diff --git a/.config/dotnet-tools.json b/.config/dotnet-tools.json
index 7b38e6d8507882..02e0543e98b8e4 100644
--- a/.config/dotnet-tools.json
+++ b/.config/dotnet-tools.json
@@ -15,7 +15,7 @@
       ]
     },
     "microsoft.dotnet.xharness.cli": {
-      "version": "1.0.0-prerelease.21281.2",
+      "version": "1.0.0-prerelease.21314.1",
       "commands": [
         "xharness"
       ]
diff --git a/Directory.Build.props b/Directory.Build.props
index c0adfc01c6439b..e2c0de947f3364 100644
--- a/Directory.Build.props
+++ b/Directory.Build.props
@@ -83,6 +83,7 @@
     <WasmBuildTasksAssemblyPath>$([MSBuild]::NormalizePath('$(WasmBuildTasksDir)', 'WasmBuildTasks.dll'))</WasmBuildTasksAssemblyPath>
     <MonoAOTCompilerTasksAssemblyPath>$([MSBuild]::NormalizePath('$(MonoAOTCompilerDir)', 'MonoAOTCompiler.dll'))</MonoAOTCompilerTasksAssemblyPath>
     <RuntimeConfigParserTasksAssemblyPath>$([MSBuild]::NormalizePath('$(RuntimeConfigParserDir)', 'RuntimeConfigParser.dll'))</RuntimeConfigParserTasksAssemblyPath>
+    <ILAsmToolPath Condition="'$(DotNetBuildFromSource)' == 'true'">$([MSBuild]::NormalizeDirectory('$(ArtifactsBinDir)', 'coreclr', '$(TargetOS).$(TargetArchitecture).$(Configuration)'))</ILAsmToolPath>
   </PropertyGroup>
 
   <PropertyGroup Label="CalculateConfiguration">
@@ -202,6 +203,17 @@
     <TargetsUnix Condition="'$(TargetsFreeBSD)' == 'true' or '$(Targetsillumos)' == 'true' or '$(TargetsSolaris)' == 'true' or '$(TargetsLinux)' == 'true' or '$(TargetsNetBSD)' == 'true' or '$(TargetsOSX)' == 'true' or '$(TargetsMacCatalyst)' == 'true' or '$(TargetstvOS)' == 'true' or '$(TargetsiOS)' == 'true' or '$(TargetsAndroid)' == 'true'">true</TargetsUnix>
   </PropertyGroup>
 
+  <PropertyGroup>
+    <MicrosoftNetCoreAppRefPackDir>$([MSBuild]::NormalizeDirectory('$(ArtifactsBinDir)', 'microsoft.netcore.app.ref'))</MicrosoftNetCoreAppRefPackDir>
+    <MicrosoftNetCoreAppRefPackRefDir>$([MSBuild]::NormalizeDirectory('$(MicrosoftNetCoreAppRefPackDir)', 'ref', '$(NetCoreAppCurrent)'))</MicrosoftNetCoreAppRefPackRefDir>
+    <MicrosoftNetCoreAppRefPackDataDir>$([MSBuild]::NormalizeDirectory('$(MicrosoftNetCoreAppRefPackDir)', 'data'))</MicrosoftNetCoreAppRefPackDataDir>
+
+    <MicrosoftNetCoreAppRuntimePackDir>$([MSBuild]::NormalizeDirectory('$(ArtifactsBinDir)', 'microsoft.netcore.app.runtime.$(PackageRID)', '$(Configuration)'))</MicrosoftNetCoreAppRuntimePackDir>
+    <MicrosoftNetCoreAppRuntimePackRidDir>$([MSBuild]::NormalizeDirectory('$(MicrosoftNetCoreAppRuntimePackDir)', 'runtimes', '$(PackageRID)'))</MicrosoftNetCoreAppRuntimePackRidDir>
+    <MicrosoftNetCoreAppRuntimePackRidLibTfmDir>$([MSBuild]::NormalizeDirectory('$(MicrosoftNetCoreAppRuntimePackRidDir)', 'lib', '$(NetCoreAppCurrent)'))</MicrosoftNetCoreAppRuntimePackRidLibTfmDir>
+    <MicrosoftNetCoreAppRuntimePackNativeDir>$([MSBuild]::NormalizeDirectory('$(MicrosoftNetCoreAppRuntimePackRidDir)', 'native'))</MicrosoftNetCoreAppRuntimePackNativeDir>
+  </PropertyGroup>
+
   <!--Feature switches -->
   <PropertyGroup>
     <EnableNgenOptimization Condition="'$(EnableNgenOptimization)' == '' and ('$(Configuration)' == 'Release' or '$(Configuration)' == 'Checked')">true</EnableNgenOptimization>
@@ -226,6 +238,9 @@
     <CoreLibSharedDir>$([MSBuild]::NormalizeDirectory('$(LibrariesProjectRoot)', 'System.Private.CoreLib', 'src'))</CoreLibSharedDir>
     <CoreLibProject Condition="'$(RuntimeFlavor)' == 'CoreCLR'">$([MSBuild]::NormalizePath('$(CoreClrProjectRoot)', 'System.Private.CoreLib', 'System.Private.CoreLib.csproj'))</CoreLibProject>
     <CoreLibProject Condition="'$(RuntimeFlavor)' == 'Mono'">$([MSBuild]::NormalizePath('$(MonoProjectRoot)', 'System.Private.CoreLib', 'System.Private.CoreLib.csproj'))</CoreLibProject>
+
+    <!-- this property is used by the SDK to pull in mono-based runtime packs -->
+    <UseMonoRuntime Condition="'$(UseMonoRuntime)' == '' and '$(RuntimeFlavor)' == 'Mono'">true</UseMonoRuntime>
   </PropertyGroup>
 
   <!-- Packaging -->
diff --git a/THIRD-PARTY-NOTICES.TXT b/THIRD-PARTY-NOTICES.TXT
index b0694275b3dbb3..14c806c5ca3e4d 100644
--- a/THIRD-PARTY-NOTICES.TXT
+++ b/THIRD-PARTY-NOTICES.TXT
@@ -680,7 +680,7 @@ worldwide. This software is distributed without any warranty.
 
 See <http://creativecommons.org/publicdomain/zero/1.0/>.
 
-License for fastmod (https://github.com/lemire/fastmod)
+License for fastmod (https://github.com/lemire/fastmod) and ibm-fpgen (https://github.com/nigeltao/parse-number-fxx-test-data)
 --------------------------------------
 
    Copyright 2018 Daniel Lemire
@@ -952,3 +952,29 @@ by constants, including codegen instructions. The unsigned division incorporates
 "round down" optimization per ridiculous_fish.
 
 This is free and unencumbered software. Any copyright is dedicated to the Public Domain.
+
+
+License notice for mimalloc
+-----------------------------------
+
+MIT License
+
+Copyright (c) 2019 Microsoft Corporation, Daan Leijen
+
+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.
diff --git a/docs/coding-guidelines/libraries-packaging.md b/docs/coding-guidelines/libraries-packaging.md
index caf447ca598a10..51c5424583e686 100644
--- a/docs/coding-guidelines/libraries-packaging.md
+++ b/docs/coding-guidelines/libraries-packaging.md
@@ -8,9 +8,9 @@ To add a library to the .NETCore shared framework, that library's `AssemblyName`
 
 The library should have both a `ref` and `src` project. Its reference assembly will be included in the ref-pack for the Microsoft.NETCore.App shared framework, and its implementation assembly will be included in the runtime pack.
 
-Including a library in the shared framework only includes the best applicable TargetFramework build of that library: `$(NetCoreAppCurrent)` if it exists, but possibly `netstandard2.1` or another if that is best. If a library has builds for other frameworks those will only be shipped if the library also produces a [Nuget package](#nuget-package). If a library ships both in the shared framework and a nuget package, it may decide to exclude its latest `$(NetCoreAppCurrent)` build from the package. This can be done by setting `ExcludeCurrentNetCoreAppFromPackage` to true. Libraries should take care when doing this to ensure that whatever asset in the package that would apply to `$(NetCoreAppCurrent)` is functionally equivalent to that which it replaces from the shared framework, to avoid breaking applications which reference a newer package than the shared framework. If possible, it's preferable to avoid this by choosing to target frameworks which can both ship in the package and shared framework.
+Including a library in the shared framework only includes the best applicable TargetFramework build of that library: `$(NetCoreAppCurrent)` if it exists, but possibly `netstandard2.1` or another if that is best. If a library has builds for other frameworks those will only be shipped if the library also produces a [Nuget package](#nuget-package).
 
-In some occasions we may want to include a library in the shared framework, but not expose it publicly. To do so, include the library in the `NetCoreAppLibraryNoReference` property in [NetCoreAppLibrary.props](../../src/libraries/NetCoreAppLibrary.props). The library should also be named in a way to discourage use at runtime, for example using the `System.Private` prefix. We should avoid hiding arbitrary public libraries as it complicates deployment and servicing, though some platform specific libraries are in this state due to historical reasons.
+In some occasions we may want to include a library in the shared framework, but not expose it publicly. The library should be named in a way to discourage use at runtime, for example using the `System.Private` prefix. We should avoid hiding arbitrary public libraries as it complicates deployment and servicing.
 
 Libraries included in the shared framework should ensure all direct and transitive assembly references are also included in the shared framework. This will be validated as part of the build and errors raised if any dependencies are unsatisfied.
 
@@ -61,13 +61,6 @@ By default all TargetFrameworks listed in your project will be included in the p
   </PropertyGroup>
 ```
 
-A common pattern is to build for the latest .NET version, for example to include a library in the shared framework or a transport package, but then excluded this from the NuGet package. This can be done to avoid growing the NuGet package in size. To do this set
-```xml
-  <PropertyGroup>
-    <ExcludeCurrentNetCoreAppFromPackage>true</ExcludeCurrentNetCoreAppFromPackage>
-  </PropertyGroup>
-```
-
 When excluding TargetFrameworks from a package special care should be taken to ensure that the builds included are equivalent to those excluded. Avoid ifdef'ing the implementation only in an excluded TargetFramework. Doing so will result in testing something different than what we ship, or shipping a nuget package that degrades the shared framework.
 
 ### Build props / targets and other content
diff --git a/docs/coding-guidelines/project-guidelines.md b/docs/coding-guidelines/project-guidelines.md
index c0a79248d01c5e..3e974772a671d9 100644
--- a/docs/coding-guidelines/project-guidelines.md
+++ b/docs/coding-guidelines/project-guidelines.md
@@ -120,9 +120,10 @@ Library projects should use the following directory layout.
 
 ```
 src\<Library Name>\src - Contains the source code for the library.
-src\<Library Name>\ref - Contains any reference assembly projects for the library
+src\<Library Name>\ref - Contains any reference assembly projects for the library.
 src\<Library Name>\pkg - Contains package projects for the library.
-src\<Library Name>\tests - Contains the test code for a library
+src\<Library Name>\tests - Contains the test code for a library.
+src\<Library Name>\gen - Contains source code for the assembly's source generator.
 ```
 
 ## ref
@@ -163,6 +164,9 @@ All test outputs should be under
 
 `bin\$(MSBuildProjectName)\$(TargetFramework)`
 
+## gen
+In the gen directory any source generator related to the assembly should exist. This does not mean the source generator is only used for that assembly only that it is conceptually apart of that assembly. For example, the assembly may provide attributes or low-level types the source generator uses.
+
 ## Facades
 Facade are unique in that they don't have any code and instead are generated by finding a contract reference assembly with the matching identity and generating type forwards for all the types to where they live in the implementation assemblies (aka facade seeds). There are also partial facades which contain some type forwards as well as some code definitions. All the various build configurations should be contained in the one csproj file per library.
 
diff --git a/docs/design/coreclr/botr/intro-to-clr.md b/docs/design/coreclr/botr/intro-to-clr.md
index d7bb57f233a930..7626ff47f22bd0 100644
--- a/docs/design/coreclr/botr/intro-to-clr.md
+++ b/docs/design/coreclr/botr/intro-to-clr.md
@@ -110,7 +110,7 @@ In addition, there is another important ramification of managed code that may no
 
 The result of this is that unmanaged interfaces are almost always _wrapped_ before being exposed to managed code developers.  For example, when accessing files, you don't use the Win32 CreateFile functions provided by the operating system, but rather the managed System.IO.File class that wraps this functionality.  It is in fact extremely rare that unmanaged functionality is exposed to users directly.
 
-While this wrapping may seem to be "bad" in some way (more code that does not seem do much), it is in fact good because it actually adds quite a bit of value.  Remember it was always _possible_ to expose the unmanaged interfaces directly; we _chose_ to wrap the functionality.  Why?  Because the overarching goal of the runtime is to **make programming easy**, and typically the unmanaged functions are not easy enough.  Most often, unmanaged interfaces are _not_ designed with ease of use in mind, but rather are tuned for completeness.  Anyone looking at the arguments to CreateFile or CreateProcess would be hard pressed to characterize them as "easy." Luckily, the functionality gets a "facelift" when it enters the managed world, and while this makeover is often very "low tech" (requiring nothing more complex than renaming, simplification, and organizing the functionality), it is also profoundly useful.  One of the very important documents created for the CLR is the [Framework Design Guidelines][fx-design-guidelines].  This 800+ page document details best practices in making new managed class libraries.
+While this wrapping may seem to be "bad" in some way (more code that does not seem to do much), it is in fact good because it actually adds quite a bit of value.  Remember it was always _possible_ to expose the unmanaged interfaces directly; we _chose_ to wrap the functionality.  Why?  Because the overarching goal of the runtime is to **make programming easy**, and typically the unmanaged functions are not easy enough.  Most often, unmanaged interfaces are _not_ designed with ease of use in mind, but rather are tuned for completeness.  Anyone looking at the arguments to CreateFile or CreateProcess would be hard pressed to characterize them as "easy." Luckily, the functionality gets a "facelift" when it enters the managed world, and while this makeover is often very "low tech" (requiring nothing more complex than renaming, simplification, and organizing the functionality), it is also profoundly useful.  One of the very important documents created for the CLR is the [Framework Design Guidelines][fx-design-guidelines].  This 800+ page document details best practices in making new managed class libraries.
 
 Thus, we have now seen that managed code (which is intimately involved with the CLR) differs from unmanaged code in two important ways:
 
@@ -204,7 +204,7 @@ As an aside, while exceptions avoid one common error (not checking for failure),
 
 Previous to version 2.0 of the CLR, the only parameterized types were arrays.  All other containers (such as hash tables, lists, queues, etc.), all operated on a generic Object type.  The inability to create List<ElemT>, or Dictionary<KeyT, ValueT> certainly had a negative performance effect because value types needed to be boxed on entry to a collection, and explicit casting was needed on element fetch.  Nevertheless, that is not the overriding reason for adding parameterized types to the CLR.  The main reason is that **parameterized types make programming easier**.
 
-The reason for this is subtle.  The easiest way to see the effect is to imagine what a class library would look like if all types were replaced with a generic Object type.  This effect is not unlike what happens in dynamically typed languages like JavaScript.  In such a world, there are simply far more ways for a programmer to make incorrect (but type-safe) programs.  Is the parameter for that method supposed to be a list? a string? an integer? any of the above? It is no longer obvious from looking at the method's signature.  Worse, when a method returns an Object, what other methods can accept it as a parameter? Typical frameworks have hundreds of methods; if they all take parameters of type Object, it becomes very difficult to determine which Object instances are valid for the operations the method will perform.  In short, strong typing helps a programmer express their intent more clearly, and allows tools (e.g., the compiler) to enforce their intent.  This results in big productivity boost.
+The reason for this is subtle.  The easiest way to see the effect is to imagine what a class library would look like if all types were replaced with a generic Object type.  This effect is not unlike what happens in dynamically typed languages like JavaScript.  In such a world, there are simply far more ways for a programmer to make incorrect (but type-safe) programs.  Is the parameter for that method supposed to be a list? a string? an integer? any of the above? It is no longer obvious from looking at the method's signature.  Worse, when a method returns an Object, what other methods can accept it as a parameter? Typical frameworks have hundreds of methods; if they all take parameters of type Object, it becomes very difficult to determine which Object instances are valid for the operations the method will perform.  In short, strong typing helps a programmer express their intent more clearly, and allows tools (e.g., the compiler) to enforce their intent.  This results in a big productivity boost.
 
 These benefits do not disappear just because the type gets put into a List or a Dictionary, so clearly parameterized types have value.  The only real question is whether parameterized types are best thought of as a language specific feature which is "compiled out" by the time CIL is generated, or whether this feature should have first class support in the runtime.  Either implementation is certainly possible.  The CLR team chose first class support because without it, parameterized types would be implemented different ways by different languages.  This would imply that interoperability would be cumbersome at best.  In addition, expressing programmer intent for parameterized types is most valuable _at the interface_ of a class library.  If the CLR did not officially support parameterized types, then class libraries could not use them, and an important usability feature would be lost.
 
diff --git a/docs/design/coreclr/botr/readytorun-format.md b/docs/design/coreclr/botr/readytorun-format.md
index f8774aa2cb9c09..63b032326403e4 100644
--- a/docs/design/coreclr/botr/readytorun-format.md
+++ b/docs/design/coreclr/botr/readytorun-format.md
@@ -6,6 +6,7 @@ Revisions:
 * 3.1 - [Tomas Rylek](https://github.com/trylek) - 2019
 * 4.1 - [Tomas Rylek](https://github.com/trylek) - 2020
 * 5.3 - [Tomas Rylek](https://github.com/trylek) - 2021
+* 5.4 - [David Wrighton](https://github.com/davidwrighton) - 2021
 
 # Introduction
 
@@ -251,6 +252,10 @@ fixup kind, the rest of the signature varies based on the fixup kind.
 | READYTORUN_FIXUP_IndirectPInvokeTarget   |  0x2E | Target (indirect) of an inlined PInvoke. Followed by method signature.
 | READYTORUN_FIXUP_PInvokeTarget           |  0x2F | Target of an inlined PInvoke. Followed by method signature.
 | READYTORUN_FIXUP_Check_InstructionSetSupport | 0x30 | Specify the instruction sets that must be supported/unsupported to use the R2R code associated with the fixup.
+| READYTORUN_FIXUP_Verify_FieldOffset      | 0x31 | Generate a runtime check to ensure that the field offset matches between compile and runtime. Unlike CheckFieldOffset, this will generate a runtime exception on failure instead of silently dropping the method
+| READYTORUN_FIXUP_Verify_TypeLayout       | 0x32 | Generate a runtime check to ensure that the field offset matches between compile and runtime. Unlike CheckFieldOffset, this will generate a runtime exception on failure instead of silently dropping the method
+| READYTORUN_FIXUP_Check_VirtualFunctionOverride | 0x33 | Generate a runtime check to ensure that virtual function resolution has equivalent behavior at runtime as at compile time. If not equivalent, code will not be used. See [Virtual override signatures](virtual-override-signatures) for details of the signature used.
+| READYTORUN_FIXUP_Verify_VirtualFunctionOverride | 0x33 | Generate a runtime check to ensure that virtual function resolution has equivalent behavior at runtime as at compile time. If not equivalent, generate runtime failure. See [Virtual override signatures](virtual-override-signatures) for details of the signature used.
 | READYTORUN_FIXUP_ModuleOverride          |  0x80 | When or-ed to the fixup ID, the fixup byte in the signature is followed by an encoded uint with assemblyref index, either within the MSIL metadata of the master context module for the signature or within the manifest metadata R2R header table (used in cases inlining brings in references to assemblies not seen in the input MSIL).
 
 #### Method Signatures
@@ -268,6 +273,7 @@ token, and additional data determined by the flags.
 | READYTORUN_METHOD_SIG_MemberRefToken      |  0x10 | If set, the token is memberref token. If not set, the token is methoddef token.
 | READYTORUN_METHOD_SIG_Constrained         |  0x20 | Constrained type for method resolution. Typespec appended as additional data.
 | READYTORUN_METHOD_SIG_OwnerType           |  0x40 | Method type. Typespec appended as additional data.
+| READYTORUN_METHOD_SIG_UpdateContext       |  0x80 | If set, update the module which is used to parse tokens before performing any token processing. A uint index into the modules table immediately follows the flags
 
 #### Field Signatures
 
@@ -281,6 +287,16 @@ additional data determined by the flags.
 | READYTORUN_FIELD_SIG_MemberRefToken      |  0x10 | If set, the token is memberref token. If not set, the token is fielddef token.
 | READYTORUN_FIELD_SIG_OwnerType           |  0x40 | Field type. Typespec appended as additional data.
 
+#### Virtual override signatures
+
+ECMA 335 does not have a natural encoding for describing an overriden method. These signatures are encoded as a ReadyToRunVirtualFunctionOverrideFlags byte, followed by a method signature representing the declaration method, a type signature representing the type which is being devirtualized, and (optionally) a method signature indicating the implementation method.
+
+| ReadyToRunVirtualFunctionOverrideFlags                | Value | Description
+|:------------------------------------------------------|------:|:-----------
+| READYTORUN_VIRTUAL_OVERRIDE_None                      |  0x00 | No flags are set
+| READYTORUN_VIRTUAL_OVERRIDE_VirtualFunctionOverriden  |  0x01 | If set, then the virtual function has an implementation, which is encoded in the optional method implementation signature.
+
+
 ### READYTORUN_IMPORT_SECTIONS::AuxiliaryData
 
 For slots resolved lazily via `READYTORUN_HELPER_DelayLoad_MethodCall` helper, auxiliary data are
diff --git a/docs/design/coreclr/botr/type-loader.md b/docs/design/coreclr/botr/type-loader.md
index b873d8541a012f..7c8b34627665be 100644
--- a/docs/design/coreclr/botr/type-loader.md
+++ b/docs/design/coreclr/botr/type-loader.md
@@ -76,21 +76,25 @@ There is a relatively small number of entry-points to the loader. Although the s
 
 There are usually many calls to the type loader during JITting. Consider:
 
-	object CreateClass()
-	{
-	    return new MyClass();
-	}
+```csharp
+object CreateClass()
+{
+    return new MyClass();
+}
+```
 
 In the IL, MyClass is referred to using a metadata token. In order to generate a call to the `JIT_New` helper which takes care of the actual instantiation, the JIT will ask the type loader to load the type and return a handle to it. This handle will be then directly embedded in the JITted code as an immediate value. The fact that types and members are usually resolved and loaded at JIT time and not at run-time also explains the sometimes confusing behavior easily hit with code like this:
 
-	object CreateClass()
-	{
-	    try {
-	        return new MyClass();
-	    } catch (TypeLoadException) {
-	        return null;
-	    }
-	}
+```csharp
+object CreateClass()
+{
+    try {
+        return new MyClass();
+    } catch (TypeLoadException) {
+        return null;
+    }
+}
+```
 
 If `MyClass` fails to load, for example because it's supposed to be defined in another assembly and it was accidentally removed in the newest build, then this code will still throw `TypeLoadException`. The reason that the catch block did not catch it is that it never ran! The exception occurred during JITting and would only be catchable in the method that called `CreateClass` and caused it to be JITted. In addition, it may not be always obvious at which point the JITting is triggered due to inlining, so users should not expect and rely on deterministic behavior.
 
@@ -153,14 +157,16 @@ both the same type.
 
 When the type loader is asked to load a specified type, identified for example by a typedef/typeref/typespec **token** and a **Module** , it does not do all the work atomically at once. The loading is done in phases instead. The reason for this is that the type usually depends on other types and requiring it to be fully loaded before it can be referred to by other types would result in infinite recursion and deadlocks. Consider:
 
-	class A<T> : C<B<T>>
-	{ }
+```csharp
+class A<T> : C<B<T>>
+{ }
 
-	class B<T> : C<A<T>>
-	{ }
+class B<T> : C<A<T>>
+{ }
 
-	class C<T>
-	{ }
+class C<T>
+{ }
+```
 
 These are valid types and apparently `A` depends on `B` and `B` depends on `A`.
 
@@ -195,10 +201,12 @@ A placeholder to be substituted by another type; the `T` in the declaration of `
 
 A type being substituted for a generic parameter; the `int` in `List<int>`. Note that a generic parameter can also be used as an argument. Consider:
 
-	List<T> GetList<T>()
-	{
-	    return new List<T>();
-	}
+```csharp
+List<T> GetList<T>()
+{
+    return new List<T>();
+}
+```
 
 The method has one generic parameter `T` which is used as a generic argument for the generic list class.
 
@@ -209,28 +217,38 @@ An optional requirement placed by generic parameters on its potential generic ar
 1. Special constraints
   - Reference type constraint - the generic argument must be a reference type (as opposed to a value type). The `class` keyword is used in C# to express this constraint.
 
-			public class A<T> where T : class
+    ```csharp
+    public class A<T> where T : class
+    ```
 
   - Value type constraint - the generic argument must be a value type different from `System.Nullable<T>`. C# uses the `struct` keyword.
 
-			public class A<T> where T : struct
+    ```csharp
+    public class A<T> where T : struct
+    ```
 
   - Default constructor constraint - the generic argument must have a public parameterless constructor. This is expressed by `new()` in C#.
 
-			public class A<T> where T : new()
+    ```csharp
+    public class A<T> where T : new()
+    ```
 
 2. Base type constraints - the generic argument must be derived from
 (or directly be of) the given non-interface type. It obviously makes
 sense to use only zero or one reference type as a base types
 constraint.
 
-		public class A<T> where T : EventArgs
+    ```csharp
+    public class A<T> where T : EventArgs
+    ```
 
 3. Implemented interface constraints - the generic argument must
 implement (or directly be of) the given interface type.  Zero or more
 interfaces can be given.
 
-		public class A<T> where T : ICloneable, IComparable<T>
+    ```csharp
+    public class A<T> where T : ICloneable, IComparable<T>
+    ```
 
 The above constraints are combined with an implicit AND, i.e. a
 generic parameter can be constrained to be derived from a given type,
@@ -239,11 +257,13 @@ generic parameters of the declaring type can be used to express the
 constraints, introducing interdependencies among the parameters. For
 example:
 
-	public class A<S, T, U>
-		where S : T
-		where T : IList<U> {
-	    void f<V>(V v) where V : S {}
-	}
+```csharp
+public class A<S, T, U>
+	where S : T
+	where T : IList<U> {
+    void f<V>(V v) where V : S {}
+}
+```
 
 **Instantiation**
 
@@ -259,7 +279,9 @@ declared. There exists exactly one typical instantiation for each
 generic type and method. Usually when one talks about an open generic
 type, they have the typical instantiation in mind. Example:
 
-	public class A<S, T, U> {}
+```csharp
+public class A<S, T, U> {}
+```
 
 The C# `typeof(A<,,>)` compiles to ldtoken A\'3 which makes the
 runtime load ``A`3`` instantiated at `S` , `T` , `U`.
diff --git a/docs/design/features/cross-dac.md b/docs/design/features/cross-dac.md
new file mode 100644
index 00000000000000..30becca5be6267
--- /dev/null
+++ b/docs/design/features/cross-dac.md
@@ -0,0 +1,97 @@
+# Cross DAC Notes
+
+The `crossdac` is a cross-compiled DAC. It is compiled to execute on one platform, but debug a target of a different architecture.
+
+Our current crossdacs are all:
+
+- compiled to run on Windows
+- Same bitness. (Target and host have the same number of bits.
+- target a *nix variant
+
+The crossdac allow us to use Windows debugging tools to debug dumps from *nix processes.
+
+## Design
+
+### Limitations
+
+- To avoid solving remoting and synchronization issues, the crossdac will not support live processes. Only dump debugging is supported.
+- Similar to the DAC, each cross DAC must match its runtime. The DACs are indexed on a symbol server to allow the debuggers to get these as needed.
+
+### Conditional Code Selection
+
+This is a simple cross compilation of the DAC, `C++` code. This mean the `HOST_*` and the `TARGET_*` are configured differently. In this context:
+
+- `HOST` refers to the architecture of the platform that is running the debugger.
+- `TARGET` refers to the platform that generated the code dump.
+
+In general, most code should be conditioned on `TARGET_*` variables. This is because in general we want the `DAC` to behave identically when cross compiled.
+
+Code must be conditioned on `HOST` when it refers to host needed services. These have typically been thing like file i/o and memory allocation.
+
+Initial implementation allowed the compiler to find most of these. The strategy was to assume all code should be conditioned on `TARGET` and let the compiler gripe.
+
+### Type Layout
+
+The DAC is essentially a memory parsing tool with supporting functionality. The layout of types in the DAC must match the layout of types in the runtime.
+
+The `C++` standard is not explicit about all layout rules of data structures. Due to its historical evolution from `C`, most structures are arranged in an intuitive easily understood fashion. Newer and more exotic structures are less consistent.
+
+Experimentation has shown that layout varies in inheritance cases. The DAC does not support general multiple inheritance, so that simplifies things. It does support multiple inheritance with the empty base classes.
+
+These cases have proven to be problematic:
+
+- Classes with empty base classes. (I the only issue is with multiple base classes.)
+  - By default `gcc` use an empty base class optimization to eliminate the 1 byte of space these empty base classes normally consume (alone).
+  - By default `Windows` compilers do not do this optimization. This is to preserve backward binary compatibility.
+  - The Windows compilers allow this optimization to be enabled. Our code uses `EMPTY_BASES_DECL` to enable this optimization. It has to be applied to every structure that has multiple base classes or derives from a such a structure. See `__declspec(empty_bases)`.
+- Packing of the first member of the derived class. In the case where the base class ended with padding:
+  - `gcc` compilers reuse the padding for the first member of the derived class. This effectively removes the padding of the base class in the derived class.
+  - Windows compilers do not remove this padding.
+  - Our code uses the `DAC_ALIGNAS(a)` macro before the first element of the derived class to force the `gcc` compiler to align that member and keep the base classes padding.
+    - The `a` parameter is preferentially the base classes typename.
+    - However, in some cases the compiler will not allow this due to some circular layout issues it causes. In these cases, `a` can refer to a well known type instead. I prefer `int64_t`, `int32_t`, `size_t` ...
+
+#### DacCompareNativeTypes Usage
+
+I wrote and used [DacCompareNativeTypes](https://github.com/dotnet/diagnostics/tree/main/src/tests/DacCompareNativeTypes), to locate and identify type layout issues.
+
+The tool is a bit crude, but it helped get the job done.
+
+The `libcoreclr.so` has a lot of symbols. This proved very slow. So to expedite things, I compared the `dac` and later the `dbi` libraries for structure layout. This had the advantage of eliminating irrelevant data structures.
+
+The compilers generate different debug data and different hidden data structures. The tool tries to overlook these. Be aware that not all differences are real. Some data structures are host only so these are expected to be different.
+
+I usually ran the tool in a debugger so that I could look at other available meta-data the tool keeps. i.e. source file and line number.
+
+### Missing/Different types
+
+There are some cases where types are defined by the Target. These types maybe missing or different on the Host. In these cases we define the cross compilation types in `src/coreclr/inc/crosscomp.h`.
+
+See `T_CRITICAL_SECTION` for a key example. In this case both host and target supported critical sections, but we needed to correctly map the target data structures. So we needed a type defined which was the TARGET's `CRITICAL_SECTION`.
+
+So the Target's definition was made available for the cross compile. Additionally the macro was created to make sure references which required the Target's definition could be separated from ones which might need the host's definition.
+
+There is also some defensive programming to make sure these structures accurate. See `T_CRITICAL_SECTION_VALIDATION_MESSAGE` for one example.
+
+### Out of Process Unwinding
+
+To fully support native stack processing, we needed a Target unwinder. For this `libunwind` was also cross-compiled.
+
+See [CMake cross libunwind](https://github.com/dotnet/runtime/blob/0049c629381c5a18e4dadd1038c2bd6b3ae6e3e6/src/coreclr/CMakeLists.txt#L113)
+
+### DBI
+
+I use the term `DAC` in this document to refer to both the `DAC` and the `DBI` debug interface. Both were actually cross compiled. Be aware.
+
+### Build entry point
+
+The main build systme change is adding the ability to set the Target OS on a Windows build.
+
+- See [build-runtime.cmd changes](https://github.com/dotnet/runtime/blob/0049c629381c5a18e4dadd1038c2bd6b3ae6e3e6/src/coreclr/build-runtime.cmd#L133-L134)
+- See [Subsets.props](https://github.com/dotnet/runtime/blob/0049c629381c5a18e4dadd1038c2bd6b3ae6e3e6/eng/Subsets.props#L191-L197)
+
+There are also changes to the official build to set these flags package the results and upload to the symbol server.
+
+### Client changes
+
+Various changes were required in the DAC clients to consume the new crossdac. These are really out of the scope of this document.
\ No newline at end of file
diff --git a/docs/design/mono/diagnostics-tracing.md b/docs/design/mono/diagnostics-tracing.md
new file mode 100644
index 00000000000000..ccf46f940d5f4d
--- /dev/null
+++ b/docs/design/mono/diagnostics-tracing.md
@@ -0,0 +1,255 @@
+# MonoVM Diagnostics Tracing Component
+
+## Summary
+
+MonoVM includes support for EventPipe and DiagnosticServer components used to generate nettrace files including both runtime as well as custom `EventSource` events. It is possible to either use dynamic components (Android) or link statically (iOS) depending on build configuration. EventPipe will mainly be used during development/testing cycle, and should not be deployed or linked into builds passed to app store for verification and publication.
+
+## Scenarios
+
+.Net supports a number of different EventPipe scenarios using tools mainly from diagnostics repository. MonoVM include support for several of these scenarios, running tools like `dotnet-counters` and `dotnet-trace` to collect and analyze runtime performance data. Other things like requesting a core/gc dump or attaching profiler over EventPipe is currently not supported on MonoVM.
+
+Due to differences between runtimes many of the NativeRuntimeEvents won't apply to MonoVM. Only a small selected amount of NativeRuntimeEvents will initially be added to MonoVM. Current supported NativeRuntimeEvents can be viewed in MonoVM include file, https://github.com/dotnet/runtime/blob/main/src/mono/mono/eventpipe/gen-eventing-event-inc.lst. Since primarly focus is EventPipe and mobile platforms (iOS/Android), ETW and LTTng providers have currently not been integrated/enabled for NativeRuntimeEvents on MonoVM.
+
+MonoVM runs on a variaty of platforms, and depending on platform capabilities MonoVM support different build configurations of EventPipe and DiagnosticServer. For desktop platforms (Windows, Linux, MacOS), MonoVM build DiagnosticServer using
+`NamedPipes` (Windows) or `UnixDomainSockets` (Linux, MacOS) support. This is inline with CoreCLR build configuration of the DiagnosticServer, working in the same way.
+
+On mobile platforms (Android/iOS) or other remote sandboxed environments, MonoVM DiagnosticServer component can be build using TCP/IP support to better handle remote targets. It is also handles the connect senario (runtime act as TCP/IP client connecting back to tooling), as well as the listening scenario (runtime act as a TCP/IP listener waiting for tooling to connect). Depending on platform, allowed capabilities (some platforms won't allow listening on sockets) and tracing scenarios (startup tracing needs suspended runtime), a combination of these scenarios can be used.
+
+Existing diagnostic tooling only supports `NamedPipes`/`UnixDomainSockets`, so in order to reuse these tools transparently when targeting MonoVM running on mobile platforms, a new component have been implmenet in diagnostics repro, `dotnet-dsrouter`, https://github.com/dotnet/diagnostics/tree/main/src/Tools/dotnet-dsrouter. dsrouter represents the application running on a remote target locally to the diagnostic tools, routing local IPC traffic over to TCP/IP handled by MonoVM running on remote target. dsrouter implements 3 different modes, server-server (IPC server, TCP server), client-server (IPC client, TCP server) and server-client (IPC server, TCP client ) and depending on configuration all three modes can be used. dsrouter also improves the reversed connect runtime scenario to support more than one diagnostic tooling client at a time, as well as converting the reversed connect runtime scenario (used when tracing startup) into a normal direct connect scenario using dsrouter in server-server mode.
+
+For more details around diagnostic scenarios, see:
+
+https://docs.microsoft.com/en-us/dotnet/core/diagnostics/dotnet-counters
+
+https://docs.microsoft.com/en-us/dotnet/core/diagnostics/dotnet-trace
+
+https://docs.microsoft.com/en-us/dotnet/core/diagnostics/event-counter-perf
+
+https://docs.microsoft.com/en-us/dotnet/core/diagnostics/debug-highcpu
+
+## Building an application including diagnostic tracing support
+
+Depending on platform, there are different recommended and supported ways to include diagnostic tracing support when building the application.
+
+### Android
+
+Android is build using dynamic component support, meaning that components are included as shared objects and runtime will try to load them from the same location as `libmonosgen-2.0.so`. If runtime fails to load component, it will be disabled, if it successfully load the component at runtime, it will be enabled and used. Enabling/disabling components is then a matter of incuding/excluding the needed shared object files in the APK (in same folder as `libmonosgen-2.0.so`), same runtime build can be used to support any combination of components.
+
+If `AndroidAppBuilderTask` is used, there is a msbuild property, `RuntimeComponents` that can be used to include specific components in the generated application. By default its empty, meaning all components will be disabled, using a `*` will enabled all components and by specify individual components, only those will be enabled. Enabling tracing would look like this, `RuntimeComponents="diagnostics_tracing"`, more components can be enabled by separting them with `;`.
+
+Android runtime pack have the following component libraries included. For default scenarios, the dynamic versions should be used togtether with `libmonosgen-2.0.so`, but runtime pack also includes static versions of the components that can be used if runtime is build statically using `libmonosgen-2.0.a`. In case of static linking, using `libmono-component-*-stub-static.a` library will disable the component, using `libmono-component-*-static.a` will enable it.
+
+```
+libmono-component-diagnostics_tracing.so
+libmono-component-diagnostics_tracing-static.a
+libmono-component-diagnostics_tracing-stub-static.a
+```
+
+### iOS
+
+iOS is build using static component support, meaning that components are included as static libraries that needs to be linked together with `libmonosgen-2.0.a` to produce final application. Static components comes in two flavours, the component library and a stub library. Linking the component library will enable the component in final application, while linking the stub library disables the component. Depeding on linked component flavours it is possible to create a build that enables specific components while disabling others. All components needs to be linked in (using component or stub library) or there will be unresolved symbols in `libmonosgen-2.0.a`.
+
+If `AppleAppBuilderTask` is used, there is a msbuild property, `RuntimeComponents` that can be used to include specific components in the build application. By default its empty, meaning all components will be disabled, using a `*` will enabled all components and by specify individual components, only those will be enabled. Enabling tracing would look like this, `RuntimeComponents="diagnostics_tracing"`, more components can be enabled by separting them with `;`.
+
+iOS runtime pack have the following component libraries included. Using `libmono-component-*-stub-static.a` library will disable the component, using `libmono-component-*-static.a` will enable it.
+
+```
+libmono-component-diagnostics_tracing-static.a
+libmono-component-diagnostics_tracing-stub-static.a
+```
+
+## Run an application including diagnostic tracing support
+
+By default EventPipe/DiagnosticServer is controlled using the same set of environment variables used by CoreCLR. The single most important one is `DOTNET_DiagnosticPorts` used in order to setup runtime to connect or accept requests from diagnostic tooling. If not defined, diagnostic server won't startup and it will not be possible to interact with runtime using diagnostic tooling. Depending on platform, capabilities and scenarios, the content of `DOTNET_DiagnosticPorts` will look differently.
+
+### Application running in simulator/emulator connecting over loopback interface
+
+Starting up application using `DOTNET_DiagnosticPorts=127.0.0.1:9000,nosuspend` on iOS, or `DOTNET_DiagnosticPorts=10.0.2.2:9000,nosuspend` on Android, will connect to dsrouter listening on loopback port 9000 (can be any available port) on local machine. Once runtime is connected, it is possible to connect diagnostic tools like dotnet-counters, dotnet-trace, towards dsrouter local IPC interface. In order to include startup events in EventPipe sessions, change `nosuspend` to `suspend` and runtime startup and wait for diagnostic tooling to connect before resuming.
+
+If supported it is possible to push the TCP/IP listener over to the device and only run a TCP/IP client on the local machine connecting to the runtime listener. Using `DOTNET_DiagnosticPorts=127.0.0.1:9000,nosuspend,listen` will run a local listener binding to loopback interface on simulator/emulator. On Android, it is possible to setup adb port forwading while on iOS runtime can bind local machine loopback interface directly from simulator. dsrouter will be configured to use a TCP/IP client when running this scenario.
+
+For more information on Android emulator networking and port forwarding:
+
+https://developer.android.com/studio/run/emulator-networking
+https://developer.android.com/studio/command-line/adb#forwardports
+
+#### Example using dotnet-counters using sample app on iOS simulator
+
+Make sure following is enabled in https://github.com/dotnet/runtime/blob/main/src/mono/sample/iOS/Makefile,
+
+RUNTIME_COMPONENTS=diagnostics_tracing
+DIAGNOSTIC_PORTS=127.0.0.1:9000,nosuspend
+
+dsrouter needs to run using a compatible configration depending on scenario. Either launch a new instance for every run, or have a background instance running over several sessions using same configuration.
+
+```
+dotnet-dsrouter server-server -tcps 127.0.0.1:9000 &
+```
+
+```
+cd src/mono/sample/iOS/
+make run-sim
+```
+
+```
+dotnet-counters monitor --process-id [dotnet-dsrouter pid]
+```
+
+Alternative running ```make run-sim``` as a child process of dsrouter:
+
+```
+cd src/mono/sample/iOS/
+dotnet-dsrouter server-server -tcps 127.0.0.1:9000 -- make run-sim
+```
+
+```
+dotnet-counters monitor --process-id [dotnet-dsrouter pid]
+```
+
+#### Example using dotnet-counters using sample app on Android emulator
+
+Make sure following is enabled in https://github.com/dotnet/runtime/blob/main/src/mono/sample/Android/Makefile,
+
+RUNTIME_COMPONENTS=diagnostics_tracing
+DIAGNOSTIC_PORTS=10.0.2.2:9000,nosuspend
+
+dsrouter needs to run using a compatible configration depending on scenario. Either launch a new instance for every run, or have a background instance running over several sessions using same configuration.
+
+```
+dotnet-dsrouter server-server -tcps 10.0.2.2:9000 &
+```
+
+```
+cd src/mono/sample/Android/
+make run
+```
+
+```
+dotnet-counters monitor --process-id [dotnet-dsrouter pid]
+```
+
+Alternative running ```make run``` as a child process of dsrouter:
+
+```
+cd src/mono/sample/Android/
+dotnet-dsrouter server-server -tcps 10.0.2.2:9000 -- make run
+```
+
+```
+dotnet-counters monitor --process-id [dotnet-dsrouter pid]
+```
+
+#### Example using dotnet-trace startup tracing using sample app on iOS simulator
+
+Make sure following is enabled in https://github.com/dotnet/runtime/blob/main/src/mono/sample/iOS/Makefile,
+
+RUNTIME_COMPONENTS=diagnostics_tracing
+DIAGNOSTIC_PORTS=127.0.0.1:9000,suspend
+
+dsrouter needs to run using a compatible configration depending on scenario. Either launch a new instance for every run, or have a background instance running over several sessions using same configuration.
+
+```
+dotnet-dsrouter client-server -tcpc [dotnet-trace path]-tcps 127.0.0.1:9000 &
+```
+
+```
+dotnet-trace collect --diagnostic-port myport
+```
+
+```
+cd src/mono/sample/iOS/
+make run-sim
+```
+
+Alternative running ```make run-sim``` as a child process of dsrouter:
+
+```
+dotnet-trace collect --diagnostic-port myport
+```
+
+```
+cd src/mono/sample/iOS/
+dotnet-dsrouter client-server -tcpc [dotnet-trace path]-tcps 127.0.0.1:9000 & -- make run-sim
+```
+
+#### Example using dotnet-trace startup tracing using sample app on Android simulator
+
+Make sure following is enabled in https://github.com/dotnet/runtime/blob/main/src/mono/sample/Android/Makefile,
+
+RUNTIME_COMPONENTS=diagnostics_tracing
+DIAGNOSTIC_PORTS=10.0.2.2:9000,suspend
+
+dsrouter needs to run using a compatible configration depending on scenario. Either launch a new instance for every run, or have a background instance running over several sessions using same configuration.
+
+```
+dotnet-dsrouter client-server -tcpc [dotnet-trace path]-tcps 127.0.0.1:9000 &
+```
+
+```
+dotnet-trace collect --diagnostic-port myport
+```
+
+```
+cd src/mono/sample/Android/
+make run
+```
+
+Alternative running ```make run``` as a child process of dsrouter:
+
+```
+dotnet-trace collect --diagnostic-port myport
+```
+
+```
+cd src/mono/sample/Android/
+dotnet-dsrouter client-server -tcpc [dotnet-trace path]-tcps 127.0.0.1:9000 & -- make run
+```
+
+### Application running on device
+
+The same envrionment variable is used when running on device, and if device is connected to development machine using usb, it is still possible to use loopback interface as described above, but it requires use of adb port forwarding on Android and an implementation of usbmux on iOS, such as mlaunch using `--tcp-tunnel` argument.
+
+If loopback interface won't work, it is possible to use any interface reachable between development machine and device in `DOTNET_DiagnosticPorts` variable, just keep in mind that the the connection is unauthenticated and unencrypted.
+
+** TODO **: Describe changes to above examples when running on device.
+
+### Application running single file based EventPipe session
+
+If application shutdown runtime on close, it is possible to run a single file based EventPipe session using environment variables as described in https://docs.microsoft.com/en-us/dotnet/core/diagnostics/eventpipe#trace-using-environment-variables. In .net6 an additional variable has been added, `COMPlus_EventPipeOutputStreaming`, making sure data is periodically flushed into the output file.
+
+If application doesn't shutdown runtime on close, this mode won't work, since it requires rundown events, only emitted when closing session and flushing memory manager. If runtime doesn't shutdown, generated nettrace file will be corrupt.
+
+Running using single file based EventPipe session will produce a file in device working directory. Use platform sepecific tooling in order to extract file once application has closed. Since file based EventPipe session doesn't use diagnostic server, there is no need to use `DOTNET_DiagnosticPorts` or running dotnet-dsrouter.
+
+** TODO **: Add example running single file based EventPipe session.
+
+### Examples running dotnet-* tooling against MonoVM
+
+https://github.com/dotnet/diagnostics/blob/main/documentation/dotnet-counters-instructions.md
+https://github.com/dotnet/diagnostics/blob/main/documentation/dotnet-trace-instructions.md
+
+** TODO **: Example of commands run to launch a dotnet-trace session collecting SampleProfiler.
+** TODO **: Example of commands run to launch a dotnet-trace session tracing startup events.
+** TODO **: Example of commands run to launch a dotnet-trace session tracing JIT statistics.
+
+## Analyze a nettrace file
+
+Collected events retrieved over EventPipe sessions is stored in a nettrace file that can be analyzed using tooling like perfview, Speedscope or Chromium:
+
+https://docs.microsoft.com/en-us/dotnet/core/diagnostics/debug-highcpu?tabs=windows#trace-generation
+https://docs.microsoft.com/en-us/dotnet/core/diagnostics/dotnet-trace#dotnet-trace-convert
+https://github.com/dotnet/diagnostics/blob/main/documentation/tutorial/app_running_slow_highcpu.md
+
+It is also possible to analyze the trace file using diagnostic client librarys from diagnostic repro:
+
+https://github.com/dotnet/diagnostics/blob/main/documentation/diagnostics-client-library-instructions.md
+
+Using the diagnostic client library gives full flexibilty to use data in nettrace to extract any information contained in file. Using the library it is also possible to implement custom tooling, that will connect and do live analyzing of event stream retrieved directly from running application.
+
+** TODO **: Add example running with the sartup events and retrieve time to method X (replaceing MonoVM --stat=method).
+
+## Developing EventPipe/DiagnosticServer on MonoVM
+
+** TODO **: EventPipe/DiagnosticServer library design.
+** TODO **: How to add a new NativeRuntimeEvent.
+** TODO **: How to add a new component API.
\ No newline at end of file
diff --git a/docs/project/list-of-diagnostics.md b/docs/project/list-of-diagnostics.md
index 46092b5528018f..fc946ddb03b081 100644
--- a/docs/project/list-of-diagnostics.md
+++ b/docs/project/list-of-diagnostics.md
@@ -80,6 +80,7 @@ The PR that reveals the implementation of the `<IncludeInternalObsoleteAttribute
 |  __`SYSLIB0023`__ | RNGCryptoServiceProvider is obsolete. To generate a random number, use one of the RandomNumberGenerator static methods instead. |
 |  __`SYSLIB0024`__ | Creating and unloading AppDomains is not supported and throws an exception. |
 |  __`SYSLIB0025`__ | SuppressIldasmAttribute has no effect in .NET 6.0+. |
+|  __`SYSLIB0026`__ | X509Certificate and X509Certificate2 are immutable. Use the appropriate constructor to create a new certificate. |
 
 ## Analyzer Warnings
 
diff --git a/docs/workflow/requirements/windows-requirements.md b/docs/workflow/requirements/windows-requirements.md
index 56f662f6f21991..2629df320d2887 100644
--- a/docs/workflow/requirements/windows-requirements.md
+++ b/docs/workflow/requirements/windows-requirements.md
@@ -34,7 +34,7 @@ Visual Studio 2019 installation process:
 
 A `.vsconfig` file is included in the root of the dotnet/runtime repository that includes all components needed to build the dotnet/runtime repository. You can [import `.vsconfig` in your Visual Studio installer](https://docs.microsoft.com/en-us/visualstudio/install/import-export-installation-configurations?view=vs-2019#import-a-configuration) to install all necessary components.
 
-The dotnet/runtime repository requires at least Visual Studio 2019 16.6.
+Visual Studio 2019 16.6 or later is required for building the repository. Visual Studio 2019 16.10 is required to work with the libraries projects inside the Visual Studio IDE.
 
 ## CMake
 
diff --git a/docs/workflow/testing/libraries/testing-wasm.md b/docs/workflow/testing/libraries/testing-wasm.md
index a8d7eb1a7934d5..da752eb2d5974e 100644
--- a/docs/workflow/testing/libraries/testing-wasm.md
+++ b/docs/workflow/testing/libraries/testing-wasm.md
@@ -100,11 +100,11 @@ The following shows how to run tests for a specific library
 
 - `$(WasmXHarnessArgs)` - xharness command arguments
 
-    Example: `WasmXHarnessArgs="--xyz"` -> becomes `dotnet xharness wasm test --xyz`
+    Example: `WasmXHarnessArgs="--set-web-server-http-env=DOTNET_TEST_WEBSOCKETHOST"` -> becomes `dotnet xharness wasm test --set-web-server-http-env=DOTNET_TEST_WEBSOCKETHOST`
 
-- `$(WasmXHarnessMonoArgs)` - arguments to mono
+- `$(WasmXHarnessMonoArgs)` - arguments and variables for mono
 
-    Example: `WasmXHarnessMonoArgs="--runtime-arg=--trace=E"`
+    Example: `WasmXHarnessMonoArgs="--runtime-arg=--trace=E --setenv=MONO_LOG_LEVEL=debug"`
 
 - `$(WasmTestAppArgs)` - arguments for the test app itself
 
diff --git a/docs/workflow/testing/libraries/testing.md b/docs/workflow/testing/libraries/testing.md
index fe4d76255a7913..a78a3d0409868d 100644
--- a/docs/workflow/testing/libraries/testing.md
+++ b/docs/workflow/testing/libraries/testing.md
@@ -1,54 +1,71 @@
 # Testing Libraries
 
-We use the OSS testing framework [xunit](https://github.com/xunit/xunit).
+## Full Build and Test Run
 
-To build the tests and run them you can call the libraries build script. For libraries tests to work, you must have built the coreclr or mono runtime for them to run on.
+These example commands automate the test run and all pre-requisite build steps in a single command from a clean enlistment.
 
-**Examples**
-- The following shows how to build only the tests but not run them:
+- Run all tests - Builds clr in release, libs+tests in debug:
 ```
-build.cmd/sh -subset libs.tests
+build.cmd/sh -subset clr+libs+libs.tests -test -rc Release
 ```
 
-- The following builds and runs all tests using clr:
+- Run all tests - Builds Mono in release, libs+tests in debug:
 ```
-build.cmd/sh -subset clr+libs.tests -test
+build.cmd/sh -subset mono+libs+libs.tests -test -rc Release
 ```
 
-- The following builds and runs all tests using mono:
+- Run all tests - Build Mono and libs for x86 architecture in debug (choosing debug for runtime will run very slowly):
 ```
-build.cmd/sh -subset mono+libs.tests -test
+build.cmd/sh -subset mono+libs+libs.tests -test -arch x86
 ```
 
-- The following builds and runs all tests in release configuration:
+## Partial Build and Test Runs
+
+Doing full build and test runs takes a long time and is very inefficient if you need to iterate on a change.
+For greater control and efficiency individual parts of the build + testing workflow can be run in isolation.
+See the [Building instructions](../../building/libraries/README.md) for more info on build options.
+
+### Test Run Pre-requisites
+Before any tests can run we need a complete build to run them on. This requires building (1) a runtime, and
+(2) all the libraries. Examples:
+
+- Build release clr + debug libraries
 ```
-build.cmd/sh -subset libs.tests -test -c Release
+build.cmd/sh -subset clr+libs -rc Release
 ```
 
-- The following builds clr in release, libs in debug and runs all tests:
+- Build release mono + debug libraries
 ```
-build.cmd/sh -subset clr+libs+libs.tests -test -rc Release
+build.cmd/sh -subset mono+libs -rc Release
 ```
 
-- The following builds mono and libs for x86 architecture and runs all tests:
+Building the `libs` subset or any of individual library projects automatically copies product binaries into the testhost folder
+in the bin directory. This is where the tests will load the binaries from during the run. However System.Private.CorLib is an
+exception - the build does not automatically copy it to the testhost folder. If you [rebuild System.Private.CoreLib](https://github.com/dotnet/runtime/blob/main/docs/workflow/building/libraries/README.md#iterating-on-systemprivatecorelib-changes) you must also build the `libs.pretest` subset to ensure S.P.C is copied before running tests.
+
+### Running tests for all libraries
+
+- Build and run all tests in release configuration.
 ```
-build.cmd/sh -subset mono+libs+libs.tests -test -arch x86
+build.cmd/sh -subset libs.tests -test -c Release
 ```
 
-- The following example shows how to pass extra msbuild properties to ignore tests ignored in CI:
+- Build the tests without running them
 ```
-build.cmd/sh -subset libs.tests -test /p:WithoutCategories=IgnoreForCI
+build.cmd/sh -subset libs.tests
 ```
 
-Unless you specifiy `-testnobuild`, test assemblies are implicitly built when invoking the `Test` action.
-- The following shows how to only test the libraries without building them
+- Run the tests without building them
 ```
 build.cmd/sh -subset libs.tests -test -testnobuild
 ```
 
-## Running tests on the command line
+- The following example shows how to pass extra msbuild properties to ignore tests ignored in CI.
+```
+build.cmd/sh -subset libs.tests -test /p:WithoutCategories=IgnoreForCI
+```
 
-To build tests you need to specify the `test` subset when invoking build.cmd/sh: `build.cmd/sh -subset libs.tests`.
+### Running tests for a single library
 
 The easiest (and recommended) way to build and run the tests for a specific library, is to invoke the `Test` target on that library:
 ```cmd
@@ -68,21 +85,21 @@ dotnet build /t:Test /p:TargetArchitecture=x86
 
 There may be multiple projects in some directories so you may need to specify the path to a specific test project to get it to build and run the tests.
 
-#### Running a single test on the command line
+### Running a single test on the command line
 
 To quickly run or debug a single test from the command line, set the XunitMethodName property, e.g.:
 ```cmd
 dotnet build /t:Test /p:XunitMethodName={FullyQualifiedNamespace}.{ClassName}.{MethodName}
 ```
 
-#### Running outer loop tests
+### Running outer loop tests
 
 To run all tests, including "outer loop" tests (which are typically slower and in some test suites less reliable, but which are more comprehensive):
 ```cmd
 dotnet build /t:Test /p:Outerloop=true
 ```
 
-#### Running tests on a different target framework
+### Running tests on a different target framework
 
 Each test project can potentially have multiple target frameworks. There are some tests that might be OS-specific, or might be testing an API that is available only on some target frameworks, so the `TargetFrameworks` property specifies the valid target frameworks. By default we will build and run only the default build target framework which is `net5.0`. The rest of the `TargetFrameworks` will need to be built and ran by specifying the `BuildTargetFramework` option, e.g.:
 ```cmd
diff --git a/eng/CodeAnalysis.ruleset b/eng/CodeAnalysis.ruleset
index 4631414599589f..8faa50e9a6f00b 100644
--- a/eng/CodeAnalysis.ruleset
+++ b/eng/CodeAnalysis.ruleset
@@ -126,6 +126,7 @@
     <Rule Id="CA1844" Action="Warning" />       <!-- Provide memory-based overrides of async methods when subclassing 'Stream' -->
     <Rule Id="CA1845" Action="Warning" />       <!-- Use span-based 'string.Concat' -->
     <Rule Id="CA1846" Action="Warning" />       <!-- Prefer 'AsSpan' over 'Substring' -->
+    <Rule Id="CA1847" Action="Warning" />       <!-- Use char literal for a single character lookup -->
     <Rule Id="CA2000" Action="None" />          <!-- Dispose objects before losing scope -->
     <Rule Id="CA2002" Action="None" />          <!-- Do not lock on objects with weak identity -->
     <Rule Id="CA2007" Action="Warning" />       <!-- Consider calling ConfigureAwait on the awaited task -->
diff --git a/eng/Signing.props b/eng/Signing.props
index ca044455e91c10..b546fd4ec3b5d3 100644
--- a/eng/Signing.props
+++ b/eng/Signing.props
@@ -35,7 +35,6 @@
     <DownloadedSymbolPackagesWithoutPaths Include="@(DownloadedSymbolPackages->'%(Filename)%(Extension)')" />
     <FileSignInfo Include="@(DownloadedSymbolPackagesWithoutPaths->Distinct())" CertificateName="None" />
 
-    <FileExtensionSignInfo Include=".mibc" CertificateName="MicrosoftDotNet500" />
     <FileExtensionSignInfo Include=".msi" CertificateName="MicrosoftDotNet500" />
     <FileExtensionSignInfo Include=".pkg" CertificateName="8003" />
     <FileExtensionSignInfo Include=".deb;.rpm" CertificateName="LinuxSign" />
@@ -77,7 +76,7 @@
                     Exclude="mscordaccore.dll"
                     CertificateName="MicrosoftSHA2" />
     </ItemGroup>
-
+    
     <ItemGroup Condition="'$(SignDiagnosticsPackages)' == 'true'">
       <!-- The cross OS diagnostics symbol packages need to be signed as they are the only packages
       that have a specific version of assets that are only meant to be indexed in symbol servers.
diff --git a/eng/SourceBuild.props b/eng/SourceBuild.props
new file mode 100644
index 00000000000000..7dfc80d41fd14c
--- /dev/null
+++ b/eng/SourceBuild.props
@@ -0,0 +1,73 @@
+<Project>
+
+  <PropertyGroup>
+    <GitHubRepositoryName>runtime</GitHubRepositoryName>
+  </PropertyGroup>
+
+  <!-- Set up the dotnet/runtime source-build command. -->
+  <PropertyGroup>
+    <BaseInnerSourceBuildCommand>./build.sh</BaseInnerSourceBuildCommand>
+
+    <SourceBuildPortable>true</SourceBuildPortable>
+    <SourceBuildPortable Condition="'$(SourceBuildNonPortable)' == 'true'">false</SourceBuildPortable>
+
+    <!-- If TargetRid not specified, detect RID based on portability. -->
+    <TargetRid Condition="'$(TargetRid)' == '' and '$(SourceBuildNonPortable)' == 'true'">$([System.Runtime.InteropServices.RuntimeInformation]::RuntimeIdentifier)</TargetRid>
+    <TargetRid Condition="'$(TargetRid)' == ''">$(__DistroRid)</TargetRid>
+
+    <!-- Split e.g. 'fedora.33-x64' into 'fedora.33' and 'x64'. -->
+    <_targetRidPlatformIndex>$(TargetRid.LastIndexOfAny("-"))</_targetRidPlatformIndex>
+    <TargetRidWithoutPlatform>$(TargetRid.Substring(0, $(_targetRidPlatformIndex)))</TargetRidWithoutPlatform>
+    <TargetRidPlatform>$(TargetRid.Substring($(_targetRidPlatformIndex)).TrimStart('-'))</TargetRidPlatform>
+
+    <LogVerbosity Condition="'$(LogVerbosity)' == ''">minimal</LogVerbosity>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <!-- Work around issue where local clone may cause failure using non-origin remote fallback: https://github.com/dotnet/sourcelink/issues/629 -->
+    <InnerBuildEnv Include="EnableSourceControlManagerQueries=false" />
+    <InnerBuildEnv Include="EnableSourceLink=false" />
+    <InnerBuildEnv Include="DisableSourceLink=true" />
+    <InnerBuildEnv Include="DeterministicSourcePaths=false" />
+  </ItemGroup>
+
+  <Target Name="GetRuntimeSourceBuildCommandConfiguration"
+          BeforeTargets="GetSourceBuildCommandConfiguration">
+    <PropertyGroup>
+      <InnerBuildArgs>$(InnerBuildArgs) --arch $(TargetRidPlatform)</InnerBuildArgs>
+      <InnerBuildArgs>$(InnerBuildArgs) --configuration $(Configuration)</InnerBuildArgs>
+      <InnerBuildArgs>$(InnerBuildArgs) --ci</InnerBuildArgs>
+      <InnerBuildArgs>$(InnerBuildArgs) --allconfigurations</InnerBuildArgs>
+      <InnerBuildArgs>$(InnerBuildArgs) --verbosity $(LogVerbosity)</InnerBuildArgs>
+      <InnerBuildArgs>$(InnerBuildArgs) --nodereuse false</InnerBuildArgs>
+      <InnerBuildArgs>$(InnerBuildArgs) --warnAsError false</InnerBuildArgs>
+      <InnerBuildArgs>$(InnerBuildArgs) --cmakeargs -DCLR_CMAKE_USE_SYSTEM_LIBUNWIND=TRUE</InnerBuildArgs>
+      <InnerBuildArgs>$(InnerBuildArgs) /p:MicrosoftNetFrameworkReferenceAssembliesVersion=1.0.0</InnerBuildArgs>
+      <InnerBuildArgs>$(InnerBuildArgs) /p:ContinuousIntegrationBuild=true</InnerBuildArgs>
+      <InnerBuildArgs>$(InnerBuildArgs) /p:PackageRid=$(TargetRid)</InnerBuildArgs>
+      <InnerBuildArgs>$(InnerBuildArgs) /p:NoPgoOptimize=true</InnerBuildArgs>
+      <InnerBuildArgs>$(InnerBuildArgs) /p:KeepNativeSymbols=true</InnerBuildArgs>
+      <InnerBuildArgs>$(InnerBuildArgs) /p:RuntimeOS=$(TargetRidWithoutPlatform)</InnerBuildArgs>
+      <InnerBuildArgs>$(InnerBuildArgs) /p:PortableBuild=$(SourceBuildPortable)</InnerBuildArgs>
+      <InnerBuildArgs>$(InnerBuildArgs) /p:BuildDebPackage=false</InnerBuildArgs>
+    </PropertyGroup>
+  </Target>
+
+  <Target Name="CategorizeRuntimeSupplementalArtifacts"
+          BeforeTargets="GetCategorizedIntermediateNupkgContents">
+    <ItemGroup>
+      <!--
+        Runtime artifacts are too large to fit into a single package (Azure DevOps feeds 500 mb constraint).
+        Split large components into separate packages.
+      -->
+      <IntermediateNupkgArtifactFile Include="$(CurrentRepoSourceBuildArtifactsPackagesDir)Shipping\dotnet-runtime-*.tar.gz" Category="runtime" />
+
+      <IntermediateNupkgArtifactFile
+        Include="
+          $(CurrentRepoSourceBuildArtifactsPackagesDir)Shipping\dotnet-crossgen2-*.tar.gz;
+          $(CurrentRepoSourceBuildArtifactsPackagesDir)Shipping\Microsoft.NETCore.App.Crossgen2.*.nupkg"
+        Category="Crossgen2Pack" />
+    </ItemGroup>
+  </Target>
+
+</Project>
diff --git a/eng/SourceBuildPrebuiltBaseline.xml b/eng/SourceBuildPrebuiltBaseline.xml
new file mode 100644
index 00000000000000..c1b6dfbf053817
--- /dev/null
+++ b/eng/SourceBuildPrebuiltBaseline.xml
@@ -0,0 +1,5 @@
+<UsageData>
+  <IgnorePatterns>
+    <UsagePattern IdentityGlob="*/*" />
+  </IgnorePatterns>
+</UsageData>
diff --git a/eng/Subsets.props b/eng/Subsets.props
index bf6b25bffc7317..105b34254c6c2b 100644
--- a/eng/Subsets.props
+++ b/eng/Subsets.props
@@ -25,8 +25,8 @@
   <PropertyGroup>
     <DefaultSubsets>clr+mono+libs+host+packs</DefaultSubsets>
     <DefaultSubsets Condition="'$(TargetsMobile)' == 'true'">mono+libs+packs</DefaultSubsets>
-    <!-- On Windows mono is supported for x86/x64 only -->
-    <DefaultSubsets Condition="'$(TargetOS)' == 'windows' and '$(TargetArchitecture)' != 'x86' and '$(TargetArchitecture)' != 'x64'">clr+libs+host+packs</DefaultSubsets>
+    <!-- mono is not supported in source build. On Windows mono is supported for x86/x64 only. -->
+    <DefaultSubsets Condition="'$(DotNetBuildFromSource)' == 'true' or ('$(TargetOS)' == 'windows' and '$(TargetArchitecture)' != 'x86' and '$(TargetArchitecture)' != 'x64')">clr+libs+host+packs</DefaultSubsets>
   </PropertyGroup>
 
   <!-- Init _subset here in to allow RuntimeFlavor to be set as early as possible -->
@@ -49,18 +49,21 @@
     <DefaultMonoSubsets Condition="'$(TargetOS)' == 'Browser'">$(DefaultMonoSubsets)mono.wasmruntime+</DefaultMonoSubsets>
     <DefaultMonoSubsets Condition="'$(MonoCrossAOTTargetOS)' != ''">$(DefaultMonoSubsets)mono.aotcross+</DefaultMonoSubsets>
     <DefaultMonoSubsets>$(DefaultMonoSubsets)mono.runtime+mono.corelib+mono.packages</DefaultMonoSubsets>
-     
+
     <DefaultLibrariesSubsets Condition="'$(BuildTargetFramework)' == '$(NetCoreAppCurrent)' or
                                         '$(BuildTargetFramework)' == '' or
                                         '$(BuildAllConfigurations)' == 'true'">libs.native+</DefaultLibrariesSubsets>
-    <DefaultLibrariesSubsets>$(DefaultLibrariesSubsets)libs.ref+libs.src+libs.pretest+libs.packages</DefaultLibrariesSubsets>
+    <DefaultLibrariesSubsets>$(DefaultLibrariesSubsets)libs.ref+libs.src+libs.packages</DefaultLibrariesSubsets>
+    <DefaultLibrariesSubsets Condition="'$(DotNetBuildFromSource)' != 'true'">$(DefaultLibrariesSubsets)+libs.pretest</DefaultLibrariesSubsets>
 
-    <DefaultHostSubsets>host.native+host.pkg+host.tools+host.tests</DefaultHostSubsets>
+    <DefaultHostSubsets>host.native+host.tools</DefaultHostSubsets>
+    <DefaultHostSubsets Condition="'$(DotNetBuildFromSource)' != 'true'">$(DefaultHostSubsets)+host.pkg+host.tests</DefaultHostSubsets>
     <DefaultHostSubsets Condition="'$(RuntimeFlavor)' == 'Mono'"></DefaultHostSubsets>
     <DefaultHostSubsets Condition="'$(RuntimeFlavor)' == 'Mono' and '$(TargetsMobile)' != 'true'">host.native</DefaultHostSubsets>
 
     <DefaultPacksSubsets>packs.product</DefaultPacksSubsets>
     <DefaultPacksSubsets Condition="'$(BuildMonoAOTCrossCompilerOnly)' != 'true'">$(DefaultPacksSubsets)+packs.tests</DefaultPacksSubsets>
+    <DefaultPacksSubsets Condition="'$(DotNetBuildFromSource)' == 'true'">$(DefaultPacksSubsets)+packs.installers</DefaultPacksSubsets>
   </PropertyGroup>
 
   <PropertyGroup>
@@ -204,12 +207,12 @@
     <ProjectToBuild Include="$(CoreClrProjectRoot)tools\runincontext\runincontext.csproj;
                              $(CoreClrProjectRoot)tools\r2rdump\R2RDump.csproj;
                              $(CoreClrProjectRoot)tools\dotnet-pgo\dotnet-pgo.csproj;
-                             $(CoreClrProjectRoot)tools\r2rtest\R2RTest.csproj;
-                             $(CoreClrProjectRoot)tools\aot\crossgen2\crossgen2.csproj" Category="clr" />
+                             $(CoreClrProjectRoot)tools\r2rtest\R2RTest.csproj" Category="clr" Condition="'$(DotNetBuildFromSource)' != 'true'"/>
+    <ProjectToBuild Include="$(CoreClrProjectRoot)tools\aot\crossgen2\crossgen2.csproj" Category="clr" />
 
     <ProjectToBuild Condition="'$(TargetArchitecture)' != 'x64' and '$(BuildArchitecture)' == 'x64'" Include="$(CoreClrProjectRoot)tools\aot\crossgen2\crossgen2_crossarch.csproj" Category="clr" />
     <ProjectToBuild Include="$(CoreClrProjectRoot)tools\aot\ILCompiler.TypeSystem.ReadyToRun.Tests\ILCompiler.TypeSystem.ReadyToRun.Tests.csproj"
-      Test="true" Category="clr" Condition="'$(__DistroRid)' != 'linux-musl-x64'"/>
+      Test="true" Category="clr" Condition="'$(__DistroRid)' != 'linux-musl-x64' and '$(DotNetBuildFromSource)' != 'true'"/>
   </ItemGroup>
 
   <ItemGroup Condition="$(_subset.Contains('+clr.nativecorelib+'))">
@@ -221,7 +224,7 @@
 
   <ItemGroup Condition="$(_subset.Contains('+clr.packages+')) and '$(PgoInstrument)' != 'true'">
     <ProjectToBuild Include="$(CoreClrProjectRoot).nuget\coreclr-packages.proj" Pack="true" Category="clr" />
-    <ProjectToBuild Include="$(CoreClrProjectRoot)tools\dotnet-pgo\dotnet-pgo-pack.proj" Pack="true" BuildInParallel="false" Category="clr" />
+    <ProjectToBuild Include="$(CoreClrProjectRoot)tools\dotnet-pgo\dotnet-pgo-pack.proj" Pack="true" BuildInParallel="false" Category="clr" Condition="'$(DotNetBuildFromSource)' != 'true'"/>
   </ItemGroup>
 
   <!-- Mono sets -->
diff --git a/eng/Tools.props b/eng/Tools.props
index 04f1c9d742510c..1a9804dbaf6925 100644
--- a/eng/Tools.props
+++ b/eng/Tools.props
@@ -7,7 +7,6 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.DotNet.Build.Tasks.Packaging" Version="$(MicrosoftDotNetBuildTasksPackagingVersion)" />
-    <PackageReference Include="Microsoft.DotNet.PackageTesting" Version="$(MicrosoftDotNetPackageTestingVersion)" />
     <!-- enable source link in pkgproj -->
     <PackageReference Include="Microsoft.SourceLink.GitHub" Version="$(MicrosoftSourceLinkVersion)" PrivateAssets="all" IsImplicitlyDefined="true" />
     <PackageReference Include="Microsoft.SourceLink.AzureRepos.Git" Version="$(MicrosoftSourceLinkVersion)" PrivateAssets="all" IsImplicitlyDefined="true" />
diff --git a/eng/Version.Details.xml b/eng/Version.Details.xml
index 4eeb9d3192cd20..5c1f457ae40f4d 100644
--- a/eng/Version.Details.xml
+++ b/eng/Version.Details.xml
@@ -1,218 +1,227 @@
 <Dependencies>
   <ProductDependencies>
-    <Dependency Name="Microsoft.NETCore.Runtime.ICU.Transport" Version="6.0.0-preview.6.21281.1">
+    <Dependency Name="Microsoft.NETCore.Runtime.ICU.Transport" Version="6.0.0-preview.6.21307.1">
       <Uri>https://github.com/dotnet/icu</Uri>
-      <Sha>05fbe174749fc77d77eaffc777908f438c011c81</Sha>
+      <Sha>d7db669b70f4dd67ec001c192f9809c218cab88b</Sha>
     </Dependency>
   </ProductDependencies>
   <ToolsetDependencies>
-    <Dependency Name="Microsoft.DotNet.Arcade.Sdk" Version="6.0.0-beta.21281.1">
+    <Dependency Name="Microsoft.DotNet.Arcade.Sdk" Version="6.0.0-beta.21311.3">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>c7d6bd607715f334cda90e01967bb0c02dee09be</Sha>
+      <Sha>4a2b475948d498b89fedef7cf890883f49bc1ea3</Sha>
+      <SourceBuild RepoName="arcade" ManagedOnly="true" />
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.Helix.Sdk" Version="6.0.0-beta.21281.1">
+    <Dependency Name="Microsoft.DotNet.Helix.Sdk" Version="6.0.0-beta.21311.3">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>c7d6bd607715f334cda90e01967bb0c02dee09be</Sha>
+      <Sha>4a2b475948d498b89fedef7cf890883f49bc1ea3</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.ApiCompat" Version="6.0.0-beta.21281.1">
+    <Dependency Name="Microsoft.DotNet.ApiCompat" Version="6.0.0-beta.21311.3">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>c7d6bd607715f334cda90e01967bb0c02dee09be</Sha>
+      <Sha>4a2b475948d498b89fedef7cf890883f49bc1ea3</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.GenAPI" Version="6.0.0-beta.21281.1">
+    <Dependency Name="Microsoft.DotNet.GenAPI" Version="6.0.0-beta.21311.3">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>c7d6bd607715f334cda90e01967bb0c02dee09be</Sha>
+      <Sha>4a2b475948d498b89fedef7cf890883f49bc1ea3</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.GenFacades" Version="6.0.0-beta.21281.1">
+    <Dependency Name="Microsoft.DotNet.GenFacades" Version="6.0.0-beta.21311.3">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>c7d6bd607715f334cda90e01967bb0c02dee09be</Sha>
+      <Sha>4a2b475948d498b89fedef7cf890883f49bc1ea3</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.XUnitExtensions" Version="6.0.0-beta.21281.1">
+    <Dependency Name="Microsoft.DotNet.XUnitExtensions" Version="6.0.0-beta.21311.3">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>c7d6bd607715f334cda90e01967bb0c02dee09be</Sha>
+      <Sha>4a2b475948d498b89fedef7cf890883f49bc1ea3</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.XUnitConsoleRunner" Version="2.5.1-beta.21281.1">
+    <Dependency Name="Microsoft.DotNet.XUnitConsoleRunner" Version="2.5.1-beta.21311.3">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>c7d6bd607715f334cda90e01967bb0c02dee09be</Sha>
+      <Sha>4a2b475948d498b89fedef7cf890883f49bc1ea3</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.Build.Tasks.Archives" Version="6.0.0-beta.21281.1">
+    <Dependency Name="Microsoft.DotNet.Build.Tasks.Archives" Version="6.0.0-beta.21311.3">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>c7d6bd607715f334cda90e01967bb0c02dee09be</Sha>
+      <Sha>4a2b475948d498b89fedef7cf890883f49bc1ea3</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.Build.Tasks.Packaging" Version="6.0.0-beta.21281.1">
+    <Dependency Name="Microsoft.DotNet.Build.Tasks.Packaging" Version="6.0.0-beta.21311.3">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>c7d6bd607715f334cda90e01967bb0c02dee09be</Sha>
+      <Sha>4a2b475948d498b89fedef7cf890883f49bc1ea3</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.Build.Tasks.Installers" Version="6.0.0-beta.21281.1">
+    <Dependency Name="Microsoft.DotNet.Build.Tasks.Installers" Version="6.0.0-beta.21311.3">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>c7d6bd607715f334cda90e01967bb0c02dee09be</Sha>
+      <Sha>4a2b475948d498b89fedef7cf890883f49bc1ea3</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.CodeAnalysis" Version="6.0.0-beta.21281.1">
+    <Dependency Name="Microsoft.DotNet.CodeAnalysis" Version="6.0.0-beta.21311.3">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>c7d6bd607715f334cda90e01967bb0c02dee09be</Sha>
+      <Sha>4a2b475948d498b89fedef7cf890883f49bc1ea3</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.Build.Tasks.TargetFramework.Sdk" Version="6.0.0-beta.21281.1">
+    <Dependency Name="Microsoft.DotNet.Build.Tasks.TargetFramework.Sdk" Version="6.0.0-beta.21311.3">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>c7d6bd607715f334cda90e01967bb0c02dee09be</Sha>
+      <Sha>4a2b475948d498b89fedef7cf890883f49bc1ea3</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.RemoteExecutor" Version="6.0.0-beta.21281.1">
+    <Dependency Name="Microsoft.DotNet.RemoteExecutor" Version="6.0.0-beta.21311.3">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>c7d6bd607715f334cda90e01967bb0c02dee09be</Sha>
+      <Sha>4a2b475948d498b89fedef7cf890883f49bc1ea3</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.Build.Tasks.Feed" Version="6.0.0-beta.21281.1">
+    <Dependency Name="Microsoft.DotNet.Build.Tasks.Feed" Version="6.0.0-beta.21311.3">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>c7d6bd607715f334cda90e01967bb0c02dee09be</Sha>
+      <Sha>4a2b475948d498b89fedef7cf890883f49bc1ea3</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.VersionTools.Tasks" Version="6.0.0-beta.21281.1">
+    <Dependency Name="Microsoft.DotNet.VersionTools.Tasks" Version="6.0.0-beta.21311.3">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>c7d6bd607715f334cda90e01967bb0c02dee09be</Sha>
+      <Sha>4a2b475948d498b89fedef7cf890883f49bc1ea3</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.SharedFramework.Sdk" Version="6.0.0-beta.21281.1">
+    <Dependency Name="Microsoft.DotNet.SharedFramework.Sdk" Version="6.0.0-beta.21311.3">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>c7d6bd607715f334cda90e01967bb0c02dee09be</Sha>
+      <Sha>4a2b475948d498b89fedef7cf890883f49bc1ea3</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="6.0.0-beta.21275.1">
+    <Dependency Name="System.ComponentModel.TypeConverter.TestData" Version="6.0.0-beta.21307.1">
       <Uri>https://github.com/dotnet/runtime-assets</Uri>
-      <Sha>3f92f2642a176248e735f61d748ace8b9dfaa56a</Sha>
+      <Sha>0612b036e67746930105231b605c4df9ac6ed47e</Sha>
     </Dependency>
-    <Dependency Name="System.Drawing.Common.TestData" Version="6.0.0-beta.21275.1">
+    <Dependency Name="System.Drawing.Common.TestData" Version="6.0.0-beta.21307.1">
       <Uri>https://github.com/dotnet/runtime-assets</Uri>
-      <Sha>3f92f2642a176248e735f61d748ace8b9dfaa56a</Sha>
+      <Sha>0612b036e67746930105231b605c4df9ac6ed47e</Sha>
     </Dependency>
-    <Dependency Name="System.IO.Compression.TestData" Version="6.0.0-beta.21275.1">
+    <Dependency Name="System.IO.Compression.TestData" Version="6.0.0-beta.21307.1">
       <Uri>https://github.com/dotnet/runtime-assets</Uri>
-      <Sha>3f92f2642a176248e735f61d748ace8b9dfaa56a</Sha>
+      <Sha>0612b036e67746930105231b605c4df9ac6ed47e</Sha>
     </Dependency>
-    <Dependency Name="System.IO.Packaging.TestData" Version="6.0.0-beta.21275.1">
+    <Dependency Name="System.IO.Packaging.TestData" Version="6.0.0-beta.21307.1">
       <Uri>https://github.com/dotnet/runtime-assets</Uri>
-      <Sha>3f92f2642a176248e735f61d748ace8b9dfaa56a</Sha>
+      <Sha>0612b036e67746930105231b605c4df9ac6ed47e</Sha>
     </Dependency>
-    <Dependency Name="System.Net.TestData" Version="6.0.0-beta.21275.1">
+    <Dependency Name="System.Net.TestData" Version="6.0.0-beta.21307.1">
       <Uri>https://github.com/dotnet/runtime-assets</Uri>
-      <Sha>3f92f2642a176248e735f61d748ace8b9dfaa56a</Sha>
+      <Sha>0612b036e67746930105231b605c4df9ac6ed47e</Sha>
     </Dependency>
-    <Dependency Name="System.Private.Runtime.UnicodeData" Version="6.0.0-beta.21275.1">
+    <Dependency Name="System.Private.Runtime.UnicodeData" Version="6.0.0-beta.21307.1">
       <Uri>https://github.com/dotnet/runtime-assets</Uri>
-      <Sha>3f92f2642a176248e735f61d748ace8b9dfaa56a</Sha>
+      <Sha>0612b036e67746930105231b605c4df9ac6ed47e</Sha>
     </Dependency>
-    <Dependency Name="System.Runtime.TimeZoneData" Version="6.0.0-beta.21275.1">
+    <Dependency Name="System.Runtime.TimeZoneData" Version="6.0.0-beta.21307.1">
       <Uri>https://github.com/dotnet/runtime-assets</Uri>
-      <Sha>3f92f2642a176248e735f61d748ace8b9dfaa56a</Sha>
+      <Sha>0612b036e67746930105231b605c4df9ac6ed47e</Sha>
     </Dependency>
-    <Dependency Name="System.Security.Cryptography.X509Certificates.TestData" Version="6.0.0-beta.21275.1">
+    <Dependency Name="System.Security.Cryptography.X509Certificates.TestData" Version="6.0.0-beta.21307.1">
       <Uri>https://github.com/dotnet/runtime-assets</Uri>
-      <Sha>3f92f2642a176248e735f61d748ace8b9dfaa56a</Sha>
+      <Sha>0612b036e67746930105231b605c4df9ac6ed47e</Sha>
     </Dependency>
-    <Dependency Name="System.Windows.Extensions.TestData" Version="6.0.0-beta.21275.1">
+    <Dependency Name="System.Windows.Extensions.TestData" Version="6.0.0-beta.21307.1">
       <Uri>https://github.com/dotnet/runtime-assets</Uri>
-      <Sha>3f92f2642a176248e735f61d748ace8b9dfaa56a</Sha>
+      <Sha>0612b036e67746930105231b605c4df9ac6ed47e</Sha>
     </Dependency>
-    <Dependency Name="runtime.linux-arm64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk" Version="9.0.1-alpha.1.21281.1">
+    <Dependency Name="runtime.linux-arm64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk" Version="11.1.0-alpha.1.21308.1">
       <Uri>https://github.com/dotnet/llvm-project</Uri>
-      <Sha>a3ff327da9634da948e84d45df9e6beb64eb5c4c</Sha>
+      <Sha>a76e596b96a1b9b4bc7a213f9a8335bcd9189b67</Sha>
     </Dependency>
-    <Dependency Name="runtime.linux-arm64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools" Version="9.0.1-alpha.1.21281.1">
+    <Dependency Name="runtime.linux-arm64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools" Version="11.1.0-alpha.1.21308.1">
       <Uri>https://github.com/dotnet/llvm-project</Uri>
-      <Sha>a3ff327da9634da948e84d45df9e6beb64eb5c4c</Sha>
+      <Sha>a76e596b96a1b9b4bc7a213f9a8335bcd9189b67</Sha>
     </Dependency>
-    <Dependency Name="runtime.linux-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk" Version="9.0.1-alpha.1.21281.1">
+    <Dependency Name="runtime.linux-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk" Version="11.1.0-alpha.1.21308.1">
       <Uri>https://github.com/dotnet/llvm-project</Uri>
-      <Sha>a3ff327da9634da948e84d45df9e6beb64eb5c4c</Sha>
+      <Sha>a76e596b96a1b9b4bc7a213f9a8335bcd9189b67</Sha>
     </Dependency>
-    <Dependency Name="runtime.linux-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools" Version="9.0.1-alpha.1.21281.1">
+    <Dependency Name="runtime.linux-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools" Version="11.1.0-alpha.1.21308.1">
       <Uri>https://github.com/dotnet/llvm-project</Uri>
-      <Sha>a3ff327da9634da948e84d45df9e6beb64eb5c4c</Sha>
+      <Sha>a76e596b96a1b9b4bc7a213f9a8335bcd9189b67</Sha>
     </Dependency>
-    <Dependency Name="runtime.win-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk" Version="9.0.1-alpha.1.21281.1">
+    <Dependency Name="runtime.win-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk" Version="11.1.0-alpha.1.21308.1">
       <Uri>https://github.com/dotnet/llvm-project</Uri>
-      <Sha>a3ff327da9634da948e84d45df9e6beb64eb5c4c</Sha>
+      <Sha>a76e596b96a1b9b4bc7a213f9a8335bcd9189b67</Sha>
     </Dependency>
-    <Dependency Name="runtime.win-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools" Version="9.0.1-alpha.1.21281.1">
+    <Dependency Name="runtime.win-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools" Version="11.1.0-alpha.1.21308.1">
       <Uri>https://github.com/dotnet/llvm-project</Uri>
-      <Sha>a3ff327da9634da948e84d45df9e6beb64eb5c4c</Sha>
+      <Sha>a76e596b96a1b9b4bc7a213f9a8335bcd9189b67</Sha>
     </Dependency>
-    <Dependency Name="runtime.osx.10.12-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk" Version="9.0.1-alpha.1.21281.1">
+    <Dependency Name="runtime.osx.10.12-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk" Version="11.1.0-alpha.1.21308.1">
       <Uri>https://github.com/dotnet/llvm-project</Uri>
-      <Sha>a3ff327da9634da948e84d45df9e6beb64eb5c4c</Sha>
+      <Sha>a76e596b96a1b9b4bc7a213f9a8335bcd9189b67</Sha>
     </Dependency>
-    <Dependency Name="runtime.osx.10.12-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools" Version="9.0.1-alpha.1.21281.1">
+    <Dependency Name="runtime.osx.10.12-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools" Version="11.1.0-alpha.1.21308.1">
       <Uri>https://github.com/dotnet/llvm-project</Uri>
-      <Sha>a3ff327da9634da948e84d45df9e6beb64eb5c4c</Sha>
+      <Sha>a76e596b96a1b9b4bc7a213f9a8335bcd9189b67</Sha>
     </Dependency>
     <Dependency Name="Microsoft.NETCore.App" Version="5.0.0-rc.1.20451.14">
       <Uri>https://github.com/dotnet/runtime</Uri>
       <Sha>38017c3935de95d0335bac04f4901ddfc2718656</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.NETCore.DotNetHost" Version="6.0.0-preview.6.21281.1">
+    <Dependency Name="Microsoft.NETCore.DotNetHost" Version="6.0.0-preview.6.21314.1">
       <Uri>https://github.com/dotnet/runtime</Uri>
-      <Sha>fea7ff2cce79da2df9cf1c50ce215287750f055e</Sha>
+      <Sha>af5c238556e204583b129cc8f5c7338f84dc2c40</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.NETCore.DotNetHostPolicy" Version="6.0.0-preview.6.21281.1">
+    <Dependency Name="Microsoft.NETCore.DotNetHostPolicy" Version="6.0.0-preview.6.21314.1">
       <Uri>https://github.com/dotnet/runtime</Uri>
-      <Sha>fea7ff2cce79da2df9cf1c50ce215287750f055e</Sha>
+      <Sha>af5c238556e204583b129cc8f5c7338f84dc2c40</Sha>
     </Dependency>
-    <Dependency Name="runtime.native.System.IO.Ports" Version="6.0.0-preview.6.21281.1">
+    <Dependency Name="runtime.native.System.IO.Ports" Version="6.0.0-preview.6.21314.1">
       <Uri>https://github.com/dotnet/runtime</Uri>
-      <Sha>fea7ff2cce79da2df9cf1c50ce215287750f055e</Sha>
+      <Sha>af5c238556e204583b129cc8f5c7338f84dc2c40</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.NETCore.ILAsm" Version="6.0.0-preview.6.21281.1">
+    <Dependency Name="Microsoft.NETCore.ILAsm" Version="6.0.0-preview.6.21314.1">
       <Uri>https://github.com/dotnet/runtime</Uri>
-      <Sha>fea7ff2cce79da2df9cf1c50ce215287750f055e</Sha>
+      <Sha>af5c238556e204583b129cc8f5c7338f84dc2c40</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.NET.Sdk.IL" Version="6.0.0-preview.6.21281.1">
+    <Dependency Name="Microsoft.NET.Sdk.IL" Version="6.0.0-preview.6.21314.1">
       <Uri>https://github.com/dotnet/runtime</Uri>
-      <Sha>fea7ff2cce79da2df9cf1c50ce215287750f055e</Sha>
+      <Sha>af5c238556e204583b129cc8f5c7338f84dc2c40</Sha>
     </Dependency>
-    <Dependency Name="System.Text.Json" Version="6.0.0-preview.6.21281.1">
+    <Dependency Name="System.Text.Json" Version="6.0.0-preview.6.21314.1">
       <Uri>https://github.com/dotnet/runtime</Uri>
-      <Sha>fea7ff2cce79da2df9cf1c50ce215287750f055e</Sha>
+      <Sha>af5c238556e204583b129cc8f5c7338f84dc2c40</Sha>
     </Dependency>
-    <Dependency Name="System.Runtime.CompilerServices.Unsafe" Version="6.0.0-preview.6.21281.1">
+    <Dependency Name="System.Runtime.CompilerServices.Unsafe" Version="6.0.0-preview.6.21314.1">
       <Uri>https://github.com/dotnet/runtime</Uri>
-      <Sha>fea7ff2cce79da2df9cf1c50ce215287750f055e</Sha>
+      <Sha>af5c238556e204583b129cc8f5c7338f84dc2c40</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.NET.ILLink.Tasks" Version="6.0.100-preview.6.21281.4">
+    <Dependency Name="Microsoft.NET.ILLink.Tasks" Version="6.0.100-preview.6.21310.3">
       <Uri>https://github.com/mono/linker</Uri>
-      <Sha>493a448586c1fad68efc2126836f5bb9b5f9ad20</Sha>
+      <Sha>caeaf2a3fb3f636805fdd4881df4f9a539fff8f6</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.XHarness.TestRunners.Xunit" Version="1.0.0-prerelease.21281.2">
+    <Dependency Name="Microsoft.DotNet.XHarness.TestRunners.Xunit" Version="1.0.0-prerelease.21314.1">
       <Uri>https://github.com/dotnet/xharness</Uri>
-      <Sha>c22941f71c25dd9371caa25410ec264e9d8efac4</Sha>
+      <Sha>d6f8a4ad30908fb210390380eae97264e4fbe8ce</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.XHarness.CLI" Version="1.0.0-prerelease.21281.2">
+    <Dependency Name="Microsoft.DotNet.XHarness.CLI" Version="1.0.0-prerelease.21314.1">
       <Uri>https://github.com/dotnet/xharness</Uri>
-      <Sha>c22941f71c25dd9371caa25410ec264e9d8efac4</Sha>
+      <Sha>d6f8a4ad30908fb210390380eae97264e4fbe8ce</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.PackageTesting" Version="6.0.0-beta.21281.1">
+    <Dependency Name="Microsoft.DotNet.PackageTesting" Version="6.0.0-beta.21311.3">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>c7d6bd607715f334cda90e01967bb0c02dee09be</Sha>
+      <Sha>85a65ea1fca1d0867f699fed44d191358270bf6a</Sha>
     </Dependency>
-    <Dependency Name="optimization.windows_nt-x64.MIBC.Runtime" Version="1.0.0-prerelease.21301.4">
+    <Dependency Name="optimization.windows_nt-x64.MIBC.Runtime" Version="1.0.0-prerelease.21313.4">
       <Uri>https://dev.azure.com/dnceng/internal/_git/dotnet-optimization</Uri>
-      <Sha>f4ee4d18519bd793bb3992349e3f756aa3028425</Sha>
+      <Sha>4e5bea15eb5a9c8cf9142195b1c9c78437a5b27f</Sha>
     </Dependency>
-    <Dependency Name="optimization.windows_nt-x86.MIBC.Runtime" Version="1.0.0-prerelease.21301.4">
+    <Dependency Name="optimization.windows_nt-x86.MIBC.Runtime" Version="1.0.0-prerelease.21313.4">
       <Uri>https://dev.azure.com/dnceng/internal/_git/dotnet-optimization</Uri>
-      <Sha>f4ee4d18519bd793bb3992349e3f756aa3028425</Sha>
+      <Sha>4e5bea15eb5a9c8cf9142195b1c9c78437a5b27f</Sha>
     </Dependency>
-    <Dependency Name="optimization.linux-x64.MIBC.Runtime" Version="1.0.0-prerelease.21301.4">
+    <Dependency Name="optimization.linux-x64.MIBC.Runtime" Version="1.0.0-prerelease.21313.4">
       <Uri>https://dev.azure.com/dnceng/internal/_git/dotnet-optimization</Uri>
-      <Sha>f4ee4d18519bd793bb3992349e3f756aa3028425</Sha>
+      <Sha>4e5bea15eb5a9c8cf9142195b1c9c78437a5b27f</Sha>
     </Dependency>
-    <Dependency Name="optimization.PGO.CoreCLR" Version="1.0.0-prerelease.21301.4">
+    <Dependency Name="optimization.PGO.CoreCLR" Version="1.0.0-prerelease.21313.4">
       <Uri>https://dev.azure.com/dnceng/internal/_git/dotnet-optimization</Uri>
-      <Sha>f4ee4d18519bd793bb3992349e3f756aa3028425</Sha>
+      <Sha>4e5bea15eb5a9c8cf9142195b1c9c78437a5b27f</Sha>
     </Dependency>
     <Dependency Name="Microsoft.NET.Runtime.Emscripten.2.0.21.Node.win-x64" Version="6.0.0-preview.6.21275.1">
       <Uri>https://github.com/dotnet/emsdk</Uri>
       <Sha>defa37b05c734e025292c5747664e970cd2ac444</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.HotReload.Utils.Generator.BuildTool" Version="1.0.1-alpha.0.21281.1">
+    <Dependency Name="Microsoft.DotNet.HotReload.Utils.Generator.BuildTool" Version="1.0.1-alpha.0.21311.1">
       <Uri>https://github.com/dotnet/hotreload-utils</Uri>
-      <Sha>2a24834bde0dab496ed9eba1bf9b87e39544b9b5</Sha>
+      <Sha>25b814e010cd4796cedfbcce72a274c26928f496</Sha>
+    </Dependency>
+    <Dependency Name="System.Runtime.Numerics.TestData" Version="6.0.0-beta.21314.1">
+      <Uri>https://github.com/dotnet/runtime-assets</Uri>
+      <Sha>8d7b898b96cbdb868cac343e938173105287ed9e</Sha>
+    </Dependency>
+    <Dependency Name="Microsoft.CodeAnalysis.NetAnalyzers" Version="6.0.0-rc1.21320.2">
+      <Uri>https://github.com/dotnet/roslyn-analyzers</Uri>
+      <Sha>fcddb771f42866f9521f23f093b1f30e129018bb</Sha>
     </Dependency>
   </ToolsetDependencies>
 </Dependencies>
diff --git a/eng/Versions.props b/eng/Versions.props
index c9ca4cead3279c..a194baa33def9e 100644
--- a/eng/Versions.props
+++ b/eng/Versions.props
@@ -8,7 +8,7 @@
     <PatchVersion>0</PatchVersion>
     <SdkBandVersion>6.0.100</SdkBandVersion>
     <PreReleaseVersionLabel>preview</PreReleaseVersionLabel>
-    <PreReleaseVersionIteration>6</PreReleaseVersionIteration>
+    <PreReleaseVersionIteration>7</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>
@@ -45,84 +45,87 @@
     <MicrosoftCodeAnalysisVersion>3.8.0</MicrosoftCodeAnalysisVersion>
   </PropertyGroup>
   <PropertyGroup>
-    <MicrosoftCodeAnalysisNetAnalyzersVersion>6.0.0-preview6.21274.2</MicrosoftCodeAnalysisNetAnalyzersVersion>
+    <!-- Code analysis dependencies -->
     <MicrosoftCodeAnalysisCSharpCodeStyleVersion>3.10.0-2.final</MicrosoftCodeAnalysisCSharpCodeStyleVersion>
     <MicrosoftCodeAnalysisCSharpVersion>3.10.0-2.final</MicrosoftCodeAnalysisCSharpVersion>
+    <MicrosoftCodeAnalysisNetAnalyzersVersion>6.0.0-rc1.21320.2</MicrosoftCodeAnalysisNetAnalyzersVersion>
     <!-- Arcade dependencies -->
-    <MicrosoftDotNetApiCompatVersion>6.0.0-beta.21281.1</MicrosoftDotNetApiCompatVersion>
-    <MicrosoftDotNetBuildTasksFeedVersion>6.0.0-beta.21281.1</MicrosoftDotNetBuildTasksFeedVersion>
-    <MicrosoftDotNetCodeAnalysisVersion>6.0.0-beta.21281.1</MicrosoftDotNetCodeAnalysisVersion>
-    <MicrosoftDotNetGenAPIVersion>6.0.0-beta.21281.1</MicrosoftDotNetGenAPIVersion>
-    <MicrosoftDotNetGenFacadesVersion>6.0.0-beta.21281.1</MicrosoftDotNetGenFacadesVersion>
-    <MicrosoftDotNetXUnitExtensionsVersion>6.0.0-beta.21281.1</MicrosoftDotNetXUnitExtensionsVersion>
-    <MicrosoftDotNetXUnitConsoleRunnerVersion>2.5.1-beta.21281.1</MicrosoftDotNetXUnitConsoleRunnerVersion>
-    <MicrosoftDotNetBuildTasksArchivesVersion>6.0.0-beta.21281.1</MicrosoftDotNetBuildTasksArchivesVersion>
-    <MicrosoftDotNetBuildTasksPackagingVersion>6.0.0-beta.21281.1</MicrosoftDotNetBuildTasksPackagingVersion>
-    <MicrosoftDotNetBuildTasksInstallersVersion>6.0.0-beta.21281.1</MicrosoftDotNetBuildTasksInstallersVersion>
-    <MicrosoftDotNetRemoteExecutorVersion>6.0.0-beta.21281.1</MicrosoftDotNetRemoteExecutorVersion>
-    <MicrosoftDotNetVersionToolsTasksVersion>6.0.0-beta.21281.1</MicrosoftDotNetVersionToolsTasksVersion>
-    <MicrosoftDotNetPackageTestingVersion>6.0.0-beta.21281.1</MicrosoftDotNetPackageTestingVersion>
+    <MicrosoftDotNetApiCompatVersion>6.0.0-beta.21311.3</MicrosoftDotNetApiCompatVersion>
+    <MicrosoftDotNetBuildTasksFeedVersion>6.0.0-beta.21311.3</MicrosoftDotNetBuildTasksFeedVersion>
+    <MicrosoftDotNetCodeAnalysisVersion>6.0.0-beta.21311.3</MicrosoftDotNetCodeAnalysisVersion>
+    <MicrosoftDotNetGenAPIVersion>6.0.0-beta.21311.3</MicrosoftDotNetGenAPIVersion>
+    <MicrosoftDotNetGenFacadesVersion>6.0.0-beta.21311.3</MicrosoftDotNetGenFacadesVersion>
+    <MicrosoftDotNetXUnitExtensionsVersion>6.0.0-beta.21311.3</MicrosoftDotNetXUnitExtensionsVersion>
+    <MicrosoftDotNetXUnitConsoleRunnerVersion>2.5.1-beta.21311.3</MicrosoftDotNetXUnitConsoleRunnerVersion>
+    <MicrosoftDotNetBuildTasksArchivesVersion>6.0.0-beta.21311.3</MicrosoftDotNetBuildTasksArchivesVersion>
+    <MicrosoftDotNetBuildTasksPackagingVersion>6.0.0-beta.21311.3</MicrosoftDotNetBuildTasksPackagingVersion>
+    <MicrosoftDotNetBuildTasksInstallersVersion>6.0.0-beta.21311.3</MicrosoftDotNetBuildTasksInstallersVersion>
+    <MicrosoftDotNetRemoteExecutorVersion>6.0.0-beta.21311.3</MicrosoftDotNetRemoteExecutorVersion>
+    <MicrosoftDotNetVersionToolsTasksVersion>6.0.0-beta.21311.3</MicrosoftDotNetVersionToolsTasksVersion>
+    <MicrosoftDotNetPackageTestingVersion>6.0.0-beta.21311.3</MicrosoftDotNetPackageTestingVersion>
     <!-- NuGet dependencies -->
     <NuGetBuildTasksPackVersion>5.9.0-preview.2</NuGetBuildTasksPackVersion>
     <!-- Installer dependencies -->
     <MicrosoftNETCoreAppVersion>6.0.0-alpha.1.20612.4</MicrosoftNETCoreAppVersion>
-    <MicrosoftNETCoreDotNetHostVersion>6.0.0-preview.6.21281.1</MicrosoftNETCoreDotNetHostVersion>
-    <MicrosoftNETCoreDotNetHostPolicyVersion>6.0.0-preview.6.21281.1</MicrosoftNETCoreDotNetHostPolicyVersion>
+    <MicrosoftNETCoreDotNetHostVersion>6.0.0-preview.6.21314.1</MicrosoftNETCoreDotNetHostVersion>
+    <MicrosoftNETCoreDotNetHostPolicyVersion>6.0.0-preview.6.21314.1</MicrosoftNETCoreDotNetHostPolicyVersion>
     <MicrosoftExtensionsDependencyModelVersion>3.1.0</MicrosoftExtensionsDependencyModelVersion>
     <!-- CoreClr dependencies -->
-    <MicrosoftNETCoreILAsmVersion>6.0.0-preview.6.21281.1</MicrosoftNETCoreILAsmVersion>
+    <MicrosoftNETCoreILAsmVersion>6.0.0-preview.6.21314.1</MicrosoftNETCoreILAsmVersion>
     <!-- Libraries dependencies -->
+    <MicrosoftBclAsyncInterfacesVersion>5.0.0</MicrosoftBclAsyncInterfacesVersion>
+    <MicrosoftWin32PrimitivesVersion>4.3.0</MicrosoftWin32PrimitivesVersion>
+    <MicrosoftWin32RegistryVersion>5.0.0</MicrosoftWin32RegistryVersion>
     <StyleCopAnalyzersVersion>1.2.0-beta.304</StyleCopAnalyzersVersion>
-    <SystemAppContextVersion>4.3.0</SystemAppContextVersion>
     <SystemBuffersVersion>4.5.1</SystemBuffersVersion>
     <SystemCollectionsVersion>4.3.0</SystemCollectionsVersion>
-    <SystemCollectionsConcurrentVersion>4.3.0</SystemCollectionsConcurrentVersion>
     <SystemComponentModelAnnotationsVersion>5.0.0</SystemComponentModelAnnotationsVersion>
-    <SystemDataSqlClientVersion>4.8.1</SystemDataSqlClientVersion>
+    <SystemDataSqlClientVersion>4.8.2</SystemDataSqlClientVersion>
+    <SystemDataDataSetExtensionsVersion>4.5.0</SystemDataDataSetExtensionsVersion>
     <SystemDiagnosticsContractsVersion>4.3.0</SystemDiagnosticsContractsVersion>
-    <SystemDiagnosticsDebugVersion>4.3.0</SystemDiagnosticsDebugVersion>
-    <SystemDiagnosticsToolsVersion>4.3.0</SystemDiagnosticsToolsVersion>
-    <SystemDiagnosticsTracingVersion>4.3.0</SystemDiagnosticsTracingVersion>
     <SystemDynamicRuntimeVersion>4.3.0</SystemDynamicRuntimeVersion>
+    <SystemIOFileSystemAccessControlVersion>5.0.0</SystemIOFileSystemAccessControlVersion>
+    <SystemIOPipesAccessControlVersion>5.0.0</SystemIOPipesAccessControlVersion>
     <SystemLinqExpressionsVersion>4.3.0</SystemLinqExpressionsVersion>
     <SystemMemoryVersion>4.5.4</SystemMemoryVersion>
-    <SystemNetHttpVersion>4.3.4</SystemNetHttpVersion>
     <SystemNetPrimitivesVersion>4.3.1</SystemNetPrimitivesVersion>
     <SystemNumericsVectorsVersion>4.5.0</SystemNumericsVectorsVersion>
-    <SystemReflectionVersion>4.3.0</SystemReflectionVersion>
     <SystemReflectionMetadataVersion>5.0.0</SystemReflectionMetadataVersion>
-    <SystemResourcesResourceManagerVersion>4.3.0</SystemResourcesResourceManagerVersion>
+    <SystemReflectionEmitVersion>4.7.0</SystemReflectionEmitVersion>
+    <SystemReflectionEmitILGenerationVersion>4.7.0</SystemReflectionEmitILGenerationVersion>
+    <SystemReflectionEmitLightweightVersion>4.7.0</SystemReflectionEmitLightweightVersion>
     <SystemRuntimeVersion>4.3.1</SystemRuntimeVersion>
     <SystemRuntimeExtensionsVersion>4.3.1</SystemRuntimeExtensionsVersion>
     <SystemRuntimeInteropServicesVersion>4.3.0</SystemRuntimeInteropServicesVersion>
     <SystemRuntimeInteropServicesRuntimeInformationVersion>4.3.0</SystemRuntimeInteropServicesRuntimeInformationVersion>
     <SystemRuntimeSerializationPrimitivesVersion>4.3.0</SystemRuntimeSerializationPrimitivesVersion>
+    <SystemSecurityAccessControlVersion>5.0.0</SystemSecurityAccessControlVersion>
     <SystemSecurityCryptographyAlgorithmsVersion>4.3.1</SystemSecurityCryptographyAlgorithmsVersion>
-    <SystemSecurityCryptographyCngVersion>4.7.0</SystemSecurityCryptographyCngVersion>
-    <SystemSecurityCryptographyOpenSslVersion>4.7.0</SystemSecurityCryptographyOpenSslVersion>
-    <SystemTextJsonVersion>6.0.0-preview.6.21281.1</SystemTextJsonVersion>
-    <SystemRuntimeCompilerServicesUnsafeVersion>6.0.0-preview.6.21281.1</SystemRuntimeCompilerServicesUnsafeVersion>
-    <SystemThreadingVersion>4.3.0</SystemThreadingVersion>
+    <SystemSecurityCryptographyCngVersion>5.0.0</SystemSecurityCryptographyCngVersion>
+    <SystemSecurityCryptographyOpenSslVersion>5.0.0</SystemSecurityCryptographyOpenSslVersion>
+    <SystemSecurityPrincipalWindowsVersion>5.0.0</SystemSecurityPrincipalWindowsVersion>
+    <ServiceModelVersion>4.8.1</ServiceModelVersion>
+    <SystemTextJsonVersion>6.0.0-preview.6.21314.1</SystemTextJsonVersion>
+    <SystemRuntimeCompilerServicesUnsafeVersion>6.0.0-preview.6.21314.1</SystemRuntimeCompilerServicesUnsafeVersion>
     <SystemThreadingTasksExtensionsVersion>4.5.4</SystemThreadingTasksExtensionsVersion>
     <SystemValueTupleVersion>4.5.0</SystemValueTupleVersion>
-    <MicrosoftBclAsyncInterfacesVersion>1.1.1</MicrosoftBclAsyncInterfacesVersion>
-    <MicrosoftWin32PrimitivesVersion>4.3.0</MicrosoftWin32PrimitivesVersion>
-    <runtimenativeSystemIOPortsVersion>6.0.0-preview.6.21281.1</runtimenativeSystemIOPortsVersion>
+    <runtimenativeSystemIOPortsVersion>6.0.0-preview.6.21314.1</runtimenativeSystemIOPortsVersion>
     <!-- Runtime-Assets dependencies -->
-    <SystemComponentModelTypeConverterTestDataVersion>6.0.0-beta.21275.1</SystemComponentModelTypeConverterTestDataVersion>
-    <SystemDrawingCommonTestDataVersion>6.0.0-beta.21275.1</SystemDrawingCommonTestDataVersion>
-    <SystemIOCompressionTestDataVersion>6.0.0-beta.21275.1</SystemIOCompressionTestDataVersion>
-    <SystemIOPackagingTestDataVersion>6.0.0-beta.21275.1</SystemIOPackagingTestDataVersion>
-    <SystemNetTestDataVersion>6.0.0-beta.21275.1</SystemNetTestDataVersion>
-    <SystemPrivateRuntimeUnicodeDataVersion>6.0.0-beta.21275.1</SystemPrivateRuntimeUnicodeDataVersion>
-    <SystemRuntimeTimeZoneDataVersion>6.0.0-beta.21275.1</SystemRuntimeTimeZoneDataVersion>
-    <SystemSecurityCryptographyX509CertificatesTestDataVersion>6.0.0-beta.21275.1</SystemSecurityCryptographyX509CertificatesTestDataVersion>
-    <SystemWindowsExtensionsTestDataVersion>6.0.0-beta.21275.1</SystemWindowsExtensionsTestDataVersion>
+    <SystemRuntimeNumericsTestDataVersion>6.0.0-beta.21314.1</SystemRuntimeNumericsTestDataVersion>
+    <SystemComponentModelTypeConverterTestDataVersion>6.0.0-beta.21307.1</SystemComponentModelTypeConverterTestDataVersion>
+    <SystemDrawingCommonTestDataVersion>6.0.0-beta.21307.1</SystemDrawingCommonTestDataVersion>
+    <SystemIOCompressionTestDataVersion>6.0.0-beta.21307.1</SystemIOCompressionTestDataVersion>
+    <SystemIOPackagingTestDataVersion>6.0.0-beta.21307.1</SystemIOPackagingTestDataVersion>
+    <SystemNetTestDataVersion>6.0.0-beta.21307.1</SystemNetTestDataVersion>
+    <SystemPrivateRuntimeUnicodeDataVersion>6.0.0-beta.21307.1</SystemPrivateRuntimeUnicodeDataVersion>
+    <SystemRuntimeTimeZoneDataVersion>6.0.0-beta.21307.1</SystemRuntimeTimeZoneDataVersion>
+    <SystemSecurityCryptographyX509CertificatesTestDataVersion>6.0.0-beta.21307.1</SystemSecurityCryptographyX509CertificatesTestDataVersion>
+    <SystemWindowsExtensionsTestDataVersion>6.0.0-beta.21307.1</SystemWindowsExtensionsTestDataVersion>
     <!-- dotnet-optimization dependencies -->
-    <optimizationwindows_ntx64MIBCRuntimeVersion>1.0.0-prerelease.21301.4</optimizationwindows_ntx64MIBCRuntimeVersion>
-    <optimizationwindows_ntx86MIBCRuntimeVersion>1.0.0-prerelease.21301.4</optimizationwindows_ntx86MIBCRuntimeVersion>
-    <optimizationlinuxx64MIBCRuntimeVersion>1.0.0-prerelease.21301.4</optimizationlinuxx64MIBCRuntimeVersion>
-    <optimizationPGOCoreCLRVersion>1.0.0-prerelease.21301.4</optimizationPGOCoreCLRVersion>
+    <optimizationwindows_ntx64MIBCRuntimeVersion>1.0.0-prerelease.21313.4</optimizationwindows_ntx64MIBCRuntimeVersion>
+    <optimizationwindows_ntx86MIBCRuntimeVersion>1.0.0-prerelease.21313.4</optimizationwindows_ntx86MIBCRuntimeVersion>
+    <optimizationlinuxx64MIBCRuntimeVersion>1.0.0-prerelease.21313.4</optimizationlinuxx64MIBCRuntimeVersion>
+    <optimizationPGOCoreCLRVersion>1.0.0-prerelease.21313.4</optimizationPGOCoreCLRVersion>
     <!-- Not auto-updated. -->
     <MicrosoftDiaSymReaderNativeVersion>16.9.0-beta1.21055.5</MicrosoftDiaSymReaderNativeVersion>
     <SystemCommandLineVersion>2.0.0-beta1.20253.1</SystemCommandLineVersion>
@@ -137,7 +140,7 @@
       These are used as reference assemblies only, so they must not take a ProdCon/source-build
       version. Insert "RefOnly" to avoid assignment via PVP.
     -->
-    <RefOnlyMicrosoftBuildVersion>16.8.0</RefOnlyMicrosoftBuildVersion>
+    <RefOnlyMicrosoftBuildVersion>16.9.0</RefOnlyMicrosoftBuildVersion>
     <RefOnlyMicrosoftBuildFrameworkVersion>$(RefOnlyMicrosoftBuildVersion)</RefOnlyMicrosoftBuildFrameworkVersion>
     <RefOnlyMicrosoftBuildTasksCoreVersion>$(RefOnlyMicrosoftBuildVersion)</RefOnlyMicrosoftBuildTasksCoreVersion>
     <RefOnlyMicrosoftBuildUtilitiesCoreVersion>$(RefOnlyMicrosoftBuildVersion)</RefOnlyMicrosoftBuildUtilitiesCoreVersion>
@@ -146,9 +149,9 @@
     <!-- Testing -->
     <MicrosoftNETCoreCoreDisToolsVersion>1.0.1-prerelease-00006</MicrosoftNETCoreCoreDisToolsVersion>
     <MicrosoftNETTestSdkVersion>16.9.0-preview-20201201-01</MicrosoftNETTestSdkVersion>
-    <MicrosoftDotNetXHarnessTestRunnersXunitVersion>1.0.0-prerelease.21281.2</MicrosoftDotNetXHarnessTestRunnersXunitVersion>
-    <MicrosoftDotNetXHarnessCLIVersion>1.0.0-prerelease.21281.2</MicrosoftDotNetXHarnessCLIVersion>
-    <MicrosoftDotNetHotReloadUtilsGeneratorBuildToolVersion>1.0.1-alpha.0.21281.1</MicrosoftDotNetHotReloadUtilsGeneratorBuildToolVersion>
+    <MicrosoftDotNetXHarnessTestRunnersXunitVersion>1.0.0-prerelease.21314.1</MicrosoftDotNetXHarnessTestRunnersXunitVersion>
+    <MicrosoftDotNetXHarnessCLIVersion>1.0.0-prerelease.21314.1</MicrosoftDotNetXHarnessCLIVersion>
+    <MicrosoftDotNetHotReloadUtilsGeneratorBuildToolVersion>1.0.1-alpha.0.21311.1</MicrosoftDotNetHotReloadUtilsGeneratorBuildToolVersion>
     <XUnitVersion>2.4.1</XUnitVersion>
     <XUnitRunnerVisualStudioVersion>2.4.2</XUnitRunnerVisualStudioVersion>
     <CoverletCollectorVersion>1.3.0</CoverletCollectorVersion>
@@ -159,23 +162,21 @@
     <!-- Docs -->
     <MicrosoftPrivateIntellisenseVersion>5.0.0-preview-20201009.2</MicrosoftPrivateIntellisenseVersion>
     <!-- ILLink -->
-    <MicrosoftNETILLinkTasksVersion>6.0.100-preview.6.21281.4</MicrosoftNETILLinkTasksVersion>
+    <MicrosoftNETILLinkTasksVersion>6.0.100-preview.6.21310.3</MicrosoftNETILLinkTasksVersion>
     <MicrosoftNETILLinkAnalyzerPackageVersion>$(MicrosoftNETILLinkTasksVersion)</MicrosoftNETILLinkAnalyzerPackageVersion>
     <!-- ICU -->
-    <MicrosoftNETCoreRuntimeICUTransportVersion>6.0.0-preview.6.21281.1</MicrosoftNETCoreRuntimeICUTransportVersion>
+    <MicrosoftNETCoreRuntimeICUTransportVersion>6.0.0-preview.6.21307.1</MicrosoftNETCoreRuntimeICUTransportVersion>
     <!-- Mono LLVM -->
-    <runtimelinuxarm64MicrosoftNETCoreRuntimeMonoLLVMSdkVersion>9.0.1-alpha.1.21281.1</runtimelinuxarm64MicrosoftNETCoreRuntimeMonoLLVMSdkVersion>
-    <runtimelinuxarm64MicrosoftNETCoreRuntimeMonoLLVMToolsVersion>9.0.1-alpha.1.21281.1</runtimelinuxarm64MicrosoftNETCoreRuntimeMonoLLVMToolsVersion>
-    <runtimelinuxx64MicrosoftNETCoreRuntimeMonoLLVMSdkVersion>9.0.1-alpha.1.21281.1</runtimelinuxx64MicrosoftNETCoreRuntimeMonoLLVMSdkVersion>
-    <runtimelinuxx64MicrosoftNETCoreRuntimeMonoLLVMToolsVersion>9.0.1-alpha.1.21281.1</runtimelinuxx64MicrosoftNETCoreRuntimeMonoLLVMToolsVersion>
-    <runtimewinx64MicrosoftNETCoreRuntimeMonoLLVMSdkVersion>9.0.1-alpha.1.21281.1</runtimewinx64MicrosoftNETCoreRuntimeMonoLLVMSdkVersion>
-    <runtimewinx64MicrosoftNETCoreRuntimeMonoLLVMToolsVersion>9.0.1-alpha.1.21281.1</runtimewinx64MicrosoftNETCoreRuntimeMonoLLVMToolsVersion>
-    <runtimeosx1012x64MicrosoftNETCoreRuntimeMonoLLVMSdkVersion>9.0.1-alpha.1.21281.1</runtimeosx1012x64MicrosoftNETCoreRuntimeMonoLLVMSdkVersion>
-    <runtimeosx1012x64MicrosoftNETCoreRuntimeMonoLLVMToolsVersion>9.0.1-alpha.1.21281.1</runtimeosx1012x64MicrosoftNETCoreRuntimeMonoLLVMToolsVersion>
+    <runtimelinuxarm64MicrosoftNETCoreRuntimeMonoLLVMSdkVersion>11.1.0-alpha.1.21308.1</runtimelinuxarm64MicrosoftNETCoreRuntimeMonoLLVMSdkVersion>
+    <runtimelinuxarm64MicrosoftNETCoreRuntimeMonoLLVMToolsVersion>11.1.0-alpha.1.21308.1</runtimelinuxarm64MicrosoftNETCoreRuntimeMonoLLVMToolsVersion>
+    <runtimelinuxx64MicrosoftNETCoreRuntimeMonoLLVMSdkVersion>11.1.0-alpha.1.21308.1</runtimelinuxx64MicrosoftNETCoreRuntimeMonoLLVMSdkVersion>
+    <runtimelinuxx64MicrosoftNETCoreRuntimeMonoLLVMToolsVersion>11.1.0-alpha.1.21308.1</runtimelinuxx64MicrosoftNETCoreRuntimeMonoLLVMToolsVersion>
+    <runtimewinx64MicrosoftNETCoreRuntimeMonoLLVMSdkVersion>11.1.0-alpha.1.21308.1</runtimewinx64MicrosoftNETCoreRuntimeMonoLLVMSdkVersion>
+    <runtimewinx64MicrosoftNETCoreRuntimeMonoLLVMToolsVersion>11.1.0-alpha.1.21308.1</runtimewinx64MicrosoftNETCoreRuntimeMonoLLVMToolsVersion>
+    <runtimeosx1012x64MicrosoftNETCoreRuntimeMonoLLVMSdkVersion>11.1.0-alpha.1.21308.1</runtimeosx1012x64MicrosoftNETCoreRuntimeMonoLLVMSdkVersion>
+    <runtimeosx1012x64MicrosoftNETCoreRuntimeMonoLLVMToolsVersion>11.1.0-alpha.1.21308.1</runtimeosx1012x64MicrosoftNETCoreRuntimeMonoLLVMToolsVersion>
     <!-- emscripten / Node -->
     <MicrosoftNETRuntimeEmscripten2021Nodewinx64Version>6.0.0-preview.6.21275.1</MicrosoftNETRuntimeEmscripten2021Nodewinx64Version>
     <MicrosoftNETRuntimeEmscriptenVersion>$(MicrosoftNETRuntimeEmscripten2021Nodewinx64Version)</MicrosoftNETRuntimeEmscriptenVersion>
   </PropertyGroup>
-  <!-- Override isolated build dependency versions with versions from Repo API. -->
-  <Import Project="$(DotNetPackageVersionPropsPath)" Condition="'$(DotNetPackageVersionPropsPath)' != ''" />
 </Project>
diff --git a/eng/build.ps1 b/eng/build.ps1
index f93182c5bd89e5..5980695e3a2c34 100644
--- a/eng/build.ps1
+++ b/eng/build.ps1
@@ -153,7 +153,7 @@ if ($vs) {
 
     if ($runtimeFlavor -eq "Mono") {
       # Search for the solution in mono
-      $vs = Split-Path $PSScriptRoot -Parent | Join-Path -ChildPath "src\mono\netcore" | Join-Path -ChildPath $vs | Join-Path -ChildPath "$vs.sln"
+      $vs = Split-Path $PSScriptRoot -Parent | Join-Path -ChildPath "src\mono" | Join-Path -ChildPath $vs | Join-Path -ChildPath "$vs.sln"
     } else {
       # Search for the solution in coreclr
       $vs = Split-Path $PSScriptRoot -Parent | Join-Path -ChildPath "src\coreclr" | Join-Path -ChildPath $vs | Join-Path -ChildPath "$vs.sln"
diff --git a/eng/common/dotnet-install.sh b/eng/common/dotnet-install.sh
index d6efeb44340ba1..fdfeea66e7d43f 100755
--- a/eng/common/dotnet-install.sh
+++ b/eng/common/dotnet-install.sh
@@ -70,7 +70,7 @@ case $cpuname in
     ;;
 esac
 
-dotnetRoot="$repo_root/.dotnet"
+dotnetRoot="${repo_root}.dotnet"
 if [[ $architecture != "" ]] && [[ $architecture != $buildarch ]]; then
   dotnetRoot="$dotnetRoot/$architecture"
 fi
diff --git a/eng/common/internal-feed-operations.ps1 b/eng/common/internal-feed-operations.ps1
index 418c09930cf16b..92b77347d9904e 100644
--- a/eng/common/internal-feed-operations.ps1
+++ b/eng/common/internal-feed-operations.ps1
@@ -45,11 +45,11 @@ function SetupCredProvider {
   # Then, we set the 'VSS_NUGET_EXTERNAL_FEED_ENDPOINTS' environment variable to restore from the stable 
   # feeds successfully
 
-  $nugetConfigPath = "$RepoRoot\NuGet.config"
+  $nugetConfigPath = Join-Path $RepoRoot "NuGet.config"
 
   if (-Not (Test-Path -Path $nugetConfigPath)) {
     Write-PipelineTelemetryError -Category 'Build' -Message 'NuGet.config file not found in repo root!'
-    ExitWithExitCode 1  
+    ExitWithExitCode 1
   }
   
   $endpoints = New-Object System.Collections.ArrayList
@@ -85,7 +85,7 @@ function SetupCredProvider {
 
 #Workaround for https://github.com/microsoft/msbuild/issues/4430
 function InstallDotNetSdkAndRestoreArcade {
-  $dotnetTempDir = "$RepoRoot\dotnet"
+  $dotnetTempDir = Join-Path $RepoRoot "dotnet"
   $dotnetSdkVersion="2.1.507" # After experimentation we know this version works when restoring the SDK (compared to 3.0.*)
   $dotnet = "$dotnetTempDir\dotnet.exe"
   $restoreProjPath = "$PSScriptRoot\restore.proj"
diff --git a/eng/common/internal-feed-operations.sh b/eng/common/internal-feed-operations.sh
index e2233e781220f4..9378223ba0955b 100755
--- a/eng/common/internal-feed-operations.sh
+++ b/eng/common/internal-feed-operations.sh
@@ -39,7 +39,7 @@ function SetupCredProvider {
   # Then, we set the 'VSS_NUGET_EXTERNAL_FEED_ENDPOINTS' environment variable to restore from the stable 
   # feeds successfully
 
-  local nugetConfigPath="$repo_root/NuGet.config"
+  local nugetConfigPath="{$repo_root}NuGet.config"
 
   if [ ! "$nugetConfigPath" ]; then
     Write-PipelineTelemetryError -category 'Build' "NuGet.config file not found in repo's root!"
diff --git a/eng/common/sdk-task.ps1 b/eng/common/sdk-task.ps1
index 65f1d75f3d3226..b1bca63ab1d82c 100644
--- a/eng/common/sdk-task.ps1
+++ b/eng/common/sdk-task.ps1
@@ -34,7 +34,7 @@ function Print-Usage() {
 function Build([string]$target) {
   $logSuffix = if ($target -eq 'Execute') { '' } else { ".$target" }
   $log = Join-Path $LogDir "$task$logSuffix.binlog"
-  $outputPath = Join-Path $ToolsetDir "$task\\"
+  $outputPath = Join-Path $ToolsetDir "$task\"
 
   MSBuild $taskProject `
     /bl:$log `
@@ -64,7 +64,7 @@ try {
       $GlobalJson.tools | Add-Member -Name "vs" -Value (ConvertFrom-Json "{ `"version`": `"16.5`" }") -MemberType NoteProperty
     }
     if( -not ($GlobalJson.tools.PSObject.Properties.Name -match "xcopy-msbuild" )) {
-      $GlobalJson.tools | Add-Member -Name "xcopy-msbuild" -Value "16.8.0-preview3" -MemberType NoteProperty
+      $GlobalJson.tools | Add-Member -Name "xcopy-msbuild" -Value "16.10.0-preview2" -MemberType NoteProperty
     }
     if ($GlobalJson.tools."xcopy-msbuild".Trim() -ine "none") {
         $xcopyMSBuildToolsFolder = InitializeXCopyMSBuild $GlobalJson.tools."xcopy-msbuild" -install $true
diff --git a/eng/common/sdl/execute-all-sdl-tools.ps1 b/eng/common/sdl/execute-all-sdl-tools.ps1
index 81b729f74a4d4e..2881a56083cf5e 100644
--- a/eng/common/sdl/execute-all-sdl-tools.ps1
+++ b/eng/common/sdl/execute-all-sdl-tools.ps1
@@ -32,7 +32,7 @@ try {
   $ErrorActionPreference = 'Stop'
   Set-StrictMode -Version 2.0
   $disableConfigureToolsetImport = $true
-  $LASTEXITCODE = 0
+  $global:LASTEXITCODE = 0
 
   # `tools.ps1` checks $ci to perform some actions. Since the SDL
   # scripts don't necessarily execute in the same agent that run the
diff --git a/eng/common/sdl/init-sdl.ps1 b/eng/common/sdl/init-sdl.ps1
index 1fe9271193cc6b..3ac1d92b37006f 100644
--- a/eng/common/sdl/init-sdl.ps1
+++ b/eng/common/sdl/init-sdl.ps1
@@ -10,7 +10,7 @@ Param(
 $ErrorActionPreference = 'Stop'
 Set-StrictMode -Version 2.0
 $disableConfigureToolsetImport = $true
-$LASTEXITCODE = 0
+$global:LASTEXITCODE = 0
 
 # `tools.ps1` checks $ci to perform some actions. Since the SDL
 # scripts don't necessarily execute in the same agent that run the
diff --git a/eng/common/sdl/run-sdl.ps1 b/eng/common/sdl/run-sdl.ps1
index fe95ab35aa5d12..3d9c87aba6acf2 100644
--- a/eng/common/sdl/run-sdl.ps1
+++ b/eng/common/sdl/run-sdl.ps1
@@ -13,7 +13,7 @@ Param(
 $ErrorActionPreference = 'Stop'
 Set-StrictMode -Version 2.0
 $disableConfigureToolsetImport = $true
-$LASTEXITCODE = 0
+$global:LASTEXITCODE = 0
 
 try {
   # `tools.ps1` checks $ci to perform some actions. Since the SDL
diff --git a/eng/common/templates/job/onelocbuild.yml b/eng/common/templates/job/onelocbuild.yml
index 2acdd5256dd83c..e8bc77d2ebbe39 100644
--- a/eng/common/templates/job/onelocbuild.yml
+++ b/eng/common/templates/job/onelocbuild.yml
@@ -18,6 +18,9 @@ parameters:
   LclSource: lclFilesInRepo
   LclPackageId: ''
   RepoType: gitHub
+  GitHubOrg: dotnet
+  MirrorRepo: ''
+  MirrorBranch: main
   condition: ''
 
 jobs:
@@ -66,6 +69,11 @@ jobs:
         ${{ if eq(parameters.RepoType, 'gitHub') }}:
           repoType: ${{ parameters.RepoType }}
           gitHubPatVariable: "${{ parameters.GithubPat }}"
+        ${{ if ne(parameters.MirrorRepo, '') }}:
+          isMirrorRepoSelected: true
+          gitHubOrganization: ${{ parameters.GitHubOrg }}
+          mirrorRepo: ${{ parameters.MirrorRepo }}
+          mirrorBranch: ${{ parameters.MirrorBranch }}
       condition: ${{ parameters.condition }}
 
     - task: PublishBuildArtifacts@1
diff --git a/eng/common/templates/job/source-index-stage1.yml b/eng/common/templates/job/source-index-stage1.yml
index a649d2b5990c01..6e8aa9f7f218b0 100644
--- a/eng/common/templates/job/source-index-stage1.yml
+++ b/eng/common/templates/job/source-index-stage1.yml
@@ -1,6 +1,6 @@
 parameters:
   runAsPublic: false
-  sourceIndexPackageVersion: 1.0.1-20210421.1
+  sourceIndexPackageVersion: 1.0.1-20210614.1
   sourceIndexPackageSource: https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-tools/nuget/v3/index.json
   sourceIndexBuildCommand: powershell -NoLogo -NoProfile -ExecutionPolicy Bypass -Command "eng/common/build.ps1 -restore -build -binarylog -ci"
   preSteps: []
diff --git a/eng/common/tools.ps1 b/eng/common/tools.ps1
index 2d8a74f7d9e89a..5619c7aaee1d7f 100644
--- a/eng/common/tools.ps1
+++ b/eng/common/tools.ps1
@@ -193,38 +193,42 @@ function InitializeDotNetCli([bool]$install, [bool]$createSdkLocationFile) {
   return $global:_DotNetInstallDir = $dotnetRoot
 }
 
+function Retry($downloadBlock, $maxRetries = 5) {
+  $retries = 1
+
+  while($true) {
+    try {
+      & $downloadBlock
+      break
+    }
+    catch {
+      Write-PipelineTelemetryError -Category 'InitializeToolset' -Message $_
+    }
+
+    if (++$retries -le $maxRetries) {
+      $delayInSeconds = [math]::Pow(2, $retries) - 1 # Exponential backoff
+      Write-Host "Retrying. Waiting for $delayInSeconds seconds before next attempt ($retries of $maxRetries)."
+      Start-Sleep -Seconds $delayInSeconds
+    }
+    else {
+      Write-PipelineTelemetryError -Category 'InitializeToolset' -Message "Unable to download file in $maxRetries attempts."
+      break
+    }
+
+  }
+}
+
 function GetDotNetInstallScript([string] $dotnetRoot) {
   $installScript = Join-Path $dotnetRoot 'dotnet-install.ps1'
   if (!(Test-Path $installScript)) {
     Create-Directory $dotnetRoot
     $ProgressPreference = 'SilentlyContinue' # Don't display the console progress UI - it's a huge perf hit
-
-    $maxRetries = 5
-    $retries = 1
-
     $uri = "https://dot.net/$dotnetInstallScriptVersion/dotnet-install.ps1"
 
-    while($true) {
-      try {
-        Write-Host "GET $uri"
-        Invoke-WebRequest $uri -OutFile $installScript
-        break
-      }
-      catch {
-        Write-Host "Failed to download '$uri'"
-        Write-Error $_.Exception.Message -ErrorAction Continue
-      }
-
-      if (++$retries -le $maxRetries) {
-        $delayInSeconds = [math]::Pow(2, $retries) - 1 # Exponential backoff
-        Write-Host "Retrying. Waiting for $delayInSeconds seconds before next attempt ($retries of $maxRetries)."
-        Start-Sleep -Seconds $delayInSeconds
-      }
-      else {
-        throw "Unable to download file in $maxRetries attempts."
-      }
-
-    }
+    Retry({
+      Write-Host "GET $uri"
+      Invoke-WebRequest $uri -OutFile $installScript
+    })
   }
 
   return $installScript
@@ -308,8 +312,8 @@ function InitializeVisualStudioMSBuild([bool]$install, [object]$vsRequirements =
 
   # If the version of msbuild is going to be xcopied,
   # use this version. Version matches a package here:
-  # https://dev.azure.com/dnceng/public/_packaging?_a=package&feed=dotnet-eng&package=RoslynTools.MSBuild&protocolType=NuGet&version=16.8.0-preview3&view=overview
-  $defaultXCopyMSBuildVersion = '16.8.0-preview3'
+  # https://dev.azure.com/dnceng/public/_packaging?_a=package&feed=dotnet-eng&package=RoslynTools.MSBuild&protocolType=NuGet&version=16.10.0-preview2&view=overview
+  $defaultXCopyMSBuildVersion = '16.10.0-preview2'
 
   if (!$vsRequirements) { $vsRequirements = $GlobalJson.tools.vs }
   $vsMinVersionStr = if ($vsRequirements.version) { $vsRequirements.version } else { $vsMinVersionReqdStr }
@@ -403,9 +407,13 @@ function InitializeXCopyMSBuild([string]$packageVersion, [bool]$install) {
     }
 
     Create-Directory $packageDir
+
     Write-Host "Downloading $packageName $packageVersion"
     $ProgressPreference = 'SilentlyContinue' # Don't display the console progress UI - it's a huge perf hit
-    Invoke-WebRequest "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-eng/nuget/v3/flat2/$packageName/$packageVersion/$packageName.$packageVersion.nupkg" -OutFile $packagePath
+    Retry({
+      Invoke-WebRequest "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-eng/nuget/v3/flat2/$packageName/$packageVersion/$packageName.$packageVersion.nupkg" -OutFile $packagePath
+    })
+
     Unzip $packagePath $packageDir
   }
 
@@ -442,27 +450,9 @@ function LocateVisualStudio([object]$vsRequirements = $null){
   if (!(Test-Path $vsWhereExe)) {
     Create-Directory $vsWhereDir
     Write-Host 'Downloading vswhere'
-    $maxRetries = 5
-    $retries = 1
-
-    while($true) {
-      try {
-        Invoke-WebRequest "https://netcorenativeassets.blob.core.windows.net/resource-packages/external/windows/vswhere/$vswhereVersion/vswhere.exe" -OutFile $vswhereExe
-        break
-      }
-      catch{
-        Write-PipelineTelemetryError -Category 'InitializeToolset' -Message $_
-      }
-
-      if (++$retries -le $maxRetries) {
-        $delayInSeconds = [math]::Pow(2, $retries) - 1 # Exponential backoff
-        Write-Host "Retrying. Waiting for $delayInSeconds seconds before next attempt ($retries of $maxRetries)."
-        Start-Sleep -Seconds $delayInSeconds
-      }
-      else {
-        Write-PipelineTelemetryError -Category 'InitializeToolset' -Message "Unable to download file in $maxRetries attempts."
-      }
-    }
+    Retry({
+      Invoke-WebRequest "https://netcorenativeassets.blob.core.windows.net/resource-packages/external/windows/vswhere/$vswhereVersion/vswhere.exe" -OutFile $vswhereExe
+    })
   }
 
   if (!$vsRequirements) { $vsRequirements = $GlobalJson.tools.vs }
@@ -498,7 +488,7 @@ function InitializeBuildTool() {
   if (Test-Path variable:global:_BuildTool) {
     # If the requested msbuild parameters do not match, clear the cached variables.
     if($global:_BuildTool.Contains('ExcludePrereleaseVS') -and $global:_BuildTool.ExcludePrereleaseVS -ne $excludePrereleaseVS) {
-      Remove-Item variable:global:_BuildTool 
+      Remove-Item variable:global:_BuildTool
       Remove-Item variable:global:_MSBuildExe
     } else {
       return $global:_BuildTool
@@ -555,7 +545,7 @@ function GetDefaultMSBuildEngine() {
 
 function GetNuGetPackageCachePath() {
   if ($env:NUGET_PACKAGES -eq $null) {
-    # Use local cache on CI to ensure deterministic build. 
+    # Use local cache on CI to ensure deterministic build.
     # Avoid using the http cache as workaround for https://github.com/NuGet/Home/issues/3116
     # use global cache in dev builds to avoid cost of downloading packages.
     # For directory normalization, see also: https://github.com/NuGet/Home/issues/7968
@@ -712,7 +702,10 @@ function MSBuild-Core() {
   }
 
   foreach ($arg in $args) {
-    if ($arg -ne $null -and $arg.Trim() -ne "") {
+    if ($null -ne $arg -and $arg.Trim() -ne "") {
+      if ($arg.EndsWith('\')) {
+        $arg = $arg + "\"
+      }
       $cmdArgs += " `"$arg`""
     }
   }
@@ -784,7 +777,7 @@ function Get-Darc($version) {
 
 . $PSScriptRoot\pipeline-logging-functions.ps1
 
-$RepoRoot = Resolve-Path (Join-Path $PSScriptRoot '..\..')
+$RepoRoot = Resolve-Path (Join-Path $PSScriptRoot '..\..\')
 $EngRoot = Resolve-Path (Join-Path $PSScriptRoot '..')
 $ArtifactsDir = Join-Path $RepoRoot 'artifacts'
 $ToolsetDir = Join-Path $ArtifactsDir 'toolset'
diff --git a/eng/common/tools.sh b/eng/common/tools.sh
index 5fad1846e5a534..05ca99c6b2813c 100755
--- a/eng/common/tools.sh
+++ b/eng/common/tools.sh
@@ -485,13 +485,14 @@ _script_dir=`dirname "$_ResolvePath"`
 
 eng_root=`cd -P "$_script_dir/.." && pwd`
 repo_root=`cd -P "$_script_dir/../.." && pwd`
-artifacts_dir="$repo_root/artifacts"
+repo_root="${repo_root}/"
+artifacts_dir="${repo_root}artifacts"
 toolset_dir="$artifacts_dir/toolset"
-tools_dir="$repo_root/.tools"
+tools_dir="${repo_root}.tools"
 log_dir="$artifacts_dir/log/$configuration"
 temp_dir="$artifacts_dir/tmp/$configuration"
 
-global_json_file="$repo_root/global.json"
+global_json_file="${repo_root}global.json"
 # determine if global.json contains a "runtimes" entry
 global_json_has_runtimes=false
 if command -v jq &> /dev/null; then
@@ -504,7 +505,7 @@ fi
 
 # HOME may not be defined in some scenarios, but it is required by NuGet
 if [[ -z $HOME ]]; then
-  export HOME="$repo_root/artifacts/.home/"
+  export HOME="${repo_root}artifacts/.home/"
   mkdir -p "$HOME"
 fi
 
diff --git a/eng/native/configurecompiler.cmake b/eng/native/configurecompiler.cmake
index 9a6832c90cfcd9..99a8013d7cf406 100644
--- a/eng/native/configurecompiler.cmake
+++ b/eng/native/configurecompiler.cmake
@@ -43,7 +43,8 @@ set(CMAKE_EXE_LINKER_FLAGS_DEBUG "")
 set(CMAKE_EXE_LINKER_FLAGS_DEBUG "")
 set(CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO "")
 
-add_compile_definitions("$<$<OR:$<CONFIG:DEBUG>,$<CONFIG:CHECKED>>:DEBUG;_DEBUG;_DBG;URTBLDENV_FRIENDLY=Checked;BUILDENV_CHECKED=1>")
+add_compile_definitions("$<$<CONFIG:DEBUG>:DEBUG;_DEBUG;_DBG;URTBLDENV_FRIENDLY=Debug;BUILDENV_DEBUG=1>")
+add_compile_definitions("$<$<CONFIG:CHECKED>:DEBUG;_DEBUG;_DBG;URTBLDENV_FRIENDLY=Checked;BUILDENV_CHECKED=1>")
 add_compile_definitions("$<$<OR:$<CONFIG:RELEASE>,$<CONFIG:RELWITHDEBINFO>>:NDEBUG;URTBLDENV_FRIENDLY=Retail>")
 
 if (MSVC)
diff --git a/eng/native/tryrun.cmake b/eng/native/tryrun.cmake
index 4aac101718111d..96199969da69c9 100644
--- a/eng/native/tryrun.cmake
+++ b/eng/native/tryrun.cmake
@@ -149,6 +149,6 @@ else()
   message(FATAL_ERROR "Arch is ${TARGET_ARCH_NAME}. Only armel, arm, arm64, s390x and x86 are supported!")
 endif()
 
-if(TARGET_ARCH_NAME STREQUAL "x86")
+if(TARGET_ARCH_NAME STREQUAL "x86" OR TARGET_ARCH_NAME STREQUAL "s390x")
   set_cache_value(HAVE_FUNCTIONAL_PTHREAD_ROBUST_MUTEXES_EXITCODE 0)
 endif()
diff --git a/eng/packaging.props b/eng/packaging.props
index 87cecef871a697..534d3ddcf321b4 100644
--- a/eng/packaging.props
+++ b/eng/packaging.props
@@ -16,10 +16,6 @@
   </PropertyGroup>
 
   <PropertyGroup Condition="'$(DotNetBuildFromSource)' == 'true'">
-    <!-- Don't build referenced projects -->
-    <BuildPackageLibraryReferences>false</BuildPackageLibraryReferences>
-    <!-- Omit any files that were not built -->
-    <AllowPartialPackages>true</AllowPartialPackages>
     <!-- Don't permit harvesting since this requires pre-builts -->
     <HarvestStablePackage>false</HarvestStablePackage>
     <!-- Validation will fail in case we were relying on harvested assets or assets not built to satisfy stated support -->
diff --git a/eng/pipelines/common/entitlements.plist b/eng/pipelines/common/entitlements.plist
index f4ea418fb45a8d..168fce4fcd879b 100644
--- a/eng/pipelines/common/entitlements.plist
+++ b/eng/pipelines/common/entitlements.plist
@@ -4,8 +4,6 @@
   <dict>
     <key>com.apple.security.cs.allow-jit</key>
       <true/>
-    <key>com.apple.security.cs.allow-unsigned-executable-memory</key>
-      <true/>
     <key>com.apple.security.cs.allow-dyld-environment-variables</key>
       <true/>
     <key>com.apple.security.cs.disable-library-validation</key>
diff --git a/eng/pipelines/common/templates/runtimes/android-runtime-and-send-to-helix.yml b/eng/pipelines/common/templates/runtimes/android-runtime-and-send-to-helix.yml
index c45d9f2f5d37b1..f42787af8ebd26 100644
--- a/eng/pipelines/common/templates/runtimes/android-runtime-and-send-to-helix.yml
+++ b/eng/pipelines/common/templates/runtimes/android-runtime-and-send-to-helix.yml
@@ -26,7 +26,7 @@ parameters:
   
   
 steps:
-  - script: $(Build.SourcesDirectory)/src/tests/build$(scriptExt) /p:LibrariesConfiguration=${{ parameters.buildConfig }} -ci -excludemonofailures os ${{ parameters.osGroup }} ${{ parameters.archType }} $(buildConfigUpper)
+  - script: $(Build.SourcesDirectory)/src/tests/build$(scriptExt) /p:LibrariesConfiguration=${{ parameters.buildConfig }} -ci -excludemonofailures os ${{ parameters.osGroup }} ${{ parameters.archType }} /p:RuntimeVariant=${{ parameters.runtimeVariant }} $(buildConfigUpper)
     displayName: Build Tests
 
   #  Send tests to Helix
@@ -40,6 +40,7 @@ steps:
       coreClrRepoRoot: $(Build.SourcesDirectory)/src/coreclr
       runtimeFlavorDisplayName: ${{ parameters.runtimeFlavorDisplayName }}
       shouldContinueOnError: ${{ parameters.shouldContinueOnError }}
+      runtimeVariant: ${{ parameters.runtimeVariant }}
 
       ${{ if eq(variables['System.TeamProject'], 'public') }}:
         creator: $(Build.DefinitionName)
diff --git a/eng/pipelines/common/templates/runtimes/build-test-job.yml b/eng/pipelines/common/templates/runtimes/build-test-job.yml
index 50de94ee79c7d0..84cfd8e58ab183 100644
--- a/eng/pipelines/common/templates/runtimes/build-test-job.yml
+++ b/eng/pipelines/common/templates/runtimes/build-test-job.yml
@@ -7,8 +7,7 @@ parameters:
   testGroup: ''
   liveRuntimeBuildConfig: ''
 
-  # When set to a non-empty value (Debug / Release), it determines libraries
-  # build configuration to use for the tests. Setting this property implies
+  # Determines librariesbuild configuration to use for the tests. Setting this property implies
   # a dependency of this job on the appropriate libraries build and is used
   # to construct the name of the Azure artifact representing libraries build
   # to use for building the tests.
@@ -47,9 +46,13 @@ jobs:
     testGroup: ${{ parameters.testGroup }}
     stagedBuild: ${{ parameters.stagedBuild }}
     liveLibrariesBuildConfig: ${{ parameters.liveLibrariesBuildConfig }}
-    variables: ${{ parameters.variables }}
     pool: ${{ parameters.pool }}
     dependOnEvaluatePaths: ${{ parameters.dependOnEvaluatePaths }}
+    liveRuntimeBuildParams: ${{ format('clr.corelib+libs.ref+libs.native -rc {0} -c {1} -arch {2} -ci', coalesce(parameters.liveRuntimeBuildConfig, parameters.buildConfig), parameters.liveLibrariesBuildConfig, parameters.archType) }}
+    ${{ if and(ne(parameters.osGroup, 'windows'), ne(parameters.compilerName, 'gcc'), not(and(eq(parameters.osGroup, 'Linux'), eq(parameters.osSubgroup, '_musl'), eq(parameters.archType, 'x64'))), not(eq(parameters.osGroup, 'OSX'))) }}:
+      compilerArg: '-clang9'
+    ${{ if not(and(ne(parameters.osGroup, 'windows'), ne(parameters.compilerName, 'gcc'), not(and(eq(parameters.osGroup, 'Linux'), eq(parameters.osSubgroup, '_musl'), eq(parameters.archType, 'x64'))), not(eq(parameters.osGroup, 'OSX')))) }}:
+      compilerArg: ''
 
     # Test jobs should continue on error for internal builds
     ${{ if eq(variables['System.TeamProject'], 'internal') }}:
@@ -70,22 +73,31 @@ jobs:
     ${{ if ne(parameters.dependsOn[0], '') }}:
       dependsOn: ${{ parameters.dependsOn }}
 
-    # TODO: Build of managed test components currently depends on the corresponding build job
-    # because it needs System.Private.Corelib; we should be able to remove this dependency
-    # by switching over to using reference assembly.
-    ${{ if and(ne(parameters.stagedBuild, true), eq(parameters.dependsOn[0], '')) }}:
-      dependsOn:
-      - ${{ format('coreclr_{0}_product_build_{1}{2}_{3}_{4}', parameters.runtimeVariant, parameters.osGroup, parameters.osSubgroup, parameters.archType, coalesce(parameters.liveRuntimeBuildConfig, parameters.buildConfig)) }}
-      - ${{ if ne(parameters.liveLibrariesBuildConfig, '') }}:
-        - ${{ format('libraries_build_{0}{1}_{2}_{3}', parameters.osGroup, parameters.osSubgroup, parameters.archType, parameters.liveLibrariesBuildConfig) }}
-
-
     ${{ if in(parameters.testGroup, 'innerloop', 'clrinterpreter') }}:
       timeoutInMinutes: 90
 
     ${{ if notIn(parameters.testGroup, 'innerloop', 'clrinterpreter') }}:
       timeoutInMinutes: 160
 
+    variables:
+      - ${{ each variable in parameters.variables }}:
+        - ${{ variable }}
+      - name: liveRuntimeBuildParams
+        value: ${{ format('clr.corelib+libs.ref+libs.native -rc {0} -c {1} -arch {2} -ci', coalesce(parameters.liveRuntimeBuildConfig, parameters.buildConfig), parameters.liveLibrariesBuildConfig, parameters.archType) }}
+      - name: compilerArg
+        value: ''
+      - ${{ if and(ne(parameters.osGroup, 'windows'), ne(parameters.compilerName, 'gcc')) }}:
+        - name: compilerArg
+          value: '-clang9'
+        # Building for x64 MUSL happens on Alpine Linux and we need to use the stable version available there
+      - ${{ if and(eq(parameters.osGroup, 'Linux'), eq(parameters.osSubgroup, '_musl'), eq(parameters.archType, 'x64')) }}:
+        - name: compilerArg
+          value: ''
+      # AppleClang has different version scheme, so we let complier introspection pick up the available clang from PATH
+      - ${{ if eq(parameters.osGroup, 'OSX') }}:
+        - name: compilerArg
+          value: ''
+
     steps:
 
     # Install test build dependencies
@@ -97,24 +109,9 @@ jobs:
       - script: $(Build.SourcesDirectory)\eng\common\init-tools-native.cmd -InstallDirectory $(Build.SourcesDirectory)\native-tools -Force
         displayName: Install native dependencies
 
-
-    # Optionally download live-built libraries
-    - ${{ if ne(parameters.liveLibrariesBuildConfig, '') }}:
-      - template: /eng/pipelines/common/download-artifact-step.yml
-        parameters:
-          unpackFolder: $(librariesDownloadDir)
-          cleanUnpackFolder: false
-          artifactFileName: '$(librariesBuildArtifactName)$(archiveExtension)'
-          artifactName: '$(librariesBuildArtifactName)'
-          displayName: 'live-built libraries'
-
-    # We need to explictly download CoreCLR, even if building Mono because the CoreCLR tests depend on it
-    - template: /eng/pipelines/common/download-artifact-step.yml
-      parameters:
-        unpackFolder: $(coreClrProductRootFolderPath)
-        artifactFileName: '$(coreClrProductArtifactName)$(archiveExtension)'
-        artifactName: '$(coreClrProductArtifactName)'
-        displayName: 'CoreCLR product build'
+    # Build core/libraries dependencies of test build
+    - script: $(Build.SourcesDirectory)/build$(scriptExt) $(liveRuntimeBuildParams) $(compilerArg)
+      displayName: Build coreclr/libs components needed by test build
 
     - ${{ if in(parameters.osGroup, 'OSX', 'iOS', 'tvOS') }}:
       - script: |
diff --git a/eng/pipelines/common/templates/runtimes/run-test-job.yml b/eng/pipelines/common/templates/runtimes/run-test-job.yml
index e8ca30b4e54e22..fb1a3b55f9afc9 100644
--- a/eng/pipelines/common/templates/runtimes/run-test-job.yml
+++ b/eng/pipelines/common/templates/runtimes/run-test-job.yml
@@ -64,6 +64,8 @@ jobs:
         - '${{ parameters.runtimeFlavor }}_common_test_build_p1_AnyOS_AnyCPU_${{parameters.buildConfig }}'
       - ${{ if ne(parameters.stagedBuild, true) }}:
         - ${{ if or( eq(parameters.runtimeVariant, 'minijit'), eq(parameters.runtimeVariant, 'monointerpreter'))  }}:
+          # This is needed for creating a CORE_ROOT in the current design.
+          - ${{ format('coreclr_{0}_product_build_{1}{2}_{3}_{4}', '', parameters.osGroup, parameters.osSubgroup, parameters.archType, parameters.buildConfig) }}
           # minijit and mono interpreter runtimevariants do not require any special build of the runtime
           - ${{ format('{0}_{1}_product_build_{2}{3}_{4}_{5}', parameters.runtimeFlavor, '', parameters.osGroup, parameters.osSubgroup, parameters.archType, parameters.buildConfig) }}
         - ${{ if not(or(eq(parameters.runtimeVariant, 'minijit'), eq(parameters.runtimeVariant, 'monointerpreter')))  }}:
@@ -102,7 +104,8 @@ jobs:
 
     - ${{ if eq(parameters.readyToRun, true) }}:
       - name: crossgenArg
-        value: 'crossgen'
+      # Switch R2R to use cg2 by default
+        value: 'crossgen2'
       - name: LogNamePrefix
         value: TestRunLogs_R2R
       - ${{ if eq(parameters.crossgen2, true) }}:
@@ -175,6 +178,9 @@ jobs:
         value: 180
       - name: timeoutPerTestInMinutes
         value: 30
+    - ${{ if in(parameters.testGroup, 'pgo') }}:
+      - name: timeoutPerTestCollectionInMinutes
+        value: 120
 
     - ${{ if eq(parameters.compositeBuildMode, true) }}:
       - name: crossgenArg
@@ -188,7 +194,7 @@ jobs:
     # TODO: update these numbers as they were determined long ago
     ${{ if eq(parameters.testGroup, 'innerloop') }}:
       timeoutInMinutes: 200
-    ${{ if in(parameters.testGroup, 'outerloop', 'jit-experimental') }}:
+    ${{ if in(parameters.testGroup, 'outerloop', 'jit-experimental', 'pgo') }}:
       timeoutInMinutes: 270
     ${{ if in(parameters.testGroup, 'gc-longrunning', 'gc-simulator') }}:
       timeoutInMinutes: 480
@@ -320,6 +326,7 @@ jobs:
         osSubgroup: ${{ parameters.osSubgroup}}
         runtimeFlavorDisplayName: ${{ parameters.runtimeFlavorDisplayName }}
         shouldContinueOnError: ${{ parameters.shouldContinueOnError }}
+        runtimeVariant: ${{ parameters.runtimeVariant }}
 
         ${{ if eq(variables['System.TeamProject'], 'public') }}:
           creator: $(Build.DefinitionName)
diff --git a/eng/pipelines/coreclr/superpmi.yml b/eng/pipelines/coreclr/superpmi.yml
index 8219ad02b8387d..d6325d87b74eb9 100644
--- a/eng/pipelines/coreclr/superpmi.yml
+++ b/eng/pipelines/coreclr/superpmi.yml
@@ -77,27 +77,6 @@ jobs:
       collectionType: pmi
       collectionName: libraries
 
-- template: /eng/pipelines/common/platform-matrix.yml
-  parameters:
-    jobTemplate: /eng/pipelines/coreclr/templates/superpmi-job.yml
-    buildConfig: checked
-    platforms:
-    # Linux tests are built on the OSX machines.
-    # - OSX_x64
-    - Linux_arm
-    - Linux_arm64
-    - Linux_x64
-    - windows_x64
-    - windows_x86
-    - windows_arm64
-    helixQueueGroup: ci
-    helixQueuesTemplate: /eng/pipelines/coreclr/templates/helix-queues-setup.yml
-    jobParameters:
-      testGroup: outerloop
-      liveLibrariesBuildConfig: Release
-      collectionType: crossgen
-      collectionName: libraries
-
 - template: /eng/pipelines/common/platform-matrix.yml
   parameters:
     jobTemplate: /eng/pipelines/coreclr/templates/superpmi-job.yml
diff --git a/eng/pipelines/coreclr/templates/build-job.yml b/eng/pipelines/coreclr/templates/build-job.yml
index 57c4134736d440..699983fa0c38c6 100644
--- a/eng/pipelines/coreclr/templates/build-job.yml
+++ b/eng/pipelines/coreclr/templates/build-job.yml
@@ -243,7 +243,8 @@ jobs:
           /p:DiagnosticsFilesRoot="$(buildProductRootFolderPath)"
           /p:SignDiagnostics=true
           /p:DotNetSignType=$(SignType)
-          /bl:$(Build.SourcesDirectory)artifacts/log/$(buildConfig)/SignDiagnostics.binlog
+          -noBl
+          /bl:$(Build.SourcesDirectory)/artifacts/log/$(buildConfig)/SignDiagnostics.binlog
           -projects $(Build.SourcesDirectory)\eng\empty.csproj
         displayName: Sign Diagnostic Binaries
 
diff --git a/eng/pipelines/coreclr/templates/helix-queues-setup.yml b/eng/pipelines/coreclr/templates/helix-queues-setup.yml
index 9312c4ac7d93d1..45c309f3ba863f 100644
--- a/eng/pipelines/coreclr/templates/helix-queues-setup.yml
+++ b/eng/pipelines/coreclr/templates/helix-queues-setup.yml
@@ -49,12 +49,12 @@ jobs:
     # Linux arm64
     - ${{ if eq(parameters.platform, 'Linux_arm64') }}:
       - ${{ if eq(variables['System.TeamProject'], 'public') }}:
-        - (Ubuntu.1804.Arm64.Open)Ubuntu.1804.Armarch.Open@mcr.microsoft.com/dotnet-buildtools/prereqs:ubuntu-18.04-helix-arm64v8-a45aeeb-20190620155855
+        - (Ubuntu.1804.Arm64.Open)Ubuntu.1804.Armarch.Open@mcr.microsoft.com/dotnet-buildtools/prereqs:ubuntu-18.04-helix-arm64v8-20210531091519-97d8652
       - ${{ if and(eq(variables['System.TeamProject'], 'public'), notIn(parameters.jobParameters.helixQueueGroup, 'pr', 'ci', 'libraries')) }}:
         - (Debian.9.Arm64.Open)Ubuntu.1804.Armarch.Open@mcr.microsoft.com/dotnet-buildtools/prereqs:debian-9-helix-arm64v8-bfcd90a-20200121150055
       - ${{ if eq(variables['System.TeamProject'], 'internal') }}:
         - (Debian.9.Arm64)Ubuntu.1804.ArmArch@mcr.microsoft.com/dotnet-buildtools/prereqs:debian-9-helix-arm64v8-bfcd90a-20200121150055
-        - (Ubuntu.1804.Arm64)Ubuntu.1804.ArmArch@mcr.microsoft.com/dotnet-buildtools/prereqs:ubuntu-18.04-helix-arm64v8-a45aeeb-20190620155855
+        - (Ubuntu.1804.Arm64)Ubuntu.1804.ArmArch@mcr.microsoft.com/dotnet-buildtools/prereqs:ubuntu-18.04-helix-arm64v8-20210531091519-97d8652
 
     # Linux musl x64
     - ${{ if eq(parameters.platform, 'Linux_musl_x64') }}:
diff --git a/eng/pipelines/coreclr/templates/run-performance-job.yml b/eng/pipelines/coreclr/templates/run-performance-job.yml
index 87832c2e9ec100..de523bb2d99e61 100644
--- a/eng/pipelines/coreclr/templates/run-performance-job.yml
+++ b/eng/pipelines/coreclr/templates/run-performance-job.yml
@@ -57,7 +57,7 @@ jobs:
     - HelixApiAccessToken: ''
     - HelixPreCommandStemWindows: 'py -m pip install -U pip;py -3 -m venv %HELIX_WORKITEM_PAYLOAD%\.venv;call %HELIX_WORKITEM_PAYLOAD%\.venv\Scripts\activate.bat;set PYTHONPATH=;py -3 -m pip install -U pip;py -3 -m pip install azure.storage.blob==12.0.0;py -3 -m pip install azure.storage.queue==12.0.0;set "PERFLAB_UPLOAD_TOKEN=$(PerfCommandUploadToken)"'
     - HelixPreCommandStemLinux: 'python3 -m pip install -U pip;sudo apt-get -y install python3-venv;python3 -m venv $HELIX_WORKITEM_PAYLOAD/.venv;source $HELIX_WORKITEM_PAYLOAD/.venv/Scripts/activate;export PYTHONPATH=;python3 -m pip install -U pip;pip3 install azure.storage.blob==12.0.0;pip3 install azure.storage.queue==12.0.0;sudo apt-get update;sudo apt -y install curl dirmngr apt-transport-https lsb-release ca-certificates;curl -sL https://deb.nodesource.com/setup_12.x | sudo -E bash -;sudo apt-get -y install nodejs;sudo apt-get -y install npm;npm install --prefix $HELIX_WORKITEM_PAYLOAD jsvu -g;$HELIX_WORKITEM_PAYLOAD/bin/jsvu --os=linux64 --engines=v8,javascriptcore;export PERFLAB_UPLOAD_TOKEN="$(PerfCommandUploadTokenLinux)"'
-    - HelixPreCommandStemMsul: 'sudo apk add icu-libs krb5-libs libgcc libintl libssl1.1 libstdc++ zlib;sudo apk add cargo --repository http://sjc.edge.kernel.org/alpine/edge/community ;sudo apk add libgdiplus --repository http://dl-cdn.alpinelinux.org/alpine/edge/testing; python3 -m venv $HELIX_WORKITEM_PAYLOAD/.venv;source $HELIX_WORKITEM_PAYLOAD/.venv/bin/activate;export PYTHONPATH=;python3 -m pip install -U pip;pip3 install azure.storage.blob==12.7.1;pip3 install azure.storage.queue==12.1.5;export PERFLAB_UPLOAD_TOKEN="$(PerfCommandUploadTokenLinux)"'
+    - HelixPreCommandStemMsul: 'sudo apk add icu-libs krb5-libs libgcc libintl libssl1.1 libstdc++ zlib;sudo apk add cargo --repository http://dl-cdn.alpinelinux.org/alpine/v3.12/community ;sudo apk add libgdiplus --repository http://dl-cdn.alpinelinux.org/alpine/edge/testing; python3 -m venv $HELIX_WORKITEM_PAYLOAD/.venv;source $HELIX_WORKITEM_PAYLOAD/.venv/bin/activate;export PYTHONPATH=;python3 -m pip install -U pip;pip3 install azure.storage.blob==12.7.1;pip3 install azure.storage.queue==12.1.5;export PERFLAB_UPLOAD_TOKEN="$(PerfCommandUploadTokenLinux)"'
     - ExtraMSBuildLogsWindows: 'set MSBUILDDEBUGCOMM=1;set "MSBUILDDEBUGPATH=%HELIX_WORKITEM_UPLOAD_ROOT%"'
     - ExtraMSBuildLogsLinux: 'export MSBUILDDEBUGCOMM=1;export "MSBUILDDEBUGPATH=$HELIX_WORKITEM_UPLOAD_ROOT"'
     - HelixPreCommand: ''
diff --git a/eng/pipelines/libraries/base-job.yml b/eng/pipelines/libraries/base-job.yml
index bea30446deed64..9c5cff7cc5e81f 100644
--- a/eng/pipelines/libraries/base-job.yml
+++ b/eng/pipelines/libraries/base-job.yml
@@ -80,7 +80,6 @@ jobs:
         - ${{ if eq(parameters.framework, 'allConfigurations') }}:
           - _finalFrameworkArg: -allConfigurations
           - _testModeArg: /p:TestAssemblies=false /p:TestPackages=true
-          - _extraHelixArguments: /p:TestPackages=true
 
         - ${{ if eq(parameters.isOfficialAllConfigurations, true) }}:
           - librariesBuildArtifactName: 'libraries_bin_official_allconfigurations'
diff --git a/eng/pipelines/libraries/build-job.yml b/eng/pipelines/libraries/build-job.yml
index ee0c0fc938f696..11fdde6316dae7 100644
--- a/eng/pipelines/libraries/build-job.yml
+++ b/eng/pipelines/libraries/build-job.yml
@@ -29,6 +29,7 @@ parameters:
   variables: {}
   pool: ''
   runTests: false
+  useHelix: true
   testScope: ''
   testBuildPlatforms: []
 
@@ -66,6 +67,7 @@ jobs:
       variables:
         - librariesTestsArtifactName: ${{ format('libraries_test_assets_{0}_{1}_{2}', parameters.osGroup, parameters.archType, parameters.buildConfig) }}
         - _subset: libs
+        - _buildAction: ''
         - _additionalBuildArguments: ''
         - ${{ parameters.variables }}
 
@@ -73,7 +75,10 @@ jobs:
         # If platform is in testBuildPlatforms we build tests as well.
         - ${{ if or(eq(parameters.runTests, true), containsValue(parameters.testBuildPlatforms, parameters.platform)) }}:
           - _subset: libs+libs.tests
-          - _additionalBuildArguments: /p:ArchiveTests=true
+          - ${{ if eq(parameters.useHelix, false) }}:
+            - _buildAction: -restore -build -test
+          - ${{ if eq(parameters.useHelix, true) }}:
+            - _additionalBuildArguments: /p:ArchiveTests=true
 
         - ${{ parameters.variables }}
 
@@ -92,6 +97,7 @@ jobs:
 
         - script: $(_buildScript)
                 -subset $(_subset)
+                $(_buildAction)
                 $(_buildArguments)
                 $(_additionalBuildArguments)
           displayName: Restore and Build Product
@@ -136,7 +142,7 @@ jobs:
               parameters:
                 name: Libraries_AllConfigurations
 
-        - ${{ if eq(parameters.runTests, true) }}:
+        - ${{ if and(eq(parameters.runTests, true), eq(parameters.useHelix, true)) }}:
           - template: /eng/pipelines/libraries/helix.yml
             parameters:
               osGroup: ${{ parameters.osGroup }}
diff --git a/eng/pipelines/libraries/helix-queues-setup.yml b/eng/pipelines/libraries/helix-queues-setup.yml
index 7cea78b1a5f3c7..b766f1af96aecb 100644
--- a/eng/pipelines/libraries/helix-queues-setup.yml
+++ b/eng/pipelines/libraries/helix-queues-setup.yml
@@ -128,7 +128,7 @@ jobs:
     # windows x64
     - ${{ if eq(parameters.platform, 'windows_x64') }}:
       # netcoreapp
-      - ${{ if notIn(parameters.jobParameters.framework, 'allConfigurations', 'net48') }}:
+      - ${{ if notIn(parameters.jobParameters.framework, 'net48') }}:
         - ${{ if and(eq(parameters.jobParameters.testScope, 'outerloop'), eq(parameters.jobParameters.runtimeFlavor, 'mono')) }}:
           - Windows.81.Amd64.Open
           - Windows.10.Amd64.Server19H1.Open
@@ -152,14 +152,10 @@ jobs:
       - ${{ if eq(parameters.jobParameters.framework, 'net48') }}:
         - Windows.10.Amd64.Client19H1.Open
 
-      # AllConfigurations
-      - ${{ if eq(parameters.jobParameters.framework, 'allConfigurations') }}:
-        - Windows.10.Amd64.Server19H1.Open
-
     # windows x86
     - ${{ if eq(parameters.platform, 'windows_x86') }}:
       # netcoreapp
-      - ${{ if notIn(parameters.jobParameters.framework, 'allConfigurations', 'net48') }}:
+      - ${{ if notIn(parameters.jobParameters.framework, 'net48') }}:
         - ${{ if and(eq(parameters.jobParameters.testScope, 'outerloop'), eq(parameters.jobParameters.runtimeFlavor, 'mono')) }}:
           - Windows.7.Amd64.Open
           - Windows.10.Amd64.ServerRS5.Open
diff --git a/eng/pipelines/runtime-staging.yml b/eng/pipelines/runtime-staging.yml
index eaaa9e08fe2c50..2352995df910a5 100644
--- a/eng/pipelines/runtime-staging.yml
+++ b/eng/pipelines/runtime-staging.yml
@@ -257,47 +257,43 @@ jobs:
           eq(variables['isFullMatrix'], true))
 
 #
-# Build the whole product using Mono and run libraries tests
+# Build the whole product using Mono for Android and run runtime tests with interpreter
 #
 - template: /eng/pipelines/common/platform-matrix.yml
   parameters:
     jobTemplate: /eng/pipelines/common/global-build-job.yml
-    helixQueuesTemplate: /eng/pipelines/libraries/helix-queues-setup.yml
+    helixQueuesTemplate: /eng/pipelines/coreclr/templates/helix-queues-setup.yml
     buildConfig: Release
     runtimeFlavor: mono
     platforms:
-    - Browser_wasm
+    - Android_x64
     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'] ]
+      - ${{ 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: 60
+      - name: timeoutPerTestCollectionInMinutes
+        value: 180
     jobParameters:
       testGroup: innerloop
-      nameSuffix: AllSubsets_Mono_AOT
-      buildArgs: -s mono+libs+host+packs+libs.tests -c $(_BuildConfig) /p:ArchiveTests=true /p:EnableAggressiveTrimming=true /p:BuildAOTTestsOnHelix=true /p:RunAOTCompilation=true
-      timeoutInMinutes: 180
+      nameSuffix: AllSubsets_Mono_RuntimeTests
+      buildArgs: -s mono+libs -c $(_BuildConfig)
+      timeoutInMinutes: 240
+      runtimeVariant: monointerpreter
       condition: >-
         or(
-          eq(dependencies.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
+          eq(dependencies.evaluate_paths.outputs['SetPathVars_runtimetests.containsChange'], true),
           eq(dependencies.evaluate_paths.outputs['SetPathVars_mono.containsChange'], true),
-          eq(dependencies.evaluate_paths.outputs['SetPathVars_installer.containsChange'], true),
           eq(variables['isFullMatrix'], true))
       # extra steps, run tests
-      extraStepsTemplate: /eng/pipelines/libraries/helix.yml
+      extraStepsTemplate: /eng/pipelines/common/templates/runtimes/android-runtime-and-send-to-helix.yml
       extraStepsParameters:
         creator: dotnet-bot
         testRunNamePrefixSuffix: Mono_$(_BuildConfig)
-        extraHelixArguments: /p:NeedsToBuildWasmAppsOnHelix=true
-        scenarios:
-        - normal
-        condition: >-
-          or(
-          eq(variables['librariesContainsChange'], true),
-          eq(variables['monoContainsChange'], true),
-          eq(variables['isFullMatrix'], true))
-
 
 #
 # Build the whole product using Mono for Android and run runtime tests with Android devices
@@ -309,7 +305,7 @@ jobs:
     buildConfig: Release
     runtimeFlavor: mono
     platforms:
-    #- Android_arm64  # disabled due to https://github.com/dotnet/runtime/issues/47850
+    - Android_arm64
     variables:
       - ${{ if and(eq(variables['System.TeamProject'], 'public'), eq(variables['Build.Reason'], 'PullRequest')) }}:
         - name: _HelixSource
@@ -331,11 +327,13 @@ jobs:
           eq(dependencies.evaluate_paths.outputs['SetPathVars_runtimetests.containsChange'], true),
           eq(dependencies.evaluate_paths.outputs['SetPathVars_mono.containsChange'], true),
           eq(variables['isFullMatrix'], true))
-      # extra steps, run tests
-      extraStepsTemplate: /eng/pipelines/common/templates/runtimes/android-runtime-and-send-to-helix.yml
-      extraStepsParameters:
-        creator: dotnet-bot
-        testRunNamePrefixSuffix: Mono_$(_BuildConfig)
+      # don't run tests on PRs until we can get significantly more devices
+      ${{ if eq(variables['isFullMatrix'], true) }}:
+        # extra steps, run tests
+        extraStepsTemplate: /eng/pipelines/common/templates/runtimes/android-runtime-and-send-to-helix.yml
+        extraStepsParameters:
+          creator: dotnet-bot
+          testRunNamePrefixSuffix: Mono_$(_BuildConfig)
 
 # Run disabled installer tests on Linux x64
 - template: /eng/pipelines/common/platform-matrix.yml
diff --git a/eng/pipelines/runtime.yml b/eng/pipelines/runtime.yml
index 818fb1360a8863..931a65a05e11ee 100644
--- a/eng/pipelines/runtime.yml
+++ b/eng/pipelines/runtime.yml
@@ -347,6 +347,48 @@ jobs:
           eq(variables['monoContainsChange'], true),
           eq(variables['isFullMatrix'], 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
+    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: AllSubsets_Mono_AOT
+      buildArgs: -s mono+libs+host+packs+libs.tests -c $(_BuildConfig) /p:ArchiveTests=true /p:EnableAggressiveTrimming=true /p:BuildAOTTestsOnHelix=true /p:RunAOTCompilation=true
+      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),
+          eq(variables['isFullMatrix'], true))
+      # extra steps, run tests
+      extraStepsTemplate: /eng/pipelines/libraries/helix.yml
+      extraStepsParameters:
+        creator: dotnet-bot
+        testRunNamePrefixSuffix: Mono_$(_BuildConfig)
+        extraHelixArguments: /p:NeedsToBuildWasmAppsOnHelix=true
+        scenarios:
+        - normal
+        condition: >-
+          or(
+          eq(variables['librariesContainsChange'], true),
+          eq(variables['monoContainsChange'], true),
+          eq(variables['isFullMatrix'], true))
+
 # Build and test libraries under single-file publishing
 - template: /eng/pipelines/common/platform-matrix.yml
   parameters:
@@ -758,11 +800,11 @@ jobs:
     buildConfig: ${{ variables.debugOnPrReleaseOnRolling }}
     platforms:
     - windows_x64
-    helixQueuesTemplate: /eng/pipelines/libraries/helix-queues-setup.yml
     jobParameters:
       isFullMatrix: ${{ variables.isFullMatrix }}
       framework: allConfigurations
       runTests: true
+      useHelix: false
       condition: >-
         or(
           eq(dependencies.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
diff --git a/eng/references.targets b/eng/references.targets
index 42763624c5eded..6adcba93322895 100644
--- a/eng/references.targets
+++ b/eng/references.targets
@@ -7,13 +7,6 @@
     <_FindDependencies>false</_FindDependencies>
   </PropertyGroup>
 
-  <!-- netstandard is a default reference whenever building an implementation assembly for .NETCoreApp. -->
-  <ItemGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp' and
-                        '$(IsSourceProject)' == 'true'">
-    <Reference Include="netstandard"
-               Private="false" />
-  </ItemGroup>
-
    <!-- If a CoreLib ProjectReference is present, make all P2P assets non transitive. -->
   <ItemGroup Condition="'@(ProjectReference)' != '' and
                          @(ProjectReference->AnyHaveMetadataValue('Identity', '$(CoreLibProject)'))">
diff --git a/eng/resolveContract.targets b/eng/resolveContract.targets
index f41be687441991..d98ef8dffb7bd7 100644
--- a/eng/resolveContract.targets
+++ b/eng/resolveContract.targets
@@ -3,6 +3,8 @@
     <!-- Use implementation referencepath if no contract dependency path is set.
          This item transform is executed at the time this property is evaluated in the API Compat targets. -->
     <ContractDependencyPaths Condition="'$(ContractDependencyPaths)' == ''">@(ReferencePath->'%(RelativeDir)'->Distinct())</ContractDependencyPaths>
+    <!-- Fall back to the targeting pack dir for NetCoreAppCurrent to avoid passing through dependencies from ref to src. -->
+    <ContractDependencyPaths Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', '$(NetCoreAppCurrent)'))">$(ContractDependencyPaths);$(MicrosoftNetCoreAppRefPackRefDir)</ContractDependencyPaths>
   </PropertyGroup>
 
   <PropertyGroup Condition="'$(IsSourceProject)' == 'true'">
diff --git a/eng/restore/harvestPackages.targets b/eng/restore/harvestPackages.targets
index a7fc8aa34655f5..07eb5a91a7a8ed 100644
--- a/eng/restore/harvestPackages.targets
+++ b/eng/restore/harvestPackages.targets
@@ -1,4 +1,14 @@
 <Project InitialTargets="AddPackageDownload">
+
+  <PropertyGroup>
+    <PackagingTaskAssembly>$(NuGetPackageRoot)microsoft.dotnet.build.tasks.packaging\$(MicrosoftDotNetBuildTasksPackagingVersion)\tools\</PackagingTaskAssembly>
+    <PackagingTaskAssembly Condition="'$(MSBuildRuntimeType)' == 'core'">$(PackagingTaskAssembly)netcoreapp3.1\</PackagingTaskAssembly>
+    <PackagingTaskAssembly Condition="'$(MSBuildRuntimeType)' != 'core'">$(PackagingTaskAssembly)net472\</PackagingTaskAssembly>
+    <!-- TODO: Remove when https://github.com/dotnet/arcade/issues/7413 is fixed. -->
+    <PackagingTaskAssembly Condition="'$(MSBuildRuntimeType)' == 'core' and '$(DotNetBuildFromSource)' == 'true'">$(PackagingTaskAssembly)net5.0\</PackagingTaskAssembly>
+    <PackagingTaskAssembly>$(PackagingTaskAssembly)Microsoft.DotNet.Build.Tasks.Packaging.dll</PackagingTaskAssembly>
+  </PropertyGroup>
+
   <UsingTask TaskName="GetLastStablePackage" AssemblyFile="$(PackagingTaskAssembly)"/>
   <Target Name="AddPackageDownload">
     <ItemGroup>
diff --git a/eng/targetingpacks.targets b/eng/targetingpacks.targets
index da9407c5090d0c..f80b26fb984456 100644
--- a/eng/targetingpacks.targets
+++ b/eng/targetingpacks.targets
@@ -1,11 +1,21 @@
+<!--
+  The following properties need to be set for this logic to work correctly:
+  - ProductVersion
+  - NetCoreAppCurrent
+  - NetCoreAppCurrentVersion
+  - MicrosoftNetCoreAppFrameworkName
+  - MicrosoftNetCoreAppRefPackDir
+  - optional: MicrosoftNetCoreAppRuntimePackDir
+-->
+
 <Project>
   <PropertyGroup>
-    <LocalFrameworkOverrideName Condition="'$(LocalFrameworkOverrideName)' == ''">$(MicrosoftNetCoreAppFrameworkName)</LocalFrameworkOverrideName>
+    <LocalFrameworkOverrideName>$(MicrosoftNetCoreAppFrameworkName)</LocalFrameworkOverrideName>
   </PropertyGroup>
 
   <PropertyGroup Condition="'$(DisableImplicitFrameworkReferences)' != 'true' and
                             '$(TargetFrameworkIdentifier)' == '.NETCoreApp' and
-                            $([MSBuild]::VersionGreaterThanOrEquals($(TargetFrameworkVersion), '$(NETCoreAppCurrentVersion)'))">
+                            $([MSBuild]::VersionGreaterThanOrEquals($(TargetFrameworkVersion), '$(NetCoreAppCurrentVersion)'))">
     <UseLocalTargetingRuntimePack Condition="'$(UseLocalTargetingRuntimePack)' == ''">true</UseLocalTargetingRuntimePack>
     <EnableTargetingPackDownload>false</EnableTargetingPackDownload>
     <GenerateErrorForMissingTargetingPacks>false</GenerateErrorForMissingTargetingPacks>
@@ -15,15 +25,22 @@
   <ItemGroup Condition="'$(UseLocalTargetingRuntimePack)' == 'true'">
     <KnownFrameworkReference Include="$(LocalFrameworkOverrideName)"
                              DefaultRuntimeFrameworkVersion="$(ProductVersion)"
-                             IsTrimmable="true"
                              LatestRuntimeFrameworkVersion="$(ProductVersion)"
                              RuntimeFrameworkName="$(LocalFrameworkOverrideName)"
                              RuntimePackNamePatterns="$(LocalFrameworkOverrideName).Runtime.**RID**"
-                             RuntimePackRuntimeIdentifiers="linux-arm;linux-arm64;linux-musl-arm64;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;ios-arm64;iossimulator-arm64;ios-arm;iossimulator-x64;iossimulator-x86;tvos-arm64;tvossimulator-arm64;tvossimulator-x64;maccatalyst-x64;maccatalyst-arm64;android-arm64;android-arm;android-x64;android-x86;browser-wasm;osx-arm64"
+                             RuntimePackRuntimeIdentifiers="linux-arm;linux-arm64;linux-musl-arm64;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;maccatalyst-x64;maccatalyst-arm64"
                              TargetFramework="$(NetCoreAppCurrent)"
                              TargetingPackName="$(LocalFrameworkOverrideName).Ref"
                              TargetingPackVersion="$(ProductVersion)"
                              Condition="'@(KnownFrameworkReference)' == '' or !@(KnownFrameworkReference->AnyHaveMetadataValue('TargetFramework', '$(NetCoreAppCurrent)'))" />
+    <KnownRuntimePack Include="$(LocalFrameworkOverrideName)"
+                      TargetFramework="$(NetCoreAppCurrent)"
+                      RuntimeFrameworkName="$(LocalFrameworkOverrideName)"
+                      LatestRuntimeFrameworkVersion="$(ProductVersion)"
+                      RuntimePackNamePatterns="$(LocalFrameworkOverrideName).Runtime.Mono.**RID**"
+                      RuntimePackRuntimeIdentifiers="linux-arm;linux-arm64;linux-musl-arm64;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="$(ProductVersion)"
@@ -38,22 +55,6 @@
                         Condition="'@(KnownCrossgen2Pack)' == '' or !@(KnownCrossgen2Pack->AnyHaveMetadataValue('TargetFramework', '$(NetCoreAppCurrent)'))" />
   </ItemGroup>
 
-  <!-- .NETCoreApp 2.x DisableImplicitAssemblyReferences support. -->
-  <Choose>
-    <When Condition="'$(DisableImplicitAssemblyReferences)' == 'true' and
-                     '$(TargetFrameworkIdentifier)' == '.NETCoreApp' and
-                     $([MSBuild]::VersionLessThan($(TargetFrameworkVersion), '3.0'))">
-    <PropertyGroup>
-      <MicrosoftNetCoreAppRefPackRefDir>$(PkgMicrosoft_NETCore_App)\ref\netcoreapp$(TargetFrameworkVersion.TrimStart('v'))\</MicrosoftNetCoreAppRefPackRefDir>
-    </PropertyGroup>
-    <ItemGroup>
-      <PackageReference Update="Microsoft.NETCore.App"
-                        ExcludeAssets="all"
-                        GeneratePathProperty="true" />
-    </ItemGroup>
-    </When>
-  </Choose>
-
   <!-- Simple name references will be resolved from the targeting pack folders and should never be copied to the output. -->
   <ItemGroup>
     <Reference Update="@(Reference)">
@@ -61,13 +62,12 @@
     </Reference>
   </ItemGroup>
 
-  <!-- .NETCoreApp > 2.x DisableImplicitAssemblyReferences support. -->
+  <!-- DisableImplicitAssemblyReferences support. -->
   <Target Name="RemoveFrameworkReferences"
           BeforeTargets="_HandlePackageFileConflicts"
           AfterTargets="ResolveTargetingPackAssets"
           Condition="'$(DisableImplicitAssemblyReferences)' == 'true' and
-                     '$(TargetFrameworkIdentifier)' == '.NETCoreApp' and
-                     $([MSBuild]::VersionGreaterThanOrEquals($(TargetFrameworkVersion), '3.0'))">
+                     '$(TargetFrameworkIdentifier)' == '.NETCoreApp'">
     <!-- Point MicrosoftNetCoreAppRefPackRefDir to the acquired targeting pack to use it later for AssemblySearchPaths resolution. -->
     <PropertyGroup Condition="'$(UseLocalTargetingRuntimePack)' != 'true'">
       <_NetCoreAppTargetFrameworkIdentifier Condition="$([MSBuild]::VersionLessThan($(TargetFrameworkVersion), '5.0'))">netcoreapp</_NetCoreAppTargetFrameworkIdentifier>
@@ -112,9 +112,10 @@
                              NuGetPackageVersion="$(ProductVersion)"
                              PackageDirectory="$(MicrosoftNetCoreAppRefPackDir.TrimEnd('/\'))"
                              Condition="'%(ResolvedTargetingPack.RuntimeFrameworkName)' == '$(LocalFrameworkOverrideName)' and
-                                        Exists('$(MicrosoftNetCoreAppRefPackDataDir)FrameworkList.xml')" />
+                                        Exists('$(MicrosoftNetCoreAppRefPackDir)data\FrameworkList.xml')" />
       <ResolvedRuntimePack PackageDirectory="$(MicrosoftNetCoreAppRuntimePackDir)"
-                           Condition="'%(ResolvedRuntimePack.FrameworkName)' == '$(LocalFrameworkOverrideName)'" />
+                           Condition="'$(MicrosoftNetCoreAppRuntimePackDir)' != '' and
+                                      '%(ResolvedRuntimePack.FrameworkName)' == '$(LocalFrameworkOverrideName)'" />
       <ResolvedFrameworkReference TargetingPackPath="$(MicrosoftNetCoreAppRefPackDir.TrimEnd('/\'))"
                                   TargetingPackVersion="$(ProductVersion)"
                                   Condition="'%(Identity)' == '$(LocalFrameworkOverrideName)'" />
diff --git a/eng/testing/linker/SupportFiles/Directory.Build.props b/eng/testing/linker/SupportFiles/Directory.Build.props
index c1220c719b9af8..760ff6d86e8102 100644
--- a/eng/testing/linker/SupportFiles/Directory.Build.props
+++ b/eng/testing/linker/SupportFiles/Directory.Build.props
@@ -21,5 +21,8 @@
 
   <ItemGroup>
     <FrameworkReference Include="Microsoft.NETCore.App" />
+    <FrameworkReference Update="Microsoft.NETCore.App"
+                        RuntimePackLabels="Mono"
+                        Condition="'$(UseMonoRuntime)' == 'true'" />
   </ItemGroup>
 </Project>
diff --git a/eng/testing/linker/project.csproj.template b/eng/testing/linker/project.csproj.template
index 95298969cf61ad..7f8ccaba794415 100644
--- a/eng/testing/linker/project.csproj.template
+++ b/eng/testing/linker/project.csproj.template
@@ -10,6 +10,7 @@
     <RepositoryEngineeringDir>{RepositoryEngineeringDir}</RepositoryEngineeringDir>
     <TargetFramework>{NetCoreAppCurrent}</TargetFramework>
     <RuntimeIdentifier>{RuntimeIdentifier}</RuntimeIdentifier>
+    <UseMonoRuntime>{UseMonoRuntime}</UseMonoRuntime>
     <TargetingPackDir>{TargetingPackDir}</TargetingPackDir>
     <NETCoreAppMaximumVersion>{NetCoreAppMaximumVersion}</NETCoreAppMaximumVersion>
     <MicrosoftNETCoreAppVersion>{MicrosoftNETCoreAppVersion}</MicrosoftNETCoreAppVersion>
diff --git a/eng/testing/linker/trimmingTests.targets b/eng/testing/linker/trimmingTests.targets
index 0473cfcd03636c..f43dbee3b4e1f2 100644
--- a/eng/testing/linker/trimmingTests.targets
+++ b/eng/testing/linker/trimmingTests.targets
@@ -74,6 +74,7 @@
                                                  .Replace('{NetCoreAppMaximumVersion}', '$(NetCoreAppMaximumVersion)')
                                                  .Replace('{TargetingPackDir}','$(MicrosoftNetCoreAppRefPackDir)')
                                                  .Replace('{RuntimeIdentifier}','%(TestConsoleApps.TestRuntimeIdentifier)')
+                                                 .Replace('{UseMonoRuntime}','$(UseMonoRuntime)')
                                                  .Replace('{MicrosoftNETILLinkTasksVersion}', '$(MicrosoftNETILLinkTasksVersion)')
                                                  .Replace('{ExtraTrimmerArgs}', '%(TestConsoleApps.ExtraTrimmerArgs)')
                                                  .Replace('{AdditionalProjectReferences}', '$(_additionalProjectReferencesString)')
diff --git a/eng/testing/performance/crossgen_perf.proj b/eng/testing/performance/crossgen_perf.proj
index eb8bdd9c440cd9..c6599aecfd42f1 100644
--- a/eng/testing/performance/crossgen_perf.proj
+++ b/eng/testing/performance/crossgen_perf.proj
@@ -44,13 +44,6 @@
     <Composite Include="framework-r2r.dll.rsp"/>
   </ItemGroup>
 
-  <ItemGroup>
-    <CrossgenWorkItem Include="@(SingleAssembly)">
-      <PayloadDirectory>$(WorkItemDirectory)</PayloadDirectory>
-      <Command>$(Python) $(CrossgenDirectory)test.py crossgen --core-root $(CoreRoot) --test-name %(Identity)</Command>
-    </CrossgenWorkItem>
-  </ItemGroup>
-
   <ItemGroup> 
     <Crossgen2WorkItem Include="@(SingleAssembly)">
       <PayloadDirectory>$(WorkItemDirectory)</PayloadDirectory>
@@ -65,15 +58,6 @@
     </Crossgen2SingleThreadedWorkItem>
   </ItemGroup>
 
-  <ItemGroup>
-    <CrossgenSizeOnDiskWorkItem Include="@(SingleAssembly)" Condition="'$(Architecture)' == 'x64'">
-      <PayloadDirectory>$(WorkItemDirectory)</PayloadDirectory>
-      <PreCommands>$(Python) $(CrossgenDirectory)pre.py crossgen --core-root $(CoreRoot) --single %(Identity) </PreCommands>
-      <Command>$(Python) $(CrossgenDirectory)test.py sod --scenario-name &quot;Crossgen %(Identity) Size&quot; --dirs ./crossgen.out/</Command>
-      <PostCommands>$(Python) $(CrossgenDirectory)post.py</PostCommands>
-    </CrossgenSizeOnDiskWorkItem>
-  </ItemGroup>
-
   <ItemGroup>
     <Crossgen2SizeOnDiskWorkItem Include="@(SingleAssembly)" Condition="'$(Architecture)' == 'x64'">
       <PayloadDirectory>$(WorkItemDirectory)</PayloadDirectory>
@@ -84,10 +68,6 @@
   </ItemGroup>
 
   <ItemGroup>
-    <!-- Enable crossgen tests on Windows x64 and Windows x86 -->
-    <HelixWorkItem Include="@(CrossgenWorkItem -> 'Crossgen %(Identity)')" Condition="'$(AGENT_OS)' == 'Windows_NT'">
-      <Timeout>4:00</Timeout>
-    </HelixWorkItem>
     <!-- Enable crossgen2 tests on Windows x64 and Linux x64 -->
     <HelixWorkItem Include="@(Crossgen2WorkItem -> 'Crossgen2 %(Identity)')" Condition="'$(Architecture)' == 'x64'">
       <Timeout>4:00</Timeout>
@@ -100,9 +80,6 @@
       <Command>$(Python) $(Crossgen2Directory)test.py crossgen2 --core-root $(CoreRoot) --composite $(Crossgen2Directory)framework-r2r.dll.rsp</Command>
       <Timeout>1:00</Timeout>  
     </HelixWorkItem>
-    <HelixWorkItem Include="@(CrossgenSizeOnDiskWorkItem -> 'Crossgen Size on Disk %(Identity)')" Condition="'$(Architecture)' == 'x64'">
-      <Timeout>4:00</Timeout>  
-    </HelixWorkItem>
     <HelixWorkItem Include="@(Crossgen2SizeOnDiskWorkItem -> 'Crossgen2 Size on Disk %(Identity)')" Condition="'$(Architecture)' == 'x64'">
       <Timeout>4:00</Timeout>  
     </HelixWorkItem>
diff --git a/eng/testing/performance/performance-setup.ps1 b/eng/testing/performance/performance-setup.ps1
index 92db27fd599a8f..3fc5a44a52ba50 100644
--- a/eng/testing/performance/performance-setup.ps1
+++ b/eng/testing/performance/performance-setup.ps1
@@ -88,7 +88,6 @@ elseif($DynamicPGO)
 elseif($FullPGO)
 {
     $Configurations += " PGOType=fullpgo"
-    $ExtraBenchmarkDotNetArguments = "--category-exclusion-filter NoAOT"
 }
 
 # FIX ME: This is a workaround until we get this from the actual pipeline
diff --git a/eng/testing/tests.mobile.targets b/eng/testing/tests.mobile.targets
index 38d568edb2c7ee..83d95eae00859f 100644
--- a/eng/testing/tests.mobile.targets
+++ b/eng/testing/tests.mobile.targets
@@ -94,7 +94,7 @@
     <RemoveDir Directories="$(BundleDir)" />
 
     <MonoAOTCompiler Condition="'$(RunAOTCompilation)' == 'true'"
-        CompilerBinaryPath="$(MonoAotCrossCompilerPath)"
+        CompilerBinaryPath="@(MonoAotCrossCompiler->WithMetadataValue('RuntimeIdentifier','$(TargetOS.ToLowerInvariant())-$(TargetArchitecture.ToLowerInvariant())'))"
         OutputDir="$(_MobileIntermediateOutputPath)"
         Mode="Full"
         OutputType="AsmOnly"
@@ -178,7 +178,7 @@
     <RemoveDir Directories="$(BundleDir)" />
 
     <MonoAOTCompiler Condition="'$(RunAOTCompilation)' == 'true'"
-        CompilerBinaryPath="$(MonoAotCrossCompilerPath)"
+        CompilerBinaryPath="@(MonoAotCrossCompiler->WithMetadataValue('RuntimeIdentifier','$(TargetOS.ToLowerInvariant())-$(TargetArchitecture.ToLowerInvariant())'))"
         OutputDir="$(_MobileIntermediateOutputPath)"
         Mode="$(AOTMode)"
         OutputType="AsmOnly"
diff --git a/eng/testing/tests.targets b/eng/testing/tests.targets
index 7e7d2cdcf949b2..dd40856e629b1b 100644
--- a/eng/testing/tests.targets
+++ b/eng/testing/tests.targets
@@ -22,9 +22,12 @@
 
   <!-- For both tests.mobile.targets and tests.wasm.targets -->
   <PropertyGroup>
-    <MonoAotCrossCompilerPath>$([MSBuild]::NormalizePath($(MonoAotCrossDir), 'mono-aot-cross'))</MonoAotCrossCompilerPath>
-    <MonoAotCrossCompilerPath Condition="$([MSBuild]::IsOSPlatform('WINDOWS'))">$(MonoAotCrossCompilerPath).exe</MonoAotCrossCompilerPath>
+    <_MonoAotCrossCompilerPath>$([MSBuild]::NormalizePath($(MonoAotCrossDir), 'mono-aot-cross'))</_MonoAotCrossCompilerPath>
+    <_MonoAotCrossCompilerPath Condition="$([MSBuild]::IsOSPlatform('WINDOWS'))">$(_MonoAotCrossCompilerPath).exe</_MonoAotCrossCompilerPath>
   </PropertyGroup>
+  <ItemGroup>
+    <MonoAotCrossCompiler Include="$(_MonoAotCrossCompilerPath)" RuntimeIdentifier="$(TargetOS.ToLowerInvariant())-$(TargetArchitecture.ToLowerInvariant())" />
+  </ItemGroup>
 
   <PropertyGroup>
     <ArchiveTestsAfterTargets>PrepareForRun</ArchiveTestsAfterTargets>
diff --git a/eng/testing/tests.wasm.targets b/eng/testing/tests.wasm.targets
index ce10194388d550..de4432bee9f5ea 100644
--- a/eng/testing/tests.wasm.targets
+++ b/eng/testing/tests.wasm.targets
@@ -35,7 +35,7 @@
   </PropertyGroup>
 
   <PropertyGroup Condition="'$(BuildAOTTestsOnHelix)' == 'true'">
-    <_AOTBuildCommand>dotnet msbuild publish/AOTTestProjectForHelix.proj /bl:$XHARNESS_OUT/AOTBuild.binlog</_AOTBuildCommand>
+    <_AOTBuildCommand>dotnet msbuild publish/ProxyProjectForAOTOnHelix.proj /bl:$XHARNESS_OUT/AOTBuild.binlog</_AOTBuildCommand>
 
     <!-- running aot-helix tests locally, so we can test with the same project file as CI -->
     <_AOTBuildCommand Condition="'$(ContinuousIntegrationBuild)' != 'true'">$(_AOTBuildCommand) /p:RuntimeSrcDir=$(RepoRoot) /p:RuntimeConfig=$(Configuration)</_AOTBuildCommand>
@@ -69,8 +69,7 @@
   <Target Name="_BundleAOTTestWasmAppForHelix" DependsOnTargets="PrepareForWasmBuildApp">
     <ItemGroup>
       <BundleFiles Include="$(WasmMainJSPath)"                  TargetDir="publish" />
-      <BundleFiles Include="@(WasmSatelliteAssemblies)"         TargetDir="publish/%(WasmSatelliteAssemblies.CultureName)" />
-      <BundleFiles Include="@(WasmAssembliesToBundle)"          TargetDir="publish" />
+      <BundleFiles Include="@(WasmAssembliesToBundle)"          TargetDir="publish\%(WasmAssembliesToBundle.RecursiveDir)" />
 
       <BundleFiles Include="$(MonoProjectRoot)\wasm\data\aot-tests\*" TargetDir="publish" />
     </ItemGroup>
@@ -96,16 +95,23 @@
       <_WasmPropertiesToPass
         Include="$(%(_WasmPropertyNames.Identity))"
         Name="%(_WasmPropertyNames.Identity)"
-        ConditionToUse="%(_WasmPropertyNames.ConditionToUse)" />
+        ConditionToUse__="%(_WasmPropertyNames.ConditionToUse__)" />
 
       <_WasmVFSFilesToCopy Include="@(WasmFilesToIncludeInFileSystem)" />
       <_WasmVFSFilesToCopy TargetPath="%(FileName)%(Extension)" Condition="'%(TargetPath)' == ''" />
+
+      <!-- Example of passing items to the project
+
+          <_WasmItemsToPass Include="@(BundleFiles)" OriginalItemName__="BundleFiles" ConditionToUse__="'$(Foo)' != 'true'" />
+
+      -->
     </ItemGroup>
 
     <!-- This file gets imported by the project file on helix -->
     <GenerateAOTProps
         Properties="@(_WasmPropertiesToPass)"
-        OutputFile="$(BundleDir)publish\AOTTestProjectForHelix.props" />
+        Items="@(_WasmItemsToPass)"
+        OutputFile="$(BundleDir)publish\ProxyProjectForAOTOnHelix.props" />
 
     <Copy SourceFiles="@(BundleFiles)"         DestinationFolder="$(BundleDir)%(TargetDir)" />
     <Copy SourceFiles="@(_WasmVFSFilesToCopy)" DestinationFiles="$(BundleDir)\extraFiles\%(_WasmVFSFilesToCopy.TargetPath)" />
@@ -124,17 +130,17 @@
       <WasmDebugLevel Condition="'$(DebuggerSupport)' == 'true' and '$(WasmDebugLevel)' == ''">-1</WasmDebugLevel>
     </PropertyGroup>
 
-    <ItemGroup>
-      <WasmSatelliteAssemblies Include="$(PublishDir)*\*.resources.dll" />
-      <WasmSatelliteAssemblies CultureName="$([System.IO.Directory]::GetParent('%(Identity)').Name)" />
+    <ItemGroup Condition="'$(IncludeSatelliteAssembliesInVFS)' == 'true'">
+      <_SatelliteAssemblies Include="$(PublishDir)*\*.resources.dll" />
+      <_SatelliteAssemblies CultureName="$([System.IO.Directory]::GetParent('%(Identity)').Name)" />
+      <_SatelliteAssemblies TargetPath="%(CultureName)\%(FileName)%(Extension)" />
 
-      <WasmAssembliesToBundle Include="$(PublishDir)\*.dll"/>
+      <WasmFilesToIncludeInFileSystem Include="@(_SatelliteAssemblies)" />
+    </ItemGroup>
 
+    <ItemGroup>
+      <WasmAssembliesToBundle Include="$(PublishDir)\**\*.dll"/>
       <WasmFilesToIncludeInFileSystem Include="@(ContentWithTargetPath)" />
-      <WasmFilesToIncludeInFileSystem
-              Include="@(WasmSatelliteAssemblies)"
-              TargetPath="%(WasmSatelliteAssemblies.CultureName)\%(WasmSatelliteAssemblies.FileName)%(WasmSatelliteAssemblies.Extension)"
-              Condition="'$(IncludeSatelliteAssembliesInVFS)' == 'true'" />
 
       <_CopyLocalPaths
               Include="@(PublishItemsOutputGroupOutputs)"
diff --git a/eng/versioning.targets b/eng/versioning.targets
index 9981f73a0beae9..4dacec01a8686b 100644
--- a/eng/versioning.targets
+++ b/eng/versioning.targets
@@ -84,6 +84,11 @@
     </ItemGroup>
   </Target>
 
+  <!-- Add PlatformNeutralAssembly property for targeted builds of cross platform assemblies -->
+  <ItemGroup Condition="'$(TargetsAnyOS)' != 'true' and '$(IsTestProject)' != 'true' and '@(SupportedOSPlatforms)' == ''">
+    <CompilerVisibleProperty Include="PlatformNeutralAssembly" />
+  </ItemGroup>
+
   <PropertyGroup>
     <!-- corefx has never generated these attributes so don't let the SDK generate them -->
     <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
diff --git a/global.json b/global.json
index 1b29cb7539fb62..df8f7ead63774f 100644
--- a/global.json
+++ b/global.json
@@ -1,24 +1,24 @@
 {
   "sdk": {
-    "version": "6.0.100-preview.3.21202.5",
+    "version": "6.0.100-preview.4.21255.9",
     "allowPrerelease": true,
     "rollForward": "major"
   },
   "tools": {
-    "dotnet": "6.0.100-preview.3.21202.5"
+    "dotnet": "6.0.100-preview.4.21255.9"
   },
   "native-tools": {
     "cmake": "3.16.4",
     "python3": "3.7.1"
   },
   "msbuild-sdks": {
-    "Microsoft.DotNet.Build.Tasks.TargetFramework.Sdk": "6.0.0-beta.21281.1",
+    "Microsoft.DotNet.Build.Tasks.TargetFramework.Sdk": "6.0.0-beta.21311.3",
     "Microsoft.DotNet.PackageValidation": "1.0.0-preview.6.21274.7",
-    "Microsoft.DotNet.Arcade.Sdk": "6.0.0-beta.21281.1",
-    "Microsoft.DotNet.Helix.Sdk": "6.0.0-beta.21281.1",
-    "Microsoft.DotNet.SharedFramework.Sdk": "6.0.0-beta.21281.1",
+    "Microsoft.DotNet.Arcade.Sdk": "6.0.0-beta.21311.3",
+    "Microsoft.DotNet.Helix.Sdk": "6.0.0-beta.21311.3",
+    "Microsoft.DotNet.SharedFramework.Sdk": "6.0.0-beta.21311.3",
     "Microsoft.Build.NoTargets": "3.0.4",
     "Microsoft.Build.Traversal": "3.0.23",
-    "Microsoft.NET.Sdk.IL": "6.0.0-preview.6.21281.1"
+    "Microsoft.NET.Sdk.IL": "6.0.0-preview.6.21314.1"
   }
 }
diff --git a/src/coreclr/.nuget/coreclr-packages.proj b/src/coreclr/.nuget/coreclr-packages.proj
index cef8381866cf12..1347e06d5ff0a0 100644
--- a/src/coreclr/.nuget/coreclr-packages.proj
+++ b/src/coreclr/.nuget/coreclr-packages.proj
@@ -5,11 +5,14 @@
     <ProjectReference Include="dotnet-ilverify\dotnet-ilverify.pkgproj" />
   </ItemGroup>
 
+  <ItemGroup Condition="'$(DotNetBuildFromSource)' != 'true'">
+    <ProjectReference Include="ILCompiler.Reflection.ReadyToRun.Experimental\ILCompiler.Reflection.ReadyToRun.Experimental.pkgproj" />
+  </ItemGroup>
+
   <ItemGroup>
     <ProjectReference Include="Microsoft.NETCore.TestHost\Microsoft.NETCore.TestHost.proj" />
     <ProjectReference Include="Microsoft.NETCore.ILAsm\Microsoft.NETCore.ILAsm.proj" />
     <ProjectReference Include="Microsoft.NETCore.ILDAsm\Microsoft.NETCore.ILDAsm.proj" />
-    <ProjectReference Include="ILCompiler.Reflection.ReadyToRun.Experimental\ILCompiler.Reflection.ReadyToRun.Experimental.pkgproj" />
   </ItemGroup>
 
   <Import Project="versioning.targets" />
diff --git a/src/coreclr/.nuget/dotnet-ilverify/dotnet-ilverify.pkgproj b/src/coreclr/.nuget/dotnet-ilverify/dotnet-ilverify.pkgproj
index 3fcc2d5e372767..5b808c62f8b86e 100644
--- a/src/coreclr/.nuget/dotnet-ilverify/dotnet-ilverify.pkgproj
+++ b/src/coreclr/.nuget/dotnet-ilverify/dotnet-ilverify.pkgproj
@@ -13,19 +13,19 @@
 
   <ItemGroup>
     <PackageFile Include="DotnetToolSettings.xml">
-       <TargetPath>tools\netcoreapp3.1\any\DotnetToolSettings.xml</TargetPath>
+       <TargetPath>tools\$(NetCoreAppToolCurrent)\any\DotnetToolSettings.xml</TargetPath>
     </PackageFile>
     <PackageFile Include="$(ArtifactsDir)bin\ILVerify\$(TargetArchitecture)\$(Configuration)\ILVerify.dll">
-       <TargetPath>tools\netcoreapp3.1\any\ILVerify.dll</TargetPath>
+       <TargetPath>tools\$(NetCoreAppToolCurrent)\any\ILVerify.dll</TargetPath>
     </PackageFile>
     <PackageFile Include="$(ArtifactsDir)bin\ILVerify\$(TargetArchitecture)\$(Configuration)\System.CommandLine.dll">
-       <TargetPath>tools\netcoreapp3.1\any\System.CommandLine.dll</TargetPath>
+       <TargetPath>tools\$(NetCoreAppToolCurrent)\any\System.CommandLine.dll</TargetPath>
     </PackageFile>
     <PackageFile Include="$(ArtifactsDir)bin\ILVerify\$(TargetArchitecture)\$(Configuration)\ILVerify.deps.json">
-       <TargetPath>tools\netcoreapp3.1\any\ILVerify.deps.json</TargetPath>
+       <TargetPath>tools\$(NetCoreAppToolCurrent)\any\ILVerify.deps.json</TargetPath>
     </PackageFile>
     <PackageFile Include="$(ArtifactsDir)bin\ILVerify\$(TargetArchitecture)\$(Configuration)\ILVerify.runtimeconfig.json">
-       <TargetPath>tools\netcoreapp3.1\any\ILVerify.runtimeconfig.json</TargetPath>
+       <TargetPath>tools\$(NetCoreAppToolCurrent)\any\ILVerify.runtimeconfig.json</TargetPath>
     </PackageFile>
   </ItemGroup>
 
diff --git a/src/coreclr/CMakeLists.txt b/src/coreclr/CMakeLists.txt
index 8f82d83fa4b735..78aa969473525d 100644
--- a/src/coreclr/CMakeLists.txt
+++ b/src/coreclr/CMakeLists.txt
@@ -34,6 +34,10 @@ endif(CORECLR_SET_RPATH)
 
 OPTION(CLR_CMAKE_ENABLE_CODE_COVERAGE "Enable code coverage" OFF)
 
+if(CLR_CMAKE_HOST_ARCH_S390X)
+  add_definitions(-DBIGENDIAN)
+endif(CLR_CMAKE_HOST_ARCH_S390X)
+
 #----------------------------------------------------
 # Cross target Component build specific configuration
 #----------------------------------------------------
diff --git a/src/coreclr/Directory.Build.props b/src/coreclr/Directory.Build.props
index 0117eb8dbe3d84..4b18a3a329a2f4 100644
--- a/src/coreclr/Directory.Build.props
+++ b/src/coreclr/Directory.Build.props
@@ -7,6 +7,8 @@
     <Configuration Condition="'$(Configuration)' == 'debug'">Debug</Configuration>
     <Configuration Condition="'$(Configuration)' == 'release'">Release</Configuration>
     <Configuration Condition="'$(Configuration)' == 'checked'">Checked</Configuration>
+
+    <UseMonoRuntime>false</UseMonoRuntime>
   </PropertyGroup>
 
   <Import Project="..\..\Directory.Build.props" />
diff --git a/src/coreclr/System.Private.CoreLib/src/ILLink/ILLink.Descriptors.Windows.xml b/src/coreclr/System.Private.CoreLib/src/ILLink/ILLink.Descriptors.Windows.xml
index 0648aed9763d13..52ab4af9bef745 100644
--- a/src/coreclr/System.Private.CoreLib/src/ILLink/ILLink.Descriptors.Windows.xml
+++ b/src/coreclr/System.Private.CoreLib/src/ILLink/ILLink.Descriptors.Windows.xml
@@ -4,5 +4,11 @@
     <type fullname="System.Runtime.InteropServices.IDispatch" />
     <type fullname="System.Runtime.InteropServices.IMarshal" />
     <type fullname="Internal.Runtime.InteropServices.IClassFactory2" />
+    <!-- ComActivator is needed for native host operations -->
+    <type fullname="Internal.Runtime.InteropServices.ComActivator" >
+      <method name="GetClassFactoryForTypeInternal" />
+      <method name="RegisterClassForTypeInternal" />
+      <method name="UnregisterClassForTypeInternal" />
+    </type>
   </assembly>
 </linker>
diff --git a/src/coreclr/System.Private.CoreLib/src/System/Attribute.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Attribute.CoreCLR.cs
index bd108893d6c22f..0779c2401f01d1 100644
--- a/src/coreclr/System.Private.CoreLib/src/System/Attribute.CoreCLR.cs
+++ b/src/coreclr/System.Private.CoreLib/src/System/Attribute.CoreCLR.cs
@@ -25,24 +25,26 @@ private static Attribute[] InternalGetCustomAttributes(PropertyInfo element, Typ
             if (!inherit)
                 return attributes;
 
+            // if this is an index we need to get the parameter types to help disambiguate
+            Type[] indexParamTypes = GetIndexParameterTypes(element);
+            PropertyInfo? baseProp = GetParentDefinition(element, indexParamTypes);
+            if (baseProp == null)
+                return attributes;
+
             // create the hashtable that keeps track of inherited types
             Dictionary<Type, AttributeUsageAttribute> types = new Dictionary<Type, AttributeUsageAttribute>(11);
 
             // create an array list to collect all the requested attibutes
             List<Attribute> attributeList = new List<Attribute>();
-            CopyToArrayList(attributeList, attributes, types);
-
-            // if this is an index we need to get the parameter types to help disambiguate
-            Type[] indexParamTypes = GetIndexParameterTypes(element);
-
-
-            PropertyInfo? baseProp = GetParentDefinition(element, indexParamTypes);
-            while (baseProp != null)
+            CopyToAttributeList(attributeList, attributes, types);
+            do
             {
                 attributes = GetCustomAttributes(baseProp, type, false);
                 AddAttributesToList(attributeList, attributes, types);
                 baseProp = GetParentDefinition(baseProp, indexParamTypes);
             }
+            while (baseProp != null);
+
             Attribute[] array = CreateAttributeArrayHelper(type, attributeList.Count);
             attributeList.CopyTo(array, 0);
             return array;
@@ -123,27 +125,33 @@ private static Attribute[] InternalGetCustomAttributes(EventInfo element, Type t
 
             // walk up the hierarchy chain
             Attribute[] attributes = (Attribute[])element.GetCustomAttributes(type, inherit);
-            if (inherit)
+            if (!inherit)
             {
-                // create the hashtable that keeps track of inherited types
-                Dictionary<Type, AttributeUsageAttribute> types = new Dictionary<Type, AttributeUsageAttribute>(11);
-                // create an array list to collect all the requested attibutes
-                List<Attribute> attributeList = new List<Attribute>();
-                CopyToArrayList(attributeList, attributes, types);
-
-                EventInfo? baseEvent = GetParentDefinition(element);
-                while (baseEvent != null)
-                {
-                    attributes = GetCustomAttributes(baseEvent, type, false);
-                    AddAttributesToList(attributeList, attributes, types);
-                    baseEvent = GetParentDefinition(baseEvent);
-                }
-                Attribute[] array = CreateAttributeArrayHelper(type, attributeList.Count);
-                attributeList.CopyTo(array, 0);
-                return array;
+                return attributes;
             }
-            else
+
+            EventInfo? baseEvent = GetParentDefinition(element);
+            if (baseEvent == null)
+            {
                 return attributes;
+            }
+
+            // create the hashtable that keeps track of inherited types
+            // create an array list to collect all the requested attibutes
+            Dictionary<Type, AttributeUsageAttribute> types = new Dictionary<Type, AttributeUsageAttribute>(11);
+            List<Attribute> attributeList = new List<Attribute>();
+            CopyToAttributeList(attributeList, attributes, types);
+            do
+            {
+                attributes = GetCustomAttributes(baseEvent, type, false);
+                AddAttributesToList(attributeList, attributes, types);
+                baseEvent = GetParentDefinition(baseEvent);
+            }
+            while (baseEvent != null);
+
+            Attribute[] array = CreateAttributeArrayHelper(type, attributeList.Count);
+            attributeList.CopyTo(array, 0);
+            return array;
         }
 
         [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2075:UnrecognizedReflectionPattern",
@@ -357,7 +365,7 @@ private static bool InternalParamIsDefined(ParameterInfo param, Type type, bool
         #endregion
 
         #region Utility
-        private static void CopyToArrayList(List<Attribute> attributeList, Attribute[] attributes, Dictionary<Type, AttributeUsageAttribute> types)
+        private static void CopyToAttributeList(List<Attribute> attributeList, Attribute[] attributes, Dictionary<Type, AttributeUsageAttribute> types)
         {
             for (int i = 0; i < attributes.Length; i++)
             {
diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/CustomAttribute.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/CustomAttribute.cs
index 1b825f0dc952f5..cf35de24627525 100644
--- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/CustomAttribute.cs
+++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/CustomAttribute.cs
@@ -237,6 +237,10 @@ private static CustomAttributeType InitCustomAttributeType(RuntimeType parameter
         private static IList<CustomAttributeData> GetCustomAttributes(RuntimeModule module, int tkTarget)
         {
             CustomAttributeRecord[] records = GetCustomAttributeRecords(module, tkTarget);
+            if (records.Length == 0)
+            {
+                return Array.Empty<CustomAttributeData>();
+            }
 
             CustomAttributeData[] customAttributes = new CustomAttributeData[records.Length];
             for (int i = 0; i < records.Length; i++)
diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimePropertyInfo.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimePropertyInfo.cs
index b7e6a58f1fe4b4..f01ae3933d0d9c 100644
--- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimePropertyInfo.cs
+++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimePropertyInfo.cs
@@ -304,9 +304,11 @@ internal ParameterInfo[] GetIndexParametersNoCopy()
                 // Now copy over the parameter info's and change their
                 // owning member info to the current property info.
 
-                ParameterInfo[] propParams = new ParameterInfo[numParams];
+                ParameterInfo[] propParams = numParams != 0 ?
+                    new ParameterInfo[numParams] :
+                    Array.Empty<ParameterInfo>();
 
-                for (int i = 0; i < numParams; i++)
+                for (int i = 0; i < propParams.Length; i++)
                     propParams[i] = new RuntimeParameterInfo((RuntimeParameterInfo)methParams![i], this);
 
                 m_parameters = propParams;
diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/Marshal.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/Marshal.CoreCLR.cs
index 688e4f83908c76..e064c36746d517 100644
--- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/Marshal.CoreCLR.cs
+++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/Marshal.CoreCLR.cs
@@ -464,8 +464,15 @@ public static IntPtr CreateAggregatedObject<T>(IntPtr pOuter, T o) where T : not
         /// <summary>
         /// Checks if the object is classic COM component.
         /// </summary>
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        public static extern bool IsComObject(object o);
+        public static bool IsComObject(object o)
+        {
+            if (o is null)
+            {
+                throw new ArgumentNullException(nameof(o));
+            }
+
+            return o is __ComObject;
+        }
 
         /// <summary>
         /// Release the COM component and if the reference hits 0 zombie this object.
diff --git a/src/coreclr/System.Private.CoreLib/src/System/RuntimeHandles.cs b/src/coreclr/System.Private.CoreLib/src/System/RuntimeHandles.cs
index 75aff556de7c34..dd17a2fa744184 100644
--- a/src/coreclr/System.Private.CoreLib/src/System/RuntimeHandles.cs
+++ b/src/coreclr/System.Private.CoreLib/src/System/RuntimeHandles.cs
@@ -460,8 +460,17 @@ internal RuntimeMethodHandleInternal GetInterfaceMethodImplementation(RuntimeTyp
             return GetInterfaceMethodImplementation(new QCallTypeHandle(ref nativeHandle), new QCallTypeHandle(ref nativeInterfaceHandle), interfaceMethodHandle);
         }
 
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        internal static extern bool IsComObject(RuntimeType type, bool isGenericCOM);
+        internal static bool IsComObject(RuntimeType type, bool isGenericCOM)
+        {
+#if FEATURE_COMINTEROP
+            if (isGenericCOM)
+                return type == typeof(__ComObject);
+
+            return RuntimeTypeHandle.CanCastTo(type, (RuntimeType)typeof(__ComObject));
+#else
+            return false;
+#endif
+        }
 
         [MethodImpl(MethodImplOptions.InternalCall)]
         internal static extern bool IsInterface(RuntimeType type);
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 1e2ece2cde5c8d..b07971e0f5600e 100644
--- a/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CoreCLR.cs
+++ b/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CoreCLR.cs
@@ -3068,6 +3068,131 @@ public override MemberInfo[] GetMember(string name, MemberTypes type, BindingFla
 
             return compressMembers;
         }
+
+        public override MemberInfo GetMemberWithSameMetadataDefinitionAs(MemberInfo member)
+        {
+            if (member is null) throw new ArgumentNullException(nameof(member));
+
+            RuntimeType? runtimeType = this;
+            while (runtimeType != null)
+            {
+                MemberInfo? result = member.MemberType switch
+                {
+                    MemberTypes.Method => GetMethodWithSameMetadataDefinitionAs(runtimeType, member),
+                    MemberTypes.Constructor => GetConstructorWithSameMetadataDefinitionAs(runtimeType, member),
+                    MemberTypes.Property => GetPropertyWithSameMetadataDefinitionAs(runtimeType, member),
+                    MemberTypes.Field => GetFieldWithSameMetadataDefinitionAs(runtimeType, member),
+                    MemberTypes.Event => GetEventWithSameMetadataDefinitionAs(runtimeType, member),
+                    MemberTypes.NestedType => GetNestedTypeWithSameMetadataDefinitionAs(runtimeType, member),
+                    _ => null
+                };
+
+                if (result != null)
+                {
+                    return result;
+                }
+
+                runtimeType = runtimeType.GetBaseType();
+            }
+
+            throw CreateGetMemberWithSameMetadataDefinitionAsNotFoundException(member);
+        }
+
+        private static MemberInfo? GetMethodWithSameMetadataDefinitionAs(RuntimeType runtimeType, MemberInfo method)
+        {
+            RuntimeMethodInfo[] cache = runtimeType.Cache.GetMethodList(MemberListType.CaseSensitive, method.Name);
+
+            for (int i = 0; i < cache.Length; i++)
+            {
+                RuntimeMethodInfo candidate = cache[i];
+                if (candidate.HasSameMetadataDefinitionAs(method))
+                {
+                    return candidate;
+                }
+            }
+
+            return null;
+        }
+
+        private static MemberInfo? GetConstructorWithSameMetadataDefinitionAs(RuntimeType runtimeType, MemberInfo constructor)
+        {
+            RuntimeConstructorInfo[] cache = runtimeType.Cache.GetConstructorList(MemberListType.CaseSensitive, constructor.Name);
+
+            for (int i = 0; i < cache.Length; i++)
+            {
+                RuntimeConstructorInfo candidate = cache[i];
+                if (candidate.HasSameMetadataDefinitionAs(constructor))
+                {
+                    return candidate;
+                }
+            }
+
+            return null;
+        }
+
+        private static MemberInfo? GetPropertyWithSameMetadataDefinitionAs(RuntimeType runtimeType, MemberInfo property)
+        {
+            RuntimePropertyInfo[] cache = runtimeType.Cache.GetPropertyList(MemberListType.CaseSensitive, property.Name);
+
+            for (int i = 0; i < cache.Length; i++)
+            {
+                RuntimePropertyInfo candidate = cache[i];
+                if (candidate.HasSameMetadataDefinitionAs(property))
+                {
+                    return candidate;
+                }
+            }
+
+            return null;
+        }
+
+        private static MemberInfo? GetFieldWithSameMetadataDefinitionAs(RuntimeType runtimeType, MemberInfo field)
+        {
+            RuntimeFieldInfo[] cache = runtimeType.Cache.GetFieldList(MemberListType.CaseSensitive, field.Name);
+
+            for (int i = 0; i < cache.Length; i++)
+            {
+                RuntimeFieldInfo candidate = cache[i];
+                if (candidate.HasSameMetadataDefinitionAs(field))
+                {
+                    return candidate;
+                }
+            }
+
+            return null;
+        }
+
+        private static MemberInfo? GetEventWithSameMetadataDefinitionAs(RuntimeType runtimeType, MemberInfo eventInfo)
+        {
+            RuntimeEventInfo[] cache = runtimeType.Cache.GetEventList(MemberListType.CaseSensitive, eventInfo.Name);
+
+            for (int i = 0; i < cache.Length; i++)
+            {
+                RuntimeEventInfo candidate = cache[i];
+                if (candidate.HasSameMetadataDefinitionAs(eventInfo))
+                {
+                    return candidate;
+                }
+            }
+
+            return null;
+        }
+
+        private static MemberInfo? GetNestedTypeWithSameMetadataDefinitionAs(RuntimeType runtimeType, MemberInfo nestedType)
+        {
+            RuntimeType[] cache = runtimeType.Cache.GetNestedTypeList(MemberListType.CaseSensitive, nestedType.Name);
+
+            for (int i = 0; i < cache.Length; i++)
+            {
+                RuntimeType candidate = cache[i];
+                if (candidate.HasSameMetadataDefinitionAs(nestedType))
+                {
+                    return candidate;
+                }
+            }
+
+            return null;
+        }
         #endregion
 
         #region Identity
diff --git a/src/coreclr/System.Private.CoreLib/src/System/Threading/ThreadPool.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Threading/ThreadPool.CoreCLR.cs
index 95b283e707c69e..86dd19a5a75609 100644
--- a/src/coreclr/System.Private.CoreLib/src/System/Threading/ThreadPool.CoreCLR.cs
+++ b/src/coreclr/System.Private.CoreLib/src/System/Threading/ThreadPool.CoreCLR.cs
@@ -522,6 +522,15 @@ internal static void NotifyWorkItemProgress()
         [MethodImpl(MethodImplOptions.InternalCall)]
         private static extern void NotifyWorkItemProgressNative();
 
+        internal static bool NotifyThreadBlocked() =>
+            UsePortableThreadPool && PortableThreadPool.ThreadPoolInstance.NotifyThreadBlocked();
+
+        internal static void NotifyThreadUnblocked()
+        {
+            Debug.Assert(UsePortableThreadPool);
+            PortableThreadPool.ThreadPoolInstance.NotifyThreadUnblocked();
+        }
+
         internal static object? GetOrCreateThreadLocalCompletionCountObject() =>
             UsePortableThreadPool ? PortableThreadPool.ThreadPoolInstance.GetOrCreateThreadLocalCompletionCountObject() : null;
 
diff --git a/src/coreclr/System.Private.CoreLib/src/System/Variant.cs b/src/coreclr/System.Private.CoreLib/src/System/Variant.cs
index 0ac6557579356e..8d2c55444072d4 100644
--- a/src/coreclr/System.Private.CoreLib/src/System/Variant.cs
+++ b/src/coreclr/System.Private.CoreLib/src/System/Variant.cs
@@ -198,7 +198,7 @@ public Variant(float val)
         {
             _objref = null;
             _flags = CV_R4;
-            _data = (uint)BitConverter.SingleToInt32Bits(val);
+            _data = BitConverter.SingleToUInt32Bits(val);
         }
 
         public Variant(double val)
@@ -328,7 +328,7 @@ public Variant(object? obj)
                 CV_U4 => (uint)_data,
                 CV_I8 => _data,
                 CV_U8 => (ulong)_data,
-                CV_R4 => BitConverter.Int32BitsToSingle((int)_data),
+                CV_R4 => BitConverter.UInt32BitsToSingle((uint)_data),
                 CV_R8 => BitConverter.Int64BitsToDouble(_data),
                 CV_DATETIME => new DateTime(_data),
                 CV_TIMESPAN => new TimeSpan(_data),
diff --git a/src/coreclr/ToolBox/superpmi/readme.md b/src/coreclr/ToolBox/superpmi/readme.md
index d9aded28c479a5..c3de3dfe94288c 100644
--- a/src/coreclr/ToolBox/superpmi/readme.md
+++ b/src/coreclr/ToolBox/superpmi/readme.md
@@ -91,7 +91,7 @@ speed up the disk operations.
 These are the general steps that are followed when doing a SuperPMI collection:
 
 1. Collect .MC files. Set up for collection, then cause the JIT to be invoked
-by either running a scenario, running tests, crossgen compiling assemblies,
+by either running a scenario, running tests, crossgen2 compiling assemblies,
 or using PMI to force the JIT to compile functions in an assembly.
 During collection, the data for each JIT compiled function is stored
 in a uniquely named file with a ".MC" filename extension (for "method context").
diff --git a/src/coreclr/ToolBox/superpmi/superpmi-shared/agnostic.h b/src/coreclr/ToolBox/superpmi/superpmi-shared/agnostic.h
index 4b47339b352f64..e51eb3ef6d049b 100644
--- a/src/coreclr/ToolBox/superpmi/superpmi-shared/agnostic.h
+++ b/src/coreclr/ToolBox/superpmi/superpmi-shared/agnostic.h
@@ -557,18 +557,22 @@ struct Agnostic_GetSystemVAmd64PassStructInRegisterDescriptor
 
 struct Agnostic_ResolveVirtualMethodKey
 {
-    DWORDLONG virtualMethod;
-    DWORDLONG objClass;
-    DWORDLONG context;
+    DWORDLONG                       virtualMethod;
+    DWORDLONG                       objClass;
+    DWORDLONG                       context;
+    DWORD                           pResolvedTokenVirtualMethodNonNull;
+    Agnostic_CORINFO_RESOLVED_TOKEN pResolvedTokenVirtualMethod;
 };
 
 struct Agnostic_ResolveVirtualMethodResult
 {
-    bool      returnValue;
-    DWORDLONG devirtualizedMethod;
-    bool      requiresInstMethodTableArg;
-    DWORDLONG exactContext;
-    DWORD     detail;
+    bool                            returnValue;
+    DWORDLONG                       devirtualizedMethod;
+    bool                            requiresInstMethodTableArg;
+    DWORDLONG                       exactContext;
+    DWORD                           detail;
+    Agnostic_CORINFO_RESOLVED_TOKEN resolvedTokenDevirtualizedMethod;
+    Agnostic_CORINFO_RESOLVED_TOKEN resolvedTokenDevirtualizedUnboxedMethod;
 };
 
 struct ResolveTokenValue
diff --git a/src/coreclr/ToolBox/superpmi/superpmi-shared/compileresult.cpp b/src/coreclr/ToolBox/superpmi/superpmi-shared/compileresult.cpp
index 94ac3a50a36923..729064aa1b0bc8 100644
--- a/src/coreclr/ToolBox/superpmi/superpmi-shared/compileresult.cpp
+++ b/src/coreclr/ToolBox/superpmi/superpmi-shared/compileresult.cpp
@@ -1096,7 +1096,10 @@ void CompileResult::repRecordCallSite(ULONG instrOffset, CORINFO_SIG_INFO* callS
         // The most call site records have only `methodHandle`, so creating two separate maps give us better perfomance
         // and smaller memory consumption. Note: we are not reading values from these maps during a normal replay.
         RecordCallSiteWithSignature = new LightWeightMap<DWORD, Agnostic_RecordCallSite>();
-        RecordCallSiteWithoutSignature = new LightWeightMap<DWORD, DWORDLONG>();
+        if (recordCallSitesWithoutSig)
+        {
+            RecordCallSiteWithoutSignature = new LightWeightMap<DWORD, DWORDLONG>();
+        }
     }
 
     if (callSig != nullptr)
@@ -1107,7 +1110,7 @@ void CompileResult::repRecordCallSite(ULONG instrOffset, CORINFO_SIG_INFO* callS
         value.methodHandle = CastHandle(methodHandle);
         RecordCallSiteWithSignature->Add(instrOffset, value);
     }
-    else
+    else if (recordCallSitesWithoutSig)
     {
         RecordCallSiteWithoutSignature->Add(instrOffset, CastHandle(methodHandle));
     }
diff --git a/src/coreclr/ToolBox/superpmi/superpmi-shared/compileresult.h b/src/coreclr/ToolBox/superpmi/superpmi-shared/compileresult.h
index 47dbc0a07ba0e7..4c912d10b5a38d 100644
--- a/src/coreclr/ToolBox/superpmi/superpmi-shared/compileresult.h
+++ b/src/coreclr/ToolBox/superpmi/superpmi-shared/compileresult.h
@@ -211,5 +211,7 @@ class CompileResult
     MemoryTracker*          memoryTracker;
     Capture_AllocMemDetails allocMemDets;
     allocGCInfoDetails      allocGCInfoDets;
+
+    const bool recordCallSitesWithoutSig = false; // Set it to true if you want to use CallUtils::GetRecordedCallSiteInfo.
 };
 #endif
diff --git a/src/coreclr/ToolBox/superpmi/superpmi-shared/lightweightmap.h b/src/coreclr/ToolBox/superpmi/superpmi-shared/lightweightmap.h
index ed06e9fac4d59e..e696f469d17dfa 100644
--- a/src/coreclr/ToolBox/superpmi/superpmi-shared/lightweightmap.h
+++ b/src/coreclr/ToolBox/superpmi/superpmi-shared/lightweightmap.h
@@ -319,7 +319,7 @@ class LightWeightMap : public LightWeightMapBuffer
 
         // If we have RTTI, we can make this assert report the correct type. No RTTI, though, when
         // built with .NET Core, especially when built against the PAL.
-        AssertCodeMsg((ptr - bytes) == size, EXCEPTIONCODE_LWM, "%s - Ended with unexpected sizes %p != %x",
+        AssertCodeMsg(ptr == (bytes + size), EXCEPTIONCODE_LWM, "%s - Ended with unexpected sizes %p != %x",
                       "Unknown type" /*typeid(_Item).name()*/, (void*)(ptr - bytes), size);
         return size;
     }
@@ -385,11 +385,9 @@ class LightWeightMap : public LightWeightMapBuffer
 
         if (numItems > 0)
         {
-            for (unsigned int i = numItems; i > insert; i--)
-            {
-                pKeys[i]  = pKeys[i - 1];
-                pItems[i] = pItems[i - 1];
-            }
+            int countToMove = (numItems - insert);
+            memmove(&pKeys[insert+1], &pKeys[insert], countToMove * sizeof(pKeys[insert]));
+            memmove(&pItems[insert+1], &pItems[insert], countToMove * sizeof(pItems[insert]));
         }
 
         pKeys[insert]  = key;
@@ -658,7 +656,7 @@ class DenseLightWeightMap : public LightWeightMapBuffer
             ptr += bufferLength * sizeof(unsigned char);
         }
 
-        AssertCodeMsg((ptr - bytes) == size, EXCEPTIONCODE_LWM, "Ended with unexpected sizes %Ix != %x", ptr - bytes,
+        AssertCodeMsg(ptr == (bytes + size), EXCEPTIONCODE_LWM, "Ended with unexpected sizes %Ix != %x", ptr - bytes,
                       size);
         return size;
     }
diff --git a/src/coreclr/ToolBox/superpmi/superpmi-shared/methodcontext.cpp b/src/coreclr/ToolBox/superpmi/superpmi-shared/methodcontext.cpp
index 52739c2f8547e2..7d7824e2208b30 100644
--- a/src/coreclr/ToolBox/superpmi/superpmi-shared/methodcontext.cpp
+++ b/src/coreclr/ToolBox/superpmi/superpmi-shared/methodcontext.cpp
@@ -3164,23 +3164,53 @@ void MethodContext::recResolveVirtualMethod(CORINFO_DEVIRTUALIZATION_INFO * info
     }
 
     Agnostic_ResolveVirtualMethodKey key;
+    ZeroMemory(&key, sizeof(key)); // Zero token including any struct padding
     key.virtualMethod  = CastHandle(info->virtualMethod);
     key.objClass       = CastHandle(info->objClass);
     key.context        = CastHandle(info->context);
+
+    key.pResolvedTokenVirtualMethodNonNull = info->pResolvedTokenVirtualMethod != NULL ? 1 : 0;
+    if (key.pResolvedTokenVirtualMethodNonNull)
+        key.pResolvedTokenVirtualMethod = SpmiRecordsHelper::StoreAgnostic_CORINFO_RESOLVED_TOKEN(info->pResolvedTokenVirtualMethod, ResolveToken);
+
     Agnostic_ResolveVirtualMethodResult result;
-    result.returnValue = returnValue;
-    result.devirtualizedMethod = CastHandle(info->devirtualizedMethod);
+    result.returnValue                = returnValue;
+    result.devirtualizedMethod        = CastHandle(info->devirtualizedMethod);
     result.requiresInstMethodTableArg = info->requiresInstMethodTableArg;
-    result.exactContext = CastHandle(info->exactContext);
-    result.detail = (DWORD) info->detail;
+    result.exactContext               = CastHandle(info->exactContext);
+    result.detail                     = (DWORD) info->detail;
+
+    if (returnValue)
+    {
+        result.resolvedTokenDevirtualizedMethod        = SpmiRecordsHelper::StoreAgnostic_CORINFO_RESOLVED_TOKEN(&info->resolvedTokenDevirtualizedMethod, ResolveToken);
+        result.resolvedTokenDevirtualizedUnboxedMethod = SpmiRecordsHelper::StoreAgnostic_CORINFO_RESOLVED_TOKEN(&info->resolvedTokenDevirtualizedUnboxedMethod, ResolveToken);
+    }
+    else
+    {
+        ZeroMemory(&result.resolvedTokenDevirtualizedMethod, sizeof(result.resolvedTokenDevirtualizedMethod));
+        ZeroMemory(&result.resolvedTokenDevirtualizedUnboxedMethod, sizeof(result.resolvedTokenDevirtualizedUnboxedMethod));
+    }
+
     ResolveVirtualMethod->Add(key, result);
     DEBUG_REC(dmpResolveVirtualMethod(key, result));
 }
 
 void MethodContext::dmpResolveVirtualMethod(const Agnostic_ResolveVirtualMethodKey& key, const Agnostic_ResolveVirtualMethodResult& result)
 {
-    printf("ResolveVirtualMethod virtMethod-%016llX, objClass-%016llX, context-%016llX :: returnValue-%d, devirtMethod-%016llX, requiresInstArg-%d, exactContext-%016llX, detail-%d",
-        key.virtualMethod, key.objClass, key.context, result.returnValue, result.devirtualizedMethod, result.requiresInstMethodTableArg, result.exactContext, result.detail);
+    printf("ResolveVirtualMethod key virtMethod-%016llX, objClass-%016llX, context-%016llX pResolvedTokenVirtualMethodNonNull-%08X pResolvedTokenVirtualMethod{%s}",
+        key.virtualMethod,
+        key.objClass,
+        key.context,
+        key.pResolvedTokenVirtualMethodNonNull,
+        key.pResolvedTokenVirtualMethodNonNull ? SpmiDumpHelper::DumpAgnostic_CORINFO_RESOLVED_TOKEN(key.pResolvedTokenVirtualMethod).c_str() : "???");
+    printf(", value returnValue-%s, devirtMethod-%016llX, requiresInstArg-%s, exactContext-%016llX, detail-%d, tokDvMeth{%s}, tokDvUnboxMeth{%s}",
+        result.returnValue ? "true" : "false",
+        result.devirtualizedMethod,
+        result.requiresInstMethodTableArg ? "true" : "false",
+        result.exactContext,
+        result.detail,
+        result.returnValue ? SpmiDumpHelper::DumpAgnostic_CORINFO_RESOLVED_TOKEN(result.resolvedTokenDevirtualizedMethod).c_str() : "???",
+        result.returnValue ? SpmiDumpHelper::DumpAgnostic_CORINFO_RESOLVED_TOKEN(result.resolvedTokenDevirtualizedUnboxedMethod).c_str() : "???");
 }
 
 bool MethodContext::repResolveVirtualMethod(CORINFO_DEVIRTUALIZATION_INFO * info)
@@ -3191,7 +3221,11 @@ bool MethodContext::repResolveVirtualMethod(CORINFO_DEVIRTUALIZATION_INFO * info
     key.objClass       = CastHandle(info->objClass);
     key.context        = CastHandle(info->context);
 
-    AssertMapAndKeyExist(ResolveVirtualMethod, key, ": %016llX-%016llX-%016llX", key.virtualMethod, key.objClass, key.context);
+    key.pResolvedTokenVirtualMethodNonNull = info->pResolvedTokenVirtualMethod != NULL ? 1 : 0;
+    if (key.pResolvedTokenVirtualMethodNonNull)
+        key.pResolvedTokenVirtualMethod = SpmiRecordsHelper::StoreAgnostic_CORINFO_RESOLVED_TOKEN(info->pResolvedTokenVirtualMethod, ResolveToken);
+
+    AssertMapAndKeyExist(ResolveVirtualMethod, key, ": %016llX-%016llX-%016llX-%08X", key.virtualMethod, key.objClass, key.context, key.pResolvedTokenVirtualMethodNonNull);
 
     Agnostic_ResolveVirtualMethodResult result = ResolveVirtualMethod->Get(key);
     DEBUG_REP(dmpResolveVirtualMethod(key, result));
@@ -3200,6 +3234,11 @@ bool MethodContext::repResolveVirtualMethod(CORINFO_DEVIRTUALIZATION_INFO * info
     info->requiresInstMethodTableArg = result.requiresInstMethodTableArg;
     info->exactContext = (CORINFO_CONTEXT_HANDLE) result.exactContext;
     info->detail = (CORINFO_DEVIRTUALIZATION_DETAIL) result.detail;
+    if (result.returnValue)
+    {
+        info->resolvedTokenDevirtualizedMethod = SpmiRecordsHelper::Restore_CORINFO_RESOLVED_TOKEN(&result.resolvedTokenDevirtualizedMethod, ResolveToken);
+        info->resolvedTokenDevirtualizedUnboxedMethod = SpmiRecordsHelper::Restore_CORINFO_RESOLVED_TOKEN(&result.resolvedTokenDevirtualizedUnboxedMethod, ResolveToken);
+    }
     return result.returnValue;
 }
 
diff --git a/src/coreclr/ToolBox/superpmi/superpmi-shared/spmirecordhelper.h b/src/coreclr/ToolBox/superpmi/superpmi-shared/spmirecordhelper.h
index 0caf8bbf597660..d5316b94db17bb 100644
--- a/src/coreclr/ToolBox/superpmi/superpmi-shared/spmirecordhelper.h
+++ b/src/coreclr/ToolBox/superpmi/superpmi-shared/spmirecordhelper.h
@@ -35,6 +35,10 @@ class SpmiRecordsHelper
     static Agnostic_CORINFO_RESOLVED_TOKEN RestoreAgnostic_CORINFO_RESOLVED_TOKEN(
         CORINFO_RESOLVED_TOKEN* pResolvedToken, LightWeightMap<key, value>* buffers);
 
+    template <typename key, typename value>
+    static CORINFO_RESOLVED_TOKEN Restore_CORINFO_RESOLVED_TOKEN(
+        Agnostic_CORINFO_RESOLVED_TOKEN* pResolvedTokenAgnostic, LightWeightMap<key, value>* buffers);
+
     // Restore the out values in the first argument from the second.
     // Can't just return whole CORINFO_RESOLVED_TOKEN because [in] values in it are important too.
     template <typename key, typename value>
@@ -200,6 +204,22 @@ inline Agnostic_CORINFO_RESOLVED_TOKEN SpmiRecordsHelper::RestoreAgnostic_CORINF
     return token;
 }
 
+template <typename key, typename value>
+inline CORINFO_RESOLVED_TOKEN SpmiRecordsHelper::Restore_CORINFO_RESOLVED_TOKEN(
+    Agnostic_CORINFO_RESOLVED_TOKEN* pResolvedTokenAgnostic, LightWeightMap<key, value>* buffers)
+{
+    CORINFO_RESOLVED_TOKEN token;
+    ZeroMemory(&token, sizeof(token));
+
+    token.tokenContext = (CORINFO_CONTEXT_HANDLE)pResolvedTokenAgnostic->inValue.tokenContext;
+    token.tokenScope   = (CORINFO_MODULE_HANDLE)pResolvedTokenAgnostic->inValue.tokenScope;
+    token.token        = (mdToken)pResolvedTokenAgnostic->inValue.token;
+    token.tokenType    = (CorInfoTokenKind)pResolvedTokenAgnostic->inValue.tokenType;
+
+    Restore_CORINFO_RESOLVED_TOKENout(&token, pResolvedTokenAgnostic->outValue, buffers);
+    return token;
+}
+
 template <typename key, typename value>
 inline void SpmiRecordsHelper::Restore_CORINFO_RESOLVED_TOKENout(
     CORINFO_RESOLVED_TOKEN*                            pResolvedToken,
diff --git a/src/coreclr/ToolBox/superpmi/superpmi-shim-collector/icorjitinfo.cpp b/src/coreclr/ToolBox/superpmi/superpmi-shim-collector/icorjitinfo.cpp
index cd601a26213339..de2c555c20a4c6 100644
--- a/src/coreclr/ToolBox/superpmi/superpmi-shim-collector/icorjitinfo.cpp
+++ b/src/coreclr/ToolBox/superpmi/superpmi-shim-collector/icorjitinfo.cpp
@@ -2115,7 +2115,7 @@ uint16_t interceptor_ICJI::getRelocTypeHint(void* target)
 
 // For what machine does the VM expect the JIT to generate code? The VM
 // returns one of the IMAGE_FILE_MACHINE_* values. Note that if the VM
-// is cross-compiling (such as the case for crossgen), it will return a
+// is cross-compiling (such as the case for crossgen2), it will return a
 // different value than if it was compiling for the host architecture.
 //
 uint32_t interceptor_ICJI::getExpectedTargetArchitecture()
diff --git a/src/coreclr/ToolBox/superpmi/superpmi-shim-collector/superpmi-shim-collector.cpp b/src/coreclr/ToolBox/superpmi/superpmi-shim-collector/superpmi-shim-collector.cpp
index f1f61fcc672096..9cd22007107534 100644
--- a/src/coreclr/ToolBox/superpmi/superpmi-shim-collector/superpmi-shim-collector.cpp
+++ b/src/coreclr/ToolBox/superpmi/superpmi-shim-collector/superpmi-shim-collector.cpp
@@ -130,7 +130,7 @@ extern "C"
     return TRUE;
 }
 
-extern "C" DLLEXPORT void __stdcall jitStartup(ICorJitHost* host)
+extern "C" DLLEXPORT void jitStartup(ICorJitHost* host)
 {
     // crossgen2 doesn't invoke DllMain on Linux/Mac (under PAL), so optionally do initialization work here.
     InitializeShim();
@@ -157,7 +157,7 @@ extern "C" DLLEXPORT void __stdcall jitStartup(ICorJitHost* host)
     pnjitStartup(g_ourJitHost);
 }
 
-extern "C" DLLEXPORT ICorJitCompiler* __stdcall getJit()
+extern "C" DLLEXPORT ICorJitCompiler* getJit()
 {
     DWORD             dwRetVal = 0;
     PgetJit           pngetJit;
diff --git a/src/coreclr/ToolBox/superpmi/superpmi-shim-counter/superpmi-shim-counter.cpp b/src/coreclr/ToolBox/superpmi/superpmi-shim-counter/superpmi-shim-counter.cpp
index af0ceac75d269f..b2ad7f6754a53a 100644
--- a/src/coreclr/ToolBox/superpmi/superpmi-shim-counter/superpmi-shim-counter.cpp
+++ b/src/coreclr/ToolBox/superpmi/superpmi-shim-counter/superpmi-shim-counter.cpp
@@ -108,7 +108,7 @@ extern "C"
     return TRUE;
 }
 
-extern "C" DLLEXPORT void __stdcall jitStartup(ICorJitHost* host)
+extern "C" DLLEXPORT void jitStartup(ICorJitHost* host)
 {
     SetDefaultPaths();
     SetLibName();
@@ -141,7 +141,7 @@ extern "C" DLLEXPORT void __stdcall jitStartup(ICorJitHost* host)
     pnjitStartup(g_ourJitHost);
 }
 
-extern "C" DLLEXPORT ICorJitCompiler* __stdcall getJit()
+extern "C" DLLEXPORT ICorJitCompiler* getJit()
 {
     DWORD             dwRetVal = 0;
     PgetJit           pngetJit;
diff --git a/src/coreclr/ToolBox/superpmi/superpmi-shim-simple/superpmi-shim-simple.cpp b/src/coreclr/ToolBox/superpmi/superpmi-shim-simple/superpmi-shim-simple.cpp
index ac720a16983b0e..c6c24afb089334 100644
--- a/src/coreclr/ToolBox/superpmi/superpmi-shim-simple/superpmi-shim-simple.cpp
+++ b/src/coreclr/ToolBox/superpmi/superpmi-shim-simple/superpmi-shim-simple.cpp
@@ -93,7 +93,7 @@ extern "C"
     return TRUE;
 }
 
-extern "C" DLLEXPORT void __stdcall jitStartup(ICorJitHost* host)
+extern "C" DLLEXPORT void jitStartup(ICorJitHost* host)
 {
     SetDefaultPaths();
     SetLibName();
@@ -117,7 +117,7 @@ extern "C" DLLEXPORT void __stdcall jitStartup(ICorJitHost* host)
     pnjitStartup(g_ourJitHost);
 }
 
-extern "C" DLLEXPORT ICorJitCompiler* __stdcall getJit()
+extern "C" DLLEXPORT ICorJitCompiler* getJit()
 {
     DWORD             dwRetVal = 0;
     PgetJit           pngetJit;
diff --git a/src/coreclr/ToolBox/superpmi/superpmi/icorjitinfo.cpp b/src/coreclr/ToolBox/superpmi/superpmi/icorjitinfo.cpp
index f1eb73b8915c96..91bf8bf2f779ff 100644
--- a/src/coreclr/ToolBox/superpmi/superpmi/icorjitinfo.cpp
+++ b/src/coreclr/ToolBox/superpmi/superpmi/icorjitinfo.cpp
@@ -1859,7 +1859,7 @@ uint16_t MyICJI::getRelocTypeHint(void* target)
 
 // For what machine does the VM expect the JIT to generate code? The VM
 // returns one of the IMAGE_FILE_MACHINE_* values. Note that if the VM
-// is cross-compiling (such as the case for crossgen), it will return a
+// is cross-compiling (such as the case for crossgen2), it will return a
 // different value than if it was compiling for the host architecture.
 //
 uint32_t MyICJI::getExpectedTargetArchitecture()
diff --git a/src/coreclr/classlibnative/bcltype/objectnative.cpp b/src/coreclr/classlibnative/bcltype/objectnative.cpp
index 80023e27a9d817..5ecbdc3b0c3742 100644
--- a/src/coreclr/classlibnative/bcltype/objectnative.cpp
+++ b/src/coreclr/classlibnative/bcltype/objectnative.cpp
@@ -163,8 +163,8 @@ FCIMPL2(FC_BOOL_RET, ObjectNative::Equals, Object *pThisRef, Object *pCompareRef
         FC_RETURN_BOOL(FALSE);
 
     // Compare the contents (size - vtable - sync block index).
-    DWORD dwBaseSize = pThisRef->GetMethodTable()->GetBaseSize();
-    if(pThisRef->GetMethodTable() == g_pStringClass)
+    DWORD dwBaseSize = pThisMT->GetBaseSize();
+    if(pThisMT == g_pStringClass)
         dwBaseSize -= sizeof(WCHAR);
     BOOL ret = memcmp(
         (void *) (pThisRef+1),
diff --git a/src/coreclr/clrdefinitions.cmake b/src/coreclr/clrdefinitions.cmake
index 425d3d84d6a13f..eeb421cac4c2f9 100644
--- a/src/coreclr/clrdefinitions.cmake
+++ b/src/coreclr/clrdefinitions.cmake
@@ -57,12 +57,14 @@ if(CLR_CMAKE_HOST_WIN32)
   add_definitions(-D_CRT_SECURE_NO_WARNINGS)
 endif(CLR_CMAKE_HOST_WIN32)
 
-add_compile_definitions($<$<NOT:$<BOOL:$<TARGET_PROPERTY:CROSSGEN_COMPONENT>>>:EnC_SUPPORTED>)
-if(CLR_CMAKE_TARGET_ARCH_AMD64 OR CLR_CMAKE_TARGET_ARCH_I386)
+if (NOT (CLR_CMAKE_TARGET_ARCH_I386 AND CLR_CMAKE_TARGET_UNIX))
+  add_compile_definitions($<$<NOT:$<BOOL:$<TARGET_PROPERTY:CROSSGEN_COMPONENT>>>:EnC_SUPPORTED>)
+endif()
+if(CLR_CMAKE_TARGET_ARCH_AMD64 OR (CLR_CMAKE_TARGET_ARCH_I386 AND CLR_CMAKE_TARGET_WIN32))
   if(CLR_CMAKE_TARGET_WIN32)
     add_compile_definitions($<$<NOT:$<BOOL:$<TARGET_PROPERTY:CROSSGEN_COMPONENT>>>:FEATURE_ENC_SUPPORTED>)
   endif(CLR_CMAKE_TARGET_WIN32)
-endif(CLR_CMAKE_TARGET_ARCH_AMD64 OR CLR_CMAKE_TARGET_ARCH_I386)
+endif(CLR_CMAKE_TARGET_ARCH_AMD64 OR (CLR_CMAKE_TARGET_ARCH_I386 AND CLR_CMAKE_TARGET_WIN32))
 
 # Features - please keep them alphabetically sorted
 if(CLR_CMAKE_TARGET_WIN32)
diff --git a/src/coreclr/crosscomponents.cmake b/src/coreclr/crosscomponents.cmake
index b779f461aa9c04..864bdf9e722184 100644
--- a/src/coreclr/crosscomponents.cmake
+++ b/src/coreclr/crosscomponents.cmake
@@ -13,14 +13,6 @@ if (CLR_CMAKE_HOST_OS STREQUAL CLR_CMAKE_TARGET_OS)
         COMPONENT crosscomponents
     )
 
-    if(CLR_CMAKE_HOST_LINUX OR NOT FEATURE_CROSSBITNESS)
-        install_clr (TARGETS
-            crossgen
-            DESTINATIONS . sharedFramework
-            COMPONENT crosscomponents
-        )
-    endif()
-
     if(CLR_CMAKE_TARGET_OSX AND ARCH_TARGET_NAME STREQUAL arm64)
         install_clr (TARGETS
             clrjit_unix_osx_${ARCH_TARGET_NAME}_${ARCH_HOST_NAME}
diff --git a/src/coreclr/crossgen-corelib.proj b/src/coreclr/crossgen-corelib.proj
index 8ffbaae33220a3..6d675a2a59e247 100644
--- a/src/coreclr/crossgen-corelib.proj
+++ b/src/coreclr/crossgen-corelib.proj
@@ -96,8 +96,10 @@
       <CrossGenDllCmd>$(CrossGenDllCmd) -o:$(CoreLibOutputPath)</CrossGenDllCmd>
       <CrossGenDllCmd>$(CrossGenDllCmd) -r:$([MSBuild]::NormalizePath('$(BinDir)', 'IL', '*.dll'))</CrossGenDllCmd>
       <CrossGenDllCmd>$(CrossGenDllCmd) --targetarch:$(TargetArchitecture)</CrossGenDllCmd>
-      <CrossGenDllCmd Condition="'$(UsingToolIbcOptimization)' != 'true' and '$(EnableNgenOptimization)' == 'true'">$(CrossGenDllCmd) -m:$(MergedMibcPath) --embed-pgo-data</CrossGenDllCmd>
+      <MibcArgs>@(OptimizationMibcFiles->'-m:$(MergedMibcPath)', ' ')</MibcArgs>
+      <CrossGenDllCmd Condition="'$(UsingToolIbcOptimization)' != 'true' and '$(EnableNgenOptimization)' == 'true'">$(CrossGenDllCmd) $(MibcArgs) --embed-pgo-data</CrossGenDllCmd>
       <CrossGenDllCmd>$(CrossGenDllCmd) -O</CrossGenDllCmd>
+      <CrossGenDllCmd  Condition="'$(Configuration)' == 'Debug' or '$(Configuration)' == 'Checked'">$(CrossGenDllCmd) --verify-type-and-field-layout</CrossGenDllCmd>
       <CrossGenDllCmd>$(CrossGenDllCmd) $(CoreLibInputPath)</CrossGenDllCmd>
     </PropertyGroup>
 
diff --git a/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/MockHostTypes/IHostBuilder.cs b/src/coreclr/debug/daccess/s390x/primitives.cpp
similarity index 58%
rename from src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/MockHostTypes/IHostBuilder.cs
rename to src/coreclr/debug/daccess/s390x/primitives.cpp
index ef73665296d748..06d7ad1d084566 100644
--- a/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/MockHostTypes/IHostBuilder.cs
+++ b/src/coreclr/debug/daccess/s390x/primitives.cpp
@@ -1,10 +1,8 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-namespace MockHostTypes
-{
-    public interface IHostBuilder
-    {
-        IHost Build();
-    }
-}
+//
+
+#include "stdafx.h"
+
+#include "../../shared/s390x/primitives.cpp"
diff --git a/src/coreclr/debug/di/CMakeLists.txt b/src/coreclr/debug/di/CMakeLists.txt
index 55f34bd1ce3e27..b0272c4d2518d8 100644
--- a/src/coreclr/debug/di/CMakeLists.txt
+++ b/src/coreclr/debug/di/CMakeLists.txt
@@ -1,4 +1,5 @@
 add_definitions(
+    -DDBI_COMPILE
     -DFEATURE_METADATA_CUSTOM_DATA_SOURCE
     -DFEATURE_METADATA_DEBUGGEE_DATA_SOURCE
     -DFEATURE_NO_HOST
diff --git a/src/coreclr/debug/ee/controller.cpp b/src/coreclr/debug/ee/controller.cpp
index 7f7fb109b402cd..eed3c453e78e2b 100644
--- a/src/coreclr/debug/ee/controller.cpp
+++ b/src/coreclr/debug/ee/controller.cpp
@@ -83,7 +83,11 @@ SharedPatchBypassBuffer* DebuggerControllerPatch::GetOrCreateSharedPatchBypassBu
 
     if (m_pSharedPatchBypassBuffer == NULL)
     {
-        m_pSharedPatchBypassBuffer = new (interopsafeEXEC) SharedPatchBypassBuffer();
+        void *pSharedPatchBypassBufferRX = g_pDebugger->GetInteropSafeExecutableHeap()->Alloc(sizeof(SharedPatchBypassBuffer));
+        ExecutableWriterHolder<SharedPatchBypassBuffer> sharedPatchBypassBufferWriterHolder((SharedPatchBypassBuffer*)pSharedPatchBypassBufferRX, sizeof(SharedPatchBypassBuffer));
+        new (sharedPatchBypassBufferWriterHolder.GetRW()) SharedPatchBypassBuffer();
+        m_pSharedPatchBypassBuffer = (SharedPatchBypassBuffer*)pSharedPatchBypassBufferRX;
+
         _ASSERTE(m_pSharedPatchBypassBuffer);
         TRACE_ALLOC(m_pSharedPatchBypassBuffer);
     }
@@ -1364,9 +1368,7 @@ bool DebuggerController::ApplyPatch(DebuggerControllerPatch *patch)
 
         LPVOID baseAddress = (LPVOID)(patch->address);
 
-#if defined(HOST_OSX) && defined(HOST_ARM64)
-        auto jitWriteEnableHolder = PAL_JITWriteEnable(true);
-#else // defined(HOST_OSX) && defined(HOST_ARM64)
+#if !defined(HOST_OSX) || !defined(HOST_ARM64)
         DWORD oldProt;
 
         if (!VirtualProtect(baseAddress,
@@ -1376,7 +1378,7 @@ bool DebuggerController::ApplyPatch(DebuggerControllerPatch *patch)
             _ASSERTE(!"VirtualProtect of code page failed");
             return false;
         }
-#endif // defined(HOST_OSX) && defined(HOST_ARM64)
+#endif // !defined(HOST_OSX) || !defined(HOST_ARM64)
 
         patch->opcode = CORDbgGetInstruction(patch->address);
 
@@ -1391,7 +1393,7 @@ bool DebuggerController::ApplyPatch(DebuggerControllerPatch *patch)
             _ASSERTE(!"VirtualProtect of code page failed");
             return false;
         }
-#endif // !defined(HOST_OSX) || !defined(HOST_ARM64)
+#endif // !defined(HOST_OSX) || !defined(HOST_ARM64)        
     }
 // TODO: : determine if this is needed for AMD64
 #if defined(TARGET_X86) //REVISIT_TODO what is this?!
@@ -1408,12 +1410,14 @@ bool DebuggerController::ApplyPatch(DebuggerControllerPatch *patch)
             _ASSERTE(!"VirtualProtect of code page failed");
             return false;
         }
+
         patch->opcode =
           (unsigned int) *(unsigned short*)(patch->address+1);
 
         _ASSERTE(patch->opcode != CEE_BREAK);
 
-        *(unsigned short *) (patch->address+1) = CEE_BREAK;
+        ExecutableWriterHolder<BYTE> breakpointWriterHolder((BYTE*)patch->address, 2);
+        *(unsigned short *) (breakpointWriterHolder.GetRW()+1) = CEE_BREAK;
 
         if (!VirtualProtect((void *) patch->address, 2, oldProt, &oldProt))
         {
@@ -1460,9 +1464,7 @@ bool DebuggerController::UnapplyPatch(DebuggerControllerPatch *patch)
 
         LPVOID baseAddress = (LPVOID)(patch->address);
 
-#if defined(HOST_OSX) && defined(HOST_ARM64)
-        auto jitWriteEnableHolder = PAL_JITWriteEnable(true);
-#else // defined(HOST_OSX) && defined(HOST_ARM64)
+#if !defined(HOST_OSX) || !defined(HOST_ARM64)
         DWORD oldProt;
 
         if (!VirtualProtect(baseAddress,
@@ -1477,7 +1479,7 @@ bool DebuggerController::UnapplyPatch(DebuggerControllerPatch *patch)
             InitializePRD(&(patch->opcode));
             return false;
         }
-#endif // defined(HOST_OSX) && defined(HOST_ARM64)
+#endif // !defined(HOST_OSX) || !defined(HOST_ARM64)
 
         CORDbgSetInstruction((CORDB_ADDRESS_TYPE *)patch->address, patch->opcode);
 
@@ -1494,7 +1496,7 @@ bool DebuggerController::UnapplyPatch(DebuggerControllerPatch *patch)
             _ASSERTE(!"VirtualProtect of code page failed");
             return false;
         }
-#endif // !defined(HOST_OSX) || !defined(HOST_ARM64)
+#endif // !defined(HOST_OSX) || !defined(HOST_ARM64)        
     }
     else
     {
@@ -1519,7 +1521,8 @@ bool DebuggerController::UnapplyPatch(DebuggerControllerPatch *patch)
 #if defined(TARGET_X86)
         _ASSERTE(*(unsigned short*)(patch->address+1) == CEE_BREAK);
 
-        *(unsigned short *) (patch->address+1)
+        ExecutableWriterHolder<BYTE> breakpointWriterHolder((BYTE*)patch->address, 2);
+        *(unsigned short *) (breakpointWriterHolder.GetRW()+1)
           = (unsigned short) patch->opcode;
 #endif //this makes no sense on anything but X86
         //VERY IMPORTANT to zero out opcode, else we might mistake
@@ -4409,8 +4412,9 @@ DebuggerPatchSkip::DebuggerPatchSkip(Thread *thread,
         }
         else
         {
+            _ASSERTE(m_instrAttrib.m_cOperandSize <= SharedPatchBypassBuffer::cbBufferBypass);
             // Copy the data into our buffer.
-            memcpy(bufferBypass, patch->address + m_instrAttrib.m_cbInstr + dwOldDisp, SharedPatchBypassBuffer::cbBufferBypass);
+            memcpy(bufferBypass, patch->address + m_instrAttrib.m_cbInstr + dwOldDisp, m_instrAttrib.m_cOperandSize);
 
             if (m_instrAttrib.m_fIsWrite)
             {
diff --git a/src/coreclr/debug/ee/controller.h b/src/coreclr/debug/ee/controller.h
index 9bcfc8682f7b2c..9fe0a67e3ea28f 100644
--- a/src/coreclr/debug/ee/controller.h
+++ b/src/coreclr/debug/ee/controller.h
@@ -288,7 +288,7 @@ class SharedPatchBypassBuffer
     // "PatchBypass" must be the first field of this class for alignment to be correct.
     BYTE    PatchBypass[MAX_INSTRUCTION_LENGTH];
 #if defined(TARGET_AMD64)
-    const static int cbBufferBypass = 0x10;
+    const static int cbBufferBypass = 0x20;
     BYTE    BypassBuffer[cbBufferBypass];
 
     UINT_PTR                RipTargetFixup;
diff --git a/src/coreclr/debug/ee/debugger.cpp b/src/coreclr/debug/ee/debugger.cpp
index d8791362ca7200..4706790dd3d7f8 100644
--- a/src/coreclr/debug/ee/debugger.cpp
+++ b/src/coreclr/debug/ee/debugger.cpp
@@ -67,7 +67,6 @@ bool g_EnableSIS = false;
 
 // The following instances are used for invoking overloaded new/delete
 InteropSafe interopsafe;
-InteropSafeExecutable interopsafeEXEC;
 
 #ifndef DACCESS_COMPILE
 
@@ -1316,16 +1315,15 @@ DebuggerEval::DebuggerEval(CONTEXT * pContext, DebuggerIPCE_FuncEvalInfo * pEval
 {
     WRAPPER_NO_CONTRACT;
 
-#if defined(HOST_OSX) && defined(HOST_ARM64)
-    auto jitWriteEnableHolder = PAL_JITWriteEnable(true);
-#endif // defined(HOST_OSX) && defined(HOST_ARM64)
-
     // Allocate the breakpoint instruction info in executable memory.
-    m_bpInfoSegment = new (interopsafeEXEC, nothrow) DebuggerEvalBreakpointInfoSegment(this);
+    void *bpInfoSegmentRX = g_pDebugger->GetInteropSafeExecutableHeap()->Alloc(sizeof(DebuggerEvalBreakpointInfoSegment));
+    ExecutableWriterHolder<DebuggerEvalBreakpointInfoSegment> bpInfoSegmentWriterHolder((DebuggerEvalBreakpointInfoSegment*)bpInfoSegmentRX, sizeof(DebuggerEvalBreakpointInfoSegment));
+    new (bpInfoSegmentWriterHolder.GetRW()) DebuggerEvalBreakpointInfoSegment(this);
+    m_bpInfoSegment = (DebuggerEvalBreakpointInfoSegment*)bpInfoSegmentRX;
 
     // This must be non-zero so that the saved opcode is non-zero, and on IA64 we want it to be 0x16
     // so that we can have a breakpoint instruction in any slot in the bundle.
-    m_bpInfoSegment->m_breakpointInstruction[0] = 0x16;
+    bpInfoSegmentWriterHolder.GetRW()->m_breakpointInstruction[0] = 0x16;
 #if defined(TARGET_ARM)
     USHORT *bp = (USHORT*)&m_bpInfoSegment->m_breakpointInstruction;
     *bp = CORDbg_BREAK_INSTRUCTION;
diff --git a/src/coreclr/debug/ee/debugger.h b/src/coreclr/debug/ee/debugger.h
index d66198607e5c1a..9d80fb3eec77eb 100644
--- a/src/coreclr/debug/ee/debugger.h
+++ b/src/coreclr/debug/ee/debugger.h
@@ -1104,11 +1104,8 @@ struct DECLSPEC_ALIGN(4096) DebuggerHeapExecutableMemoryPage
 
     inline void SetNextPage(DebuggerHeapExecutableMemoryPage* nextPage)
     {
-#if defined(HOST_OSX) && defined(HOST_ARM64)
-        auto jitWriteEnableHolder = PAL_JITWriteEnable(true);
-#endif // defined(HOST_OSX) && defined(HOST_ARM64)
-
-        chunks[0].bookkeeping.nextPage = nextPage;
+        ExecutableWriterHolder<DebuggerHeapExecutableMemoryPage> debuggerHeapPageWriterHolder(this, sizeof(DebuggerHeapExecutableMemoryPage));
+        debuggerHeapPageWriterHolder.GetRW()->chunks[0].bookkeeping.nextPage = nextPage;
     }
 
     inline uint64_t GetPageOccupancy() const
@@ -1118,14 +1115,11 @@ struct DECLSPEC_ALIGN(4096) DebuggerHeapExecutableMemoryPage
 
     inline void SetPageOccupancy(uint64_t newOccupancy)
     {
-#if defined(HOST_OSX) && defined(HOST_ARM64)
-        auto jitWriteEnableHolder = PAL_JITWriteEnable(true);
-#endif // defined(HOST_OSX) && defined(HOST_ARM64)
-
         // Can't unset first bit of occupancy!
         ASSERT((newOccupancy & 0x8000000000000000) != 0);
 
-        chunks[0].bookkeeping.pageOccupancy = newOccupancy;
+        ExecutableWriterHolder<DebuggerHeapExecutableMemoryPage> debuggerHeapPageWriterHolder(this, sizeof(DebuggerHeapExecutableMemoryPage));
+        debuggerHeapPageWriterHolder.GetRW()->chunks[0].bookkeeping.pageOccupancy = newOccupancy;
     }
 
     inline void* GetPointerToChunk(int chunkNum) const
@@ -1135,16 +1129,14 @@ struct DECLSPEC_ALIGN(4096) DebuggerHeapExecutableMemoryPage
 
     DebuggerHeapExecutableMemoryPage()
     {
-#if defined(HOST_OSX) && defined(HOST_ARM64)
-        auto jitWriteEnableHolder = PAL_JITWriteEnable(true);
-#endif // defined(HOST_OSX) && defined(HOST_ARM64)
+        ExecutableWriterHolder<DebuggerHeapExecutableMemoryPage> debuggerHeapPageWriterHolder(this, sizeof(DebuggerHeapExecutableMemoryPage));
 
         SetPageOccupancy(0x8000000000000000); // only the first bit is set.
         for (uint8_t i = 1; i < sizeof(chunks)/sizeof(chunks[0]); i++)
         {
             ASSERT(i != 0);
-            chunks[i].data.startOfPage = this;
-            chunks[i].data.chunkNumber = i;
+            debuggerHeapPageWriterHolder.GetRW()->chunks[i].data.startOfPage = this;
+            debuggerHeapPageWriterHolder.GetRW()->chunks[i].data.chunkNumber = i;
         }
     }
 
@@ -3486,9 +3478,6 @@ class DebuggerEval
 class InteropSafe {};
 extern InteropSafe interopsafe;
 
-class InteropSafeExecutable {};
-extern InteropSafeExecutable interopsafeEXEC;
-
 #ifndef DACCESS_COMPILE
 inline void * __cdecl operator new(size_t n, const InteropSafe&)
 {
@@ -3631,62 +3620,6 @@ template<class T> void DeleteInteropSafe(T *p)
     }
 }
 
-inline void * __cdecl operator new(size_t n, const InteropSafeExecutable&)
-{
-    CONTRACTL
-    {
-        THROWS; // throw on OOM
-        GC_NOTRIGGER;
-    }
-    CONTRACTL_END;
-
-    _ASSERTE(g_pDebugger != NULL);
-    void *result = g_pDebugger->GetInteropSafeExecutableHeap()->Alloc((DWORD)n);
-    if (result == NULL) {
-        ThrowOutOfMemory();
-    }
-    return result;
-}
-
-inline void * __cdecl operator new(size_t n, const InteropSafeExecutable&, const NoThrow&) throw()
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-    }
-    CONTRACTL_END;
-
-    _ASSERTE(g_pDebugger != NULL);
-    DebuggerHeap * pHeap = g_pDebugger->GetInteropSafeExecutableHeap_NoThrow();
-    if (pHeap == NULL)
-    {
-        return NULL;
-    }
-    void *result = pHeap->Alloc((DWORD)n);
-    return result;
-}
-
-// Note: there is no C++ syntax for manually invoking this, but if a constructor throws an exception I understand that
-// this delete operator will be invoked automatically to destroy the object.
-inline void __cdecl operator delete(void *p, const InteropSafeExecutable&)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-    }
-    CONTRACTL_END;
-
-    if (p != NULL)
-    {
-        _ASSERTE(g_pDebugger != NULL);
-        DebuggerHeap * pHeap = g_pDebugger->GetInteropSafeExecutableHeap_NoThrow();
-        _ASSERTE(pHeap != NULL); // should have had heap around if we're deleting
-        pHeap->Free(p);
-    }
-}
-
 //
 // Interop safe delete to match the interop safe new's above. There is no C++ syntax for actually invoking those interop
 // safe delete operators above, so we use this method to accomplish the same thing.
diff --git a/src/coreclr/debug/ee/funceval.cpp b/src/coreclr/debug/ee/funceval.cpp
index 41acc0cb92b9d3..de23343b7979b7 100644
--- a/src/coreclr/debug/ee/funceval.cpp
+++ b/src/coreclr/debug/ee/funceval.cpp
@@ -1635,7 +1635,7 @@ static void GCProtectAllPassedArgs(DebuggerEval *pDE,
 #endif
             }
 #endif // TARGET_X86
-
+            FALLTHROUGH;
         default:
             //
             // Ignorable - no need to protect
diff --git a/src/coreclr/debug/ee/i386/x86walker.cpp b/src/coreclr/debug/ee/i386/x86walker.cpp
index ef7dabb3be4c26..cb262e770ecdc3 100644
--- a/src/coreclr/debug/ee/i386/x86walker.cpp
+++ b/src/coreclr/debug/ee/i386/x86walker.cpp
@@ -415,7 +415,7 @@ void NativeWalker::DecodeInstructionForPatchSkip(const BYTE *address, Instructio
         case 2:
         case 3:
             pInstrAttrib->m_fIsCall = true;
-            // fall through
+            FALLTHROUGH;
         case 4:
         case 5:
             pInstrAttrib->m_fIsAbsBranch = true;
diff --git a/src/coreclr/debug/ee/s390x/dbghelpers.S b/src/coreclr/debug/ee/s390x/dbghelpers.S
new file mode 100644
index 00000000000000..a1ec66394511ea
--- /dev/null
+++ b/src/coreclr/debug/ee/s390x/dbghelpers.S
@@ -0,0 +1,8 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+#include "asmconstants.h"
+#include "unixasmmacros.inc"
+
+#error Unsupported platform
+
diff --git a/src/coreclr/debug/ee/s390x/primitives.cpp b/src/coreclr/debug/ee/s390x/primitives.cpp
new file mode 100644
index 00000000000000..3432959ed16815
--- /dev/null
+++ b/src/coreclr/debug/ee/s390x/primitives.cpp
@@ -0,0 +1,9 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+//
+
+#include "stdafx.h"
+#include "threads.h"
+#include "../../shared/s390x/primitives.cpp"
+
diff --git a/src/coreclr/debug/ee/wks/CMakeLists.txt b/src/coreclr/debug/ee/wks/CMakeLists.txt
index ca3aca44e1ffaf..6411b64d436ff7 100644
--- a/src/coreclr/debug/ee/wks/CMakeLists.txt
+++ b/src/coreclr/debug/ee/wks/CMakeLists.txt
@@ -32,11 +32,7 @@ if (CLR_CMAKE_TARGET_WIN32)
 
 else ()
 
-  if(CLR_CMAKE_HOST_ARCH_AMD64 OR CLR_CMAKE_HOST_ARCH_ARM OR CLR_CMAKE_HOST_ARCH_ARM64 OR CLR_CMAKE_HOST_ARCH_I386)
-    add_library_clr(cordbee_wks_obj OBJECT ${CORDBEE_SOURCES_WKS} ../${ARCH_SOURCES_DIR}/dbghelpers.S)
-  else()
-    message(FATAL_ERROR "Unknown platform")
-  endif()
+  add_library_clr(cordbee_wks_obj OBJECT ${CORDBEE_SOURCES_WKS} ../${ARCH_SOURCES_DIR}/dbghelpers.S)
 
 endif (CLR_CMAKE_TARGET_WIN32)
 
diff --git a/src/coreclr/debug/inc/amd64/primitives.h b/src/coreclr/debug/inc/amd64/primitives.h
index a119c2b3639fe3..d8d14b24b5425a 100644
--- a/src/coreclr/debug/inc/amd64/primitives.h
+++ b/src/coreclr/debug/inc/amd64/primitives.h
@@ -12,6 +12,10 @@
 #ifndef PRIMITIVES_H_
 #define PRIMITIVES_H_
 
+#if !defined(DBI_COMPILE) && !defined(DACCESS_COMPILE)
+#include "executableallocator.h"
+#endif
+
 #ifndef CORDB_ADDRESS_TYPE
 typedef const BYTE                  CORDB_ADDRESS_TYPE;
 typedef DPTR(CORDB_ADDRESS_TYPE)    PTR_CORDB_ADDRESS_TYPE;
@@ -187,7 +191,14 @@ inline void CORDbgInsertBreakpoint(UNALIGNED CORDB_ADDRESS_TYPE *address)
 {
     LIMITED_METHOD_CONTRACT;
 
-    *((unsigned char*)address) = 0xCC;  // int 3 (single byte patch)
+#if !defined(DBI_COMPILE) && !defined(DACCESS_COMPILE)
+    ExecutableWriterHolder<CORDB_ADDRESS_TYPE> breakpointWriterHolder(address, CORDbg_BREAK_INSTRUCTION_SIZE);
+    UNALIGNED CORDB_ADDRESS_TYPE* addressRW = breakpointWriterHolder.GetRW();
+#else // !DBI_COMPILE && !DACCESS_COMPILE
+    UNALIGNED CORDB_ADDRESS_TYPE* addressRW = address;
+#endif // !DBI_COMPILE && !DACCESS_COMPILE
+
+    *((unsigned char*)addressRW) = 0xCC; // int 3 (single byte patch)
     FlushInstructionCache(GetCurrentProcess(), address, 1);
 
 }
@@ -198,7 +209,14 @@ inline void CORDbgSetInstruction(UNALIGNED CORDB_ADDRESS_TYPE* address,
     // In a DAC build, this function assumes the input is an host address.
     LIMITED_METHOD_DAC_CONTRACT;
 
-    *((unsigned char*)address) =
+#if !defined(DBI_COMPILE) && !defined(DACCESS_COMPILE)
+    ExecutableWriterHolder<CORDB_ADDRESS_TYPE> instructionWriterHolder(address, sizeof(unsigned char));
+    UNALIGNED CORDB_ADDRESS_TYPE* addressRW = instructionWriterHolder.GetRW();
+#else // !DBI_COMPILE && !DACCESS_COMPILE
+    UNALIGNED CORDB_ADDRESS_TYPE* addressRW = address;
+#endif // !DBI_COMPILE && !DACCESS_COMPILE
+
+    *((unsigned char*)addressRW) =
         (unsigned char) instruction;    // setting one byte is important
     FlushInstructionCache(GetCurrentProcess(), address, 1);
 
diff --git a/src/coreclr/debug/inc/arm/primitives.h b/src/coreclr/debug/inc/arm/primitives.h
index 269281eb006bed..c4e2d28602e565 100644
--- a/src/coreclr/debug/inc/arm/primitives.h
+++ b/src/coreclr/debug/inc/arm/primitives.h
@@ -12,6 +12,10 @@
 #ifndef PRIMITIVES_H_
 #define PRIMITIVES_H_
 
+#if !defined(DBI_COMPILE) && !defined(DACCESS_COMPILE)
+#include "executableallocator.h"
+#endif
+
 #ifndef THUMB_CODE
 #define THUMB_CODE 1
 #endif
@@ -159,7 +163,14 @@ inline void CORDbgSetInstruction(CORDB_ADDRESS_TYPE* address,
     // In a DAC build, this function assumes the input is an host address.
     LIMITED_METHOD_DAC_CONTRACT;
 
-    CORDB_ADDRESS ptraddr = (CORDB_ADDRESS)address;
+#if !defined(DBI_COMPILE) && !defined(DACCESS_COMPILE)
+    ExecutableWriterHolder<CORDB_ADDRESS_TYPE> instructionWriterHolder(address, sizeof(PRD_TYPE));
+    CORDB_ADDRESS_TYPE* addressRW = instructionWriterHolder.GetRW();
+#else // !DBI_COMPILE && !DACCESS_COMPILE
+    CORDB_ADDRESS_TYPE* addressRW = address;
+#endif // !DBI_COMPILE && !DACCESS_COMPILE
+
+    CORDB_ADDRESS ptraddr = (CORDB_ADDRESS)addressRW;
     _ASSERTE(ptraddr & THUMB_CODE);
     ptraddr &= ~THUMB_CODE;
 
diff --git a/src/coreclr/debug/inc/arm64/primitives.h b/src/coreclr/debug/inc/arm64/primitives.h
index f359680370dfe5..4f4c3f7bcd8f21 100644
--- a/src/coreclr/debug/inc/arm64/primitives.h
+++ b/src/coreclr/debug/inc/arm64/primitives.h
@@ -12,6 +12,10 @@
 #ifndef PRIMITIVES_H_
 #define PRIMITIVES_H_
 
+#if !defined(DBI_COMPILE) && !defined(DACCESS_COMPILE)
+#include "executableallocator.h"
+#endif
+
 typedef NEON128                     FPRegister64;
 typedef const BYTE                  CORDB_ADDRESS_TYPE;
 typedef DPTR(CORDB_ADDRESS_TYPE)    PTR_CORDB_ADDRESS_TYPE;
@@ -146,7 +150,13 @@ inline void CORDbgSetInstruction(CORDB_ADDRESS_TYPE* address,
     // In a DAC build, this function assumes the input is an host address.
     LIMITED_METHOD_DAC_CONTRACT;
 
+#if !defined(DBI_COMPILE) && !defined(DACCESS_COMPILE)
+    ExecutableWriterHolder<void> instructionWriterHolder((LPVOID)address, sizeof(PRD_TYPE));
+
+    ULONGLONG ptraddr = dac_cast<ULONGLONG>(instructionWriterHolder.GetRW());
+#else // !DBI_COMPILE && !DACCESS_COMPILE
     ULONGLONG ptraddr = dac_cast<ULONGLONG>(address);
+#endif // !DBI_COMPILE && !DACCESS_COMPILE
     *(PRD_TYPE *)ptraddr = instruction;
     FlushInstructionCache(GetCurrentProcess(),
                           address,
diff --git a/src/coreclr/debug/inc/i386/primitives.h b/src/coreclr/debug/inc/i386/primitives.h
index 980dc2707bb0f6..313b42c5a1970d 100644
--- a/src/coreclr/debug/inc/i386/primitives.h
+++ b/src/coreclr/debug/inc/i386/primitives.h
@@ -12,6 +12,9 @@
 #ifndef PRIMITIVES_H_
 #define PRIMITIVES_H_
 
+#if !defined(DBI_COMPILE) && !defined(DACCESS_COMPILE)
+#include "executableallocator.h"
+#endif
 
 typedef const BYTE                  CORDB_ADDRESS_TYPE;
 typedef DPTR(CORDB_ADDRESS_TYPE)    PTR_CORDB_ADDRESS_TYPE;
@@ -148,7 +151,14 @@ inline void CORDbgInsertBreakpoint(UNALIGNED CORDB_ADDRESS_TYPE *address)
 {
     LIMITED_METHOD_CONTRACT;
 
-    *((unsigned char*)address) = 0xCC; // int 3 (single byte patch)
+#if !defined(DBI_COMPILE) && !defined(DACCESS_COMPILE)
+    ExecutableWriterHolder<CORDB_ADDRESS_TYPE> breakpointWriterHolder(address, CORDbg_BREAK_INSTRUCTION_SIZE);
+    UNALIGNED CORDB_ADDRESS_TYPE* addressRW = breakpointWriterHolder.GetRW();
+#else // !DBI_COMPILE && !DACCESS_COMPILE
+    UNALIGNED CORDB_ADDRESS_TYPE* addressRW = address;
+#endif // !DBI_COMPILE && !DACCESS_COMPILE
+
+    *((unsigned char*)addressRW) = 0xCC; // int 3 (single byte patch)
     FlushInstructionCache(GetCurrentProcess(), address, 1);
 }
 
diff --git a/src/coreclr/debug/shared/s390x/primitives.cpp b/src/coreclr/debug/shared/s390x/primitives.cpp
new file mode 100644
index 00000000000000..cb4be30c89b56e
--- /dev/null
+++ b/src/coreclr/debug/shared/s390x/primitives.cpp
@@ -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.
+//*****************************************************************************
+// File: primitives.cpp
+//
+
+//
+// Platform-specific debugger primitives
+//
+//*****************************************************************************
+
+#include "primitives.h"
+
+#error Unsupported platform
+
diff --git a/src/coreclr/dlls/mscorrc/mscorrc.rc b/src/coreclr/dlls/mscorrc/mscorrc.rc
index 20390aec94eb11..0b4247c17e637a 100644
--- a/src/coreclr/dlls/mscorrc/mscorrc.rc
+++ b/src/coreclr/dlls/mscorrc/mscorrc.rc
@@ -745,7 +745,10 @@ BEGIN
         IDS_PROF_V2PROFILER_DISABLED            "Loading profiler failed.   The profiler that was configured to load was designed for an older version of the CLR.  You can use the COMPlus_ProfAPI_ProfilerCompatibilitySetting environment variable to allow older profilers to be loaded by the current version of the CLR.  Please consult the documentation for information on how to use this environment variable, and the risks associated with it.  Profiler CLSID: '%s'."
         IDS_PROF_V2PROFILER_ENABLED             "A profiler designed for an older version of the CLR was loaded because of the environment variable setting below.  Older profilers will continue to work in many cases, but if you encounter problems, please consider upgrading the profiler or changing the setting of the environment variable.  Please consult the documentation for information on how to use this environment variable, and the risks associated with it.  Environment variable setting: %s=%s.  Profiler CLSID: '%s'."
         IDS_PROF_PROFILER_DISABLED              "Profilers will not be loaded by the current version of the CLR because of the environment variable setting below.  Please consult the documentation for information on how to use this environment variable, and the risks associated with it.  Environment variable setting: %s=%s. Profiler CLSID: '%s'."
+        IDS_E_PROF_NOTIFICATION_DISABLED        "Profiler was prevented from loading notification profiler due to app settings."
+        IDS_E_PROF_NOTIFICATION_LIMIT_EXCEEDED  "Notification profiler was prevented from loading because the limit of notification profilers was reached."
         IDS_E_PROF_TIMEOUT_WAITING_FOR_CONCURRENT_GC    "Profiler timed out on waiting for concurrent GC to finish after '%d' milliseconds. Please configure your profiler to increase its attaching time out value or consult the documentation for the COMPlus_ProfAPI_AttachProfilerMinTimeoutInMs environment variable and try again. Profiler CLSID: '%s'."
+        IDS_PROF_ALREADY_LOADED                 "A request was made to load a profiler when a profiler was already loaded."
   END
 
 
diff --git a/src/coreclr/dlls/mscorrc/resource.h b/src/coreclr/dlls/mscorrc/resource.h
index b26dc8567426ca..8038665a0b8d40 100644
--- a/src/coreclr/dlls/mscorrc/resource.h
+++ b/src/coreclr/dlls/mscorrc/resource.h
@@ -549,6 +549,9 @@
 #define IDS_PROF_SUPPLEMENTARY_INFO             0x2506
 #define IDS_PROF_LOAD_COMPLETE                  0x2507
 #define IDS_E_PROF_BAD_PATH                     0x2508
+#define IDS_E_PROF_NOTIFICATION_DISABLED        0x2509
+#define IDS_PROF_ALREADY_LOADED                 0x250A
+#define IDS_E_PROF_NOTIFICATION_LIMIT_EXCEEDED  0x250B
 #define IDS_E_PROF_NOT_ATTACHABLE               0x250E
 #define IDS_E_PROF_UNHANDLED_EXCEPTION_ON_LOAD  0x250F
 #define IDS_PROF_ATTACH_REQUEST_RECEIVED        0x2512
diff --git a/src/coreclr/gc/env/gcenv.h b/src/coreclr/gc/env/gcenv.h
index 6a6b1c3c87412f..63b5979aab0c8a 100644
--- a/src/coreclr/gc/env/gcenv.h
+++ b/src/coreclr/gc/env/gcenv.h
@@ -195,131 +195,7 @@ enum LogLevel
 class ThreadStressLog
 {
 public:
-    static const char* gcStartMsg()
-    {
-        STATIC_CONTRACT_LEAF;
-        return "{ =========== BEGINGC %d, (requested generation = %lu, collect_classes = %lu) ==========\n";
-    }
-
-    static const char* gcEndMsg()
-    {
-        STATIC_CONTRACT_LEAF;
-        return "========== ENDGC %d (gen = %lu, collect_classes = %lu) ===========}\n";
-    }
-
-    static const char* gcRootMsg()
-    {
-        STATIC_CONTRACT_LEAF;
-        return "    GC Root %p RELOCATED %p -> %p  MT = %pT\n";
-    }
-
-    static const char* gcRootPromoteMsg()
-    {
-        STATIC_CONTRACT_LEAF;
-        return "    IGCHeap::Promote: Promote GC Root *%p = %p MT = %pT\n";
-    }
-
-    static const char* gcPlugMoveMsg()
-    {
-        STATIC_CONTRACT_LEAF;
-        return "GC_HEAP RELOCATING Objects in heap within range [%p %p) by -0x%x bytes\n";
-    }
-
-    static const char* gcServerThread0StartMsg()
-    {
-        STATIC_CONTRACT_LEAF;
-        return "%d gc thread waiting...";
-    }
-
-    static const char* gcServerThreadNStartMsg()
-    {
-        STATIC_CONTRACT_LEAF;
-        return "%d gc thread waiting... Done";
-    }
-
-    static const char* gcDetailedStartMsg()
-    {
-        STATIC_CONTRACT_LEAF;
-        return "*GC* %d(gen0:%d)(%d)(alloc: %Id)(%s)(%d)";
-    }
-
-    static const char* gcDetailedEndMsg()
-    {
-        STATIC_CONTRACT_LEAF;
-        return "*EGC* %Id(gen0:%Id)(%Id)(%d)(%s)(%s)(%s)(ml: %d->%d)";
-    }
-
-    static const char* gcStartMarkMsg()
-    {
-        STATIC_CONTRACT_LEAF;
-        return "---- Mark Phase on heap %d condemning %d ----";
-    }
-
-    static const char* gcStartPlanMsg()
-    {
-        STATIC_CONTRACT_LEAF;
-        return "---- Plan Phase on heap %d ---- Condemned generation %d, promotion: %d";
-    }
-
-    static const char* gcStartRelocateMsg()
-    {
-        STATIC_CONTRACT_LEAF;
-        return "---- Relocate phase on heap %d -----";
-    }
-
-    static const char* gcEndRelocateMsg()
-    {
-        STATIC_CONTRACT_LEAF;
-        return "---- End of Relocate phase on heap %d ----";
-    }
-
-    static const char* gcStartCompactMsg()
-    {
-        STATIC_CONTRACT_LEAF;
-        return "---- Compact Phase on heap %d: %Ix(%Ix)----";
-    }
-
-    static const char* gcEndCompactMsg()
-    {
-        STATIC_CONTRACT_LEAF;
-        return "---- End of Compact phase on heap %d ----";
-    }
-
-    static const char* gcMemCopyMsg()
-    {
-        STATIC_CONTRACT_LEAF;
-        return " mc: [%Ix->%Ix, %Ix->%Ix[";
-    }
-
-    static const char* gcPlanPlugMsg()
-    {
-        STATIC_CONTRACT_LEAF;
-        return "(%Ix)[%Ix->%Ix, NA: [%Ix(%Id), %Ix[: %Ix(%d), x: %Ix (%s)";
-    }
-
-    static const char* gcPlanPinnedPlugMsg()
-    {
-        STATIC_CONTRACT_LEAF;
-        return "(%Ix)PP: [%Ix, %Ix[%Ix](m:%d)";
-    }
-
-    static const char* gcDesiredNewAllocationMsg()
-    {
-        STATIC_CONTRACT_LEAF;
-        return "h%d g%d surv: %Id current: %Id alloc: %Id (%d%%) f: %d%% new-size: %Id new-alloc: %Id";
-    }
-
-    static const char* gcMakeUnusedArrayMsg()
-    {
-        STATIC_CONTRACT_LEAF;
-        return "Making unused array [%Ix, %Ix[";
-    }
-
-    static const char* gcStartBgcThread()
-    {
-        STATIC_CONTRACT_LEAF;
-        return "beginning of bgc on heap %d: gen2 FL: %d, FO: %d, frag: %d";
-    }
+    #include "../../inc/gcmsg.inl"
 };
 
 struct StressLogMsg
diff --git a/src/coreclr/gc/gc.cpp b/src/coreclr/gc/gc.cpp
index 61ea4f8f73b3e2..9cb439e650411f 100644
--- a/src/coreclr/gc/gc.cpp
+++ b/src/coreclr/gc/gc.cpp
@@ -641,6 +641,10 @@ process_sync_log_stats()
 #ifndef DACCESS_COMPILE
 uint32_t g_num_active_processors = 0;
 
+// Note that when a join is no longer used we still keep the values here because
+// tooling already recognized them as having the meaning they were assigned originally.
+// It doesn't break tooling if we stop using them but does if we assign a new meaning 
+// to them. 
 enum gc_join_stage
 {
     gc_join_init_cpu_mapping = 0,
@@ -681,6 +685,7 @@ enum gc_join_stage
     gc_join_after_commit_soh_no_gc = 35,
     gc_join_expand_loh_no_gc = 36,
     gc_join_final_no_gc = 37,
+    // No longer in use but do not remove, see comments for this enum.
     gc_join_disable_software_write_watch = 38,
     gc_join_max = 39
 };
@@ -10808,7 +10813,7 @@ void gc_heap::return_free_region (heap_segment* region)
         heap_segment_mem (region), num_basic_regions, num_free_regions));
     for (int i = 0; i < num_basic_regions; i++)
     {
-        uint8_t* basic_region_start = region_start + (i << min_segment_size_shr);
+        uint8_t* basic_region_start = region_start + ((size_t)i << min_segment_size_shr);
         heap_segment* basic_region = get_region_info (basic_region_start);
         heap_segment_allocated (basic_region) = 0;
 #ifdef MULTIPLE_HEAPS
@@ -15527,9 +15532,9 @@ int bgc_allocate_spin(size_t min_gc_size, size_t bgc_begin_size, size_t bgc_size
         return 0;
     }
 
-    if (((bgc_begin_size / end_size) >= 2) || (bgc_size_increased >= bgc_begin_size))
+    if ((bgc_begin_size >= (2 * end_size)) || (bgc_size_increased >= bgc_begin_size))
     {
-        if ((bgc_begin_size / end_size) >= 2)
+        if (bgc_begin_size >= (2 * end_size))
         {
             dprintf (3, ("alloc-ed too much before bgc started"));
         }
@@ -20587,6 +20592,7 @@ void gc_heap::garbage_collect (int n)
             update_collection_counts_for_no_gc();
 
 #ifdef MULTIPLE_HEAPS
+            gc_start_event.Reset();
             gc_t_join.restart();
 #endif //MULTIPLE_HEAPS
         }
@@ -22290,7 +22296,7 @@ inline
 void gc_heap::mark_object (uint8_t* o THREAD_NUMBER_DCL)
 {
 #ifdef USE_REGIONS
-    if (is_in_condemned_gc (o))
+    if ((o != nullptr) && is_in_condemned_gc (o))
     {
         mark_object_simple (&o THREAD_NUMBER_ARG);
     }
@@ -23314,7 +23320,10 @@ void gc_heap::process_mark_overflow_internal (int condemned_gen_number,
 #endif //MULTIPLE_HEAPS
     BOOL  full_p = (condemned_gen_number == max_generation);
 
-        dprintf(3,("Processing Mark overflow [%Ix %Ix]", (size_t)min_add, (size_t)max_add));
+    dprintf(3,("Processing Mark overflow [%Ix %Ix]", (size_t)min_add, (size_t)max_add));
+
+    size_t obj_count = 0;
+
 #ifdef MULTIPLE_HEAPS
     for (int hi = 0; hi < n_heaps; hi++)
     {
@@ -23323,11 +23332,10 @@ void gc_heap::process_mark_overflow_internal (int condemned_gen_number,
 #else
     {
         gc_heap*  hp = 0;
-
 #endif //MULTIPLE_HEAPS
         int gen_limit = full_p ? total_generation_count : condemned_gen_number + 1;
 
-        for (int i = condemned_gen_number; i < gen_limit; i++)
+        for (int i = get_stop_generation_index (condemned_gen_number); i < gen_limit; i++)
         {
             generation* gen = hp->generation_of (i);
             heap_segment* seg = heap_segment_in_range (generation_start_segment (gen));
@@ -23347,6 +23355,7 @@ void gc_heap::process_mark_overflow_internal (int condemned_gen_number,
                     if (marked (o))
                     {
                         mark_through_object (o, TRUE THREAD_NUMBER_ARG);
+                        obj_count++;
                     }
 
                     o = o + Align (size (o), align_const);
@@ -23355,6 +23364,10 @@ void gc_heap::process_mark_overflow_internal (int condemned_gen_number,
                 seg = heap_segment_next_in_range (seg);
             }
         }
+#ifndef MULTIPLE_HEAPS
+        // we should have found at least one object
+        assert (obj_count > 0);
+#endif //MULTIPLE_HEAPS
     }
 }
 
@@ -28669,11 +28682,6 @@ heap_segment* gc_heap::relocate_advance_to_non_sip (heap_segment* region)
                             {
                                 dprintf (4444, ("SIP %Ix(%Ix)->%Ix->%Ix(%Ix)", 
                                     x, (uint8_t*)pval, child, *pval, method_table (child)));
-
-                                if (method_table (child) == 0)
-                                {
-                                    FATAL_GC_ERROR();
-                                }
                             }
                         });
                     }
@@ -29214,6 +29222,7 @@ void gc_heap::relocate_address (uint8_t** pold_address THREAD_NUMBER_DCL)
             }
         }
 
+        dprintf (4, (ThreadStressLog::gcRelocateReferenceMsg(), pold_address, old_address, new_address));
         *pold_address = new_address;
         return;
     }
@@ -29243,7 +29252,9 @@ void gc_heap::relocate_address (uint8_t** pold_address THREAD_NUMBER_DCL)
 #endif
                 )
             {
-                *pold_address = old_address + loh_node_relocation_distance (old_address);
+                new_address = old_address + loh_node_relocation_distance (old_address);
+                dprintf (4, (ThreadStressLog::gcRelocateReferenceMsg(), pold_address, old_address, new_address));
+                *pold_address = new_address;
             }
         }
     }
@@ -31799,23 +31810,6 @@ void gc_heap::background_mark_phase ()
         //concurrent_print_time_delta ("nonconcurrent revisit dirtied pages on LOH");
         concurrent_print_time_delta ("NRre LOH");
 
-#ifdef FEATURE_USE_SOFTWARE_WRITE_WATCH_FOR_GC_HEAP
-#ifdef MULTIPLE_HEAPS
-        bgc_t_join.join(this, gc_join_disable_software_write_watch);
-        if (bgc_t_join.joined())
-#endif // MULTIPLE_HEAPS
-        {
-            // The runtime is suspended, and we will be doing a final query of dirty pages, so pause tracking written pages to
-            // avoid further perf penalty after the runtime is restarted
-            SoftwareWriteWatch::DisableForGCHeap();
-
-#ifdef MULTIPLE_HEAPS
-            dprintf(3, ("Restarting BGC threads after disabling software write watch"));
-            bgc_t_join.restart();
-#endif // MULTIPLE_HEAPS
-        }
-#endif // FEATURE_USE_SOFTWARE_WRITE_WATCH_FOR_GC_HEAP
-
         dprintf (2, ("before NR 1st Hov count: %d", bgc_overflow_count));
         bgc_overflow_count = 0;
 
@@ -31840,6 +31834,12 @@ void gc_heap::background_mark_phase ()
         if (bgc_t_join.joined())
 #endif //MULTIPLE_HEAPS
         {
+#ifdef FEATURE_USE_SOFTWARE_WRITE_WATCH_FOR_GC_HEAP
+            // The runtime is suspended, take this opportunity to pause tracking written pages to
+            // avoid further perf penalty after the runtime is restarted
+            SoftwareWriteWatch::DisableForGCHeap();
+#endif // FEATURE_USE_SOFTWARE_WRITE_WATCH_FOR_GC_HEAP
+
             GCToEEInterface::AfterGcScanRoots (max_generation, max_generation, &sc);
 
 #ifdef MULTIPLE_HEAPS
@@ -38467,7 +38467,7 @@ void gc_heap::process_background_segment_end (heap_segment* seg,
                         heap_segment_mem (seg), (*delete_p ? "should" : "should not")));
 
         }
-        else
+        if (!*delete_p)
         {
             dprintf (3, ("[h%d] seg %Ix alloc %Ix->%Ix",
                 heap_number, (size_t)seg,
@@ -39732,9 +39732,6 @@ void gc_heap::mark_through_cards_for_uoh_objects (card_fn fn,
 
 void gc_heap::descr_generations_to_profiler (gen_walk_fn fn, void *context)
 {
-#ifdef USE_REGIONS
-    assert (!"not impl!!");
-#else
 #ifdef MULTIPLE_HEAPS
     for (int i = 0; i < n_heaps; i++)
     {
@@ -39753,6 +39750,16 @@ void gc_heap::descr_generations_to_profiler (gen_walk_fn fn, void *context)
         {
             generation* gen = hp->generation_of (curr_gen_number);
             heap_segment* seg = generation_start_segment (gen);
+#ifdef USE_REGIONS
+            while (seg)
+            {
+                fn(context, curr_gen_number, heap_segment_mem (seg),
+                                              heap_segment_allocated (seg),
+                                              heap_segment_reserved (seg));
+
+                seg = heap_segment_next (seg);
+            }
+#else
             while (seg && (seg != hp->ephemeral_heap_segment))
             {
                 assert (curr_gen_number > 0);
@@ -39805,9 +39812,9 @@ void gc_heap::descr_generations_to_profiler (gen_walk_fn fn, void *context)
                                                   heap_segment_reserved (hp->ephemeral_heap_segment) );
                 }
             }
+#endif //USE_REGIONS
         }
     }
-#endif //USE_REGIONS
 }
 
 #ifdef TRACE_GC
@@ -42250,6 +42257,15 @@ GCHeap::Alloc(gc_alloc_context* context, size_t size, uint32_t flags REQD_ALIGN_
         newAlloc = (Object*) hp->allocate_uoh_object (size + ComputeMaxStructAlignPadLarge(requiredAlignment), flags, gen_num, acontext->alloc_bytes_uoh);
         ASSERT(((size_t)newAlloc & 7) == 0);
 
+#ifdef MULTIPLE_HEAPS
+        if (flags & GC_ALLOC_FINALIZE)
+        {
+            // the heap may have changed due to heap balancing - it's important
+            // to register the object for finalization on the heap it was allocated on
+            hp = gc_heap::heap_of ((uint8_t*)newAlloc);
+        }
+#endif //MULTIPLE_HEAPS
+
 #ifdef FEATURE_STRUCTALIGN
         newAlloc = (Object*) hp->pad_for_alignment_large ((uint8_t*) newAlloc, requiredAlignment, size);
 #endif // FEATURE_STRUCTALIGN
@@ -42269,6 +42285,16 @@ GCHeap::Alloc(gc_alloc_context* context, size_t size, uint32_t flags REQD_ALIGN_
             newAlloc = (Object*) hp->allocate (size + ComputeMaxStructAlignPad(requiredAlignment), acontext, flags);
         }
 
+#ifdef MULTIPLE_HEAPS
+        if (flags & GC_ALLOC_FINALIZE)
+        {
+            // the heap may have changed due to heap balancing - it's important
+            // to register the object for finalization on the heap it was allocated on
+            hp = acontext->get_alloc_heap()->pGenGCHeap;
+            assert ((newAlloc == nullptr) || (hp == gc_heap::heap_of ((uint8_t*)newAlloc)));
+        }
+#endif //MULTIPLE_HEAPS
+
 #ifdef FEATURE_STRUCTALIGN
         newAlloc = (Object*) hp->pad_for_alignment ((uint8_t*) newAlloc, requiredAlignment, size, acontext);
 #endif // FEATURE_STRUCTALIGN
@@ -44397,6 +44423,9 @@ CFinalize::RelocateFinalizationData (int gen, gc_heap* hp)
     unsigned int Seg = gen_segment (gen);
 
     Object** startIndex = SegQueue (Seg);
+
+    dprintf (3, ("RelocateFinalizationData gen=%d, [%Ix,%Ix[", gen, startIndex, SegQueue (FreeList)));
+
     for (Object** po = startIndex; po < SegQueue (FreeList);po++)
     {
         GCHeap::Relocate (po, &sc);
@@ -44406,6 +44435,8 @@ CFinalize::RelocateFinalizationData (int gen, gc_heap* hp)
 void
 CFinalize::UpdatePromotedGenerations (int gen, BOOL gen_0_empty_p)
 {
+    dprintf(3, ("UpdatePromotedGenerations gen=%d, gen_0_empty_p=%d", gen, gen_0_empty_p));
+
     // update the generation fill pointers.
     // if gen_0_empty is FALSE, test each object to find out if
     // it was promoted or not
@@ -44430,6 +44461,8 @@ CFinalize::UpdatePromotedGenerations (int gen, BOOL gen_0_empty_p)
                 int new_gen = g_theGCHeap->WhichGeneration (*po);
                 if (new_gen != i)
                 {
+                    dprintf (3, ("Moving object %Ix->%Ix from gen %d to gen %d", po, *po, i, new_gen));
+
                     if (new_gen > i)
                     {
                         //promotion
@@ -44461,6 +44494,8 @@ CFinalize::GrowArray()
     }
     memcpy (newArray, m_Array, oldArraySize*sizeof(Object*));
 
+    dprintf (3, ("Grow finalizer array [%Ix,%Ix[ -> [%Ix,%Ix[", m_Array, m_EndArray, newArray, &m_Array[newArraySize]));
+
     //adjust the fill pointers
     for (int i = 0; i < FreeList; i++)
     {
@@ -44518,6 +44553,19 @@ void gc_heap::walk_heap_per_heap (walk_fn fn, void* context, int gen_number, BOO
                 end = heap_segment_allocated (seg);
                 continue;
             }
+#ifdef USE_REGIONS
+            else if (gen_number > 0)
+            {
+                // advance to next lower generation
+                gen_number--;
+                gen = gc_heap::generation_of (gen_number);
+                seg = generation_start_segment (gen);
+
+                x = heap_segment_mem (seg);
+                end = heap_segment_allocated (seg);
+                continue;
+            }
+#endif // USE_REGIONS
             else
             {
                 if (walk_large_object_heap_p)
diff --git a/src/coreclr/gc/gcinterface.ee.h b/src/coreclr/gc/gcinterface.ee.h
index 4b048271c0e553..ea5f2d2914c543 100644
--- a/src/coreclr/gc/gcinterface.ee.h
+++ b/src/coreclr/gc/gcinterface.ee.h
@@ -4,7 +4,7 @@
 #ifndef _GCINTERFACE_EE_H_
 #define _GCINTERFACE_EE_H_
 
-enum EtwGCRootFlags
+enum EtwGCRootFlags: int32_t
 {
     kEtwGCRootFlagsPinning =            0x1,
     kEtwGCRootFlagsWeakRef =            0x2,
@@ -12,7 +12,7 @@ enum EtwGCRootFlags
     kEtwGCRootFlagsRefCounted =         0x8,
 };
 
-enum EtwGCRootKind
+enum EtwGCRootKind: int32_t
 {
     kEtwGCRootKindStack =               0,
     kEtwGCRootKindFinalizer =           1,
diff --git a/src/coreclr/gc/gcpriv.h b/src/coreclr/gc/gcpriv.h
index b89a0043589258..09bd97d1891886 100644
--- a/src/coreclr/gc/gcpriv.h
+++ b/src/coreclr/gc/gcpriv.h
@@ -63,7 +63,7 @@ inline void FATAL_GC_ERROR()
 // + creates some pins on our own
 // + creates some ro segs
 // We can add more mechanisms here.
-#define STRESS_REGIONS
+//#define STRESS_REGIONS
 #endif //USE_REGIONS
 
 // FEATURE_STRUCTALIGN was added by Midori. In CLR we are not interested
diff --git a/src/coreclr/gc/unix/gcenv.unix.cpp b/src/coreclr/gc/unix/gcenv.unix.cpp
index 9408a9b121406e..d2798c860adee5 100644
--- a/src/coreclr/gc/unix/gcenv.unix.cpp
+++ b/src/coreclr/gc/unix/gcenv.unix.cpp
@@ -884,7 +884,7 @@ static size_t GetLogicalProcessorCacheSizeFromOS()
     cacheSize = std::max(cacheSize, ( size_t) sysconf(_SC_LEVEL4_CACHE_SIZE));
 #endif
 
-#if defined(TARGET_LINUX) && !defined(HOST_ARM)
+#if defined(TARGET_LINUX) && !defined(HOST_ARM) && !defined(HOST_X86)
     if (cacheSize == 0)
     {
         //
diff --git a/src/coreclr/gcinfo/CMakeLists.txt b/src/coreclr/gcinfo/CMakeLists.txt
index 70b0f7396d89b3..bfddaee4b700af 100644
--- a/src/coreclr/gcinfo/CMakeLists.txt
+++ b/src/coreclr/gcinfo/CMakeLists.txt
@@ -82,3 +82,7 @@ create_gcinfo_lib(TARGET gcinfo_unix_armel OS unix ARCH armel)
 create_gcinfo_lib(TARGET gcinfo_unix_arm OS unix ARCH arm)
 create_gcinfo_lib(TARGET gcinfo_win_arm OS win ARCH arm)
 create_gcinfo_lib(TARGET gcinfo_win_x86 OS win ARCH x86)
+
+if (CLR_CMAKE_TARGET_ARCH_I386 AND CLR_CMAKE_TARGET_UNIX)
+  create_gcinfo_lib(TARGET gcinfo_unix_x86 OS unix ARCH x86)
+endif (CLR_CMAKE_TARGET_ARCH_I386 AND CLR_CMAKE_TARGET_UNIX)
diff --git a/src/coreclr/inc/CrstTypes.def b/src/coreclr/inc/CrstTypes.def
index 185a590d938e54..c48872a0b94243 100644
--- a/src/coreclr/inc/CrstTypes.def
+++ b/src/coreclr/inc/CrstTypes.def
@@ -433,7 +433,7 @@ Crst SingleUseLock
 End
 
 Crst UnwindInfoTableLock
-	AcquiredAfter StubUnwindInfoHeapSegments SingleUseLock
+    AcquiredAfter StubUnwindInfoHeapSegments SingleUseLock
     AcquiredBefore StressLog
 End
 
diff --git a/src/coreclr/inc/clrconfigvalues.h b/src/coreclr/inc/clrconfigvalues.h
index 5dc7e5d34b20bd..3f21e41dfa3693 100644
--- a/src/coreclr/inc/clrconfigvalues.h
+++ b/src/coreclr/inc/clrconfigvalues.h
@@ -504,6 +504,10 @@ RETAIL_CONFIG_STRING_INFO_EX(EXTERNAL_CORECLR_PROFILER_PATH_32, W("CORECLR_PROFI
 RETAIL_CONFIG_STRING_INFO_EX(EXTERNAL_CORECLR_PROFILER_PATH_64, W("CORECLR_PROFILER_PATH_64"), "CoreCLR only: Specifies the path to the DLL of profiler to load into currently running 64 process", CLRConfig::LookupOptions::DontPrependPrefix)
 RETAIL_CONFIG_STRING_INFO_EX(EXTERNAL_CORECLR_PROFILER_PATH_ARM32, W("CORECLR_PROFILER_PATH_ARM32"), "CoreCLR only: Specifies the path to the DLL of profiler to load into currently running ARM32 process", CLRConfig::LookupOptions::DontPrependPrefix)
 RETAIL_CONFIG_STRING_INFO_EX(EXTERNAL_CORECLR_PROFILER_PATH_ARM64, W("CORECLR_PROFILER_PATH_ARM64"), "CoreCLR only: Specifies the path to the DLL of profiler to load into currently running ARM64 process", CLRConfig::LookupOptions::DontPrependPrefix)
+RETAIL_CONFIG_DWORD_INFO_EX(EXTERNAL_CORECLR_ENABLE_NOTIFICATION_PROFILERS, W("CORECLR_ENABLE_NOTIFICATION_PROFILERS"), 0, "Set to 0 to disable loading notification profilers.", CLRConfig::LookupOptions::DontPrependPrefix)
+RETAIL_CONFIG_STRING_INFO_EX(EXTERNAL_CORECLR_NOTIFICATION_PROFILERS_64, W("CORECLR_NOTIFICATION_PROFILERS_64"), "A semi-colon separated list of notification profilers to load in the form \"path={guid}\"", CLRConfig::LookupOptions::DontPrependPrefix)
+RETAIL_CONFIG_STRING_INFO_EX(EXTERNAL_CORECLR_NOTIFICATION_PROFILERS_32, W("CORECLR_NOTIFICATION_PROFILERS_32"), "A semi-colon separated list of notification profilers to load in the form \"path={guid}\"", CLRConfig::LookupOptions::DontPrependPrefix)
+RETAIL_CONFIG_STRING_INFO_EX(EXTERNAL_CORECLR_NOTIFICATION_PROFILERS, W("CORECLR_NOTIFICATION_PROFILERS"), "A semi-colon separated list of notification profilers to load in the form \"path={guid}\"", CLRConfig::LookupOptions::DontPrependPrefix)
 RETAIL_CONFIG_STRING_INFO_EX(EXTERNAL_ProfAPI_ProfilerCompatibilitySetting, W("ProfAPI_ProfilerCompatibilitySetting"), "Specifies the profiler loading policy (the default is not to load a V2 profiler in V4)", CLRConfig::LookupOptions::TrimWhiteSpaceFromStringValue)
 RETAIL_CONFIG_DWORD_INFO(EXTERNAL_ProfAPI_DetachMinSleepMs, W("ProfAPI_DetachMinSleepMs"), 0, "The minimum time, in milliseconds, the CLR will wait before checking whether a profiler that is in the process of detaching is ready to be unloaded.")
 RETAIL_CONFIG_DWORD_INFO(EXTERNAL_ProfAPI_DetachMaxSleepMs, W("ProfAPI_DetachMaxSleepMs"), 0, "The maximum time, in milliseconds, the CLR will wait before checking whether a profiler that is in the process of detaching is ready to be unloaded.")
diff --git a/src/coreclr/inc/corcompile.h b/src/coreclr/inc/corcompile.h
index 2fb5d6fabc7f96..283124c15b9509 100644
--- a/src/coreclr/inc/corcompile.h
+++ b/src/coreclr/inc/corcompile.h
@@ -702,6 +702,9 @@ enum CORCOMPILE_FIXUP_BLOB_KIND
     ENCODE_VERIFY_FIELD_OFFSET,                     /* Used for the R2R compiler can generate a check against the real field offset used at runtime */
     ENCODE_VERIFY_TYPE_LAYOUT,                      /* Used for the R2R compiler can generate a check against the real type layout used at runtime */
 
+    ENCODE_CHECK_VIRTUAL_FUNCTION_OVERRIDE,         /* Generate a runtime check to ensure that virtual function resolution has equivalent behavior at runtime as at compile time. If not equivalent, code will not be used */
+    ENCODE_VERIFY_VIRTUAL_FUNCTION_OVERRIDE,        /* Generate a runtime check to ensure that virtual function resolution has equivalent behavior at runtime as at compile time. If not equivalent, generate runtime failure. */
+
     ENCODE_MODULE_HANDLE                = 0x50,     /* Module token */
     ENCODE_STATIC_FIELD_ADDRESS,                    /* For accessing a static field */
     ENCODE_MODULE_ID_FOR_STATICS,                   /* For accessing static fields */
@@ -724,6 +727,7 @@ enum EncodeMethodSigFlags
     ENCODE_METHOD_SIG_MemberRefToken            = 0x10,
     ENCODE_METHOD_SIG_Constrained               = 0x20,
     ENCODE_METHOD_SIG_OwnerType                 = 0x40,
+    ENCODE_METHOD_SIG_UpdateContext             = 0x80,
 };
 
 enum EncodeFieldSigFlags
diff --git a/src/coreclr/inc/corinfo.h b/src/coreclr/inc/corinfo.h
index c2fde45f84fc52..abf5527d0016cc 100644
--- a/src/coreclr/inc/corinfo.h
+++ b/src/coreclr/inc/corinfo.h
@@ -1604,18 +1604,24 @@ struct CORINFO_CALL_INFO
 
 enum CORINFO_DEVIRTUALIZATION_DETAIL
 {
-    CORINFO_DEVIRTUALIZATION_UNKNOWN,         // no details available
-    CORINFO_DEVIRTUALIZATION_SUCCESS,         // devirtualization was successful
-    CORINFO_DEVIRTUALIZATION_FAILED_CANON,    // object class was canonical
-    CORINFO_DEVIRTUALIZATION_FAILED_COM,      // object class was com
-    CORINFO_DEVIRTUALIZATION_FAILED_CAST,     // object class could not be cast to interface class
-    CORINFO_DEVIRTUALIZATION_FAILED_LOOKUP,   // interface method could not be found
-    CORINFO_DEVIRTUALIZATION_FAILED_DIM,      // interface method was default interface method
-    CORINFO_DEVIRTUALIZATION_FAILED_SUBCLASS, // object not subclass of base class
-    CORINFO_DEVIRTUALIZATION_FAILED_SLOT,     // virtual method installed via explicit override
-    CORINFO_DEVIRTUALIZATION_FAILED_BUBBLE,   // devirtualization crossed version bubble
-    CORINFO_DEVIRTUALIZATION_MULTIPLE_IMPL,   // object has multiple implementations of interface class
-    CORINFO_DEVIRTUALIZATION_COUNT,           // sentinel for maximum value
+    CORINFO_DEVIRTUALIZATION_UNKNOWN,                              // no details available
+    CORINFO_DEVIRTUALIZATION_SUCCESS,                              // devirtualization was successful
+    CORINFO_DEVIRTUALIZATION_FAILED_CANON,                         // object class was canonical
+    CORINFO_DEVIRTUALIZATION_FAILED_COM,                           // object class was com
+    CORINFO_DEVIRTUALIZATION_FAILED_CAST,                          // object class could not be cast to interface class
+    CORINFO_DEVIRTUALIZATION_FAILED_LOOKUP,                        // interface method could not be found
+    CORINFO_DEVIRTUALIZATION_FAILED_DIM,                           // interface method was default interface method
+    CORINFO_DEVIRTUALIZATION_FAILED_SUBCLASS,                      // object not subclass of base class
+    CORINFO_DEVIRTUALIZATION_FAILED_SLOT,                          // virtual method installed via explicit override
+    CORINFO_DEVIRTUALIZATION_FAILED_BUBBLE,                        // devirtualization crossed version bubble
+    CORINFO_DEVIRTUALIZATION_MULTIPLE_IMPL,                        // object has multiple implementations of interface class
+    CORINFO_DEVIRTUALIZATION_FAILED_BUBBLE_CLASS_DECL,             // decl method is defined on class and decl method not in version bubble, and decl method not in closest to version bubble
+    CORINFO_DEVIRTUALIZATION_FAILED_BUBBLE_INTERFACE_DECL,         // decl method is defined on interface and not in version bubble, and implementation type not entirely defined in bubble
+    CORINFO_DEVIRTUALIZATION_FAILED_BUBBLE_IMPL,                   // object class not defined within version bubble
+    CORINFO_DEVIRTUALIZATION_FAILED_BUBBLE_IMPL_NOT_REFERENCEABLE, // object class cannot be referenced from R2R code due to missing tokens
+    CORINFO_DEVIRTUALIZATION_FAILED_DUPLICATE_INTERFACE,           // crossgen2 virtual method algorithm and runtime algorithm differ in the presence of duplicate interface implementations
+    CORINFO_DEVIRTUALIZATION_FAILED_DECL_NOT_REPRESENTABLE,        // Decl method cannot be represented in R2R image
+    CORINFO_DEVIRTUALIZATION_COUNT,                                // sentinel for maximum value
 };
 
 struct CORINFO_DEVIRTUALIZATION_INFO
@@ -1626,6 +1632,7 @@ struct CORINFO_DEVIRTUALIZATION_INFO
     CORINFO_METHOD_HANDLE       virtualMethod;
     CORINFO_CLASS_HANDLE        objClass;
     CORINFO_CONTEXT_HANDLE      context;
+    CORINFO_RESOLVED_TOKEN     *pResolvedTokenVirtualMethod;
 
     //
     // [Out] results of resolveVirtualMethod.
@@ -1634,11 +1641,15 @@ struct CORINFO_DEVIRTUALIZATION_INFO
     // - requiresInstMethodTableArg is set to TRUE if the devirtualized method requires a type handle arg.
     // - exactContext is set to wrapped CORINFO_CLASS_HANDLE of devirt'ed method table.
     // - details on the computation done by the jit host
+    // - If pResolvedTokenDevirtualizedMethod is not set to NULL and targetting an R2R image
+    //   use it as the parameter to getCallInfo
     //
     CORINFO_METHOD_HANDLE           devirtualizedMethod;
     bool                            requiresInstMethodTableArg;
     CORINFO_CONTEXT_HANDLE          exactContext;
     CORINFO_DEVIRTUALIZATION_DETAIL detail;
+    CORINFO_RESOLVED_TOKEN          resolvedTokenDevirtualizedMethod;
+    CORINFO_RESOLVED_TOKEN          resolvedTokenDevirtualizedUnboxedMethod;
 };
 
 //----------------------------------------------------------------------------
diff --git a/src/coreclr/inc/corprof.idl b/src/coreclr/inc/corprof.idl
index 74fb809928125f..8fc965a84f6b59 100644
--- a/src/coreclr/inc/corprof.idl
+++ b/src/coreclr/inc/corprof.idl
@@ -475,6 +475,7 @@ typedef enum
     // and ThreadNameChanged callbacks.
     COR_PRF_MONITOR_THREADS             = 0x00000200,
 
+    // CORECLR DEPRECATION WARNING: Remoting no longer exists in coreclr
     // MONITOR_REMOTING controls the Remoting*
     // callbacks.
     COR_PRF_MONITOR_REMOTING            = 0x00000400,
@@ -492,10 +493,12 @@ typedef enum
     // callbacks.
     COR_PRF_MONITOR_CCW                 = 0x00002000,
 
+    // CORECLR DEPRECATION WARNING: Remoting no longer exists in coreclr
     // MONITOR_REMOTING_COOKIE controls whether
     // a cookie will be passed to the Remoting* callbacks
     COR_PRF_MONITOR_REMOTING_COOKIE     = 0x00004000 | COR_PRF_MONITOR_REMOTING,
 
+    // CORECLR DEPRECATION WARNING: Remoting no longer exists in coreclr
     // MONITOR_REMOTING_ASYNC controls whether
     // the Remoting* callbacks will monitor async events
     COR_PRF_MONITOR_REMOTING_ASYNC      = 0x00008000 | COR_PRF_MONITOR_REMOTING,
@@ -594,6 +597,28 @@ typedef enum
                                           COR_PRF_MONITOR_JIT_COMPILATION |
                                           COR_PRF_ENABLE_REJIT,
 
+    COR_PRF_ALLOWABLE_NOTIFICATION_PROFILER
+                                        =     COR_PRF_MONITOR_FUNCTION_UNLOADS |
+                                              COR_PRF_MONITOR_CLASS_LOADS |
+                                              COR_PRF_MONITOR_MODULE_LOADS |
+                                              COR_PRF_MONITOR_ASSEMBLY_LOADS |
+                                              COR_PRF_MONITOR_APPDOMAIN_LOADS |
+                                              COR_PRF_MONITOR_JIT_COMPILATION |
+                                              COR_PRF_MONITOR_EXCEPTIONS |
+                                              COR_PRF_MONITOR_OBJECT_ALLOCATED |
+                                              COR_PRF_MONITOR_THREADS |
+                                              COR_PRF_MONITOR_CODE_TRANSITIONS |
+                                              COR_PRF_MONITOR_CCW |
+                                              COR_PRF_MONITOR_SUSPENDS |
+                                              COR_PRF_MONITOR_CACHE_SEARCHES |
+                                              COR_PRF_DISABLE_INLINING |
+                                              COR_PRF_DISABLE_OPTIMIZATIONS |
+                                              COR_PRF_ENABLE_OBJECT_ALLOCATED |
+                                              COR_PRF_MONITOR_CLR_EXCEPTIONS |
+                                              COR_PRF_ENABLE_STACK_SNAPSHOT |
+                                              COR_PRF_USE_PROFILE_IMAGES |
+                                              COR_PRF_DISABLE_ALL_NGEN_IMAGES,
+
     // MONITOR_IMMUTABLE represents all flags that may only be set during initialization.
     // Trying to change any of these flags elsewhere will result in a
     // failed HRESULT.
@@ -621,6 +646,7 @@ typedef enum
 {
     COR_PRF_HIGH_MONITOR_NONE                       = 0x00000000,
 
+    // CORECLR DEPRECATION WARNING: This flag is no longer checked by the runtime
     COR_PRF_HIGH_ADD_ASSEMBLY_REFERENCES            = 0x00000001,
 
     COR_PRF_HIGH_IN_MEMORY_SYMBOLS_UPDATED          = 0x00000002,
@@ -648,6 +674,15 @@ typedef enum
                                                       COR_PRF_HIGH_MONITOR_LARGEOBJECT_ALLOCATED |
                                                       COR_PRF_HIGH_MONITOR_EVENT_PIPE,
 
+    COR_PRF_HIGH_ALLOWABLE_NOTIFICATION_PROFILER
+                                        =     COR_PRF_HIGH_IN_MEMORY_SYMBOLS_UPDATED |
+                                              COR_PRF_HIGH_MONITOR_DYNAMIC_FUNCTION_UNLOADS |
+                                              COR_PRF_HIGH_DISABLE_TIERED_COMPILATION |
+                                              COR_PRF_HIGH_BASIC_GC |
+                                              COR_PRF_HIGH_MONITOR_GC_MOVED_OBJECTS |
+                                              COR_PRF_HIGH_MONITOR_LARGEOBJECT_ALLOCATED |
+                                              COR_PRF_HIGH_MONITOR_EVENT_PIPE,
+
     // MONITOR_IMMUTABLE represents all flags that may only be set during initialization.
     // Trying to change any of these flags elsewhere will result in a
     // failed HRESULT.
@@ -2433,6 +2468,7 @@ interface ICorProfilerCallback5 : ICorProfilerCallback4
 ]
 interface ICorProfilerCallback6 : ICorProfilerCallback5
 {
+    // CORECLR DEPRECATION WARNING: This callback does not occur on coreclr.
     // Controlled by the COR_PRF_HIGH_ADD_ASSEMBLY_REFERENCES event mask flag.
     // Notifies the profiler of a very early stage in the loading of an Assembly, where the CLR
     // performs an assembly reference closure walk.  This is useful ONLY if the profiler will need
@@ -2555,6 +2591,17 @@ interface ICorProfilerCallback10 : ICorProfilerCallback9
     HRESULT EventPipeProviderCreated([in] EVENTPIPE_PROVIDER provider);
 }
 
+[
+    object,
+    uuid(42350846-AAED-47F7-B128-FD0C98881CDE),
+    pointer_default(unique),
+    local
+]
+interface ICorProfilerCallback11 : ICorProfilerCallback10
+{
+    HRESULT LoadAsNotficationOnly(BOOL *pbNotificationOnly);
+}
+
 /*
  * COR_PRF_CODEGEN_FLAGS controls various flags and hooks for a specific
  * method.  A combination of COR_PRF_CODEGEN_FLAGS is provided by the
diff --git a/src/coreclr/inc/crosscomp.h b/src/coreclr/inc/crosscomp.h
index d5d8cc8bd70b0d..0874603640b3b0 100644
--- a/src/coreclr/inc/crosscomp.h
+++ b/src/coreclr/inc/crosscomp.h
@@ -422,6 +422,8 @@ enum
 #define DAC_CS_NATIVE_DATA_SIZE 76
 #elif defined(TARGET_LINUX) && defined(TARGET_AMD64)
 #define DAC_CS_NATIVE_DATA_SIZE 96
+#elif defined(TARGET_LINUX) && defined(TARGET_S390X)
+#define DAC_CS_NATIVE_DATA_SIZE 96
 #elif defined(TARGET_NETBSD) && defined(TARGET_AMD64)
 #define DAC_CS_NATIVE_DATA_SIZE 96
 #elif defined(TARGET_NETBSD) && defined(TARGET_ARM)
diff --git a/src/coreclr/inc/executableallocator.h b/src/coreclr/inc/executableallocator.h
new file mode 100644
index 00000000000000..ce0c6c22f890e6
--- /dev/null
+++ b/src/coreclr/inc/executableallocator.h
@@ -0,0 +1,81 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+
+//
+// Allocator and holders for double mapped executable memory
+//
+
+#pragma once
+
+#include "utilcode.h"
+#include "ex.h"
+
+// Holder class to map read-execute memory as read-write so that it can be modified without using read-write-execute mapping.
+// At the moment the implementation is dummy, returning the same addresses for both cases and expecting them to be read-write-execute.
+// The class uses the move semantics to ensure proper unmapping in case of re-assigning of the holder value.
+template<typename T>
+class ExecutableWriterHolder
+{
+    T *m_addressRX;
+    T *m_addressRW;
+
+    void Move(ExecutableWriterHolder& other)
+    {
+        m_addressRX = other.m_addressRX;
+        m_addressRW = other.m_addressRW;
+        other.m_addressRX = NULL;
+        other.m_addressRW = NULL;
+    }
+
+    void Unmap()
+    {
+        if (m_addressRX != NULL)
+        {
+            // TODO: mapping / unmapping for targets using double memory mapping  will be added with the double mapped allocator addition 
+#if defined(HOST_OSX) && defined(HOST_ARM64) && !defined(DACCESS_COMPILE)
+            PAL_JitWriteProtect(false);
+#endif
+        }
+    }
+
+public:
+    ExecutableWriterHolder(const ExecutableWriterHolder& other) = delete;
+    ExecutableWriterHolder& operator=(const ExecutableWriterHolder& other) = delete;
+
+    ExecutableWriterHolder(ExecutableWriterHolder&& other)
+    {
+        Move(other);
+    }
+
+    ExecutableWriterHolder& operator=(ExecutableWriterHolder&& other)
+    {
+        Unmap();
+        Move(other);
+        return *this;
+    }
+
+    ExecutableWriterHolder() : m_addressRX(nullptr), m_addressRW(nullptr)
+    {
+    }
+
+    ExecutableWriterHolder(T* addressRX, size_t size)
+    {
+        m_addressRX = addressRX;
+        m_addressRW = addressRX;
+#if defined(HOST_OSX) && defined(HOST_ARM64) && !defined(DACCESS_COMPILE)
+        PAL_JitWriteProtect(true);
+#endif
+    }
+
+    ~ExecutableWriterHolder()
+    {
+        Unmap();
+    }
+
+    // Get the writeable address
+    inline T *GetRW() const
+    {
+        return m_addressRW;
+    }
+};
diff --git a/src/coreclr/inc/gcmsg.inl b/src/coreclr/inc/gcmsg.inl
new file mode 100644
index 00000000000000..f6e1f7227a1c45
--- /dev/null
+++ b/src/coreclr/inc/gcmsg.inl
@@ -0,0 +1,132 @@
+
+    static const char* gcStartMsg()
+    {
+        STATIC_CONTRACT_LEAF;
+        return "{ =========== BEGINGC %d, (requested generation = %lu, collect_classes = %lu) ==========\n";
+    }
+
+    static const char* gcEndMsg()
+    {
+        STATIC_CONTRACT_LEAF;
+        return "========== ENDGC %d (gen = %lu, collect_classes = %lu) ===========}\n";
+    }
+
+    static const char* gcRootMsg()
+    {
+        STATIC_CONTRACT_LEAF;
+        return "    GC Root %p RELOCATED %p -> %p  MT = %pT\n";
+    }
+
+    static const char* gcRootPromoteMsg()
+    {
+        STATIC_CONTRACT_LEAF;
+        return "    IGCHeap::Promote: Promote GC Root *%p = %p MT = %pT\n";
+    }
+
+    static const char* gcPlugMoveMsg()
+    {
+        STATIC_CONTRACT_LEAF;
+        return "GC_HEAP RELOCATING Objects in heap within range [%p %p) by -0x%x bytes\n";
+    }
+
+    static const char* gcServerThread0StartMsg()
+    {
+        STATIC_CONTRACT_LEAF;
+        return "%d gc thread waiting...";
+    }
+
+    static const char* gcServerThreadNStartMsg()
+    {
+        STATIC_CONTRACT_LEAF;
+        return "%d gc thread waiting... Done";
+    }
+
+    static const char* gcDetailedStartMsg()
+    {
+        STATIC_CONTRACT_LEAF;
+        return "*GC* %d(gen0:%d)(%d)(alloc: %Id)(%s)(%d)";
+    }
+
+    static const char* gcDetailedEndMsg()
+    {
+        STATIC_CONTRACT_LEAF;
+        return "*EGC* %Id(gen0:%Id)(%Id)(%d)(%s)(%s)(%s)(ml: %d->%d)";
+    }
+
+    static const char* gcStartMarkMsg()
+    {
+        STATIC_CONTRACT_LEAF;
+        return "---- Mark Phase on heap %d condemning %d ----";
+    }
+
+    static const char* gcStartPlanMsg()
+    {
+        STATIC_CONTRACT_LEAF;
+        return "---- Plan Phase on heap %d ---- Condemned generation %d, promotion: %d";
+    }
+
+    static const char* gcStartRelocateMsg()
+    {
+        STATIC_CONTRACT_LEAF;
+        return "---- Relocate phase on heap %d -----";
+    }
+
+    static const char* gcEndRelocateMsg()
+    {
+        STATIC_CONTRACT_LEAF;
+        return "---- End of Relocate phase on heap %d ----";
+    }
+
+    static const char* gcStartCompactMsg()
+    {
+        STATIC_CONTRACT_LEAF;
+        return "---- Compact Phase on heap %d: %Ix(%Ix)----";
+    }
+
+    static const char* gcEndCompactMsg()
+    {
+        STATIC_CONTRACT_LEAF;
+        return "---- End of Compact phase on heap %d ----";
+    }
+
+    static const char* gcMemCopyMsg()
+    {
+        STATIC_CONTRACT_LEAF;
+        return " mc: [%Ix->%Ix, %Ix->%Ix[";
+    }
+
+    static const char* gcPlanPlugMsg()
+    {
+        STATIC_CONTRACT_LEAF;
+        return "(%Ix)[%Ix->%Ix, NA: [%Ix(%Id), %Ix[: %Ix(%d), x: %Ix (%s)";
+    }
+
+    static const char* gcPlanPinnedPlugMsg()
+    {
+        STATIC_CONTRACT_LEAF;
+        return "(%Ix)PP: [%Ix, %Ix[%Ix](m:%d)";
+    }
+
+    static const char* gcDesiredNewAllocationMsg()
+    {
+        STATIC_CONTRACT_LEAF;
+        return "h%d g%d surv: %Id current: %Id alloc: %Id (%d%%) f: %d%% new-size: %Id new-alloc: %Id";
+    }
+
+    static const char* gcMakeUnusedArrayMsg()
+    {
+        STATIC_CONTRACT_LEAF;
+        return "Making unused array [%Ix, %Ix[";
+    }
+
+    static const char* gcStartBgcThread()
+    {
+        STATIC_CONTRACT_LEAF;
+        return "beginning of bgc on heap %d: gen2 FL: %d, FO: %d, frag: %d";
+    }
+
+    static const char* gcRelocateReferenceMsg()
+    {
+        STATIC_CONTRACT_LEAF;
+        return "Relocating reference *(%p) from %p to %p";
+    }
diff --git a/src/coreclr/inc/holder.h b/src/coreclr/inc/holder.h
index 20f6aeb964614a..448610634a6129 100644
--- a/src/coreclr/inc/holder.h
+++ b/src/coreclr/inc/holder.h
@@ -934,11 +934,17 @@ using NonVMComHolder = SpecializedWrapper<_TYPE, DoTheRelease<_TYPE>>;
 //  } // foo->DecRef() on out of scope
 //
 //-----------------------------------------------------------------------------
+template<typename _TYPE>
+class ExecutableWriterHolder;
+
 template <typename TYPE>
 FORCEINLINE void StubRelease(TYPE* value)
 {
     if (value)
-        value->DecRef();
+    {
+        ExecutableWriterHolder<TYPE> stubWriterHolder(value, sizeof(TYPE));
+        stubWriterHolder.GetRW()->DecRef();
+    }
 }
 
 template<typename _TYPE>
diff --git a/src/coreclr/inc/jiteeversionguid.h b/src/coreclr/inc/jiteeversionguid.h
index 25746b45992942..225c73008bb297 100644
--- a/src/coreclr/inc/jiteeversionguid.h
+++ b/src/coreclr/inc/jiteeversionguid.h
@@ -43,11 +43,11 @@ typedef const GUID *LPCGUID;
 #define GUID_DEFINED
 #endif // !GUID_DEFINED
 
-constexpr GUID JITEEVersionIdentifier = { /* 1052f490-cad7-4610-99bb-6f2bd91a1d19 */
-    0x1052f490,
-    0xcad7,
-    0x4610,
-    {0x99, 0xbb, 0x6f, 0x2b, 0xd9, 0x1a, 0x1d, 0x19}
+constexpr GUID JITEEVersionIdentifier = { /* de9a9a0e-c66a-4d97-a268-92a31f99d919 */
+    0xde9a9a0e,
+    0xc66a,
+    0x4d97,
+    {0xa2, 0x68, 0x92, 0xa3, 0x1f, 0x99, 0xd9, 0x19}
   };
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/coreclr/inc/loaderheap.h b/src/coreclr/inc/loaderheap.h
index 96fec35be0ce4c..ac0669a55867f3 100644
--- a/src/coreclr/inc/loaderheap.h
+++ b/src/coreclr/inc/loaderheap.h
@@ -16,6 +16,7 @@
 
 #include "utilcode.h"
 #include "ex.h"
+#include "executableallocator.h"
 
 //==============================================================================
 // Interface used to back out loader heap allocations.
@@ -553,10 +554,6 @@ class LoaderHeap : public UnlockedLoaderHeap, public ILoaderHeapBackout
     {
         WRAPPER_NO_CONTRACT;
 
-#if defined(HOST_OSX) && defined(HOST_ARM64)
-        auto jitWriteEnableHolder = PAL_JITWriteEnable(true);
-#endif // defined(HOST_OSX) && defined(HOST_ARM64)
-
         void *pResult;
         TaggedMemAllocPtr tmap;
 
@@ -633,10 +630,6 @@ class LoaderHeap : public UnlockedLoaderHeap, public ILoaderHeapBackout
     {
         WRAPPER_NO_CONTRACT;
 
-#if defined(HOST_OSX) && defined(HOST_ARM64)
-        auto jitWriteEnableHolder = PAL_JITWriteEnable(true);
-#endif // defined(HOST_OSX) && defined(HOST_ARM64)
-
         CRITSEC_Holder csh(m_CriticalSection);
 
 
diff --git a/src/coreclr/inc/patchpointinfo.h b/src/coreclr/inc/patchpointinfo.h
index e01446beb42916..1445d8f79bce9c 100644
--- a/src/coreclr/inc/patchpointinfo.h
+++ b/src/coreclr/inc/patchpointinfo.h
@@ -66,6 +66,11 @@ struct PatchpointInfo
         return m_genericContextArgOffset;
     }
 
+    bool HasGenericContextArgOffset() const
+    {
+        return m_genericContextArgOffset != -1;
+    }
+
     void SetGenericContextArgOffset(int offset)
     {
         m_genericContextArgOffset = offset;
diff --git a/src/coreclr/inc/pedecoder.h b/src/coreclr/inc/pedecoder.h
index b551bf02d62254..66f25747317e65 100644
--- a/src/coreclr/inc/pedecoder.h
+++ b/src/coreclr/inc/pedecoder.h
@@ -81,6 +81,8 @@ inline CHECK CheckOverflow(RVA value1, COUNT_T value2)
 #define IMAGE_FILE_MACHINE_NATIVE   IMAGE_FILE_MACHINE_ARMNT
 #elif defined(TARGET_ARM64)
 #define IMAGE_FILE_MACHINE_NATIVE   IMAGE_FILE_MACHINE_ARM64
+#elif defined(TARGET_S390X)
+#define IMAGE_FILE_MACHINE_NATIVE   IMAGE_FILE_MACHINE_UNKNOWN
 #else
 #error "port me"
 #endif
diff --git a/src/coreclr/inc/profilepriv.h b/src/coreclr/inc/profilepriv.h
index bd5533f12c6fc8..75d1c3dbcc29bb 100644
--- a/src/coreclr/inc/profilepriv.h
+++ b/src/coreclr/inc/profilepriv.h
@@ -16,8 +16,15 @@
 
 // Forward declarations
 class EEToProfInterfaceImpl;
+class ProfToEEInterfaceImpl;
 class Object;
 struct ScanContext;
+enum EtwGCRootFlags: int32_t;
+enum EtwGCRootKind: int32_t;
+struct IAssemblyBindingClosure;
+struct AssemblyReferenceClosureWalkContextForProfAPI;
+
+#include "eventpipeadaptertypes.h"
 
 #if defined (PROFILING_SUPPORTED_DATA) || defined(PROFILING_SUPPORTED)
 #ifndef PROFILING_SUPPORTED_DATA
@@ -25,6 +32,9 @@ struct ScanContext;
 #endif  // PROFILING_SUPPORTED_DATA
 
 #include "corprof.h"
+#include "slist.h"
+
+#define MAX_NOTIFICATION_PROFILERS 32
 
 //---------------------------------------------------------------------------------------
 // Enumerates the various init states of profiling.
@@ -55,33 +65,183 @@ class CurrentProfilerStatus
     void Set(ProfilerStatus profStatus);
 };
 
-// ---------------------------------------------------------------------------------------
-// Global struct that lets the EE see the load status of the profiler, and provides a
-// pointer (pProfInterface) through which profiler calls can be made
-//
-// When you are adding new session, please refer to
-// code:ProfControlBlock::ResetPerSessionStatus#ProfileResetSessionStatus for more details.
-struct ProfControlBlock
+class EventMask
 {
+    friend class ProfControlBlock;
+private:
+    const UINT64 EventMaskLowMask           = 0x00000000FFFFFFFF;
+    const UINT64 EventMaskHighShiftAmount   = 32;
+    const UINT64 EventMaskHighMask          = 0xFFFFFFFF00000000;
+
+    Volatile<UINT64> m_eventMask;
+
+public:
+    EventMask() :
+        m_eventMask(0)
+    {
+
+    }
+
+    EventMask& operator=(const EventMask& other);
+
+    BOOL IsEventMaskSet(DWORD eventMask);
+    DWORD GetEventMask();
+    void SetEventMask(DWORD eventMask);
+    BOOL IsEventMaskHighSet(DWORD eventMaskHigh);
+    DWORD GetEventMaskHigh();
+    void SetEventMaskHigh(DWORD eventMaskHigh);
+};
+
+class ProfilerInfo
+{
+public:
     // **** IMPORTANT!! ****
     // All uses of pProfInterface must be properly synchronized to avoid the profiler
     // from detaching while the EE attempts to call into it.  The recommended way to do
-    // this is to use the (lockless) BEGIN_PIN_PROFILER / END_PIN_PROFILER macros.  See
-    // code:BEGIN_PIN_PROFILER for instructions.  For full details on how the
+    // this is to use the (lockless) BEGIN_PROFILER_CALLBACK / END_PROFILER_CALLBACK macros.  See
+    // code:BEGIN_PROFILER_CALLBACK for instructions.  For full details on how the
     // synchronization works, see
     // code:ProfilingAPIUtility::InitializeProfiling#LoadUnloadCallbackSynchronization
     VolatilePtr<EEToProfInterfaceImpl> pProfInterface;
     // **** IMPORTANT!! ****
 
-    DWORD dwEventMask;          // Original low event mask bits
-    DWORD dwEventMaskHigh;      // New high event mask bits
     CurrentProfilerStatus curProfStatus;
+    
+    EventMask eventMask;
+
+    //---------------------------------------------------------------
+    // m_dwProfilerEvacuationCounter keeps track of how many profiler
+    // callback calls remain on the stack
+    //---------------------------------------------------------------
+    // Why volatile?
+    // See code:ProfilingAPIUtility::InitializeProfiling#LoadUnloadCallbackSynchronization.
+    Volatile<DWORD> dwProfilerEvacuationCounter;
+
+    Volatile<BOOL> inUse;
+
+    // Reset those variables that is only for the current attach session
+    void ResetPerSessionStatus();
+    void Init();
+};
+
+enum class ProfilerCallbackType
+{
+    Active,
+    ActiveOrInitializing
+};
+
+// We need a way to track which profilers are in active calls, to synchronize with detach.
+// If we detached a profiler while it was actively in a callback there would be issues.
+// However, we don't want to pin all profilers, because then a chatty profiler could
+// cause another profiler to not be able to detach. We can't just check the event masks
+// before and after the call because it is legal for a profiler to change its event mask,
+// and then it would be possible for a profiler to permanently prevent itself from detaching.
+// 
+// WHEN IS EvacuationCounterHolder REQUIRED?
+// Answer: any time you access a ProfilerInfo *. There is a specific sequence that must be followed:
+//   - Do a dirty read of the Profiler interface
+//   - Increment an evacuation counter by using EvacuationCounterHolder as a RAII guard class
+//   - Now do a clean read of the ProfilerInfo's status - this will be changed during detach and
+//     is always read with a memory barrier
+//
+// The DoProfilerCallback/IterateProfilers functions automate this process for you, you should use
+// them unless you are absoultely sure you know what you're doing
+class EvacuationCounterHolder
+{
+private:
+    ProfilerInfo *m_pProfilerInfo;
+
+public:
+    EvacuationCounterHolder(ProfilerInfo *pProfilerInfo) :
+        m_pProfilerInfo(pProfilerInfo)
+    {
+        _ASSERTE(m_pProfilerInfo != NULL);
+        InterlockedIncrement((LONG *)(m_pProfilerInfo->dwProfilerEvacuationCounter.GetPointer()));
+    }
+
+    ~EvacuationCounterHolder()
+    {
+        InterlockedDecrement((LONG *)(m_pProfilerInfo->dwProfilerEvacuationCounter.GetPointer()));
+    }
+};
+
+struct StoredProfilerNode
+{
+    CLSID guid;
+    SString path;
+    SLink m_Link;
+};
+
+typedef SList<StoredProfilerNode, true> STOREDPROFILERLIST;
+// ---------------------------------------------------------------------------------------
+// Global struct that lets the EE see the load status of the profiler, and provides a
+// pointer (pProfInterface) through which profiler calls can be made
+//
+// When you are adding new session, please refer to
+// code:ProfControlBlock::ResetPerSessionStatus#ProfileResetSessionStatus for more details.
+class ProfControlBlock
+{
+private:
+    // IsProfilerPresent(pProfilerInfo) returns whether or not a CLR Profiler is actively loaded
+    // (meaning it's initialized and ready to receive callbacks).
+    FORCEINLINE BOOL IsProfilerPresent(ProfilerInfo *pProfilerInfo)
+    {
+        LIMITED_METHOD_DAC_CONTRACT;
+
+        return pProfilerInfo->curProfStatus.Get() >= kProfStatusActive;
+    }
+
+    FORCEINLINE BOOL IsProfilerPresentOrInitializing(ProfilerInfo *pProfilerInfo)
+    {
+        return pProfilerInfo->curProfStatus.Get() > kProfStatusDetaching;
+    }
+
+    template<typename Func, typename... Args>
+    FORCEINLINE VOID DoOneProfilerIteration(ProfilerInfo *pProfilerInfo, ProfilerCallbackType callbackType, Func callback, Args... args)
+    {
+        // This is the dirty read
+        if (pProfilerInfo->pProfInterface.Load() != NULL)
+        {
+#ifdef FEATURE_PROFAPI_ATTACH_DETACH
+            // Now indicate we are accessing the profiler
+            EvacuationCounterHolder evacuationCounter(pProfilerInfo);
+#endif // FEATURE_PROFAPI_ATTACH_DETACH
+            
+            if ((callbackType == ProfilerCallbackType::Active && IsProfilerPresent(pProfilerInfo))
+                || (callbackType == ProfilerCallbackType::ActiveOrInitializing && IsProfilerPresentOrInitializing(pProfilerInfo)))
+            {
+                callback(pProfilerInfo, args...);
+            }
+        }
+    }
+
+    template<typename Func, typename... Args>
+    FORCEINLINE VOID IterateProfilers(ProfilerCallbackType callbackType, Func callback, Args... args)
+    {
+        DoOneProfilerIteration(&mainProfilerInfo, callbackType, callback, args...);
+        
+        if (notificationProfilerCount > 0)
+        {
+            for (SIZE_T i = 0; i < MAX_NOTIFICATION_PROFILERS; ++i)
+            {
+                ProfilerInfo *current = &(notificationOnlyProfilers[i]);
+                DoOneProfilerIteration(current, callbackType, callback, args...);
+            }
+        }
+    }
+
+public:
     BOOL fGCInProgress;
     BOOL fBaseSystemClassesLoaded;
 
-    BOOL fIsStoredProfilerRegistered;
-    CLSID clsStoredProfilerGuid;
-    SString sStoredProfilerPath;
+    STOREDPROFILERLIST storedProfilers;
+
+    ProfilerInfo mainProfilerInfo;
+
+    ProfilerInfo notificationOnlyProfilers[MAX_NOTIFICATION_PROFILERS];
+    Volatile<LONG> notificationProfilerCount;
+
+    EventMask globalEventMask;
 
 #ifdef PROF_TEST_ONLY_FORCE_ELT_DATA
     // #TestOnlyELT This implements a test-only (and debug-only) hook that allows a test
@@ -118,14 +278,128 @@ struct ProfControlBlock
 #endif // _DEBUG
 
     // Whether we've turned off concurrent GC during attach
-    BOOL fConcurrentGCDisabledForAttach;
+    Volatile<BOOL> fConcurrentGCDisabledForAttach;
 
     Volatile<BOOL> fProfControlBlockInitialized;
 
     Volatile<BOOL> fProfilerRequestedRuntimeSuspend;
 
     void Init();
-    void ResetPerSessionStatus();
+    BOOL IsMainProfiler(EEToProfInterfaceImpl *pEEToProf);
+    BOOL IsMainProfiler(ProfToEEInterfaceImpl *pProfToEE);
+    ProfilerInfo *GetProfilerInfo(ProfToEEInterfaceImpl *pProfToEE);
+
+    template<typename ConditionFunc, typename CallbackFunc, typename Data = void, typename... Args>
+    FORCEINLINE HRESULT DoProfilerCallback(ProfilerCallbackType callbackType, ConditionFunc condition, Data *additionalData, CallbackFunc callback, Args... args)
+    {
+        HRESULT hr = S_OK;
+        IterateProfilers(callbackType,
+                         [](ProfilerInfo *pProfilerInfo, ConditionFunc condition, Data *additionalData, CallbackFunc callback, HRESULT *pHR, Args... args)
+                            {
+                                if (condition(pProfilerInfo))
+                                {
+                                    HRESULT innerHR = callback(additionalData, pProfilerInfo->pProfInterface, args...);
+                                    if (FAILED(innerHR))
+                                    {
+                                        *pHR = innerHR;
+                                    }
+                                }
+                            },
+                         condition, additionalData, callback, &hr, args...);
+        return hr;
+    }
+
+#ifndef DACCESS_COMPILE
+    ProfilerInfo *FindNextFreeProfilerInfoSlot();
+    void DeRegisterProfilerInfo(ProfilerInfo *pProfilerInfo);
+    void UpdateGlobalEventMask();
+#endif // DACCESS_COMPILE
+
+    BOOL IsCallback3Supported();
+    BOOL IsCallback5Supported();
+    BOOL IsDisableTransparencySet();
+    BOOL RequiresGenericsContextForEnterLeave();
+    UINT_PTR EEFunctionIDMapper(FunctionID funcId, BOOL * pbHookFunction);
+    
+    void ThreadCreated(ThreadID threadID);
+    void ThreadDestroyed(ThreadID threadID);
+    void ThreadAssignedToOSThread(ThreadID managedThreadId, DWORD osThreadId);
+    void ThreadNameChanged(ThreadID managedThreadId, ULONG cchName, WCHAR name[]);
+    void Shutdown();
+    void FunctionUnloadStarted(FunctionID functionId);
+    void JITCompilationFinished(FunctionID functionId, HRESULT hrStatus, BOOL fIsSafeToBlock);
+    void JITCompilationStarted(FunctionID functionId, BOOL fIsSafeToBlock);
+    void DynamicMethodJITCompilationStarted(FunctionID functionId, BOOL fIsSafeToBlock, LPCBYTE pILHeader, ULONG cbILHeader);
+    void DynamicMethodJITCompilationFinished(FunctionID functionId, HRESULT hrStatus, BOOL fIsSafeToBlock);
+    void DynamicMethodUnloaded(FunctionID functionId);
+    void JITCachedFunctionSearchStarted(FunctionID functionId, BOOL *pbUseCachedFunction);
+    void JITCachedFunctionSearchFinished(FunctionID functionId, COR_PRF_JIT_CACHE result);
+    HRESULT JITInlining(FunctionID callerId, FunctionID calleeId, BOOL *pfShouldInline);
+    void ReJITCompilationStarted(FunctionID functionId, ReJITID reJitId, BOOL fIsSafeToBlock);
+    HRESULT GetReJITParameters(ModuleID moduleId, mdMethodDef methodId, ICorProfilerFunctionControl *pFunctionControl);
+    void ReJITCompilationFinished(FunctionID functionId, ReJITID reJitId, HRESULT hrStatus, BOOL fIsSafeToBlock);
+    void ReJITError(ModuleID moduleId, mdMethodDef methodId, FunctionID functionId, HRESULT hrStatus);
+    void ModuleLoadStarted(ModuleID moduleId);
+    void ModuleLoadFinished(ModuleID moduleId, HRESULT hrStatus);
+    void ModuleUnloadStarted(ModuleID moduleId);
+    void ModuleUnloadFinished(ModuleID moduleId, HRESULT hrStatus);
+    void ModuleAttachedToAssembly(ModuleID moduleId, AssemblyID AssemblyId);
+    void ModuleInMemorySymbolsUpdated(ModuleID moduleId);
+    void ClassLoadStarted(ClassID classId);
+    void ClassLoadFinished(ClassID classId, HRESULT hrStatus);
+    void ClassUnloadStarted(ClassID classId);
+    void ClassUnloadFinished(ClassID classId, HRESULT hrStatus);
+    void AppDomainCreationStarted(AppDomainID appDomainId);
+    void AppDomainCreationFinished(AppDomainID appDomainId, HRESULT hrStatus);
+    void AppDomainShutdownStarted(AppDomainID appDomainId);
+    void AppDomainShutdownFinished(AppDomainID appDomainId, HRESULT hrStatus);
+    void AssemblyLoadStarted(AssemblyID assemblyId);
+    void AssemblyLoadFinished(AssemblyID assemblyId, HRESULT hrStatus);
+    void AssemblyUnloadStarted(AssemblyID assemblyId);
+    void AssemblyUnloadFinished(AssemblyID assemblyId, HRESULT hrStatus);
+    void UnmanagedToManagedTransition(FunctionID functionId, COR_PRF_TRANSITION_REASON reason);
+    void ManagedToUnmanagedTransition(FunctionID functionId, COR_PRF_TRANSITION_REASON reason);
+    void ExceptionThrown(ObjectID thrownObjectId);
+    void ExceptionSearchFunctionEnter(FunctionID functionId);
+    void ExceptionSearchFunctionLeave();
+    void ExceptionSearchFilterEnter(FunctionID funcId);
+    void ExceptionSearchFilterLeave();
+    void ExceptionSearchCatcherFound(FunctionID functionId);
+    void ExceptionOSHandlerEnter(FunctionID funcId);
+    void ExceptionOSHandlerLeave(FunctionID funcId);
+    void ExceptionUnwindFunctionEnter(FunctionID functionId);
+    void ExceptionUnwindFunctionLeave();
+    void ExceptionUnwindFinallyEnter(FunctionID functionId);
+    void ExceptionUnwindFinallyLeave();
+    void ExceptionCatcherEnter(FunctionID functionId, ObjectID objectId);
+    void ExceptionCatcherLeave();
+    void COMClassicVTableCreated(ClassID wrappedClassId, REFGUID implementedIID, void *pVTable, ULONG cSlots);
+    void RuntimeSuspendStarted(COR_PRF_SUSPEND_REASON suspendReason);
+    void RuntimeSuspendFinished();
+    void RuntimeSuspendAborted();
+    void RuntimeResumeStarted();
+    void RuntimeResumeFinished();
+    void RuntimeThreadSuspended(ThreadID suspendedThreadId);
+    void RuntimeThreadResumed(ThreadID resumedThreadId);
+    void ObjectAllocated(ObjectID objectId, ClassID classId);
+    void FinalizeableObjectQueued(BOOL isCritical, ObjectID objectID);
+    void MovedReference(BYTE *pbMemBlockStart, BYTE *pbMemBlockEnd, ptrdiff_t cbRelocDistance, void *pHeapId, BOOL fCompacting);
+    void EndMovedReferences(void *pHeapId);
+    void RootReference2(BYTE *objectId, EtwGCRootKind dwEtwRootKind, EtwGCRootFlags dwEtwRootFlags, void *rootID, void *pHeapId);
+    void EndRootReferences2(void *pHeapId);
+    void ConditionalWeakTableElementReference(BYTE *primaryObjectId, BYTE *secondaryObjectId, void *rootID, void *pHeapId);
+    void EndConditionalWeakTableElementReferences(void *pHeapId);
+    void AllocByClass(ObjectID objId, ClassID classId, void *pHeapId);
+    void EndAllocByClass(void *pHeapId);
+    HRESULT ObjectReference(ObjectID objId, ClassID classId, ULONG cNumRefs, ObjectID *arrObjRef);
+    void HandleCreated(UINT_PTR handleId, ObjectID initialObjectId);
+    void HandleDestroyed(UINT_PTR handleId);
+    void GarbageCollectionStarted(int cGenerations, BOOL generationCollected[], COR_PRF_GC_REASON reason);
+    void GarbageCollectionFinished();
+    void GetAssemblyReferences(LPCWSTR wszAssemblyPath, IAssemblyBindingClosure *pClosure, AssemblyReferenceClosureWalkContextForProfAPI *pContext);
+    void EventPipeEventDelivered(EventPipeProvider *provider, DWORD eventId, DWORD eventVersion, ULONG cbMetadataBlob, LPCBYTE metadataBlob, ULONG cbEventData, 
+                                 LPCBYTE eventData, LPCGUID pActivityId, LPCGUID pRelatedActivityId, Thread *pEventThread, ULONG numStackFrames, UINT_PTR stackFrames[]);
+    void EventPipeProviderCreated(EventPipeProvider *provider);
 };
 
 
diff --git a/src/coreclr/inc/profilepriv.inl b/src/coreclr/inc/profilepriv.inl
index 41e0bf3da96e9b..08ba58f5623f1c 100644
--- a/src/coreclr/inc/profilepriv.inl
+++ b/src/coreclr/inc/profilepriv.inl
@@ -17,7 +17,6 @@
 #include "eetoprofinterfaceimpl.h"
 #ifdef PROFILING_SUPPORTED
 #include "profilinghelper.h"
-BOOL CORProfilerBypassSecurityChecks();
 #endif // PROFILING_SUPPORTED
 
 //---------------------------------------------------------------------------------------
@@ -36,11 +35,1260 @@ inline ProfilerStatus CurrentProfilerStatus::Get()
     return m_profStatus;
 }
 
+inline EventMask& EventMask::operator=(const EventMask& other)
+{
+    m_eventMask = other.m_eventMask;
+    return *this;
+}
+
+inline BOOL EventMask::IsEventMaskSet(DWORD eventMask)
+{
+    return (GetEventMask() & eventMask) != 0;
+}
+
+inline DWORD EventMask::GetEventMask()
+{
+    return (DWORD)(m_eventMask & EventMaskLowMask);
+}
+
+inline void EventMask::SetEventMask(DWORD eventMask)
+{
+    m_eventMask = (m_eventMask & EventMaskHighMask) | (UINT64)eventMask;
+}
+
+inline BOOL EventMask::IsEventMaskHighSet(DWORD eventMaskHigh)
+{
+    return (GetEventMaskHigh() & eventMaskHigh) != 0;
+}
+
+inline DWORD EventMask::GetEventMaskHigh()
+{
+    return (DWORD)((m_eventMask & EventMaskHighMask) >> EventMaskHighShiftAmount);
+}
+
+inline void EventMask::SetEventMaskHigh(DWORD eventMaskHigh)
+{
+    m_eventMask = (m_eventMask & EventMaskLowMask) | ((UINT64)eventMaskHigh << EventMaskHighShiftAmount);
+}
+
+// Reset those variables that is only for the current attach session
+inline void ProfilerInfo::ResetPerSessionStatus()
+{
+    LIMITED_METHOD_CONTRACT;
+
+    pProfInterface = NULL;
+    eventMask.SetEventMask(COR_PRF_MONITOR_NONE);
+    eventMask.SetEventMaskHigh(COR_PRF_HIGH_MONITOR_NONE);
+}
+
+inline void ProfilerInfo::Init()
+{
+    curProfStatus.Init();
+    dwProfilerEvacuationCounter = 0;
+    ResetPerSessionStatus();
+    inUse = FALSE;
+}
+
+template<typename ConditionFunc>
+inline BOOL AnyProfilerPassesCondition(ConditionFunc condition)
+{
+    BOOL anyPassed = FALSE;
+    (&g_profControlBlock)->DoProfilerCallback(ProfilerCallbackType::ActiveOrInitializing,
+                                              condition, 
+                                              &anyPassed,
+                                              [](BOOL *pAnyPassed, VolatilePtr<EEToProfInterfaceImpl> profInterface)
+                                              {
+                                                   *pAnyPassed = TRUE;
+                                                   return S_OK;
+                                              });
+
+    return anyPassed;
+}
+
 //---------------------------------------------------------------------------------------
 // ProfControlBlock
 //---------------------------------------------------------------------------------------
 
-inline void ProfControlBlock::Init()
+inline void ProfControlBlock::Init()
+{
+    CONTRACTL
+    {
+        NOTHROW;
+        GC_NOTRIGGER;
+        CANNOT_TAKE_LOCK;
+    }
+    CONTRACTL_END;
+
+    mainProfilerInfo.Init();
+
+    for (SIZE_T i = 0; i < MAX_NOTIFICATION_PROFILERS; ++i)
+    {
+        notificationOnlyProfilers[i].Init();
+    }
+
+    globalEventMask.SetEventMask(COR_PRF_MONITOR_NONE);
+    globalEventMask.SetEventMaskHigh(COR_PRF_HIGH_MONITOR_NONE);
+
+    fGCInProgress = FALSE;
+    fBaseSystemClassesLoaded = FALSE;
+#ifdef PROF_TEST_ONLY_FORCE_ELT
+    fTestOnlyForceEnterLeave = FALSE;
+#endif
+
+#ifdef PROF_TEST_ONLY_FORCE_OBJECT_ALLOCATED
+    fTestOnlyForceObjectAllocated = FALSE;
+#endif
+
+#ifdef _DEBUG
+    fTestOnlyEnableICorProfilerInfo = FALSE;
+#endif // _DEBUG
+
+    fConcurrentGCDisabledForAttach = FALSE;
+
+    mainProfilerInfo.ResetPerSessionStatus();
+
+    fProfControlBlockInitialized = TRUE;
+
+    fProfilerRequestedRuntimeSuspend = FALSE;
+}
+
+
+inline BOOL ProfControlBlock::IsMainProfiler(EEToProfInterfaceImpl *pEEToProf)
+{
+    EEToProfInterfaceImpl *pProfInterface = mainProfilerInfo.pProfInterface.Load();
+    return pProfInterface == pEEToProf;
+}
+
+inline BOOL ProfControlBlock::IsMainProfiler(ProfToEEInterfaceImpl *pProfToEE)
+{
+    EEToProfInterfaceImpl *pProfInterface = mainProfilerInfo.pProfInterface.Load();
+    return pProfInterface != NULL && pProfInterface->m_pProfToEE == pProfToEE;
+}
+
+inline ProfilerInfo *ProfControlBlock::GetProfilerInfo(ProfToEEInterfaceImpl *pProfToEE)
+{
+    ProfilerInfo *pProfilerInfo = NULL;
+    IterateProfilers(ProfilerCallbackType::Active,
+                    [](ProfilerInfo *pProfilerInfo, ProfToEEInterfaceImpl *pProfToEE, ProfilerInfo **ppFoundProfilerInfo)
+                      {
+                          if (pProfilerInfo->pProfInterface->m_pProfToEE == pProfToEE)
+                          {
+                              *ppFoundProfilerInfo = pProfilerInfo;
+                          }
+                      },
+                      pProfToEE,
+                      &pProfilerInfo);
+
+    return pProfilerInfo;
+}
+
+#ifndef DACCESS_COMPILE
+inline ProfilerInfo *ProfControlBlock::FindNextFreeProfilerInfoSlot()
+{
+    for (SIZE_T i = 0; i < MAX_NOTIFICATION_PROFILERS; ++i)
+    {
+        if (InterlockedCompareExchange((LONG *)notificationOnlyProfilers[i].inUse.GetPointer(), TRUE, FALSE) == FALSE) 
+        {
+            InterlockedIncrement(notificationProfilerCount.GetPointer());
+            return &(notificationOnlyProfilers[i]);
+        }
+    }
+
+    return NULL;
+}
+
+inline void ProfControlBlock::DeRegisterProfilerInfo(ProfilerInfo *pProfilerInfo)
+{
+    pProfilerInfo->inUse = FALSE;
+    InterlockedDecrement(notificationProfilerCount.GetPointer());
+}
+
+inline void ProfControlBlock::UpdateGlobalEventMask()
+{
+    while (true)
+    {
+        UINT64 originalEventMask = globalEventMask.m_eventMask;
+        UINT64 qwEventMask = 0;
+
+        IterateProfilers(ProfilerCallbackType::ActiveOrInitializing,
+                        [](ProfilerInfo *pProfilerInfo, UINT64 *pEventMask)
+                          {
+                              *pEventMask |= pProfilerInfo->eventMask.m_eventMask;
+                          },
+                          &qwEventMask);
+        
+        // We are relying on the memory barrier introduced by InterlockedCompareExchange64 to observer any
+        // change to the global event mask.
+        if ((UINT64)InterlockedCompareExchange64((LONG64 *)&(globalEventMask.m_eventMask), (LONG64)qwEventMask, (LONG64)originalEventMask) == originalEventMask)
+        {
+            break;
+        }
+    }
+}
+#endif // DACCESS_COMPILE
+
+inline BOOL ProfControlBlock::IsCallback3Supported()
+{
+    return AnyProfilerPassesCondition([](ProfilerInfo *pProfilerInfo) { return pProfilerInfo->pProfInterface->IsCallback3Supported(); });
+}
+
+inline BOOL ProfControlBlock::IsCallback5Supported()
+{
+    return AnyProfilerPassesCondition([](ProfilerInfo *pProfilerInfo) { return pProfilerInfo->pProfInterface->IsCallback5Supported(); });
+}
+
+inline BOOL ProfControlBlock::IsDisableTransparencySet()
+{
+    return AnyProfilerPassesCondition([](ProfilerInfo *pProfilerInfo) { return pProfilerInfo->eventMask.IsEventMaskSet(COR_PRF_DISABLE_TRANSPARENCY_CHECKS_UNDER_FULL_TRUST); });
+}
+
+inline BOOL ProfControlBlock::RequiresGenericsContextForEnterLeave()
+{
+    return AnyProfilerPassesCondition([](ProfilerInfo *pProfilerInfo) { return pProfilerInfo->pProfInterface->RequiresGenericsContextForEnterLeave(); }); 
+}
+
+inline bool DoesProfilerWantEEFunctionIDMapper(ProfilerInfo *pProfilerInfo)
+{
+    CONTRACTL
+    {
+        NOTHROW;
+        GC_NOTRIGGER;
+        CANNOT_TAKE_LOCK;
+    }
+    CONTRACTL_END;
+
+    return ((pProfilerInfo->pProfInterface->GetFunctionIDMapper()  != NULL) ||
+             (pProfilerInfo->pProfInterface->GetFunctionIDMapper2() != NULL));
+}
+
+inline UINT_PTR ProfControlBlock::EEFunctionIDMapper(FunctionID funcId, BOOL *pbHookFunction)
+{
+    LIMITED_METHOD_CONTRACT;
+    UINT_PTR ptr = NULL;
+    DoOneProfilerIteration(&mainProfilerInfo,
+                          ProfilerCallbackType::Active,
+                          [](ProfilerInfo *pProfilerInfo, FunctionID funcId, BOOL *pbHookFunction, UINT_PTR *pPtr)
+                          {
+                               if (DoesProfilerWantEEFunctionIDMapper(pProfilerInfo))
+                               {
+                                   *pPtr = pProfilerInfo->pProfInterface->EEFunctionIDMapper(funcId, pbHookFunction);
+                               }
+                          },
+                          funcId, pbHookFunction, &ptr);
+
+    return ptr;
+}
+
+inline BOOL IsProfilerTrackingThreads(ProfilerInfo *pProfilerInfo)
+{
+    CONTRACTL
+    {
+        NOTHROW;
+        GC_NOTRIGGER;
+        CANNOT_TAKE_LOCK;
+    }
+    CONTRACTL_END;
+
+    return pProfilerInfo->eventMask.IsEventMaskSet(COR_PRF_MONITOR_THREADS);
+}
+
+inline void ProfControlBlock::ThreadCreated(ThreadID threadID)
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingThreads,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface, ThreadID threadID)
+                        {
+                            return profInterface->ThreadCreated(threadID);
+                        },
+                        threadID);
+}
+
+inline void ProfControlBlock::ThreadDestroyed(ThreadID threadID)
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingThreads,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface, ThreadID threadID)
+                        {
+                            return profInterface->ThreadDestroyed(threadID);
+                        },
+                        threadID);
+}
+
+inline void ProfControlBlock::ThreadAssignedToOSThread(ThreadID managedThreadId, DWORD osThreadId)
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingThreads,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface, ThreadID managedThreadId, DWORD osThreadId)
+                        {
+                            return profInterface->ThreadAssignedToOSThread(managedThreadId, osThreadId);
+                        },
+                        managedThreadId, osThreadId);
+}
+
+inline void ProfControlBlock::ThreadNameChanged(ThreadID managedThreadId, ULONG cchName, WCHAR name[])
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingThreads,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface, ThreadID managedThreadId, ULONG cchName, WCHAR name[])
+                        {
+                            return profInterface->ThreadNameChanged(managedThreadId, cchName, name);
+                        },
+                        managedThreadId, cchName, name);
+}
+
+inline void ProfControlBlock::Shutdown()
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       [](ProfilerInfo *pProfilerInfo) { return true; },
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface)
+                        {
+                            return profInterface->Shutdown();
+                        });
+}
+
+inline BOOL IsProfilerTrackingJITInfo(ProfilerInfo *pProfilerInfo)
+{
+    CONTRACTL
+    {
+        NOTHROW;
+        GC_NOTRIGGER;
+        CANNOT_TAKE_LOCK;
+    }
+    CONTRACTL_END;
+
+    return pProfilerInfo->eventMask.IsEventMaskSet(COR_PRF_MONITOR_JIT_COMPILATION);
+}
+
+inline void ProfControlBlock::JITCompilationFinished(FunctionID functionId, HRESULT hrStatus, BOOL fIsSafeToBlock)
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingJITInfo,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface, FunctionID functionId, HRESULT hrStatus, BOOL fIsSafeToBlock)
+                        {
+                            return profInterface->JITCompilationFinished(functionId, hrStatus, fIsSafeToBlock);
+                        },
+                        functionId, hrStatus, fIsSafeToBlock);
+}
+
+inline void ProfControlBlock::JITCompilationStarted(FunctionID functionId, BOOL fIsSafeToBlock)
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingJITInfo,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface, FunctionID functionId, BOOL fIsSafeToBlock)
+                        {
+                            return profInterface->JITCompilationStarted(functionId, fIsSafeToBlock);
+                        },
+                        functionId, fIsSafeToBlock);
+}
+
+inline void ProfControlBlock::DynamicMethodJITCompilationStarted(FunctionID functionId, BOOL fIsSafeToBlock, LPCBYTE pILHeader, ULONG cbILHeader)
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingJITInfo,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface, FunctionID functionId, BOOL fIsSafeToBlock, LPCBYTE pILHeader, ULONG cbILHeader)
+                        {
+                            return profInterface->DynamicMethodJITCompilationStarted(functionId, fIsSafeToBlock, pILHeader, cbILHeader);
+                        },
+                        functionId, fIsSafeToBlock, pILHeader, cbILHeader);
+}
+
+inline void ProfControlBlock::DynamicMethodJITCompilationFinished(FunctionID functionId, HRESULT hrStatus, BOOL fIsSafeToBlock)
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingJITInfo,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface, FunctionID functionId, HRESULT hrStatus, BOOL fIsSafeToBlock)
+                        {
+                            return profInterface->DynamicMethodJITCompilationFinished(functionId, hrStatus, fIsSafeToBlock);
+                        },
+                        functionId, hrStatus, fIsSafeToBlock);
+}
+
+inline BOOL IsProfilerMonitoringDynamicFunctionUnloads(ProfilerInfo *pProfilerInfo)
+{
+    CONTRACTL
+    {
+        NOTHROW;
+        GC_NOTRIGGER;
+        CANNOT_TAKE_LOCK;
+    }
+    CONTRACTL_END;
+
+    return pProfilerInfo->eventMask.IsEventMaskHighSet(COR_PRF_HIGH_MONITOR_DYNAMIC_FUNCTION_UNLOADS);
+}
+
+inline void ProfControlBlock::DynamicMethodUnloaded(FunctionID functionId)
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerMonitoringDynamicFunctionUnloads,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface, FunctionID functionId)
+                        {
+                            return profInterface->DynamicMethodUnloaded(functionId);
+                        },
+                        functionId);
+}
+
+inline BOOL IsProfilerTrackingCacheSearches(ProfilerInfo *pProfilerInfo)
+{
+    CONTRACTL
+    {
+        NOTHROW;
+        GC_NOTRIGGER;
+        CANNOT_TAKE_LOCK;
+    }
+    CONTRACTL_END;
+
+    return pProfilerInfo->eventMask.IsEventMaskSet(COR_PRF_MONITOR_CACHE_SEARCHES);
+}
+
+inline void ProfControlBlock::JITCachedFunctionSearchStarted(FunctionID functionId, BOOL *pbUseCachedFunction)
+{
+    LIMITED_METHOD_CONTRACT;
+
+    BOOL allTrue = TRUE;
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingCacheSearches,
+                       &allTrue,
+                       [](BOOL *pAllTrue, VolatilePtr<EEToProfInterfaceImpl> profInterface, FunctionID functionId, BOOL *pbUseCachedFunction)
+                        {
+                            HRESULT hr = profInterface->JITCachedFunctionSearchStarted(functionId, pbUseCachedFunction);
+                            *pAllTrue &= *pbUseCachedFunction;
+                            return hr;
+                        },
+                        functionId, pbUseCachedFunction);
+
+    // If any reject it, consider it rejected.
+    *pbUseCachedFunction = allTrue;
+}
+
+inline void ProfControlBlock::JITCachedFunctionSearchFinished(FunctionID functionId, COR_PRF_JIT_CACHE result)
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingCacheSearches,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface, FunctionID functionId, COR_PRF_JIT_CACHE result)
+                        {
+                            return profInterface->JITCachedFunctionSearchFinished(functionId, result);
+                        },
+                        functionId, result);
+}
+
+inline HRESULT ProfControlBlock::JITInlining(FunctionID callerId, FunctionID calleeId, BOOL *pfShouldInline)
+{
+    LIMITED_METHOD_CONTRACT;
+
+    BOOL allTrue = TRUE;
+    HRESULT hr =  DoProfilerCallback(ProfilerCallbackType::Active,
+                                     IsProfilerTrackingJITInfo,
+                                     &allTrue,
+                                     [](BOOL *pAllTrue, VolatilePtr<EEToProfInterfaceImpl> profInterface, FunctionID callerId, FunctionID calleeId, BOOL *pfShouldInline)
+                                      {
+                                          HRESULT hr = profInterface->JITInlining(callerId, calleeId, pfShouldInline);
+                                          *pAllTrue &= *pfShouldInline;
+                                          return hr;
+                                      },
+                                      callerId, calleeId, pfShouldInline);
+
+    // If any reject it, consider it rejected.
+    *pfShouldInline = allTrue;
+    return hr;
+}
+
+inline BOOL IsRejitEnabled(ProfilerInfo *pProfilerInfo)
+{
+    return pProfilerInfo->eventMask.IsEventMaskSet(COR_PRF_ENABLE_REJIT);
+}
+
+inline void ProfControlBlock::ReJITCompilationStarted(FunctionID functionId, ReJITID reJitId, BOOL fIsSafeToBlock)
+{
+    LIMITED_METHOD_CONTRACT;
+    DoOneProfilerIteration(&mainProfilerInfo,
+                          ProfilerCallbackType::Active,
+                          [](ProfilerInfo *pProfilerInfo, FunctionID functionId, ReJITID reJitId, BOOL fIsSafeToBlock)
+                          {
+                               if (IsRejitEnabled(pProfilerInfo))
+                               {
+                                   pProfilerInfo->pProfInterface->ReJITCompilationStarted(functionId, reJitId, fIsSafeToBlock);
+                               }
+                          },
+                          functionId, reJitId, fIsSafeToBlock);
+}
+
+inline HRESULT ProfControlBlock::GetReJITParameters(ModuleID moduleId, mdMethodDef methodId, ICorProfilerFunctionControl *pFunctionControl)
+{
+    LIMITED_METHOD_CONTRACT;
+    HRESULT hr = S_OK;
+    DoOneProfilerIteration(&mainProfilerInfo,
+                          ProfilerCallbackType::Active,
+                          [](ProfilerInfo *pProfilerInfo, ModuleID moduleId, mdMethodDef methodId, ICorProfilerFunctionControl *pFunctionControl, HRESULT *pHr)
+                          {
+                               if (IsRejitEnabled(pProfilerInfo))
+                               {
+                                   *pHr = pProfilerInfo->pProfInterface->GetReJITParameters(moduleId, methodId, pFunctionControl);
+                               }
+                          },
+                          moduleId, methodId, pFunctionControl, &hr);
+    return hr;
+}
+
+inline void ProfControlBlock::ReJITCompilationFinished(FunctionID functionId, ReJITID reJitId, HRESULT hrStatus, BOOL fIsSafeToBlock)
+{
+    LIMITED_METHOD_CONTRACT;
+    DoOneProfilerIteration(&mainProfilerInfo,
+                          ProfilerCallbackType::Active,
+                          [](ProfilerInfo *pProfilerInfo, FunctionID functionId, ReJITID reJitId, HRESULT hrStatus, BOOL fIsSafeToBlock)
+                          {
+                               if (IsRejitEnabled(pProfilerInfo))
+                               {
+                                   pProfilerInfo->pProfInterface->ReJITCompilationFinished(functionId, reJitId, hrStatus, fIsSafeToBlock);
+                               }
+                          },
+                          functionId, reJitId, hrStatus, fIsSafeToBlock);
+}
+
+inline void ProfControlBlock::ReJITError(ModuleID moduleId, mdMethodDef methodId, FunctionID functionId, HRESULT hrStatus)
+{
+    LIMITED_METHOD_CONTRACT;
+    DoOneProfilerIteration(&mainProfilerInfo,
+                          ProfilerCallbackType::Active,
+                          [](ProfilerInfo *pProfilerInfo, ModuleID moduleId, mdMethodDef methodId, FunctionID functionId, HRESULT hrStatus)
+                          {
+                               if (IsRejitEnabled(pProfilerInfo))
+                               {
+                                   pProfilerInfo->pProfInterface->ReJITError(moduleId, methodId, functionId, hrStatus);
+                               }
+                          },
+                          moduleId, methodId, functionId, hrStatus);
+}
+
+inline BOOL IsProfilerTrackingModuleLoads(ProfilerInfo *pProfilerInfo)
+{
+    CONTRACTL
+    {
+        NOTHROW;
+        GC_NOTRIGGER;
+        CANNOT_TAKE_LOCK;
+    }
+    CONTRACTL_END;
+
+    return pProfilerInfo->eventMask.IsEventMaskSet(COR_PRF_MONITOR_MODULE_LOADS);
+}
+
+inline void ProfControlBlock::ModuleLoadStarted(ModuleID moduleId)
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingModuleLoads,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface, ModuleID moduleId)
+                        {
+                            return profInterface->ModuleLoadStarted(moduleId);
+                        },
+                        moduleId);
+}
+
+inline void ProfControlBlock::ModuleLoadFinished(ModuleID moduleId, HRESULT hrStatus)
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingModuleLoads,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface, ModuleID moduleId, HRESULT hrStatus)
+                        {
+                            return profInterface->ModuleLoadFinished(moduleId, hrStatus);
+                        },
+                        moduleId, hrStatus);
+}
+
+inline void ProfControlBlock::ModuleUnloadStarted(ModuleID moduleId)
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingModuleLoads,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface, ModuleID moduleId)
+                        {
+                            return profInterface->ModuleUnloadStarted(moduleId);
+                        },
+                        moduleId);
+}
+
+inline void ProfControlBlock::ModuleUnloadFinished(ModuleID moduleId, HRESULT hrStatus)
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingModuleLoads,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface, ModuleID moduleId, HRESULT hrStatus)
+                        {
+                            return profInterface->ModuleUnloadFinished(moduleId, hrStatus);
+                        },
+                        moduleId, hrStatus);
+}
+
+inline void ProfControlBlock::ModuleAttachedToAssembly(ModuleID moduleId, AssemblyID AssemblyId)
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingModuleLoads,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface, ModuleID moduleId, AssemblyID AssemblyId)
+                        {
+                            return profInterface->ModuleAttachedToAssembly(moduleId, AssemblyId);
+                        },
+                        moduleId, AssemblyId);
+}
+
+inline BOOL IsProfilerTrackingInMemorySymbolsUpdatesEnabled(ProfilerInfo *pProfilerInfo)
+{
+    CONTRACTL
+    {
+        NOTHROW;
+        GC_NOTRIGGER;
+        CANNOT_TAKE_LOCK;
+    }
+    CONTRACTL_END;
+
+    return pProfilerInfo->eventMask.IsEventMaskHighSet(COR_PRF_HIGH_IN_MEMORY_SYMBOLS_UPDATED);
+}
+
+inline void ProfControlBlock::ModuleInMemorySymbolsUpdated(ModuleID moduleId)
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingInMemorySymbolsUpdatesEnabled,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface, ModuleID moduleId)
+                        {
+                            return profInterface->ModuleInMemorySymbolsUpdated(moduleId);
+                        },
+                        moduleId);
+}
+
+inline BOOL IsProfilerTrackingClasses(ProfilerInfo *pProfilerInfo)
+{
+    CONTRACTL
+    {
+        NOTHROW;
+        GC_NOTRIGGER;
+        CANNOT_TAKE_LOCK;
+    }
+    CONTRACTL_END;
+
+    return pProfilerInfo->eventMask.IsEventMaskSet(COR_PRF_MONITOR_CLASS_LOADS);
+}
+
+inline void ProfControlBlock::ClassLoadStarted(ClassID classId)
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingClasses,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface, ClassID classId)
+                        {
+                            return profInterface->ClassLoadStarted(classId);
+                        },
+                        classId);
+}
+
+inline void ProfControlBlock::ClassLoadFinished(ClassID classId, HRESULT hrStatus)
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingClasses,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface, ClassID classId, HRESULT hrStatus)
+                        {
+                            return profInterface->ClassLoadFinished(classId, hrStatus);
+                        },
+                        classId, hrStatus);
+}
+
+inline void ProfControlBlock::ClassUnloadStarted(ClassID classId)
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingClasses,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface, ClassID classId)
+                        {
+                            return profInterface->ClassUnloadStarted(classId);
+                        },
+                        classId);
+}
+
+inline void ProfControlBlock::ClassUnloadFinished(ClassID classId, HRESULT hrStatus)
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingClasses,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface, ClassID classId, HRESULT hrStatus)
+                        {
+                            return profInterface->ClassUnloadFinished(classId, hrStatus);
+                        },
+                        classId, hrStatus);
+}
+
+inline BOOL IsProfilerTrackingAppDomainLoads(ProfilerInfo *pProfilerInfo)
+{
+    CONTRACTL
+    {
+        NOTHROW;
+        GC_NOTRIGGER;
+        CANNOT_TAKE_LOCK;
+    }
+    CONTRACTL_END;
+
+    return pProfilerInfo->eventMask.IsEventMaskSet(COR_PRF_MONITOR_APPDOMAIN_LOADS);
+}
+
+inline void ProfControlBlock::AppDomainCreationStarted(AppDomainID appDomainId)
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingAppDomainLoads,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface, AppDomainID appDomainId)
+                        {
+                            return profInterface->AppDomainCreationStarted(appDomainId);
+                        },
+                        appDomainId);
+}
+
+inline void ProfControlBlock::AppDomainCreationFinished(AppDomainID appDomainId, HRESULT hrStatus)
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingAppDomainLoads,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface, AppDomainID appDomainId, HRESULT hrStatus)
+                        {
+                            return profInterface->AppDomainCreationFinished(appDomainId, hrStatus);
+                        },
+                        appDomainId, hrStatus);
+}
+
+inline void ProfControlBlock::AppDomainShutdownStarted(AppDomainID appDomainId)
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingAppDomainLoads,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface, AppDomainID appDomainId)
+                        {
+                            return profInterface->AppDomainShutdownStarted(appDomainId);
+                        },
+                        appDomainId);
+}
+
+inline void ProfControlBlock::AppDomainShutdownFinished(AppDomainID appDomainId, HRESULT hrStatus)
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingAppDomainLoads,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface, AppDomainID appDomainId, HRESULT hrStatus)
+                        {
+                            return profInterface->AppDomainShutdownFinished(appDomainId, hrStatus);
+                        },
+                        appDomainId, hrStatus);
+}
+
+inline BOOL IsProfilerTrackingAssemblyLoads(ProfilerInfo *pProfilerInfo)
+{
+    CONTRACTL
+    {
+        NOTHROW;
+        GC_NOTRIGGER;
+        CANNOT_TAKE_LOCK;
+    }
+    CONTRACTL_END;
+
+    return pProfilerInfo->eventMask.IsEventMaskSet(COR_PRF_MONITOR_ASSEMBLY_LOADS);
+}
+
+inline void ProfControlBlock::AssemblyLoadStarted(AssemblyID assemblyId)
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingAssemblyLoads,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface, AssemblyID assemblyId)
+                        {
+                            return profInterface->AssemblyLoadStarted(assemblyId);
+                        },
+                        assemblyId);
+}
+
+inline void ProfControlBlock::AssemblyLoadFinished(AssemblyID assemblyId, HRESULT hrStatus)
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingAssemblyLoads,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface, AssemblyID assemblyId, HRESULT hrStatus)
+                        {
+                            return profInterface->AssemblyLoadFinished(assemblyId, hrStatus);
+                        },
+                        assemblyId, hrStatus);
+}
+
+inline void ProfControlBlock::AssemblyUnloadStarted(AssemblyID assemblyId)
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingAssemblyLoads,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface, AssemblyID assemblyId)
+                        {
+                            return profInterface->AssemblyUnloadStarted(assemblyId);
+                        },
+                        assemblyId);
+}
+
+inline void ProfControlBlock::AssemblyUnloadFinished(AssemblyID assemblyId, HRESULT hrStatus)
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingAssemblyLoads,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface, AssemblyID assemblyId, HRESULT hrStatus)
+                        {
+                            return profInterface->AssemblyUnloadFinished(assemblyId, hrStatus);
+                        },
+                        assemblyId, hrStatus);
+}
+
+inline BOOL IsProfilerTrackingTransitions(ProfilerInfo *pProfilerInfo)
+{
+    CONTRACTL
+    {
+        NOTHROW;
+        GC_NOTRIGGER;
+        CANNOT_TAKE_LOCK;
+    }
+    CONTRACTL_END;
+
+    return pProfilerInfo->eventMask.IsEventMaskSet(COR_PRF_MONITOR_CODE_TRANSITIONS);
+}
+
+inline void ProfControlBlock::UnmanagedToManagedTransition(FunctionID functionId, COR_PRF_TRANSITION_REASON reason)
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingTransitions,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface, FunctionID functionId, COR_PRF_TRANSITION_REASON reason)
+                        {
+                            return profInterface->UnmanagedToManagedTransition(functionId, reason);
+                        },
+                        functionId, reason);
+}
+
+inline void ProfControlBlock::ManagedToUnmanagedTransition(FunctionID functionId, COR_PRF_TRANSITION_REASON reason)
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingTransitions,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface, FunctionID functionId, COR_PRF_TRANSITION_REASON reason)
+                        {
+                            return profInterface->ManagedToUnmanagedTransition(functionId, reason);
+                        },
+                        functionId, reason);
+}
+
+inline BOOL IsProfilerTrackingExceptions(ProfilerInfo *pProfilerInfo)
+{
+    CONTRACTL
+    {
+        NOTHROW;
+        GC_NOTRIGGER;
+        CANNOT_TAKE_LOCK;
+    }
+    CONTRACTL_END;
+
+    return pProfilerInfo->eventMask.IsEventMaskSet(COR_PRF_MONITOR_EXCEPTIONS);
+}
+
+inline void ProfControlBlock::ExceptionThrown(ObjectID thrownObjectId)
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingExceptions,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface, ObjectID thrownObjectId)
+                        {
+                            return profInterface->ExceptionThrown(thrownObjectId);
+                        },
+                        thrownObjectId);
+}
+
+inline void ProfControlBlock::ExceptionSearchFunctionEnter(FunctionID functionId)
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingExceptions,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface, FunctionID functionId)
+                        {
+                            return profInterface->ExceptionSearchFunctionEnter(functionId);
+                        },
+                        functionId);
+}
+
+inline void ProfControlBlock::ExceptionSearchFunctionLeave()
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingExceptions,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface)
+                        {
+                            return profInterface->ExceptionSearchFunctionLeave();
+                        });
+}
+
+inline void ProfControlBlock::ExceptionSearchFilterEnter(FunctionID funcId)
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingExceptions,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface, FunctionID funcId)
+                        {
+                            return profInterface->ExceptionSearchFilterEnter(funcId);
+                        },
+                        funcId);
+}
+
+inline void ProfControlBlock::ExceptionSearchFilterLeave()
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingExceptions,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface)
+                        {
+                            return profInterface->ExceptionSearchFilterLeave();
+                        });
+}
+
+inline void ProfControlBlock::ExceptionSearchCatcherFound(FunctionID functionId)
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingExceptions,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface, FunctionID functionId)
+                        {
+                            return profInterface->ExceptionSearchCatcherFound(functionId);
+                        },
+                        functionId);
+}
+
+inline void ProfControlBlock::ExceptionOSHandlerEnter(FunctionID funcId)
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingExceptions,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface, FunctionID funcId)
+                        {
+                            return profInterface->ExceptionOSHandlerEnter(funcId);
+                        },
+                        funcId);
+}
+
+inline void ProfControlBlock::ExceptionOSHandlerLeave(FunctionID funcId)
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingExceptions,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface, FunctionID funcId)
+                        {
+                            return profInterface->ExceptionOSHandlerLeave(funcId);
+                        },
+                        funcId);
+}
+
+inline void ProfControlBlock::ExceptionUnwindFunctionEnter(FunctionID functionId)
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingExceptions,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface, FunctionID functionId)
+                        {
+                            return profInterface->ExceptionUnwindFunctionEnter(functionId);
+                        },
+                        functionId);
+}
+
+inline void ProfControlBlock::ExceptionUnwindFunctionLeave()
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingExceptions,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface)
+                        {
+                            return profInterface->ExceptionUnwindFunctionLeave();
+                        });
+}
+
+inline void ProfControlBlock::ExceptionUnwindFinallyEnter(FunctionID functionId)
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingExceptions,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface, FunctionID functionId)
+                        {
+                            return profInterface->ExceptionUnwindFinallyEnter(functionId);
+                        },
+                        functionId);
+}
+
+inline void ProfControlBlock::ExceptionUnwindFinallyLeave()
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingExceptions,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface)
+                        {
+                            return profInterface->ExceptionUnwindFinallyLeave();
+                        });
+}
+
+inline void ProfControlBlock::ExceptionCatcherEnter(FunctionID functionId, ObjectID objectId)
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingExceptions,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface, FunctionID functionId, ObjectID objectId)
+                        {
+                            return profInterface->ExceptionCatcherEnter(functionId, objectId);
+                        },
+                        functionId, objectId);
+}
+
+inline void ProfControlBlock::ExceptionCatcherLeave()
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingExceptions,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface)
+                        {
+                            return profInterface->ExceptionCatcherLeave();
+                        });
+}
+
+inline BOOL IsProfilerTrackingCCW(ProfilerInfo *pProfilerInfo)
+{
+    CONTRACTL
+    {
+        NOTHROW;
+        GC_NOTRIGGER;
+        CANNOT_TAKE_LOCK;
+    }
+    CONTRACTL_END;
+
+    return pProfilerInfo->eventMask.IsEventMaskSet(COR_PRF_MONITOR_CCW);
+}
+
+inline void ProfControlBlock::COMClassicVTableCreated(ClassID wrappedClassId, REFGUID implementedIID, void *pVTable, ULONG cSlots)
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingCCW,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface, ClassID wrappedClassId, REFGUID implementedIID, void *pVTable, ULONG cSlots)
+                        {
+                            return profInterface->COMClassicVTableCreated(wrappedClassId, implementedIID, pVTable, cSlots);
+                        },
+                        wrappedClassId, implementedIID, pVTable, cSlots);
+}
+
+inline BOOL IsProfilerTrackingSuspends(ProfilerInfo *pProfilerInfo)
+{
+    CONTRACTL
+    {
+        NOTHROW;
+        GC_NOTRIGGER;
+        CANNOT_TAKE_LOCK;
+    }
+    CONTRACTL_END;
+
+    return pProfilerInfo->eventMask.IsEventMaskSet(COR_PRF_MONITOR_SUSPENDS);
+}
+
+inline void ProfControlBlock::RuntimeSuspendStarted(COR_PRF_SUSPEND_REASON suspendReason)
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingSuspends,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface, COR_PRF_SUSPEND_REASON suspendReason)
+                        {
+                            return profInterface->RuntimeSuspendStarted(suspendReason);
+                        },
+                        suspendReason);
+}
+
+inline void ProfControlBlock::RuntimeSuspendFinished()
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingSuspends,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface)
+                        {
+                            return profInterface->RuntimeSuspendFinished();
+                        });
+}
+
+inline void ProfControlBlock::RuntimeSuspendAborted()
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingSuspends,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface)
+                        {
+                            return profInterface->RuntimeSuspendAborted();
+                        });
+}
+
+inline void ProfControlBlock::RuntimeResumeStarted()
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingSuspends,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface)
+                        {
+                            return profInterface->RuntimeResumeStarted();
+                        });
+}
+
+inline void ProfControlBlock::RuntimeResumeFinished()
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingSuspends,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface)
+                        {
+                            return profInterface->RuntimeResumeFinished();
+                        });
+}
+
+inline void ProfControlBlock::RuntimeThreadSuspended(ThreadID suspendedThreadId)
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingSuspends,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface, ThreadID suspendedThreadId)
+                        {
+                            return profInterface->RuntimeThreadSuspended(suspendedThreadId);
+                        },
+                        suspendedThreadId);
+}
+
+inline void ProfControlBlock::RuntimeThreadResumed(ThreadID resumedThreadId)
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingSuspends,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface, ThreadID resumedThreadId)
+                        {
+                            return profInterface->RuntimeThreadResumed(resumedThreadId);
+                        },
+                        resumedThreadId);
+}
+
+inline BOOL IsProfilerTrackingAllocations(ProfilerInfo *pProfilerInfo)
 {
     CONTRACTL
     {
@@ -50,39 +1298,365 @@ inline void ProfControlBlock::Init()
     }
     CONTRACTL_END;
 
-    curProfStatus.Init();
+    return (pProfilerInfo->eventMask.IsEventMaskSet(COR_PRF_ENABLE_OBJECT_ALLOCATED)
+                || pProfilerInfo->eventMask.IsEventMaskHighSet(COR_PRF_HIGH_MONITOR_LARGEOBJECT_ALLOCATED));
+}
 
-    fGCInProgress = FALSE;
-    fBaseSystemClassesLoaded = FALSE;
-#ifdef PROF_TEST_ONLY_FORCE_ELT
-    fTestOnlyForceEnterLeave = FALSE;
-#endif
+inline void ProfControlBlock::ObjectAllocated(ObjectID objectId, ClassID classId)
+{
+    LIMITED_METHOD_CONTRACT;
 
-#ifdef PROF_TEST_ONLY_FORCE_OBJECT_ALLOCATED
-    fTestOnlyForceObjectAllocated = FALSE;
-#endif
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingAllocations,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface, ObjectID objectId, ClassID classId)
+                        {
+                            return profInterface->ObjectAllocated(objectId, classId);
+                        },
+                        objectId, classId);
+}
 
-#ifdef _DEBUG
-    fTestOnlyEnableICorProfilerInfo = FALSE;
-#endif // _DEBUG
 
-    fConcurrentGCDisabledForAttach = FALSE;
+inline BOOL IsProfilerTrackingGC(ProfilerInfo *pProfilerInfo)
+{
+    CONTRACTL
+    {
+        NOTHROW;
+        GC_NOTRIGGER;
+        CANNOT_TAKE_LOCK;
+    }
+    CONTRACTL_END;
 
-    ResetPerSessionStatus();
+    return pProfilerInfo->eventMask.IsEventMaskSet(COR_PRF_MONITOR_GC);
+}
 
-    fProfControlBlockInitialized = TRUE;
+inline void ProfControlBlock::FinalizeableObjectQueued(BOOL isCritical, ObjectID objectID)
+{
+    LIMITED_METHOD_CONTRACT;
 
-    fProfilerRequestedRuntimeSuspend = FALSE;
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingGC,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface, BOOL isCritical, ObjectID objectID)
+                        {
+                            return profInterface->FinalizeableObjectQueued(isCritical, objectID);
+                        },
+                        isCritical, objectID);
 }
 
-// Reset those variables that is only for the current attach session
-inline void ProfControlBlock::ResetPerSessionStatus()
+inline void ProfControlBlock::MovedReference(BYTE *pbMemBlockStart, BYTE *pbMemBlockEnd, ptrdiff_t cbRelocDistance, void *pHeapId, BOOL fCompacting)
 {
     LIMITED_METHOD_CONTRACT;
 
-    pProfInterface = NULL;
-    dwEventMask = COR_PRF_MONITOR_NONE;
-    dwEventMaskHigh = COR_PRF_HIGH_MONITOR_NONE;
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingGC,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface, BYTE *pbMemBlockStart, BYTE *pbMemBlockEnd, ptrdiff_t cbRelocDistance, void *pHeapId, BOOL fCompacting)
+                        {
+                            return profInterface->MovedReference(pbMemBlockStart, pbMemBlockEnd, cbRelocDistance, pHeapId, fCompacting);
+                        },
+                        pbMemBlockStart, pbMemBlockEnd, cbRelocDistance, pHeapId, fCompacting);
+}
+
+inline void ProfControlBlock::EndMovedReferences(void *pHeapId)
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingGC,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface, void *pHeapId)
+                        {
+                            return profInterface->EndMovedReferences(pHeapId);
+                        },
+                        pHeapId);
+}
+
+inline void ProfControlBlock::RootReference2(BYTE *objectId, EtwGCRootKind dwEtwRootKind, EtwGCRootFlags dwEtwRootFlags, void *rootID, void *pHeapId)
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingGC,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface, BYTE *objectId, EtwGCRootKind dwEtwRootKind, EtwGCRootFlags dwEtwRootFlags, void *rootID, void *pHeapId)
+                        {
+                            return profInterface->RootReference2(objectId, dwEtwRootKind, dwEtwRootFlags, rootID, pHeapId);
+                        },
+                        objectId, dwEtwRootKind, dwEtwRootFlags, rootID, pHeapId);
+}
+
+inline void ProfControlBlock::EndRootReferences2(void *pHeapId)
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingGC,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface, void *pHeapId)
+                        {
+                            return profInterface->EndRootReferences2(pHeapId);
+                        },
+                        pHeapId);
+}
+
+inline void ProfControlBlock::ConditionalWeakTableElementReference(BYTE *primaryObjectId, BYTE *secondaryObjectId, void *rootID, void *pHeapId)
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingGC,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface, BYTE *primaryObjectId, BYTE *secondaryObjectId, void *rootID, void *pHeapId)
+                        {
+                            if (!profInterface->IsCallback5Supported())
+                            {
+                                return S_OK;
+                            }
+
+                            return profInterface->ConditionalWeakTableElementReference(primaryObjectId, secondaryObjectId, rootID, pHeapId);
+                        },
+                        primaryObjectId, secondaryObjectId, rootID, pHeapId);
+}
+
+inline void ProfControlBlock::EndConditionalWeakTableElementReferences(void *pHeapId)
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingGC,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface, void *pHeapId)
+                        {
+                            if (!profInterface->IsCallback5Supported())
+                            {
+                                return S_OK;
+                            }
+
+                            return profInterface->EndConditionalWeakTableElementReferences(pHeapId);
+                        },
+                        pHeapId);
+}
+
+inline void ProfControlBlock::AllocByClass(ObjectID objId, ClassID classId, void *pHeapId)
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingGC,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface, ObjectID objId, ClassID classId, void *pHeapId)
+                        {
+                            return profInterface->AllocByClass(objId, classId, pHeapId);
+                        },
+                        objId, classId, pHeapId);
+}
+
+inline void ProfControlBlock::EndAllocByClass(void *pHeapId)
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingGC,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface, void *pHeapId)
+                        {
+                            return profInterface->EndAllocByClass(pHeapId);
+                        },
+                        pHeapId);
+}
+
+inline HRESULT ProfControlBlock::ObjectReference(ObjectID objId, ClassID classId, ULONG cNumRefs, ObjectID *arrObjRef)
+{
+    LIMITED_METHOD_CONTRACT;
+
+    return DoProfilerCallback(ProfilerCallbackType::Active,
+                              IsProfilerTrackingGC,
+                              (void *)NULL,
+                              [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface, ObjectID objId, ClassID classId, ULONG cNumRefs, ObjectID *arrObjRef)
+                               {
+                                   return profInterface->ObjectReference(objId, classId, cNumRefs, arrObjRef);
+                               },
+                               objId, classId, cNumRefs, arrObjRef);
+}
+
+inline void ProfControlBlock::HandleCreated(UINT_PTR handleId, ObjectID initialObjectId)
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingGC,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface, UINT_PTR handleId, ObjectID initialObjectId)
+                        {
+                            return profInterface->HandleCreated(handleId, initialObjectId);
+                        },
+                        handleId, initialObjectId);
+}
+
+inline void ProfControlBlock::HandleDestroyed(UINT_PTR handleId)
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingGC,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface, UINT_PTR handleId)
+                        {
+                            return profInterface->HandleDestroyed(handleId);
+                        },
+                        handleId);
+}
+
+
+inline BOOL IsProfilerTrackingBasicGC(ProfilerInfo *pProfilerInfo)
+{
+    CONTRACTL
+    {
+        NOTHROW;
+        GC_NOTRIGGER;
+        CANNOT_TAKE_LOCK;
+    }
+    CONTRACTL_END;
+
+    return pProfilerInfo->eventMask.IsEventMaskHighSet(COR_PRF_HIGH_BASIC_GC);
+}
+
+inline BOOL IsProfilerTrackingMovedObjects(ProfilerInfo *pProfilerInfo)
+{
+    CONTRACTL
+    {
+        NOTHROW;
+        GC_NOTRIGGER;
+        CANNOT_TAKE_LOCK;
+    }
+    CONTRACTL_END;
+
+    return pProfilerInfo->eventMask.IsEventMaskHighSet(COR_PRF_HIGH_MONITOR_GC_MOVED_OBJECTS);
+}
+
+inline BOOL IsProfilerTrackingGCOrBasicGC(ProfilerInfo *pProfilerInfo)
+{
+    return IsProfilerTrackingGC(pProfilerInfo) || IsProfilerTrackingBasicGC(pProfilerInfo);
+}
+
+inline BOOL IsProfilerTrackingGCOrMovedObjects(ProfilerInfo *pProfilerInfo)
+{
+    return IsProfilerTrackingGC(pProfilerInfo) || IsProfilerTrackingMovedObjects(pProfilerInfo);
+}
+
+inline void ProfControlBlock::GarbageCollectionStarted(int cGenerations, BOOL generationCollected[], COR_PRF_GC_REASON reason)
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingGCOrBasicGC,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface, int cGenerations, BOOL generationCollected[], COR_PRF_GC_REASON reason)
+                        {
+                            return profInterface->GarbageCollectionStarted(cGenerations, generationCollected, reason);
+                        },
+                        cGenerations, generationCollected, reason);
+}
+
+inline void ProfControlBlock::GarbageCollectionFinished()
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerTrackingGCOrBasicGC,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface)
+                        {
+                            return profInterface->GarbageCollectionFinished();
+                        });
+}
+
+
+inline BOOL IsProfilerMonitoringEventPipe(ProfilerInfo *pProfilerInfo)
+{
+    CONTRACTL
+    {
+        NOTHROW;
+        GC_NOTRIGGER;
+        CANNOT_TAKE_LOCK;
+    }
+    CONTRACTL_END;
+
+    return pProfilerInfo->eventMask.IsEventMaskHighSet(COR_PRF_HIGH_MONITOR_EVENT_PIPE);
+}
+
+
+inline void ProfControlBlock::EventPipeEventDelivered(EventPipeProvider *provider,
+                                                      DWORD eventId,
+                                                      DWORD eventVersion,
+                                                      ULONG cbMetadataBlob,
+                                                      LPCBYTE metadataBlob,
+                                                      ULONG cbEventData,
+                                                      LPCBYTE eventData,
+                                                      LPCGUID pActivityId,
+                                                      LPCGUID pRelatedActivityId,
+                                                      Thread *pEventThread,
+                                                      ULONG numStackFrames,
+                                                      UINT_PTR stackFrames[])
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerMonitoringEventPipe,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface, EventPipeProvider *provider,
+                          DWORD eventId,
+                          DWORD eventVersion,
+                          ULONG cbMetadataBlob,
+                          LPCBYTE metadataBlob,
+                          ULONG cbEventData,
+                          LPCBYTE eventData,
+                          LPCGUID pActivityId,
+                          LPCGUID pRelatedActivityId,
+                          Thread *pEventThread,
+                          ULONG numStackFrames,
+                          UINT_PTR stackFrames[])
+                        {
+                            return profInterface->EventPipeEventDelivered(provider,
+                                                                   eventId,
+                                                                   eventVersion,
+                                                                   cbMetadataBlob,
+                                                                   metadataBlob,
+                                                                   cbEventData,
+                                                                   eventData,
+                                                                   pActivityId,
+                                                                   pRelatedActivityId,
+                                                                   pEventThread,
+                                                                   numStackFrames,
+                                                                   stackFrames);
+                        },
+                        provider,
+                        eventId,
+                        eventVersion,
+                        cbMetadataBlob,
+                        metadataBlob,
+                        cbEventData,
+                        eventData,
+                        pActivityId,
+                        pRelatedActivityId,
+                        pEventThread,
+                        numStackFrames,
+                        stackFrames);
+}
+
+inline void ProfControlBlock::EventPipeProviderCreated(EventPipeProvider *provider)
+{
+    LIMITED_METHOD_CONTRACT;
+
+    DoProfilerCallback(ProfilerCallbackType::Active,
+                       IsProfilerMonitoringEventPipe,
+                       (void *)NULL,
+                       [](void *additionalData, VolatilePtr<EEToProfInterfaceImpl> profInterface, EventPipeProvider *provider)
+                        {
+                            return profInterface->EventPipeProviderCreated(provider);
+                        },
+                        provider);
 }
 
 //---------------------------------------------------------------------------------------
@@ -90,14 +1664,18 @@ inline void ProfControlBlock::ResetPerSessionStatus()
 // and what features it enabled callbacks for.
 //---------------------------------------------------------------------------------------
 
-
-// CORProfilerPresent() returns whether or not a CLR Profiler is actively loaded
-// (meaning it's initialized and ready to receive callbacks).
 inline BOOL CORProfilerPresent()
 {
     LIMITED_METHOD_DAC_CONTRACT;
 
-    return ((&g_profControlBlock)->curProfStatus.Get() == kProfStatusActive);
+    return AnyProfilerPassesCondition([](ProfilerInfo *pProfilerInfo) { return pProfilerInfo->curProfStatus.Get() >= kProfStatusActive; });
+}
+
+inline BOOL CORMainProfilerPresent()
+{
+    LIMITED_METHOD_DAC_CONTRACT;
+
+    return (&g_profControlBlock)->mainProfilerInfo.curProfStatus.Get() >= kProfStatusActive;
 }
 
 // These return whether a CLR Profiler is actively loaded AND has requested the
@@ -113,10 +1691,10 @@ inline BOOL CORProfilerFunctionIDMapperEnabled()
     }
     CONTRACTL_END;
 
-    return (CORProfilerPresent() &&
+    return (CORMainProfilerPresent() &&
         (
-         ((&g_profControlBlock)->pProfInterface->GetFunctionIDMapper()  != NULL) ||
-         ((&g_profControlBlock)->pProfInterface->GetFunctionIDMapper2() != NULL)
+         ((&g_profControlBlock)->mainProfilerInfo.pProfInterface->GetFunctionIDMapper()  != NULL) ||
+         ((&g_profControlBlock)->mainProfilerInfo.pProfInterface->GetFunctionIDMapper2() != NULL)
         ));
 }
 
@@ -131,7 +1709,7 @@ inline BOOL CORProfilerTrackJITInfo()
     CONTRACTL_END;
 
     return (CORProfilerPresent() &&
-            ((&g_profControlBlock)->dwEventMask & COR_PRF_MONITOR_JIT_COMPILATION));
+            (&g_profControlBlock)->globalEventMask.IsEventMaskSet(COR_PRF_MONITOR_JIT_COMPILATION));
 }
 
 inline BOOL CORProfilerTrackCacheSearches()
@@ -145,7 +1723,7 @@ inline BOOL CORProfilerTrackCacheSearches()
     CONTRACTL_END;
 
     return (CORProfilerPresent() &&
-            ((&g_profControlBlock)->dwEventMask & COR_PRF_MONITOR_CACHE_SEARCHES));
+            (&g_profControlBlock)->globalEventMask.IsEventMaskSet(COR_PRF_MONITOR_CACHE_SEARCHES));
 }
 
 inline BOOL CORProfilerTrackModuleLoads()
@@ -159,7 +1737,7 @@ inline BOOL CORProfilerTrackModuleLoads()
     CONTRACTL_END;
 
     return (CORProfilerPresent() &&
-            ((&g_profControlBlock)->dwEventMask & COR_PRF_MONITOR_MODULE_LOADS));
+            (&g_profControlBlock)->globalEventMask.IsEventMaskSet(COR_PRF_MONITOR_MODULE_LOADS));
 }
 
 inline BOOL CORProfilerTrackAssemblyLoads()
@@ -173,7 +1751,7 @@ inline BOOL CORProfilerTrackAssemblyLoads()
     CONTRACTL_END;
 
     return (CORProfilerPresent() &&
-            ((&g_profControlBlock)->dwEventMask & COR_PRF_MONITOR_ASSEMBLY_LOADS));
+            (&g_profControlBlock)->globalEventMask.IsEventMaskSet(COR_PRF_MONITOR_ASSEMBLY_LOADS));
 }
 
 inline BOOL CORProfilerTrackAppDomainLoads()
@@ -187,7 +1765,7 @@ inline BOOL CORProfilerTrackAppDomainLoads()
     CONTRACTL_END;
 
     return (CORProfilerPresent() &&
-            ((&g_profControlBlock)->dwEventMask & COR_PRF_MONITOR_APPDOMAIN_LOADS));
+            (&g_profControlBlock)->globalEventMask.IsEventMaskSet(COR_PRF_MONITOR_APPDOMAIN_LOADS));
 }
 
 inline BOOL CORProfilerTrackThreads()
@@ -201,7 +1779,7 @@ inline BOOL CORProfilerTrackThreads()
     CONTRACTL_END;
 
     return (CORProfilerPresent() &&
-            ((&g_profControlBlock)->dwEventMask & COR_PRF_MONITOR_THREADS));
+            (&g_profControlBlock)->globalEventMask.IsEventMaskSet(COR_PRF_MONITOR_THREADS));
 }
 
 inline BOOL CORProfilerTrackClasses()
@@ -215,7 +1793,7 @@ inline BOOL CORProfilerTrackClasses()
     CONTRACTL_END;
 
     return (CORProfilerPresent() &&
-            ((&g_profControlBlock)->dwEventMask & COR_PRF_MONITOR_CLASS_LOADS));
+            (&g_profControlBlock)->globalEventMask.IsEventMaskSet(COR_PRF_MONITOR_CLASS_LOADS));
 }
 
 inline BOOL CORProfilerTrackGC()
@@ -229,7 +1807,7 @@ inline BOOL CORProfilerTrackGC()
     CONTRACTL_END;
 
     return (CORProfilerPresent() &&
-            ((&g_profControlBlock)->dwEventMask & COR_PRF_MONITOR_GC));
+            (&g_profControlBlock)->globalEventMask.IsEventMaskSet(COR_PRF_MONITOR_GC));
 }
 
 inline BOOL CORProfilerTrackAllocationsEnabled()
@@ -248,7 +1826,7 @@ inline BOOL CORProfilerTrackAllocationsEnabled()
             (&g_profControlBlock)->fTestOnlyForceObjectAllocated ||
 #endif
             (CORProfilerPresent() &&
-                ((&g_profControlBlock)->dwEventMask & COR_PRF_ENABLE_OBJECT_ALLOCATED))
+                (&g_profControlBlock)->globalEventMask.IsEventMaskSet(COR_PRF_ENABLE_OBJECT_ALLOCATED))
         );
 }
 
@@ -264,7 +1842,7 @@ inline BOOL CORProfilerTrackAllocations()
 
     return
             (CORProfilerTrackAllocationsEnabled() &&
-            ((&g_profControlBlock)->dwEventMask & COR_PRF_MONITOR_OBJECT_ALLOCATED));
+            (&g_profControlBlock)->globalEventMask.IsEventMaskSet(COR_PRF_MONITOR_OBJECT_ALLOCATED));
 }
 
 inline BOOL CORProfilerTrackLargeAllocations()
@@ -279,7 +1857,7 @@ inline BOOL CORProfilerTrackLargeAllocations()
 
     return
             (CORProfilerPresent() &&
-            ((&g_profControlBlock)->dwEventMaskHigh & COR_PRF_HIGH_MONITOR_LARGEOBJECT_ALLOCATED));
+            (&g_profControlBlock)->globalEventMask.IsEventMaskHighSet(COR_PRF_HIGH_MONITOR_LARGEOBJECT_ALLOCATED));
 }
 
 inline BOOL CORProfilerEnableRejit()
@@ -292,8 +1870,8 @@ inline BOOL CORProfilerEnableRejit()
     }
     CONTRACTL_END;
 
-    return (CORProfilerPresent() &&
-            ((&g_profControlBlock)->dwEventMask & COR_PRF_ENABLE_REJIT));
+    return (CORMainProfilerPresent() &&
+            (&g_profControlBlock)->globalEventMask.IsEventMaskSet(COR_PRF_ENABLE_REJIT));
 }
 
 inline BOOL CORProfilerTrackExceptions()
@@ -307,7 +1885,7 @@ inline BOOL CORProfilerTrackExceptions()
     CONTRACTL_END;
 
     return (CORProfilerPresent() &&
-            ((&g_profControlBlock)->dwEventMask & COR_PRF_MONITOR_EXCEPTIONS));
+            (&g_profControlBlock)->globalEventMask.IsEventMaskSet(COR_PRF_MONITOR_EXCEPTIONS));
 }
 
 inline BOOL CORProfilerTrackTransitions()
@@ -321,7 +1899,7 @@ inline BOOL CORProfilerTrackTransitions()
     CONTRACTL_END;
 
     return (CORProfilerPresent() &&
-            ((&g_profControlBlock)->dwEventMask & COR_PRF_MONITOR_CODE_TRANSITIONS));
+            (&g_profControlBlock)->globalEventMask.IsEventMaskSet(COR_PRF_MONITOR_CODE_TRANSITIONS));
 }
 
 inline BOOL CORProfilerTrackEnterLeave()
@@ -340,7 +1918,7 @@ inline BOOL CORProfilerTrackEnterLeave()
 #endif // PROF_TEST_ONLY_FORCE_ELT
 
     return (CORProfilerPresent() &&
-            ((&g_profControlBlock)->dwEventMask & COR_PRF_MONITOR_ENTERLEAVE));
+            (&g_profControlBlock)->globalEventMask.IsEventMaskSet(COR_PRF_MONITOR_ENTERLEAVE));
 }
 
 inline BOOL CORProfilerTrackCCW()
@@ -354,53 +1932,7 @@ inline BOOL CORProfilerTrackCCW()
     CONTRACTL_END;
 
     return (CORProfilerPresent() &&
-            ((&g_profControlBlock)->dwEventMask & COR_PRF_MONITOR_CCW));
-}
-
-inline BOOL CORProfilerTrackRemoting()
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        CANNOT_TAKE_LOCK;
-    }
-    CONTRACTL_END;
-
-    return (CORProfilerPresent() &&
-            ((&g_profControlBlock)->dwEventMask & COR_PRF_MONITOR_REMOTING));
-}
-
-inline BOOL CORProfilerTrackRemotingCookie()
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        CANNOT_TAKE_LOCK;
-    }
-    CONTRACTL_END;
-
-    return
-        (CORProfilerPresent() &&
-        (((&g_profControlBlock)->dwEventMask & COR_PRF_MONITOR_REMOTING_COOKIE)
-                             == COR_PRF_MONITOR_REMOTING_COOKIE));
-}
-
-inline BOOL CORProfilerTrackRemotingAsync()
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        CANNOT_TAKE_LOCK;
-    }
-    CONTRACTL_END;
-
-    return
-        (CORProfilerPresent() &&
-        (((&g_profControlBlock)->dwEventMask & COR_PRF_MONITOR_REMOTING_ASYNC)
-                             == COR_PRF_MONITOR_REMOTING_ASYNC));
+            (&g_profControlBlock)->globalEventMask.IsEventMaskSet(COR_PRF_MONITOR_CCW));
 }
 
 inline BOOL CORProfilerTrackSuspends()
@@ -414,7 +1946,7 @@ inline BOOL CORProfilerTrackSuspends()
     CONTRACTL_END;
 
     return (CORProfilerPresent() &&
-            ((&g_profControlBlock)->dwEventMask & COR_PRF_MONITOR_SUSPENDS));
+            (&g_profControlBlock)->globalEventMask.IsEventMaskSet(COR_PRF_MONITOR_SUSPENDS));
 }
 
 inline BOOL CORProfilerDisableInlining()
@@ -428,21 +1960,7 @@ inline BOOL CORProfilerDisableInlining()
     CONTRACTL_END;
 
     return (CORProfilerPresent() &&
-            ((&g_profControlBlock)->dwEventMask & COR_PRF_DISABLE_INLINING));
-}
-
-inline BOOL CORProfilerJITMapEnabled()
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        CANNOT_TAKE_LOCK;
-    }
-    CONTRACTL_END;
-
-    return (CORProfilerPresent() &&
-            ((&g_profControlBlock)->dwEventMask & COR_PRF_ENABLE_JIT_MAPS));
+            (&g_profControlBlock)->globalEventMask.IsEventMaskSet(COR_PRF_DISABLE_INLINING));
 }
 
 inline BOOL CORProfilerDisableOptimizations()
@@ -457,7 +1975,7 @@ inline BOOL CORProfilerDisableOptimizations()
     CONTRACTL_END;
 
     return (CORProfilerPresent() &&
-            ((&g_profControlBlock)->dwEventMask & COR_PRF_DISABLE_OPTIMIZATIONS));
+            (&g_profControlBlock)->globalEventMask.IsEventMaskSet(COR_PRF_DISABLE_OPTIMIZATIONS));
 }
 
 inline BOOL CORProfilerUseProfileImages()
@@ -475,14 +1993,8 @@ inline BOOL CORProfilerUseProfileImages()
         return TRUE;
 #endif // PROF_TEST_ONLY_FORCE_ELT
 
-    if (!CORProfilerPresent())
-        return FALSE;
-
-    if (((&g_profControlBlock)->dwEventMask &
-            COR_PRF_REQUIRE_PROFILE_IMAGE) == 0)
-        return FALSE;
-
-    return TRUE;
+    return (CORProfilerPresent() &&
+            (&g_profControlBlock)->globalEventMask.IsEventMaskSet(COR_PRF_REQUIRE_PROFILE_IMAGE));
 }
 
 inline BOOL CORProfilerDisableAllNGenImages()
@@ -490,14 +2002,14 @@ inline BOOL CORProfilerDisableAllNGenImages()
     LIMITED_METHOD_DAC_CONTRACT;
 
     return (CORProfilerPresent() &&
-            ((&g_profControlBlock)->dwEventMask & COR_PRF_DISABLE_ALL_NGEN_IMAGES));
+            (&g_profControlBlock)->globalEventMask.IsEventMaskSet(COR_PRF_DISABLE_ALL_NGEN_IMAGES));
 }
 
 inline BOOL CORProfilerTrackConditionalWeakTableElements()
 {
     LIMITED_METHOD_DAC_CONTRACT;
 
-    return CORProfilerTrackGC() && (&g_profControlBlock)->pProfInterface->IsCallback5Supported();
+    return CORProfilerTrackGC() && (&g_profControlBlock)->IsCallback5Supported();
 }
 
 // CORProfilerPresentOrInitializing() returns nonzero iff a CLR Profiler is actively
@@ -508,8 +2020,8 @@ inline BOOL CORProfilerTrackConditionalWeakTableElements()
 // that may still be initializing, and this function is appropriate for that code.
 inline BOOL CORProfilerPresentOrInitializing()
 {
-    LIMITED_METHOD_DAC_CONTRACT;
-    return ((&g_profControlBlock)->curProfStatus.Get() > kProfStatusDetaching);
+    LIMITED_METHOD_CONTRACT;
+    return AnyProfilerPassesCondition([](ProfilerInfo *pProfilerInfo) { return pProfilerInfo->curProfStatus.Get() > kProfStatusDetaching; });
 }
 
 // These return whether a CLR Profiler has requested the specified functionality.
@@ -531,7 +2043,7 @@ inline BOOL CORProfilerELT3SlowPathEnabled()
     CONTRACTL_END;
 
     return (CORProfilerPresentOrInitializing() &&
-        ((&g_profControlBlock)->dwEventMask & (COR_PRF_ENABLE_FUNCTION_ARGS | COR_PRF_ENABLE_FUNCTION_RETVAL | COR_PRF_ENABLE_FRAME_INFO)));
+        (&g_profControlBlock)->globalEventMask.IsEventMaskSet((COR_PRF_ENABLE_FUNCTION_ARGS | COR_PRF_ENABLE_FUNCTION_RETVAL | COR_PRF_ENABLE_FRAME_INFO)));
 }
 
 inline BOOL CORProfilerELT3SlowPathEnterEnabled()
@@ -545,7 +2057,7 @@ inline BOOL CORProfilerELT3SlowPathEnterEnabled()
     CONTRACTL_END;
 
     return (CORProfilerPresentOrInitializing() &&
-        ((&g_profControlBlock)->dwEventMask & (COR_PRF_ENABLE_FUNCTION_ARGS | COR_PRF_ENABLE_FRAME_INFO)));
+        (&g_profControlBlock)->globalEventMask.IsEventMaskSet((COR_PRF_ENABLE_FUNCTION_ARGS | COR_PRF_ENABLE_FRAME_INFO)));
 }
 
 inline BOOL CORProfilerELT3SlowPathLeaveEnabled()
@@ -559,7 +2071,7 @@ inline BOOL CORProfilerELT3SlowPathLeaveEnabled()
     CONTRACTL_END;
 
     return (CORProfilerPresentOrInitializing() &&
-        ((&g_profControlBlock)->dwEventMask & (COR_PRF_ENABLE_FUNCTION_RETVAL | COR_PRF_ENABLE_FRAME_INFO)));
+        (&g_profControlBlock)->globalEventMask.IsEventMaskSet((COR_PRF_ENABLE_FUNCTION_RETVAL | COR_PRF_ENABLE_FRAME_INFO)));
 }
 
 inline BOOL CORProfilerELT3SlowPathTailcallEnabled()
@@ -573,7 +2085,7 @@ inline BOOL CORProfilerELT3SlowPathTailcallEnabled()
     CONTRACTL_END;
 
     return (CORProfilerPresentOrInitializing() &&
-        ((&g_profControlBlock)->dwEventMask & (COR_PRF_ENABLE_FRAME_INFO)));
+        (&g_profControlBlock)->globalEventMask.IsEventMaskSet((COR_PRF_ENABLE_FRAME_INFO)));
 }
 
 inline BOOL CORProfilerELT2FastPathEnterEnabled()
@@ -587,7 +2099,7 @@ inline BOOL CORProfilerELT2FastPathEnterEnabled()
     CONTRACTL_END;
 
     return (CORProfilerPresentOrInitializing() &&
-        (!((&g_profControlBlock)->dwEventMask & (COR_PRF_ENABLE_STACK_SNAPSHOT | COR_PRF_ENABLE_FUNCTION_ARGS | COR_PRF_ENABLE_FRAME_INFO))));
+        !((&g_profControlBlock)->globalEventMask.IsEventMaskSet((COR_PRF_ENABLE_STACK_SNAPSHOT | COR_PRF_ENABLE_FUNCTION_ARGS | COR_PRF_ENABLE_FRAME_INFO))));
 }
 
 inline BOOL CORProfilerELT2FastPathLeaveEnabled()
@@ -601,7 +2113,7 @@ inline BOOL CORProfilerELT2FastPathLeaveEnabled()
     CONTRACTL_END;
 
     return (CORProfilerPresentOrInitializing() &&
-        (!((&g_profControlBlock)->dwEventMask & (COR_PRF_ENABLE_STACK_SNAPSHOT | COR_PRF_ENABLE_FUNCTION_RETVAL | COR_PRF_ENABLE_FRAME_INFO))));
+        !((&g_profControlBlock)->globalEventMask.IsEventMaskSet((COR_PRF_ENABLE_STACK_SNAPSHOT | COR_PRF_ENABLE_FUNCTION_RETVAL | COR_PRF_ENABLE_FRAME_INFO))));
 }
 
 inline BOOL CORProfilerELT2FastPathTailcallEnabled()
@@ -615,7 +2127,7 @@ inline BOOL CORProfilerELT2FastPathTailcallEnabled()
     CONTRACTL_END;
 
     return (CORProfilerPresentOrInitializing() &&
-        (!((&g_profControlBlock)->dwEventMask & (COR_PRF_ENABLE_STACK_SNAPSHOT | COR_PRF_ENABLE_FRAME_INFO))));
+        !((&g_profControlBlock)->globalEventMask.IsEventMaskSet((COR_PRF_ENABLE_STACK_SNAPSHOT | COR_PRF_ENABLE_FRAME_INFO))));
 }
 
 inline BOOL CORProfilerFunctionArgsEnabled()
@@ -629,7 +2141,7 @@ inline BOOL CORProfilerFunctionArgsEnabled()
     CONTRACTL_END;
 
     return (CORProfilerPresentOrInitializing() &&
-        ((&g_profControlBlock)->dwEventMask & COR_PRF_ENABLE_FUNCTION_ARGS));
+        (&g_profControlBlock)->globalEventMask.IsEventMaskSet(COR_PRF_ENABLE_FUNCTION_ARGS));
 }
 
 inline BOOL CORProfilerFunctionReturnValueEnabled()
@@ -643,7 +2155,7 @@ inline BOOL CORProfilerFunctionReturnValueEnabled()
     CONTRACTL_END;
 
     return (CORProfilerPresentOrInitializing() &&
-        ((&g_profControlBlock)->dwEventMask & COR_PRF_ENABLE_FUNCTION_RETVAL));
+        (&g_profControlBlock)->globalEventMask.IsEventMaskSet(COR_PRF_ENABLE_FUNCTION_RETVAL));
 }
 
 inline BOOL CORProfilerFrameInfoEnabled()
@@ -657,7 +2169,7 @@ inline BOOL CORProfilerFrameInfoEnabled()
     CONTRACTL_END;
 
     return (CORProfilerPresentOrInitializing() &&
-        ((&g_profControlBlock)->dwEventMask & COR_PRF_ENABLE_FRAME_INFO));
+        (&g_profControlBlock)->globalEventMask.IsEventMaskSet(COR_PRF_ENABLE_FRAME_INFO));
 }
 
 inline BOOL CORProfilerStackSnapshotEnabled()
@@ -671,21 +2183,7 @@ inline BOOL CORProfilerStackSnapshotEnabled()
     CONTRACTL_END;
 
     return (CORProfilerPresentOrInitializing() &&
-        ((&g_profControlBlock)->dwEventMask & COR_PRF_ENABLE_STACK_SNAPSHOT));
-}
-
-inline BOOL CORProfilerAddsAssemblyReferences()
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        CANNOT_TAKE_LOCK;
-    }
-    CONTRACTL_END;
-
-    return (CORProfilerPresent() &&
-        ((&g_profControlBlock)->dwEventMaskHigh & COR_PRF_HIGH_ADD_ASSEMBLY_REFERENCES));
+        (&g_profControlBlock)->globalEventMask.IsEventMaskSet(COR_PRF_ENABLE_STACK_SNAPSHOT));
 }
 
 inline BOOL CORProfilerInMemorySymbolsUpdatesEnabled()
@@ -699,10 +2197,10 @@ inline BOOL CORProfilerInMemorySymbolsUpdatesEnabled()
     CONTRACTL_END;
 
     return (CORProfilerPresent() &&
-        ((&g_profControlBlock)->dwEventMaskHigh & COR_PRF_HIGH_IN_MEMORY_SYMBOLS_UPDATED));
+        (&g_profControlBlock)->globalEventMask.IsEventMaskHighSet(COR_PRF_HIGH_IN_MEMORY_SYMBOLS_UPDATED));
 }
 
-inline BOOL CORProfilerIsMonitoringDynamicFunctionUnloads()
+inline BOOL CORProfilerTrackDynamicFunctionUnloads()
 {
     CONTRACTL
     {
@@ -713,7 +2211,7 @@ inline BOOL CORProfilerIsMonitoringDynamicFunctionUnloads()
     CONTRACTL_END;
 
     return (CORProfilerPresent() &&
-        ((&g_profControlBlock)->dwEventMaskHigh & COR_PRF_HIGH_MONITOR_DYNAMIC_FUNCTION_UNLOADS));
+        (&g_profControlBlock)->globalEventMask.IsEventMaskHighSet(COR_PRF_HIGH_MONITOR_DYNAMIC_FUNCTION_UNLOADS));
 }
 
 inline BOOL CORProfilerDisableTieredCompilation()
@@ -728,7 +2226,7 @@ inline BOOL CORProfilerDisableTieredCompilation()
 
 
     return (CORProfilerPresent() &&
-         ((&g_profControlBlock)->dwEventMaskHigh & COR_PRF_HIGH_DISABLE_TIERED_COMPILATION));
+         (&g_profControlBlock)->globalEventMask.IsEventMaskHighSet(COR_PRF_HIGH_DISABLE_TIERED_COMPILATION));
 }
 
 inline BOOL CORProfilerTrackBasicGC()
@@ -742,7 +2240,7 @@ inline BOOL CORProfilerTrackBasicGC()
     CONTRACTL_END;
 
     return (CORProfilerPresent() &&
-         ((&g_profControlBlock)->dwEventMaskHigh & COR_PRF_HIGH_BASIC_GC));
+         (&g_profControlBlock)->globalEventMask.IsEventMaskHighSet(COR_PRF_HIGH_BASIC_GC));
 }
 
 inline BOOL CORProfilerTrackGCMovedObjects()
@@ -756,10 +2254,10 @@ inline BOOL CORProfilerTrackGCMovedObjects()
     CONTRACTL_END;
 
     return (CORProfilerPresent() &&
-         ((&g_profControlBlock)->dwEventMaskHigh & COR_PRF_HIGH_MONITOR_GC_MOVED_OBJECTS));
+         (&g_profControlBlock)->globalEventMask.IsEventMaskHighSet(COR_PRF_HIGH_MONITOR_GC_MOVED_OBJECTS));
 }
 
-inline BOOL CORProfilerIsMonitoringEventPipe()
+inline BOOL CORProfilerTrackEventPipe()
 {
     CONTRACTL
     {
@@ -770,55 +2268,38 @@ inline BOOL CORProfilerIsMonitoringEventPipe()
     CONTRACTL_END;
 
     return (CORProfilerPresent() &&
-        ((&g_profControlBlock)->dwEventMaskHigh & COR_PRF_HIGH_MONITOR_EVENT_PIPE));
+        (&g_profControlBlock)->globalEventMask.IsEventMaskHighSet(COR_PRF_HIGH_MONITOR_EVENT_PIPE));
 }
 
 #if defined(PROFILING_SUPPORTED) && !defined(CROSSGEN_COMPILE)
 
-#if defined(FEATURE_PROFAPI_ATTACH_DETACH)
-
-//---------------------------------------------------------------------------------------
-// When EE calls into the profiler, an EvacuationCounterHolder object is instantiated on
-// the stack to increment the evacuation counter inside the EE Thread. Upon returning to
-// EE, this EvacuationCounterHolder object when being destroyed decreases the evacuation
-// counter by one.
-//
-// Do not use this object directly.  Use BEGIN_PIN_PROFILER / END_PIN_PROFILER defined
-// below.
-//
-// See code:ProfilingAPIUtility::InitializeProfiling#LoadUnloadCallbackSynchronization.
-//
-typedef Wrapper<Thread *, ProfilingAPIUtility::IncEvacuationCounter, ProfilingAPIUtility::DecEvacuationCounter,
-    (UINT_PTR)0, CompareDefault<Thread *>> EvacuationCounterHolder;
-
-
 //---------------------------------------------------------------------------------------
-// These macros must be placed around any access to g_profControlBlock.pProfInterface by
+// These macros must be placed around any callbacks to g_profControlBlock by
 // the EE. Example:
 //    {
-//        BEGIN_PIN_PROFILER(CORProfilerTrackAppDomainLoads());
-//        g_profControlBlock.pProfInterface->AppDomainCreationStarted(MyAppDomainID);
-//        END_PIN_PROFILER();
+//        BEGIN_PROFILER_CALLBACK(CORProfilerTrackAppDomainLoads;
+//        g_profControlBlock.AppDomainCreationStarted(MyAppDomainID);
+//        END_PROFILER_CALLBACK();
 //    }
-// The parameter to the BEGIN_PIN_PROFILER is the condition you want to check for, to
+// The parameter to the BEGIN_PROFILER_CALLBACK is the condition you want to check for, to
 // determine whether the profiler is loaded and requesting the callback you're about to
 // issue. Typically, this will be a call to one of the inline functions in
 // profilepriv.inl. If the condition is true, the macro will increment an evacuation
 // counter that effectively pins the profiler, recheck the condition, and (if still
-// true), execute whatever code you place inside the BEGIN/END_PIN_PROFILER block. If
+// true), execute whatever code you place inside the BEGIN/END_PROFILER_CALLBACK block. If
 // your condition is more complex than a simple profiler status check, then place the
 // profiler status check as parameter to the macro, and add a separate if inside the
 // block. Example:
 //
 //    {
-//        BEGIN_PIN_PROFILER(CORProfilerTrackTransitions());
+//        BEGIN_PROFILER_CALLBACK(CorProfilerTrackTransitions);
 //        if (!pNSL->pMD->IsQCall())
 //        {
-//            g_profControlBlock.pProfInterface->
+//            g_profControlBlock.
 //                ManagedToUnmanagedTransition((FunctionID) pNSL->pMD,
 //                COR_PRF_TRANSITION_CALL);
 //        }
-//        END_PIN_PROFILER();
+//        END_PROFILER_CALLBACK();
 //    }
 //
 // This ensures that the extra condition check (in this case "if
@@ -827,35 +2308,19 @@ typedef Wrapper<Thread *, ProfilingAPIUtility::IncEvacuationCounter, ProfilingAP
 //
 // See code:ProfilingAPIUtility::InitializeProfiling#LoadUnloadCallbackSynchronization
 // for more details about how the synchronization works.
-#define BEGIN_PIN_PROFILER(condition)                                                       \
+#define BEGIN_PROFILER_CALLBACK(condition)                                                  \
     /* Do a cheap check of the condition (dirty-read)                                   */  \
     if (condition)                                                                          \
     {                                                                                       \
-        EvacuationCounterHolder __evacuationCounter(GetThreadNULLOk());                     \
-        /* Now that the evacuation counter is incremented, the condition re-check       */  \
-        /* below is a clean read.  There's no MemoryBarrier() here, but that's ok       */  \
-        /* as writes to the profiler status force a FlushStoreBuffers().                */  \
-        if (condition)                                                                      \
-        {
-#define END_PIN_PROFILER()  } }
-
-#else // FEATURE_PROFAPI_ATTACH_DETACH
-
-// For builds that include profiling but not attach / detach (e.g., Silverlight 2), the
-// *PIN_PROFILER macros should just check the condition without using the evacuation
-// counters.
-
-#define BEGIN_PIN_PROFILER(condition)       if (condition) {
-#define END_PIN_PROFILER()                  }
 
-#endif // FEATURE_PROFAPI_ATTACH_DETACH
+#define END_PROFILER_CALLBACK()  }
 
 #else // PROFILING_SUPPORTED && !CROSSGEN_COMPILE
 
 // Profiling feature not supported
 
-#define BEGIN_PIN_PROFILER(condition)       if (false) {
-#define END_PIN_PROFILER()                  }
+#define BEGIN_PROFILER_CALLBACK(condition)       if (false) {
+#define END_PROFILER_CALLBACK()                  }
 
 #endif // PROFILING_SUPPORTED && !CROSSGEN_COMPILE
 
diff --git a/src/coreclr/inc/readytorun.h b/src/coreclr/inc/readytorun.h
index f35d80c37d1451..7d43b403894582 100644
--- a/src/coreclr/inc/readytorun.h
+++ b/src/coreclr/inc/readytorun.h
@@ -16,7 +16,7 @@
 
 // Keep these in sync with src/coreclr/tools/Common/Internal/Runtime/ModuleHeaders.cs
 #define READYTORUN_MAJOR_VERSION 0x0005
-#define READYTORUN_MINOR_VERSION 0x0003
+#define READYTORUN_MINOR_VERSION 0x0004
 
 #define MINIMUM_READYTORUN_MAJOR_VERSION 0x003
 
@@ -134,6 +134,7 @@ enum ReadyToRunMethodSigFlags
     READYTORUN_METHOD_SIG_MemberRefToken        = 0x10,
     READYTORUN_METHOD_SIG_Constrained           = 0x20,
     READYTORUN_METHOD_SIG_OwnerType             = 0x40,
+    READYTORUN_METHOD_SIG_UpdateContext         = 0x80,
 };
 
 enum ReadyToRunFieldSigFlags
@@ -152,6 +153,12 @@ enum ReadyToRunTypeLayoutFlags
     READYTORUN_LAYOUT_GCLayout_Empty            = 0x10,
 };
 
+enum ReadyToRunVirtualFunctionOverrideFlags
+{
+    READYTORUN_VIRTUAL_OVERRIDE_None = 0x00,
+    READYTORUN_VIRTUAL_OVERRIDE_VirtualFunctionOverriden = 0x01,
+};
+
 //
 // Constants for fixup signature encoding
 //
@@ -211,6 +218,9 @@ enum ReadyToRunFixupKind
 
     READYTORUN_FIXUP_Verify_FieldOffset         = 0x31, /* Generate a runtime check to ensure that the field offset matches between compile and runtime. Unlike Check_FieldOffset, this will generate a runtime failure instead of silently dropping the method */
     READYTORUN_FIXUP_Verify_TypeLayout          = 0x32, /* Generate a runtime check to ensure that the type layout (size, alignment, HFA, reference map) matches between compile and runtime. Unlike Check_TypeLayout, this will generate a runtime failure instead of silently dropping the method */
+
+    READYTORUN_FIXUP_Check_VirtualFunctionOverride = 0x33, /* Generate a runtime check to ensure that virtual function resolution has equivalent behavior at runtime as at compile time. If not equivalent, code will not be used */
+    READYTORUN_FIXUP_Verify_VirtualFunctionOverride = 0x34, /* Generate a runtime check to ensure that virtual function resolution has equivalent behavior at runtime as at compile time. If not equivalent, generate runtime failure. */
 };
 
 //
diff --git a/src/coreclr/inc/sarray.inl b/src/coreclr/inc/sarray.inl
index b375b6a633b23e..7d6a5b6a37d099 100644
--- a/src/coreclr/inc/sarray.inl
+++ b/src/coreclr/inc/sarray.inl
@@ -247,7 +247,7 @@ inline void SArray<ELEMENT, BITWISE_COPY>::Delete(const Iterator &i, COUNT_T cou
 }
 
 template <typename ELEMENT, BOOL BITWISE_COPY>
-inline void SArray<ELEMENT, BITWISE_COPY>:: Replace(const Iterator &i, COUNT_T deleteCount, COUNT_T insertCount)
+inline void SArray<ELEMENT, BITWISE_COPY>::Replace(const Iterator &i, COUNT_T deleteCount, COUNT_T insertCount)
 {
     WRAPPER_NO_CONTRACT;
     DestructBuffer(i, deleteCount);
diff --git a/src/coreclr/inc/stresslog.h b/src/coreclr/inc/stresslog.h
index 8f1f81002b5abc..508bc91edb72a0 100644
--- a/src/coreclr/inc/stresslog.h
+++ b/src/coreclr/inc/stresslog.h
@@ -787,131 +787,7 @@ class ThreadStressLog {
     }
 #endif //STRESS_LOG_READONLY
 
-    static const char* gcStartMsg()
-    {
-        STATIC_CONTRACT_LEAF;
-        return "{ =========== BEGINGC %d, (requested generation = %lu, collect_classes = %lu) ==========\n";
-    }
-
-    static const char* gcEndMsg()
-    {
-        STATIC_CONTRACT_LEAF;
-        return "========== ENDGC %d (gen = %lu, collect_classes = %lu) ===========}\n";
-    }
-
-    static const char* gcRootMsg()
-    {
-        STATIC_CONTRACT_LEAF;
-        return "    GC Root %p RELOCATED %p -> %p  MT = %pT\n";
-    }
-
-    static const char* gcRootPromoteMsg()
-    {
-        STATIC_CONTRACT_LEAF;
-        return "    IGCHeap::Promote: Promote GC Root *%p = %p MT = %pT\n";
-    }
-
-    static const char* gcPlugMoveMsg()
-    {
-        STATIC_CONTRACT_LEAF;
-        return "GC_HEAP RELOCATING Objects in heap within range [%p %p) by -0x%x bytes\n";
-    }
-
-    static const char* gcServerThread0StartMsg()
-    {
-        STATIC_CONTRACT_LEAF;
-        return "%d gc thread waiting...";
-    }
-
-    static const char* gcServerThreadNStartMsg()
-    {
-        STATIC_CONTRACT_LEAF;
-        return "%d gc thread waiting... Done";
-    }
-
-    static const char* gcDetailedStartMsg()
-    {
-        STATIC_CONTRACT_LEAF;
-        return "*GC* %d(gen0:%d)(%d)(alloc: %Id)(%s)(%d)";
-    }
-
-    static const char* gcDetailedEndMsg()
-    {
-        STATIC_CONTRACT_LEAF;
-        return "*EGC* %Id(gen0:%Id)(%Id)(%d)(%s)(%s)(%s)(ml: %d->%d)";
-    }
-
-    static const char* gcStartMarkMsg()
-    {
-        STATIC_CONTRACT_LEAF;
-        return "---- Mark Phase on heap %d condemning %d ----";
-    }
-
-    static const char* gcStartPlanMsg()
-    {
-        STATIC_CONTRACT_LEAF;
-        return "---- Plan Phase on heap %d ---- Condemned generation %d, promotion: %d";
-    }
-
-    static const char* gcStartRelocateMsg()
-    {
-        STATIC_CONTRACT_LEAF;
-        return "---- Relocate phase on heap %d -----";
-    }
-
-    static const char* gcEndRelocateMsg()
-    {
-        STATIC_CONTRACT_LEAF;
-        return "---- End of Relocate phase on heap %d ----";
-    }
-
-    static const char* gcStartCompactMsg()
-    {
-        STATIC_CONTRACT_LEAF;
-        return "---- Compact Phase on heap %d: %Ix(%Ix)----";
-    }
-
-    static const char* gcEndCompactMsg()
-    {
-        STATIC_CONTRACT_LEAF;
-        return "---- End of Compact phase on heap %d ----";
-    }
-
-    static const char* gcMemCopyMsg()
-    {
-        STATIC_CONTRACT_LEAF;
-        return " mc: [%Ix->%Ix, %Ix->%Ix[";
-    }
-
-    static const char* gcPlanPlugMsg()
-    {
-        STATIC_CONTRACT_LEAF;
-        return "(%Ix)[%Ix->%Ix, NA: [%Ix(%Id), %Ix[: %Ix(%d), x: %Ix (%s)";
-    }
-
-    static const char* gcPlanPinnedPlugMsg()
-    {
-        STATIC_CONTRACT_LEAF;
-        return "(%Ix)PP: [%Ix, %Ix[%Ix](m:%d)";
-    }
-
-    static const char* gcDesiredNewAllocationMsg()
-    {
-        STATIC_CONTRACT_LEAF;
-        return "h%d g%d surv: %Id current: %Id alloc: %Id (%d%%) f: %d%% new-size: %Id new-alloc: %Id";
-    }
-
-    static const char* gcMakeUnusedArrayMsg()
-    {
-        STATIC_CONTRACT_LEAF;
-        return "Making unused array [%Ix, %Ix[";
-    }
-
-    static const char* gcStartBgcThread()
-    {
-        STATIC_CONTRACT_LEAF;
-        return "beginning of bgc on heap %d: gen2 FL: %d, FO: %d, frag: %d";
-    }
+    #include "gcmsg.inl"
 
     static const char* TaskSwitchMsg()
     {
diff --git a/src/coreclr/inc/switches.h b/src/coreclr/inc/switches.h
index 322a71ea11f440..d0ccfad62797c0 100644
--- a/src/coreclr/inc/switches.h
+++ b/src/coreclr/inc/switches.h
@@ -53,7 +53,7 @@
 #if defined(TARGET_X86) || defined(TARGET_ARM)
     #define USE_UPPER_ADDRESS       0
 
-#elif defined(TARGET_AMD64) || defined(TARGET_ARM64)
+#elif defined(TARGET_AMD64) || defined(TARGET_ARM64) || defined(TARGET_S390X)
     #define UPPER_ADDRESS_MAPPING_FACTOR 2
     #define CLR_UPPER_ADDRESS_MIN   0x64400000000
     #define CODEHEAP_START_ADDRESS  0x64480000000
diff --git a/src/coreclr/inc/volatile.h b/src/coreclr/inc/volatile.h
index f5bb1f09f063d1..610a408f39fb6e 100644
--- a/src/coreclr/inc/volatile.h
+++ b/src/coreclr/inc/volatile.h
@@ -68,8 +68,8 @@
 #error The Volatile type is currently only defined for Visual C++ and GNU C++
 #endif
 
-#if defined(__GNUC__) && !defined(HOST_X86) && !defined(HOST_AMD64) && !defined(HOST_ARM) && !defined(HOST_ARM64)
-#error The Volatile type is currently only defined for GCC when targeting x86, AMD64, ARM or ARM64 CPUs
+#if defined(__GNUC__) && !defined(HOST_X86) && !defined(HOST_AMD64) && !defined(HOST_ARM) && !defined(HOST_ARM64) && !defined(HOST_S390X)
+#error The Volatile type is currently only defined for GCC when targeting x86, AMD64, ARM, ARM64, or S390X CPUs
 #endif
 
 #if defined(__GNUC__)
diff --git a/src/coreclr/jit/CMakeLists.txt b/src/coreclr/jit/CMakeLists.txt
index cd78586ed0db7d..f06c011e5b9639 100644
--- a/src/coreclr/jit/CMakeLists.txt
+++ b/src/coreclr/jit/CMakeLists.txt
@@ -31,6 +31,8 @@ function(create_standalone_jit)
     set(JIT_ARCH_SOURCES ${JIT_I386_SOURCES})
   elseif(TARGETDETAILS_ARCH STREQUAL "arm64")
     set(JIT_ARCH_SOURCES ${JIT_ARM64_SOURCES})
+  elseif(TARGETDETAILS_ARCH STREQUAL "s390x")
+    set(JIT_ARCH_SOURCES ${JIT_S390X_SOURCES})
   else()
     clr_unknown_arch()
   endif()
@@ -345,6 +347,10 @@ set( JIT_ARM64_SOURCES
   hwintrinsiccodegenarm64.cpp
 )
 
+set( JIT_S390X_SOURCES
+  # Not supported as JIT target
+)
+
 if(CLR_CMAKE_TARGET_ARCH_AMD64)
   set(JIT_ARCH_SOURCES ${JIT_AMD64_SOURCES})
 elseif(CLR_CMAKE_TARGET_ARCH_ARM)
@@ -353,6 +359,8 @@ elseif(CLR_CMAKE_TARGET_ARCH_I386)
   set(JIT_ARCH_SOURCES ${JIT_I386_SOURCES})
 elseif(CLR_CMAKE_TARGET_ARCH_ARM64)
   set(JIT_ARCH_SOURCES ${JIT_ARM64_SOURCES})
+elseif(CLR_CMAKE_TARGET_ARCH_S390X)
+  set(JIT_ARCH_SOURCES ${JIT_S390X_SOURCES})
 else()
   clr_unknown_arch()
 endif()
@@ -508,8 +516,14 @@ target_compile_definitions(clrjit_unix_arm_${ARCH_HOST_NAME} PRIVATE ARM_SOFTFP
 create_standalone_jit(TARGET clrjit_win_arm_${ARCH_HOST_NAME} OS win ARCH arm DESTINATIONS .)
 create_standalone_jit(TARGET clrjit_win_x86_${ARCH_HOST_NAME} OS win ARCH x86 DESTINATIONS .)
 
+if (CLR_CMAKE_TARGET_ARCH_I386 AND CLR_CMAKE_TARGET_UNIX)
+  create_standalone_jit(TARGET clrjit_unix_x86_${ARCH_HOST_NAME} OS unix ARCH x86 DESTINATIONS .)
+endif (CLR_CMAKE_TARGET_ARCH_I386 AND CLR_CMAKE_TARGET_UNIX)
+
 if (CLR_CMAKE_TARGET_UNIX)
-    install_clr(TARGETS clrjit_unix_${ARCH_TARGET_NAME}_${ARCH_HOST_NAME} DESTINATIONS . COMPONENT jit)
+    if (NOT ARCH_TARGET_NAME STREQUAL s390x)
+      install_clr(TARGETS clrjit_unix_${ARCH_TARGET_NAME}_${ARCH_HOST_NAME} DESTINATIONS . COMPONENT jit)
+    endif(NOT ARCH_TARGET_NAME STREQUAL s390x)
     if (ARCH_TARGET_NAME STREQUAL arm)
       target_compile_definitions(clrjit_unix_arm_${ARCH_HOST_NAME} PRIVATE ARM_SOFTFP CONFIGURABLE_ARM_ABI)
   endif (ARCH_TARGET_NAME STREQUAL arm)
diff --git a/src/coreclr/jit/assertionprop.cpp b/src/coreclr/jit/assertionprop.cpp
index 82a578f6f754b4..981879142bf265 100644
--- a/src/coreclr/jit/assertionprop.cpp
+++ b/src/coreclr/jit/assertionprop.cpp
@@ -4818,15 +4818,15 @@ ASSERT_TP* Compiler::optComputeAssertionGen()
 {
     ASSERT_TP* jumpDestGen = fgAllocateTypeForEachBlk<ASSERT_TP>();
 
-    for (BasicBlock* block = fgFirstBB; block != nullptr; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
         ASSERT_TP valueGen = BitVecOps::MakeEmpty(apTraits);
         GenTree*  jtrue    = nullptr;
 
         // Walk the statement trees in this basic block.
-        for (Statement* stmt : block->Statements())
+        for (Statement* const stmt : block->Statements())
         {
-            for (GenTree* tree = stmt->GetTreeList(); tree != nullptr; tree = tree->gtNext)
+            for (GenTree* const tree : stmt->TreeList())
             {
                 if (tree->gtOper == GT_JTRUE)
                 {
@@ -4930,7 +4930,7 @@ ASSERT_TP* Compiler::optInitAssertionDataflowFlags()
 
     // Initially estimate the OUT sets to everything except killed expressions
     // Also set the IN sets to 1, so that we can perform the intersection.
-    for (BasicBlock* block = fgFirstBB; block; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
         block->bbAssertionIn      = BitVecOps::MakeCopy(apTraits, apValidFull);
         block->bbAssertionGen     = BitVecOps::MakeEmpty(apTraits);
@@ -5338,7 +5338,7 @@ void Compiler::optAssertionPropMain()
     noway_assert(optAssertionCount == 0);
 
     // First discover all value assignments and record them in the table.
-    for (BasicBlock* block = fgFirstBB; block; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
         compCurBB = block;
 
@@ -5375,7 +5375,7 @@ void Compiler::optAssertionPropMain()
             }
 
             // Perform assertion gen for control flow based assertions.
-            for (GenTree* tree = stmt->GetTreeList(); tree != nullptr; tree = tree->gtNext)
+            for (GenTree* const tree : stmt->TreeList())
             {
                 optAssertionGen(tree);
             }
@@ -5390,7 +5390,7 @@ void Compiler::optAssertionPropMain()
         // Zero out the bbAssertionIn values, as these can be referenced in RangeCheck::MergeAssertion
         // and this is sharedstate with the CSE phase: bbCseIn
         //
-        for (BasicBlock* block = fgFirstBB; block; block = block->bbNext)
+        for (BasicBlock* const block : Blocks())
         {
             block->bbAssertionIn = BitVecOps::MakeEmpty(apTraits);
         }
@@ -5410,7 +5410,7 @@ void Compiler::optAssertionPropMain()
     AssertionPropFlowCallback ap(this, bbJtrueAssertionOut, jumpDestGen);
     flow.ForwardAnalysis(ap);
 
-    for (BasicBlock* block = fgFirstBB; block; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
         // Compute any implied non-Null assertions for block->bbAssertionIn
         optImpliedByTypeOfAssertions(block->bbAssertionIn);
@@ -5420,7 +5420,7 @@ void Compiler::optAssertionPropMain()
     if (verbose)
     {
         printf("\n");
-        for (BasicBlock* block = fgFirstBB; block; block = block->bbNext)
+        for (BasicBlock* const block : Blocks())
         {
             printf("\n" FMT_BB, block->bbNum);
             printf(" valueIn  = %s", BitVecOps::ToString(apTraits, block->bbAssertionIn));
@@ -5438,7 +5438,7 @@ void Compiler::optAssertionPropMain()
     ASSERT_TP assertions = BitVecOps::MakeEmpty(apTraits);
 
     // Perform assertion propagation (and constant folding)
-    for (BasicBlock* block = fgFirstBB; block; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
         BitVecOps::Assign(apTraits, assertions, block->bbAssertionIn);
 
diff --git a/src/coreclr/jit/block.cpp b/src/coreclr/jit/block.cpp
index fed7b59d329e75..128c4e033d9fa5 100644
--- a/src/coreclr/jit/block.cpp
+++ b/src/coreclr/jit/block.cpp
@@ -163,10 +163,9 @@ flowList* Compiler::BlockPredsWithEH(BasicBlock* blk)
         // Find the first block of the try.
         EHblkDsc*   ehblk    = ehGetDsc(tryIndex);
         BasicBlock* tryStart = ehblk->ebdTryBeg;
-        for (flowList* tryStartPreds = tryStart->bbPreds; tryStartPreds != nullptr;
-             tryStartPreds           = tryStartPreds->flNext)
+        for (BasicBlock* const tryStartPredBlock : tryStart->PredBlocks())
         {
-            res = new (this, CMK_FlowList) flowList(tryStartPreds->getBlock(), res);
+            res = new (this, CMK_FlowList) flowList(tryStartPredBlock, res);
 
 #if MEASURE_BLOCK_SIZE
             genFlowNodeCnt += 1;
@@ -182,7 +181,7 @@ flowList* Compiler::BlockPredsWithEH(BasicBlock* blk)
         //     (plus adding in any filter blocks outside the try whose exceptions are handled here).
         // That doesn't work, however: funclets have caused us to sometimes split the body of a try into
         // more than one sequence of contiguous blocks.  We need to find a better way to do this.
-        for (BasicBlock* bb = fgFirstBB; bb != nullptr; bb = bb->bbNext)
+        for (BasicBlock* const bb : Blocks())
         {
             if (bbInExnFlowRegions(tryIndex, bb) && !bb->isBBCallAlwaysPairTail())
             {
@@ -217,9 +216,9 @@ flowList* Compiler::BlockPredsWithEH(BasicBlock* blk)
 bool BasicBlock::checkPredListOrder()
 {
     unsigned lastBBNum = 0;
-    for (flowList* pred = bbPreds; pred != nullptr; pred = pred->flNext)
+    for (BasicBlock* const predBlock : PredBlocks())
     {
-        const unsigned bbNum = pred->getBlock()->bbNum;
+        const unsigned bbNum = predBlock->bbNum;
         if (bbNum <= lastBBNum)
         {
             assert(bbNum != lastBBNum);
@@ -261,7 +260,7 @@ void BasicBlock::reorderPredList(Compiler* compiler)
     // Count number or entries.
     //
     int count = 0;
-    for (flowList* pred = bbPreds; pred != nullptr; pred = pred->flNext)
+    for (flowList* const pred : PredEdges())
     {
         count++;
     }
@@ -286,7 +285,7 @@ void BasicBlock::reorderPredList(Compiler* compiler)
 
     // Fill in the vector from the list.
     //
-    for (flowList* pred = bbPreds; pred != nullptr; pred = pred->flNext)
+    for (flowList* const pred : PredEdges())
     {
         sortVector->push_back(pred);
     }
@@ -516,7 +515,7 @@ void BasicBlock::dspFlags()
 unsigned BasicBlock::dspPreds()
 {
     unsigned count = 0;
-    for (flowList* pred = bbPreds; pred != nullptr; pred = pred->flNext)
+    for (flowList* const pred : PredEdges())
     {
         if (count != 0)
         {
@@ -575,20 +574,16 @@ unsigned BasicBlock::dspCheapPreds()
 /*****************************************************************************
  *
  *  Display the basic block successors.
- *  Returns the count of successors.
  */
 
-unsigned BasicBlock::dspSuccs(Compiler* compiler)
+void BasicBlock::dspSuccs(Compiler* compiler)
 {
-    unsigned numSuccs = NumSucc(compiler);
-    unsigned count    = 0;
-    for (unsigned i = 0; i < numSuccs; i++)
+    bool first = true;
+    for (BasicBlock* const succ : Succs(compiler))
     {
-        printf("%s", (count == 0) ? "" : ",");
-        printf(FMT_BB, GetSucc(i, compiler)->bbNum);
-        count++;
+        printf("%s" FMT_BB, first ? "" : ",", succ->bbNum);
+        first = false;
     }
-    return count;
 }
 
 // Display a compact representation of the bbJumpKind, that is, where this block branches.
@@ -773,7 +768,7 @@ bool BasicBlock::CloneBlockState(
     to->bbTgtStkDepth = from->bbTgtStkDepth;
 #endif // DEBUG
 
-    for (Statement* fromStmt : from->Statements())
+    for (Statement* const fromStmt : from->Statements())
     {
         auto newExpr = compiler->gtCloneExpr(fromStmt->GetRootNode(), GTF_EMPTY, varNum, varVal);
         if (!newExpr)
@@ -800,7 +795,7 @@ void BasicBlock::MakeLIR(GenTree* firstNode, GenTree* lastNode)
     bbFlags |= BBF_IS_LIR;
 }
 
-bool BasicBlock::IsLIR()
+bool BasicBlock::IsLIR() const
 {
     assert(isValid());
     const bool isLIR = ((bbFlags & BBF_IS_LIR) != 0);
@@ -845,7 +840,7 @@ Statement* BasicBlock::lastStmt() const
 //------------------------------------------------------------------------
 // BasicBlock::firstNode: Returns the first node in the block.
 //
-GenTree* BasicBlock::firstNode()
+GenTree* BasicBlock::firstNode() const
 {
     return IsLIR() ? GetFirstLIRNode() : Compiler::fgGetFirstNode(firstStmt()->GetRootNode());
 }
@@ -853,7 +848,7 @@ GenTree* BasicBlock::firstNode()
 //------------------------------------------------------------------------
 // BasicBlock::lastNode: Returns the last node in the block.
 //
-GenTree* BasicBlock::lastNode()
+GenTree* BasicBlock::lastNode() const
 {
     return IsLIR() ? m_lastNode : lastStmt()->GetRootNode();
 }
@@ -873,7 +868,7 @@ GenTree* BasicBlock::lastNode()
 //    a backedge), we never want to consider it "unique" because the prolog is an
 //    implicit predecessor.
 
-BasicBlock* BasicBlock::GetUniquePred(Compiler* compiler)
+BasicBlock* BasicBlock::GetUniquePred(Compiler* compiler) const
 {
     if ((bbPreds == nullptr) || (bbPreds->flNext != nullptr) || (this == compiler->fgFirstBB))
     {
@@ -895,7 +890,7 @@ BasicBlock* BasicBlock::GetUniquePred(Compiler* compiler)
 // Return Value:
 //    The unique successor of a block, or nullptr if there is no unique successor.
 
-BasicBlock* BasicBlock::GetUniqueSucc()
+BasicBlock* BasicBlock::GetUniqueSucc() const
 {
     if (bbJumpKind == BBJ_ALWAYS)
     {
@@ -933,20 +928,16 @@ unsigned JitPtrKeyFuncs<BasicBlock>::GetHashCode(const BasicBlock* ptr)
 //    True if block is empty, or contains only PHI assignments,
 //    or contains zero or more PHI assignments followed by NOPs.
 //
-bool BasicBlock::isEmpty()
+bool BasicBlock::isEmpty() const
 {
     if (!IsLIR())
     {
-        Statement* stmt = FirstNonPhiDef();
-
-        while (stmt != nullptr)
+        for (Statement* const stmt : NonPhiStatements())
         {
             if (!stmt->GetRootNode()->OperIs(GT_NOP))
             {
                 return false;
             }
-
-            stmt = stmt->GetNextStmt();
         }
     }
     else
@@ -969,7 +960,7 @@ bool BasicBlock::isEmpty()
 // Return Value:
 //    True if it a valid basic block.
 //
-bool BasicBlock::isValid()
+bool BasicBlock::isValid() const
 {
     const bool isLIR = ((bbFlags & BBF_IS_LIR) != 0);
     if (isLIR)
@@ -984,7 +975,7 @@ bool BasicBlock::isValid()
     }
 }
 
-Statement* BasicBlock::FirstNonPhiDef()
+Statement* BasicBlock::FirstNonPhiDef() const
 {
     Statement* stmt = firstStmt();
     if (stmt == nullptr)
@@ -1005,7 +996,7 @@ Statement* BasicBlock::FirstNonPhiDef()
     return stmt;
 }
 
-Statement* BasicBlock::FirstNonPhiDefOrCatchArgAsg()
+Statement* BasicBlock::FirstNonPhiDefOrCatchArgAsg() const
 {
     Statement* stmt = FirstNonPhiDef();
     if (stmt == nullptr)
@@ -1026,11 +1017,10 @@ Statement* BasicBlock::FirstNonPhiDefOrCatchArgAsg()
  *  Can a BasicBlock be inserted after this without altering the flowgraph
  */
 
-bool BasicBlock::bbFallsThrough()
+bool BasicBlock::bbFallsThrough() const
 {
     switch (bbJumpKind)
     {
-
         case BBJ_THROW:
         case BBJ_EHFINALLYRET:
         case BBJ_EHFILTERRET:
@@ -1063,7 +1053,7 @@ bool BasicBlock::bbFallsThrough()
 // Return Value:
 //    Count of block successors.
 //
-unsigned BasicBlock::NumSucc()
+unsigned BasicBlock::NumSucc() const
 {
     switch (bbJumpKind)
     {
@@ -1107,7 +1097,7 @@ unsigned BasicBlock::NumSucc()
 // Return Value:
 //    Requested successor block
 //
-BasicBlock* BasicBlock::GetSucc(unsigned i)
+BasicBlock* BasicBlock::GetSucc(unsigned i) const
 {
     assert(i < NumSucc()); // Index bounds check.
     switch (bbJumpKind)
@@ -1279,7 +1269,7 @@ void BasicBlock::InitVarSets(Compiler* comp)
 }
 
 // Returns true if the basic block ends with GT_JMP
-bool BasicBlock::endsWithJmpMethod(Compiler* comp)
+bool BasicBlock::endsWithJmpMethod(Compiler* comp) const
 {
     if (comp->compJmpOpUsed && (bbJumpKind == BBJ_RETURN) && (bbFlags & BBF_HAS_JMP))
     {
@@ -1299,7 +1289,7 @@ bool BasicBlock::endsWithJmpMethod(Compiler* comp)
 //    comp              - Compiler instance
 //    fastTailCallsOnly - Only consider fast tail calls excluding tail calls via helper.
 //
-bool BasicBlock::endsWithTailCallOrJmp(Compiler* comp, bool fastTailCallsOnly /*=false*/)
+bool BasicBlock::endsWithTailCallOrJmp(Compiler* comp, bool fastTailCallsOnly /*=false*/) const
 {
     GenTree* tailCall                       = nullptr;
     bool     tailCallsConvertibleToLoopOnly = false;
@@ -1326,7 +1316,7 @@ bool BasicBlock::endsWithTailCallOrJmp(Compiler* comp, bool fastTailCallsOnly /*
 bool BasicBlock::endsWithTailCall(Compiler* comp,
                                   bool      fastTailCallsOnly,
                                   bool      tailCallsConvertibleToLoopOnly,
-                                  GenTree** tailCall)
+                                  GenTree** tailCall) const
 {
     assert(!fastTailCallsOnly || !tailCallsConvertibleToLoopOnly);
     *tailCall   = nullptr;
@@ -1393,7 +1383,7 @@ bool BasicBlock::endsWithTailCall(Compiler* comp,
 // Return Value:
 //    true if the block ends with a tail call convertible to loop.
 //
-bool BasicBlock::endsWithTailCallConvertibleToLoop(Compiler* comp, GenTree** tailCall)
+bool BasicBlock::endsWithTailCallConvertibleToLoop(Compiler* comp, GenTree** tailCall) const
 {
     bool fastTailCallsOnly              = false;
     bool tailCallsConvertibleToLoopOnly = true;
@@ -1522,7 +1512,7 @@ BasicBlock* Compiler::bbNewBasicBlock(BBjumpKinds jumpKind)
 
 //------------------------------------------------------------------------
 // isBBCallAlwaysPair: Determine if this is the first block of a BBJ_CALLFINALLY/BBJ_ALWAYS pair
-
+//
 // Return Value:
 //    True iff "this" is the first block of a BBJ_CALLFINALLY/BBJ_ALWAYS pair
 //    -- a block corresponding to an exit from the try of a try/finally.
@@ -1540,7 +1530,7 @@ BasicBlock* Compiler::bbNewBasicBlock(BBjumpKinds jumpKind)
 //    "retless" BBJ_CALLFINALLY blocks due to a requirement to use the BBJ_ALWAYS for
 //    generating code.
 //
-bool BasicBlock::isBBCallAlwaysPair()
+bool BasicBlock::isBBCallAlwaysPair() const
 {
 #if defined(FEATURE_EH_FUNCLETS) && defined(TARGET_ARM)
     if (this->bbJumpKind == BBJ_CALLFINALLY)
@@ -1576,7 +1566,7 @@ bool BasicBlock::isBBCallAlwaysPair()
 // Notes:
 //    See notes on isBBCallAlwaysPair(), above.
 //
-bool BasicBlock::isBBCallAlwaysPairTail()
+bool BasicBlock::isBBCallAlwaysPairTail() const
 {
     return (bbPrev != nullptr) && bbPrev->isBBCallAlwaysPair();
 }
@@ -1597,7 +1587,7 @@ bool BasicBlock::isBBCallAlwaysPairTail()
 //    this block might be entered via flow that is not represented by an edge
 //    in the flowgraph.
 //
-bool BasicBlock::hasEHBoundaryIn()
+bool BasicBlock::hasEHBoundaryIn() const
 {
     bool returnVal = (bbCatchTyp != BBCT_NONE);
     if (!returnVal)
@@ -1621,7 +1611,7 @@ bool BasicBlock::hasEHBoundaryIn()
 //    live in registers if any successor is a normal flow edge. That's because the
 //    EH write-thru semantics ensure that we always have an up-to-date value on the stack.
 //
-bool BasicBlock::hasEHBoundaryOut()
+bool BasicBlock::hasEHBoundaryOut() const
 {
     bool returnVal = false;
     if (bbJumpKind == BBJ_EHFILTERRET)
diff --git a/src/coreclr/jit/block.h b/src/coreclr/jit/block.h
index 042c376cd2f94d..0cbe51281b3536 100644
--- a/src/coreclr/jit/block.h
+++ b/src/coreclr/jit/block.h
@@ -319,6 +319,162 @@ class AllSuccessorIterPosition
     }
 };
 
+// PredEdgeList: adapter class for forward iteration of the predecessor edge linked list using range-based `for`,
+// normally used via BasicBlock::PredEdges(), e.g.:
+//    for (flowList* const edge : block->PredEdges()) ...
+//
+class PredEdgeList
+{
+    flowList* m_begin;
+
+    // Forward iterator for the predecessor edges linked list.
+    // The caller can't make changes to the preds list when using this.
+    //
+    class iterator
+    {
+        flowList* m_pred;
+
+#ifdef DEBUG
+        // Try to guard against the user of the iterator from making changes to the IR that would invalidate
+        // the iterator: cache the edge we think should be next, then check it when we actually do the `++`
+        // operation. This is a bit conservative, but attempts to protect against callers assuming too much about
+        // this iterator implementation.
+        flowList* m_next;
+#endif
+
+    public:
+        iterator(flowList* pred);
+
+        flowList* operator*() const
+        {
+            return m_pred;
+        }
+
+        iterator& operator++();
+
+        bool operator!=(const iterator& i) const
+        {
+            return m_pred != i.m_pred;
+        }
+    };
+
+public:
+    PredEdgeList(flowList* pred) : m_begin(pred)
+    {
+    }
+
+    iterator begin() const
+    {
+        return iterator(m_begin);
+    }
+
+    iterator end() const
+    {
+        return iterator(nullptr);
+    }
+};
+
+// PredBlockList: adapter class for forward iteration of the predecessor edge linked list yielding
+// predecessor blocks, using range-based `for`, normally used via BasicBlock::PredBlocks(), e.g.:
+//    for (BasicBlock* const predBlock : block->PredBlocks()) ...
+//
+class PredBlockList
+{
+    flowList* m_begin;
+
+    // Forward iterator for the predecessor edges linked list, yielding the predecessor block, not the edge.
+    // The caller can't make changes to the preds list when using this.
+    //
+    class iterator
+    {
+        flowList* m_pred;
+
+#ifdef DEBUG
+        // Try to guard against the user of the iterator from making changes to the IR that would invalidate
+        // the iterator: cache the edge we think should be next, then check it when we actually do the `++`
+        // operation. This is a bit conservative, but attempts to protect against callers assuming too much about
+        // this iterator implementation.
+        flowList* m_next;
+#endif
+
+    public:
+        iterator(flowList* pred);
+
+        BasicBlock* operator*() const;
+
+        iterator& operator++();
+
+        bool operator!=(const iterator& i) const
+        {
+            return m_pred != i.m_pred;
+        }
+    };
+
+public:
+    PredBlockList(flowList* pred) : m_begin(pred)
+    {
+    }
+
+    iterator begin() const
+    {
+        return iterator(m_begin);
+    }
+
+    iterator end() const
+    {
+        return iterator(nullptr);
+    }
+};
+
+// BBArrayIterator: forward iterator for an array of BasicBlock*, such as the BBswtDesc->bbsDstTab.
+// It is an error (with assert) to yield a nullptr BasicBlock* in this array.
+// `m_bbEntry` can be nullptr, but it only makes sense if both the begin and end of an iteration range are nullptr
+// (meaning, no actual iteration will happen).
+//
+class BBArrayIterator
+{
+    BasicBlock* const* m_bbEntry;
+
+public:
+    BBArrayIterator(BasicBlock* const* bbEntry) : m_bbEntry(bbEntry)
+    {
+    }
+
+    BasicBlock* operator*() const
+    {
+        assert(m_bbEntry != nullptr);
+        BasicBlock* bTarget = *m_bbEntry;
+        assert(bTarget != nullptr);
+        return bTarget;
+    }
+
+    BBArrayIterator& operator++()
+    {
+        assert(m_bbEntry != nullptr);
+        ++m_bbEntry;
+        return *this;
+    }
+
+    bool operator!=(const BBArrayIterator& i) const
+    {
+        return m_bbEntry != i.m_bbEntry;
+    }
+};
+
+// BBSwitchTargetList: adapter class for forward iteration of switch targets, using range-based `for`,
+// normally used via BasicBlock::SwitchTargets(), e.g.:
+//    for (BasicBlock* const target : block->SwitchTargets()) ...
+//
+class BBSwitchTargetList
+{
+    BBswtDesc* m_bbsDesc;
+
+public:
+    BBSwitchTargetList(BBswtDesc* bbsDesc);
+    BBArrayIterator begin() const;
+    BBArrayIterator end() const;
+};
+
 //------------------------------------------------------------------------
 // BasicBlockFlags: a bitmask of flags for BasicBlock
 //
@@ -499,12 +655,12 @@ struct BasicBlock : private LIR::Range
     }
 
 #ifdef DEBUG
-    void     dspFlags();                   // Print the flags
-    unsigned dspCheapPreds();              // Print the predecessors (bbCheapPreds)
-    unsigned dspPreds();                   // Print the predecessors (bbPreds)
-    unsigned dspSuccs(Compiler* compiler); // Print the successors. The 'compiler' argument determines whether EH
-                                           // regions are printed: see NumSucc() for details.
-    void dspJumpKind();                    // Print the block jump kind (e.g., BBJ_NONE, BBJ_COND, etc.).
+    void     dspFlags();               // Print the flags
+    unsigned dspCheapPreds();          // Print the predecessors (bbCheapPreds)
+    unsigned dspPreds();               // Print the predecessors (bbPreds)
+    void dspSuccs(Compiler* compiler); // Print the successors. The 'compiler' argument determines whether EH
+                                       // regions are printed: see NumSucc() for details.
+    void dspJumpKind();                // Print the block jump kind (e.g., BBJ_NONE, BBJ_COND, etc.).
 
     // Print a simple basic block header for various output, including a list of predecessors and successors.
     void dspBlockHeader(Compiler* compiler, bool showKind = true, bool showFlags = false, bool showPreds = true);
@@ -641,16 +797,17 @@ struct BasicBlock : private LIR::Range
 
     // Returns "true" if the block is empty. Empty here means there are no statement
     // trees *except* PHI definitions.
-    bool isEmpty();
+    bool isEmpty() const;
 
-    bool isValid();
+    bool isValid() const;
 
     // Returns "true" iff "this" is the first block of a BBJ_CALLFINALLY/BBJ_ALWAYS pair --
     // a block corresponding to an exit from the try of a try/finally.
-    bool isBBCallAlwaysPair();
+    bool isBBCallAlwaysPair() const;
+
     // Returns "true" iff "this" is the last block of a BBJ_CALLFINALLY/BBJ_ALWAYS pair --
     // a block corresponding to an exit from the try of a try/finally.
-    bool isBBCallAlwaysPairTail();
+    bool isBBCallAlwaysPairTail() const;
 
     BBjumpKinds bbJumpKind; // jump (if any) at the end of this block
 
@@ -689,18 +846,27 @@ struct BasicBlock : private LIR::Range
     // Note that for BBJ_COND, which has two successors (fall through and condition true branch target),
     // only the unique targets are returned. Thus, if both targets are the same, NumSucc() will only return 1
     // instead of 2.
-
+    //
     // NumSucc: Returns the number of successors of "this".
-    unsigned NumSucc();
+    unsigned NumSucc() const;
     unsigned NumSucc(Compiler* comp);
 
     // GetSucc: Returns the "i"th successor. Requires (0 <= i < NumSucc()).
-    BasicBlock* GetSucc(unsigned i);
+    BasicBlock* GetSucc(unsigned i) const;
     BasicBlock* GetSucc(unsigned i, Compiler* comp);
 
-    BasicBlock* GetUniquePred(Compiler* comp);
+    // SwitchTargets: convenience methods for enabling range-based `for` iteration over a switch block's targets, e.g.:
+    //    for (BasicBlock* const bTarget : block->SwitchTargets()) ...
+    //
+    BBSwitchTargetList SwitchTargets() const
+    {
+        assert(bbJumpKind == BBJ_SWITCH);
+        return BBSwitchTargetList(bbJumpSwt);
+    }
+
+    BasicBlock* GetUniquePred(Compiler* comp) const;
 
-    BasicBlock* GetUniqueSucc();
+    BasicBlock* GetUniqueSucc() const;
 
     unsigned countOfInEdges() const
     {
@@ -837,8 +1003,8 @@ struct BasicBlock : private LIR::Range
         return sameTryRegion(blk1, blk2) && sameHndRegion(blk1, blk2);
     }
 
-    bool hasEHBoundaryIn();
-    bool hasEHBoundaryOut();
+    bool hasEHBoundaryIn() const;
+    bool hasEHBoundaryOut() const;
 
 // Some non-zero value that will not collide with real tokens for bbCatchTyp
 #define BBCT_NONE 0x00000000
@@ -875,6 +1041,22 @@ struct BasicBlock : private LIR::Range
         flowList*       bbPreds;      // ptr to list of predecessors
     };
 
+    // PredEdges: convenience method for enabling range-based `for` iteration over predecessor edges, e.g.:
+    //    for (flowList* const edge : block->PredEdges()) ...
+    //
+    PredEdgeList PredEdges() const
+    {
+        return PredEdgeList(bbPreds);
+    }
+
+    // PredBlocks: convenience method for enabling range-based `for` iteration over predecessor blocks, e.g.:
+    //    for (BasicBlock* const predBlock : block->PredBlocks()) ...
+    //
+    PredBlockList PredBlocks() const
+    {
+        return PredBlockList(bbPreds);
+    }
+
     // Pred list maintenance
     //
     bool checkPredListOrder();
@@ -997,7 +1179,7 @@ struct BasicBlock : private LIR::Range
     static size_t s_Count;
 #endif // MEASURE_BLOCK_SIZE
 
-    bool bbFallsThrough();
+    bool bbFallsThrough() const;
 
     // Our slop fraction is 1/128 of the block weight rounded off
     static weight_t GetSlopFraction(weight_t weightBlk)
@@ -1025,14 +1207,14 @@ struct BasicBlock : private LIR::Range
     unsigned bbID;
 #endif // DEBUG
 
-    ThisInitState bbThisOnEntry();
-    unsigned      bbStackDepthOnEntry();
+    ThisInitState bbThisOnEntry() const;
+    unsigned      bbStackDepthOnEntry() const;
     void bbSetStack(void* stackBuffer);
-    StackEntry* bbStackOnEntry();
+    StackEntry* bbStackOnEntry() const;
 
     // "bbNum" is one-based (for unknown reasons); it is sometimes useful to have the corresponding
     // zero-based number for use as an array index.
-    unsigned bbInd()
+    unsigned bbInd() const
     {
         assert(bbNum > 0);
         return bbNum - 1;
@@ -1041,29 +1223,41 @@ struct BasicBlock : private LIR::Range
     Statement* firstStmt() const;
     Statement* lastStmt() const;
 
+    // Statements: convenience method for enabling range-based `for` iteration over the statement list, e.g.:
+    //    for (Statement* const stmt : block->Statements())
+    //
     StatementList Statements() const
     {
         return StatementList(firstStmt());
     }
 
-    GenTree* firstNode();
-    GenTree* lastNode();
+    // NonPhiStatements: convenience method for enabling range-based `for` iteration over the statement list,
+    // excluding any initial PHI statements, e.g.:
+    //    for (Statement* const stmt : block->NonPhiStatements())
+    //
+    StatementList NonPhiStatements() const
+    {
+        return StatementList(FirstNonPhiDef());
+    }
+
+    GenTree* firstNode() const;
+    GenTree* lastNode() const;
 
-    bool endsWithJmpMethod(Compiler* comp);
+    bool endsWithJmpMethod(Compiler* comp) const;
 
     bool endsWithTailCall(Compiler* comp,
                           bool      fastTailCallsOnly,
                           bool      tailCallsConvertibleToLoopOnly,
-                          GenTree** tailCall);
+                          GenTree** tailCall) const;
 
-    bool endsWithTailCallOrJmp(Compiler* comp, bool fastTailCallsOnly = false);
+    bool endsWithTailCallOrJmp(Compiler* comp, bool fastTailCallsOnly = false) const;
 
-    bool endsWithTailCallConvertibleToLoop(Compiler* comp, GenTree** tailCall);
+    bool endsWithTailCallConvertibleToLoop(Compiler* comp, GenTree** tailCall) const;
 
     // Returns the first statement in the statement list of "this" that is
     // not an SSA definition (a lcl = phi(...) assignment).
-    Statement* FirstNonPhiDef();
-    Statement* FirstNonPhiDefOrCatchArgAsg();
+    Statement* FirstNonPhiDef() const;
+    Statement* FirstNonPhiDefOrCatchArgAsg() const;
 
     BasicBlock() : bbStmtList(nullptr), bbLiveIn(VarSetOps::UninitVal()), bbLiveOut(VarSetOps::UninitVal())
     {
@@ -1138,6 +1332,103 @@ struct BasicBlock : private LIR::Range
         return Successors<AllSuccessorIterPosition>(comp, this);
     }
 
+    // BBSuccList: adapter class for forward iteration of block successors, using range-based `for`,
+    // normally used via BasicBlock::Succs(), e.g.:
+    //    for (BasicBlock* const target : block->Succs()) ...
+    //
+    class BBSuccList
+    {
+        // For one or two successors, pre-compute and stash the successors inline, in m_succs[], so we don't
+        // need to call a function or execute another `switch` to get them. Also, pre-compute the begin and end
+        // points of the iteration, for use by BBArrayIterator. `m_begin` and `m_end` will either point at
+        // `m_succs` or at the switch table successor array.
+        BasicBlock*        m_succs[2];
+        BasicBlock* const* m_begin;
+        BasicBlock* const* m_end;
+
+    public:
+        BBSuccList(const BasicBlock* block);
+        BBArrayIterator begin() const;
+        BBArrayIterator end() const;
+    };
+
+    // BBCompilerSuccList: adapter class for forward iteration of block successors, using range-based `for`,
+    // normally used via BasicBlock::Succs(), e.g.:
+    //    for (BasicBlock* const target : block->Succs(compiler)) ...
+    //
+    // This version uses NumSucc(Compiler*)/GetSucc(Compiler*). See the documentation there for the explanation
+    // of the implications of this versus the version that does not take `Compiler*`.
+    class BBCompilerSuccList
+    {
+        Compiler*   m_comp;
+        BasicBlock* m_block;
+
+        // iterator: forward iterator for an array of BasicBlock*, such as the BBswtDesc->bbsDstTab.
+        //
+        class iterator
+        {
+            Compiler*   m_comp;
+            BasicBlock* m_block;
+            unsigned    m_succNum;
+
+        public:
+            iterator(Compiler* comp, BasicBlock* block, unsigned succNum)
+                : m_comp(comp), m_block(block), m_succNum(succNum)
+            {
+            }
+
+            BasicBlock* operator*() const
+            {
+                assert(m_block != nullptr);
+                BasicBlock* bTarget = m_block->GetSucc(m_succNum, m_comp);
+                assert(bTarget != nullptr);
+                return bTarget;
+            }
+
+            iterator& operator++()
+            {
+                ++m_succNum;
+                return *this;
+            }
+
+            bool operator!=(const iterator& i) const
+            {
+                return m_succNum != i.m_succNum;
+            }
+        };
+
+    public:
+        BBCompilerSuccList(Compiler* comp, BasicBlock* block) : m_comp(comp), m_block(block)
+        {
+        }
+
+        iterator begin() const
+        {
+            return iterator(m_comp, m_block, 0);
+        }
+
+        iterator end() const
+        {
+            return iterator(m_comp, m_block, m_block->NumSucc(m_comp));
+        }
+    };
+
+    // Succs: convenience methods for enabling range-based `for` iteration over a block's successors, e.g.:
+    //    for (BasicBlock* const succ : block->Succs()) ...
+    //
+    // There are two options: one that takes a Compiler* and one that doesn't. These correspond to the
+    // NumSucc()/GetSucc() functions that do or do not take a Compiler*. See the comment for NumSucc()/GetSucc()
+    // for the distinction.
+    BBSuccList Succs() const
+    {
+        return BBSuccList(this);
+    }
+
+    BBCompilerSuccList Succs(Compiler* comp)
+    {
+        return BBCompilerSuccList(comp, this);
+    }
+
     // Try to clone block state and statements from `from` block to `to` block (which must be new/empty),
     // optionally replacing uses of local `varNum` with IntCns `varVal`.  Return true if all statements
     // in the block are cloned successfully, false (with partially-populated `to` block) if one fails.
@@ -1145,20 +1436,20 @@ struct BasicBlock : private LIR::Range
         Compiler* compiler, BasicBlock* to, const BasicBlock* from, unsigned varNum = (unsigned)-1, int varVal = 0);
 
     void MakeLIR(GenTree* firstNode, GenTree* lastNode);
-    bool IsLIR();
+    bool IsLIR() const;
 
     void SetDominatedByExceptionalEntryFlag()
     {
         bbFlags |= BBF_DOMINATED_BY_EXCEPTIONAL_ENTRY;
     }
 
-    bool IsDominatedByExceptionalEntryFlag()
+    bool IsDominatedByExceptionalEntryFlag() const
     {
         return (bbFlags & BBF_DOMINATED_BY_EXCEPTIONAL_ENTRY) != 0;
     }
 
 #ifdef DEBUG
-    bool Contains(const GenTree* node)
+    bool Contains(const GenTree* node) const
     {
         assert(IsLIR());
         for (Iterator iter = begin(); iter != end(); ++iter)
@@ -1196,6 +1487,96 @@ typedef JitHashTable<BasicBlock*, JitPtrKeyFuncs<BasicBlock>, BlkVector> BlkToBl
 // Map from Block to Block.  Used for a variety of purposes.
 typedef JitHashTable<BasicBlock*, JitPtrKeyFuncs<BasicBlock>, BasicBlock*> BlockToBlockMap;
 
+// BasicBlockIterator: forward iterator for the BasicBlock linked list.
+// It is allowed to make changes to the BasicBlock list as long as the current block remains in the list.
+// E.g., the current block `m_bbNext` pointer can be altered (such as when inserting a following block),
+// as long as the current block is still in the list.
+// The block list is expected to be properly doubly-linked.
+//
+class BasicBlockIterator
+{
+    BasicBlock* m_block;
+
+public:
+    BasicBlockIterator(BasicBlock* block) : m_block(block)
+    {
+    }
+
+    BasicBlock* operator*() const
+    {
+        return m_block;
+    }
+
+    BasicBlockIterator& operator++()
+    {
+        assert(m_block != nullptr);
+        // Check that we haven't been spliced out of the list.
+        assert((m_block->bbNext == nullptr) || (m_block->bbNext->bbPrev == m_block));
+        assert((m_block->bbPrev == nullptr) || (m_block->bbPrev->bbNext == m_block));
+
+        m_block = m_block->bbNext;
+        return *this;
+    }
+
+    bool operator!=(const BasicBlockIterator& i) const
+    {
+        return m_block != i.m_block;
+    }
+};
+
+// BasicBlockSimpleList: adapter class for forward iteration of a lexically contiguous range of
+// BasicBlock, starting at `begin` and going to the end of the function, using range-based `for`,
+// normally used via Compiler::Blocks(), e.g.:
+//    for (BasicBlock* const block : Blocks()) ...
+//
+class BasicBlockSimpleList
+{
+    BasicBlock* m_begin;
+
+public:
+    BasicBlockSimpleList(BasicBlock* begin) : m_begin(begin)
+    {
+    }
+
+    BasicBlockIterator begin() const
+    {
+        return BasicBlockIterator(m_begin);
+    }
+
+    BasicBlockIterator end() const
+    {
+        return BasicBlockIterator(nullptr);
+    }
+};
+
+// BasicBlockRangeList: adapter class for forward iteration of a lexically contiguous range of
+// BasicBlock specified with both `begin` and `end` blocks. `begin` and `end` are *inclusive*
+// and must be non-null. E.g.,
+//    for (BasicBlock* const block : BasicBlockRangeList(startBlock, endBlock)) ...
+//
+class BasicBlockRangeList
+{
+    BasicBlock* m_begin;
+    BasicBlock* m_end;
+
+public:
+    BasicBlockRangeList(BasicBlock* begin, BasicBlock* end) : m_begin(begin), m_end(end)
+    {
+        assert(begin != nullptr);
+        assert(end != nullptr);
+    }
+
+    BasicBlockIterator begin() const
+    {
+        return BasicBlockIterator(m_begin);
+    }
+
+    BasicBlockIterator end() const
+    {
+        return BasicBlockIterator(m_end->bbNext); // walk until we see the block *following* the `m_end` block
+    }
+};
+
 // BBswtDesc -- descriptor for a switch block
 //
 //  Things to know:
@@ -1241,6 +1622,98 @@ struct BBswtDesc
     }
 };
 
+// BBSwitchTargetList out-of-class-declaration implementations (here due to C++ ordering requirements).
+//
+
+inline BBSwitchTargetList::BBSwitchTargetList(BBswtDesc* bbsDesc) : m_bbsDesc(bbsDesc)
+{
+    assert(m_bbsDesc != nullptr);
+    assert(m_bbsDesc->bbsDstTab != nullptr);
+}
+
+inline BBArrayIterator BBSwitchTargetList::begin() const
+{
+    return BBArrayIterator(m_bbsDesc->bbsDstTab);
+}
+
+inline BBArrayIterator BBSwitchTargetList::end() const
+{
+    return BBArrayIterator(m_bbsDesc->bbsDstTab + m_bbsDesc->bbsCount);
+}
+
+// BBSuccList out-of-class-declaration implementations
+//
+inline BasicBlock::BBSuccList::BBSuccList(const BasicBlock* block)
+{
+    assert(block != nullptr);
+    switch (block->bbJumpKind)
+    {
+        case BBJ_THROW:
+        case BBJ_RETURN:
+        case BBJ_EHFINALLYRET:
+        case BBJ_EHFILTERRET:
+            // We don't need m_succs.
+            m_begin = nullptr;
+            m_end   = nullptr;
+            break;
+
+        case BBJ_CALLFINALLY:
+        case BBJ_ALWAYS:
+        case BBJ_EHCATCHRET:
+        case BBJ_LEAVE:
+            m_succs[0] = block->bbJumpDest;
+            m_begin    = &m_succs[0];
+            m_end      = &m_succs[1];
+            break;
+
+        case BBJ_NONE:
+            m_succs[0] = block->bbNext;
+            m_begin    = &m_succs[0];
+            m_end      = &m_succs[1];
+            break;
+
+        case BBJ_COND:
+            m_succs[0] = block->bbNext;
+            m_begin    = &m_succs[0];
+
+            // If both fall-through and branch successors are identical, then only include
+            // them once in the iteration (this is the same behavior as NumSucc()/GetSucc()).
+            if (block->bbJumpDest == block->bbNext)
+            {
+                m_end = &m_succs[1];
+            }
+            else
+            {
+                m_succs[1] = block->bbJumpDest;
+                m_end      = &m_succs[2];
+            }
+            break;
+
+        case BBJ_SWITCH:
+            // We don't use the m_succs in-line data for switches; use the existing jump table in the block.
+            assert(block->bbJumpSwt != nullptr);
+            assert(block->bbJumpSwt->bbsDstTab != nullptr);
+            m_begin = block->bbJumpSwt->bbsDstTab;
+            m_end   = block->bbJumpSwt->bbsDstTab + block->bbJumpSwt->bbsCount;
+            break;
+
+        default:
+            unreached();
+    }
+
+    assert(m_end >= m_begin);
+}
+
+inline BBArrayIterator BasicBlock::BBSuccList::begin() const
+{
+    return BBArrayIterator(m_begin);
+}
+
+inline BBArrayIterator BasicBlock::BBSuccList::end() const
+{
+    return BBArrayIterator(m_end);
+}
+
 // In compiler terminology the control flow between two BasicBlocks
 // is typically referred to as an "edge".  Most well known are the
 // backward branches for loops, which are often called "back-edges".
@@ -1354,6 +1827,55 @@ struct flowList
     }
 };
 
+// Pred list iterator implementations (that are required to be defined after the declaration of BasicBlock and flowList)
+
+inline PredEdgeList::iterator::iterator(flowList* pred) : m_pred(pred)
+{
+#ifdef DEBUG
+    m_next = (m_pred == nullptr) ? nullptr : m_pred->flNext;
+#endif
+}
+
+inline PredEdgeList::iterator& PredEdgeList::iterator::operator++()
+{
+    flowList* next = m_pred->flNext;
+
+#ifdef DEBUG
+    // Check that the next block is the one we expect to see.
+    assert(next == m_next);
+    m_next = (next == nullptr) ? nullptr : next->flNext;
+#endif // DEBUG
+
+    m_pred = next;
+    return *this;
+}
+
+inline PredBlockList::iterator::iterator(flowList* pred) : m_pred(pred)
+{
+#ifdef DEBUG
+    m_next = (m_pred == nullptr) ? nullptr : m_pred->flNext;
+#endif
+}
+
+inline BasicBlock* PredBlockList::iterator::operator*() const
+{
+    return m_pred->getBlock();
+}
+
+inline PredBlockList::iterator& PredBlockList::iterator::operator++()
+{
+    flowList* next = m_pred->flNext;
+
+#ifdef DEBUG
+    // Check that the next block is the one we expect to see.
+    assert(next == m_next);
+    m_next = (next == nullptr) ? nullptr : next->flNext;
+#endif // DEBUG
+
+    m_pred = next;
+    return *this;
+}
+
 // This enum represents a pre/post-visit action state to emulate a depth-first
 // spanning tree traversal of a tree or graph.
 enum DfsStackState
diff --git a/src/coreclr/jit/clrjit.natvis b/src/coreclr/jit/clrjit.natvis
index a6ba8f53b19165..90a9ff703a4716 100644
--- a/src/coreclr/jit/clrjit.natvis
+++ b/src/coreclr/jit/clrjit.natvis
@@ -24,7 +24,7 @@ The .NET Foundation licenses this file to you under the MIT license.
 
   <!-- GenTree -->
   <Type Name="GenTree">
-    <DisplayString>[{gtOper,en}, {gtType,en}}]</DisplayString>
+    <DisplayString>[{gtOper,en}, {gtType,en}]</DisplayString>
   </Type>
   <Type Name="GenTreeIntCon">
     <DisplayString>[IntCon={((GenTreeIntCon*)this)-&gt;gtIconVal, d}]</DisplayString>
@@ -55,6 +55,10 @@ The .NET Foundation licenses this file to you under the MIT license.
     <DisplayString>[{gtOper,en}, {gtType,en} V{((GenTreeLclVar*)this)-&gt;_gtLclNum,u}]</DisplayString>
   </Type>
 
+  <Type Name="GenTreeLclFld" Inheritable="false">
+    <DisplayString>[{gtOper,en}, {gtType,en} V{((GenTreeLclFld*)this)-&gt;_gtLclNum,u}[+{((GenTreeLclFld*)this)-&gt;m_lclOffs,u}]]</DisplayString>
+  </Type>
+
   <!-- Register allocation -->
   <Type Name="LinearScan">
     <DisplayString>LinearScan</DisplayString>
@@ -157,6 +161,14 @@ The .NET Foundation licenses this file to you under the MIT license.
     <DisplayString>IG{igNum,d}</DisplayString>
   </Type>
 
+  <Type Name="emitter::instrDesc">
+    <DisplayString Condition="(_idInsFmt == IF_RRD) || (_idInsFmt == IF_RWR) || (_idInsFmt == IF_RRW)">{_idIns,en} {_idReg1,en}</DisplayString>
+    <DisplayString Condition="(_idInsFmt == IF_RRD_CNS) || (_idInsFmt == IF_RWR_CNS) || (_idInsFmt == IF_RRW_CNS)">{_idIns,en} {_idReg1,en}, {_idLargeCns,d}</DisplayString>
+    <DisplayString Condition="(_idInsFmt == IF_RRW_SHF) &amp;&amp; (_idLargeCns != 0)">{_idIns,en} {_idReg1,en}, {_idLargeCns,d}</DisplayString>
+    <DisplayString Condition="(_idInsFmt == IF_RRW_SHF) &amp;&amp; (_idLargeCns == 0)">{_idIns,en} {_idReg1,en}, {_idSmallCns,d}</DisplayString>
+    <DisplayString>{_idIns,en}</DisplayString>
+  </Type>
+
   <!-- utils -->
    <Type Name="jitstd::list&lt;*&gt;">
     <DisplayString Condition="m_nSize > 0">Size={m_nSize}</DisplayString>
diff --git a/src/coreclr/jit/codegenarm.cpp b/src/coreclr/jit/codegenarm.cpp
index cc572c663c242c..5993f7015ec2bd 100644
--- a/src/coreclr/jit/codegenarm.cpp
+++ b/src/coreclr/jit/codegenarm.cpp
@@ -460,7 +460,7 @@ void CodeGen::genLclHeap(GenTree* tree)
         }
 
         // regCnt will be the total number of bytes to locAlloc
-        genSetRegToIcon(regCnt, amount, ((int)amount == amount) ? TYP_INT : TYP_LONG);
+        genSetRegToIcon(regCnt, amount, TYP_INT);
     }
     else
     {
diff --git a/src/coreclr/jit/codegencommon.cpp b/src/coreclr/jit/codegencommon.cpp
index f6eaa8b044ccc9..e99f047c061a55 100644
--- a/src/coreclr/jit/codegencommon.cpp
+++ b/src/coreclr/jit/codegencommon.cpp
@@ -352,7 +352,7 @@ void CodeGen::genMarkLabelsForCodegen()
 
 #ifdef DEBUG
     // No label flags should be set before this.
-    for (BasicBlock* block = compiler->fgFirstBB; block != nullptr; block = block->bbNext)
+    for (BasicBlock* const block : compiler->Blocks())
     {
         assert((block->bbFlags & BBF_HAS_LABEL) == 0);
     }
@@ -372,7 +372,7 @@ void CodeGen::genMarkLabelsForCodegen()
         compiler->fgFirstBB->bbFlags |= BBF_HAS_LABEL;
     }
 
-    for (BasicBlock* block = compiler->fgFirstBB; block != nullptr; block = block->bbNext)
+    for (BasicBlock* const block : compiler->Blocks())
     {
         switch (block->bbJumpKind)
         {
@@ -384,15 +384,11 @@ void CodeGen::genMarkLabelsForCodegen()
                 break;
 
             case BBJ_SWITCH:
-                unsigned jumpCnt;
-                jumpCnt = block->bbJumpSwt->bbsCount;
-                BasicBlock** jumpTab;
-                jumpTab = block->bbJumpSwt->bbsDstTab;
-                do
+                for (BasicBlock* const bTarget : block->SwitchTargets())
                 {
-                    JITDUMP("  " FMT_BB " : branch target\n", (*jumpTab)->bbNum);
-                    (*jumpTab)->bbFlags |= BBF_HAS_LABEL;
-                } while (++jumpTab, --jumpCnt);
+                    JITDUMP("  " FMT_BB " : branch target\n", bTarget->bbNum);
+                    bTarget->bbFlags |= BBF_HAS_LABEL;
+                }
                 break;
 
             case BBJ_CALLFINALLY:
@@ -439,11 +435,7 @@ void CodeGen::genMarkLabelsForCodegen()
         add->acdDstBlk->bbFlags |= BBF_HAS_LABEL;
     }
 
-    EHblkDsc* HBtab;
-    EHblkDsc* HBtabEnd;
-
-    for (HBtab = compiler->compHndBBtab, HBtabEnd = compiler->compHndBBtab + compiler->compHndBBtabCount;
-         HBtab < HBtabEnd; HBtab++)
+    for (EHblkDsc* const HBtab : EHClauses(compiler))
     {
         HBtab->ebdTryBeg->bbFlags |= BBF_HAS_LABEL;
         HBtab->ebdHndBeg->bbFlags |= BBF_HAS_LABEL;
@@ -2411,11 +2403,19 @@ void CodeGen::genEmitMachineCode()
     if (compiler->opts.disAsm || verbose)
     {
         printf("\n; Total bytes of code %d, prolog size %d, PerfScore %.2f, instruction count %d, allocated bytes for "
-               "code %d (MethodHash=%08x) for "
-               "method %s\n",
+               "code %d",
                codeSize, prologSize, compiler->info.compPerfScore, instrCount,
-               GetEmitter()->emitTotalHotCodeSize + GetEmitter()->emitTotalColdCodeSize,
-               compiler->info.compMethodHash(), compiler->info.compFullName);
+               GetEmitter()->emitTotalHotCodeSize + GetEmitter()->emitTotalColdCodeSize);
+
+#if TRACK_LSRA_STATS
+        if (JitConfig.DisplayLsraStats() == 3)
+        {
+            compiler->m_pLinearScan->dumpLsraStatsSummary(jitstdout);
+        }
+#endif // TRACK_LSRA_STATS
+
+        printf(" (MethodHash=%08x) for method %s\n", compiler->info.compMethodHash(), compiler->info.compFullName);
+
         printf("; ============================================================\n\n");
         printf(""); // in our logic this causes a flush
     }
@@ -2623,9 +2623,7 @@ void CodeGen::genReportEH()
     }
 #endif // DEBUG
 
-    unsigned  XTnum;
-    EHblkDsc* HBtab;
-    EHblkDsc* HBtabEnd;
+    unsigned XTnum;
 
     bool isCoreRTABI = compiler->IsTargetAbi(CORINFO_CORERT_ABI);
 
@@ -2664,8 +2662,7 @@ void CodeGen::genReportEH()
         // clauses. If there aren't, we don't need to look for BBJ_CALLFINALLY.
 
         bool anyFinallys = false;
-        for (HBtab = compiler->compHndBBtab, HBtabEnd = compiler->compHndBBtab + compiler->compHndBBtabCount;
-             HBtab < HBtabEnd; HBtab++)
+        for (EHblkDsc* const HBtab : EHClauses(compiler))
         {
             if (HBtab->HasFinallyHandler())
             {
@@ -2675,7 +2672,7 @@ void CodeGen::genReportEH()
         }
         if (anyFinallys)
         {
-            for (BasicBlock* block = compiler->fgFirstBB; block != nullptr; block = block->bbNext)
+            for (BasicBlock* const block : compiler->Blocks())
             {
                 if (block->bbJumpKind == BBJ_CALLFINALLY)
                 {
@@ -2715,8 +2712,7 @@ void CodeGen::genReportEH()
 
     XTnum = 0; // This is the index we pass to the VM
 
-    for (HBtab = compiler->compHndBBtab, HBtabEnd = compiler->compHndBBtab + compiler->compHndBBtabCount;
-         HBtab < HBtabEnd; HBtab++)
+    for (EHblkDsc* const HBtab : EHClauses(compiler))
     {
         UNATIVE_OFFSET tryBeg, tryEnd, hndBeg, hndEnd, hndTyp;
 
@@ -2908,8 +2904,9 @@ void CodeGen::genReportEH()
 
     if (duplicateClauseCount > 0)
     {
-        unsigned reportedDuplicateClauseCount = 0; // How many duplicated clauses have we reported?
-        unsigned XTnum2;
+        unsigned  reportedDuplicateClauseCount = 0; // How many duplicated clauses have we reported?
+        unsigned  XTnum2;
+        EHblkDsc* HBtab;
         for (XTnum2 = 0, HBtab = compiler->compHndBBtab; XTnum2 < compiler->compHndBBtabCount; XTnum2++, HBtab++)
         {
             unsigned enclosingTryIndex;
@@ -3001,7 +2998,7 @@ void CodeGen::genReportEH()
     if (clonedFinallyCount > 0)
     {
         unsigned reportedClonedFinallyCount = 0;
-        for (BasicBlock* block = compiler->fgFirstBB; block != nullptr; block = block->bbNext)
+        for (BasicBlock* const block : compiler->Blocks())
         {
             if (block->bbJumpKind == BBJ_CALLFINALLY)
             {
@@ -7457,7 +7454,7 @@ void CodeGen::genFnProlog()
     // Establish the AMD64 frame pointer after the OS-reported prolog.
     if (doubleAlignOrFramePointerUsed())
     {
-        bool reportUnwindData = compiler->compLocallocUsed || compiler->opts.compDbgEnC;
+        const bool reportUnwindData = compiler->compLocallocUsed || compiler->opts.compDbgEnC;
         genEstablishFramePointer(compiler->codeGen->genSPtoFPdelta(), reportUnwindData);
     }
 #endif // TARGET_AMD64
@@ -8150,7 +8147,31 @@ void CodeGen::genFnEpilog(BasicBlock* block)
 
     /* Compute the size in bytes we've pushed/popped */
 
-    if (!doubleAlignOrFramePointerUsed())
+    bool removeEbpFrame = doubleAlignOrFramePointerUsed();
+
+#ifdef TARGET_AMD64
+    // We only remove the EBP frame using the frame pointer (using `lea rsp, [rbp + const]`)
+    // if we reported the frame pointer in the prolog. The Windows x64 unwinding ABI specifically
+    // disallows this `lea` form:
+    //
+    //    See https://docs.microsoft.com/en-us/cpp/build/prolog-and-epilog?view=msvc-160#epilog-code
+    //
+    //    "When a frame pointer is not used, the epilog must use add RSP,constant to deallocate the fixed part of the
+    //    stack. It may not use lea RSP,constant[RSP] instead. This restriction exists so the unwind code has fewer
+    //    patterns to recognize when searching for epilogs."
+    //
+    // Otherwise, we must use `add RSP, constant`, as stated. So, we need to use the same condition
+    // as genFnProlog() used in determining whether to report the frame pointer in the unwind data.
+    // This is a subset of the `doubleAlignOrFramePointerUsed()` cases.
+    //
+    if (removeEbpFrame)
+    {
+        const bool reportUnwindData = compiler->compLocallocUsed || compiler->opts.compDbgEnC;
+        removeEbpFrame              = removeEbpFrame && reportUnwindData;
+    }
+#endif // TARGET_AMD64
+
+    if (!removeEbpFrame)
     {
         // We have an ESP frame */
 
@@ -8180,6 +8201,15 @@ void CodeGen::genFnEpilog(BasicBlock* block)
 
         genPopCalleeSavedRegisters();
 
+#ifdef TARGET_AMD64
+        // In the case where we have an RSP frame, and no frame pointer reported in the OS unwind info,
+        // but we do have a pushed frame pointer and established frame chain, we do need to pop RBP.
+        if (doubleAlignOrFramePointerUsed())
+        {
+            inst_RV(INS_pop, REG_EBP, TYP_I_IMPL);
+        }
+#endif // TARGET_AMD64
+
         // Extra OSR adjust to get to where RBP was saved by the original frame, and
         // restore RBP.
         //
@@ -10843,7 +10873,7 @@ void CodeGen::genIPmappingGen()
         //
         //It turns out that the only thing we really have to assert is that the first statement in each basic
         //block has an IL offset and appears in eeBoundaries.
-        for (BasicBlock * block = compiler->fgFirstBB; block != nullptr; block = block->bbNext)
+        for (BasicBlock* const block : compiler->Blocks())
         {
             Statement* stmt = block->firstStmt();
             if ((block->bbRefs > 1) && (stmt != nullptr))
@@ -11703,7 +11733,8 @@ void CodeGenInterface::VariableLiveKeeper::VariableLiveRange::dumpVariableLiveRa
     const CodeGenInterface* codeGen) const
 {
     codeGen->dumpSiVarLoc(&m_VarLocation);
-    printf(" [ ");
+
+    printf(" [");
     m_StartEmitLocation.Print(codeGen->GetCompiler()->compMethodID);
     printf(", ");
     if (m_EndEmitLocation.Valid())
@@ -11712,9 +11743,9 @@ void CodeGenInterface::VariableLiveKeeper::VariableLiveRange::dumpVariableLiveRa
     }
     else
     {
-        printf("NON_CLOSED_RANGE");
+        printf("...");
     }
-    printf(" ]; ");
+    printf("]");
 }
 
 // Dump "VariableLiveRange" when code has been generated and we have the assembly native offset of each "emitLocation"
@@ -11730,7 +11761,7 @@ void CodeGenInterface::VariableLiveKeeper::VariableLiveRange::dumpVariableLiveRa
     // If this is an open "VariableLiveRange", "m_EndEmitLocation" is non-valid and print -1
     UNATIVE_OFFSET endAssemblyOffset = m_EndEmitLocation.Valid() ? m_EndEmitLocation.CodeOffset(emit) : -1;
 
-    printf(" [%X , %X )", m_StartEmitLocation.CodeOffset(emit), m_EndEmitLocation.CodeOffset(emit));
+    printf(" [%X, %X)", m_StartEmitLocation.CodeOffset(emit), m_EndEmitLocation.CodeOffset(emit));
 }
 
 //------------------------------------------------------------------------
@@ -11974,25 +12005,31 @@ void CodeGenInterface::VariableLiveKeeper::VariableLiveDescriptor::updateLiveRan
 void CodeGenInterface::VariableLiveKeeper::VariableLiveDescriptor::dumpAllRegisterLiveRangesForBlock(
     emitter* emit, const CodeGenInterface* codeGen) const
 {
-    printf("[");
+    bool first = true;
     for (LiveRangeListIterator it = m_VariableLiveRanges->begin(); it != m_VariableLiveRanges->end(); it++)
     {
+        if (!first)
+        {
+            printf("; ");
+        }
         it->dumpVariableLiveRange(emit, codeGen);
+        first = false;
     }
-    printf("]\n");
 }
 
 void CodeGenInterface::VariableLiveKeeper::VariableLiveDescriptor::dumpRegisterLiveRangesForBlockBeforeCodeGenerated(
     const CodeGenInterface* codeGen) const
 {
-    noway_assert(codeGen != nullptr);
-
-    printf("[");
+    bool first = true;
     for (LiveRangeListIterator it = m_VariableLifeBarrier->getStartForDump(); it != m_VariableLiveRanges->end(); it++)
     {
+        if (!first)
+        {
+            printf("; ");
+        }
         it->dumpVariableLiveRange(codeGen);
+        first = false;
     }
-    printf("]\n");
 }
 
 // Returns true if a live range for this variable has been recorded
@@ -12431,41 +12468,33 @@ void CodeGenInterface::VariableLiveKeeper::psiClosePrologVariableRanges()
 #ifdef DEBUG
 void CodeGenInterface::VariableLiveKeeper::dumpBlockVariableLiveRanges(const BasicBlock* block)
 {
-    // "block" will be dereferenced
-    noway_assert(block != nullptr);
+    assert(block != nullptr);
 
     bool hasDumpedHistory = false;
 
-    if (m_Compiler->verbose)
-    {
-        printf("////////////////////////////////////////\n");
-        printf("////////////////////////////////////////\n");
-        printf("Variable Live Range History Dump for Block %d \n", block->bbNum);
+    printf("\nVariable Live Range History Dump for " FMT_BB "\n", block->bbNum);
 
-        if (m_Compiler->opts.compDbgInfo)
+    if (m_Compiler->opts.compDbgInfo)
+    {
+        for (unsigned int varNum = 0; varNum < m_LiveDscCount; varNum++)
         {
-            for (unsigned int varNum = 0; varNum < m_LiveDscCount; varNum++)
-            {
-                VariableLiveDescriptor* varLiveDsc = m_vlrLiveDsc + varNum;
+            VariableLiveDescriptor* varLiveDsc = m_vlrLiveDsc + varNum;
 
-                if (varLiveDsc->hasVarLiveRangesFromLastBlockToDump())
-                {
-                    hasDumpedHistory = true;
-                    printf("IL Var Num %d:\n", m_Compiler->compMap2ILvarNum(varNum));
-                    varLiveDsc->dumpRegisterLiveRangesForBlockBeforeCodeGenerated(m_Compiler->codeGen);
-                    varLiveDsc->endBlockLiveRanges();
-                }
+            if (varLiveDsc->hasVarLiveRangesFromLastBlockToDump())
+            {
+                hasDumpedHistory = true;
+                m_Compiler->gtDispLclVar(varNum, false);
+                printf(": ");
+                varLiveDsc->dumpRegisterLiveRangesForBlockBeforeCodeGenerated(m_Compiler->codeGen);
+                varLiveDsc->endBlockLiveRanges();
+                printf("\n");
             }
         }
+    }
 
-        if (!hasDumpedHistory)
-        {
-            printf("..None..\n");
-        }
-
-        printf("////////////////////////////////////////\n");
-        printf("////////////////////////////////////////\n");
-        printf("End Generating code for Block %d \n", block->bbNum);
+    if (!hasDumpedHistory)
+    {
+        printf("..None..\n");
     }
 }
 
@@ -12473,34 +12502,28 @@ void CodeGenInterface::VariableLiveKeeper::dumpLvaVariableLiveRanges() const
 {
     bool hasDumpedHistory = false;
 
-    if (m_Compiler->verbose)
-    {
-        printf("////////////////////////////////////////\n");
-        printf("////////////////////////////////////////\n");
-        printf("PRINTING VARIABLE LIVE RANGES:\n");
+    printf("VARIABLE LIVE RANGES:\n");
 
-        if (m_Compiler->opts.compDbgInfo)
+    if (m_Compiler->opts.compDbgInfo)
+    {
+        for (unsigned int varNum = 0; varNum < m_LiveDscCount; varNum++)
         {
-            for (unsigned int varNum = 0; varNum < m_LiveDscCount; varNum++)
-            {
-                VariableLiveDescriptor* varLiveDsc = m_vlrLiveDsc + varNum;
+            VariableLiveDescriptor* varLiveDsc = m_vlrLiveDsc + varNum;
 
-                if (varLiveDsc->hasVarLiveRangesToDump())
-                {
-                    hasDumpedHistory = true;
-                    printf("IL Var Num %d:\n", m_Compiler->compMap2ILvarNum(varNum));
-                    varLiveDsc->dumpAllRegisterLiveRangesForBlock(m_Compiler->GetEmitter(), m_Compiler->codeGen);
-                }
+            if (varLiveDsc->hasVarLiveRangesToDump())
+            {
+                hasDumpedHistory = true;
+                m_Compiler->gtDispLclVar(varNum, false);
+                printf(": ");
+                varLiveDsc->dumpAllRegisterLiveRangesForBlock(m_Compiler->GetEmitter(), m_Compiler->codeGen);
+                printf("\n");
             }
         }
+    }
 
-        if (!hasDumpedHistory)
-        {
-            printf("..None..\n");
-        }
-
-        printf("////////////////////////////////////////\n");
-        printf("////////////////////////////////////////\n");
+    if (!hasDumpedHistory)
+    {
+        printf("..None..\n");
     }
 }
 #endif // DEBUG
diff --git a/src/coreclr/jit/codegenxarch.cpp b/src/coreclr/jit/codegenxarch.cpp
index e830007e51b4f4..2bd0142381f628 100644
--- a/src/coreclr/jit/codegenxarch.cpp
+++ b/src/coreclr/jit/codegenxarch.cpp
@@ -2332,7 +2332,8 @@ void CodeGen::genLclHeap(GenTree* tree)
     noway_assert(isFramePointerUsed()); // localloc requires Frame Pointer to be established since SP changes
     noway_assert(genStackLevel == 0);   // Can't have anything on the stack
 
-    unsigned stackAdjustment = 0;
+    target_size_t stackAdjustment     = 0;
+    target_size_t locAllocStackOffset = 0;
 
     // compute the amount of memory to allocate to properly STACK_ALIGN.
     size_t amount = 0;
@@ -2410,6 +2411,9 @@ void CodeGen::genLclHeap(GenTree* tree)
         }
     }
 
+    bool initMemOrLargeAlloc; // Declaration must be separate from initialization to avoid clang compiler error.
+    initMemOrLargeAlloc = compiler->info.compInitMem || (amount >= compiler->eeGetPageSize()); // must be >= not >
+
 #if FEATURE_FIXED_OUT_ARGS
     // If we have an outgoing arg area then we must adjust the SP by popping off the
     // outgoing arg area. We will restore it right before we return from this method.
@@ -2425,8 +2429,22 @@ void CodeGen::genLclHeap(GenTree* tree)
     {
         assert((compiler->lvaOutgoingArgSpaceSize % STACK_ALIGN) == 0); // This must be true for the stack to remain
                                                                         // aligned
+
+        // If the localloc amount is a small enough constant, and we're not initializing the allocated
+        // memory, then don't bother popping off the ougoing arg space first; just allocate the amount
+        // of space needed by the allocation, and call the bottom part the new outgoing arg space.
+
+        if ((amount > 0) && !initMemOrLargeAlloc)
+        {
+            lastTouchDelta      = genStackPointerConstantAdjustmentLoopWithProbe(-(ssize_t)amount, REG_NA);
+            stackAdjustment     = 0;
+            locAllocStackOffset = (target_size_t)compiler->lvaOutgoingArgSpaceSize;
+            goto ALLOC_DONE;
+        }
+
         inst_RV_IV(INS_add, REG_SPBASE, compiler->lvaOutgoingArgSpaceSize, EA_PTRSIZE);
-        stackAdjustment += compiler->lvaOutgoingArgSpaceSize;
+        stackAdjustment += (target_size_t)compiler->lvaOutgoingArgSpaceSize;
+        locAllocStackOffset = stackAdjustment;
     }
 #endif
 
@@ -2451,9 +2469,6 @@ void CodeGen::genLclHeap(GenTree* tree)
             goto ALLOC_DONE;
         }
 
-        bool initMemOrLargeAlloc =
-            compiler->info.compInitMem || (amount >= compiler->eeGetPageSize()); // must be >= not >
-
 #ifdef TARGET_X86
         bool needRegCntRegister = true;
 #else  // !TARGET_X86
@@ -2552,7 +2567,7 @@ void CodeGen::genLclHeap(GenTree* tree)
         assert(lastTouchDelta >= -1);
 
         if ((lastTouchDelta == (target_ssize_t)-1) ||
-            (stackAdjustment + (unsigned)lastTouchDelta + STACK_PROBE_BOUNDARY_THRESHOLD_BYTES >
+            (stackAdjustment + (target_size_t)lastTouchDelta + STACK_PROBE_BOUNDARY_THRESHOLD_BYTES >
              compiler->eeGetPageSize()))
         {
             genStackPointerConstantAdjustmentLoopWithProbe(-(ssize_t)stackAdjustment, REG_NA);
@@ -2564,8 +2579,8 @@ void CodeGen::genLclHeap(GenTree* tree)
     }
 
     // Return the stackalloc'ed address in result register.
-    // TargetReg = RSP + stackAdjustment.
-    GetEmitter()->emitIns_R_AR(INS_lea, EA_PTRSIZE, targetReg, REG_SPBASE, stackAdjustment);
+    // TargetReg = RSP + locAllocStackOffset
+    GetEmitter()->emitIns_R_AR(INS_lea, EA_PTRSIZE, targetReg, REG_SPBASE, (int)locAllocStackOffset);
 
     if (endLabel != nullptr)
     {
@@ -2737,26 +2752,47 @@ void CodeGen::genCodeForInitBlkUnroll(GenTreeBlk* node)
         src = src->AsUnOp()->gtGetOp1();
     }
 
+    unsigned size = node->GetLayout()->GetSize();
+
+    // An SSE mov that accesses data larger than 8 bytes may be implemented using
+    // multiple memory accesses. Hence, the JIT must not use such stores when
+    // INITBLK zeroes a struct that contains GC pointers and can be observed by
+    // other threads (i.e. when dstAddr is not an address of a local).
+    // For example, this can happen when initializing a struct field of an object.
+    const bool canUse16BytesSimdMov = !node->IsOnHeapAndContainsReferences();
+
+#ifdef TARGET_AMD64
+    // On Amd64 the JIT will not use SIMD stores for such structs and instead
+    // will always allocate a GP register for src node.
+    const bool willUseSimdMov = canUse16BytesSimdMov && (size >= XMM_REGSIZE_BYTES);
+#else
+    // On X86 the JIT will use movq for structs that are larger than 16 bytes
+    // since it is more beneficial than using two mov-s from a GP register.
+    const bool willUseSimdMov = (size >= 16);
+#endif
+
     if (!src->isContained())
     {
         srcIntReg = genConsumeReg(src);
     }
     else
     {
-        // If src is contained then it must be 0 and the size must be a multiple
-        // of XMM_REGSIZE_BYTES so initialization can use only SSE2 instructions.
+        // If src is contained then it must be 0.
         assert(src->IsIntegralConst(0));
-        assert((node->GetLayout()->GetSize() % XMM_REGSIZE_BYTES) == 0);
+        assert(willUseSimdMov);
+#ifdef TARGET_AMD64
+        assert(size % 16 == 0);
+#else
+        assert(size % 8 == 0);
+#endif
     }
 
     emitter* emit = GetEmitter();
-    unsigned size = node->GetLayout()->GetSize();
 
     assert(size <= INT32_MAX);
     assert(dstOffset < (INT32_MAX - static_cast<int>(size)));
 
-    // Fill as much as possible using SSE2 stores.
-    if (size >= XMM_REGSIZE_BYTES)
+    if (willUseSimdMov)
     {
         regNumber srcXmmReg = node->GetSingleTempReg(RBM_ALLFLOAT);
 
@@ -2776,9 +2812,25 @@ void CodeGen::genCodeForInitBlkUnroll(GenTreeBlk* node)
 #endif
         }
 
-        instruction simdMov = simdUnalignedMovIns();
-        for (unsigned regSize = XMM_REGSIZE_BYTES; size >= regSize; size -= regSize, dstOffset += regSize)
+        instruction simdMov      = simdUnalignedMovIns();
+        unsigned    regSize      = XMM_REGSIZE_BYTES;
+        unsigned    bytesWritten = 0;
+
+        while (bytesWritten < size)
         {
+#ifdef TARGET_X86
+            if (!canUse16BytesSimdMov || (bytesWritten + regSize > size))
+            {
+                simdMov = INS_movq;
+                regSize = 8;
+            }
+#endif
+            if (bytesWritten + regSize > size)
+            {
+                assert(srcIntReg != REG_NA);
+                break;
+            }
+
             if (dstLclNum != BAD_VAR_NUM)
             {
                 emit->emitIns_S_R(simdMov, EA_ATTR(regSize), srcXmmReg, dstLclNum, dstOffset);
@@ -2788,11 +2840,12 @@ void CodeGen::genCodeForInitBlkUnroll(GenTreeBlk* node)
                 emit->emitIns_ARX_R(simdMov, EA_ATTR(regSize), srcXmmReg, dstAddrBaseReg, dstAddrIndexReg,
                                     dstAddrIndexScale, dstOffset);
             }
+
+            dstOffset += regSize;
+            bytesWritten += regSize;
         }
 
-        // TODO-CQ-XArch: On x86 we could initialize 8 byte at once by using MOVQ instead of two 4 byte MOV stores.
-        // On x64 it may also be worth zero initializing a 4/8 byte remainder using MOVD/MOVQ, that avoids the need
-        // to allocate a GPR just for the remainder.
+        size -= bytesWritten;
     }
 
     // Fill the remainder using normal stores.
@@ -4589,7 +4642,7 @@ void CodeGen::genCodeForIndexAddr(GenTreeIndexAddr* node)
             // The VM doesn't allow such large array elements but let's be sure.
             noway_assert(scale <= INT32_MAX);
 #else  // !TARGET_64BIT
-            tmpReg              = node->GetSingleTempReg();
+            tmpReg = node->GetSingleTempReg();
 #endif // !TARGET_64BIT
 
             GetEmitter()->emitIns_R_I(emitter::inst3opImulForReg(tmpReg), EA_PTRSIZE, indexReg,
@@ -6035,8 +6088,7 @@ void CodeGen::genCompareInt(GenTree* treeNode)
     // TYP_UINT and TYP_ULONG should not appear here, only small types can be unsigned
     assert(!varTypeIsUnsigned(type) || varTypeIsSmall(type));
 
-    bool needsOCFlags = !tree->OperIs(GT_EQ, GT_NE);
-    if (canReuseFlags && emit->AreFlagsSetToZeroCmp(op1->GetRegNum(), emitTypeSize(type), needsOCFlags))
+    if (canReuseFlags && emit->AreFlagsSetToZeroCmp(op1->GetRegNum(), emitTypeSize(type), tree->OperGet()))
     {
         JITDUMP("Not emitting compare due to flags being already set\n");
     }
diff --git a/src/coreclr/jit/compiler.cpp b/src/coreclr/jit/compiler.cpp
index 5f086e1b8c5050..0093b0e0dbb41c 100644
--- a/src/coreclr/jit/compiler.cpp
+++ b/src/coreclr/jit/compiler.cpp
@@ -1466,7 +1466,19 @@ void Compiler::compShutdown()
 
 #if defined(DEBUG) || defined(INLINE_DATA)
     // Finish reading and/or writing inline xml
-    InlineStrategy::FinalizeXml();
+    if (JitConfig.JitInlineDumpXmlFile() != nullptr)
+    {
+        FILE* file = _wfopen(JitConfig.JitInlineDumpXmlFile(), W("a"));
+        if (file != nullptr)
+        {
+            InlineStrategy::FinalizeXml(file);
+            fclose(file);
+        }
+        else
+        {
+            InlineStrategy::FinalizeXml();
+        }
+    }
 #endif // defined(DEBUG) || defined(INLINE_DATA)
 
 #if defined(DEBUG) || MEASURE_NODE_SIZE || MEASURE_BLOCK_SIZE || DISPLAY_SIZES || CALL_ARG_STATS
@@ -5107,9 +5119,9 @@ void Compiler::compCompile(void** methodCodePtr, uint32_t* methodCodeSize, JitFl
     {
         compSizeEstimate  = 0;
         compCycleEstimate = 0;
-        for (BasicBlock* block = fgFirstBB; block != nullptr; block = block->bbNext)
+        for (BasicBlock* const block : Blocks())
         {
-            for (Statement* stmt : block->Statements())
+            for (Statement* const stmt : block->Statements())
             {
                 compSizeEstimate += stmt->GetCostSz();
                 compCycleEstimate += stmt->GetCostEx();
@@ -5295,12 +5307,12 @@ void Compiler::generatePatchpointInfo()
     }
 
     // Special offsets
-
-    if (lvaReportParamTypeArg() || lvaKeepAliveAndReportThis())
+    //
+    if (lvaReportParamTypeArg())
     {
-        const int offset = lvaToCallerSPRelativeOffset(lvaCachedGenericContextArgOffset(), true);
+        const int offset = lvaCachedGenericContextArgOffset();
         patchpointInfo->SetGenericContextArgOffset(offset);
-        JITDUMP("--OSR-- cached generic context offset is CallerSP %d\n", patchpointInfo->GenericContextArgOffset());
+        JITDUMP("--OSR-- cached generic context offset is FP %d\n", patchpointInfo->GenericContextArgOffset());
     }
 
     if (lvaKeepAliveAndReportThis())
@@ -5342,11 +5354,11 @@ void Compiler::ResetOptAnnotations()
     fgSsaPassesCompleted  = 0;
     fgVNPassesCompleted   = 0;
 
-    for (BasicBlock* block = fgFirstBB; block != nullptr; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
-        for (Statement* stmt : block->Statements())
+        for (Statement* const stmt : block->Statements())
         {
-            for (GenTree* tree = stmt->GetTreeList(); tree != nullptr; tree = tree->gtNext)
+            for (GenTree* const tree : stmt->TreeList())
             {
                 tree->ClearVN();
                 tree->ClearAssertion();
@@ -5371,7 +5383,7 @@ void Compiler::RecomputeLoopInfo()
     // Recompute reachability sets, dominators, and loops.
     optLoopCount   = 0;
     fgDomsComputed = false;
-    for (BasicBlock* block = fgFirstBB; block != nullptr; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
         block->bbFlags &= ~BBF_LOOP_FLAGS;
     }
@@ -5898,7 +5910,24 @@ void Compiler::compCompileFinish()
 #if defined(DEBUG) || defined(INLINE_DATA)
 
     m_inlineStrategy->DumpData();
-    m_inlineStrategy->DumpXml();
+
+    if (JitConfig.JitInlineDumpXmlFile() != nullptr)
+    {
+        FILE* file = _wfopen(JitConfig.JitInlineDumpXmlFile(), W("a"));
+        if (file != nullptr)
+        {
+            m_inlineStrategy->DumpXml(file);
+            fclose(file);
+        }
+        else
+        {
+            m_inlineStrategy->DumpXml();
+        }
+    }
+    else
+    {
+        m_inlineStrategy->DumpXml();
+    }
 
 #endif
 
@@ -7366,11 +7395,11 @@ Compiler::NodeToIntMap* Compiler::FindReachableNodesInNodeTestData()
 
     // Otherwise, iterate.
 
-    for (BasicBlock* block = fgFirstBB; block != nullptr; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
-        for (Statement* stmt = block->FirstNonPhiDef(); stmt != nullptr; stmt = stmt->GetNextStmt())
+        for (Statement* const stmt : block->NonPhiStatements())
         {
-            for (GenTree* tree = stmt->GetTreeList(); tree != nullptr; tree = tree->gtNext)
+            for (GenTree* const tree : stmt->TreeList())
             {
                 TestLabelAndNum tlAndN;
 
@@ -7494,22 +7523,17 @@ void Compiler::compCallArgStats()
 
     assert(fgStmtListThreaded);
 
-    for (BasicBlock* block = fgFirstBB; block != nullptr; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
-        for (Statement* stmt : block->Statements())
+        for (Statement* const stmt : block->Statements())
         {
-            for (GenTree* call = stmt->GetTreeList(); call != nullptr; call = call->gtNext)
+            for (GenTree* const call : stmt->TreeList())
             {
                 if (call->gtOper != GT_CALL)
                     continue;
 
-                argNum =
-
-                    regArgNum = regArgDeferred = regArgTemp =
-
-                        regArgConst = regArgLclVar =
-
-                            argDWordNum = argLngNum = argFltNum = argDblNum = 0;
+                argNum = regArgNum = regArgDeferred = regArgTemp = regArgConst = regArgLclVar = argDWordNum =
+                    argLngNum = argFltNum = argDblNum = 0;
 
                 argTotalCalls++;
 
@@ -8919,16 +8943,15 @@ GenTree* dFindTree(GenTree* tree, unsigned id)
 
 GenTree* dFindTree(unsigned id)
 {
-    Compiler*   comp = JitTls::GetCompiler();
-    BasicBlock* block;
-    GenTree*    tree;
+    Compiler* comp = JitTls::GetCompiler();
+    GenTree*  tree;
 
     dbTreeBlock = nullptr;
     dbTree      = nullptr;
 
-    for (block = comp->fgFirstBB; block != nullptr; block = block->bbNext)
+    for (BasicBlock* const block : comp->Blocks())
     {
-        for (Statement* stmt : block->Statements())
+        for (Statement* const stmt : block->Statements())
         {
             tree = dFindTree(stmt->GetRootNode(), id);
             if (tree != nullptr)
@@ -8944,15 +8967,14 @@ GenTree* dFindTree(unsigned id)
 
 Statement* dFindStmt(unsigned id)
 {
-    Compiler*   comp = JitTls::GetCompiler();
-    BasicBlock* block;
+    Compiler* comp = JitTls::GetCompiler();
 
     dbStmt = nullptr;
 
     unsigned stmtId = 0;
-    for (block = comp->fgFirstBB; block != nullptr; block = block->bbNext)
+    for (BasicBlock* const block : comp->Blocks())
     {
-        for (Statement* stmt : block->Statements())
+        for (Statement* const stmt : block->Statements())
         {
             stmtId++;
             if (stmtId == id)
@@ -9721,6 +9743,21 @@ const char* Compiler::devirtualizationDetailToString(CORINFO_DEVIRTUALIZATION_DE
             return "devirtualization crossed version bubble";
         case CORINFO_DEVIRTUALIZATION_MULTIPLE_IMPL:
             return "object class has multiple implementations of interface";
+        case CORINFO_DEVIRTUALIZATION_FAILED_BUBBLE_CLASS_DECL:
+            return "decl method is defined on class and decl method not in version bubble, and decl method not in "
+                   "type closest to version bubble";
+        case CORINFO_DEVIRTUALIZATION_FAILED_BUBBLE_INTERFACE_DECL:
+            return "decl method is defined on interface and not in version bubble, and implementation type not "
+                   "entirely defined in bubble";
+        case CORINFO_DEVIRTUALIZATION_FAILED_BUBBLE_IMPL:
+            return "object class not defined within version bubble";
+        case CORINFO_DEVIRTUALIZATION_FAILED_BUBBLE_IMPL_NOT_REFERENCEABLE:
+            return "object class cannot be referenced from R2R code due to missing tokens";
+        case CORINFO_DEVIRTUALIZATION_FAILED_DUPLICATE_INTERFACE:
+            return "crossgen2 virtual method algorithm and runtime algorithm differ in the presence of duplicate "
+                   "interface implementations";
+        case CORINFO_DEVIRTUALIZATION_FAILED_DECL_NOT_REPRESENTABLE:
+            return "Decl method cannot be represented in R2R image";
         default:
             return "undefined";
     }
diff --git a/src/coreclr/jit/compiler.h b/src/coreclr/jit/compiler.h
index 58340e00922036..117d7d28a167a4 100644
--- a/src/coreclr/jit/compiler.h
+++ b/src/coreclr/jit/compiler.h
@@ -1131,7 +1131,8 @@ class LinearScanInterface
     virtual void recordVarLocationsAtStartOfBB(BasicBlock* bb) = 0;
     virtual bool willEnregisterLocalVars() const               = 0;
 #if TRACK_LSRA_STATS
-    virtual void dumpLsraStatsCsv(FILE* file) = 0;
+    virtual void dumpLsraStatsCsv(FILE* file)     = 0;
+    virtual void dumpLsraStatsSummary(FILE* file) = 0;
 #endif // TRACK_LSRA_STATS
 };
 
@@ -3568,7 +3569,7 @@ class Compiler
     unsigned lvaFrameSize(FrameLayoutState curState);
 
     // Returns the caller-SP-relative offset for the SP/FP relative offset determined by FP based.
-    int lvaToCallerSPRelativeOffset(int offs, bool isFpBased) const;
+    int lvaToCallerSPRelativeOffset(int offs, bool isFpBased, bool forRootFrame = true) const;
 
     // Returns the caller-SP-relative offset for the local variable "varNum."
     int lvaGetCallerSPRelativeOffset(unsigned varNum);
@@ -3947,6 +3948,7 @@ class Compiler
     }
 
     void impDevirtualizeCall(GenTreeCall*            call,
+                             CORINFO_RESOLVED_TOKEN* pResolvedToken,
                              CORINFO_METHOD_HANDLE*  method,
                              unsigned*               methodFlags,
                              CORINFO_CONTEXT_HANDLE* contextHandle,
@@ -3988,7 +3990,10 @@ class Compiler
 
     GenTree* impImportLdvirtftn(GenTree* thisPtr, CORINFO_RESOLVED_TOKEN* pResolvedToken, CORINFO_CALL_INFO* pCallInfo);
 
-    int impBoxPatternMatch(CORINFO_RESOLVED_TOKEN* pResolvedToken, const BYTE* codeAddr, const BYTE* codeEndp);
+    int impBoxPatternMatch(CORINFO_RESOLVED_TOKEN* pResolvedToken,
+                           const BYTE*             codeAddr,
+                           const BYTE*             codeEndp,
+                           bool                    makeInlineObservation = false);
     void impImportAndPushBox(CORINFO_RESOLVED_TOKEN* pResolvedToken);
 
     void impImportNewObjArray(CORINFO_RESOLVED_TOKEN* pResolvedToken, CORINFO_CALL_INFO* pCallInfo);
@@ -4978,6 +4983,28 @@ class Compiler
 
     void fgInterBlockLocalVarLiveness();
 
+    // Blocks: convenience methods for enabling range-based `for` iteration over the function's blocks, e.g.:
+    // 1.   for (BasicBlock* const block : compiler->Blocks()) ...
+    // 2.   for (BasicBlock* const block : compiler->Blocks(startBlock)) ...
+    // 3.   for (BasicBlock* const block : compiler->Blocks(startBlock, endBlock)) ...
+    // In case (1), the block list can be empty. In case (2), `startBlock` can be nullptr. In case (3),
+    // both `startBlock` and `endBlock` must be non-null.
+    //
+    BasicBlockSimpleList Blocks() const
+    {
+        return BasicBlockSimpleList(fgFirstBB);
+    }
+
+    BasicBlockSimpleList Blocks(BasicBlock* startBlock) const
+    {
+        return BasicBlockSimpleList(startBlock);
+    }
+
+    BasicBlockRangeList Blocks(BasicBlock* startBlock, BasicBlock* endBlock) const
+    {
+        return BasicBlockRangeList(startBlock, endBlock);
+    }
+
     // The presence of a partial definition presents some difficulties for SSA: this is both a use of some SSA name
     // of "x", and a def of a new SSA name for "x".  The tree only has one local variable for "x", so it has to choose
     // whether to treat that as the use or def.  It chooses the "use", and thus the old SSA name.  This map allows us
@@ -6479,6 +6506,18 @@ class Compiler
                    lpEntry->bbNum <= lpBottom->bbNum &&
                    (lpHead->bbNum < lpTop->bbNum || lpHead->bbNum > lpBottom->bbNum);
         }
+
+        // LoopBlocks: convenience method for enabling range-based `for` iteration over all the
+        // blocks in a loop, e.g.:
+        //    for (BasicBlock* const block : loop->LoopBlocks()) ...
+        // Currently, the loop blocks are expected to be in linear, lexical, `bbNext` order
+        // from `lpFirst` through `lpBottom`, inclusive. All blocks in this range are considered
+        // to be part of the loop.
+        //
+        BasicBlockRangeList LoopBlocks() const
+        {
+            return BasicBlockRangeList(lpFirst, lpBottom);
+        }
     };
 
 protected:
@@ -11256,6 +11295,59 @@ class DomTreeVisitor
     }
 };
 
+// EHClauses: adapter class for forward iteration of the exception handling table using range-based `for`, e.g.:
+//    for (EHblkDsc* const ehDsc : EHClauses(compiler))
+//
+class EHClauses
+{
+    EHblkDsc* m_begin;
+    EHblkDsc* m_end;
+
+    // Forward iterator for the exception handling table entries. Iteration is in table order.
+    //
+    class iterator
+    {
+        EHblkDsc* m_ehDsc;
+
+    public:
+        iterator(EHblkDsc* ehDsc) : m_ehDsc(ehDsc)
+        {
+        }
+
+        EHblkDsc* operator*() const
+        {
+            return m_ehDsc;
+        }
+
+        iterator& operator++()
+        {
+            ++m_ehDsc;
+            return *this;
+        }
+
+        bool operator!=(const iterator& i) const
+        {
+            return m_ehDsc != i.m_ehDsc;
+        }
+    };
+
+public:
+    EHClauses(Compiler* comp) : m_begin(comp->compHndBBtab), m_end(comp->compHndBBtab + comp->compHndBBtabCount)
+    {
+        assert((m_begin != nullptr) || (m_begin == m_end));
+    }
+
+    iterator begin() const
+    {
+        return iterator(m_begin);
+    }
+
+    iterator end() const
+    {
+        return iterator(m_end);
+    }
+};
+
 /*
 XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
 XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
@@ -11471,16 +11563,6 @@ extern const BYTE genActualTypes[];
 
 /*****************************************************************************/
 
-// foreach_block: An iterator over all blocks in the function.
-//    __compiler: the Compiler* object
-//    __block   : a BasicBlock*, already declared, that gets updated each iteration.
-
-#define foreach_block(__compiler, __block)                                                                             \
-    for ((__block) = (__compiler)->fgFirstBB; (__block); (__block) = (__block)->bbNext)
-
-/*****************************************************************************/
-/*****************************************************************************/
-
 #ifdef DEBUG
 void dumpConvertedVarSet(Compiler* comp, VARSET_VALARG_TP vars);
 #endif // DEBUG
diff --git a/src/coreclr/jit/compiler.hpp b/src/coreclr/jit/compiler.hpp
index 091758bcdeeca3..e898605c7b6a5c 100644
--- a/src/coreclr/jit/compiler.hpp
+++ b/src/coreclr/jit/compiler.hpp
@@ -1832,7 +1832,7 @@ inline VARSET_VALRET_TP Compiler::lvaStmtLclMask(Statement* stmt)
 
     assert(fgStmtListThreaded);
 
-    for (GenTree* tree = stmt->GetTreeList(); tree != nullptr; tree = tree->gtNext)
+    for (GenTree* const tree : stmt->TreeList())
     {
         if (tree->gtOper != GT_LCL_VAR)
         {
diff --git a/src/coreclr/jit/copyprop.cpp b/src/coreclr/jit/copyprop.cpp
index ca01e90250f654..c0d72123e1a11d 100644
--- a/src/coreclr/jit/copyprop.cpp
+++ b/src/coreclr/jit/copyprop.cpp
@@ -28,9 +28,9 @@
  */
 void Compiler::optBlockCopyPropPopStacks(BasicBlock* block, LclNumToGenTreePtrStack* curSsaName)
 {
-    for (Statement* stmt : block->Statements())
+    for (Statement* const stmt : block->Statements())
     {
-        for (GenTree* tree = stmt->GetTreeList(); tree != nullptr; tree = tree->gtNext)
+        for (GenTree* const tree : stmt->TreeList())
         {
             if (!tree->IsLocal())
             {
@@ -97,16 +97,6 @@ int Compiler::optCopyProp_LclVarScore(LclVarDsc* lclVarDsc, LclVarDsc* copyVarDs
         score -= 4;
     }
 
-    if (lclVarDsc->lvDoNotEnregister)
-    {
-        score += 4;
-    }
-
-    if (copyVarDsc->lvDoNotEnregister)
-    {
-        score -= 4;
-    }
-
 #ifdef TARGET_X86
     // For doubles we also prefer to change parameters into non-parameter local variables
     if (lclVarDsc->lvType == TYP_DOUBLE)
@@ -363,12 +353,12 @@ void Compiler::optBlockCopyProp(BasicBlock* block, LclNumToGenTreePtrStack* curS
     // There are no definitions at the start of the block. So clear it.
     compCurLifeTree = nullptr;
     VarSetOps::Assign(this, compCurLife, block->bbLiveIn);
-    for (Statement* stmt : block->Statements())
+    for (Statement* const stmt : block->Statements())
     {
         VarSetOps::ClearD(this, optCopyPropKillSet);
 
         // Walk the tree to find if any local variable can be replaced with current live definitions.
-        for (GenTree* tree = stmt->GetTreeList(); tree != nullptr; tree = tree->gtNext)
+        for (GenTree* const tree : stmt->TreeList())
         {
             treeLifeUpdater.UpdateLife(tree);
 
@@ -396,7 +386,7 @@ void Compiler::optBlockCopyProp(BasicBlock* block, LclNumToGenTreePtrStack* curS
         }
 
         // This logic must be in sync with SSA renaming process.
-        for (GenTree* tree = stmt->GetTreeList(); tree != nullptr; tree = tree->gtNext)
+        for (GenTree* const tree : stmt->TreeList())
         {
             const unsigned lclNum = optIsSsaLocal(tree);
             if (lclNum == BAD_VAR_NUM)
diff --git a/src/coreclr/jit/cpp.hint b/src/coreclr/jit/cpp.hint
index b2fe33cc9815a0..297be6b8d49324 100644
--- a/src/coreclr/jit/cpp.hint
+++ b/src/coreclr/jit/cpp.hint
@@ -7,21 +7,9 @@
 // See the article on hints in MSDN for more information on their necessity and use:
 //    http://msdn.microsoft.com/en-us/library/dd997977.aspx
 
-#define foreach_treenode_execution_order(__node, __stmt) for (;;)
-
-#define foreach_block(__compiler, __block) for (;;)
-
 #define FOREACH_REGISTER_FILE(file) for (;;)
 
 // From jit.h
 
-#define DECLARE_TYPED_ENUM(tag,baseType) enum tag : baseType
-
-#define END_DECLARE_TYPED_ENUM(tag,baseType) ;
-
 #define INDEBUG(x)          x
-#define INDEBUG_COMMA(x)    x,
 #define DEBUGARG(x)         , x
-
-#define PROTO_ARG(x)   x ,
-#define PROTO_ARGL(x)  , x
\ No newline at end of file
diff --git a/src/coreclr/jit/earlyprop.cpp b/src/coreclr/jit/earlyprop.cpp
index fbdc6881ea0155..f30b33eb1f3fdb 100644
--- a/src/coreclr/jit/earlyprop.cpp
+++ b/src/coreclr/jit/earlyprop.cpp
@@ -242,7 +242,7 @@ void Compiler::optEarlyProp()
 
     assert(fgSsaPassesCompleted == 1);
 
-    for (BasicBlock* block = fgFirstBB; block != nullptr; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
 #ifndef DEBUG
         if (!optDoEarlyPropForBlock(block))
diff --git a/src/coreclr/jit/emitxarch.cpp b/src/coreclr/jit/emitxarch.cpp
index da7febee92b0d8..6578232a92996e 100644
--- a/src/coreclr/jit/emitxarch.cpp
+++ b/src/coreclr/jit/emitxarch.cpp
@@ -149,6 +149,98 @@ bool emitter::IsDstSrcSrcAVXInstruction(instruction ins)
     return ((CodeGenInterface::instInfo[ins] & INS_Flags_IsDstSrcSrcAVXInstruction) != 0) && IsAVXInstruction(ins);
 }
 
+//------------------------------------------------------------------------
+// DoesWriteZeroFlag: check if the instruction write the
+//     ZF flag.
+//
+// Arguments:
+//    ins - instruction to test
+//
+// Return Value:
+//    true if instruction writes the ZF flag, false otherwise.
+//
+bool emitter::DoesWriteZeroFlag(instruction ins)
+{
+    return (CodeGenInterface::instInfo[ins] & Writes_ZF) != 0;
+}
+
+//------------------------------------------------------------------------
+// DoesResetOverflowAndCarryFlags: check if the instruction resets the
+//     OF and CF flag to 0.
+//
+// Arguments:
+//    ins - instruction to test
+//
+// Return Value:
+//    true if instruction resets the OF and CF flag, false otherwise.
+//
+bool emitter::DoesResetOverflowAndCarryFlags(instruction ins)
+{
+    return (CodeGenInterface::instInfo[ins] & (Resets_OF | Resets_CF)) == (Resets_OF | Resets_CF);
+}
+
+//------------------------------------------------------------------------
+// IsFlagsAlwaysModified: check if the instruction guarantee to modify any flags.
+//
+// Arguments:
+//    id - instruction to test
+//
+// Return Value:
+//    false, if instruction is guaranteed to not modify any flag.
+//    true, if instruction will modify some flag.
+//
+bool emitter::IsFlagsAlwaysModified(instrDesc* id)
+{
+    instruction ins = id->idIns();
+    insFormat   fmt = id->idInsFmt();
+
+    if (fmt == IF_RRW_SHF)
+    {
+        if (id->idIsLargeCns())
+        {
+            return true;
+        }
+        else if (id->idSmallCns() == 0)
+        {
+            switch (ins)
+            {
+                // If shift-amount for below instructions is 0, then flags are unaffected.
+                case INS_rcl_N:
+                case INS_rcr_N:
+                case INS_rol_N:
+                case INS_ror_N:
+                case INS_shl_N:
+                case INS_shr_N:
+                case INS_sar_N:
+                    return false;
+                default:
+                    return true;
+            }
+        }
+    }
+    else if (fmt == IF_RRW)
+    {
+        switch (ins)
+        {
+            // If shift-amount for below instructions is 0, then flags are unaffected.
+            // So, to be conservative, do not optimize if the instruction has register
+            // as the shift-amount operand.
+            case INS_rcl:
+            case INS_rcr:
+            case INS_rol:
+            case INS_ror:
+            case INS_shl:
+            case INS_shr:
+            case INS_sar:
+                return false;
+            default:
+                return true;
+        }
+    }
+
+    return true;
+}
+
 //------------------------------------------------------------------------
 // AreUpper32BitsZero: check if some previously emitted
 //     instruction set the upper 32 bits of reg to zero.
@@ -225,9 +317,9 @@ bool emitter::AreUpper32BitsZero(regNumber reg)
 //                       the same values as if there were a compare to 0
 //
 // Arguments:
-//    reg - register of interest
-//    opSize - size of register
-//    needsOCFlags - additionally check the overflow and carry flags
+//    reg     - register of interest
+//    opSize  - size of register
+//    treeOps - type of tree node operation
 //
 // Return Value:
 //    true if the previous instruction set the flags for reg
@@ -235,17 +327,19 @@ bool emitter::AreUpper32BitsZero(regNumber reg)
 //
 // Notes:
 //    Currently only looks back one instruction.
-bool emitter::AreFlagsSetToZeroCmp(regNumber reg, emitAttr opSize, bool needsOCFlags)
+bool emitter::AreFlagsSetToZeroCmp(regNumber reg, emitAttr opSize, genTreeOps treeOps)
 {
     assert(reg != REG_NA);
+
     // Don't look back across IG boundaries (possible control flow)
     if (emitCurIGinsCnt == 0 && ((emitCurIG->igFlags & IGF_EXTEND) == 0))
     {
         return false;
     }
 
-    instrDesc* id  = emitLastIns;
-    insFormat  fmt = id->idInsFmt();
+    instrDesc*  id      = emitLastIns;
+    instruction lastIns = id->idIns();
+    insFormat   fmt     = id->idInsFmt();
 
     // make sure op1 is a reg
     switch (fmt)
@@ -264,7 +358,6 @@ bool emitter::AreFlagsSetToZeroCmp(regNumber reg, emitAttr opSize, bool needsOCF
         case IF_RRD:
         case IF_RRW:
             break;
-
         default:
             return false;
     }
@@ -274,34 +367,20 @@ bool emitter::AreFlagsSetToZeroCmp(regNumber reg, emitAttr opSize, bool needsOCF
         return false;
     }
 
-    switch (id->idIns())
+    // Certain instruction like and, or and xor modifies exactly same flags
+    // as "test" instruction.
+    // They reset OF and CF to 0 and modifies SF, ZF and PF.
+    if (DoesResetOverflowAndCarryFlags(lastIns))
     {
-        case INS_adc:
-        case INS_add:
-        case INS_dec:
-        case INS_dec_l:
-        case INS_inc:
-        case INS_inc_l:
-        case INS_neg:
-        case INS_shr_1:
-        case INS_shl_1:
-        case INS_sar_1:
-        case INS_sbb:
-        case INS_sub:
-        case INS_xadd:
-            if (needsOCFlags)
-            {
-                return false;
-            }
-            FALLTHROUGH;
-        // these always set OC to 0
-        case INS_and:
-        case INS_or:
-        case INS_xor:
-            return id->idOpSize() == opSize;
+        return id->idOpSize() == opSize;
+    }
 
-        default:
-            break;
+    if ((treeOps == GT_EQ) || (treeOps == GT_NE))
+    {
+        if (DoesWriteZeroFlag(lastIns) && IsFlagsAlwaysModified(id))
+        {
+            return id->idOpSize() == opSize;
+        }
     }
 
     return false;
@@ -4164,6 +4243,20 @@ void emitter::emitIns_C(instruction ins, emitAttr attr, CORINFO_FIELD_HANDLE fld
 // Arguments:
 //    ins       -- The instruction being checked
 //
+// Return Value:
+//    true if the instruction is a qualifying move instruction; otherwise, false
+//
+// Remarks:
+//    This methods covers most kinds of two operand move instructions that copy a
+//    value between two registers. It does not cover all move-like instructions
+//    and so doesn't currently cover things like movsb/movsw/movsd/movsq or cmovcc
+//    and doesn't currently cover cases where a value is read/written from memory.
+//
+//    The reason it doesn't cover all instructions was namely to limit the scope
+//    of the initial change to that which was impactful to move elision so that
+//    it could be centrally managed and optimized. It may be beneficial to support
+//    the other move instructions in the future but that may require more extensive
+//    changes to ensure relevant codegen/emit paths flow and check things correctly.
 bool emitter::IsMovInstruction(instruction ins)
 {
     switch (ins)
@@ -4174,7 +4267,6 @@ bool emitter::IsMovInstruction(instruction ins)
         case INS_movd:
         case INS_movdqa:
         case INS_movdqu:
-        case INS_movsd:
         case INS_movsdsse2:
         case INS_movss:
         case INS_movsx:
@@ -4200,6 +4292,183 @@ bool emitter::IsMovInstruction(instruction ins)
     }
 }
 
+//----------------------------------------------------------------------------------------
+// IsRedundantMov:
+//    Check if the current `mov` instruction is redundant and can be omitted.
+//    A `mov` is redundant in following 3 cases:
+//
+//    1. Move to same register on TARGET_AMD64
+//       (Except 4-byte movement like "mov eax, eax" which zeros out upper bits of eax register)
+//
+//         mov rax, rax
+//
+//    2. Move that is identical to last instruction emitted.
+//
+//         mov rax, rbx  # <-- last instruction
+//         mov rax, rbx  # <-- current instruction can be omitted.
+//
+//    3. Opposite Move as that of last instruction emitted.
+//
+//         mov rax, rbx  # <-- last instruction
+//         mov rbx, rax  # <-- current instruction can be omitted.
+//
+// Arguments:
+//                 ins  - The current instruction
+//                 fmt  - The current format
+//                 size - Operand size of current instruction
+//                 dst  - The current destination
+//                 src  - The current source
+// canIgnoreSideEffects - The move can be skipped as it doesn't represent special semantics
+//
+// Return Value:
+//    true if the move instruction is redundant; otherwise, false.
+
+bool emitter::IsRedundantMov(
+    instruction ins, insFormat fmt, emitAttr size, regNumber dst, regNumber src, bool canIgnoreSideEffects)
+{
+    assert(IsMovInstruction(ins));
+
+    if (canIgnoreSideEffects && (dst == src))
+    {
+        // These elisions used to be explicit even when optimizations were disabled
+
+        // Some instructions have a side effect and shouldn't be skipped
+        // however existing codepaths were skipping these instructions in
+        // certain scenarios and so we skip them as well for back-compat
+        // when canIgnoreSideEffects is true (see below for which have a
+        // side effect).
+        //
+        // Long term, these paths should be audited and should likely be
+        // replaced with copies rather than extensions.
+        return true;
+    }
+
+    if (!emitComp->opts.OptimizationEnabled())
+    {
+        // The remaining move elisions should only happen if optimizations are enabled
+        return false;
+    }
+
+    // TODO-XArch-CQ: There are places where the fact that an instruction zero-extends
+    // is not an important detail, such as when "regular" floating-point code is generated
+    //
+    // This differs from cases like HWIntrinsics that deal with the entire vector and so
+    // they need to be "aware" that a given move impacts the upper-bits.
+    //
+    // Ideally we can detect this difference, likely via canIgnoreSideEffects, and allow
+    // the below optimizations for those scenarios as well.
+
+    // Track whether the instruction has a zero/sign-extension or clearing of the upper-bits as a side-effect
+    bool hasSideEffect = false;
+
+    switch (ins)
+    {
+        case INS_mov:
+        {
+            // non EA_PTRSIZE moves may zero-extend the source
+            hasSideEffect = (size != EA_PTRSIZE);
+            break;
+        }
+
+        case INS_movapd:
+        case INS_movaps:
+        case INS_movdqa:
+        case INS_movdqu:
+        case INS_movupd:
+        case INS_movups:
+        {
+            // non EA_32BYTE moves clear the upper bits under VEX encoding
+            hasSideEffect = UseVEXEncoding() && (size != EA_32BYTE);
+            break;
+        }
+
+        case INS_movd:
+        {
+            // Clears the upper bits
+            hasSideEffect = true;
+            break;
+        }
+
+        case INS_movsdsse2:
+        case INS_movss:
+        {
+            // Clears the upper bits under VEX encoding
+            hasSideEffect = UseVEXEncoding();
+            break;
+        }
+
+        case INS_movsx:
+        case INS_movzx:
+        {
+            // Sign/Zero-extends the source
+            hasSideEffect = true;
+            break;
+        }
+
+#if defined(TARGET_AMD64)
+        case INS_movq:
+        {
+            // Clears the upper bits
+            hasSideEffect = true;
+            break;
+        }
+
+        case INS_movsxd:
+        {
+            // Sign-extends the source
+            hasSideEffect = true;
+            break;
+        }
+#endif // TARGET_AMD64
+
+        default:
+        {
+            unreached();
+        }
+    }
+
+    // Check if we are already in the correct register and don't have a side effect
+    if ((dst == src) && !hasSideEffect)
+    {
+        JITDUMP("\n -- suppressing mov because src and dst is same register and the mov has no side-effects.\n");
+        return true;
+    }
+
+    bool isFirstInstrInBlock = (emitCurIGinsCnt == 0) && ((emitCurIG->igFlags & IGF_EXTEND) == 0);
+
+    // TODO-XArch-CQ: Certain instructions, such as movaps vs movups, are equivalent in
+    // functionality even if their actual identifier differs and we should optimize these
+
+    if (isFirstInstrInBlock ||               // Don't optimize if instruction is the first instruction in IG.
+        (emitLastIns == nullptr) ||          // or if a last instruction doesn't exist
+        (emitLastIns->idIns() != ins) ||     // or if the instruction is different from the last instruction
+        (emitLastIns->idOpSize() != size) || // or if the operand size is different from the last instruction
+        (emitLastIns->idInsFmt() != fmt))    // or if the format is different from the last instruction
+    {
+        return false;
+    }
+
+    regNumber lastDst = emitLastIns->idReg1();
+    regNumber lastSrc = emitLastIns->idReg2();
+
+    // Check if we did same move in last instruction, side effects don't matter since they already happened
+    if ((lastDst == dst) && (lastSrc == src))
+    {
+        JITDUMP("\n -- suppressing mov because last instruction already moved from src to dst register.\n");
+        return true;
+    }
+
+    // Check if we did a switched mov in the last instruction  and don't have a side effect
+    if ((lastDst == src) && (lastSrc == dst) && !hasSideEffect)
+    {
+        JITDUMP("\n -- suppressing mov because last instruction already moved from dst to src register and the mov has "
+                "no side-effects.\n");
+        return true;
+    }
+
+    return false;
+}
+
 //------------------------------------------------------------------------
 // emitIns_Mov: Emits a move instruction
 //
@@ -4230,7 +4499,6 @@ void emitter::emitIns_Mov(instruction ins, emitAttr attr, regNumber dstReg, regN
         case INS_movaps:
         case INS_movdqa:
         case INS_movdqu:
-        case INS_movsd:
         case INS_movsdsse2:
         case INS_movss:
         case INS_movupd:
@@ -4272,67 +4540,14 @@ void emitter::emitIns_Mov(instruction ins, emitAttr attr, regNumber dstReg, regN
     assert(size <= EA_32BYTE);
     noway_assert(emitVerifyEncodable(ins, size, dstReg, srcReg));
 
-    if (canSkip && (dstReg == srcReg))
-    {
-        switch (ins)
-        {
-            case INS_mov:
-            {
-                // These instructions have no side effect and can be skipped
-                return;
-            }
-
-            case INS_movapd:
-            case INS_movaps:
-            case INS_movdqa:
-            case INS_movdqu:
-            case INS_movupd:
-            case INS_movups:
-            {
-                // These instructions have no side effect and can be skipped
-                return;
-            }
-
-            case INS_movd:
-            case INS_movsd:
-            case INS_movsdsse2:
-            case INS_movss:
-            case INS_movsx:
-            case INS_movzx:
-            {
-                // These instructions have a side effect and shouldn't be skipped
-                // however existing codepaths were skipping these instructions in
-                // certain scenarios and so we skip them as well for back-compat.
-                //
-                // Long term, these paths should be audited and should likely be
-                // replaced with copies rather than extensions.
-                return;
-            }
-
-#if defined(TARGET_AMD64)
-            case INS_movq:
-            case INS_movsxd:
-            {
-                // These instructions have a side effect and shouldn't be skipped
-                // however existing codepaths were skipping these instructions in
-                // certain scenarios and so we skip them as well for back-compat.
-                //
-                // Long term, these paths should be audited and should likely be
-                // replaced with copies rather than extensions.
-                return;
-            }
-#endif // TARGET_AMD64
-
-            default:
-            {
-                unreached();
-            }
-        }
-    }
-
     UNATIVE_OFFSET sz  = emitInsSizeRR(ins, dstReg, srcReg, attr);
     insFormat      fmt = emitInsModeFormat(ins, IF_RRD_RRD);
 
+    if (IsRedundantMov(ins, fmt, attr, dstReg, srcReg, canSkip))
+    {
+        return;
+    }
+
     instrDesc* id = emitNewInstrSmall(attr);
     id->idIns(ins);
     id->idInsFmt(fmt);
diff --git a/src/coreclr/jit/emitxarch.h b/src/coreclr/jit/emitxarch.h
index d395a29ec9b138..8260445686be09 100644
--- a/src/coreclr/jit/emitxarch.h
+++ b/src/coreclr/jit/emitxarch.h
@@ -95,10 +95,12 @@ code_t AddRexPrefix(instruction ins, code_t code);
 bool EncodedBySSE38orSSE3A(instruction ins);
 bool Is4ByteSSEInstruction(instruction ins);
 static bool IsMovInstruction(instruction ins);
+bool IsRedundantMov(
+    instruction ins, insFormat fmt, emitAttr size, regNumber dst, regNumber src, bool canIgnoreSideEffects);
 
 bool AreUpper32BitsZero(regNumber reg);
 
-bool AreFlagsSetToZeroCmp(regNumber reg, emitAttr opSize, bool needsOCFlags);
+bool AreFlagsSetToZeroCmp(regNumber reg, emitAttr opSize, genTreeOps treeOps);
 
 bool hasRexPrefix(code_t code)
 {
@@ -171,6 +173,10 @@ void SetContains256bitAVX(bool value)
 
 bool IsDstDstSrcAVXInstruction(instruction ins);
 bool IsDstSrcSrcAVXInstruction(instruction ins);
+bool DoesWriteZeroFlag(instruction ins);
+bool DoesResetOverflowAndCarryFlags(instruction ins);
+bool IsFlagsAlwaysModified(instrDesc* id);
+
 bool IsThreeOperandAVXInstruction(instruction ins)
 {
     return (IsDstDstSrcAVXInstruction(ins) || IsDstSrcSrcAVXInstruction(ins));
diff --git a/src/coreclr/jit/fgbasic.cpp b/src/coreclr/jit/fgbasic.cpp
index ca15afbff50925..0807b69d7eee13 100644
--- a/src/coreclr/jit/fgbasic.cpp
+++ b/src/coreclr/jit/fgbasic.cpp
@@ -382,15 +382,9 @@ void Compiler::fgChangeSwitchBlock(BasicBlock* oldSwitchBlock, BasicBlock* newSw
     noway_assert(newSwitchBlock != nullptr);
     noway_assert(oldSwitchBlock->bbJumpKind == BBJ_SWITCH);
 
-    unsigned     jumpCnt = oldSwitchBlock->bbJumpSwt->bbsCount;
-    BasicBlock** jumpTab = oldSwitchBlock->bbJumpSwt->bbsDstTab;
-
-    unsigned i;
-
     // Walk the switch's jump table, updating the predecessor for each branch.
-    for (i = 0; i < jumpCnt; i++)
+    for (BasicBlock* const bJump : oldSwitchBlock->SwitchTargets())
     {
-        BasicBlock* bJump = jumpTab[i];
         noway_assert(bJump != nullptr);
 
         // Note that if there are duplicate branch targets in the switch jump table,
@@ -623,7 +617,7 @@ void Compiler::fgReplacePred(BasicBlock* block, BasicBlock* oldPred, BasicBlock*
 
     bool modified = false;
 
-    for (flowList* pred = block->bbPreds; pred != nullptr; pred = pred->flNext)
+    for (flowList* const pred : block->PredEdges())
     {
         if (oldPred == pred->getBlock())
         {
@@ -659,7 +653,6 @@ BasicBlock* Compiler::fgFirstBlockOfHandler(BasicBlock* block)
 void Compiler::fgInitBBLookup()
 {
     BasicBlock** dscBBptr;
-    BasicBlock*  tmpBBdesc;
 
     /* Allocate the basic block table */
 
@@ -667,9 +660,9 @@ void Compiler::fgInitBBLookup()
 
     /* Walk all the basic blocks, filling in the table */
 
-    for (tmpBBdesc = fgFirstBB; tmpBBdesc; tmpBBdesc = tmpBBdesc->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
-        *dscBBptr++ = tmpBBdesc;
+        *dscBBptr++ = block;
     }
 
     noway_assert(dscBBptr == fgBBs + fgBBcount);
@@ -771,7 +764,7 @@ class FgStack
     }
     void PushArgument(unsigned arg)
     {
-        Push(SLOT_ARGUMENT + arg);
+        Push(static_cast<FgSlot>(SLOT_ARGUMENT + arg));
     }
     unsigned GetSlot0() const
     {
@@ -814,7 +807,7 @@ class FgStack
     }
 
 private:
-    enum
+    enum FgSlot
     {
         SLOT_INVALID  = UINT_MAX,
         SLOT_UNKNOWN  = 0,
@@ -823,7 +816,7 @@ class FgStack
         SLOT_ARGUMENT = 3
     };
 
-    void Push(int type)
+    void Push(FgSlot type)
     {
         switch (depth)
         {
@@ -840,8 +833,8 @@ class FgStack
         }
     }
 
-    unsigned slot0;
-    unsigned slot1;
+    FgSlot   slot0;
+    FgSlot   slot1;
     unsigned depth;
 };
 
@@ -878,6 +871,12 @@ void Compiler::fgFindJumpTargets(const BYTE* codeAddr, IL_OFFSET codeSize, Fixed
             compInlineResult->Note(InlineObservation::CALLSITE_IN_TRY_REGION);
         }
 
+        // Determine if the call site is in a no-return block
+        if (isInlining && (impInlineInfo->iciBlock->bbJumpKind == BBJ_THROW))
+        {
+            compInlineResult->Note(InlineObservation::CALLSITE_IN_NORETURN_REGION);
+        }
+
         // Determine if the call site is in a loop.
         if (isInlining && ((impInlineInfo->iciBlock->bbFlags & BBF_BACKWARD_JUMP) != 0))
         {
@@ -948,6 +947,32 @@ void Compiler::fgFindJumpTargets(const BYTE* codeAddr, IL_OFFSET codeSize, Fixed
                 BADCODE3("Illegal opcode", ": %02X", (int)opcode);
             }
 
+            case CEE_THROW:
+            {
+                if (makeInlineObservations)
+                {
+                    compInlineResult->Note(InlineObservation::CALLEE_THROW_BLOCK);
+                }
+                break;
+            }
+
+            case CEE_BOX:
+            {
+                if (makeInlineObservations)
+                {
+                    int toSkip = impBoxPatternMatch(nullptr, codeAddr + sz, codeEndp, true);
+                    if (toSkip > 0)
+                    {
+                        // toSkip > 0 means we most likely will hit a pattern (e.g. box+isinst+brtrue) that
+                        // will be folded into a const
+
+                        // TODO: uncomment later
+                        // codeAddr += toSkip;
+                    }
+                }
+                break;
+            }
+
             case CEE_CALL:
             case CEE_CALLVIRT:
             {
@@ -1781,7 +1806,7 @@ void Compiler::fgMarkBackwardJump(BasicBlock* targetBlock, BasicBlock* sourceBlo
 {
     noway_assert(targetBlock->bbNum <= sourceBlock->bbNum);
 
-    for (BasicBlock* block = targetBlock; block != sourceBlock->bbNext; block = block->bbNext)
+    for (BasicBlock* const block : Blocks(targetBlock, sourceBlock))
     {
         if (((block->bbFlags & BBF_BACKWARD_JUMP) == 0) && (block->bbJumpKind != BBJ_RETURN))
         {
@@ -1810,7 +1835,7 @@ void Compiler::fgLinkBasicBlocks()
 
     /* Walk all the basic blocks, filling in the target addresses */
 
-    for (BasicBlock* curBBdesc = fgFirstBB; curBBdesc; curBBdesc = curBBdesc->bbNext)
+    for (BasicBlock* const curBBdesc : Blocks())
     {
         switch (curBBdesc->bbJumpKind)
         {
@@ -2938,8 +2963,7 @@ void Compiler::fgFindBasicBlocks()
 
 #if !defined(FEATURE_EH_FUNCLETS)
 
-    EHblkDsc* HBtabEnd;
-    for (HBtab = compHndBBtab, HBtabEnd = compHndBBtab + compHndBBtabCount; HBtab < HBtabEnd; HBtab++)
+    for (EHblkDsc* const HBtab : EHClauses(this))
     {
         if (ehMaxHndNestingCount <= HBtab->ebdHandlerNestingLevel)
             ehMaxHndNestingCount = HBtab->ebdHandlerNestingLevel + 1;
@@ -2990,7 +3014,7 @@ void Compiler::fgCheckBasicBlockControlFlow()
 
     EHblkDsc* HBtab;
 
-    for (BasicBlock* blk = fgFirstBB; blk; blk = blk->bbNext)
+    for (BasicBlock* const blk : Blocks())
     {
         if (blk->bbFlags & BBF_INTERNAL)
         {
@@ -3072,18 +3096,10 @@ void Compiler::fgCheckBasicBlockControlFlow()
                 break;
 
             case BBJ_SWITCH: // block ends with a switch statement
-
-                BBswtDesc* swtDesc;
-                swtDesc = blk->bbJumpSwt;
-
-                assert(swtDesc);
-
-                unsigned i;
-                for (i = 0; i < swtDesc->bbsCount; i++)
+                for (BasicBlock* const bTarget : blk->SwitchTargets())
                 {
-                    fgControlFlowPermitted(blk, swtDesc->bbsDstTab[i]);
+                    fgControlFlowPermitted(blk, bTarget);
                 }
-
                 break;
 
             case BBJ_EHCATCHRET:  // block ends with a leave out of a catch (only #if defined(FEATURE_EH_FUNCLETS))
@@ -3473,7 +3489,7 @@ IL_OFFSET Compiler::fgFindBlockILOffset(BasicBlock* block)
     // could have a similar function for LIR that searches for GT_IL_OFFSET nodes.
     assert(!block->IsLIR());
 
-    for (Statement* stmt : block->Statements())
+    for (Statement* const stmt : block->Statements())
     {
         if (stmt->GetILOffsetX() != BAD_IL_OFFSET)
         {
@@ -3504,10 +3520,8 @@ BasicBlock* Compiler::fgSplitBlockAtEnd(BasicBlock* curr)
     // Without these arcs, a block 'b' may not be a member of succs(preds(b))
     if (curr->bbJumpKind != BBJ_SWITCH)
     {
-        unsigned numSuccs = curr->NumSucc(this);
-        for (unsigned i = 0; i < numSuccs; i++)
+        for (BasicBlock* const succ : curr->Succs(this))
         {
-            BasicBlock* succ = curr->GetSucc(i, this);
             if (succ != newBlock)
             {
                 JITDUMP(FMT_BB " previous predecessor was " FMT_BB ", now is " FMT_BB "\n", succ->bbNum, curr->bbNum,
@@ -4131,7 +4145,7 @@ void Compiler::fgRemoveBlock(BasicBlock* block, bool unreachable)
 
         fgRemoveRefPred(succBlock, block);
 
-        for (flowList* pred = block->bbPreds; pred; pred = pred->flNext)
+        for (flowList* const pred : block->PredEdges())
         {
             BasicBlock* predBlock = pred->getBlock();
 
@@ -4481,7 +4495,7 @@ bool Compiler::fgRenumberBlocks()
     //
     if (renumbered && fgComputePredsDone)
     {
-        for (block = fgFirstBB; block != nullptr; block = block->bbNext)
+        for (BasicBlock* const block : Blocks())
         {
             block->ensurePredListOrder(this);
         }
@@ -4982,7 +4996,7 @@ bool Compiler::fgMightHaveLoop()
     BitVecTraits blockVecTraits(fgBBNumMax + 1, this);
     BitVec       blocksSeen(BitVecOps::MakeEmpty(&blockVecTraits));
 
-    for (BasicBlock* block = fgFirstBB; block; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
         BitVecOps::AddElemD(&blockVecTraits, blocksSeen, block->bbNum);
 
diff --git a/src/coreclr/jit/fgdiagnostic.cpp b/src/coreclr/jit/fgdiagnostic.cpp
index f9f9d3c86b6d00..d284f075bd30d9 100644
--- a/src/coreclr/jit/fgdiagnostic.cpp
+++ b/src/coreclr/jit/fgdiagnostic.cpp
@@ -14,19 +14,15 @@
 #ifdef DEBUG
 void Compiler::fgPrintEdgeWeights()
 {
-    BasicBlock* bSrc;
-    BasicBlock* bDst;
-    flowList*   edge;
-
     // Print out all of the edge weights
-    for (bDst = fgFirstBB; bDst != nullptr; bDst = bDst->bbNext)
+    for (BasicBlock* const bDst : Blocks())
     {
         if (bDst->bbPreds != nullptr)
         {
             printf("    Edge weights into " FMT_BB " :", bDst->bbNum);
-            for (edge = bDst->bbPreds; edge != nullptr; edge = edge->flNext)
+            for (flowList* const edge : bDst->PredEdges())
             {
-                bSrc = edge->getBlock();
+                BasicBlock* bSrc = edge->getBlock();
                 // This is the control flow edge (bSrc -> bDst)
 
                 printf(FMT_BB " ", bSrc->bbNum);
@@ -845,7 +841,7 @@ bool Compiler::fgDumpFlowGraph(Phases phase, PhasePosition pos)
     unsigned  blockOrdinal = 1;
     unsigned* blkMap       = new (this, CMK_DebugOnly) unsigned[blkMapSize];
     memset(blkMap, 0, sizeof(unsigned) * blkMapSize);
-    for (BasicBlock* block = fgFirstBB; block != nullptr; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
         assert(block->bbNum < blkMapSize);
         blkMap[block->bbNum] = blockOrdinal++;
@@ -989,8 +985,7 @@ bool Compiler::fgDumpFlowGraph(Phases phase, PhasePosition pos)
                 targetWeightDivisor = (double)bTarget->bbWeight;
             }
 
-            flowList* edge;
-            for (edge = bTarget->bbPreds; edge != nullptr; edge = edge->flNext, edgeNum++)
+            for (flowList* const edge : bTarget->PredEdges())
             {
                 BasicBlock* bSource = edge->getBlock();
                 double      sourceWeightDivisor;
@@ -1084,6 +1079,8 @@ bool Compiler::fgDumpFlowGraph(Phases phase, PhasePosition pos)
                     fprintf(fgxFile, ">");
                     fprintf(fgxFile, "\n        </edge>");
                 }
+
+                ++edgeNum;
             }
         }
     }
@@ -1093,7 +1090,7 @@ bool Compiler::fgDumpFlowGraph(Phases phase, PhasePosition pos)
     //
     if (createDotFile)
     {
-        for (BasicBlock* bSource = fgFirstBB; bSource != nullptr; bSource = bSource->bbNext)
+        for (BasicBlock* const bSource : Blocks())
         {
             if (constrained)
             {
@@ -1115,11 +1112,8 @@ bool Compiler::fgDumpFlowGraph(Phases phase, PhasePosition pos)
 
             // Emit successor edges
             //
-            const unsigned numSuccs = bSource->NumSucc();
-
-            for (unsigned i = 0; i < numSuccs; i++)
+            for (BasicBlock* const bTarget : bSource->Succs())
             {
-                BasicBlock* const bTarget = bSource->GetSucc(i);
                 fprintf(fgxFile, "    " FMT_BB " -> " FMT_BB, bSource->bbNum, bTarget->bbNum);
                 if (blkMap[bSource->bbNum] > blkMap[bTarget->bbNum])
                 {
@@ -1696,7 +1690,7 @@ void Compiler::fgDispReach()
     printf("BBnum  Reachable by \n");
     printf("------------------------------------------------\n");
 
-    for (BasicBlock* block = fgFirstBB; block != nullptr; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
         printf(FMT_BB " : ", block->bbNum);
         BlockSetOps::Iter iter(this, block->bbReach);
@@ -2044,10 +2038,7 @@ void Compiler::fgTableDispBasicBlock(BasicBlock* block, int ibcColWidth /* = 0 *
     {
         // Output a brace for every try region that this block opens
 
-        EHblkDsc* HBtab;
-        EHblkDsc* HBtabEnd;
-
-        for (HBtab = compHndBBtab, HBtabEnd = compHndBBtab + compHndBBtabCount; HBtab < HBtabEnd; HBtab++)
+        for (EHblkDsc* const HBtab : EHClauses(this))
         {
             if (HBtab->ebdTryBeg == block)
             {
@@ -2058,10 +2049,7 @@ void Compiler::fgTableDispBasicBlock(BasicBlock* block, int ibcColWidth /* = 0 *
         }
     }
 
-    EHblkDsc* HBtab;
-    EHblkDsc* HBtabEnd;
-
-    for (HBtab = compHndBBtab, HBtabEnd = compHndBBtab + compHndBBtabCount; HBtab < HBtabEnd; HBtab++)
+    for (EHblkDsc* const HBtab : EHClauses(this))
     {
         if (HBtab->ebdTryLast == block)
         {
@@ -2242,7 +2230,7 @@ void Compiler::fgDumpBlock(BasicBlock* block)
 
     if (!block->IsLIR())
     {
-        for (Statement* stmt : block->Statements())
+        for (Statement* const stmt : block->Statements())
         {
             fgDumpStmtTree(stmt, block->bbNum);
         }
@@ -2264,7 +2252,7 @@ void Compiler::fgDumpTrees(BasicBlock* firstBlock, BasicBlock* lastBlock)
 {
     // Note that typically we have already called fgDispBasicBlocks()
     // so we don't need to print the preds and succs again here.
-    for (BasicBlock* block = firstBlock; block; block = block->bbNext)
+    for (BasicBlock* block = firstBlock; block != nullptr; block = block->bbNext)
     {
         fgDumpBlock(block);
 
@@ -2369,7 +2357,7 @@ unsigned BBPredsChecker::CheckBBPreds(BasicBlock* block, unsigned curTraversalSt
     }
 
     unsigned blockRefs = 0;
-    for (flowList* pred = block->bbPreds; pred != nullptr; pred = pred->flNext)
+    for (flowList* const pred : block->PredEdges())
     {
         blockRefs += pred->flDupCount;
 
@@ -2504,22 +2492,15 @@ bool BBPredsChecker::CheckJump(BasicBlock* blockPred, BasicBlock* block)
             break;
 
         case BBJ_SWITCH:
-        {
-            unsigned jumpCnt = blockPred->bbJumpSwt->bbsCount;
-
-            for (unsigned i = 0; i < jumpCnt; ++i)
+            for (BasicBlock* const bTarget : blockPred->SwitchTargets())
             {
-                BasicBlock* jumpTab = blockPred->bbJumpSwt->bbsDstTab[i];
-                assert(jumpTab != nullptr);
-                if (block == jumpTab)
+                if (block == bTarget)
                 {
                     return true;
                 }
             }
-
             assert(!"SWITCH in the predecessor list with no jump label to BLOCK!");
-        }
-        break;
+            break;
 
         default:
             assert(!"Unexpected bbJumpKind");
@@ -2568,7 +2549,7 @@ bool BBPredsChecker::CheckEHFinallyRet(BasicBlock* blockPred, BasicBlock* block)
         // we find a potential 'hit' we check if the funclet we're looking at is
         // from the correct try region.
 
-        for (BasicBlock* bcall = comp->fgFirstFuncletBB; bcall != nullptr; bcall = bcall->bbNext)
+        for (BasicBlock* const bcall : comp->Blocks(comp->fgFirstFuncletBB))
         {
             if (bcall->bbJumpKind != BBJ_CALLFINALLY || bcall->bbJumpDest != finBeg)
             {
@@ -2646,12 +2627,12 @@ void Compiler::fgDebugCheckBBlist(bool checkBBNum /* = false */, bool checkBBRef
     /* Check bbNum, bbRefs and bbPreds */
     // First, pick a traversal stamp, and label all the blocks with it.
     unsigned curTraversalStamp = unsigned(InterlockedIncrement((LONG*)&bbTraverseLabel));
-    for (BasicBlock* block = fgFirstBB; block != nullptr; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
         block->bbTraversalStamp = curTraversalStamp;
     }
 
-    for (BasicBlock* block = fgFirstBB; block != nullptr; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
         if (checkBBNum)
         {
@@ -2737,8 +2718,7 @@ void Compiler::fgDebugCheckBBlist(bool checkBBNum /* = false */, bool checkBBRef
             {
                 // Check to see if this block is the beginning of a filter or a handler and adjust the ref count
                 // appropriately.
-                for (EHblkDsc *HBtab = compHndBBtab, *HBtabEnd = &compHndBBtab[compHndBBtabCount]; HBtab != HBtabEnd;
-                     HBtab++)
+                for (EHblkDsc* const HBtab : EHClauses(this))
                 {
                     if (HBtab->ebdHndBeg == block)
                     {
@@ -3466,7 +3446,7 @@ void Compiler::fgDebugCheckLinks(bool morphTrees)
     fgDebugCheckBlockLinks();
 
     // For each block check the links between the trees.
-    for (BasicBlock* block = fgFirstBB; block != nullptr; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
         if (block->IsLIR())
         {
@@ -3496,7 +3476,7 @@ void Compiler::fgDebugCheckLinks(bool morphTrees)
 
 void Compiler::fgDebugCheckStmtsList(BasicBlock* block, bool morphTrees)
 {
-    for (Statement* stmt : block->Statements())
+    for (Statement* const stmt : block->Statements())
     {
         // Verify that bbStmtList is threaded correctly.
         // Note that for the statements list, the GetPrevStmt() list is circular.
@@ -3560,7 +3540,7 @@ void Compiler::fgDebugCheckBlockLinks()
 {
     assert(fgFirstBB->bbPrev == nullptr);
 
-    for (BasicBlock* block = fgFirstBB; block != nullptr; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
         if (block->bbNext)
         {
@@ -3592,11 +3572,9 @@ void Compiler::fgDebugCheckBlockLinks()
                 // about the BlockSet epoch.
                 BitVecTraits bitVecTraits(fgBBNumMax + 1, this);
                 BitVec       succBlocks(BitVecOps::MakeEmpty(&bitVecTraits));
-                BasicBlock** jumpTable = block->bbJumpSwt->bbsDstTab;
-                unsigned     jumpCount = block->bbJumpSwt->bbsCount;
-                for (unsigned i = 0; i < jumpCount; i++)
+                for (BasicBlock* const bTarget : block->SwitchTargets())
                 {
-                    BitVecOps::AddElemD(&bitVecTraits, succBlocks, jumpTable[i]->bbNum);
+                    BitVecOps::AddElemD(&bitVecTraits, succBlocks, bTarget->bbNum);
                 }
                 // Now we should have a set of unique successors that matches what's in the switchMap.
                 // First, check the number of entries, then make sure all the blocks in uniqueSuccSet
@@ -3675,7 +3653,7 @@ void Compiler::fgDebugCheckNodesUniqueness()
 {
     UniquenessCheckWalker walker(this);
 
-    for (BasicBlock* block = fgFirstBB; block != nullptr; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
         if (block->IsLIR())
         {
@@ -3686,7 +3664,7 @@ void Compiler::fgDebugCheckNodesUniqueness()
         }
         else
         {
-            for (Statement* stmt : block->Statements())
+            for (Statement* const stmt : block->Statements())
             {
                 GenTree* root = stmt->GetRootNode();
                 fgWalkTreePre(&root, UniquenessCheckWalker::MarkTreeId, &walker);
@@ -3709,7 +3687,7 @@ void Compiler::fgDebugCheckLoopTable()
         assert(optLoopTable != nullptr);
     }
 
-    for (BasicBlock* block = fgFirstBB; block != nullptr; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
         if (optLoopCount == 0)
         {
diff --git a/src/coreclr/jit/fgehopt.cpp b/src/coreclr/jit/fgehopt.cpp
index 0a5e1602857404..06abf455ac2df1 100644
--- a/src/coreclr/jit/fgehopt.cpp
+++ b/src/coreclr/jit/fgehopt.cpp
@@ -102,7 +102,7 @@ PhaseStatus Compiler::fgRemoveEmptyFinally()
         // Limit for now to finallys that contain only a GT_RETFILT.
         bool isEmpty = true;
 
-        for (Statement* stmt : firstBlock->Statements())
+        for (Statement* const stmt : firstBlock->Statements())
         {
             GenTree* stmtExpr = stmt->GetRootNode();
 
@@ -197,7 +197,7 @@ PhaseStatus Compiler::fgRemoveEmptyFinally()
         BasicBlock* const lastTryBlock  = HBtab->ebdTryLast;
         assert(firstTryBlock->getTryIndex() == XTnum);
 
-        for (BasicBlock* block = firstTryBlock; block != nullptr; block = block->bbNext)
+        for (BasicBlock* const block : Blocks(firstTryBlock))
         {
             // Look for blocks directly contained in this try, and
             // update the try region appropriately.
@@ -349,7 +349,6 @@ PhaseStatus Compiler::fgRemoveEmptyTry()
         BasicBlock* const lastTryBlock      = HBtab->ebdTryLast;
         BasicBlock* const firstHandlerBlock = HBtab->ebdHndBeg;
         BasicBlock* const lastHandlerBlock  = HBtab->ebdHndLast;
-        BasicBlock* const endHandlerBlock   = lastHandlerBlock->bbNext;
 
         assert(firstTryBlock->getTryIndex() == XTnum);
 
@@ -474,7 +473,7 @@ PhaseStatus Compiler::fgRemoveEmptyTry()
         // handler region (if any) won't change.
         //
         // Kind of overkill to loop here, but hey.
-        for (BasicBlock* block = firstTryBlock; block != nullptr; block = block->bbNext)
+        for (BasicBlock* const block : Blocks(firstTryBlock))
         {
             // Look for blocks directly contained in this try, and
             // update the try region appropriately.
@@ -511,7 +510,7 @@ PhaseStatus Compiler::fgRemoveEmptyTry()
         // remove the EH table entry.  Change handler exits to jump to
         // the continuation.  Clear catch type on handler entry.
         // Decrement nesting level of enclosed GT_END_LFINs.
-        for (BasicBlock* block = firstHandlerBlock; block != endHandlerBlock; block = block->bbNext)
+        for (BasicBlock* const block : Blocks(firstHandlerBlock, lastHandlerBlock))
         {
             if (block == firstHandlerBlock)
             {
@@ -545,7 +544,7 @@ PhaseStatus Compiler::fgRemoveEmptyTry()
             // If we're in a non-funclet model, decrement the nesting
             // level of any GT_END_LFIN we find in the handler region,
             // since we're removing the enclosing handler.
-            for (Statement* stmt : block->Statements())
+            for (Statement* const stmt : block->Statements())
             {
                 GenTree* expr = stmt->GetRootNode();
                 if (expr->gtOper == GT_END_LFIN)
@@ -733,7 +732,7 @@ PhaseStatus Compiler::fgCloneFinally()
 
             // Should we compute statement cost here, or is it
             // premature...? For now just count statements I guess.
-            for (Statement* stmt : block->Statements())
+            for (Statement* const stmt : block->Statements())
             {
                 regionStmtCount++;
             }
@@ -1244,7 +1243,7 @@ PhaseStatus Compiler::fgCloneFinally()
             JITDUMP("Profile scale factor (" FMT_WT "/" FMT_WT ") => clone " FMT_WT " / original " FMT_WT "\n",
                     retargetedWeight, originalWeight, clonedScale, originalScale);
 
-            for (BasicBlock* block = firstBlock; block != lastBlock->bbNext; block = block->bbNext)
+            for (BasicBlock* const block : Blocks(firstBlock, lastBlock))
             {
                 if (block->hasProfileWeight())
                 {
@@ -1343,10 +1342,9 @@ void Compiler::fgDebugCheckTryFinallyExits()
         BasicBlock* const lastTryBlock  = HBtab->ebdTryLast;
         assert(firstTryBlock->getTryIndex() <= XTnum);
         assert(lastTryBlock->getTryIndex() <= XTnum);
-        BasicBlock* const afterTryBlock = lastTryBlock->bbNext;
-        BasicBlock* const finallyBlock  = isFinally ? HBtab->ebdHndBeg : nullptr;
+        BasicBlock* const finallyBlock = isFinally ? HBtab->ebdHndBeg : nullptr;
 
-        for (BasicBlock* block = firstTryBlock; block != afterTryBlock; block = block->bbNext)
+        for (BasicBlock* const block : Blocks(firstTryBlock, lastTryBlock))
         {
             // Only check the directly contained blocks.
             assert(block->hasTryIndex());
@@ -1357,12 +1355,8 @@ void Compiler::fgDebugCheckTryFinallyExits()
             }
 
             // Look at each of the normal control flow possibilities.
-            const unsigned numSuccs = block->NumSucc();
-
-            for (unsigned i = 0; i < numSuccs; i++)
+            for (BasicBlock* const succBlock : block->Succs())
             {
-                BasicBlock* const succBlock = block->GetSucc(i);
-
                 if (succBlock->hasTryIndex() && succBlock->getTryIndex() <= XTnum)
                 {
                     // Successor does not exit this try region.
@@ -1514,7 +1508,7 @@ void Compiler::fgCleanupContinuation(BasicBlock* continuation)
     // Remove the GT_END_LFIN from the continuation,
     // Note we only expect to see one such statement.
     bool foundEndLFin = false;
-    for (Statement* stmt : continuation->Statements())
+    for (Statement* const stmt : continuation->Statements())
     {
         GenTree* expr = stmt->GetRootNode();
         if (expr->gtOper == GT_END_LFIN)
@@ -1566,7 +1560,7 @@ void Compiler::fgClearAllFinallyTargetBits()
     // in case bits are left over from EH clauses being deleted.
 
     // Walk all blocks, and reset the target bits.
-    for (BasicBlock* block = fgFirstBB; block != nullptr; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
         block->bbFlags &= ~BBF_FINALLY_TARGET;
     }
@@ -1585,7 +1579,7 @@ void Compiler::fgAddFinallyTargetFlags()
         return;
     }
 
-    for (BasicBlock* block = fgFirstBB; block != nullptr; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
         if (block->isBBCallAlwaysPair())
         {
@@ -1682,10 +1676,8 @@ PhaseStatus Compiler::fgMergeFinallyChains()
 
     // Look for finallys.
     bool hasFinally = false;
-    for (unsigned XTnum = 0; XTnum < compHndBBtabCount; XTnum++)
+    for (EHblkDsc* const HBtab : EHClauses(this))
     {
-        EHblkDsc* const HBtab = &compHndBBtab[XTnum];
-
         // Check if this is a try/finally.
         if (HBtab->HasFinallyHandler())
         {
diff --git a/src/coreclr/jit/fgflow.cpp b/src/coreclr/jit/fgflow.cpp
index fda7f901451818..c267dc558ed688 100644
--- a/src/coreclr/jit/fgflow.cpp
+++ b/src/coreclr/jit/fgflow.cpp
@@ -29,9 +29,7 @@ flowList* Compiler::fgGetPredForBlock(BasicBlock* block, BasicBlock* blockPred)
     assert(blockPred);
     assert(!fgCheapPredsValid);
 
-    flowList* pred;
-
-    for (pred = block->bbPreds; pred != nullptr; pred = pred->flNext)
+    for (flowList* const pred : block->PredEdges())
     {
         if (blockPred == pred->getBlock())
         {
@@ -461,17 +459,11 @@ void Compiler::fgRemoveBlockAsPred(BasicBlock* block)
             break;
 
         case BBJ_SWITCH:
-        {
-            unsigned     jumpCnt = block->bbJumpSwt->bbsCount;
-            BasicBlock** jumpTab = block->bbJumpSwt->bbsDstTab;
-
-            do
+            for (BasicBlock* const bTarget : block->SwitchTargets())
             {
-                fgRemoveRefPred(*jumpTab, block);
-            } while (++jumpTab, --jumpCnt);
-
+                fgRemoveRefPred(bTarget, block);
+            }
             break;
-        }
 
         default:
             noway_assert(!"Block doesn't have a valid bbJumpKind!!!!");
@@ -499,8 +491,6 @@ void Compiler::fgComputeCheapPreds()
     noway_assert(!fgComputePredsDone); // We can't do this if we've got the full preds.
     noway_assert(fgFirstBB != nullptr);
 
-    BasicBlock* block;
-
 #ifdef DEBUG
     if (verbose)
     {
@@ -513,7 +503,7 @@ void Compiler::fgComputeCheapPreds()
     // Clear out the cheap preds lists.
     fgRemovePreds();
 
-    for (block = fgFirstBB; block != nullptr; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
         switch (block->bbJumpKind)
         {
@@ -546,16 +536,10 @@ void Compiler::fgComputeCheapPreds()
                 break;
 
             case BBJ_SWITCH:
-                unsigned jumpCnt;
-                jumpCnt = block->bbJumpSwt->bbsCount;
-                BasicBlock** jumpTab;
-                jumpTab = block->bbJumpSwt->bbsDstTab;
-
-                do
+                for (BasicBlock* const bTarget : block->SwitchTargets())
                 {
-                    fgAddCheapPred(*jumpTab, block);
-                } while (++jumpTab, --jumpCnt);
-
+                    fgAddCheapPred(bTarget, block);
+                }
                 break;
 
             case BBJ_EHFINALLYRET: // It's expensive to compute the preds for this case, so we don't for the cheap
@@ -659,7 +643,7 @@ void Compiler::fgRemovePreds()
     // and are the same size. So, this function removes both.
     static_assert_no_msg(sizeof(((BasicBlock*)nullptr)->bbPreds) == sizeof(((BasicBlock*)nullptr)->bbCheapPreds));
 
-    for (BasicBlock* block = fgFirstBB; block != nullptr; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
         block->bbPreds = nullptr;
     }
@@ -688,8 +672,6 @@ void Compiler::fgComputePreds()
 {
     noway_assert(fgFirstBB != nullptr);
 
-    BasicBlock* block;
-
 #ifdef DEBUG
     if (verbose)
     {
@@ -700,7 +682,7 @@ void Compiler::fgComputePreds()
 
     // Check that the block numbers are increasing order.
     unsigned lastBBnum = fgFirstBB->bbNum;
-    for (BasicBlock* block = fgFirstBB->bbNext; block != nullptr; block = block->bbNext)
+    for (BasicBlock* const block : Blocks(fgFirstBB->bbNext))
     {
         assert(lastBBnum < block->bbNum);
         lastBBnum = block->bbNum;
@@ -708,7 +690,7 @@ void Compiler::fgComputePreds()
 #endif // DEBUG
 
     // Reset everything pred related
-    for (BasicBlock* block = fgFirstBB; block != nullptr; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
         block->bbPreds    = nullptr;
         block->bbLastPred = nullptr;
@@ -726,7 +708,7 @@ void Compiler::fgComputePreds()
         fgEntryBB->bbRefs = 1;
     }
 
-    for (block = fgFirstBB; block; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
         switch (block->bbJumpKind)
         {
@@ -823,16 +805,10 @@ void Compiler::fgComputePreds()
                 break;
 
             case BBJ_SWITCH:
-                unsigned jumpCnt;
-                jumpCnt = block->bbJumpSwt->bbsCount;
-                BasicBlock** jumpTab;
-                jumpTab = block->bbJumpSwt->bbsDstTab;
-
-                do
+                for (BasicBlock* const bTarget : block->SwitchTargets())
                 {
-                    fgAddRefPred(*jumpTab, block, nullptr, true);
-                } while (++jumpTab, --jumpCnt);
-
+                    fgAddRefPred(bTarget, block, nullptr, true);
+                }
                 break;
 
             default:
@@ -841,10 +817,8 @@ void Compiler::fgComputePreds()
         }
     }
 
-    for (unsigned EHnum = 0; EHnum < compHndBBtabCount; EHnum++)
+    for (EHblkDsc* const ehDsc : EHClauses(this))
     {
-        EHblkDsc* ehDsc = ehGetDsc(EHnum);
-
         if (ehDsc->HasFilter())
         {
             // The first block of a filter has an artifical extra refcount.
@@ -949,11 +923,8 @@ Compiler::SwitchUniqueSuccSet Compiler::GetDescriptorForSwitch(BasicBlock* switc
 
         BitVecTraits blockVecTraits(fgBBNumMax + 1, this);
         BitVec       uniqueSuccBlocks(BitVecOps::MakeEmpty(&blockVecTraits));
-        BasicBlock** jumpTable = switchBlk->bbJumpSwt->bbsDstTab;
-        unsigned     jumpCount = switchBlk->bbJumpSwt->bbsCount;
-        for (unsigned i = 0; i < jumpCount; i++)
+        for (BasicBlock* const targ : switchBlk->SwitchTargets())
         {
-            BasicBlock* targ = jumpTable[i];
             BitVecOps::AddElemD(&blockVecTraits, uniqueSuccBlocks, targ->bbNum);
         }
         // Now we have a set of unique successors.
@@ -964,9 +935,8 @@ Compiler::SwitchUniqueSuccSet Compiler::GetDescriptorForSwitch(BasicBlock* switc
         unsigned nonDupInd = 0;
         // At this point, all unique targets are in "uniqueSuccBlocks".  As we encounter each,
         // add to nonDups, remove from "uniqueSuccBlocks".
-        for (unsigned i = 0; i < jumpCount; i++)
+        for (BasicBlock* const targ : switchBlk->SwitchTargets())
         {
-            BasicBlock* targ = jumpTable[i];
             if (BitVecOps::IsMember(&blockVecTraits, uniqueSuccBlocks, targ->bbNum))
             {
                 nonDups[nonDupInd] = targ;
@@ -990,14 +960,12 @@ void Compiler::SwitchUniqueSuccSet::UpdateTarget(CompAllocator alloc,
                                                  BasicBlock*   to)
 {
     assert(switchBlk->bbJumpKind == BBJ_SWITCH); // Precondition.
-    unsigned     jmpTabCnt = switchBlk->bbJumpSwt->bbsCount;
-    BasicBlock** jmpTab    = switchBlk->bbJumpSwt->bbsDstTab;
 
     // Is "from" still in the switch table (because it had more than one entry before?)
     bool fromStillPresent = false;
-    for (unsigned i = 0; i < jmpTabCnt; i++)
+    for (BasicBlock* const bTarget : switchBlk->SwitchTargets())
     {
-        if (jmpTab[i] == from)
+        if (bTarget == from)
         {
             fromStillPresent = true;
             break;
diff --git a/src/coreclr/jit/fginline.cpp b/src/coreclr/jit/fginline.cpp
index 06d750eb9c1a7d..29aabbaf40a902 100644
--- a/src/coreclr/jit/fginline.cpp
+++ b/src/coreclr/jit/fginline.cpp
@@ -99,30 +99,28 @@ PhaseStatus Compiler::fgInline()
                                                                         &info.compMethodInfo->args);
 #endif // DEBUG
 
-    BasicBlock* block       = fgFirstBB;
-    bool        madeChanges = false;
-    noway_assert(block != nullptr);
+    noway_assert(fgFirstBB != nullptr);
 
     // Set the root inline context on all statements
     InlineContext* rootContext = m_inlineStrategy->GetRootContext();
 
-    for (; block != nullptr; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
-        for (Statement* stmt : block->Statements())
+        for (Statement* const stmt : block->Statements())
         {
             stmt->SetInlineContext(rootContext);
         }
     }
 
-    // Reset block back to start for inlining
-    block = fgFirstBB;
+    BasicBlock* block       = fgFirstBB;
+    bool        madeChanges = false;
 
     do
     {
         // Make the current basic block address available globally
         compCurBB = block;
 
-        for (Statement* stmt : block->Statements())
+        for (Statement* const stmt : block->Statements())
         {
 
 #ifdef DEBUG
@@ -212,7 +210,7 @@ PhaseStatus Compiler::fgInline()
 
     do
     {
-        for (Statement* stmt : block->Statements())
+        for (Statement* const stmt : block->Statements())
         {
             // Call Compiler::fgDebugCheckInlineCandidates on each node
             fgWalkTreePre(stmt->GetRootNodePointer(), fgDebugCheckInlineCandidates);
@@ -731,7 +729,7 @@ Compiler::fgWalkResult Compiler::fgLateDevirtualization(GenTree** pTree, fgWalkD
             CORINFO_CONTEXT_HANDLE context                = nullptr;
             const bool             isLateDevirtualization = true;
             bool explicitTailCall = (call->AsCall()->gtCallMoreFlags & GTF_CALL_M_EXPLICIT_TAILCALL) != 0;
-            comp->impDevirtualizeCall(call, &method, &methodFlags, &context, nullptr, isLateDevirtualization,
+            comp->impDevirtualizeCall(call, nullptr, &method, &methodFlags, &context, nullptr, isLateDevirtualization,
                                       explicitTailCall);
         }
     }
@@ -1095,7 +1093,6 @@ void Compiler::fgInsertInlineeBlocks(InlineInfo* pInlineInfo)
     GenTreeCall* iciCall  = pInlineInfo->iciCall;
     Statement*   iciStmt  = pInlineInfo->iciStmt;
     BasicBlock*  iciBlock = pInlineInfo->iciBlock;
-    BasicBlock*  block;
 
     noway_assert(iciBlock->bbStmtList != nullptr);
     noway_assert(iciStmt->GetRootNode() != nullptr);
@@ -1118,9 +1115,9 @@ void Compiler::fgInsertInlineeBlocks(InlineInfo* pInlineInfo)
     // Create a new inline context and mark the inlined statements with it
     InlineContext* calleeContext = m_inlineStrategy->NewSuccess(pInlineInfo);
 
-    for (block = InlineeCompiler->fgFirstBB; block != nullptr; block = block->bbNext)
+    for (BasicBlock* const block : InlineeCompiler->Blocks())
     {
-        for (Statement* stmt : block->Statements())
+        for (Statement* const stmt : block->Statements())
         {
             stmt->SetInlineContext(calleeContext);
         }
@@ -1272,7 +1269,7 @@ void Compiler::fgInsertInlineeBlocks(InlineInfo* pInlineInfo)
     //
     // Set the try and handler index and fix the jump types of inlinee's blocks.
     //
-    for (block = InlineeCompiler->fgFirstBB; block != nullptr; block = block->bbNext)
+    for (BasicBlock* const block : InlineeCompiler->Blocks())
     {
         noway_assert(!block->hasTryIndex());
         noway_assert(!block->hasHndIndex());
diff --git a/src/coreclr/jit/fgopt.cpp b/src/coreclr/jit/fgopt.cpp
index 5f029de9a8f2b6..3b1b1739919d54 100644
--- a/src/coreclr/jit/fgopt.cpp
+++ b/src/coreclr/jit/fgopt.cpp
@@ -48,9 +48,9 @@ bool Compiler::fgDominate(BasicBlock* b1, BasicBlock* b2)
             return true;
         }
 
-        for (flowList* pred = b2->bbPreds; pred != nullptr; pred = pred->flNext)
+        for (BasicBlock* const predBlock : b2->PredBlocks())
         {
-            if (!fgDominate(b1, pred->getBlock()))
+            if (!fgDominate(b1, predBlock))
             {
                 return false;
             }
@@ -132,9 +132,9 @@ bool Compiler::fgReachable(BasicBlock* b1, BasicBlock* b2)
             return true;
         }
 
-        for (flowList* pred = b2->bbPreds; pred != nullptr; pred = pred->flNext)
+        for (BasicBlock* const predBlock : b2->PredBlocks())
         {
-            if (fgReachable(b1, pred->getBlock()))
+            if (fgReachable(b1, predBlock))
             {
                 return true;
             }
@@ -220,9 +220,7 @@ void Compiler::fgComputeReachabilitySets()
     fgReachabilitySetsValid = false;
 #endif // DEBUG
 
-    BasicBlock* block;
-
-    for (block = fgFirstBB; block != nullptr; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
         // Initialize the per-block bbReach sets. It creates a new empty set,
         // because the block epoch could change since the previous initialization
@@ -241,16 +239,14 @@ void Compiler::fgComputeReachabilitySets()
     {
         change = false;
 
-        for (block = fgFirstBB; block != nullptr; block = block->bbNext)
+        for (BasicBlock* const block : Blocks())
         {
             BlockSetOps::Assign(this, newReach, block->bbReach);
 
             bool predGcSafe = (block->bbPreds != nullptr); // Do all of our predecessor blocks have a GC safe bit?
 
-            for (flowList* pred = block->bbPreds; pred != nullptr; pred = pred->flNext)
+            for (BasicBlock* const predBlock : block->PredBlocks())
             {
-                BasicBlock* predBlock = pred->getBlock();
-
                 /* Union the predecessor's reachability set into newReach */
                 BlockSetOps::UnionD(this, newReach, predBlock->bbReach);
 
@@ -308,9 +304,7 @@ void Compiler::fgComputeEnterBlocksSet()
     if (compHndBBtabCount > 0)
     {
         /* Also 'or' in the handler basic blocks */
-        EHblkDsc* HBtab;
-        EHblkDsc* HBtabEnd;
-        for (HBtab = compHndBBtab, HBtabEnd = compHndBBtab + compHndBBtabCount; HBtab < HBtabEnd; HBtab++)
+        for (EHblkDsc* const HBtab : EHClauses(this))
         {
             if (HBtab->HasFilter())
             {
@@ -325,7 +319,7 @@ void Compiler::fgComputeEnterBlocksSet()
     // to the enter blocks is a bit of a compromise, because sometimes the blocks are already reachable,
     // and it messes up DFS ordering to have them marked as enter block. We should prevent the
     // creation of retless calls some other way.
-    for (BasicBlock* block = fgFirstBB; block != nullptr; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
         if (block->bbJumpKind == BBJ_CALLFINALLY)
         {
@@ -380,12 +374,11 @@ bool Compiler::fgRemoveUnreachableBlocks()
     assert(!fgCheapPredsValid);
     assert(fgReachabilitySetsValid);
 
-    bool        hasLoops             = false;
-    bool        hasUnreachableBlocks = false;
-    BasicBlock* block;
+    bool hasLoops             = false;
+    bool hasUnreachableBlocks = false;
 
     /* Record unreachable blocks */
-    for (block = fgFirstBB; block != nullptr; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
         /* Internal throw blocks are also reachable */
         if (fgIsThrowHlpBlk(block))
@@ -458,9 +451,8 @@ bool Compiler::fgRemoveUnreachableBlocks()
         // Set BBF_LOOP_HEAD if we have backwards branches to this block.
 
         unsigned blockNum = block->bbNum;
-        for (flowList* pred = block->bbPreds; pred != nullptr; pred = pred->flNext)
+        for (BasicBlock* const predBlock : block->PredBlocks())
         {
-            BasicBlock* predBlock = pred->getBlock();
             if (blockNum <= predBlock->bbNum)
             {
                 if (predBlock->bbJumpKind == BBJ_CALLFINALLY)
@@ -486,7 +478,7 @@ bool Compiler::fgRemoveUnreachableBlocks()
     if (hasUnreachableBlocks)
     {
         // Now remove the unreachable blocks
-        for (block = fgFirstBB; block != nullptr; block = block->bbNext)
+        for (BasicBlock* block = fgFirstBB; block != nullptr; block = block->bbNext)
         {
             //  If we mark the block with BBF_REMOVED then
             //  we need to call fgRemovedBlock() on it
@@ -541,7 +533,7 @@ void Compiler::fgComputeReachability()
     /* Create a list of all BBJ_RETURN blocks. The head of the list is 'fgReturnBlocks'. */
     fgReturnBlocks = nullptr;
 
-    for (BasicBlock* block = fgFirstBB; block != nullptr; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
         // If this is a BBJ_RETURN block, add it to our list of all BBJ_RETURN blocks. This list is only
         // used to find return blocks.
@@ -660,7 +652,7 @@ void Compiler::fgDfsInvPostOrder()
 
     // Call the flowgraph DFS traversal helper.
     unsigned postIndex = 1;
-    for (BasicBlock* block = fgFirstBB; block != nullptr; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
         // If the block has no predecessors, and we haven't already visited it (because it's in fgEnterBlks but also
         // reachable from the first block), go ahead and traverse starting from this block.
@@ -699,17 +691,12 @@ void Compiler::fgDfsInvPostOrder()
 //
 BlockSet_ValRet_T Compiler::fgDomFindStartNodes()
 {
-    unsigned    j;
-    BasicBlock* block;
-
     BlockSet startNodes(BlockSetOps::MakeFull(this));
 
-    for (block = fgFirstBB; block != nullptr; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
-        unsigned cSucc = block->NumSucc(this);
-        for (j = 0; j < cSucc; ++j)
+        for (BasicBlock* const succ : block->Succs(this))
         {
-            BasicBlock* succ = block->GetSucc(j, this);
             BlockSetOps::RemoveElemD(this, startNodes, succ->bbNum);
         }
     }
@@ -773,11 +760,8 @@ void Compiler::fgDfsInvPostOrderHelper(BasicBlock* block, BlockSet& visited, uns
             // pre and post actions are processed.
             stack.Push(DfsBlockEntry(DSS_Post, currentBlock));
 
-            unsigned cSucc = currentBlock->NumSucc(this);
-            for (unsigned j = 0; j < cSucc; ++j)
+            for (BasicBlock* const succ : currentBlock->Succs(this))
             {
-                BasicBlock* succ = currentBlock->GetSucc(j, this);
-
                 // If this is a node we haven't seen before, go ahead and process
                 if (!BlockSetOps::IsMember(this, visited, succ->bbNum))
                 {
@@ -894,9 +878,7 @@ void Compiler::fgComputeDoms()
     // Mark the EH blocks as entry blocks and also flag them as processed.
     if (compHndBBtabCount > 0)
     {
-        EHblkDsc* HBtab;
-        EHblkDsc* HBtabEnd;
-        for (HBtab = compHndBBtab, HBtabEnd = compHndBBtab + compHndBBtabCount; HBtab < HBtabEnd; HBtab++)
+        for (EHblkDsc* const HBtab : EHClauses(this))
         {
             if (HBtab->HasFilter())
             {
@@ -973,7 +955,7 @@ void Compiler::fgComputeDoms()
     // As stated before, once we have computed immediate dominance we need to clear
     // all the basic blocks whose predecessor list was set to flRoot.  This
     // reverts that and leaves the blocks the same as before.
-    for (block = fgFirstBB; block != nullptr; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
         if (block->bbPreds == &flRoot)
         {
@@ -1037,7 +1019,7 @@ DomTreeNode* Compiler::fgBuildDomTree()
 
     // Traverse the entire block list to build the dominator tree. Skip fgFirstBB
     // as it is always a root of the dominator forest.
-    for (BasicBlock* block = fgFirstBB->bbNext; block != nullptr; block = block->bbNext)
+    for (BasicBlock* const block : Blocks(fgFirstBB->bbNext))
     {
         BasicBlock* parent = block->bbIDom;
 
@@ -1231,7 +1213,7 @@ BlockSet_ValRet_T Compiler::fgGetDominatorSet(BasicBlock* block)
 //
 void Compiler::fgInitBlockVarSets()
 {
-    for (BasicBlock* block = fgFirstBB; block != nullptr; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
         block->InitVarSets(this);
     }
@@ -1568,9 +1550,9 @@ bool Compiler::fgCanCompactBlocks(BasicBlock* block, BasicBlock* bNext)
 
     // If there is a switch predecessor don't bother because we'd have to update the uniquesuccs as well
     // (if they are valid).
-    for (flowList* pred = bNext->bbPreds; pred != nullptr; pred = pred->flNext)
+    for (BasicBlock* const predBlock : bNext->PredBlocks())
     {
-        if (pred->getBlock()->bbJumpKind == BBJ_SWITCH)
+        if (predBlock->bbJumpKind == BBJ_SWITCH)
         {
             return false;
         }
@@ -1628,13 +1610,13 @@ void Compiler::fgCompactBlocks(BasicBlock* block, BasicBlock* bNext)
         JITDUMP("Second block has multiple incoming edges\n");
 
         assert(block->isEmpty());
-        for (flowList* pred = bNext->bbPreds; pred; pred = pred->flNext)
+        for (BasicBlock* const predBlock : bNext->PredBlocks())
         {
-            fgReplaceJumpTarget(pred->getBlock(), block, bNext);
+            fgReplaceJumpTarget(predBlock, block, bNext);
 
-            if (pred->getBlock() != block)
+            if (predBlock != block)
             {
-                fgAddRefPred(block, pred->getBlock());
+                fgAddRefPred(block, predBlock);
             }
         }
         bNext->bbPreds = nullptr;
@@ -1999,7 +1981,7 @@ void Compiler::fgCompactBlocks(BasicBlock* block, BasicBlock* bNext)
         // and we avoid most of the work if pred lists are already in order,
         // we'll just ensure everything is properly ordered.
         //
-        for (BasicBlock* checkBlock = fgFirstBB; checkBlock != nullptr; checkBlock = checkBlock->bbNext)
+        for (BasicBlock* const checkBlock : Blocks())
         {
             checkBlock->ensurePredListOrder(this);
         }
@@ -2154,7 +2136,7 @@ void Compiler::fgUnreachableBlock(BasicBlock* block)
             block->bbStmtList = firstNonPhi;
         }
 
-        for (Statement* stmt : block->Statements())
+        for (Statement* const stmt : block->Statements())
         {
             fgRemoveStmt(block, stmt);
         }
@@ -2557,11 +2539,11 @@ bool Compiler::fgOptimizeEmptyBlock(BasicBlock* block)
                     // EH regions. Is this a case where they can't be merged?
 
                     bool okToMerge = true; // assume it's ok
-                    for (flowList* pred = block->bbPreds; pred; pred = pred->flNext)
+                    for (BasicBlock* const predBlock : block->PredBlocks())
                     {
-                        if (pred->getBlock()->bbJumpKind == BBJ_EHCATCHRET)
+                        if (predBlock->bbJumpKind == BBJ_EHCATCHRET)
                         {
-                            assert(pred->getBlock()->bbJumpDest == block);
+                            assert(predBlock->bbJumpDest == block);
                             okToMerge = false; // we can't get rid of the empty block
                             break;
                         }
@@ -3466,7 +3448,7 @@ bool Compiler::fgOptimizeBranch(BasicBlock* bJump)
     assert(!bDest->IsLIR());
 
     unsigned estDupCostSz = 0;
-    for (Statement* stmt : bDest->Statements())
+    for (Statement* const stmt : bDest->Statements())
     {
         // We want to compute the costs of the statement. Unfortunately, gtPrepareCost() / gtSetStmtInfo()
         // call gtSetEvalOrder(), which can reorder nodes. If it does so, we need to re-thread the gtNext/gtPrev
@@ -3576,7 +3558,7 @@ bool Compiler::fgOptimizeBranch(BasicBlock* bJump)
 
     /* Visit all the statements in bDest */
 
-    for (Statement* curStmt : bDest->Statements())
+    for (Statement* const curStmt : bDest->Statements())
     {
         // Clone/substitute the expression.
         Statement* stmt = gtCloneStmt(curStmt);
@@ -3730,7 +3712,7 @@ bool Compiler::fgOptimizeSwitchJumps()
 
     bool modified = false;
 
-    for (BasicBlock* block = fgFirstBB; block != NULL; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
         // Lowering expands switches, so calling this method on lowered IR
         // does not make sense.
@@ -4087,10 +4069,10 @@ bool Compiler::fgExpandRarelyRunBlocks()
             bool rare = true;
 
             /* Make sure that block has at least one normal predecessor */
-            for (flowList* pred = block->bbPreds; pred != nullptr; pred = pred->flNext)
+            for (BasicBlock* const predBlock : block->PredBlocks())
             {
                 /* Find the fall through predecessor, if any */
-                if (!pred->getBlock()->isRunRarely())
+                if (!predBlock->isRunRarely())
                 {
                     rare = false;
                     break;
@@ -4354,7 +4336,7 @@ bool Compiler::fgReorderBlocks()
                             noway_assert(edgeFromPrev != nullptr);
 
                             // Examine all of the other edges into bDest
-                            for (flowList* edge = bDest->bbPreds; edge != nullptr; edge = edge->flNext)
+                            for (flowList* const edge : bDest->PredEdges())
                             {
                                 if (edge != edgeFromPrev)
                                 {
@@ -4374,11 +4356,9 @@ bool Compiler::fgReorderBlocks()
                             //
 
                             // Examine all of the other edges into bDest
-                            for (flowList* edge = bDest->bbPreds; edge != nullptr; edge = edge->flNext)
+                            for (BasicBlock* const predBlock : bDest->PredBlocks())
                             {
-                                BasicBlock* bTemp = edge->getBlock();
-
-                                if ((bTemp != bPrev) && (bTemp->bbWeight >= bPrev->bbWeight))
+                                if ((predBlock != bPrev) && (predBlock->bbWeight >= bPrev->bbWeight))
                                 {
                                     moveDestUp = false;
                                     break;
@@ -5704,11 +5684,7 @@ bool Compiler::fgUpdateFlowGraph(bool doTailDuplication)
                         // we will need to update ebdTryLast or ebdHndLast.
                         //
 
-                        EHblkDsc* HBtab;
-                        EHblkDsc* HBtabEnd;
-
-                        for (HBtab = compHndBBtab, HBtabEnd = compHndBBtab + compHndBBtabCount; HBtab < HBtabEnd;
-                             HBtab++)
+                        for (EHblkDsc* const HBtab : EHClauses(this))
                         {
                             if ((HBtab->ebdTryLast == bNext) || (HBtab->ebdHndLast == bNext))
                             {
@@ -5888,7 +5864,7 @@ bool Compiler::fgUpdateFlowGraph(bool doTailDuplication)
 
     if (compRationalIRForm)
     {
-        for (BasicBlock* block = fgFirstBB; block != nullptr; block = block->bbNext)
+        for (BasicBlock* const block : Blocks())
         {
             LIR::AsRange(block).CheckLIR(this);
         }
@@ -5952,7 +5928,7 @@ unsigned Compiler::fgGetCodeEstimate(BasicBlock* block)
             break;
     }
 
-    for (Statement* stmt : StatementList(block->FirstNonPhiDef()))
+    for (Statement* const stmt : block->NonPhiStatements())
     {
         unsigned char cost = stmt->GetCostSz();
         costSz += cost;
@@ -5970,11 +5946,11 @@ unsigned Compiler::fgMeasureIR()
 {
     unsigned nodeCount = 0;
 
-    for (BasicBlock* block = fgFirstBB; block != nullptr; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
         if (!block->IsLIR())
         {
-            for (Statement* stmt : block->Statements())
+            for (Statement* const stmt : block->Statements())
             {
                 fgWalkTreePre(stmt->GetRootNodePointer(),
                               [](GenTree** slot, fgWalkData* data) -> Compiler::fgWalkResult {
diff --git a/src/coreclr/jit/fgprofile.cpp b/src/coreclr/jit/fgprofile.cpp
index 1039d303a0d2e3..1659b2d3905293 100644
--- a/src/coreclr/jit/fgprofile.cpp
+++ b/src/coreclr/jit/fgprofile.cpp
@@ -131,9 +131,9 @@ void Compiler::fgApplyProfileScale()
             calleeWeight, scale);
     JITDUMP("Scaling inlinee blocks\n");
 
-    for (BasicBlock* bb = fgFirstBB; bb != nullptr; bb = bb->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
-        bb->scaleBBWeight(scale);
+        block->scaleBBWeight(scale);
     }
 }
 
@@ -314,7 +314,7 @@ void BlockCountInstrumentor::Prepare(bool preImport)
 #ifdef DEBUG
     // Set schema index to invalid value
     //
-    for (BasicBlock* block = m_comp->fgFirstBB; (block != nullptr); block = block->bbNext)
+    for (BasicBlock* const block : m_comp->Blocks())
     {
         block->bbCountSchemaIndex = -1;
     }
@@ -563,10 +563,7 @@ void Compiler::WalkSpanningTree(SpanningTreeVisitor* visitor)
     //
     if (!compIsForInlining())
     {
-        EHblkDsc* HBtab = compHndBBtab;
-        unsigned  XTnum = 0;
-
-        for (; XTnum < compHndBBtabCount; XTnum++, HBtab++)
+        for (EHblkDsc* const HBtab : EHClauses(this))
         {
             BasicBlock* hndBegBB = HBtab->ebdHndBeg;
             stack.Push(hndBegBB);
@@ -1125,11 +1122,14 @@ void EfficientEdgeCountInstrumentor::Instrument(BasicBlock* block, Schema& schem
 #ifdef DEBUG
                 // Verify the edge still exists.
                 //
-                const unsigned numSucc = block->NumSucc(comp);
-                bool           found   = false;
-                for (unsigned i = 0; i < numSucc && !found; i++)
+                bool found = false;
+                for (BasicBlock* const succ : block->Succs(comp))
                 {
-                    found = (target == block->GetSucc(i, comp));
+                    if (target == succ)
+                    {
+                        found = true;
+                        break;
+                    }
                 }
                 assert(found);
 #endif
@@ -1391,7 +1391,7 @@ void ClassProbeInstrumentor::Prepare(bool isPreImport)
 #ifdef DEBUG
     // Set schema index to invalid value
     //
-    for (BasicBlock* block = m_comp->fgFirstBB; (block != nullptr); block = block->bbNext)
+    for (BasicBlock* const block : m_comp->Blocks())
     {
         block->bbClassSchemaIndex = -1;
     }
@@ -1420,7 +1420,7 @@ void ClassProbeInstrumentor::BuildSchemaElements(BasicBlock* block, Schema& sche
     //
     BuildClassProbeSchemaGen                    schemaGen(schema, m_schemaCount);
     ClassProbeVisitor<BuildClassProbeSchemaGen> visitor(m_comp, schemaGen);
-    for (Statement* stmt : block->Statements())
+    for (Statement* const stmt : block->Statements())
     {
         visitor.WalkTree(stmt->GetRootNodePointer(), nullptr);
     }
@@ -1453,7 +1453,7 @@ void ClassProbeInstrumentor::Instrument(BasicBlock* block, Schema& schema, BYTE*
 
     ClassProbeInserter                    insertProbes(schema, profileMemory, &classSchemaIndex, m_instrCount);
     ClassProbeVisitor<ClassProbeInserter> visitor(m_comp, insertProbes);
-    for (Statement* stmt : block->Statements())
+    for (Statement* const stmt : block->Statements())
     {
         visitor.WalkTree(stmt->GetRootNodePointer(), nullptr);
     }
@@ -1474,14 +1474,14 @@ void ClassProbeInstrumentor::SuppressProbes()
     SuppressProbesFunctor                    suppressProbes(cleanupCount);
     ClassProbeVisitor<SuppressProbesFunctor> visitor(m_comp, suppressProbes);
 
-    for (BasicBlock* block = m_comp->fgFirstBB; (block != nullptr); block = block->bbNext)
+    for (BasicBlock* const block : m_comp->Blocks())
     {
         if ((block->bbFlags & BBF_HAS_CLASS_PROFILE) == 0)
         {
             continue;
         }
 
-        for (Statement* stmt : block->Statements())
+        for (Statement* const stmt : block->Statements())
         {
             visitor.WalkTree(stmt->GetRootNodePointer(), nullptr);
         }
@@ -1589,7 +1589,7 @@ PhaseStatus Compiler::fgInstrumentMethod()
     // Walk the flow graph to build up the instrumentation schema.
     //
     Schema schema(getAllocator(CMK_Pgo));
-    for (BasicBlock* block = fgFirstBB; (block != nullptr); block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
         if (fgCountInstrumentor->ShouldProcess(block))
         {
@@ -1670,7 +1670,7 @@ PhaseStatus Compiler::fgInstrumentMethod()
 
     // Add the instrumentation code
     //
-    for (BasicBlock* block = fgFirstBB; (block != nullptr); block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
         if (fgCountInstrumentor->ShouldProcess(block))
         {
@@ -1852,7 +1852,7 @@ void Compiler::fgSetProfileWeight(BasicBlock* block, BasicBlock::weight_t profil
 //
 void Compiler::fgIncorporateBlockCounts()
 {
-    for (BasicBlock* block = fgFirstBB; block != nullptr; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
         BasicBlock::weight_t profileWeight;
 
@@ -2172,7 +2172,7 @@ void EfficientEdgeCountReconstructor::Prepare()
 {
     // Create per-block info, and set up the key to block map.
     //
-    for (BasicBlock* block = m_comp->fgFirstBB; (block != nullptr); block = block->bbNext)
+    for (BasicBlock* const block : m_comp->Blocks())
     {
         m_keyToBlockMap.Set(BlockToKey(block), block);
         BlockInfo* const info = new (m_allocator) BlockInfo();
@@ -2536,7 +2536,7 @@ void EfficientEdgeCountReconstructor::Propagate()
 
     // Set weight on all blocks.
     //
-    for (BasicBlock* block = m_comp->fgFirstBB; (block != nullptr); block = block->bbNext)
+    for (BasicBlock* const block : m_comp->Blocks())
     {
         BlockInfo* const info = BlockToInfo(block);
         assert(info->m_weightKnown);
@@ -3222,7 +3222,6 @@ void Compiler::fgComputeEdgeWeights()
 
     BasicBlock*          bSrc;
     BasicBlock*          bDst;
-    flowList*            edge;
     BasicBlock::weight_t slop;
     unsigned             goodEdgeCountCurrent     = 0;
     unsigned             goodEdgeCountPrevious    = 0;
@@ -3247,7 +3246,7 @@ void Compiler::fgComputeEdgeWeights()
             bDstWeight -= fgCalledCount;
         }
 
-        for (edge = bDst->bbPreds; edge != nullptr; edge = edge->flNext)
+        for (flowList* const edge : bDst->PredEdges())
         {
             bool assignOK = true;
 
@@ -3327,7 +3326,7 @@ void Compiler::fgComputeEdgeWeights()
         JITDUMP("\n -- step 1 --\n");
         for (bDst = fgFirstBB; bDst != nullptr; bDst = bDst->bbNext)
         {
-            for (edge = bDst->bbPreds; edge != nullptr; edge = edge->flNext)
+            for (flowList* const edge : bDst->PredEdges())
             {
                 bool assignOK = true;
 
@@ -3432,11 +3431,8 @@ void Compiler::fgComputeEdgeWeights()
                 BasicBlock::weight_t maxEdgeWeightSum = 0;
 
                 // Calculate the sums of the minimum and maximum edge weights
-                for (edge = bDst->bbPreds; edge != nullptr; edge = edge->flNext)
+                for (flowList* const edge : bDst->PredEdges())
                 {
-                    // We are processing the control flow edge (bSrc -> bDst)
-                    bSrc = edge->getBlock();
-
                     maxEdgeWeightSum += edge->edgeWeightMax();
                     minEdgeWeightSum += edge->edgeWeightMin();
                 }
@@ -3444,7 +3440,7 @@ void Compiler::fgComputeEdgeWeights()
                 // maxEdgeWeightSum is the sum of all flEdgeWeightMax values into bDst
                 // minEdgeWeightSum is the sum of all flEdgeWeightMin values into bDst
 
-                for (edge = bDst->bbPreds; edge != nullptr; edge = edge->flNext)
+                for (flowList* const edge : bDst->PredEdges())
                 {
                     bool assignOK = true;
 
@@ -3567,14 +3563,13 @@ EARLY_EXIT:;
 
     // See if any edge weight are expressed in [min..max] form
 
-    for (bDst = fgFirstBB; bDst != nullptr; bDst = bDst->bbNext)
+    for (BasicBlock* const bDst : Blocks())
     {
         if (bDst->bbPreds != nullptr)
         {
-            for (edge = bDst->bbPreds; edge != nullptr; edge = edge->flNext)
+            for (flowList* const edge : bDst->PredEdges())
             {
-                bSrc = edge->getBlock();
-                // This is the control flow edge (bSrc -> bDst)
+                // This is the control flow edge (edge->getBlock() -> bDst)
 
                 if (edge->edgeWeightMin() != edge->edgeWeightMax())
                 {
@@ -3666,7 +3661,7 @@ void Compiler::fgDebugCheckProfileData()
 
     // Verify each profiled block.
     //
-    for (BasicBlock* block = fgFirstBB; block != nullptr; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
         if (!block->hasProfileWeight())
         {
@@ -3801,7 +3796,7 @@ bool Compiler::fgDebugCheckIncomingProfileData(BasicBlock* block)
     BasicBlock::weight_t       incomingWeightMax = 0;
     bool                       foundPreds        = false;
 
-    for (flowList* predEdge = block->bbPreds; predEdge != nullptr; predEdge = predEdge->flNext)
+    for (flowList* const predEdge : block->PredEdges())
     {
         incomingWeightMin += predEdge->edgeWeightMin();
         incomingWeightMax += predEdge->edgeWeightMax();
@@ -3883,16 +3878,7 @@ bool Compiler::fgDebugCheckOutgoingProfileData(BasicBlock* block)
     for (unsigned i = 0; i < numSuccs; i++)
     {
         BasicBlock* succBlock = block->GetSucc(i, this);
-        flowList*   succEdge  = nullptr;
-
-        for (flowList* edge = succBlock->bbPreds; edge != nullptr; edge = edge->flNext)
-        {
-            if (edge->getBlock() == block)
-            {
-                succEdge = edge;
-                break;
-            }
-        }
+        flowList*   succEdge  = fgGetPredForBlock(succBlock, block);
 
         if (succEdge == nullptr)
         {
diff --git a/src/coreclr/jit/flowgraph.cpp b/src/coreclr/jit/flowgraph.cpp
index a76cc93dc40cbf..e7a281cdecaa18 100644
--- a/src/coreclr/jit/flowgraph.cpp
+++ b/src/coreclr/jit/flowgraph.cpp
@@ -25,11 +25,11 @@
 static bool blockNeedsGCPoll(BasicBlock* block)
 {
     bool blockMayNeedGCPoll = false;
-    for (Statement* stmt = block->FirstNonPhiDef(); stmt != nullptr; stmt = stmt->GetNextStmt())
+    for (Statement* const stmt : block->NonPhiStatements())
     {
         if ((stmt->GetRootNode()->gtFlags & GTF_CALL) != 0)
         {
-            for (GenTree* tree = stmt->GetTreeList(); tree != nullptr; tree = tree->gtNext)
+            for (GenTree* const tree : stmt->TreeList())
             {
                 if (tree->OperGet() == GT_CALL)
                 {
@@ -91,7 +91,7 @@ PhaseStatus Compiler::fgInsertGCPolls()
     BasicBlock* block;
 
     // Walk through the blocks and hunt for a block that needs a GC Poll
-    for (block = fgFirstBB; block; block = block->bbNext)
+    for (block = fgFirstBB; block != nullptr; block = block->bbNext)
     {
         // When optimizations are enabled, we can't rely on BBF_HAS_SUPPRESSGC_CALL flag:
         // the call could've been moved, e.g., hoisted from a loop, CSE'd, etc.
@@ -629,7 +629,7 @@ PhaseStatus Compiler::fgImport()
     // Note this includes (to some extent) the impact of importer folded
     // branches, provided the folded tree covered the entire block's IL.
     unsigned importedILSize = 0;
-    for (BasicBlock* block = fgFirstBB; block != nullptr; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
         if ((block->bbFlags & BBF_IMPORTED) != 0)
         {
@@ -1395,8 +1395,6 @@ inline void Compiler::fgLoopCallTest(BasicBlock* srcBB, BasicBlock* dstBB)
 
 void Compiler::fgLoopCallMark()
 {
-    BasicBlock* block;
-
     /* If we've already marked all the block, bail */
 
     if (fgLoopCallMarked)
@@ -1408,7 +1406,7 @@ void Compiler::fgLoopCallMark()
 
     /* Walk the blocks, looking for backward edges */
 
-    for (block = fgFirstBB; block; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
         switch (block->bbJumpKind)
         {
@@ -1420,17 +1418,10 @@ void Compiler::fgLoopCallMark()
                 break;
 
             case BBJ_SWITCH:
-
-                unsigned jumpCnt;
-                jumpCnt = block->bbJumpSwt->bbsCount;
-                BasicBlock** jumpPtr;
-                jumpPtr = block->bbJumpSwt->bbsDstTab;
-
-                do
+                for (BasicBlock* const bTarget : block->SwitchTargets())
                 {
-                    fgLoopCallTest(block, *jumpPtr);
-                } while (++jumpPtr, --jumpCnt);
-
+                    fgLoopCallTest(block, bTarget);
+                }
                 break;
 
             default:
@@ -1849,7 +1840,7 @@ void Compiler::fgAddSyncMethodEnterExit()
     fgCreateMonitorTree(lvaMonAcquired, lvaCopyThis, faultBB, false /*exit*/);
 
     // non-exceptional cases
-    for (BasicBlock* block = fgFirstBB; block != nullptr; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
         if (block->bbJumpKind == BBJ_RETURN)
         {
@@ -2091,7 +2082,7 @@ bool Compiler::fgMoreThanOneReturnBlock()
 {
     unsigned retCnt = 0;
 
-    for (BasicBlock* block = fgFirstBB; block; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
         if (block->bbJumpKind == BBJ_RETURN)
         {
@@ -2920,10 +2911,10 @@ void Compiler::fgFindOperOrder()
     /* Walk the basic blocks and for each statement determine
      * the evaluation order, cost, FP levels, etc... */
 
-    for (BasicBlock* block = fgFirstBB; block; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
         compCurBB = block;
-        for (Statement* stmt : block->Statements())
+        for (Statement* const stmt : block->Statements())
         {
             /* Recursively process the statement */
 
@@ -2953,7 +2944,7 @@ void Compiler::fgSimpleLowering()
     unsigned outgoingArgSpaceSize = 0;
 #endif // FEATURE_FIXED_OUT_ARGS
 
-    for (BasicBlock* block = fgFirstBB; block; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
         // Walk the statement trees in this basic block.
         compCurBB = block; // Used in fgRngChkTarget.
@@ -3187,9 +3178,8 @@ void Compiler::fgInsertFuncletPrologBlock(BasicBlock* block)
     // the handler go to the prolog. Edges coming from with the handler are back-edges, and
     // go to the existing 'block'.
 
-    for (flowList* pred = block->bbPreds; pred; pred = pred->flNext)
+    for (BasicBlock* const predBlock : block->PredBlocks())
     {
-        BasicBlock* predBlock = pred->getBlock();
         if (!fgIsIntraHandlerPred(predBlock, block))
         {
             // It's a jump from outside the handler; add it to the newHead preds list and remove
@@ -3235,11 +3225,9 @@ void Compiler::fgCreateFuncletPrologBlocks()
     noway_assert(!fgDomsComputed); // this function doesn't maintain the dom sets
     assert(!fgFuncletsCreated);
 
-    bool      prologBlocksCreated = false;
-    EHblkDsc* HBtabEnd;
-    EHblkDsc* HBtab;
+    bool prologBlocksCreated = false;
 
-    for (HBtab = compHndBBtab, HBtabEnd = compHndBBtab + compHndBBtabCount; HBtab < HBtabEnd; HBtab++)
+    for (EHblkDsc* const HBtab : EHClauses(this))
     {
         BasicBlock* head = HBtab->ebdHndBeg;
 
@@ -4295,7 +4283,7 @@ void Compiler::fgSetBlockOrder()
     /* If we don't compute the doms, then we never mark blocks as loops. */
     if (fgDomsComputed)
     {
-        for (BasicBlock* block = fgFirstBB; block; block = block->bbNext)
+        for (BasicBlock* const block : Blocks())
         {
             /* If this block is a loop header, mark it appropriately */
 
@@ -4310,11 +4298,7 @@ void Compiler::fgSetBlockOrder()
         /* If we don't have the dominators, use an abbreviated test for fully interruptible.  If there are
          * any back edges, check the source and destination blocks to see if they're GC Safe.  If not, then
          * go fully interruptible. */
-
-        /* XXX Mon 1/21/2008
-         * Wouldn't it be nice to have a block iterator that can do this loop?
-         */
-        for (BasicBlock* block = fgFirstBB; block; block = block->bbNext)
+        for (BasicBlock* const block : Blocks())
         {
 // true if the edge is forward, or if it is a back edge and either the source and dest are GC safe.
 #define EDGE_IS_GC_SAFE(src, dst)                                                                                      \
@@ -4329,17 +4313,10 @@ void Compiler::fgSetBlockOrder()
                     break;
 
                 case BBJ_SWITCH:
-
-                    unsigned jumpCnt;
-                    jumpCnt = block->bbJumpSwt->bbsCount;
-                    BasicBlock** jumpPtr;
-                    jumpPtr = block->bbJumpSwt->bbsDstTab;
-
-                    do
+                    for (BasicBlock* const bTarget : block->SwitchTargets())
                     {
-                        partiallyInterruptible &= EDGE_IS_GC_SAFE(block, *jumpPtr);
-                    } while (++jumpPtr, --jumpCnt);
-
+                        partiallyInterruptible &= EDGE_IS_GC_SAFE(block, bTarget);
+                    }
                     break;
 
                 default:
@@ -4363,7 +4340,7 @@ void Compiler::fgSetBlockOrder()
         }
     }
 
-    for (BasicBlock* block = fgFirstBB; block; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
 
 #if FEATURE_FASTTAILCALL
@@ -4482,7 +4459,7 @@ void Compiler::fgSetStmtSeq(Statement* stmt)
 
 void Compiler::fgSetBlockOrder(BasicBlock* block)
 {
-    for (Statement* stmt : block->Statements())
+    for (Statement* const stmt : block->Statements())
     {
         fgSetStmtSeq(stmt);
 
diff --git a/src/coreclr/jit/gcencode.cpp b/src/coreclr/jit/gcencode.cpp
index 8c5fcd65b046d5..60011aade54995 100644
--- a/src/coreclr/jit/gcencode.cpp
+++ b/src/coreclr/jit/gcencode.cpp
@@ -127,9 +127,8 @@ ReturnKind GCInfo::getReturnKind()
 void GCInfo::gcMarkFilterVarsPinned()
 {
     assert(compiler->ehAnyFunclets());
-    const EHblkDsc* endHBtab = &(compiler->compHndBBtab[compiler->compHndBBtabCount]);
 
-    for (EHblkDsc* HBtab = compiler->compHndBBtab; HBtab < endHBtab; HBtab++)
+    for (EHblkDsc* const HBtab : EHClauses(compiler))
     {
         if (HBtab->HasFilter())
         {
@@ -3907,19 +3906,22 @@ void GCInfo::gcInfoBlockHdrSave(GcInfoEncoder* gcInfoEncoder, unsigned methodSiz
                 assert(false);
         }
 
-        int offset = 0;
+        const int offset = compiler->lvaToCallerSPRelativeOffset(compiler->lvaCachedGenericContextArgOffset(),
+                                                                 compiler->isFramePointerUsed());
 
+#ifdef DEBUG
         if (compiler->opts.IsOSR())
         {
-            PatchpointInfo* ppInfo = compiler->info.compPatchpointInfo;
-            offset                 = ppInfo->GenericContextArgOffset();
-            assert(offset != -1);
-        }
-        else
-        {
-            offset = compiler->lvaToCallerSPRelativeOffset(compiler->lvaCachedGenericContextArgOffset(),
-                                                           compiler->isFramePointerUsed());
+            // Sanity check the offset vs saved patchpoint info.
+            //
+            // PP info has FP relative offset, to get to caller SP we need to
+            // subtract off 2 register slots (saved FP, saved RA).
+            //
+            const PatchpointInfo* const ppInfo    = compiler->info.compPatchpointInfo;
+            const int                   osrOffset = ppInfo->GenericContextArgOffset() - 2 * REGSIZE_BYTES;
+            assert(offset == osrOffset);
         }
+#endif
 
         gcInfoEncoderWithLog->SetGenericsInstContextStackSlot(offset, ctxtParamType);
     }
@@ -3929,30 +3931,33 @@ void GCInfo::gcInfoBlockHdrSave(GcInfoEncoder* gcInfoEncoder, unsigned methodSiz
     {
         assert(compiler->info.compThisArg != BAD_VAR_NUM);
 
-        int offset = 0;
-
         // OSR can report the root method's frame slot, if that method reported context.
+        // If not, the OSR frame will have saved the needed context.
         //
-        bool isOsrAndUsingRootFrameSlot = false;
+        bool useRootFrameSlot = true;
         if (compiler->opts.IsOSR())
         {
-            PatchpointInfo* const ppInfo = compiler->info.compPatchpointInfo;
+            const PatchpointInfo* const ppInfo = compiler->info.compPatchpointInfo;
 
-            if (ppInfo->HasKeptAliveThis())
-            {
-                offset = ppInfo->GenericContextArgOffset();
-                assert(offset != -1);
-                isOsrAndUsingRootFrameSlot = true;
-            }
+            useRootFrameSlot = ppInfo->HasKeptAliveThis();
         }
 
-        // If not OSR, or OSR but newly reporting context, use the current frame offset.
-        //
-        if (!isOsrAndUsingRootFrameSlot)
+        const int offset = compiler->lvaToCallerSPRelativeOffset(compiler->lvaCachedGenericContextArgOffset(),
+                                                                 compiler->isFramePointerUsed(), useRootFrameSlot);
+
+#ifdef DEBUG
+        if (compiler->opts.IsOSR() && useRootFrameSlot)
         {
-            offset = compiler->lvaToCallerSPRelativeOffset(compiler->lvaCachedGenericContextArgOffset(),
-                                                           compiler->isFramePointerUsed());
+            // Sanity check the offset vs saved patchpoint info.
+            //
+            // PP info has FP relative offset, to get to caller SP we need to
+            // subtract off 2 register slots (saved FP, saved RA).
+            //
+            const PatchpointInfo* const ppInfo    = compiler->info.compPatchpointInfo;
+            const int                   osrOffset = ppInfo->KeptAliveThisOffset() - 2 * REGSIZE_BYTES;
+            assert(offset == osrOffset);
         }
+#endif
 
         gcInfoEncoderWithLog->SetGenericsInstContextStackSlot(offset, GENERIC_CONTEXTPARAM_THIS);
     }
@@ -3962,22 +3967,7 @@ void GCInfo::gcInfoBlockHdrSave(GcInfoEncoder* gcInfoEncoder, unsigned methodSiz
         assert(compiler->lvaGSSecurityCookie != BAD_VAR_NUM);
 
         // The lv offset is FP-relative, and the using code expects caller-sp relative, so translate.
-        int offset = compiler->lvaGetCallerSPRelativeOffset(compiler->lvaGSSecurityCookie);
-
-        if (compiler->opts.IsOSR())
-        {
-            // The offset computed above already includes the OSR frame adjustment, plus the
-            // pop of the "pseudo return address" from the OSR frame.
-            //
-            // To get to caller-SP, we need to subtract off the original frame size and the
-            // pushed RA and RBP for that frame. But ppInfo's FpToSpDelta also accounts for the
-            // pseudo RA between the original method frame and the OSR frame. So the net adjustment
-            // is simply FpToSpDelta plus one register.
-            PatchpointInfo* ppInfo     = compiler->info.compPatchpointInfo;
-            int             adjustment = ppInfo->FpToSpDelta() + REGSIZE_BYTES;
-            offset -= adjustment;
-            JITDUMP("OSR cookie adjustment %d, final caller-SP offset %d\n", adjustment, offset);
-        }
+        const int offset = compiler->lvaGetCallerSPRelativeOffset(compiler->lvaGSSecurityCookie);
 
         // The code offset ranges assume that the GS Cookie slot is initialized in the prolog, and is valid
         // through the remainder of the method.  We will not query for the GS Cookie while we're in an epilog,
diff --git a/src/coreclr/jit/gentree.cpp b/src/coreclr/jit/gentree.cpp
index ca0ef63b174887..3596de621d664b 100644
--- a/src/coreclr/jit/gentree.cpp
+++ b/src/coreclr/jit/gentree.cpp
@@ -569,9 +569,9 @@ void GenTree::DumpNodeSizes(FILE* fp)
 
 void Compiler::fgWalkAllTreesPre(fgWalkPreFn* visitor, void* pCallBackData)
 {
-    for (BasicBlock* block = fgFirstBB; block != nullptr; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
-        for (Statement* stmt : block->Statements())
+        for (Statement* const stmt : block->Statements())
         {
             fgWalkTreePre(stmt->GetRootNodePointer(), visitor, pCallBackData);
         }
@@ -7137,8 +7137,8 @@ bool GenTreeOp::UsesDivideByConstOptimized(Compiler* comp)
         else
         {
             // If the divisor is greater or equal than 2^(N - 1) then the result is either 0 or 1
-            if (((divType == TYP_INT) && (divisorValue > (UINT32_MAX / 2))) ||
-                ((divType == TYP_LONG) && (divisorValue > (UINT64_MAX / 2))))
+            if (((divType == TYP_INT) && ((UINT32)divisorValue > (UINT32_MAX / 2))) ||
+                ((divType == TYP_LONG) && ((UINT64)divisorValue > (UINT64_MAX / 2))))
             {
                 return true;
             }
@@ -12417,7 +12417,7 @@ void Compiler::gtDispStmt(Statement* stmt, const char* msg /* = nullptr */)
 //
 void Compiler::gtDispBlockStmts(BasicBlock* block)
 {
-    for (Statement* stmt : block->Statements())
+    for (Statement* const stmt : block->Statements())
     {
         gtDispStmt(stmt);
         printf("\n");
diff --git a/src/coreclr/jit/gentree.h b/src/coreclr/jit/gentree.h
index b476837739a850..e2a5045e9069b4 100644
--- a/src/coreclr/jit/gentree.h
+++ b/src/coreclr/jit/gentree.h
@@ -5686,6 +5686,13 @@ struct GenTreeBlk : public GenTreeIndir
     bool gtBlkOpGcUnsafe;
 #endif
 
+#ifdef TARGET_XARCH
+    bool IsOnHeapAndContainsReferences()
+    {
+        return (m_layout != nullptr) && m_layout->HasGCPtr() && !Addr()->OperIsLocalAddr();
+    }
+#endif
+
     GenTreeBlk(genTreeOps oper, var_types type, GenTree* addr, ClassLayout* layout)
         : GenTreeIndir(oper, type, addr, nullptr)
         , m_layout(layout)
@@ -5946,6 +5953,58 @@ struct GenTreeILOffset : public GenTree
 #endif
 };
 
+// GenTreeList: adapter class for forward iteration of the execution order GenTree linked list
+// using range-based `for`, normally used via Statement::TreeList(), e.g.:
+//    for (GenTree* const tree : stmt->TreeList()) ...
+//
+class GenTreeList
+{
+    GenTree* m_trees;
+
+    // Forward iterator for the execution order GenTree linked list (using `gtNext` pointer).
+    //
+    class iterator
+    {
+        GenTree* m_tree;
+
+    public:
+        iterator(GenTree* tree) : m_tree(tree)
+        {
+        }
+
+        GenTree* operator*() const
+        {
+            return m_tree;
+        }
+
+        iterator& operator++()
+        {
+            m_tree = m_tree->gtNext;
+            return *this;
+        }
+
+        bool operator!=(const iterator& i) const
+        {
+            return m_tree != i.m_tree;
+        }
+    };
+
+public:
+    GenTreeList(GenTree* trees) : m_trees(trees)
+    {
+    }
+
+    iterator begin() const
+    {
+        return iterator(m_trees);
+    }
+
+    iterator end() const
+    {
+        return iterator(nullptr);
+    }
+};
+
 // We use the following format when printing the Statement number: Statement->GetID()
 // This define is used with string concatenation to put this in printf format strings  (Note that %u means unsigned int)
 #define FMT_STMT "STMT%05u"
@@ -5993,6 +6052,15 @@ struct Statement
         m_treeList = treeHead;
     }
 
+    // TreeList: convenience method for enabling range-based `for` iteration over the
+    // execution order of the GenTree linked list, e.g.:
+    //    for (GenTree* const tree : stmt->TreeList()) ...
+    //
+    GenTreeList TreeList() const
+    {
+        return GenTreeList(GetTreeList());
+    }
+
     InlineContext* GetInlineContext() const
     {
         return m_inlineContext;
@@ -6103,49 +6171,57 @@ struct Statement
     bool m_compilerAdded; // Was the statement created by optimizer?
 };
 
-class StatementIterator
+// StatementList: adapter class for forward iteration of the statement linked list using range-based `for`,
+// normally used via BasicBlock::Statements(), e.g.:
+//    for (Statement* const stmt : block->Statements()) ...
+// or:
+//    for (Statement* const stmt : block->NonPhiStatements()) ...
+//
+class StatementList
 {
-    Statement* m_stmt;
+    Statement* m_stmts;
 
-public:
-    StatementIterator(Statement* stmt) : m_stmt(stmt)
+    // Forward iterator for the statement linked list.
+    //
+    class iterator
     {
-    }
+        Statement* m_stmt;
 
-    Statement* operator*() const
-    {
-        return m_stmt;
-    }
+    public:
+        iterator(Statement* stmt) : m_stmt(stmt)
+        {
+        }
 
-    StatementIterator& operator++()
-    {
-        m_stmt = m_stmt->GetNextStmt();
-        return *this;
-    }
+        Statement* operator*() const
+        {
+            return m_stmt;
+        }
 
-    bool operator!=(const StatementIterator& i) const
-    {
-        return m_stmt != i.m_stmt;
-    }
-};
+        iterator& operator++()
+        {
+            m_stmt = m_stmt->GetNextStmt();
+            return *this;
+        }
 
-class StatementList
-{
-    Statement* m_stmts;
+        bool operator!=(const iterator& i) const
+        {
+            return m_stmt != i.m_stmt;
+        }
+    };
 
 public:
     StatementList(Statement* stmts) : m_stmts(stmts)
     {
     }
 
-    StatementIterator begin() const
+    iterator begin() const
     {
-        return StatementIterator(m_stmts);
+        return iterator(m_stmts);
     }
 
-    StatementIterator end() const
+    iterator end() const
     {
-        return StatementIterator(nullptr);
+        return iterator(nullptr);
     }
 };
 
diff --git a/src/coreclr/jit/gschecks.cpp b/src/coreclr/jit/gschecks.cpp
index 3dc60f8e12d9a8..23d02f82bd57b5 100644
--- a/src/coreclr/jit/gschecks.cpp
+++ b/src/coreclr/jit/gschecks.cpp
@@ -480,9 +480,9 @@ void Compiler::gsParamsToShadows()
         }
     };
 
-    for (BasicBlock* block = fgFirstBB; block != nullptr; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
-        for (Statement* stmt : block->Statements())
+        for (Statement* const stmt : block->Statements())
         {
             ReplaceShadowParamsVisitor replaceShadowParamsVisitor(this);
             replaceShadowParamsVisitor.WalkTree(stmt->GetRootNodePointer(), nullptr);
@@ -530,7 +530,7 @@ void Compiler::gsParamsToShadows()
     {
         // There could be more than one basic block ending with a "Jmp" type tail call.
         // We would have to insert assignments in all such blocks, just before GT_JMP stmnt.
-        for (BasicBlock* block = fgFirstBB; block; block = block->bbNext)
+        for (BasicBlock* const block : Blocks())
         {
             if (block->bbJumpKind != BBJ_RETURN)
             {
diff --git a/src/coreclr/jit/importer.cpp b/src/coreclr/jit/importer.cpp
index 4521a68735910f..fc8544f9138ba6 100644
--- a/src/coreclr/jit/importer.cpp
+++ b/src/coreclr/jit/importer.cpp
@@ -6442,7 +6442,10 @@ GenTree* Compiler::impImportLdvirtftn(GenTree*                thisPtr,
 //   pResolvedToken is known to be a value type; ref type boxing
 //   is handled in the CEE_BOX clause.
 
-int Compiler::impBoxPatternMatch(CORINFO_RESOLVED_TOKEN* pResolvedToken, const BYTE* codeAddr, const BYTE* codeEndp)
+int Compiler::impBoxPatternMatch(CORINFO_RESOLVED_TOKEN* pResolvedToken,
+                                 const BYTE*             codeAddr,
+                                 const BYTE*             codeEndp,
+                                 bool                    makeInlineObservation)
 {
     if (codeAddr >= codeEndp)
     {
@@ -6455,6 +6458,12 @@ int Compiler::impBoxPatternMatch(CORINFO_RESOLVED_TOKEN* pResolvedToken, const B
             // box + unbox.any
             if (codeAddr + 1 + sizeof(mdToken) <= codeEndp)
             {
+                if (makeInlineObservation)
+                {
+                    compInlineResult->Note(InlineObservation::CALLEE_FOLDABLE_BOX);
+                    return 1 + sizeof(mdToken);
+                }
+
                 CORINFO_RESOLVED_TOKEN unboxResolvedToken;
 
                 impResolveToken(codeAddr + 1, &unboxResolvedToken, CORINFO_TOKENKIND_Class);
@@ -6480,6 +6489,12 @@ int Compiler::impBoxPatternMatch(CORINFO_RESOLVED_TOKEN* pResolvedToken, const B
             // box + br_true/false
             if ((codeAddr + ((codeAddr[0] >= CEE_BRFALSE) ? 5 : 2)) <= codeEndp)
             {
+                if (makeInlineObservation)
+                {
+                    compInlineResult->Note(InlineObservation::CALLEE_FOLDABLE_BOX);
+                    return 0;
+                }
+
                 GenTree* const treeToBox       = impStackTop().val;
                 bool           canOptimize     = true;
                 GenTree*       treeToNullcheck = nullptr;
@@ -6542,6 +6557,12 @@ int Compiler::impBoxPatternMatch(CORINFO_RESOLVED_TOKEN* pResolvedToken, const B
                     case CEE_BRFALSE_S:
                         if ((nextCodeAddr + ((nextCodeAddr[0] >= CEE_BRFALSE) ? 5 : 2)) <= codeEndp)
                         {
+                            if (makeInlineObservation)
+                            {
+                                compInlineResult->Note(InlineObservation::CALLEE_FOLDABLE_BOX);
+                                return 1 + sizeof(mdToken);
+                            }
+
                             if (!(impStackTop().val->gtFlags & GTF_SIDE_EFFECT))
                             {
                                 CorInfoHelpFunc boxHelper = info.compCompHnd->getBoxHelper(pResolvedToken->hClass);
@@ -6618,6 +6639,12 @@ int Compiler::impBoxPatternMatch(CORINFO_RESOLVED_TOKEN* pResolvedToken, const B
                     case CEE_UNBOX_ANY:
                         if ((nextCodeAddr + 1 + sizeof(mdToken)) <= codeEndp)
                         {
+                            if (makeInlineObservation)
+                            {
+                                compInlineResult->Note(InlineObservation::CALLEE_FOLDABLE_BOX);
+                                return 2 + sizeof(mdToken) * 2;
+                            }
+
                             // See if the resolved tokens in box, isinst and unbox.any describe types that are equal.
                             CORINFO_RESOLVED_TOKEN isinstResolvedToken = {};
                             impResolveToken(codeAddr + 1, &isinstResolvedToken, CORINFO_TOKENKIND_Class);
@@ -8929,8 +8956,9 @@ var_types Compiler::impImportCall(OPCODE                  opcode,
 
             const bool isExplicitTailCall     = (tailCallFlags & PREFIX_TAILCALL_EXPLICIT) != 0;
             const bool isLateDevirtualization = false;
-            impDevirtualizeCall(call->AsCall(), &callInfo->hMethod, &callInfo->methodFlags, &callInfo->contextHandle,
-                                &exactContextHnd, isLateDevirtualization, isExplicitTailCall, rawILOffset);
+            impDevirtualizeCall(call->AsCall(), pResolvedToken, &callInfo->hMethod, &callInfo->methodFlags,
+                                &callInfo->contextHandle, &exactContextHnd, isLateDevirtualization, isExplicitTailCall,
+                                rawILOffset);
         }
 
         if (impIsThis(obj))
@@ -16258,11 +16286,25 @@ void Compiler::impImportBlockCode(BasicBlock* block)
                            "type operand incompatible with type of address");
                 }
 
-                size = info.compCompHnd->getClassSize(resolvedToken.hClass); // Size
-                op2  = gtNewIconNode(0);                                     // Value
-                op1  = impPopStack().val;                                    // Dest
-                op1  = gtNewBlockVal(op1, size);
-                op1  = gtNewBlkOpNode(op1, op2, (prefixFlags & PREFIX_VOLATILE) != 0, false);
+                op2 = gtNewIconNode(0);  // Value
+                op1 = impPopStack().val; // Dest
+
+                if (eeIsValueClass(resolvedToken.hClass))
+                {
+                    op1 = gtNewStructVal(resolvedToken.hClass, op1);
+                    if (op1->OperIs(GT_OBJ))
+                    {
+                        gtSetObjGcInfo(op1->AsObj());
+                    }
+                }
+                else
+                {
+                    size = info.compCompHnd->getClassSize(resolvedToken.hClass);
+                    assert(size == TARGET_POINTER_SIZE);
+                    op1 = gtNewBlockVal(op1, size);
+                }
+
+                op1 = gtNewBlkOpNode(op1, op2, (prefixFlags & PREFIX_VOLATILE) != 0, false);
                 goto SPILL_APPEND;
 
             case CEE_INITBLK:
@@ -17376,10 +17418,9 @@ inline void Compiler::impReimportMarkBlock(BasicBlock* block)
 
 void Compiler::impReimportMarkSuccessors(BasicBlock* block)
 {
-    const unsigned numSuccs = block->NumSucc();
-    for (unsigned i = 0; i < numSuccs; i++)
+    for (BasicBlock* const succBlock : block->Succs())
     {
-        impReimportMarkBlock(block->GetSucc(i));
+        impReimportMarkBlock(succBlock);
     }
 }
 
@@ -17562,10 +17603,9 @@ void Compiler::impImportBlock(BasicBlock* block)
         JITDUMP("Marking BBF_INTERNAL block " FMT_BB " as BBF_IMPORTED\n", block->bbNum);
         block->bbFlags |= BBF_IMPORTED;
 
-        const unsigned numSuccs = block->NumSucc();
-        for (unsigned i = 0; i < numSuccs; i++)
+        for (BasicBlock* const succBlock : block->Succs())
         {
-            impImportBlockPending(block->GetSucc(i));
+            impImportBlockPending(succBlock);
         }
 
         return;
@@ -17722,20 +17762,11 @@ void Compiler::impImportBlock(BasicBlock* block)
                 break;
 
             case BBJ_SWITCH:
-
-                BasicBlock** jmpTab;
-                unsigned     jmpCnt;
-
                 addStmt = impExtractLastStmt();
                 assert(addStmt->GetRootNode()->gtOper == GT_SWITCH);
 
-                jmpCnt = block->bbJumpSwt->bbsCount;
-                jmpTab = block->bbJumpSwt->bbsDstTab;
-
-                do
+                for (BasicBlock* const tgtBlock : block->SwitchTargets())
                 {
-                    tgtBlock = (*jmpTab);
-
                     multRef |= tgtBlock->bbRefs;
 
                     // Thanks to spill cliques, we should have assigned all or none
@@ -17745,8 +17776,7 @@ void Compiler::impImportBlock(BasicBlock* block)
                     {
                         break;
                     }
-                } while (++jmpTab, --jmpCnt);
-
+                }
                 break;
 
             case BBJ_CALLFINALLY:
@@ -17964,10 +17994,8 @@ void Compiler::impImportBlock(BasicBlock* block)
         impReimportSpillClique(block);
 
         // For blocks that haven't been imported yet, we still need to mark them as pending import.
-        const unsigned numSuccs = block->NumSucc();
-        for (unsigned i = 0; i < numSuccs; i++)
+        for (BasicBlock* const succ : block->Succs())
         {
-            BasicBlock* succ = block->GetSucc(i);
             if ((succ->bbFlags & BBF_IMPORTED) == 0)
             {
                 impImportBlockPending(succ);
@@ -17979,10 +18007,9 @@ void Compiler::impImportBlock(BasicBlock* block)
         // otherwise just import the successors of block
 
         /* Does this block jump to any other blocks? */
-        const unsigned numSuccs = block->NumSucc();
-        for (unsigned i = 0; i < numSuccs; i++)
+        for (BasicBlock* const succ : block->Succs())
         {
-            impImportBlockPending(block->GetSucc(i));
+            impImportBlockPending(succ);
         }
     }
 }
@@ -18237,10 +18264,8 @@ void Compiler::impWalkSpillCliqueFromPred(BasicBlock* block, SpillCliqueWalker*
             BasicBlock* blk     = node->m_blk;
             FreeBlockListNode(node);
 
-            const unsigned numSuccs = blk->NumSucc();
-            for (unsigned succNum = 0; succNum < numSuccs; succNum++)
+            for (BasicBlock* const succ : blk->Succs())
             {
-                BasicBlock* succ = blk->GetSucc(succNum);
                 // If it's not already in the clique, add it, and also add it
                 // as a member of the successor "toDo" set.
                 if (impSpillCliqueGetMember(SpillCliqueSucc, succ) == 0)
@@ -18491,12 +18516,12 @@ void Compiler::verResetCurrentState(BasicBlock* block, EntryState* destState)
     return;
 }
 
-ThisInitState BasicBlock::bbThisOnEntry()
+ThisInitState BasicBlock::bbThisOnEntry() const
 {
     return bbEntryState ? bbEntryState->thisInitialized : TIS_Bottom;
 }
 
-unsigned BasicBlock::bbStackDepthOnEntry()
+unsigned BasicBlock::bbStackDepthOnEntry() const
 {
     return (bbEntryState ? bbEntryState->esStackDepth : 0);
 }
@@ -18508,7 +18533,7 @@ void BasicBlock::bbSetStack(void* stackBuffer)
     bbEntryState->esStack = (StackEntry*)stackBuffer;
 }
 
-StackEntry* BasicBlock::bbStackOnEntry()
+StackEntry* BasicBlock::bbStackOnEntry() const
 {
     assert(bbEntryState);
     return bbEntryState->esStack;
@@ -18753,7 +18778,7 @@ void Compiler::impImport()
     }
 
     // Used in impImportBlockPending() for STRESS_CHK_REIMPORT
-    for (BasicBlock* block = fgFirstBB; block; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
         block->bbFlags &= ~BBF_VISITED;
     }
@@ -18885,6 +18910,86 @@ void Compiler::impMakeDiscretionaryInlineObservations(InlineInfo* pInlineInfo, I
         }
     }
 
+    bool callsiteIsGeneric = (rootCompiler->info.compMethodInfo->args.sigInst.methInstCount != 0) ||
+                             (rootCompiler->info.compMethodInfo->args.sigInst.classInstCount != 0);
+
+    bool calleeIsGeneric = (info.compMethodInfo->args.sigInst.methInstCount != 0) ||
+                           (info.compMethodInfo->args.sigInst.classInstCount != 0);
+
+    if (!callsiteIsGeneric && calleeIsGeneric)
+    {
+        inlineResult->Note(InlineObservation::CALLSITE_NONGENERIC_CALLS_GENERIC);
+    }
+
+    if (pInlineInfo != nullptr)
+    {
+        // Inspect callee's arguments (and the actual values at the callsite for them)
+        CORINFO_SIG_INFO        sig    = info.compMethodInfo->args;
+        CORINFO_ARG_LIST_HANDLE sigArg = sig.args;
+
+        GenTreeCall::Use* argUse = pInlineInfo->iciCall->AsCall()->gtCallArgs;
+
+        for (unsigned i = 0; i < info.compMethodInfo->args.numArgs; i++)
+        {
+            assert(argUse != nullptr);
+
+            CORINFO_CLASS_HANDLE sigClass;
+            CorInfoType          corType = strip(info.compCompHnd->getArgType(&sig, sigArg, &sigClass));
+            GenTree*             argNode = argUse->GetNode()->gtSkipPutArgType();
+
+            if (corType == CORINFO_TYPE_CLASS)
+            {
+                sigClass = info.compCompHnd->getArgClass(&sig, sigArg);
+            }
+            else if (corType == CORINFO_TYPE_VALUECLASS)
+            {
+                inlineResult->Note(InlineObservation::CALLEE_ARG_STRUCT);
+            }
+            else if (corType == CORINFO_TYPE_BYREF)
+            {
+                sigClass = info.compCompHnd->getArgClass(&sig, sigArg);
+                corType  = info.compCompHnd->getChildType(sigClass, &sigClass);
+            }
+
+            bool                 isExact   = false;
+            bool                 isNonNull = false;
+            CORINFO_CLASS_HANDLE argCls    = gtGetClassHandle(argNode, &isExact, &isNonNull);
+            if (argCls != nullptr)
+            {
+                const bool isArgValueType = eeIsValueClass(argCls);
+                // Exact class of the arg is known
+                if (isExact && !isArgValueType)
+                {
+                    inlineResult->Note(InlineObservation::CALLSITE_ARG_EXACT_CLS);
+                    if ((argCls != sigClass) && (sigClass != nullptr))
+                    {
+                        // .. but the signature accepts a less concrete type.
+                        inlineResult->Note(InlineObservation::CALLSITE_ARG_EXACT_CLS_SIG_IS_NOT);
+                    }
+                }
+                // Arg is a reference type in the signature and a boxed value type was passed.
+                else if (isArgValueType && (corType == CORINFO_TYPE_CLASS))
+                {
+                    inlineResult->Note(InlineObservation::CALLSITE_ARG_BOXED);
+                }
+            }
+
+            if (argNode->OperIsConst())
+            {
+                inlineResult->Note(InlineObservation::CALLSITE_ARG_CONST);
+            }
+
+            sigArg = info.compCompHnd->getArgNext(sigArg);
+            argUse = argUse->GetNext();
+        }
+    }
+
+    // Note if the callee's return type is a value type
+    if (info.compMethodInfo->args.retType == CORINFO_TYPE_VALUECLASS)
+    {
+        inlineResult->Note(InlineObservation::CALLEE_RETURNS_STRUCT);
+    }
+
     // Note if the callee's class is a promotable struct
     if ((info.compClassAttr & CORINFO_FLG_VALUECLASS) != 0)
     {
@@ -20643,6 +20748,7 @@ bool Compiler::IsMathIntrinsic(GenTree* tree)
 //
 // Arguments:
 //     call -- the call node to examine/modify
+//     pResolvedToken -- [IN] the resolved token used to create the call. Used for R2R.
 //     method   -- [IN/OUT] the method handle for call. Updated iff call devirtualized.
 //     methodFlags -- [IN/OUT] flags for the method to call. Updated iff call devirtualized.
 //     pContextHandle -- [IN/OUT] context handle for the call. Updated iff call devirtualized.
@@ -20681,8 +20787,8 @@ bool Compiler::IsMathIntrinsic(GenTree* tree)
 //     When guarded devirtualization is enabled, this method will mark
 //     calls as guarded devirtualization candidates, if the type of `this`
 //     is not exactly known, and there is a plausible guess for the type.
-//
 void Compiler::impDevirtualizeCall(GenTreeCall*            call,
+                                   CORINFO_RESOLVED_TOKEN* pResolvedToken,
                                    CORINFO_METHOD_HANDLE*  method,
                                    unsigned*               methodFlags,
                                    CORINFO_CONTEXT_HANDLE* pContextHandle,
@@ -20881,16 +20987,18 @@ void Compiler::impDevirtualizeCall(GenTreeCall*            call,
     // and prepare to fetch the method attributes.
     //
     CORINFO_DEVIRTUALIZATION_INFO dvInfo;
-    dvInfo.virtualMethod = baseMethod;
-    dvInfo.objClass      = objClass;
-    dvInfo.context       = *pContextHandle;
-    dvInfo.detail        = CORINFO_DEVIRTUALIZATION_UNKNOWN;
+    dvInfo.virtualMethod               = baseMethod;
+    dvInfo.objClass                    = objClass;
+    dvInfo.context                     = *pContextHandle;
+    dvInfo.detail                      = CORINFO_DEVIRTUALIZATION_UNKNOWN;
+    dvInfo.pResolvedTokenVirtualMethod = pResolvedToken;
 
     info.compCompHnd->resolveVirtualMethod(&dvInfo);
 
-    CORINFO_METHOD_HANDLE  derivedMethod = dvInfo.devirtualizedMethod;
-    CORINFO_CONTEXT_HANDLE exactContext  = dvInfo.exactContext;
-    CORINFO_CLASS_HANDLE   derivedClass  = NO_CLASS_HANDLE;
+    CORINFO_METHOD_HANDLE   derivedMethod         = dvInfo.devirtualizedMethod;
+    CORINFO_CONTEXT_HANDLE  exactContext          = dvInfo.exactContext;
+    CORINFO_CLASS_HANDLE    derivedClass          = NO_CLASS_HANDLE;
+    CORINFO_RESOLVED_TOKEN* pDerivedResolvedToken = &dvInfo.resolvedTokenDevirtualizedMethod;
 
     if (derivedMethod != nullptr)
     {
@@ -21104,14 +21212,6 @@ void Compiler::impDevirtualizeCall(GenTreeCall*            call,
         {
             JITDUMP("Have a direct explicit tail call to boxed entry point; can't optimize further\n");
         }
-        else if (opts.jitFlags->IsSet(JitFlags::JIT_FLAG_PREJIT))
-        {
-            // Per https://github.com/dotnet/runtime/issues/52483, crossgen2 seemingly gets
-            // confused about whether the unboxed entry requires an extra arg.
-            // So defer further optimization for now.
-            //
-            JITDUMP("Have a direct boxed entry point, prejitting. Can't optimize further yet.\n");
-        }
         else
         {
             JITDUMP("Have a direct call to boxed entry point. Trying to optimize to call an unboxed entry point\n");
@@ -21189,8 +21289,9 @@ void Compiler::impDevirtualizeCall(GenTreeCall*            call,
                                     beforeArg->SetNext(gtNewCallArgs(methodTableArg));
                                 }
 
-                                call->gtCallMethHnd = unboxedEntryMethod;
-                                derivedMethod       = unboxedEntryMethod;
+                                call->gtCallMethHnd   = unboxedEntryMethod;
+                                derivedMethod         = unboxedEntryMethod;
+                                pDerivedResolvedToken = &dvInfo.resolvedTokenDevirtualizedUnboxedMethod;
 
                                 // Method attributes will differ because unboxed entry point is shared
                                 //
@@ -21222,7 +21323,8 @@ void Compiler::impDevirtualizeCall(GenTreeCall*            call,
                             call->gtCallThisArg = gtNewCallArgs(localCopyThis);
                             call->gtCallMethHnd = unboxedEntryMethod;
                             call->gtCallMoreFlags |= GTF_CALL_M_UNBOXED;
-                            derivedMethod = unboxedEntryMethod;
+                            derivedMethod         = unboxedEntryMethod;
+                            pDerivedResolvedToken = &dvInfo.resolvedTokenDevirtualizedUnboxedMethod;
 
                             optimizedTheBox = true;
                         }
@@ -21290,8 +21392,9 @@ void Compiler::impDevirtualizeCall(GenTreeCall*            call,
                             const DWORD unboxedMethodAttribs = info.compCompHnd->getMethodAttribs(unboxedEntryMethod);
                             JITDUMP("Updating method attribs from 0x%08x to 0x%08x\n", derivedMethodAttribs,
                                     unboxedMethodAttribs);
-                            derivedMethod        = unboxedEntryMethod;
-                            derivedMethodAttribs = unboxedMethodAttribs;
+                            derivedMethod         = unboxedEntryMethod;
+                            pDerivedResolvedToken = &dvInfo.resolvedTokenDevirtualizedUnboxedMethod;
+                            derivedMethodAttribs  = unboxedMethodAttribs;
 
                             // Add the method table argument.
                             //
@@ -21334,7 +21437,8 @@ void Compiler::impDevirtualizeCall(GenTreeCall*            call,
                         call->gtCallThisArg = gtNewCallArgs(boxPayload);
                         call->gtCallMethHnd = unboxedEntryMethod;
                         call->gtCallMoreFlags |= GTF_CALL_M_UNBOXED;
-                        derivedMethod = unboxedEntryMethod;
+                        derivedMethod         = unboxedEntryMethod;
+                        pDerivedResolvedToken = &dvInfo.resolvedTokenDevirtualizedUnboxedMethod;
                     }
                 }
             }
@@ -21370,21 +21474,11 @@ void Compiler::impDevirtualizeCall(GenTreeCall*            call,
     if (opts.IsReadyToRun())
     {
         // For R2R, getCallInfo triggers bookkeeping on the zap
-        // side so we need to call it here.
-        //
-        // First, cons up a suitable resolved token.
-        CORINFO_RESOLVED_TOKEN derivedResolvedToken = {};
-
-        derivedResolvedToken.tokenScope   = info.compCompHnd->getMethodModule(derivedMethod);
-        derivedResolvedToken.tokenContext = *pContextHandle;
-        derivedResolvedToken.token        = info.compCompHnd->getMethodDefFromMethod(derivedMethod);
-        derivedResolvedToken.tokenType    = CORINFO_TOKENKIND_DevirtualizedMethod;
-        derivedResolvedToken.hClass       = derivedClass;
-        derivedResolvedToken.hMethod      = derivedMethod;
+        // side and acquires the actual symbol to call so we need to call it here.
 
         // Look up the new call info.
         CORINFO_CALL_INFO derivedCallInfo;
-        eeGetCallInfo(&derivedResolvedToken, nullptr, addVerifyFlag(CORINFO_CALLINFO_ALLOWINSTPARAM), &derivedCallInfo);
+        eeGetCallInfo(pDerivedResolvedToken, nullptr, addVerifyFlag(CORINFO_CALLINFO_ALLOWINSTPARAM), &derivedCallInfo);
 
         // Update the call.
         call->gtCallMoreFlags &= ~GTF_CALL_M_VIRTSTUB_REL_INDIRECT;
@@ -21666,9 +21760,11 @@ void Compiler::considerGuardedDevirtualization(
     // Figure out which method will be called.
     //
     CORINFO_DEVIRTUALIZATION_INFO dvInfo;
-    dvInfo.virtualMethod = baseMethod;
-    dvInfo.objClass      = likelyClass;
-    dvInfo.context       = *pContextHandle;
+    dvInfo.virtualMethod               = baseMethod;
+    dvInfo.objClass                    = likelyClass;
+    dvInfo.context                     = *pContextHandle;
+    dvInfo.exactContext                = *pContextHandle;
+    dvInfo.pResolvedTokenVirtualMethod = nullptr;
 
     const bool canResolve = info.compCompHnd->resolveVirtualMethod(&dvInfo);
 
diff --git a/src/coreclr/jit/indirectcalltransformer.cpp b/src/coreclr/jit/indirectcalltransformer.cpp
index 5b6b663e7e035d..f36a5a2c1691c4 100644
--- a/src/coreclr/jit/indirectcalltransformer.cpp
+++ b/src/coreclr/jit/indirectcalltransformer.cpp
@@ -80,7 +80,7 @@ class IndirectCallTransformer
     {
         int count = 0;
 
-        for (BasicBlock* block = compiler->fgFirstBB; block != nullptr; block = block->bbNext)
+        for (BasicBlock* const block : compiler->Blocks())
         {
             count += TransformBlock(block);
         }
@@ -100,7 +100,7 @@ class IndirectCallTransformer
     {
         int count = 0;
 
-        for (Statement* stmt : block->Statements())
+        for (Statement* const stmt : block->Statements())
         {
             if (compiler->doesMethodHaveFatPointer() && ContainsFatCalli(stmt))
             {
@@ -754,8 +754,8 @@ class IndirectCallTransformer
             CORINFO_CONTEXT_HANDLE context                = inlineInfo->exactContextHnd;
             const bool             isLateDevirtualization = true;
             const bool explicitTailCall = (call->AsCall()->gtCallMoreFlags & GTF_CALL_M_EXPLICIT_TAILCALL) != 0;
-            compiler->impDevirtualizeCall(call, &methodHnd, &methodFlags, &context, nullptr, isLateDevirtualization,
-                                          explicitTailCall);
+            compiler->impDevirtualizeCall(call, nullptr, &methodHnd, &methodFlags, &context, nullptr,
+                                          isLateDevirtualization, explicitTailCall);
 
             // We know this call can devirtualize or we would not have set up GDV here.
             // So impDevirtualizeCall should succeed in devirtualizing.
@@ -1012,7 +1012,7 @@ class IndirectCallTransformer
                 }
             };
 
-            for (Statement* nextStmt : remainderBlock->Statements())
+            for (Statement* const nextStmt : remainderBlock->Statements())
             {
                 JITDUMP(" Scouting " FMT_STMT "\n", nextStmt->GetID());
 
@@ -1273,9 +1273,9 @@ void Compiler::CheckNoTransformableIndirectCallsRemain()
     assert(!doesMethodHaveGuardedDevirtualization());
     assert(!doesMethodHaveExpRuntimeLookup());
 
-    for (BasicBlock* block = fgFirstBB; block != nullptr; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
-        for (Statement* stmt : block->Statements())
+        for (Statement* const stmt : block->Statements())
         {
             fgWalkTreePre(stmt->GetRootNodePointer(), fgDebugCheckForTransformableIndirectCalls);
         }
diff --git a/src/coreclr/jit/inline.cpp b/src/coreclr/jit/inline.cpp
index b2db02dcd25c63..4e86755491b8f0 100644
--- a/src/coreclr/jit/inline.cpp
+++ b/src/coreclr/jit/inline.cpp
@@ -466,6 +466,36 @@ void InlineContext::DumpData(unsigned indent)
     }
 }
 
+//------------------------------------------------------------------------
+// EscapeNameForXml: Cheap xml quoting for values. Only < and & are
+//                   troublemakers, but change > for symmetry.
+//
+// Arguments:
+//    name     - string to escape (modifies content)
+
+static void EscapeNameForXml(char* name)
+{
+    int i = 0;
+    while (name[i] != '\0')
+    {
+        switch (name[i])
+        {
+            case '<':
+                name[i] = '[';
+                break;
+            case '>':
+                name[i] = ']';
+                break;
+            case '&':
+                name[i] = '#';
+                break;
+            default:
+                break;
+        }
+        i++;
+    }
+}
+
 //------------------------------------------------------------------------
 // DumpXml: Dump an InlineContext entry and all descendants in xml format
 //
@@ -499,6 +529,12 @@ void InlineContext::DumpXml(FILE* file, unsigned indent)
         mdMethodDef calleeToken  = compiler->info.compCompHnd->getMethodDefFromMethod(m_Callee);
         unsigned    calleeHash   = compiler->compMethodHash(m_Callee);
         const char* inlineReason = InlGetObservationString(m_Observation);
+        const char* name         = compiler->eeGetMethodFullName(m_Callee);
+
+        char buf[1024];
+        strncpy(buf, name, sizeof(buf));
+        buf[sizeof(buf) - 1] = 0;
+        EscapeNameForXml(buf);
 
         int offset = -1;
         if (m_Offset != BAD_IL_OFFSET)
@@ -511,6 +547,17 @@ void InlineContext::DumpXml(FILE* file, unsigned indent)
         fprintf(file, "%*s<Hash>%08x</Hash>\n", indent + 2, "", calleeHash);
         fprintf(file, "%*s<Offset>%u</Offset>\n", indent + 2, "", offset);
         fprintf(file, "%*s<Reason>%s</Reason>\n", indent + 2, "", inlineReason);
+        fprintf(file, "%*s<Name>%s</Name>\n", indent + 2, "", buf);
+        fprintf(file, "%*s<ILSize>%d</ILSize>\n", indent + 2, "", m_ILSize);
+        fprintf(file, "%*s<Devirtualized>%s</Devirtualized>\n", indent + 2, "", m_Devirtualized ? "True" : "False");
+        fprintf(file, "%*s<Guarded>%s</Guarded>\n", indent + 2, "", m_Guarded ? "True" : "False");
+        fprintf(file, "%*s<Unboxed>%s</Unboxed>\n", indent + 2, "", m_Unboxed ? "True" : "False");
+
+        // Ask InlinePolicy if it has anything to dump as well:
+        if ((m_Policy != nullptr) && (JitConfig.JitInlinePolicyDumpXml() != 0))
+        {
+            m_Policy->DumpXml(file, indent + 2);
+        }
 
         // Optionally, dump data about the inline
         const int dumpDataSetting = JitConfig.JitInlineDumpData();
@@ -1548,8 +1595,7 @@ void InlineStrategy::DumpXml(FILE* file, unsigned indent)
     const Compiler::Info&    info = m_Compiler->info;
     const Compiler::Options& opts = m_Compiler->opts;
 
-    const bool isPrejitRoot  = opts.jitFlags->IsSet(JitFlags::JIT_FLAG_PREJIT);
-    const bool isForceInline = (info.compFlags & CORINFO_FLG_FORCEINLINE) != 0;
+    const bool isPrejitRoot = opts.jitFlags->IsSet(JitFlags::JIT_FLAG_PREJIT);
 
     // We'd really like the method identifier to be unique and
     // durable across crossgen invocations. Not clear how to
@@ -1573,44 +1619,23 @@ void InlineStrategy::DumpXml(FILE* file, unsigned indent)
 
     // Get method name just for root method, to make it a bit easier
     // to search for things in the inline xml.
-    const char* methodName = info.compCompHnd->getMethodName(info.compMethodHnd, nullptr);
+    const char* methodName = m_Compiler->eeGetMethodFullName(info.compMethodHnd);
 
-    // Cheap xml quoting for values. Only < and & are troublemakers,
-    // but change > for symmetry.
-    //
-    // Ok to truncate name, just ensure it's null terminated.
-    char buf[64];
+    char buf[1024];
     strncpy(buf, methodName, sizeof(buf));
     buf[sizeof(buf) - 1] = 0;
-
-    for (size_t i = 0; i < _countof(buf); i++)
-    {
-        switch (buf[i])
-        {
-            case '<':
-                buf[i] = '[';
-                break;
-            case '>':
-                buf[i] = ']';
-                break;
-            case '&':
-                buf[i] = '#';
-                break;
-            default:
-                break;
-        }
-    }
+    EscapeNameForXml(buf);
 
     fprintf(file, "%*s<Method>\n", indent, "");
     fprintf(file, "%*s<Token>%08x</Token>\n", indent + 2, "", currentMethodToken);
     fprintf(file, "%*s<Hash>%08x</Hash>\n", indent + 2, "", hash);
-    fprintf(file, "%*s<Name>%s</Name>\n", indent + 2, "", buf);
     fprintf(file, "%*s<InlineCount>%u</InlineCount>\n", indent + 2, "", m_InlineCount);
     fprintf(file, "%*s<HotSize>%u</HotSize>\n", indent + 2, "", info.compTotalHotCodeSize);
     fprintf(file, "%*s<ColdSize>%u</ColdSize>\n", indent + 2, "", info.compTotalColdCodeSize);
     fprintf(file, "%*s<JitTime>%u</JitTime>\n", indent + 2, "", microsecondsSpentJitting);
     fprintf(file, "%*s<SizeEstimate>%u</SizeEstimate>\n", indent + 2, "", m_CurrentSizeEstimate / 10);
     fprintf(file, "%*s<TimeEstimate>%u</TimeEstimate>\n", indent + 2, "", m_CurrentTimeEstimate);
+    fprintf(file, "%*s<Name>%s</Name>\n", indent + 2, "", buf);
 
     // For prejit roots also propagate out the assessment of the root method
     if (isPrejitRoot)
diff --git a/src/coreclr/jit/inline.def b/src/coreclr/jit/inline.def
index 3c3ef462a150f7..001cb415491928 100644
--- a/src/coreclr/jit/inline.def
+++ b/src/coreclr/jit/inline.def
@@ -68,10 +68,20 @@ INLINE_OBSERVATION(TOO_MUCH_IL,               bool,   "too many il bytes",
 
 INLINE_OBSERVATION(ARG_FEEDS_CONSTANT_TEST,   bool,   "argument feeds constant test",         INFORMATION, CALLEE)
 INLINE_OBSERVATION(ARG_FEEDS_TEST,            bool,   "argument feeds test",                  INFORMATION, CALLEE)
+INLINE_OBSERVATION(ARG_FEEDS_CAST,            int,    "argument feeds castclass or isinst",   INFORMATION, CALLEE)
 INLINE_OBSERVATION(ARG_FEEDS_RANGE_CHECK,     bool,   "argument feeds range check",           INFORMATION, CALLEE)
+INLINE_OBSERVATION(ARG_STRUCT,                int,    "arg is a struct passed by value",      INFORMATION, CALLEE)
+INLINE_OBSERVATION(RETURNS_STRUCT,            bool,   "returns a struct by value",            INFORMATION, CALLEE)
+INLINE_OBSERVATION(ARG_STRUCT_FIELD_ACCESS,   int,    "ldfld/stfld over arg (struct)",        INFORMATION, CALLEE)
+INLINE_OBSERVATION(BINARY_EXRP_WITH_CNS,      int,    "'X op CNS' pattern",                   INFORMATION, CALLEE)
 INLINE_OBSERVATION(BEGIN_OPCODE_SCAN,         bool,   "prepare to look at opcodes",           INFORMATION, CALLEE)
 INLINE_OBSERVATION(BELOW_ALWAYS_INLINE_SIZE,  bool,   "below ALWAYS_INLINE size",             INFORMATION, CALLEE)
 INLINE_OBSERVATION(CLASS_PROMOTABLE,          bool,   "promotable value class",               INFORMATION, CALLEE)
+INLINE_OBSERVATION(CLASS_VALUETYPE,           bool,   "value class",                          INFORMATION, CALLEE)
+INLINE_OBSERVATION(FOLDABLE_BOX,              int,    "foldable box/unbox operation",         INFORMATION, CALLEE)
+INLINE_OBSERVATION(INTRINSIC,                 int,    "call marked as intrinsic",             INFORMATION, CALLEE)
+INLINE_OBSERVATION(BACKWARD_JUMP,             int,    "backward jump",                        INFORMATION, CALLEE)
+INLINE_OBSERVATION(THROW_BLOCK,               int,    "throw block",                          INFORMATION, CALLEE)
 INLINE_OBSERVATION(DOES_NOT_RETURN,           bool,   "does not return",                      INFORMATION, CALLEE)
 INLINE_OBSERVATION(END_OPCODE_SCAN,           bool,   "done looking at opcodes",              INFORMATION, CALLEE)
 INLINE_OBSERVATION(HAS_GC_STRUCT,             bool,   "has gc field in struct local",         INFORMATION, CALLEE)
@@ -162,12 +172,23 @@ INLINE_OBSERVATION(RARE_GC_STRUCT,            bool,   "rarely called, has gc str
 
 // ------ Call Site Information -------
 
+INLINE_OBSERVATION(NONGENERIC_CALLS_GENERIC, bool,    "callee is generic and caller is not",  INFORMATION, CALLSITE)
+INLINE_OBSERVATION(ARG_EXACT_CLS,             int,    "arg is of an exact class",             INFORMATION, CALLSITE)
+INLINE_OBSERVATION(ARG_EXACT_CLS_SIG_IS_NOT,  int,    "arg is more concrete than in sig.",    INFORMATION, CALLSITE)
+INLINE_OBSERVATION(ARG_CONST,                 int,    "arg is a constant",                    INFORMATION, CALLSITE)
+INLINE_OBSERVATION(ARG_BOXED,                 int,    "arg is boxed at call site",            INFORMATION, CALLSITE)
+INLINE_OBSERVATION(FOLDABLE_INTRINSIC,        int,    "foldable intrinsic",                   INFORMATION, CALLSITE)
+INLINE_OBSERVATION(FOLDABLE_EXPR,             int,    "foldable binary expression",           INFORMATION, CALLSITE)
+INLINE_OBSERVATION(FOLDABLE_EXPR_UN,          int,    "foldable unary expression",            INFORMATION, CALLSITE)
+INLINE_OBSERVATION(FOLDABLE_BRANCH,           int,    "foldable branch",                      INFORMATION, CALLSITE)
+INLINE_OBSERVATION(DIV_BY_CNS,                int,    "dividy by const",                      INFORMATION, CALLSITE)
 INLINE_OBSERVATION(CONSTANT_ARG_FEEDS_TEST,   bool,   "constant argument feeds test",         INFORMATION, CALLSITE)
 INLINE_OBSERVATION(DEPTH,                     int,    "depth",                                INFORMATION, CALLSITE)
 INLINE_OBSERVATION(FREQUENCY,                 int,    "rough call site frequency",            INFORMATION, CALLSITE)
 INLINE_OBSERVATION(HAS_PROFILE,               bool,   "profile data is available",            INFORMATION, CALLSITE)
 INLINE_OBSERVATION(IN_LOOP,                   bool,   "call site is in a loop",               INFORMATION, CALLSITE)
 INLINE_OBSERVATION(IN_TRY_REGION,             bool,   "call site is in a try region",         INFORMATION, CALLSITE)
+INLINE_OBSERVATION(IN_NORETURN_REGION,        bool,   "call site is in a no-return region",   INFORMATION, CALLSITE)
 INLINE_OBSERVATION(IS_PROFITABLE_INLINE,      bool,   "profitable inline",                    INFORMATION, CALLSITE)
 INLINE_OBSERVATION(IS_SAME_THIS,              bool,   "same this as root caller",             INFORMATION, CALLSITE)
 INLINE_OBSERVATION(IS_SIZE_DECREASING_INLINE, bool,   "size decreasing inline",               INFORMATION, CALLSITE)
diff --git a/src/coreclr/jit/inline.h b/src/coreclr/jit/inline.h
index cfa8de36cabffe..f74f9e53109681 100644
--- a/src/coreclr/jit/inline.h
+++ b/src/coreclr/jit/inline.h
@@ -263,6 +263,10 @@ class InlinePolicy
     virtual void DumpSchema(FILE* file) const
     {
     }
+    // Detailed data value dump as XML
+    virtual void DumpXml(FILE* file, unsigned indent = 0) const
+    {
+    }
     // True if this is the inline targeted by data collection
     bool IsDataCollectionTarget()
     {
diff --git a/src/coreclr/jit/inlinepolicy.cpp b/src/coreclr/jit/inlinepolicy.cpp
index bd8b363e977f82..25cd23cf522f67 100644
--- a/src/coreclr/jit/inlinepolicy.cpp
+++ b/src/coreclr/jit/inlinepolicy.cpp
@@ -288,10 +288,98 @@ void DefaultPolicy::NoteBool(InlineObservation obs, bool value)
                 m_IsInstanceCtor = value;
                 break;
 
+            case InlineObservation::CALLEE_RETURNS_STRUCT:
+                m_ReturnsStructByValue = value;
+                break;
+
+            case InlineObservation::CALLEE_CLASS_VALUETYPE:
+                m_IsFromValueClass = value;
+                break;
+
+            case InlineObservation::CALLSITE_NONGENERIC_CALLS_GENERIC:
+                m_NonGenericCallsGeneric = value;
+                break;
+
             case InlineObservation::CALLEE_CLASS_PROMOTABLE:
                 m_IsFromPromotableValueClass = value;
                 break;
 
+            case InlineObservation::CALLEE_BINARY_EXRP_WITH_CNS:
+                m_BinaryExprWithCns++;
+                break;
+
+            case InlineObservation::CALLEE_ARG_STRUCT:
+                m_ArgIsStructByValue++;
+                break;
+
+            case InlineObservation::CALLEE_ARG_STRUCT_FIELD_ACCESS:
+                m_FldAccessOverArgStruct++;
+                break;
+
+            case InlineObservation::CALLEE_ARG_FEEDS_CAST:
+                m_ArgCasted++;
+                break;
+
+            case InlineObservation::CALLEE_FOLDABLE_BOX:
+                m_FoldableBox++;
+                break;
+
+            case InlineObservation::CALLEE_INTRINSIC:
+                m_Intrinsic++;
+                break;
+
+            case InlineObservation::CALLEE_BACKWARD_JUMP:
+                m_BackwardJump++;
+                break;
+
+            case InlineObservation::CALLEE_THROW_BLOCK:
+                m_ThrowBlock++;
+                break;
+
+            case InlineObservation::CALLSITE_ARG_EXACT_CLS:
+                m_ArgIsExactCls++;
+                break;
+
+            case InlineObservation::CALLSITE_ARG_BOXED:
+                m_ArgIsBoxedAtCallsite++;
+                break;
+
+            case InlineObservation::CALLSITE_ARG_CONST:
+                m_ArgIsConst++;
+                break;
+
+            case InlineObservation::CALLSITE_ARG_EXACT_CLS_SIG_IS_NOT:
+                m_ArgIsExactClsSigIsNot++;
+                break;
+
+            case InlineObservation::CALLSITE_FOLDABLE_INTRINSIC:
+                m_FoldableIntrinsic++;
+                break;
+
+            case InlineObservation::CALLSITE_FOLDABLE_EXPR:
+                m_FoldableExpr++;
+                break;
+
+            case InlineObservation::CALLSITE_FOLDABLE_EXPR_UN:
+                m_FoldableExprUn++;
+                break;
+
+            case InlineObservation::CALLSITE_FOLDABLE_BRANCH:
+                m_FoldableBranch++;
+                break;
+
+            case InlineObservation::CALLSITE_DIV_BY_CNS:
+                m_DivByCns++;
+                break;
+
+            case InlineObservation::CALLSITE_HAS_PROFILE:
+                m_HasProfile = value;
+                break;
+
+            case InlineObservation::CALLSITE_IN_TRY_REGION:
+                m_CallsiteIsInTryRegion = value;
+                break;
+
             case InlineObservation::CALLEE_HAS_SIMD:
                 m_HasSimd = value;
                 break;
@@ -389,8 +477,8 @@ void DefaultPolicy::NoteBool(InlineObservation obs, bool value)
                 break;
             }
 
-            case InlineObservation::CALLSITE_IN_TRY_REGION:
-                m_CallsiteIsInTryRegion = true;
+            case InlineObservation::CALLSITE_IN_NORETURN_REGION:
+                m_IsCallsiteInNoReturnRegion = value;
                 break;
 
             case InlineObservation::CALLSITE_IN_LOOP:
@@ -449,6 +537,85 @@ void DefaultPolicy::NoteBool(InlineObservation obs, bool value)
     }
 }
 
+#if defined(DEBUG) || defined(INLINE_DATA)
+//------------------------------------------------------------------------
+// DumpXml: Dump DefaultPolicy data as XML
+//
+// Arguments:
+//    file     - stream to output to
+//    indent   - indent level
+
+void DefaultPolicy::DumpXml(FILE* file, unsigned indent) const
+{
+    fprintf(file, "%*s<DefaultPolicyData", indent, "");
+
+// To reduce verbosity, let's print only non-default values
+#define XATTR_I4(x)                                                                                                    \
+    if ((INT32)x != 0)                                                                                                 \
+    {                                                                                                                  \
+        fprintf(file, " " #x "=\"%d\"", (INT32)x);                                                                     \
+    }
+#define XATTR_R8(x)                                                                                                    \
+    if (fabs(x) > 0.01)                                                                                                \
+    {                                                                                                                  \
+        fprintf(file, " " #x "=\"%.2lf\"", x);                                                                         \
+    }
+#define XATTR_B(x)                                                                                                     \
+    if (x)                                                                                                             \
+    {                                                                                                                  \
+        fprintf(file, " " #x "=\"True\"");                                                                             \
+    }
+
+    XATTR_R8(m_Multiplier);
+    XATTR_R8(m_ProfileFrequency);
+    XATTR_I4(m_CodeSize);
+    XATTR_I4(m_CallsiteFrequency);
+    XATTR_I4(m_CallsiteDepth);
+    XATTR_I4(m_InstructionCount);
+    XATTR_I4(m_LoadStoreCount);
+    XATTR_I4(m_ArgFeedsTest);
+    XATTR_I4(m_ArgFeedsConstantTest);
+    XATTR_I4(m_ArgFeedsRangeCheck);
+    XATTR_I4(m_ConstantArgFeedsConstantTest);
+    XATTR_I4(m_BinaryExprWithCns);
+    XATTR_I4(m_ArgCasted);
+    XATTR_I4(m_ArgIsStructByValue);
+    XATTR_I4(m_FldAccessOverArgStruct);
+    XATTR_I4(m_FoldableBox);
+    XATTR_I4(m_Intrinsic);
+    XATTR_I4(m_BackwardJump);
+    XATTR_I4(m_ThrowBlock);
+    XATTR_I4(m_ArgIsExactCls);
+    XATTR_I4(m_ArgIsExactClsSigIsNot);
+    XATTR_I4(m_ArgIsConst);
+    XATTR_I4(m_ArgIsBoxedAtCallsite);
+    XATTR_I4(m_FoldableIntrinsic);
+    XATTR_I4(m_FoldableExpr);
+    XATTR_I4(m_FoldableExprUn);
+    XATTR_I4(m_FoldableBranch);
+    XATTR_I4(m_DivByCns);
+    XATTR_I4(m_CalleeNativeSizeEstimate);
+    XATTR_I4(m_CallsiteNativeSizeEstimate);
+    XATTR_B(m_IsForceInline);
+    XATTR_B(m_IsForceInlineKnown);
+    XATTR_B(m_IsInstanceCtor);
+    XATTR_B(m_IsFromPromotableValueClass);
+    XATTR_B(m_HasSimd);
+    XATTR_B(m_LooksLikeWrapperMethod);
+    XATTR_B(m_MethodIsMostlyLoadStore);
+    XATTR_B(m_CallsiteIsInTryRegion);
+    XATTR_B(m_CallsiteIsInLoop);
+    XATTR_B(m_IsNoReturn);
+    XATTR_B(m_IsNoReturnKnown);
+    XATTR_B(m_ReturnsStructByValue);
+    XATTR_B(m_IsFromValueClass);
+    XATTR_B(m_NonGenericCallsGeneric);
+    XATTR_B(m_IsCallsiteInNoReturnRegion);
+    XATTR_B(m_HasProfile);
+    fprintf(file, " />\n");
+}
+#endif
+
 //------------------------------------------------------------------------
 // BudgetCheck: see if this inline would exceed the current budget
 //
@@ -654,9 +821,8 @@ void DefaultPolicy::NoteInt(InlineObservation obs, int value)
 
 void DefaultPolicy::NoteDouble(InlineObservation obs, double value)
 {
-    // By default, ignore this observation.
-    //
     assert(obs == InlineObservation::CALLSITE_PROFILE_FREQUENCY);
+    m_ProfileFrequency = value;
 }
 
 //------------------------------------------------------------------------
@@ -761,6 +927,174 @@ double DefaultPolicy::DetermineMultiplier()
             break;
     }
 
+    if (m_ReturnsStructByValue)
+    {
+        // For structs-passed-by-value we might avoid expensive copy operations if we inline
+        JITDUMP("\nInline candidate returns a struct by value.");
+    }
+
+    if (m_ArgIsStructByValue > 0)
+    {
+        // Same here
+        JITDUMP("\n%d arguments are structs passed by value.", m_ArgIsStructByValue);
+    }
+
+    if (m_NonGenericCallsGeneric)
+    {
+        // Especially, if such a callee has many foldable branches like 'typeof(T) == typeof(T2)'
+        JITDUMP("\nInline candidate is generic and caller is not.");
+    }
+
+    if (m_IsCallsiteInNoReturnRegion)
+    {
+        // E.g.
+        //
+        //   throw new ArgumentException(SR.GetMessage());
+        //
+        // ^ Here we have two calls inside a BBJ_THROW block
+        // Unfortunately, we're not able to detect ThrowHelpers calls yet.
+        JITDUMP("\nCallsite is in a no-return region.");
+    }
+
+    if (m_FoldableBranch > 0)
+    {
+        // Examples:
+        //
+        //  if (typeof(T) == typeof(int)) {
+        //  if (Avx2.IsSupported) {
+        //  if (arg0 / 10 > 100) { // where arg0 is a constant at the callsite
+        //  if (Math.Abs(arg0) > 10) { // same here
+        //  etc.
+        //
+        JITDUMP("\nInline candidate has %d foldable branches.", m_FoldableBranch);
+    }
+
+    if (m_ArgCasted > 0)
+    {
+        JITDUMP("\nArgument feeds ISINST/CASTCLASS %d times.", m_ArgCasted);
+    }
+
+    if (m_FldAccessOverArgStruct > 0)
+    {
+        // Such ldfld/stfld are cheap for promotable structs
+        JITDUMP("\n%d ldfld or stfld over arguments which are structs", m_ArgIsStructByValue);
+    }
+
+    if (m_FoldableBox > 0)
+    {
+        // We met some BOX+ISINST+BR or BOX+UNBOX patterns (see impBoxPatternMatch).
+        // Especially useful with m_IsGenericFromNonGeneric
+        JITDUMP("\nInline has %d foldable BOX ops.", m_FoldableBox);
+    }
+
+    if (m_Intrinsic > 0)
+    {
+        // In most cases such intrinsics are lowered as single CPU instructions
+        JITDUMP("\nInline has %d intrinsics.", m_Intrinsic);
+    }
+
+    if (m_BinaryExprWithCns > 0)
+    {
+        // In some cases we're not able to detect potentially foldable expressions, e.g.:
+        //
+        //   ldc.i4.0
+        //   call int SomeFoldableNonIntrinsicCall
+        //   ceq
+        //
+        // so at least we can note potential constant tests
+        JITDUMP("\nInline candidate has %d binary expressions with constants.", m_BinaryExprWithCns);
+    }
+
+    if (m_ThrowBlock > 0)
+    {
+        // 'throw' opcode and its friends (Exception's ctor, its exception message, etc) significantly increase
+        // NativeSizeEstimate. However, such basic-blocks won't hurt us since they are always moved to
+        // the end of the functions and don't impact Register Allocations.
+        // NOTE: Unfortunately, we're not able to recognize ThrowHelper calls here yet.
+        JITDUMP("\nInline has %d throw blocks.", m_ThrowBlock);
+    }
+
+    if (m_ArgIsBoxedAtCallsite > 0)
+    {
+        // Callsite is going to box n arguments. We might avoid boxing after inlining.
+        // Example:
+        //
+        //  void DoNothing(object o) {} // o is unused, so the boxing is redundant
+        //
+        //  void Caller() => DoNothing(42); // 42 is going to be boxed at the call site.
+        //
+        JITDUMP("\nCallsite is going to box %d arguments.", m_ArgIsBoxedAtCallsite);
+    }
+
+    if (m_ArgIsExactClsSigIsNot > 0)
+    {
+        // If we inline such a callee - we'll be able to devirtualize all the calls for such arguments
+        // Example:
+        //
+        //  int Callee(object o) => o.GetHashCode(); // virtual call
+        //
+        //  int Caller(string s) => Callee(s); // String is 'exact' (sealed)
+        //
+        JITDUMP("\nCallsite passes %d arguments of exact classes while callee accepts non-exact ones.",
+                m_ArgIsExactClsSigIsNot);
+    }
+
+    if (m_ArgIsExactCls > 0)
+    {
+        JITDUMP("\nCallsite passes %d arguments of exact classes.", m_ArgIsExactCls);
+    }
+
+    if (m_ArgIsConst > 0)
+    {
+        // Normally, we try to note all the places where constant arguments lead to folding/feed tests
+        // but just in case:
+        JITDUMP("\n%d arguments are constants at the callsite.", m_ArgIsConst);
+    }
+
+    if (m_FoldableIntrinsic > 0)
+    {
+        // Examples:
+        //
+        //   typeof(T1) == typeof(T2)
+        //   Math.Abs(constArg)
+        //   BitOperation.PopCount(10)
+        JITDUMP("\nInline has %d foldable intrinsics.", m_FoldableIntrinsic);
+    }
+
+    if (m_FoldableExpr > 0)
+    {
+        // E.g. add/mul/ceq, etc. over constant/constant arguments
+        JITDUMP("\nInline has %d foldable binary expressions.", m_FoldableExpr);
+    }
+
+    if (m_FoldableExprUn > 0)
+    {
+        // E.g. casts, negations, etc. over constants/constant arguments
+        JITDUMP("\nInline has %d foldable unary expressions.", m_FoldableExprUn);
+    }
+
+    if (m_DivByCns > 0)
+    {
+        // E.g. callee has "x / arg0" where arg0 is a const at the call site -
+        // we'll avoid a very expensive DIV instruction after inlining.
+        JITDUMP("\nInline has %d Div-by-constArg expressions.", m_DivByCns);
+    }
+
+    if (m_BackwardJump)
+    {
+        const bool callSiteIsInLoop = m_CallsiteFrequency == InlineCallsiteFrequency::LOOP;
+        JITDUMP("\nInline has %d backward jumps (loops?).", m_BackwardJump);
+        if (callSiteIsInLoop)
+        {
+            JITDUMP(" And is inlined into a loop.")
+        }
+    }
+
+    if (m_HasProfile)
+    {
+        JITDUMP("\nCallsite has profile data: %g.", m_ProfileFrequency);
+    }
+
 #ifdef DEBUG
 
     int additionalMultiplier = JitConfig.JitInlineAdditionalMultiplier();
@@ -2028,6 +2362,28 @@ void DiscretionaryPolicy::DumpData(FILE* file) const
     fprintf(file, ",%u", m_IsNoReturn ? 1 : 0);
     fprintf(file, ",%u", m_CalleeHasGCStruct ? 1 : 0);
     fprintf(file, ",%u", m_CallsiteDepth);
+    fprintf(file, ",%u", m_BinaryExprWithCns);
+    fprintf(file, ",%u", m_ArgCasted);
+    fprintf(file, ",%u", m_ArgIsStructByValue);
+    fprintf(file, ",%u", m_FldAccessOverArgStruct);
+    fprintf(file, ",%u", m_FoldableBox);
+    fprintf(file, ",%u", m_Intrinsic);
+    fprintf(file, ",%u", m_BackwardJump);
+    fprintf(file, ",%u", m_ThrowBlock);
+    fprintf(file, ",%u", m_ArgIsExactCls);
+    fprintf(file, ",%u", m_ArgIsExactClsSigIsNot);
+    fprintf(file, ",%u", m_ArgIsConst);
+    fprintf(file, ",%u", m_ArgIsBoxedAtCallsite);
+    fprintf(file, ",%u", m_FoldableIntrinsic);
+    fprintf(file, ",%u", m_FoldableExpr);
+    fprintf(file, ",%u", m_FoldableExprUn);
+    fprintf(file, ",%u", m_FoldableBranch);
+    fprintf(file, ",%u", m_DivByCns);
+    fprintf(file, ",%u", m_ReturnsStructByValue ? 1 : 0);
+    fprintf(file, ",%u", m_IsFromValueClass ? 1 : 0);
+    fprintf(file, ",%u", m_NonGenericCallsGeneric ? 1 : 0);
+    fprintf(file, ",%u", m_IsCallsiteInNoReturnRegion ? 1 : 0);
+    fprintf(file, ",%u", m_HasProfile ? 1 : 0);
 }
 
 #endif // defined(DEBUG) || defined(INLINE_DATA)
diff --git a/src/coreclr/jit/inlinepolicy.h b/src/coreclr/jit/inlinepolicy.h
index 3e0d3440a8e851..9c107f480c241a 100644
--- a/src/coreclr/jit/inlinepolicy.h
+++ b/src/coreclr/jit/inlinepolicy.h
@@ -87,6 +87,7 @@ class DefaultPolicy : public LegalPolicy
         , m_RootCompiler(compiler)
         , m_StateMachine(nullptr)
         , m_Multiplier(0.0)
+        , m_ProfileFrequency(0.0)
         , m_CodeSize(0)
         , m_CallsiteFrequency(InlineCallsiteFrequency::UNUSED)
         , m_CallsiteDepth(0)
@@ -96,6 +97,23 @@ class DefaultPolicy : public LegalPolicy
         , m_ArgFeedsConstantTest(0)
         , m_ArgFeedsRangeCheck(0)
         , m_ConstantArgFeedsConstantTest(0)
+        , m_BinaryExprWithCns(0)
+        , m_ArgCasted(0)
+        , m_ArgIsStructByValue(0)
+        , m_FldAccessOverArgStruct(0)
+        , m_FoldableBox(0)
+        , m_Intrinsic(0)
+        , m_BackwardJump(0)
+        , m_ThrowBlock(0)
+        , m_ArgIsExactCls(0)
+        , m_ArgIsExactClsSigIsNot(0)
+        , m_ArgIsConst(0)
+        , m_ArgIsBoxedAtCallsite(0)
+        , m_FoldableIntrinsic(0)
+        , m_FoldableExpr(0)
+        , m_FoldableExprUn(0)
+        , m_FoldableBranch(0)
+        , m_DivByCns(0)
         , m_CalleeNativeSizeEstimate(0)
         , m_CallsiteNativeSizeEstimate(0)
         , m_IsForceInline(false)
@@ -109,6 +127,11 @@ class DefaultPolicy : public LegalPolicy
         , m_CallsiteIsInLoop(false)
         , m_IsNoReturn(false)
         , m_IsNoReturnKnown(false)
+        , m_ReturnsStructByValue(false)
+        , m_IsFromValueClass(false)
+        , m_NonGenericCallsGeneric(false)
+        , m_IsCallsiteInNoReturnRegion(false)
+        , m_HasProfile(false)
     {
         // empty
     }
@@ -136,6 +159,8 @@ class DefaultPolicy : public LegalPolicy
         return "DefaultPolicy";
     }
 
+    void DumpXml(FILE* file, unsigned indent = 0) const override;
+
 #endif // (DEBUG) || defined(INLINE_DATA)
 
 protected:
@@ -155,6 +180,7 @@ class DefaultPolicy : public LegalPolicy
     Compiler*               m_RootCompiler; // root compiler instance
     CodeSeqSM*              m_StateMachine;
     double                  m_Multiplier;
+    double                  m_ProfileFrequency;
     unsigned                m_CodeSize;
     InlineCallsiteFrequency m_CallsiteFrequency;
     unsigned                m_CallsiteDepth;
@@ -164,6 +190,23 @@ class DefaultPolicy : public LegalPolicy
     unsigned                m_ArgFeedsConstantTest;
     unsigned                m_ArgFeedsRangeCheck;
     unsigned                m_ConstantArgFeedsConstantTest;
+    unsigned                m_BinaryExprWithCns;
+    unsigned                m_ArgCasted;
+    unsigned                m_ArgIsStructByValue;
+    unsigned                m_FldAccessOverArgStruct;
+    unsigned                m_FoldableBox;
+    unsigned                m_Intrinsic;
+    unsigned                m_BackwardJump;
+    unsigned                m_ThrowBlock;
+    unsigned                m_ArgIsExactCls;
+    unsigned                m_ArgIsExactClsSigIsNot;
+    unsigned                m_ArgIsConst;
+    unsigned                m_ArgIsBoxedAtCallsite;
+    unsigned                m_FoldableIntrinsic;
+    unsigned                m_FoldableExpr;
+    unsigned                m_FoldableExprUn;
+    unsigned                m_FoldableBranch;
+    unsigned                m_DivByCns;
     int                     m_CalleeNativeSizeEstimate;
     int                     m_CallsiteNativeSizeEstimate;
     bool                    m_IsForceInline : 1;
@@ -177,6 +220,11 @@ class DefaultPolicy : public LegalPolicy
     bool                    m_CallsiteIsInLoop : 1;
     bool                    m_IsNoReturn : 1;
     bool                    m_IsNoReturnKnown : 1;
+    bool                    m_ReturnsStructByValue : 1;
+    bool                    m_IsFromValueClass : 1;
+    bool                    m_NonGenericCallsGeneric : 1;
+    bool                    m_IsCallsiteInNoReturnRegion : 1;
+    bool                    m_HasProfile : 1;
 };
 
 // DiscretionaryPolicy is a variant of the default policy.  It
diff --git a/src/coreclr/jit/instr.h b/src/coreclr/jit/instr.h
index ed001fdc1bc722..d9e2b9319ee4c2 100644
--- a/src/coreclr/jit/instr.h
+++ b/src/coreclr/jit/instr.h
@@ -86,18 +86,56 @@ enum GCtype : unsigned
 };
 
 #if defined(TARGET_XARCH)
-enum insFlags: uint8_t
+
+enum insFlags : uint32_t
 {
-    INS_FLAGS_None = 0x00,
-    INS_FLAGS_ReadsFlags = 0x01,
-    INS_FLAGS_WritesFlags = 0x02,
-    INS_FLAGS_x87Instr = 0x04,
-    INS_Flags_IsDstDstSrcAVXInstruction = 0x08,
-    INS_Flags_IsDstSrcSrcAVXInstruction = 0x10,
+    INS_FLAGS_None = 0,
+
+    // Reads
+    Reads_OF = 1 << 0,
+    Reads_SF = 1 << 1,
+    Reads_ZF = 1 << 2,
+    Reads_PF = 1 << 3,
+    Reads_CF = 1 << 4,
+    Reads_DF = 1 << 5,
+
+    // Writes
+    Writes_OF = 1 << 6,
+    Writes_SF = 1 << 7,
+    Writes_ZF = 1 << 8,
+    Writes_AF = 1 << 9,
+    Writes_PF = 1 << 10,
+    Writes_CF = 1 << 11,
+
+    // Resets
+    Resets_OF = 1 << 12,
+    Resets_SF = 1 << 13,
+    Resets_AF = 1 << 14,
+    Resets_PF = 1 << 15,
+    Resets_CF = 1 << 16,
+
+    // Undefined
+    Undefined_OF = 1 << 17,
+    Undefined_SF = 1 << 18,
+    Undefined_ZF = 1 << 19,
+    Undefined_AF = 1 << 20,
+    Undefined_PF = 1 << 21,
+    Undefined_CF = 1 << 22,
+
+    // Restore
+    Restore_SF_ZF_AF_PF_CF = 1 << 23,
+
+    // x87 instruction
+    INS_FLAGS_x87Instr = 1 << 24,
+
+    // Avx
+    INS_Flags_IsDstDstSrcAVXInstruction = 1 << 25,
+    INS_Flags_IsDstSrcSrcAVXInstruction = 1 << 26,
 
     //  TODO-Cleanup:  Remove this flag and its usage from TARGET_XARCH
     INS_FLAGS_DONT_CARE = 0x00,
 };
+
 #elif defined(TARGET_ARM) || defined(TARGET_ARM64)
 // TODO-Cleanup: Move 'insFlags' under TARGET_ARM
 enum insFlags: unsigned
diff --git a/src/coreclr/jit/instrsxarch.h b/src/coreclr/jit/instrsxarch.h
index 750f1b215036b1..262e0c052fc6a6 100644
--- a/src/coreclr/jit/instrsxarch.h
+++ b/src/coreclr/jit/instrsxarch.h
@@ -51,69 +51,71 @@
 //    id                nm                  um      mr            mi            rm            a4            rr           flags
 INST5(invalid,          "INVALID",          IUM_RD, BAD_CODE,     BAD_CODE,     BAD_CODE,     BAD_CODE,     BAD_CODE,    INS_FLAGS_None)
 
-INST5(push,             "push",             IUM_RD, 0x0030FE,     0x000068,     BAD_CODE,     BAD_CODE,     0x000050,    INS_FLAGS_None)
-INST5(pop,              "pop",              IUM_WR, 0x00008E,     BAD_CODE,     BAD_CODE,     BAD_CODE,     0x000058,    INS_FLAGS_None)
+INST5(push,             "push",             IUM_RD, 0x0030FE,     0x000068,     BAD_CODE,     BAD_CODE,     0x000050,    INS_FLAGS_None )
+INST5(pop,              "pop",              IUM_WR, 0x00008E,     BAD_CODE,     BAD_CODE,     BAD_CODE,     0x000058,    INS_FLAGS_None )
 // Does not affect the stack tracking in the emitter
-INST5(push_hide,        "push",             IUM_RD, 0x0030FE,     0x000068,     BAD_CODE,     BAD_CODE,     0x000050,    INS_FLAGS_None)
-INST5(pop_hide,         "pop",              IUM_WR, 0x00008E,     BAD_CODE,     BAD_CODE,     BAD_CODE,     0x000058,    INS_FLAGS_None)
+INST5(push_hide,        "push",             IUM_RD, 0x0030FE,     0x000068,     BAD_CODE,     BAD_CODE,     0x000050,    INS_FLAGS_None )
+INST5(pop_hide,         "pop",              IUM_WR, 0x00008E,     BAD_CODE,     BAD_CODE,     BAD_CODE,     0x000058,    INS_FLAGS_None )
 
-INST5(inc,              "inc",              IUM_RW, 0x0000FE,     BAD_CODE,     BAD_CODE,     BAD_CODE,     0x000040,    INS_FLAGS_WritesFlags)
-INST5(inc_l,            "inc",              IUM_RW, 0x0000FE,     BAD_CODE,     BAD_CODE,     BAD_CODE,     0x00C0FE,    INS_FLAGS_WritesFlags)
-INST5(dec,              "dec",              IUM_RW, 0x0008FE,     BAD_CODE,     BAD_CODE,     BAD_CODE,     0x000048,    INS_FLAGS_WritesFlags)
-INST5(dec_l,            "dec",              IUM_RW, 0x0008FE,     BAD_CODE,     BAD_CODE,     BAD_CODE,     0x00C8FE,    INS_FLAGS_WritesFlags)
+INST5(inc,              "inc",              IUM_RW, 0x0000FE,     BAD_CODE,     BAD_CODE,     BAD_CODE,     0x000040,    Writes_OF      | Writes_SF     | Writes_ZF     | Writes_AF     | Writes_PF )
+INST5(inc_l,            "inc",              IUM_RW, 0x0000FE,     BAD_CODE,     BAD_CODE,     BAD_CODE,     0x00C0FE,    Writes_OF      | Writes_SF     | Writes_ZF     | Writes_AF     | Writes_PF )
+INST5(dec,              "dec",              IUM_RW, 0x0008FE,     BAD_CODE,     BAD_CODE,     BAD_CODE,     0x000048,    Writes_OF      | Writes_SF     | Writes_ZF     | Writes_AF     | Writes_PF )
+INST5(dec_l,            "dec",              IUM_RW, 0x0008FE,     BAD_CODE,     BAD_CODE,     BAD_CODE,     0x00C8FE,    Writes_OF      | Writes_SF     | Writes_ZF     | Writes_AF     | Writes_PF )
 
 // Multi-byte opcodes without modrm are represented in mixed endian fashion.
 // See comment around quarter way through this file for more information.
-INST5(bswap,            "bswap",            IUM_RW, 0x0F00C8,     BAD_CODE,     BAD_CODE,     BAD_CODE,     0x00C80F,    INS_FLAGS_None)
+INST5(bswap,            "bswap",            IUM_RW, 0x0F00C8,     BAD_CODE,     BAD_CODE,     BAD_CODE,     0x00C80F,    INS_FLAGS_None )
 
 //    id                nm                  um      mr            mi            rm            a4                         flags
-INST4(add,              "add",              IUM_RW, 0x000000,     0x000080,     0x000002,     0x000004,                  INS_FLAGS_WritesFlags)
-INST4(or,               "or",               IUM_RW, 0x000008,     0x000880,     0x00000A,     0x00000C,                  INS_FLAGS_WritesFlags)
-INST4(adc,              "adc",              IUM_RW, 0x000010,     0x001080,     0x000012,     0x000014,                  INS_FLAGS_ReadsFlags | INS_FLAGS_WritesFlags)
-INST4(sbb,              "sbb",              IUM_RW, 0x000018,     0x001880,     0x00001A,     0x00001C,                  INS_FLAGS_ReadsFlags | INS_FLAGS_WritesFlags)
-INST4(and,              "and",              IUM_RW, 0x000020,     0x002080,     0x000022,     0x000024,                  INS_FLAGS_WritesFlags)
-INST4(sub,              "sub",              IUM_RW, 0x000028,     0x002880,     0x00002A,     0x00002C,                  INS_FLAGS_WritesFlags)
-INST4(xor,              "xor",              IUM_RW, 0x000030,     0x003080,     0x000032,     0x000034,                  INS_FLAGS_WritesFlags)
-INST4(cmp,              "cmp",              IUM_RD, 0x000038,     0x003880,     0x00003A,     0x00003C,                  INS_FLAGS_WritesFlags)
-INST4(test,             "test",             IUM_RD, 0x000084,     0x0000F6,     0x000084,     0x0000A8,                  INS_FLAGS_WritesFlags)
-INST4(mov,              "mov",              IUM_WR, 0x000088,     0x0000C6,     0x00008A,     0x0000B0,                  INS_FLAGS_None)
-
-INST4(lea,              "lea",              IUM_WR, BAD_CODE,     BAD_CODE,     0x00008D,     BAD_CODE,                  INS_FLAGS_None)
+INST4(add,              "add",              IUM_RW, 0x000000,     0x000080,     0x000002,     0x000004,                  Writes_OF      | Writes_SF     | Writes_ZF     | Writes_AF     | Writes_PF     | Writes_CF     )
+INST4(or,               "or",               IUM_RW, 0x000008,     0x000880,     0x00000A,     0x00000C,                  Resets_OF      | Writes_SF     | Writes_ZF     | Undefined_AF  | Writes_PF     | Resets_CF     )
+INST4(adc,              "adc",              IUM_RW, 0x000010,     0x001080,     0x000012,     0x000014,                  Writes_OF      | Writes_SF     | Writes_ZF     | Writes_AF     | Writes_PF     | Writes_CF
+                                                                                                                                                                                                        | Reads_CF      )
+INST4(sbb,              "sbb",              IUM_RW, 0x000018,     0x001880,     0x00001A,     0x00001C,                  Writes_OF      | Writes_SF     | Writes_ZF     | Writes_AF     | Writes_PF     | Writes_CF
+                                                                                                                                                                                                        | Reads_CF      )
+INST4(and,              "and",              IUM_RW, 0x000020,     0x002080,     0x000022,     0x000024,                  Resets_OF      | Writes_SF     | Writes_ZF     | Undefined_AF  | Writes_PF     | Resets_CF     )
+INST4(sub,              "sub",              IUM_RW, 0x000028,     0x002880,     0x00002A,     0x00002C,                  Writes_OF      | Writes_SF     | Writes_ZF     | Writes_AF     | Writes_PF     | Writes_CF     )
+INST4(xor,              "xor",              IUM_RW, 0x000030,     0x003080,     0x000032,     0x000034,                  Resets_OF      | Writes_SF     | Writes_ZF     | Undefined_AF  | Writes_PF     | Resets_CF     )
+INST4(cmp,              "cmp",              IUM_RD, 0x000038,     0x003880,     0x00003A,     0x00003C,                  Writes_OF      | Writes_SF     | Writes_ZF     | Writes_AF     | Writes_PF     | Writes_CF     )
+INST4(test,             "test",             IUM_RD, 0x000084,     0x0000F6,     0x000084,     0x0000A8,                  Resets_OF      | Writes_SF     | Writes_ZF     | Undefined_AF  | Writes_PF     | Resets_CF     )
+INST4(mov,              "mov",              IUM_WR, 0x000088,     0x0000C6,     0x00008A,     0x0000B0,                  INS_FLAGS_None )
+
+INST4(lea,              "lea",              IUM_WR, BAD_CODE,     BAD_CODE,     0x00008D,     BAD_CODE,                  INS_FLAGS_None )
 
 //    id                nm                  um      mr            mi            rm                                       flags
 
 // Note that emitter has only partial support for BT. It can only emit the reg,reg form
 // and the registers need to be reversed to get the correct encoding.
-INST3(bt,               "bt",               IUM_RD, 0x0F00A3,     BAD_CODE,     0x0F00A3,                                INS_FLAGS_WritesFlags)
+INST3(bt,               "bt",               IUM_RD, 0x0F00A3,     BAD_CODE,     0x0F00A3,                                Undefined_OF   | Undefined_SF  | Undefined_ZF  | Undefined_AF  | Undefined_PF  | Writes_CF     )
 
-INST3(bsf,              "bsf",              IUM_WR, BAD_CODE,     BAD_CODE,     0x0F00BC,                                INS_FLAGS_WritesFlags)
-INST3(bsr,              "bsr",              IUM_WR, BAD_CODE,     BAD_CODE,     0x0F00BD,                                INS_FLAGS_WritesFlags)
+INST3(bsf,              "bsf",              IUM_WR, BAD_CODE,     BAD_CODE,     0x0F00BC,                                Undefined_OF   | Undefined_SF  | Writes_ZF     | Undefined_AF  | Undefined_PF  | Undefined_CF  )
+INST3(bsr,              "bsr",              IUM_WR, BAD_CODE,     BAD_CODE,     0x0F00BD,                                Undefined_OF   | Undefined_SF  | Writes_ZF     | Undefined_AF  | Undefined_PF  | Undefined_CF  )
 
-INST3(movsx,            "movsx",            IUM_WR, BAD_CODE,     BAD_CODE,     0x0F00BE,                                INS_FLAGS_None)
+INST3(movsx,            "movsx",            IUM_WR, BAD_CODE,     BAD_CODE,     0x0F00BE,                                INS_FLAGS_None )
 #ifdef TARGET_AMD64
-INST3(movsxd,           "movsxd",           IUM_WR, BAD_CODE,     BAD_CODE,     0x4800000063,                            INS_FLAGS_None)
+INST3(movsxd,           "movsxd",           IUM_WR, BAD_CODE,     BAD_CODE,     0x4800000063,                            INS_FLAGS_None )
 #endif
-INST3(movzx,            "movzx",            IUM_WR, BAD_CODE,     BAD_CODE,     0x0F00B6,                                INS_FLAGS_None)
-
-INST3(cmovo,            "cmovo",            IUM_WR, BAD_CODE,     BAD_CODE,     0x0F0040,                                INS_FLAGS_ReadsFlags)
-INST3(cmovno,           "cmovno",           IUM_WR, BAD_CODE,     BAD_CODE,     0x0F0041,                                INS_FLAGS_ReadsFlags)
-INST3(cmovb,            "cmovb",            IUM_WR, BAD_CODE,     BAD_CODE,     0x0F0042,                                INS_FLAGS_ReadsFlags)
-INST3(cmovae,           "cmovae",           IUM_WR, BAD_CODE,     BAD_CODE,     0x0F0043,                                INS_FLAGS_ReadsFlags)
-INST3(cmove,            "cmove",            IUM_WR, BAD_CODE,     BAD_CODE,     0x0F0044,                                INS_FLAGS_ReadsFlags)
-INST3(cmovne,           "cmovne",           IUM_WR, BAD_CODE,     BAD_CODE,     0x0F0045,                                INS_FLAGS_ReadsFlags)
-INST3(cmovbe,           "cmovbe",           IUM_WR, BAD_CODE,     BAD_CODE,     0x0F0046,                                INS_FLAGS_ReadsFlags)
-INST3(cmova,            "cmova",            IUM_WR, BAD_CODE,     BAD_CODE,     0x0F0047,                                INS_FLAGS_ReadsFlags)
-INST3(cmovs,            "cmovs",            IUM_WR, BAD_CODE,     BAD_CODE,     0x0F0048,                                INS_FLAGS_ReadsFlags)
-INST3(cmovns,           "cmovns",           IUM_WR, BAD_CODE,     BAD_CODE,     0x0F0049,                                INS_FLAGS_ReadsFlags)
-INST3(cmovp,            "cmovp",            IUM_WR, BAD_CODE,     BAD_CODE,     0x0F004A,                                INS_FLAGS_ReadsFlags)
-INST3(cmovnp,           "cmovnp",           IUM_WR, BAD_CODE,     BAD_CODE,     0x0F004B,                                INS_FLAGS_ReadsFlags)
-INST3(cmovl,            "cmovl",            IUM_WR, BAD_CODE,     BAD_CODE,     0x0F004C,                                INS_FLAGS_ReadsFlags)
-INST3(cmovge,           "cmovge",           IUM_WR, BAD_CODE,     BAD_CODE,     0x0F004D,                                INS_FLAGS_ReadsFlags)
-INST3(cmovle,           "cmovle",           IUM_WR, BAD_CODE,     BAD_CODE,     0x0F004E,                                INS_FLAGS_ReadsFlags)
-INST3(cmovg,            "cmovg",            IUM_WR, BAD_CODE,     BAD_CODE,     0x0F004F,                                INS_FLAGS_ReadsFlags)
-
-INST3(xchg,             "xchg",             IUM_RW, 0x000086,     BAD_CODE,     0x000086,                                INS_FLAGS_None)
-INST3(imul,             "imul",             IUM_RW, 0x0F00AC,     BAD_CODE,     0x0F00AF,                                INS_FLAGS_WritesFlags) // op1 *= op2
+INST3(movzx,            "movzx",            IUM_WR, BAD_CODE,     BAD_CODE,     0x0F00B6,                                INS_FLAGS_None )
+
+INST3(cmovo,            "cmovo",            IUM_WR, BAD_CODE,     BAD_CODE,     0x0F0040,                                Reads_OF )
+INST3(cmovno,           "cmovno",           IUM_WR, BAD_CODE,     BAD_CODE,     0x0F0041,                                Reads_OF )
+INST3(cmovb,            "cmovb",            IUM_WR, BAD_CODE,     BAD_CODE,     0x0F0042,                                Reads_CF )
+INST3(cmovae,           "cmovae",           IUM_WR, BAD_CODE,     BAD_CODE,     0x0F0043,                                Reads_CF )
+INST3(cmove,            "cmove",            IUM_WR, BAD_CODE,     BAD_CODE,     0x0F0044,                                Reads_ZF )
+INST3(cmovne,           "cmovne",           IUM_WR, BAD_CODE,     BAD_CODE,     0x0F0045,                                Reads_ZF )
+INST3(cmovbe,           "cmovbe",           IUM_WR, BAD_CODE,     BAD_CODE,     0x0F0046,                                Reads_ZF | Reads_CF )
+INST3(cmova,            "cmova",            IUM_WR, BAD_CODE,     BAD_CODE,     0x0F0047,                                Reads_ZF | Reads_CF )
+INST3(cmovs,            "cmovs",            IUM_WR, BAD_CODE,     BAD_CODE,     0x0F0048,                                Reads_SF )
+INST3(cmovns,           "cmovns",           IUM_WR, BAD_CODE,     BAD_CODE,     0x0F0049,                                Reads_SF )
+INST3(cmovp,            "cmovp",            IUM_WR, BAD_CODE,     BAD_CODE,     0x0F004A,                                Reads_PF )
+INST3(cmovnp,           "cmovnp",           IUM_WR, BAD_CODE,     BAD_CODE,     0x0F004B,                                Reads_PF )
+INST3(cmovl,            "cmovl",            IUM_WR, BAD_CODE,     BAD_CODE,     0x0F004C,                                Reads_OF       | Reads_SF                                                                      )
+INST3(cmovge,           "cmovge",           IUM_WR, BAD_CODE,     BAD_CODE,     0x0F004D,                                Reads_OF       | Reads_SF                                                                      )
+INST3(cmovle,           "cmovle",           IUM_WR, BAD_CODE,     BAD_CODE,     0x0F004E,                                Reads_OF       | Reads_SF      | Reads_ZF                                                      )
+INST3(cmovg,            "cmovg",            IUM_WR, BAD_CODE,     BAD_CODE,     0x0F004F,                                Reads_OF       | Reads_SF      | Reads_ZF                                                      )
+
+INST3(xchg,             "xchg",             IUM_RW, 0x000086,     BAD_CODE,     0x000086,                                INS_FLAGS_None )
+INST3(imul,             "imul",             IUM_RW, 0x0F00AC,     BAD_CODE,     0x0F00AF,                                Writes_OF      | Undefined_SF  | Undefined_ZF  | Undefined_AF  | Undefined_PF  | Writes_CF     )
 
 //    id                nm                  um      mr            mi            rm                                       flags
 
@@ -121,25 +123,25 @@ INST3(imul,             "imul",             IUM_RW, 0x0F00AC,     BAD_CODE,
 // as 2-operand instructions with the target register being implicit
 // implicit_reg = op1*op2_icon
 #define INSTMUL INST3
-INSTMUL(imul_AX,        "imul",             IUM_RD, BAD_CODE,     0x000068,     BAD_CODE,                                INS_FLAGS_WritesFlags)
-INSTMUL(imul_CX,        "imul",             IUM_RD, BAD_CODE,     0x000868,     BAD_CODE,                                INS_FLAGS_WritesFlags)
-INSTMUL(imul_DX,        "imul",             IUM_RD, BAD_CODE,     0x001068,     BAD_CODE,                                INS_FLAGS_WritesFlags)
-INSTMUL(imul_BX,        "imul",             IUM_RD, BAD_CODE,     0x001868,     BAD_CODE,                                INS_FLAGS_WritesFlags)
-INSTMUL(imul_SP,        "imul",             IUM_RD, BAD_CODE,     BAD_CODE,     BAD_CODE,                                INS_FLAGS_WritesFlags)
-INSTMUL(imul_BP,        "imul",             IUM_RD, BAD_CODE,     0x002868,     BAD_CODE,                                INS_FLAGS_WritesFlags)
-INSTMUL(imul_SI,        "imul",             IUM_RD, BAD_CODE,     0x003068,     BAD_CODE,                                INS_FLAGS_WritesFlags)
-INSTMUL(imul_DI,        "imul",             IUM_RD, BAD_CODE,     0x003868,     BAD_CODE,                                INS_FLAGS_WritesFlags)
+INSTMUL(imul_AX,        "imul",             IUM_RD, BAD_CODE,     0x000068,     BAD_CODE,                                Writes_OF      | Undefined_SF  | Undefined_ZF  | Undefined_AF  | Undefined_PF  | Writes_CF     )
+INSTMUL(imul_CX,        "imul",             IUM_RD, BAD_CODE,     0x000868,     BAD_CODE,                                Writes_OF      | Undefined_SF  | Undefined_ZF  | Undefined_AF  | Undefined_PF  | Writes_CF     )
+INSTMUL(imul_DX,        "imul",             IUM_RD, BAD_CODE,     0x001068,     BAD_CODE,                                Writes_OF      | Undefined_SF  | Undefined_ZF  | Undefined_AF  | Undefined_PF  | Writes_CF     )
+INSTMUL(imul_BX,        "imul",             IUM_RD, BAD_CODE,     0x001868,     BAD_CODE,                                Writes_OF      | Undefined_SF  | Undefined_ZF  | Undefined_AF  | Undefined_PF  | Writes_CF     )
+INSTMUL(imul_SP,        "imul",             IUM_RD, BAD_CODE,     BAD_CODE,     BAD_CODE,                                Writes_OF      | Undefined_SF  | Undefined_ZF  | Undefined_AF  | Undefined_PF  | Writes_CF     )
+INSTMUL(imul_BP,        "imul",             IUM_RD, BAD_CODE,     0x002868,     BAD_CODE,                                Writes_OF      | Undefined_SF  | Undefined_ZF  | Undefined_AF  | Undefined_PF  | Writes_CF     )
+INSTMUL(imul_SI,        "imul",             IUM_RD, BAD_CODE,     0x003068,     BAD_CODE,                                Writes_OF      | Undefined_SF  | Undefined_ZF  | Undefined_AF  | Undefined_PF  | Writes_CF     )
+INSTMUL(imul_DI,        "imul",             IUM_RD, BAD_CODE,     0x003868,     BAD_CODE,                                Writes_OF      | Undefined_SF  | Undefined_ZF  | Undefined_AF  | Undefined_PF  | Writes_CF     )
 
 #ifdef TARGET_AMD64
 
-INSTMUL(imul_08,        "imul",             IUM_RD, BAD_CODE,     0x4400000068, BAD_CODE,                                INS_FLAGS_WritesFlags)
-INSTMUL(imul_09,        "imul",             IUM_RD, BAD_CODE,     0x4400000868, BAD_CODE,                                INS_FLAGS_WritesFlags)
-INSTMUL(imul_10,        "imul",             IUM_RD, BAD_CODE,     0x4400001068, BAD_CODE,                                INS_FLAGS_WritesFlags)
-INSTMUL(imul_11,        "imul",             IUM_RD, BAD_CODE,     0x4400001868, BAD_CODE,                                INS_FLAGS_WritesFlags)
-INSTMUL(imul_12,        "imul",             IUM_RD, BAD_CODE,     0x4400002068, BAD_CODE,                                INS_FLAGS_WritesFlags)
-INSTMUL(imul_13,        "imul",             IUM_RD, BAD_CODE,     0x4400002868, BAD_CODE,                                INS_FLAGS_WritesFlags)
-INSTMUL(imul_14,        "imul",             IUM_RD, BAD_CODE,     0x4400003068, BAD_CODE,                                INS_FLAGS_WritesFlags)
-INSTMUL(imul_15,        "imul",             IUM_RD, BAD_CODE,     0x4400003868, BAD_CODE,                                INS_FLAGS_WritesFlags)
+INSTMUL(imul_08,        "imul",             IUM_RD, BAD_CODE,     0x4400000068, BAD_CODE,                                Writes_OF      | Undefined_SF  | Undefined_ZF  | Undefined_AF  | Undefined_PF  | Writes_CF     )
+INSTMUL(imul_09,        "imul",             IUM_RD, BAD_CODE,     0x4400000868, BAD_CODE,                                Writes_OF      | Undefined_SF  | Undefined_ZF  | Undefined_AF  | Undefined_PF  | Writes_CF     )
+INSTMUL(imul_10,        "imul",             IUM_RD, BAD_CODE,     0x4400001068, BAD_CODE,                                Writes_OF      | Undefined_SF  | Undefined_ZF  | Undefined_AF  | Undefined_PF  | Writes_CF     )
+INSTMUL(imul_11,        "imul",             IUM_RD, BAD_CODE,     0x4400001868, BAD_CODE,                                Writes_OF      | Undefined_SF  | Undefined_ZF  | Undefined_AF  | Undefined_PF  | Writes_CF     )
+INSTMUL(imul_12,        "imul",             IUM_RD, BAD_CODE,     0x4400002068, BAD_CODE,                                Writes_OF      | Undefined_SF  | Undefined_ZF  | Undefined_AF  | Undefined_PF  | Writes_CF     )
+INSTMUL(imul_13,        "imul",             IUM_RD, BAD_CODE,     0x4400002868, BAD_CODE,                                Writes_OF      | Undefined_SF  | Undefined_ZF  | Undefined_AF  | Undefined_PF  | Writes_CF     )
+INSTMUL(imul_14,        "imul",             IUM_RD, BAD_CODE,     0x4400003068, BAD_CODE,                                Writes_OF      | Undefined_SF  | Undefined_ZF  | Undefined_AF  | Undefined_PF  | Writes_CF     )
+INSTMUL(imul_15,        "imul",             IUM_RD, BAD_CODE,     0x4400003868, BAD_CODE,                                Writes_OF      | Undefined_SF  | Undefined_ZF  | Undefined_AF  | Undefined_PF  | Writes_CF     )
 
 #endif // TARGET_AMD64
 
@@ -301,10 +303,10 @@ INST3(cvttpd2dq,        "cvttpd2dq",        IUM_WR, BAD_CODE,     BAD_CODE,
 INST3(cvtdq2pd,         "cvtdq2pd",         IUM_WR, BAD_CODE,     BAD_CODE,     SSEFLT(0xE6),                            INS_FLAGS_None)    // cvt packed DWORDs to doubles
 
 // SSE2 comparison instructions
-INST3(comiss,           "comiss",           IUM_RD, BAD_CODE,     BAD_CODE,     PCKFLT(0x2F),                            INS_FLAGS_None)    // ordered compare singles
-INST3(comisd,           "comisd",           IUM_RD, BAD_CODE,     BAD_CODE,     PCKDBL(0x2F),                            INS_FLAGS_None)    // ordered compare doubles
-INST3(ucomiss,          "ucomiss",          IUM_RD, BAD_CODE,     BAD_CODE,     PCKFLT(0x2E),                            INS_FLAGS_None)    // unordered compare singles
-INST3(ucomisd,          "ucomisd",          IUM_RD, BAD_CODE,     BAD_CODE,     PCKDBL(0x2E),                            INS_FLAGS_None)    // unordered compare doubles
+INST3(comiss,           "comiss",           IUM_RD, BAD_CODE,     BAD_CODE,     PCKFLT(0x2F),                            Resets_OF  | Resets_SF     | Writes_ZF     | Resets_AF     | Writes_PF     | Writes_CF                     )  // ordered compare singles
+INST3(comisd,           "comisd",           IUM_RD, BAD_CODE,     BAD_CODE,     PCKDBL(0x2F),                            Resets_OF  | Resets_SF     | Writes_ZF     | Resets_AF     | Writes_PF     | Writes_CF                     )  // ordered compare doubles
+INST3(ucomiss,          "ucomiss",          IUM_RD, BAD_CODE,     BAD_CODE,     PCKFLT(0x2E),                            Resets_OF  | Resets_SF     | Writes_ZF     | Resets_AF     | Writes_PF     | Writes_CF                     )  // unordered compare singles
+INST3(ucomisd,          "ucomisd",          IUM_RD, BAD_CODE,     BAD_CODE,     PCKDBL(0x2E),                            Resets_OF  | Resets_SF     | Writes_ZF     | Resets_AF     | Writes_PF     | Writes_CF                     )  // unordered compare doubles
 
 // SSE2 packed single/double comparison operations.
 // Note that these instructions not only compare but also overwrite the first source.
@@ -600,10 +602,10 @@ INST3(bextr,            "bextr",            IUM_WR, BAD_CODE,     BAD_CODE,
 
 // BMI2
 INST3(rorx,             "rorx",             IUM_WR, BAD_CODE,     BAD_CODE,     SSE3A(0xF0),                             INS_FLAGS_None)
-INST3(pdep,             "pdep",             IUM_WR, BAD_CODE,     BAD_CODE,     SSE38(0xF5),                             INS_Flags_IsDstDstSrcAVXInstruction)    // Parallel Bits Deposit
-INST3(pext,             "pext",             IUM_WR, BAD_CODE,     BAD_CODE,     SSE38(0xF5),                             INS_Flags_IsDstDstSrcAVXInstruction)    // Parallel Bits Extract
-INST3(bzhi,             "bzhi",             IUM_WR, BAD_CODE,     BAD_CODE,     SSE38(0xF5),                             INS_Flags_IsDstDstSrcAVXInstruction)    // Zero High Bits Starting with Specified Bit Position
-INST3(mulx,             "mulx",             IUM_WR, BAD_CODE,     BAD_CODE,     SSE38(0xF6),                             INS_Flags_IsDstDstSrcAVXInstruction)    // Unsigned Multiply Without Affecting Flags
+INST3(pdep,             "pdep",             IUM_WR, BAD_CODE,     BAD_CODE,     SSE38(0xF5),                             INS_Flags_IsDstDstSrcAVXInstruction)                               // Parallel Bits Deposit
+INST3(pext,             "pext",             IUM_WR, BAD_CODE,     BAD_CODE,     SSE38(0xF5),                             INS_Flags_IsDstDstSrcAVXInstruction)                               // Parallel Bits Extract
+INST3(bzhi,             "bzhi",             IUM_WR, BAD_CODE,     BAD_CODE,     SSE38(0xF5),                             Resets_OF      | Writes_SF     | Writes_ZF     | Undefined_AF  | Undefined_PF  | Writes_CF     | INS_Flags_IsDstDstSrcAVXInstruction)    // Zero High Bits Starting with Specified Bit Position
+INST3(mulx,             "mulx",             IUM_WR, BAD_CODE,     BAD_CODE,     SSE38(0xF6),                             INS_Flags_IsDstDstSrcAVXInstruction)                               // Unsigned Multiply Without Affecting Flags
 
 INST3(LAST_BMI_INSTRUCTION, "LAST_BMI_INSTRUCTION", IUM_WR, BAD_CODE, BAD_CODE, BAD_CODE, INS_FLAGS_None)
 
@@ -613,88 +615,94 @@ INST3(LAST_AVX_INSTRUCTION, "LAST_AVX_INSTRUCTION", IUM_WR, BAD_CODE, BAD_CODE,
 INST3(crc32,            "crc32",            IUM_WR, BAD_CODE,     BAD_CODE,     PACK4(0xF2, 0x0F, 0x38, 0xF0),           INS_FLAGS_None)
 
 // BMI1
-INST3(tzcnt,            "tzcnt",            IUM_WR, BAD_CODE,     BAD_CODE,     SSEFLT(0xBC),                            INS_FLAGS_None)    // Count the Number of Trailing Zero Bits
+INST3(tzcnt,            "tzcnt",            IUM_WR, BAD_CODE,     BAD_CODE,     SSEFLT(0xBC),                            Undefined_OF   | Undefined_SF  | Writes_ZF     | Undefined_AF  | Undefined_PF  | Writes_CF )    // Count the Number of Trailing Zero Bits
 
 // LZCNT
-INST3(lzcnt,            "lzcnt",            IUM_WR, BAD_CODE,     BAD_CODE,     SSEFLT(0xBD),                            INS_FLAGS_None)
+INST3(lzcnt,            "lzcnt",            IUM_WR, BAD_CODE,     BAD_CODE,     SSEFLT(0xBD),                            Undefined_OF   | Undefined_SF  | Writes_ZF     | Undefined_AF  | Undefined_PF  | Writes_CF )
 
 // POPCNT
-INST3(popcnt,           "popcnt",           IUM_WR, BAD_CODE,     BAD_CODE,     SSEFLT(0xB8),                            INS_FLAGS_None)
+INST3(popcnt,           "popcnt",           IUM_WR, BAD_CODE,     BAD_CODE,     SSEFLT(0xB8),                            Resets_OF      | Resets_SF     | Writes_ZF     | Resets_AF     | Resets_PF     | Resets_CF )
 
 //    id                nm                  um      mr            mi                                                     flags
-INST2(ret,              "ret",              IUM_RD, 0x0000C3,     0x0000C2,                                              INS_FLAGS_None)
-INST2(loop,             "loop",             IUM_RD, BAD_CODE,     0x0000E2,                                              INS_FLAGS_None)
-INST2(call,             "call",             IUM_RD, 0x0010FF,     0x0000E8,                                              INS_FLAGS_WritesFlags)
-
-INST2(rol,              "rol",              IUM_RW, 0x0000D2,     BAD_CODE,                                              INS_FLAGS_WritesFlags)
-INST2(rol_1,            "rol",              IUM_RW, 0x0000D0,     0x0000D0,                                              INS_FLAGS_WritesFlags)
-INST2(rol_N,            "rol",              IUM_RW, 0x0000C0,     0x0000C0,                                              INS_FLAGS_WritesFlags)
-INST2(ror,              "ror",              IUM_RW, 0x0008D2,     BAD_CODE,                                              INS_FLAGS_WritesFlags)
-INST2(ror_1,            "ror",              IUM_RW, 0x0008D0,     0x0008D0,                                              INS_FLAGS_WritesFlags)
-INST2(ror_N,            "ror",              IUM_RW, 0x0008C0,     0x0008C0,                                              INS_FLAGS_WritesFlags)
-
-INST2(rcl,              "rcl",              IUM_RW, 0x0010D2,     BAD_CODE,                                              INS_FLAGS_ReadsFlags | INS_FLAGS_WritesFlags)
-INST2(rcl_1,            "rcl",              IUM_RW, 0x0010D0,     0x0010D0,                                              INS_FLAGS_ReadsFlags | INS_FLAGS_WritesFlags)
-INST2(rcl_N,            "rcl",              IUM_RW, 0x0010C0,     0x0010C0,                                              INS_FLAGS_ReadsFlags | INS_FLAGS_WritesFlags)
-INST2(rcr,              "rcr",              IUM_RW, 0x0018D2,     BAD_CODE,                                              INS_FLAGS_ReadsFlags | INS_FLAGS_WritesFlags)
-INST2(rcr_1,            "rcr",              IUM_RW, 0x0018D0,     0x0018D0,                                              INS_FLAGS_ReadsFlags | INS_FLAGS_WritesFlags)
-INST2(rcr_N,            "rcr",              IUM_RW, 0x0018C0,     0x0018C0,                                              INS_FLAGS_ReadsFlags | INS_FLAGS_WritesFlags)
-INST2(shl,              "shl",              IUM_RW, 0x0020D2,     BAD_CODE,                                              INS_FLAGS_WritesFlags)
-INST2(shl_1,            "shl",              IUM_RW, 0x0020D0,     0x0020D0,                                              INS_FLAGS_WritesFlags)
-INST2(shl_N,            "shl",              IUM_RW, 0x0020C0,     0x0020C0,                                              INS_FLAGS_WritesFlags)
-INST2(shr,              "shr",              IUM_RW, 0x0028D2,     BAD_CODE,                                              INS_FLAGS_WritesFlags)
-INST2(shr_1,            "shr",              IUM_RW, 0x0028D0,     0x0028D0,                                              INS_FLAGS_WritesFlags)
-INST2(shr_N,            "shr",              IUM_RW, 0x0028C0,     0x0028C0,                                              INS_FLAGS_WritesFlags)
-INST2(sar,              "sar",              IUM_RW, 0x0038D2,     BAD_CODE,                                              INS_FLAGS_WritesFlags)
-INST2(sar_1,            "sar",              IUM_RW, 0x0038D0,     0x0038D0,                                              INS_FLAGS_WritesFlags)
-INST2(sar_N,            "sar",              IUM_RW, 0x0038C0,     0x0038C0,                                              INS_FLAGS_WritesFlags)
+INST2(ret,              "ret",              IUM_RD, 0x0000C3,     0x0000C2,                                              INS_FLAGS_None )
+INST2(loop,             "loop",             IUM_RD, BAD_CODE,     0x0000E2,                                              INS_FLAGS_None )
+INST2(call,             "call",             IUM_RD, 0x0010FF,     0x0000E8,                                              INS_FLAGS_None )
+
+INST2(rol,              "rol",              IUM_RW, 0x0000D2,     BAD_CODE,                                              Undefined_OF                                                                   | Writes_CF     )
+INST2(rol_1,            "rol",              IUM_RW, 0x0000D0,     0x0000D0,                                              Writes_OF                                                                      | Writes_CF     )
+INST2(rol_N,            "rol",              IUM_RW, 0x0000C0,     0x0000C0,                                              Undefined_OF                                                                   | Writes_CF     )
+INST2(ror,              "ror",              IUM_RW, 0x0008D2,     BAD_CODE,                                              Undefined_OF                                                                   | Writes_CF     )
+INST2(ror_1,            "ror",              IUM_RW, 0x0008D0,     0x0008D0,                                              Writes_OF                                                                      | Writes_CF     )
+INST2(ror_N,            "ror",              IUM_RW, 0x0008C0,     0x0008C0,                                              Undefined_OF                                                                   | Writes_CF     )
+
+INST2(rcl,              "rcl",              IUM_RW, 0x0010D2,     BAD_CODE,                                              Undefined_OF                                                                   | Writes_CF
+                                                                                                                                                                                                        | Reads_CF      )
+INST2(rcl_1,            "rcl",              IUM_RW, 0x0010D0,     0x0010D0,                                              Writes_OF                                                                      | Writes_CF
+                                                                                                                                                                                                        | Reads_CF      )
+INST2(rcl_N,            "rcl",              IUM_RW, 0x0010C0,     0x0010C0,                                              Undefined_OF                                                                   | Writes_CF
+                                                                                                                                                                                                        | Reads_CF      ) 
+INST2(rcr,              "rcr",              IUM_RW, 0x0018D2,     BAD_CODE,                                              Undefined_OF                                                                   | Writes_CF
+                                                                                                                                                                                                        | Reads_CF      )
+INST2(rcr_1,            "rcr",              IUM_RW, 0x0018D0,     0x0018D0,                                              Writes_OF                                                                      | Writes_CF
+                                                                                                                                                                                                        | Reads_CF      )   
+INST2(rcr_N,            "rcr",              IUM_RW, 0x0018C0,     0x0018C0,                                              Undefined_OF                                                                   | Writes_CF
+                                                                                                                                                                                                        | Reads_CF      )
+INST2(shl,              "shl",              IUM_RW, 0x0020D2,     BAD_CODE,                                              Undefined_OF   | Writes_SF     | Writes_ZF     | Undefined_AF  | Writes_PF     | Writes_CF     )
+INST2(shl_1,            "shl",              IUM_RW, 0x0020D0,     0x0020D0,                                              Writes_OF      | Writes_SF     | Writes_ZF     | Undefined_AF  | Writes_PF     | Writes_CF     )
+INST2(shl_N,            "shl",              IUM_RW, 0x0020C0,     0x0020C0,                                              Undefined_OF   | Writes_SF     | Writes_ZF     | Undefined_AF  | Writes_PF     | Writes_CF     )
+INST2(shr,              "shr",              IUM_RW, 0x0028D2,     BAD_CODE,                                              Undefined_OF   | Writes_SF     | Writes_ZF     | Undefined_AF  | Writes_PF     | Writes_CF     )
+INST2(shr_1,            "shr",              IUM_RW, 0x0028D0,     0x0028D0,                                              Writes_OF      | Writes_SF     | Writes_ZF     | Undefined_AF  | Writes_PF     | Writes_CF     )
+INST2(shr_N,            "shr",              IUM_RW, 0x0028C0,     0x0028C0,                                              Undefined_OF   | Writes_SF     | Writes_ZF     | Undefined_AF  | Writes_PF     | Writes_CF     )
+INST2(sar,              "sar",              IUM_RW, 0x0038D2,     BAD_CODE,                                              Undefined_OF   | Writes_SF     | Writes_ZF     | Undefined_AF  | Writes_PF     | Writes_CF     )
+INST2(sar_1,            "sar",              IUM_RW, 0x0038D0,     0x0038D0,                                              Writes_OF      | Writes_SF     | Writes_ZF     | Undefined_AF  | Writes_PF     | Writes_CF     )
+INST2(sar_N,            "sar",              IUM_RW, 0x0038C0,     0x0038C0,                                              Undefined_OF   | Writes_SF     | Writes_ZF     | Undefined_AF  | Writes_PF     | Writes_CF     )
 
 
 //    id                nm                  um      mr                                                                   flags
-INST1(r_movsb,          "rep movsb",        IUM_RD, 0x00A4F3,                                                            INS_FLAGS_None)
-INST1(r_movsd,          "rep movsd",        IUM_RD, 0x00A5F3,                                                            INS_FLAGS_None)
+INST1(r_movsb,          "rep movsb",        IUM_RD, 0x00A4F3,                                                            Reads_DF )
+INST1(r_movsd,          "rep movsd",        IUM_RD, 0x00A5F3,                                                            Reads_DF )
 #if defined(TARGET_AMD64)
-INST1(r_movsq,          "rep movsq",        IUM_RD, 0xF3A548,                                                            INS_FLAGS_None)
+INST1(r_movsq,          "rep movsq",        IUM_RD, 0xF3A548,                                                            Reads_DF )
 #endif // defined(TARGET_AMD64)
-INST1(movsb,            "movsb",            IUM_RD, 0x0000A4,                                                            INS_FLAGS_None)
-INST1(movsd,            "movsd",            IUM_RD, 0x0000A5,                                                            INS_FLAGS_None)
+INST1(movsb,            "movsb",            IUM_RD, 0x0000A4,                                                            Reads_DF   )
+INST1(movsd,            "movsd",            IUM_RD, 0x0000A5,                                                            Reads_DF   )
 #if defined(TARGET_AMD64)
-INST1(movsq,            "movsq",            IUM_RD, 0x00A548,                                                            INS_FLAGS_None)
+INST1(movsq,            "movsq",            IUM_RD, 0x00A548,                                                            Reads_DF   )
 #endif // defined(TARGET_AMD64)
 
-INST1(r_stosb,          "rep stosb",        IUM_RD, 0x00AAF3,                                                            INS_FLAGS_None)
-INST1(r_stosd,          "rep stosd",        IUM_RD, 0x00ABF3,                                                            INS_FLAGS_None)
+INST1(r_stosb,          "rep stosb",        IUM_RD, 0x00AAF3,                                                            Reads_DF   )
+INST1(r_stosd,          "rep stosd",        IUM_RD, 0x00ABF3,                                                            Reads_DF   )
 #if defined(TARGET_AMD64)
-INST1(r_stosq,          "rep stosq",        IUM_RD, 0xF3AB48,                                                            INS_FLAGS_None)
+INST1(r_stosq,          "rep stosq",        IUM_RD, 0xF3AB48,                                                            Reads_DF   )
 #endif // defined(TARGET_AMD64)
-INST1(stosb,            "stosb",            IUM_RD, 0x0000AA,                                                            INS_FLAGS_None)
-INST1(stosd,            "stosd",            IUM_RD, 0x0000AB,                                                            INS_FLAGS_None)
+INST1(stosb,            "stosb",            IUM_RD, 0x0000AA,                                                            Reads_DF   )
+INST1(stosd,            "stosd",            IUM_RD, 0x0000AB,                                                            Reads_DF   )
 #if defined(TARGET_AMD64)
-INST1(stosq,            "stosq",            IUM_RD, 0x00AB48,                                                            INS_FLAGS_None)
+INST1(stosq,            "stosq",            IUM_RD, 0x00AB48,                                                            Reads_DF   )
 #endif // defined(TARGET_AMD64)
 
-INST1(int3,             "int3",             IUM_RD, 0x0000CC,                                                            INS_FLAGS_None)
-INST1(nop,              "nop",              IUM_RD, 0x000090,                                                            INS_FLAGS_None)
-INST1(lock,             "lock",             IUM_RD, 0x0000F0,                                                            INS_FLAGS_None)
-INST1(leave,            "leave",            IUM_RD, 0x0000C9,                                                            INS_FLAGS_None)
+INST1(int3,             "int3",             IUM_RD, 0x0000CC,                                                            INS_FLAGS_None )
+INST1(nop,              "nop",              IUM_RD, 0x000090,                                                            INS_FLAGS_None )
+INST1(lock,             "lock",             IUM_RD, 0x0000F0,                                                            INS_FLAGS_None )
+INST1(leave,            "leave",            IUM_RD, 0x0000C9,                                                            INS_FLAGS_None )
 
 
-INST1(neg,              "neg",              IUM_RW, 0x0018F6,                                                            INS_FLAGS_WritesFlags)
-INST1(not,              "not",              IUM_RW, 0x0010F6,                                                            INS_FLAGS_WritesFlags)
+INST1(neg,              "neg",              IUM_RW, 0x0018F6,                                                            Writes_OF      | Writes_SF     | Writes_ZF     | Writes_AF     | Writes_PF     | Writes_CF     )
+INST1(not,              "not",              IUM_RW, 0x0010F6,                                                            INS_FLAGS_None )
 
-INST1(cdq,              "cdq",              IUM_RD, 0x000099,                                                            INS_FLAGS_WritesFlags)
-INST1(idiv,             "idiv",             IUM_RD, 0x0038F6,                                                            INS_FLAGS_WritesFlags)
-INST1(imulEAX,          "imul",             IUM_RD, 0x0028F6,                                                            INS_FLAGS_WritesFlags) // edx:eax = eax*op1
-INST1(div,              "div",              IUM_RD, 0x0030F6,                                                            INS_FLAGS_WritesFlags)
-INST1(mulEAX,           "mul",              IUM_RD, 0x0020F6,                                                            INS_FLAGS_WritesFlags)
+INST1(cdq,              "cdq",              IUM_RD, 0x000099,                                                            INS_FLAGS_None)
+INST1(idiv,             "idiv",             IUM_RD, 0x0038F6,                                                            Undefined_OF   | Undefined_SF  | Undefined_ZF  | Undefined_AF  | Undefined_PF  | Undefined_CF  )
+INST1(imulEAX,          "imul",             IUM_RD, 0x0028F6,                                                            Writes_OF      | Undefined_SF  | Undefined_ZF  | Undefined_AF  | Undefined_PF  | Writes_CF     )
+INST1(div,              "div",              IUM_RD, 0x0030F6,                                                            Undefined_OF   | Undefined_SF  | Undefined_ZF  | Undefined_AF  | Undefined_PF  | Undefined_CF  )
+INST1(mulEAX,           "mul",              IUM_RD, 0x0020F6,                                                            Writes_OF      | Undefined_SF  | Undefined_ZF  | Undefined_AF  | Undefined_PF  | Writes_CF     )
 
-INST1(sahf,             "sahf",             IUM_RD, 0x00009E,                                                            INS_FLAGS_WritesFlags)
+INST1(sahf,             "sahf",             IUM_RD, 0x00009E,                                                            Restore_SF_ZF_AF_PF_CF )
 
-INST1(xadd,             "xadd",             IUM_RW, 0x0F00C0,                                                            INS_FLAGS_WritesFlags)
-INST1(cmpxchg,          "cmpxchg",          IUM_RW, 0x0F00B0,                                                            INS_FLAGS_WritesFlags)
+INST1(xadd,             "xadd",             IUM_RW, 0x0F00C0,                                                            Writes_OF      | Writes_SF     | Writes_ZF     | Writes_AF     | Writes_PF     | Writes_CF     )
+INST1(cmpxchg,          "cmpxchg",          IUM_RW, 0x0F00B0,                                                            Writes_OF      | Writes_SF     | Writes_ZF     | Writes_AF     | Writes_PF     | Writes_CF     )
 
-INST1(shld,             "shld",             IUM_RW, 0x0F00A4,                                                            INS_FLAGS_WritesFlags)
-INST1(shrd,             "shrd",             IUM_RW, 0x0F00AC,                                                            INS_FLAGS_WritesFlags)
+INST1(shld,             "shld",             IUM_RW, 0x0F00A4,                                                            Undefined_OF   | Writes_SF     | Writes_ZF     | Undefined_AF  | Writes_PF     | Writes_CF     )
+INST1(shrd,             "shrd",             IUM_RW, 0x0F00AC,                                                            Undefined_OF   | Writes_SF     | Writes_ZF     | Undefined_AF  | Writes_PF     | Writes_CF     )
 
 // For RyuJIT/x86, we follow the x86 calling convention that requires
 // us to return floating point value on the x87 FP stack, so we need
@@ -704,22 +712,22 @@ INST1(fld,              "fld",              IUM_WR, 0x0000D9,
 INST1(fstp,             "fstp",             IUM_WR, 0x0018D9,                                                            INS_FLAGS_x87Instr)
 #endif // TARGET_X86
 
-INST1(seto,             "seto",             IUM_WR, 0x0F0090,                                                            INS_FLAGS_ReadsFlags)
-INST1(setno,            "setno",            IUM_WR, 0x0F0091,                                                            INS_FLAGS_ReadsFlags)
-INST1(setb,             "setb",             IUM_WR, 0x0F0092,                                                            INS_FLAGS_ReadsFlags)
-INST1(setae,            "setae",            IUM_WR, 0x0F0093,                                                            INS_FLAGS_ReadsFlags)
-INST1(sete,             "sete",             IUM_WR, 0x0F0094,                                                            INS_FLAGS_ReadsFlags)
-INST1(setne,            "setne",            IUM_WR, 0x0F0095,                                                            INS_FLAGS_ReadsFlags)
-INST1(setbe,            "setbe",            IUM_WR, 0x0F0096,                                                            INS_FLAGS_ReadsFlags)
-INST1(seta,             "seta",             IUM_WR, 0x0F0097,                                                            INS_FLAGS_ReadsFlags)
-INST1(sets,             "sets",             IUM_WR, 0x0F0098,                                                            INS_FLAGS_ReadsFlags)
-INST1(setns,            "setns",            IUM_WR, 0x0F0099,                                                            INS_FLAGS_ReadsFlags)
-INST1(setp,             "setp",             IUM_WR, 0x0F009A,                                                            INS_FLAGS_ReadsFlags)
-INST1(setnp,            "setnp",            IUM_WR, 0x0F009B,                                                            INS_FLAGS_ReadsFlags)
-INST1(setl,             "setl",             IUM_WR, 0x0F009C,                                                            INS_FLAGS_ReadsFlags)
-INST1(setge,            "setge",            IUM_WR, 0x0F009D,                                                            INS_FLAGS_ReadsFlags)
-INST1(setle,            "setle",            IUM_WR, 0x0F009E,                                                            INS_FLAGS_ReadsFlags)
-INST1(setg,             "setg",             IUM_WR, 0x0F009F,                                                            INS_FLAGS_ReadsFlags)
+INST1(seto,             "seto",             IUM_WR, 0x0F0090,                                                            Reads_OF )
+INST1(setno,            "setno",            IUM_WR, 0x0F0091,                                                            Reads_OF )
+INST1(setb,             "setb",             IUM_WR, 0x0F0092,                                                            Reads_CF )
+INST1(setae,            "setae",            IUM_WR, 0x0F0093,                                                            Reads_CF )
+INST1(sete,             "sete",             IUM_WR, 0x0F0094,                                                            Reads_ZF )
+INST1(setne,            "setne",            IUM_WR, 0x0F0095,                                                            Reads_ZF )
+INST1(setbe,            "setbe",            IUM_WR, 0x0F0096,                                                            Reads_ZF | Reads_CF )
+INST1(seta,             "seta",             IUM_WR, 0x0F0097,                                                            Reads_ZF | Reads_CF )
+INST1(sets,             "sets",             IUM_WR, 0x0F0098,                                                            Reads_SF )
+INST1(setns,            "setns",            IUM_WR, 0x0F0099,                                                            Reads_SF )
+INST1(setp,             "setp",             IUM_WR, 0x0F009A,                                                            Reads_PF )
+INST1(setnp,            "setnp",            IUM_WR, 0x0F009B,                                                            Reads_PF )
+INST1(setl,             "setl",             IUM_WR, 0x0F009C,                                                            Reads_OF       | Reads_SF  )
+INST1(setge,            "setge",            IUM_WR, 0x0F009D,                                                            Reads_OF       | Reads_SF  )
+INST1(setle,            "setle",            IUM_WR, 0x0F009E,                                                            Reads_OF       | Reads_SF      | Reads_ZF  )
+INST1(setg,             "setg",             IUM_WR, 0x0F009F,                                                            Reads_OF       | Reads_SF      | Reads_ZF  )
 
 #ifdef TARGET_AMD64
 // A jump with rex prefix. This is used for register indirect
@@ -727,43 +735,43 @@ INST1(setg,             "setg",             IUM_WR, 0x0F009F,
 INST1(rex_jmp,          "rex.jmp",          IUM_RD, 0x0020FE,                                                            INS_FLAGS_None)
 #endif
 
-INST1(i_jmp,            "jmp",              IUM_RD, 0x0020FE,                                                            INS_FLAGS_None)
-
-INST0(jmp,              "jmp",              IUM_RD, 0x0000EB,                                                            INS_FLAGS_None)
-INST0(jo,               "jo",               IUM_RD, 0x000070,                                                            INS_FLAGS_ReadsFlags)
-INST0(jno,              "jno",              IUM_RD, 0x000071,                                                            INS_FLAGS_ReadsFlags)
-INST0(jb,               "jb",               IUM_RD, 0x000072,                                                            INS_FLAGS_ReadsFlags)
-INST0(jae,              "jae",              IUM_RD, 0x000073,                                                            INS_FLAGS_ReadsFlags)
-INST0(je,               "je",               IUM_RD, 0x000074,                                                            INS_FLAGS_ReadsFlags)
-INST0(jne,              "jne",              IUM_RD, 0x000075,                                                            INS_FLAGS_ReadsFlags)
-INST0(jbe,              "jbe",              IUM_RD, 0x000076,                                                            INS_FLAGS_ReadsFlags)
-INST0(ja,               "ja",               IUM_RD, 0x000077,                                                            INS_FLAGS_ReadsFlags)
-INST0(js,               "js",               IUM_RD, 0x000078,                                                            INS_FLAGS_ReadsFlags)
-INST0(jns,              "jns",              IUM_RD, 0x000079,                                                            INS_FLAGS_ReadsFlags)
-INST0(jp,               "jp",               IUM_RD, 0x00007A,                                                            INS_FLAGS_ReadsFlags)
-INST0(jnp,              "jnp",              IUM_RD, 0x00007B,                                                            INS_FLAGS_ReadsFlags)
-INST0(jl,               "jl",               IUM_RD, 0x00007C,                                                            INS_FLAGS_ReadsFlags)
-INST0(jge,              "jge",              IUM_RD, 0x00007D,                                                            INS_FLAGS_ReadsFlags)
-INST0(jle,              "jle",              IUM_RD, 0x00007E,                                                            INS_FLAGS_ReadsFlags)
-INST0(jg,               "jg",               IUM_RD, 0x00007F,                                                            INS_FLAGS_ReadsFlags)
-
-INST0(l_jmp,            "jmp",              IUM_RD, 0x0000E9,                                                            INS_FLAGS_None)
-INST0(l_jo,             "jo",               IUM_RD, 0x00800F,                                                            INS_FLAGS_ReadsFlags)
-INST0(l_jno,            "jno",              IUM_RD, 0x00810F,                                                            INS_FLAGS_ReadsFlags)
-INST0(l_jb,             "jb",               IUM_RD, 0x00820F,                                                            INS_FLAGS_ReadsFlags)
-INST0(l_jae,            "jae",              IUM_RD, 0x00830F,                                                            INS_FLAGS_ReadsFlags)
-INST0(l_je,             "je",               IUM_RD, 0x00840F,                                                            INS_FLAGS_ReadsFlags)
-INST0(l_jne,            "jne",              IUM_RD, 0x00850F,                                                            INS_FLAGS_ReadsFlags)
-INST0(l_jbe,            "jbe",              IUM_RD, 0x00860F,                                                            INS_FLAGS_ReadsFlags)
-INST0(l_ja,             "ja",               IUM_RD, 0x00870F,                                                            INS_FLAGS_ReadsFlags)
-INST0(l_js,             "js",               IUM_RD, 0x00880F,                                                            INS_FLAGS_ReadsFlags)
-INST0(l_jns,            "jns",              IUM_RD, 0x00890F,                                                            INS_FLAGS_ReadsFlags)
-INST0(l_jp,             "jp",               IUM_RD, 0x008A0F,                                                            INS_FLAGS_ReadsFlags)
-INST0(l_jnp,            "jnp",              IUM_RD, 0x008B0F,                                                            INS_FLAGS_ReadsFlags)
-INST0(l_jl,             "jl",               IUM_RD, 0x008C0F,                                                            INS_FLAGS_ReadsFlags)
-INST0(l_jge,            "jge",              IUM_RD, 0x008D0F,                                                            INS_FLAGS_ReadsFlags)
-INST0(l_jle,            "jle",              IUM_RD, 0x008E0F,                                                            INS_FLAGS_ReadsFlags)
-INST0(l_jg,             "jg",               IUM_RD, 0x008F0F,                                                            INS_FLAGS_ReadsFlags)
+INST1(i_jmp,            "jmp",              IUM_RD, 0x0020FE,                                                            INS_FLAGS_None )
+
+INST0(jmp,              "jmp",              IUM_RD, 0x0000EB,                                                            INS_FLAGS_None )
+INST0(jo,               "jo",               IUM_RD, 0x000070,                                                            Reads_OF )
+INST0(jno,              "jno",              IUM_RD, 0x000071,                                                            Reads_OF )
+INST0(jb,               "jb",               IUM_RD, 0x000072,                                                            Reads_CF )
+INST0(jae,              "jae",              IUM_RD, 0x000073,                                                            Reads_CF )
+INST0(je,               "je",               IUM_RD, 0x000074,                                                            Reads_ZF )
+INST0(jne,              "jne",              IUM_RD, 0x000075,                                                            Reads_ZF )
+INST0(jbe,              "jbe",              IUM_RD, 0x000076,                                                            Reads_ZF | Reads_CF )
+INST0(ja,               "ja",               IUM_RD, 0x000077,                                                            Reads_ZF | Reads_CF )
+INST0(js,               "js",               IUM_RD, 0x000078,                                                            Reads_SF )
+INST0(jns,              "jns",              IUM_RD, 0x000079,                                                            Reads_SF )
+INST0(jp,               "jp",               IUM_RD, 0x00007A,                                                            Reads_PF )
+INST0(jnp,              "jnp",              IUM_RD, 0x00007B,                                                            Reads_PF )
+INST0(jl,               "jl",               IUM_RD, 0x00007C,                                                            Reads_OF       | Reads_SF  )
+INST0(jge,              "jge",              IUM_RD, 0x00007D,                                                            Reads_OF       | Reads_SF  )
+INST0(jle,              "jle",              IUM_RD, 0x00007E,                                                            Reads_OF       | Reads_SF      | Reads_ZF  )
+INST0(jg,               "jg",               IUM_RD, 0x00007F,                                                            Reads_OF       | Reads_SF      | Reads_ZF  )
+
+INST0(l_jmp,            "jmp",              IUM_RD, 0x0000E9,                                                            INS_FLAGS_None )
+INST0(l_jo,             "jo",               IUM_RD, 0x00800F,                                                            Reads_OF )
+INST0(l_jno,            "jno",              IUM_RD, 0x00810F,                                                            Reads_OF )
+INST0(l_jb,             "jb",               IUM_RD, 0x00820F,                                                            Reads_CF )
+INST0(l_jae,            "jae",              IUM_RD, 0x00830F,                                                            Reads_CF )
+INST0(l_je,             "je",               IUM_RD, 0x00840F,                                                            Reads_ZF )
+INST0(l_jne,            "jne",              IUM_RD, 0x00850F,                                                            Reads_ZF )
+INST0(l_jbe,            "jbe",              IUM_RD, 0x00860F,                                                            Reads_ZF | Reads_CF )
+INST0(l_ja,             "ja",               IUM_RD, 0x00870F,                                                            Reads_ZF | Reads_CF )
+INST0(l_js,             "js",               IUM_RD, 0x00880F,                                                            Reads_SF )
+INST0(l_jns,            "jns",              IUM_RD, 0x00890F,                                                            Reads_SF )
+INST0(l_jp,             "jp",               IUM_RD, 0x008A0F,                                                            Reads_PF )
+INST0(l_jnp,            "jnp",              IUM_RD, 0x008B0F,                                                            Reads_PF )
+INST0(l_jl,             "jl",               IUM_RD, 0x008C0F,                                                            Reads_OF       | Reads_SF  )
+INST0(l_jge,            "jge",              IUM_RD, 0x008D0F,                                                            Reads_OF       | Reads_SF  )
+INST0(l_jle,            "jle",              IUM_RD, 0x008E0F,                                                            Reads_OF       | Reads_SF      | Reads_ZF  )
+INST0(l_jg,             "jg",               IUM_RD, 0x008F0F,                                                            Reads_OF       | Reads_SF      | Reads_ZF  )
 
 INST0(align,            "align",            IUM_RD, BAD_CODE,                                                            INS_FLAGS_None)
 
diff --git a/src/coreclr/jit/jit.h b/src/coreclr/jit/jit.h
index 1a5c80c3218aa1..2dd39559c282ee 100644
--- a/src/coreclr/jit/jit.h
+++ b/src/coreclr/jit/jit.h
@@ -86,9 +86,6 @@
 #if defined(TARGET_ARM64)
 #error Cannot define both TARGET_X86 and TARGET_ARM64
 #endif
-#if !defined(HOST_X86)
-#define _CROSS_COMPILER_
-#endif
 #elif defined(TARGET_AMD64)
 #if defined(TARGET_X86)
 #error Cannot define both TARGET_AMD64 and TARGET_X86
@@ -99,9 +96,6 @@
 #if defined(TARGET_ARM64)
 #error Cannot define both TARGET_AMD64 and TARGET_ARM64
 #endif
-#if !defined(HOST_AMD64)
-#define _CROSS_COMPILER_
-#endif
 #elif defined(TARGET_ARM)
 #if defined(TARGET_X86)
 #error Cannot define both TARGET_ARM and TARGET_X86
@@ -112,9 +106,6 @@
 #if defined(TARGET_ARM64)
 #error Cannot define both TARGET_ARM and TARGET_ARM64
 #endif
-#if !defined(HOST_ARM)
-#define _CROSS_COMPILER_
-#endif
 #elif defined(TARGET_ARM64)
 #if defined(TARGET_X86)
 #error Cannot define both TARGET_ARM64 and TARGET_X86
@@ -125,9 +116,6 @@
 #if defined(TARGET_ARM)
 #error Cannot define both TARGET_ARM64 and TARGET_ARM
 #endif
-#if !defined(HOST_ARM64)
-#define _CROSS_COMPILER_
-#endif
 #else
 #error Unsupported or unset target architecture
 #endif
@@ -198,11 +186,9 @@
 
 #ifdef DEBUG
 #define INDEBUG(x) x
-#define INDEBUG_COMMA(x) x,
 #define DEBUGARG(x) , x
 #else
 #define INDEBUG(x)
-#define INDEBUG_COMMA(x)
 #define DEBUGARG(x)
 #endif
 
@@ -223,7 +209,7 @@
 #if defined(DEBUG) && !defined(OSX_ARM64_ABI)
 // On all platforms except Arm64 OSX arguments on the stack are taking
 // register size slots. On these platforms we could check that stack slots count
-// matchs out new byte size calculations.
+// matches our new byte size calculations.
 #define DEBUG_ARG_SLOTS
 #endif
 
@@ -239,11 +225,6 @@
 
 #if defined(UNIX_AMD64_ABI) || !defined(TARGET_64BIT) || defined(TARGET_ARM64)
 #define FEATURE_PUT_STRUCT_ARG_STK 1
-#define PUT_STRUCT_ARG_STK_ONLY_ARG(x) , x
-#define PUT_STRUCT_ARG_STK_ONLY(x) x
-#else
-#define PUT_STRUCT_ARG_STK_ONLY_ARG(x)
-#define PUT_STRUCT_ARG_STK_ONLY(x)
 #endif
 
 #if defined(UNIX_AMD64_ABI)
@@ -297,8 +278,6 @@ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
 #define INFO6 LL_INFO10000   // Did Jit or Inline succeeded?
 #define INFO7 LL_INFO100000  // NYI stuff
 #define INFO8 LL_INFO1000000 // Weird failures
-#define INFO9 LL_EVERYTHING  // Info about incoming settings
-#define INFO10 LL_EVERYTHING // Totally verbose
 
 #endif // DEBUG
 
@@ -308,11 +287,6 @@ const CORINFO_CLASS_HANDLE NO_CLASS_HANDLE = (CORINFO_CLASS_HANDLE) nullptr;
 
 /*****************************************************************************/
 
-inline bool False()
-{
-    return false;
-} // Use to disable code while keeping prefast happy
-
 // We define two IL offset types, as follows:
 //
 // IL_OFFSET:  either a distinguished value, or an IL offset.
@@ -496,21 +470,17 @@ class GlobalJitOptions
 #endif
 
 /*****************************************************************************/
-#ifdef DEBUG
-/*****************************************************************************/
-
-#define DUMPER
-
-#else // !DEBUG
+#if !defined(DEBUG)
 
 #if DUMP_GC_TABLES
 #pragma message("NOTE: this non-debug build has GC ptr table dumping always enabled!")
-const bool            dspGCtbls      = true;
+const bool dspGCtbls = true;
 #endif
 
-/*****************************************************************************/
 #endif // !DEBUG
 
+/*****************************************************************************/
+
 #ifdef DEBUG
 #define JITDUMP(...)                                                                                                   \
     {                                                                                                                  \
@@ -591,21 +561,8 @@ inline bool IsUninitialized(T data);
 
 /*****************************************************************************/
 
-enum accessLevel
-{
-    ACL_NONE,
-    ACL_PRIVATE,
-    ACL_DEFAULT,
-    ACL_PROTECTED,
-    ACL_PUBLIC,
-};
-
-/*****************************************************************************/
-
 #define castto(var, typ) (*(typ*)&var)
 
-#define sizeto(typ, mem) (offsetof(typ, mem) + sizeof(((typ*)0)->mem))
-
 /*****************************************************************************/
 
 #ifdef NO_MISALIGNED_ACCESS
@@ -645,23 +602,11 @@ inline size_t roundUp(size_t size, size_t mult = sizeof(size_t))
     return (size + (mult - 1)) & ~(mult - 1);
 }
 
-inline size_t roundDn(size_t size, size_t mult = sizeof(size_t))
-{
-    assert(mult && ((mult & (mult - 1)) == 0)); // power of two test
-
-    return (size) & ~(mult - 1);
-}
-
 #ifdef HOST_64BIT
 inline unsigned int roundUp(unsigned size, unsigned mult)
 {
     return (unsigned int)roundUp((size_t)size, (size_t)mult);
 }
-
-inline unsigned int roundDn(unsigned size, unsigned mult)
-{
-    return (unsigned int)roundDn((size_t)size, (size_t)mult);
-}
 #endif // HOST_64BIT
 
 inline unsigned int unsigned_abs(int x)
@@ -698,12 +643,6 @@ class Histogram
 
 #endif // CALL_ARG_STATS || COUNT_BASIC_BLOCKS || COUNT_LOOPS || EMITTER_STATS || MEASURE_NODE_SIZE
 
-/*****************************************************************************/
-#ifdef ICECAP
-#include "icapexp.h"
-#include "icapctrl.h"
-#endif
-
 /*****************************************************************************/
 
 #include "error.h"
@@ -783,10 +722,6 @@ extern int jitNativeCode(CORINFO_METHOD_HANDLE methodHnd,
 const size_t MAX_USHORT_SIZE_T   = static_cast<size_t>(static_cast<unsigned short>(-1));
 const size_t MAX_UNSIGNED_SIZE_T = static_cast<size_t>(static_cast<unsigned>(-1));
 
-// These assume 2's complement...
-const int MAX_SHORT_AS_INT = 32767;
-const int MIN_SHORT_AS_INT = -32768;
-
 /*****************************************************************************/
 
 class Compiler;
diff --git a/src/coreclr/jit/jitconfigvalues.h b/src/coreclr/jit/jitconfigvalues.h
index 5d1cd06faaad9d..b1c9e522883209 100644
--- a/src/coreclr/jit/jitconfigvalues.h
+++ b/src/coreclr/jit/jitconfigvalues.h
@@ -26,10 +26,12 @@ CONFIG_INTEGER(DiffableDasm, W("JitDiffableDasm"), 0)          // Make the disas
 CONFIG_INTEGER(JitDasmWithAddress, W("JitDasmWithAddress"), 0) // Print the process address next to each instruction of
                                                                // the disassembly
 CONFIG_INTEGER(DisplayLoopHoistStats, W("JitLoopHoistStats"), 0) // Display JIT loop hoisting statistics
-CONFIG_INTEGER(DisplayLsraStats, W("JitLsraStats"), 0) // Display JIT Linear Scan Register Allocator statistics
-                                                       // if set to 1. If set to "2", display the stats in csv format.
-                                                       // Recommended to use with JitStdOutFile flag.
-CONFIG_STRING(JitLsraOrdering, W("JitLsraOrdering"))   // LSRA heuristics ordering
+CONFIG_INTEGER(DisplayLsraStats, W("JitLsraStats"), 0)       // Display JIT Linear Scan Register Allocator statistics
+                                                             // If set to "1", display the stats in textual format.
+                                                             // If set to "2", display the stats in csv format.
+                                                             // If set to "3", display the stats in summarize format.
+                                                             // Recommended to use with JitStdOutFile flag.
+CONFIG_STRING(JitLsraOrdering, W("JitLsraOrdering"))         // LSRA heuristics ordering
 CONFIG_INTEGER(DumpJittedMethods, W("DumpJittedMethods"), 0) // Prints all jitted methods to the console
 CONFIG_INTEGER(EnablePCRelAddr, W("JitEnablePCRelAddr"), 1)  // Whether absolute addr be encoded as PC-rel offset by
                                                              // RyuJIT where possible
@@ -439,6 +441,8 @@ CONFIG_INTEGER(JitInlineDumpData, W("JitInlineDumpData"), 0)
 CONFIG_INTEGER(JitInlineDumpXml, W("JitInlineDumpXml"), 0) // 1 = full xml (+ failures in DEBUG)
                                                            // 2 = only methods with inlines (+ failures in DEBUG)
                                                            // 3 = only methods with inlines, no failures
+CONFIG_STRING(JitInlineDumpXmlFile, W("JitInlineDumpXmlFile"))
+CONFIG_INTEGER(JitInlinePolicyDumpXml, W("JitInlinePolicyDumpXml"), 0)
 CONFIG_INTEGER(JitInlineLimit, W("JitInlineLimit"), -1)
 CONFIG_INTEGER(JitInlinePolicyDiscretionary, W("JitInlinePolicyDiscretionary"), 0)
 CONFIG_INTEGER(JitInlinePolicyFull, W("JitInlinePolicyFull"), 0)
diff --git a/src/coreclr/jit/jiteh.cpp b/src/coreclr/jit/jiteh.cpp
index f0adcfce6be185..da431dd82e2de9 100644
--- a/src/coreclr/jit/jiteh.cpp
+++ b/src/coreclr/jit/jiteh.cpp
@@ -870,10 +870,7 @@ bool Compiler::ehCanDeleteEmptyBlock(BasicBlock* block)
  */
 void Compiler::ehUpdateLastBlocks(BasicBlock* oldLast, BasicBlock* newLast)
 {
-    EHblkDsc* HBtab;
-    EHblkDsc* HBtabEnd;
-
-    for (HBtab = compHndBBtab, HBtabEnd = compHndBBtab + compHndBBtabCount; HBtab < HBtabEnd; HBtab++)
+    for (EHblkDsc* const HBtab : EHClauses(this))
     {
         if (HBtab->ebdTryLast == oldLast)
         {
@@ -1004,11 +1001,9 @@ bool Compiler::ehAnyFunclets()
 
 unsigned Compiler::ehFuncletCount()
 {
-    unsigned  funcletCnt = 0;
-    EHblkDsc* HBtab;
-    EHblkDsc* HBtabEnd;
+    unsigned funcletCnt = 0;
 
-    for (HBtab = compHndBBtab, HBtabEnd = compHndBBtab + compHndBBtabCount; HBtab < HBtabEnd; HBtab++)
+    for (EHblkDsc* const HBtab : EHClauses(this))
     {
         if (HBtab->HasFilter())
         {
@@ -1420,9 +1415,7 @@ void Compiler::fgRemoveEHTableEntry(unsigned XTnum)
 
         HBtab = compHndBBtab + XTnum;
 
-        EHblkDsc* xtabEnd;
-        EHblkDsc* xtab;
-        for (xtab = compHndBBtab, xtabEnd = compHndBBtab + compHndBBtabCount; xtab < xtabEnd; xtab++)
+        for (EHblkDsc* const xtab : EHClauses(this))
         {
             if ((xtab != HBtab) && (xtab->ebdEnclosingTryIndex != EHblkDsc::NO_ENCLOSING_INDEX) &&
                 (xtab->ebdEnclosingTryIndex >= XTnum))
@@ -1457,7 +1450,7 @@ void Compiler::fgRemoveEHTableEntry(unsigned XTnum)
 
         /* We need to update all of the blocks' bbTryIndex */
 
-        for (BasicBlock* blk = fgFirstBB; blk; blk = blk->bbNext)
+        for (BasicBlock* const blk : Blocks())
         {
             if (blk->hasTryIndex())
             {
@@ -1518,9 +1511,7 @@ EHblkDsc* Compiler::fgAddEHTableEntry(unsigned XTnum)
     {
         // Update all enclosing links that will get invalidated by inserting an entry at 'XTnum'
 
-        EHblkDsc* xtabEnd;
-        EHblkDsc* xtab;
-        for (xtab = compHndBBtab, xtabEnd = compHndBBtab + compHndBBtabCount; xtab < xtabEnd; xtab++)
+        for (EHblkDsc* const xtab : EHClauses(this))
         {
             if ((xtab->ebdEnclosingTryIndex != EHblkDsc::NO_ENCLOSING_INDEX) && (xtab->ebdEnclosingTryIndex >= XTnum))
             {
@@ -1536,7 +1527,7 @@ EHblkDsc* Compiler::fgAddEHTableEntry(unsigned XTnum)
 
         // We need to update the BasicBlock bbTryIndex and bbHndIndex field for all blocks
 
-        for (BasicBlock* blk = fgFirstBB; blk; blk = blk->bbNext)
+        for (BasicBlock* const blk : Blocks())
         {
             if (blk->hasTryIndex() && (blk->getTryIndex() >= XTnum))
             {
@@ -1762,8 +1753,7 @@ void Compiler::fgRemoveEH()
 #ifdef DEBUG
     // Make sure none of the remaining blocks have any EH.
 
-    BasicBlock* blk;
-    foreach_block(this, blk)
+    for (BasicBlock* const blk : Blocks())
     {
         assert(!blk->hasTryIndex());
         assert(!blk->hasHndIndex());
@@ -3124,9 +3114,8 @@ void Compiler::fgVerifyHandlerTab()
     unsigned* blockNumMap   = (unsigned*)_alloca(blockNumBytes);
     memset(blockNumMap, 0, blockNumBytes);
 
-    BasicBlock* block;
-    unsigned    newBBnum = 1;
-    for (block = fgFirstBB; block != nullptr; block = block->bbNext)
+    unsigned newBBnum = 1;
+    for (BasicBlock* const block : Blocks())
     {
         assert((block->bbFlags & BBF_REMOVED) == 0);
         assert(1 <= block->bbNum && block->bbNum <= bbNumMax);
@@ -3151,15 +3140,12 @@ void Compiler::fgVerifyHandlerTab()
 #endif
 
     // To verify that bbCatchTyp is set properly on all blocks, and that some BBF_* flags are only set on the first
-    // block
-    // of 'try' or handlers, create two bool arrays indexed by block number: one for the set of blocks that are the
-    // beginning
-    // blocks of 'try' regions, and one for blocks that are the beginning of handlers (including filters). Note that
-    // since
-    // this checking function runs before EH normalization, we have to handle the case where blocks can be both the
-    // beginning
-    // of a 'try' as well as the beginning of a handler. After we've iterated over the EH table, loop
-    // over all blocks and verify that only handler begin blocks have bbCatchTyp == BBCT_NONE, and some other things.
+    // block of 'try' or handlers, create two bool arrays indexed by block number: one for the set of blocks that
+    // are the beginning blocks of 'try' regions, and one for blocks that are the beginning of handlers (including
+    // filters). Note that since this checking function runs before EH normalization, we have to handle the case
+    // where blocks can be both the beginning of a 'try' as well as the beginning of a handler. After we've iterated
+    // over the EH table, loop over all blocks and verify that only handler begin blocks have bbCatchTyp == BBCT_NONE,
+    // and some other things.
 
     size_t blockBoolSetBytes = (bbNumMax + 1) * sizeof(bool);
     bool*  blockTryBegSet    = (bool*)_alloca(blockBoolSetBytes);
@@ -3495,6 +3481,8 @@ void Compiler::fgVerifyHandlerTab()
     // otherwise set. The duplicate clause handler is truly a duplicate of
     // a previously processed handler, so we ignore it.
 
+    BasicBlock* block;
+
     size_t          blockIndexBytes = (bbNumMax + 1) * sizeof(unsigned short);
     unsigned short* blockTryIndex   = (unsigned short*)_alloca(blockIndexBytes);
     unsigned short* blockHndIndex   = (unsigned short*)_alloca(blockIndexBytes);
@@ -3556,7 +3544,7 @@ void Compiler::fgVerifyHandlerTab()
 #endif // FEATURE_EH_FUNCLETS
 
     // Make sure that all blocks have the right index, including those blocks that should have zero (no EH region).
-    for (block = fgFirstBB; block != nullptr; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
         assert(block->bbTryIndex == blockTryIndex[block->bbNum]);
         assert(block->bbHndIndex == blockHndIndex[block->bbNum]);
@@ -4088,12 +4076,12 @@ void Compiler::fgClearFinallyTargetBit(BasicBlock* block)
     assert(fgComputePredsDone);
     assert((block->bbFlags & BBF_FINALLY_TARGET) != 0);
 
-    for (flowList* pred = block->bbPreds; pred; pred = pred->flNext)
+    for (BasicBlock* const predBlock : block->PredBlocks())
     {
-        if (pred->getBlock()->bbJumpKind == BBJ_ALWAYS && pred->getBlock()->bbJumpDest == block)
+        if (predBlock->bbJumpKind == BBJ_ALWAYS && predBlock->bbJumpDest == block)
         {
-            BasicBlock* pPrev = pred->getBlock()->bbPrev;
-            if (pPrev != NULL)
+            BasicBlock* pPrev = predBlock->bbPrev;
+            if (pPrev != nullptr)
             {
                 if (pPrev->bbJumpKind == BBJ_CALLFINALLY)
                 {
@@ -4241,12 +4229,8 @@ bool Compiler::fgAnyIntraHandlerPreds(BasicBlock* block)
     assert(block->hasHndIndex());
     assert(fgFirstBlockOfHandler(block) == block); // this block is the first block of a handler
 
-    flowList* pred;
-
-    for (pred = block->bbPreds; pred; pred = pred->flNext)
+    for (BasicBlock* const predBlock : block->PredBlocks())
     {
-        BasicBlock* predBlock = pred->getBlock();
-
         if (fgIsIntraHandlerPred(predBlock, block))
         {
             // We have a predecessor that is not from our try region
@@ -4395,10 +4379,7 @@ void Compiler::fgExtendEHRegionBefore(BasicBlock* block)
     bPrev->bbCatchTyp = block->bbCatchTyp;
     block->bbCatchTyp = BBCT_NONE;
 
-    EHblkDsc* HBtab;
-    EHblkDsc* HBtabEnd;
-
-    for (HBtab = compHndBBtab, HBtabEnd = compHndBBtab + compHndBBtabCount; HBtab < HBtabEnd; HBtab++)
+    for (EHblkDsc* const HBtab : EHClauses(this))
     {
         /* Multiple pointers in EHblkDsc can point to same block. We can not early out after the first match. */
         if (HBtab->ebdTryBeg == block)
diff --git a/src/coreclr/jit/lclmorph.cpp b/src/coreclr/jit/lclmorph.cpp
index bfa47db004ab6a..349c5ef88e542f 100644
--- a/src/coreclr/jit/lclmorph.cpp
+++ b/src/coreclr/jit/lclmorph.cpp
@@ -1212,12 +1212,12 @@ void Compiler::fgMarkAddressExposedLocals()
 
     LocalAddressVisitor visitor(this);
 
-    for (BasicBlock* block = fgFirstBB; block != nullptr; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
         // Make the current basic block address available globally
         compCurBB = block;
 
-        for (Statement* stmt : block->Statements())
+        for (Statement* const stmt : block->Statements())
         {
             visitor.VisitStmt(stmt);
         }
diff --git a/src/coreclr/jit/lclvars.cpp b/src/coreclr/jit/lclvars.cpp
index e517df3bde5ea9..9f1c01042a4b8a 100644
--- a/src/coreclr/jit/lclvars.cpp
+++ b/src/coreclr/jit/lclvars.cpp
@@ -4246,7 +4246,7 @@ void Compiler::lvaMarkLocalVars(BasicBlock* block, bool isRecompute)
     JITDUMP("\n*** %s local variables in block " FMT_BB " (weight=%s)\n", isRecompute ? "recomputing" : "marking",
             block->bbNum, refCntWtd2str(block->getBBWeight(this)));
 
-    for (Statement* stmt : StatementList(block->FirstNonPhiDef()))
+    for (Statement* const stmt : block->NonPhiStatements())
     {
         MarkLocalVarsVisitor visitor(this, block, stmt, isRecompute);
         DISPSTMT(stmt);
@@ -4514,7 +4514,7 @@ void Compiler::lvaComputeRefCounts(bool isRecompute, bool setSlotNumbers)
     JITDUMP("\n*** lvaComputeRefCounts -- explicit counts ***\n");
 
     // Second, account for all explicit local variable references
-    for (BasicBlock* block = fgFirstBB; block; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
         if (block->IsLIR())
         {
@@ -6273,15 +6273,25 @@ void Compiler::lvaAssignVirtualFrameOffsetsToLocals()
     //
     // Inlining done under OSR may introduce new reporting, in which case the OSR frame
     // must allocate a slot.
-    if (!opts.IsOSR() && lvaReportParamTypeArg())
+    if (lvaReportParamTypeArg())
     {
 #ifdef JIT32_GCENCODER
         noway_assert(codeGen->isFramePointerUsed());
 #endif
-        // For CORINFO_CALLCONV_PARAMTYPE (if needed)
-        lvaIncrementFrameSize(TARGET_POINTER_SIZE);
-        stkOffs -= TARGET_POINTER_SIZE;
-        lvaCachedGenericContextArgOffs = stkOffs;
+        if (opts.IsOSR())
+        {
+            PatchpointInfo* ppInfo = info.compPatchpointInfo;
+            assert(ppInfo->HasGenericContextArgOffset());
+            const int originalOffset       = ppInfo->GenericContextArgOffset();
+            lvaCachedGenericContextArgOffs = originalFrameStkOffs + originalOffset;
+        }
+        else
+        {
+            // For CORINFO_CALLCONV_PARAMTYPE (if needed)
+            lvaIncrementFrameSize(TARGET_POINTER_SIZE);
+            stkOffs -= TARGET_POINTER_SIZE;
+            lvaCachedGenericContextArgOffs = stkOffs;
+        }
     }
 #ifndef JIT32_GCENCODER
     else if (lvaKeepAliveAndReportThis())
@@ -6292,7 +6302,7 @@ void Compiler::lvaAssignVirtualFrameOffsetsToLocals()
             PatchpointInfo* ppInfo = info.compPatchpointInfo;
             if (ppInfo->HasKeptAliveThis())
             {
-                int originalOffset             = ppInfo->KeptAliveThisOffset();
+                const int originalOffset       = ppInfo->KeptAliveThisOffset();
                 lvaCachedGenericContextArgOffs = originalFrameStkOffs + originalOffset;
                 canUseExistingSlot             = true;
             }
@@ -7753,25 +7763,24 @@ int Compiler::lvaGetCallerSPRelativeOffset(unsigned varNum)
     return lvaToCallerSPRelativeOffset(varDsc->GetStackOffset(), varDsc->lvFramePointerBased);
 }
 
-int Compiler::lvaToCallerSPRelativeOffset(int offset, bool isFpBased) const
+//-----------------------------------------------------------------------------
+// lvaToCallerSPRelativeOffset: translate a frame offset into an offset from
+//    the caller's stack pointer.
+//
+// Arguments:
+//    offset - frame offset
+//    isFpBase - if true, offset is from FP, otherwise offset is from SP
+//    forRootFrame - if the current method is an OSR method, adjust the offset
+//      to be relative to the SP for the root method, instead of being relative
+//      to the SP for the OSR method.
+//
+// Returins:
+//    suitable offset
+//
+int Compiler::lvaToCallerSPRelativeOffset(int offset, bool isFpBased, bool forRootFrame) const
 {
     assert(lvaDoneFrameLayout == FINAL_FRAME_LAYOUT);
 
-    // TODO-Cleanup
-    //
-    // This current should not be called for OSR as caller SP relative
-    // offsets computed below do not reflect the extra stack space
-    // taken up by the original method frame.
-    //
-    // We should make it work.
-    //
-    // Instead we record the needed offsets in the patchpoint info
-    // when doing the original method compile(see special offsets
-    // in generatePatchpointInfo) and consume those values in the OSR
-    // compile. If we fix this we may be able to reduce the size
-    // of the patchpoint info and have less special casing for these
-    // frame slots.
-
     if (isFpBased)
     {
         offset += codeGen->genCallerSPtoFPdelta();
@@ -7781,6 +7790,30 @@ int Compiler::lvaToCallerSPRelativeOffset(int offset, bool isFpBased) const
         offset += codeGen->genCallerSPtoInitialSPdelta();
     }
 
+#ifdef TARGET_AMD64
+    if (forRootFrame && opts.IsOSR())
+    {
+        // The offset computed above already includes the OSR frame adjustment, plus the
+        // pop of the "pseudo return address" from the OSR frame.
+        //
+        // To get to root method caller-SP, we need to subtract off the original frame
+        // size and the pushed return address and RBP for that frame (which we know is an
+        // RPB frame).
+        //
+        // ppInfo's FpToSpDelta also accounts for the popped pseudo return address
+        // between the original method frame and the OSR frame. So the net adjustment
+        // is simply FpToSpDelta plus one register.
+        //
+
+        const PatchpointInfo* const ppInfo     = info.compPatchpointInfo;
+        const int                   adjustment = ppInfo->FpToSpDelta() + REGSIZE_BYTES;
+        offset -= adjustment;
+    }
+#else
+    // OSR NYI for other targets.
+    assert(!opts.IsOSR());
+#endif
+
     return offset;
 }
 
diff --git a/src/coreclr/jit/lir.cpp b/src/coreclr/jit/lir.cpp
index b34b35f8a9c367..db941e7638dcf6 100644
--- a/src/coreclr/jit/lir.cpp
+++ b/src/coreclr/jit/lir.cpp
@@ -1583,6 +1583,11 @@ LIR::Range& LIR::AsRange(BasicBlock* block)
     return *static_cast<Range*>(block);
 }
 
+const LIR::Range& LIR::AsRange(const BasicBlock* block)
+{
+    return *static_cast<const Range*>(block);
+}
+
 //------------------------------------------------------------------------
 // LIR::EmptyRange: Constructs and returns an empty range.
 //
diff --git a/src/coreclr/jit/lir.h b/src/coreclr/jit/lir.h
index a700bb16728558..f205527df5c716 100644
--- a/src/coreclr/jit/lir.h
+++ b/src/coreclr/jit/lir.h
@@ -298,6 +298,7 @@ class LIR final
 
 public:
     static Range& AsRange(BasicBlock* block);
+    static const LIR::Range& LIR::AsRange(const BasicBlock* block);
 
     static Range EmptyRange();
     static Range SeqTree(Compiler* compiler, GenTree* tree);
diff --git a/src/coreclr/jit/liveness.cpp b/src/coreclr/jit/liveness.cpp
index 20366bd8f1b5e2..745cbb9d1a9af3 100644
--- a/src/coreclr/jit/liveness.cpp
+++ b/src/coreclr/jit/liveness.cpp
@@ -508,10 +508,10 @@ void Compiler::fgPerBlockLocalVarLiveness()
         }
         else
         {
-            for (Statement* stmt : StatementList(block->FirstNonPhiDef()))
+            for (Statement* const stmt : block->NonPhiStatements())
             {
                 compCurStmt = stmt;
-                for (GenTree* node = stmt->GetTreeList(); node != nullptr; node = node->gtNext)
+                for (GenTree* const node : stmt->TreeList())
                 {
                     fgPerNodeLocalVarLiveness(node);
                 }
@@ -680,8 +680,7 @@ void Compiler::fgDispDebugScopes()
 {
     printf("\nDebug scopes:\n");
 
-    BasicBlock* block;
-    for (block = fgFirstBB; block; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
         printf(FMT_BB ": ", block->bbNum);
         dumpConvertedVarSet(this, block->bbScope);
@@ -719,7 +718,7 @@ void Compiler::fgExtendDbgScopes()
     // Mark all tracked LocalVars live over their scope - walk the blocks
     // keeping track of the current life, and assign it to the blocks.
 
-    for (BasicBlock* block = fgFirstBB; block; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
         // If we get to a funclet, reset the scope lists and start again, since the block
         // offsets will be out of order compared to the previous block.
@@ -772,8 +771,7 @@ void Compiler::fgExtendDbgScopes()
     // Mark all tracked LocalVars live over their scope - walk the blocks
     // keeping track of the current life, and assign it to the blocks.
 
-    BasicBlock* block;
-    for (block = fgFirstBB; block; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
         // Find scopes becoming alive. If there is a gap in the instr
         // sequence, we need to process any scopes on those missing offsets.
@@ -915,7 +913,7 @@ void Compiler::fgExtendDbgLifetimes()
 
     VARSET_TP initVars(VarSetOps::MakeEmpty(this)); // Vars which are artificially made alive
 
-    for (BasicBlock* block = fgFirstBB; block; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
         VarSetOps::ClearD(this, initVars);
 
@@ -949,19 +947,11 @@ void Compiler::fgExtendDbgLifetimes()
                 break;
 
             case BBJ_SWITCH:
-            {
-                BasicBlock** jmpTab;
-                unsigned     jmpCnt;
-
-                jmpCnt = block->bbJumpSwt->bbsCount;
-                jmpTab = block->bbJumpSwt->bbsDstTab;
-
-                do
+                for (BasicBlock* const bTarget : block->SwitchTargets())
                 {
-                    VarSetOps::UnionD(this, initVars, (*jmpTab)->bbScope);
-                } while (++jmpTab, --jmpCnt);
-            }
-            break;
+                    VarSetOps::UnionD(this, initVars, bTarget->bbScope);
+                }
+                break;
 
             case BBJ_EHFINALLYRET:
             case BBJ_RETURN:
@@ -2559,12 +2549,11 @@ void Compiler::fgInterBlockLocalVarLiveness()
     // Variables involved in exception-handlers and finally blocks need
     // to be specially marked
     //
-    BasicBlock* block;
 
     VARSET_TP exceptVars(VarSetOps::MakeEmpty(this));  // vars live on entry to a handler
     VARSET_TP finallyVars(VarSetOps::MakeEmpty(this)); // vars live on exit of a 'finally' block
 
-    for (block = fgFirstBB; block; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
         if (block->hasEHBoundaryIn())
         {
@@ -2641,7 +2630,7 @@ void Compiler::fgInterBlockLocalVarLiveness()
      * Now fill in liveness info within each basic block - Backward DataFlow
      */
 
-    for (block = fgFirstBB; block; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
         /* Tell everyone what block we're working on */
 
@@ -2781,7 +2770,7 @@ void Compiler::fgDispBBLiveness(BasicBlock* block)
 
 void Compiler::fgDispBBLiveness()
 {
-    for (BasicBlock* block = fgFirstBB; block; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
         fgDispBBLiveness(block);
     }
diff --git a/src/coreclr/jit/loopcloning.cpp b/src/coreclr/jit/loopcloning.cpp
index d9798d98e09a2a..0fe22420f783e4 100644
--- a/src/coreclr/jit/loopcloning.cpp
+++ b/src/coreclr/jit/loopcloning.cpp
@@ -1314,9 +1314,8 @@ bool Compiler::optIsLoopClonable(unsigned loopInd)
     // for the cloned loop (and its embedded EH regions).
     //
     // Also, count the number of return blocks within the loop for future use.
-    BasicBlock* stopAt       = loop.lpBottom->bbNext;
-    unsigned    loopRetCount = 0;
-    for (BasicBlock* blk = loop.lpFirst; blk != stopAt; blk = blk->bbNext)
+    unsigned loopRetCount = 0;
+    for (BasicBlock* const blk : loop.LoopBlocks())
     {
         if (blk->bbJumpKind == BBJ_RETURN)
         {
@@ -1570,10 +1569,8 @@ void Compiler::optEnsureUniqueHead(unsigned loopInd, BasicBlock::weight_t ambien
     BlockToBlockMap* blockMap = new (getAllocator(CMK_LoopClone)) BlockToBlockMap(getAllocator(CMK_LoopClone));
     blockMap->Set(e, h2);
 
-    for (flowList* predEntry = e->bbPreds; predEntry != nullptr; predEntry = predEntry->flNext)
+    for (BasicBlock* const predBlock : e->PredBlocks())
     {
-        BasicBlock* predBlock = predEntry->getBlock();
-
         // Skip if predBlock is in the loop.
         if (t->bbNum <= predBlock->bbNum && predBlock->bbNum <= b->bbNum)
         {
@@ -1749,7 +1746,7 @@ void Compiler::optCloneLoop(unsigned loopInd, LoopCloneContext* context)
     BasicBlock* newFirst = nullptr;
 
     BlockToBlockMap* blockMap = new (getAllocator(CMK_LoopClone)) BlockToBlockMap(getAllocator(CMK_LoopClone));
-    for (BasicBlock* blk = loop.lpFirst; blk != loop.lpBottom->bbNext; blk = blk->bbNext)
+    for (BasicBlock* const blk : loop.LoopBlocks())
     {
         BasicBlock* newBlk = fgNewBBafter(blk->bbJumpKind, newPred, /*extendRegion*/ true);
         JITDUMP("Adding " FMT_BB " (copy of " FMT_BB ") after " FMT_BB "\n", newBlk->bbNum, blk->bbNum, newPred->bbNum);
@@ -1798,7 +1795,7 @@ void Compiler::optCloneLoop(unsigned loopInd, LoopCloneContext* context)
 
     // Now go through the new blocks, remapping their jump targets within the loop
     // and updating the preds lists.
-    for (BasicBlock* blk = loop.lpFirst; blk != loop.lpBottom->bbNext; blk = blk->bbNext)
+    for (BasicBlock* const blk : loop.LoopBlocks())
     {
         BasicBlock* newblk = nullptr;
         bool        b      = blockMap->Lookup(blk, &newblk);
@@ -1830,14 +1827,11 @@ void Compiler::optCloneLoop(unsigned loopInd, LoopCloneContext* context)
                 break;
 
             case BBJ_SWITCH:
-            {
-                for (unsigned i = 0; i < newblk->bbJumpSwt->bbsCount; i++)
+                for (BasicBlock* const switchDest : newblk->SwitchTargets())
                 {
-                    BasicBlock* switchDest = newblk->bbJumpSwt->bbsDstTab[i];
                     fgAddRefPred(switchDest, newblk);
                 }
-            }
-            break;
+                break;
 
             default:
                 break;
@@ -1847,15 +1841,15 @@ void Compiler::optCloneLoop(unsigned loopInd, LoopCloneContext* context)
 #ifdef DEBUG
     // Display the preds for the new blocks, after all the new blocks have been redirected.
     JITDUMP("Preds after loop copy:\n");
-    for (BasicBlock* blk = loop.lpFirst; blk != loop.lpBottom->bbNext; blk = blk->bbNext)
+    for (BasicBlock* const blk : loop.LoopBlocks())
     {
         BasicBlock* newblk = nullptr;
         bool        b      = blockMap->Lookup(blk, &newblk);
         assert(b && newblk != nullptr);
         JITDUMP(FMT_BB ":", newblk->bbNum);
-        for (flowList* pred = newblk->bbPreds; pred != nullptr; pred = pred->flNext)
+        for (BasicBlock* const predBlock : newblk->PredBlocks())
         {
-            JITDUMP(" " FMT_BB, pred->getBlock()->bbNum);
+            JITDUMP(" " FMT_BB, predBlock->bbNum);
         }
         JITDUMP("\n");
     }
@@ -2311,21 +2305,15 @@ Compiler::fgWalkResult Compiler::optCanOptimizeByLoopCloningVisitor(GenTree** pT
 //
 bool Compiler::optIdentifyLoopOptInfo(unsigned loopNum, LoopCloneContext* context)
 {
-    noway_assert(loopNum < optLoopCount);
-
-    LoopDsc* pLoop = &optLoopTable[loopNum];
-
-    BasicBlock* head = pLoop->lpHead;
-    BasicBlock* beg  = head->bbNext; // should this be pLoop->lpFirst or pLoop->lpTop instead?
-    BasicBlock* end  = pLoop->lpBottom;
+    JITDUMP("Checking loop " FMT_LP " for optimization candidates\n", loopNum);
 
-    JITDUMP("Checking blocks " FMT_BB ".." FMT_BB " for optimization candidates\n", beg->bbNum, end->bbNum);
+    const LoopDsc& loop = optLoopTable[loopNum];
 
     LoopCloneVisitorInfo info(context, loopNum, nullptr);
-    for (BasicBlock* block = beg; block != end->bbNext; block = block->bbNext)
+    for (BasicBlock* const block : loop.LoopBlocks())
     {
         compCurBB = block;
-        for (Statement* stmt : block->Statements())
+        for (Statement* const stmt : block->Statements())
         {
             info.stmt               = stmt;
             const bool lclVarsOnly  = false;
diff --git a/src/coreclr/jit/lower.cpp b/src/coreclr/jit/lower.cpp
index 559daa9e268078..389c29f7643056 100644
--- a/src/coreclr/jit/lower.cpp
+++ b/src/coreclr/jit/lower.cpp
@@ -5888,7 +5888,7 @@ PhaseStatus Lowering::DoPhase()
     }
 #endif // !defined(TARGET_64BIT)
 
-    for (BasicBlock* block = comp->fgFirstBB; block; block = block->bbNext)
+    for (BasicBlock* const block : comp->Blocks())
     {
         /* Make the block publicly available */
         comp->compCurBB = block;
@@ -6210,17 +6210,22 @@ bool Lowering::IndirsAreEquivalent(GenTree* candidate, GenTree* storeInd)
     }
 }
 
-/** Test whether the two given nodes are the same leaves.
- *  Right now, only constant integers and local variables are supported
- */
+//------------------------------------------------------------------------
+// NodesAreEquivalentLeaves: Check whether the two given nodes are the same leaves.
+//
+// Arguments:
+//      tree1 and tree2 are nodes to be checked.
+// Return Value:
+//    Returns true if they are same leaves, false otherwise.
+//
+// static
 bool Lowering::NodesAreEquivalentLeaves(GenTree* tree1, GenTree* tree2)
 {
-    if (tree1 == nullptr && tree2 == nullptr)
+    if (tree1 == tree2)
     {
         return true;
     }
 
-    // both null, they are equivalent, otherwise if either is null not equivalent
     if (tree1 == nullptr || tree2 == nullptr)
     {
         return false;
@@ -6247,7 +6252,7 @@ bool Lowering::NodesAreEquivalentLeaves(GenTree* tree1, GenTree* tree2)
     switch (tree1->OperGet())
     {
         case GT_CNS_INT:
-            return tree1->AsIntCon()->gtIconVal == tree2->AsIntCon()->gtIconVal &&
+            return tree1->AsIntCon()->IconValue() == tree2->AsIntCon()->IconValue() &&
                    tree1->IsIconHandle() == tree2->IsIconHandle();
         case GT_LCL_VAR:
         case GT_LCL_VAR_ADDR:
diff --git a/src/coreclr/jit/lowerxarch.cpp b/src/coreclr/jit/lowerxarch.cpp
index 4d4253006047cd..55bfab94f6f5f8 100644
--- a/src/coreclr/jit/lowerxarch.cpp
+++ b/src/coreclr/jit/lowerxarch.cpp
@@ -216,11 +216,18 @@ void Lowering::LowerBlockStore(GenTreeBlk* blkNode)
 
                 if (fill == 0)
                 {
-                    // If the size is multiple of XMM register size there's no need to load 0 in a GPR,
-                    // codegen will use xorps to generate 0 directly in the temporary XMM register.
-                    if ((size % XMM_REGSIZE_BYTES) == 0)
+                    if (size >= XMM_REGSIZE_BYTES)
                     {
-                        src->SetContained();
+                        const bool canUse16BytesSimdMov = !blkNode->IsOnHeapAndContainsReferences();
+#ifdef TARGET_AMD64
+                        const bool willUseOnlySimdMov = canUse16BytesSimdMov && (size % 16 == 0);
+#else
+                        const bool willUseOnlySimdMov = (size % 8 == 0);
+#endif
+                        if (willUseOnlySimdMov)
+                        {
+                            src->SetContained();
+                        }
                     }
                 }
 #ifdef TARGET_AMD64
diff --git a/src/coreclr/jit/lsra.cpp b/src/coreclr/jit/lsra.cpp
index 0006d26451f07b..e137b7f678a0d7 100644
--- a/src/coreclr/jit/lsra.cpp
+++ b/src/coreclr/jit/lsra.cpp
@@ -831,8 +831,10 @@ void LinearScan::setBlockSequence()
     }
 #endif // TRACK_LSRA_STATS
 
+    JITDUMP("Start LSRA Block Sequence: \n");
     for (BasicBlock* block = compiler->fgFirstBB; block != nullptr; block = nextBlock)
     {
+        JITDUMP("Current block: " FMT_BB "\n", block->bbNum);
         blockSequence[bbSeqCount] = block;
         markBlockVisited(block);
         bbSeqCount++;
@@ -866,9 +868,8 @@ void LinearScan::setBlockSequence()
         }
 
         bool hasUniquePred = (block->GetUniquePred(compiler) != nullptr);
-        for (flowList* pred = block->bbPreds; pred != nullptr; pred = pred->flNext)
+        for (BasicBlock* const predBlock : block->PredBlocks())
         {
-            BasicBlock* predBlock = pred->getBlock();
             if (!hasUniquePred)
             {
                 if (predBlock->NumSucc(compiler) > 1)
@@ -903,13 +904,13 @@ void LinearScan::setBlockSequence()
 
         // First, update the NORMAL successors of the current block, adding them to the worklist
         // according to the desired order.  We will handle the EH successors below.
-        bool checkForCriticalOutEdge = (block->NumSucc(compiler) > 1);
+        const unsigned numSuccs                = block->NumSucc(compiler);
+        bool           checkForCriticalOutEdge = (numSuccs > 1);
         if (!checkForCriticalOutEdge && block->bbJumpKind == BBJ_SWITCH)
         {
             assert(!"Switch with single successor");
         }
 
-        const unsigned numSuccs = block->NumSucc(compiler);
         for (unsigned succIndex = 0; succIndex < numSuccs; succIndex++)
         {
             BasicBlock* succ = block->GetSucc(succIndex, compiler);
@@ -931,6 +932,7 @@ void LinearScan::setBlockSequence()
             // (i.e. pred-first or random, since layout order is handled above).
             if (!BlockSetOps::IsMember(compiler, readySet, succ->bbNum))
             {
+                JITDUMP("\tSucc block: " FMT_BB, succ->bbNum);
                 addToBlockSequenceWorkList(readySet, succ, predSet);
                 BlockSetOps::AddElemD(compiler, readySet, succ->bbNum);
             }
@@ -954,27 +956,18 @@ void LinearScan::setBlockSequence()
                 // If we don't encounter all blocks by traversing the regular successor links, do a full
                 // traversal of all the blocks, and add them in layout order.
                 // This may include:
-                //   - internal-only blocks (in the fgAddCodeList) which may not be in the flow graph
-                //     (these are not even in the bbNext links).
+                //   - internal-only blocks which may not be in the flow graph
                 //   - blocks that have become unreachable due to optimizations, but that are strongly
                 //     connected (these are not removed)
                 //   - EH blocks
 
-                for (Compiler::AddCodeDsc* desc = compiler->fgAddCodeList; desc != nullptr; desc = desc->acdNext)
+                for (BasicBlock* const seqBlock : compiler->Blocks())
                 {
-                    if (!isBlockVisited(block))
+                    if (!isBlockVisited(seqBlock))
                     {
-                        addToBlockSequenceWorkList(readySet, block, predSet);
-                        BlockSetOps::AddElemD(compiler, readySet, block->bbNum);
-                    }
-                }
-
-                for (BasicBlock* block = compiler->fgFirstBB; block; block = block->bbNext)
-                {
-                    if (!isBlockVisited(block))
-                    {
-                        addToBlockSequenceWorkList(readySet, block, predSet);
-                        BlockSetOps::AddElemD(compiler, readySet, block->bbNum);
+                        JITDUMP("\tUnvisited block: " FMT_BB, seqBlock->bbNum);
+                        addToBlockSequenceWorkList(readySet, seqBlock, predSet);
+                        BlockSetOps::AddElemD(compiler, readySet, seqBlock->bbNum);
                     }
                 }
                 verifiedAllBBs = true;
@@ -989,25 +982,17 @@ void LinearScan::setBlockSequence()
 
 #ifdef DEBUG
     // Make sure that we've visited all the blocks.
-    for (BasicBlock* block = compiler->fgFirstBB; block != nullptr; block = block->bbNext)
+    for (BasicBlock* const block : compiler->Blocks())
     {
         assert(isBlockVisited(block));
     }
 
-    JITDUMP("LSRA Block Sequence: ");
+    JITDUMP("Final LSRA Block Sequence: \n");
     int i = 1;
     for (BasicBlock *block = startBlockSequence(); block != nullptr; ++i, block = moveToNextBlock())
     {
         JITDUMP(FMT_BB, block->bbNum);
-
-        if (block->isMaxBBWeight())
-        {
-            JITDUMP("(MAX) ");
-        }
-        else
-        {
-            JITDUMP("(%6s) ", refCntWtd2str(block->getBBWeight(compiler)));
-        }
+        JITDUMP("(%6s) ", refCntWtd2str(block->getBBWeight(compiler)));
 
         if (blockInfo[block->bbNum].hasEHBoundaryIn)
         {
@@ -1111,18 +1096,17 @@ void LinearScan::addToBlockSequenceWorkList(BlockSet sequencedBlockSet, BasicBlo
 
     // Get predSet of block
     BlockSetOps::ClearD(compiler, predSet);
-    flowList* pred;
-    for (pred = block->bbPreds; pred != nullptr; pred = pred->flNext)
+    for (BasicBlock* const predBlock : block->PredBlocks())
     {
-        BlockSetOps::AddElemD(compiler, predSet, pred->getBlock()->bbNum);
+        BlockSetOps::AddElemD(compiler, predSet, predBlock->bbNum);
     }
 
     // If either a rarely run block or all its preds are already sequenced, use block's weight to sequence
     bool useBlockWeight = block->isRunRarely() || BlockSetOps::IsSubset(compiler, sequencedBlockSet, predSet);
+    JITDUMP(", Criteria: %s", useBlockWeight ? "weight" : "bbNum");
 
     BasicBlockList* prevNode = nullptr;
     BasicBlockList* nextNode = blockSequenceWorkList;
-
     while (nextNode != nullptr)
     {
         int seqResult;
@@ -1160,6 +1144,17 @@ void LinearScan::addToBlockSequenceWorkList(BlockSet sequencedBlockSet, BasicBlo
     {
         prevNode->next = newListNode;
     }
+
+#ifdef DEBUG
+    nextNode = blockSequenceWorkList;
+    JITDUMP(", Worklist: [");
+    while (nextNode != nullptr)
+    {
+        JITDUMP(FMT_BB " ", nextNode->block->bbNum);
+        nextNode = nextNode->next;
+    }
+    JITDUMP("]\n");
+#endif
 }
 
 void LinearScan::removeFromBlockSequenceWorkList(BasicBlockList* listNode, BasicBlockList* prevNode)
@@ -1397,9 +1392,7 @@ void Interval::setLocalNumber(Compiler* compiler, unsigned lclNum, LinearScan* l
 //
 void LinearScan::identifyCandidatesExceptionDataflow()
 {
-    BasicBlock* block;
-
-    foreach_block(compiler, block)
+    for (BasicBlock* const block : compiler->Blocks())
     {
         if (block->hasEHBoundaryIn())
         {
@@ -2415,9 +2408,8 @@ BasicBlock* LinearScan::findPredBlockForLiveIn(BasicBlock* block,
                         }
                         else
                         {
-                            for (flowList* pred = otherBlock->bbPreds; pred != nullptr; pred = pred->flNext)
+                            for (BasicBlock* const otherPred : otherBlock->PredBlocks())
                             {
-                                BasicBlock* otherPred = pred->getBlock();
                                 if (otherPred->bbNum == blockInfo[otherBlock->bbNum].predBBNum)
                                 {
                                     predBlock = otherPred;
@@ -2435,10 +2427,8 @@ BasicBlock* LinearScan::findPredBlockForLiveIn(BasicBlock* block,
         }
         else
         {
-            for (flowList* pred = block->bbPreds; pred != nullptr; pred = pred->flNext)
+            for (BasicBlock* const candidatePredBlock : block->PredBlocks())
             {
-                BasicBlock* candidatePredBlock = pred->getBlock();
-
                 if (isBlockVisited(candidatePredBlock))
                 {
                     if ((predBlock == nullptr) || (predBlock->bbWeight < candidatePredBlock->bbWeight))
@@ -6945,7 +6935,7 @@ void LinearScan::resolveRegisters()
             printf("Has %sCritical Edges\n\n", hasCriticalEdges ? "" : "No ");
 
             printf("Prior to Resolution\n");
-            foreach_block(compiler, block)
+            for (BasicBlock* const block : compiler->Blocks())
             {
                 printf("\n" FMT_BB, block->bbNum);
                 if (block->hasEHBoundaryIn())
@@ -7857,8 +7847,6 @@ void LinearScan::resolveEdges()
         return;
     }
 
-    BasicBlock *block, *prevBlock = nullptr;
-
     // Handle all the critical edges first.
     // We will try to avoid resolution across critical edges in cases where all the critical-edge
     // targets of a block have the same home.  We will then split the edges only for the
@@ -7867,7 +7855,7 @@ void LinearScan::resolveEdges()
 
     if (hasCriticalEdges)
     {
-        foreach_block(compiler, block)
+        for (BasicBlock* const block : compiler->Blocks())
         {
             if (block->bbNum > bbNumMaxBeforeResolution)
             {
@@ -7878,12 +7866,10 @@ void LinearScan::resolveEdges()
             {
                 handleOutgoingCriticalEdges(block);
             }
-            prevBlock = block;
         }
     }
 
-    prevBlock = nullptr;
-    foreach_block(compiler, block)
+    for (BasicBlock* const block : compiler->Blocks())
     {
         if (block->bbNum > bbNumMaxBeforeResolution)
         {
@@ -7943,7 +7929,7 @@ void LinearScan::resolveEdges()
     // would only improve the debug case, and would clutter up the code somewhat.
     if (compiler->fgBBNumMax > bbNumMaxBeforeResolution)
     {
-        foreach_block(compiler, block)
+        for (BasicBlock* const block : compiler->Blocks())
         {
             if (block->bbNum > bbNumMaxBeforeResolution)
             {
@@ -8000,16 +7986,15 @@ void LinearScan::resolveEdges()
 #ifdef DEBUG
     // Make sure the varToRegMaps match up on all edges.
     bool foundMismatch = false;
-    foreach_block(compiler, block)
+    for (BasicBlock* const block : compiler->Blocks())
     {
         if (block->isEmpty() && block->bbNum > bbNumMaxBeforeResolution)
         {
             continue;
         }
         VarToRegMap toVarToRegMap = getInVarToRegMap(block->bbNum);
-        for (flowList* pred = block->bbPreds; pred != nullptr; pred = pred->flNext)
+        for (BasicBlock* const predBlock : block->PredBlocks())
         {
-            BasicBlock*     predBlock       = pred->getBlock();
             VarToRegMap     fromVarToRegMap = getOutVarToRegMap(predBlock->bbNum);
             VarSetOps::Iter iter(compiler, block->bbLiveIn);
             unsigned        varIndex = 0;
@@ -8636,7 +8621,8 @@ void LinearScan::dumpLsraStats(FILE* file)
 
     fprintf(file, "----------\n");
 #ifdef DEBUG
-    fprintf(file, "Register selection order: %S\n", JitConfig.JitLsraOrdering());
+    fprintf(file, "Register selection order: %S\n",
+            JitConfig.JitLsraOrdering() == nullptr ? W("ABCDEFGHIJKLMNOPQ") : JitConfig.JitLsraOrdering());
 #endif
     fprintf(file, "Total Tracked Vars:  %d\n", compiler->lvaTrackedCount);
     fprintf(file, "Total Reg Cand Vars: %d\n", regCandidateVarCount);
@@ -8655,6 +8641,7 @@ void LinearScan::dumpLsraStats(FILE* file)
     bool addedBlockHeader = false;
     bool anyNonZeroStat   = false;
 
+    // Iterate for block 0
     for (int statIndex = 0; statIndex < LsraStat::COUNT; statIndex++)
     {
         unsigned lsraStat = blockInfo[0].stats[statIndex];
@@ -8682,7 +8669,8 @@ void LinearScan::dumpLsraStats(FILE* file)
         fprintf(file, "\n");
     }
 
-    for (BasicBlock* block = compiler->fgFirstBB; block != nullptr; block = block->bbNext)
+    // Iterate for remaining blocks
+    for (BasicBlock* const block : compiler->Blocks())
     {
         if (block->bbNum > bbNumMaxBeforeResolution)
         {
@@ -8727,7 +8715,6 @@ void LinearScan::dumpLsraStats(FILE* file)
         {
             fprintf(file, "..........\n");
         }
-        // TODO-review: I don't see a point of displaying Stats (SpillCount, etc.) if they are zero. Thoughts?
         if ((regSelectI < firstRegSelStat) || (sumStats[regSelectI] != 0))
         {
             // Print register selection stats
@@ -8775,7 +8762,7 @@ void LinearScan::dumpLsraStatsCsv(FILE* file)
     }
 
     // blocks
-    for (BasicBlock* block = compiler->fgFirstBB; block != nullptr; block = block->bbNext)
+    for (BasicBlock* const block : compiler->Blocks())
     {
         if (block->bbNum > bbNumMaxBeforeResolution)
         {
@@ -8795,6 +8782,48 @@ void LinearScan::dumpLsraStatsCsv(FILE* file)
     }
     fprintf(file, ",%.2f\n", compiler->info.compPerfScore);
 }
+
+// -----------------------------------------------------------
+// dumpLsraStatsSummary - dumps Lsra stats summary to given file
+//
+// Arguments:
+//    file    -  file to which stats are to be written.
+//
+void LinearScan::dumpLsraStatsSummary(FILE* file)
+{
+    unsigned             sumStats[LsraStat::STAT_FREE] = {0};
+    BasicBlock::weight_t wtdStats[LsraStat::STAT_FREE] = {0.0};
+
+    // Iterate for block 0
+    for (int statIndex = 0; statIndex < LsraStat::STAT_FREE; statIndex++)
+    {
+        unsigned lsraStat = blockInfo[0].stats[statIndex];
+        sumStats[statIndex] += lsraStat;
+        wtdStats[statIndex] += (lsraStat * blockInfo[0].weight);
+    }
+
+    // Iterate for remaining blocks
+    for (BasicBlock* const block : compiler->Blocks())
+    {
+        if (block->bbNum > bbNumMaxBeforeResolution)
+        {
+            continue;
+        }
+
+        for (int statIndex = 0; statIndex < LsraStat::STAT_FREE; statIndex++)
+        {
+            unsigned lsraStat = blockInfo[block->bbNum].stats[statIndex];
+            sumStats[statIndex] += lsraStat;
+            wtdStats[statIndex] += (lsraStat * block->bbWeight);
+        }
+    }
+
+    for (int regSelectI = 0; regSelectI < LsraStat::STAT_FREE; regSelectI++)
+    {
+        fprintf(file, ", %s %u %sWt %f", getStatName(regSelectI), sumStats[regSelectI], getStatName(regSelectI),
+                wtdStats[regSelectI]);
+    }
+}
 #endif // TRACK_LSRA_STATS
 
 #ifdef DEBUG
@@ -10618,7 +10647,7 @@ void LinearScan::verifyFinalAllocation()
     // Now, verify the resolution blocks.
     // Currently these are nearly always at the end of the method, but that may not always be the case.
     // So, we'll go through all the BBs looking for blocks whose bbNum is greater than bbNumMaxBeforeResolution.
-    for (BasicBlock* currentBlock = compiler->fgFirstBB; currentBlock != nullptr; currentBlock = currentBlock->bbNext)
+    for (BasicBlock* const currentBlock : compiler->Blocks())
     {
         if (currentBlock->bbNum > bbNumMaxBeforeResolution)
         {
@@ -11229,13 +11258,36 @@ void LinearScan::RegisterSelection::try_SPILL_COST()
             continue;
         }
 
-        float currentSpillWeight = linearScan->spillCost[spillCandidateRegNum];
-#ifdef TARGET_ARM
-        if (currentInterval->registerType == TYP_DOUBLE)
+        float        currentSpillWeight = 0;
+        RefPosition* recentRefPosition  = spillCandidateRegRecord->assignedInterval != nullptr
+                                             ? spillCandidateRegRecord->assignedInterval->recentRefPosition
+                                             : nullptr;
+        if ((recentRefPosition != nullptr) && (recentRefPosition->RegOptional()) &&
+            !(currentInterval->isLocalVar && recentRefPosition->IsActualRef()))
         {
-            currentSpillWeight = max(currentSpillWeight, linearScan->spillCost[REG_NEXT(spillCandidateRegNum)]);
+            // We do not "spillAfter" if previous (recent) refPosition was regOptional or if it
+            // is not an actual ref. In those cases, we will reload in future (next) refPosition.
+            // For such cases, consider the spill cost of next refposition.
+            // See notes in "spillInterval()".
+            RefPosition* reloadRefPosition = spillCandidateRegRecord->assignedInterval->getNextRefPosition();
+            if (reloadRefPosition != nullptr)
+            {
+                currentSpillWeight = linearScan->getWeight(reloadRefPosition);
+            }
         }
+
+        // Only consider spillCost if we were not able to calculate weight of reloadRefPosition.
+        if (currentSpillWeight == 0)
+        {
+            currentSpillWeight = linearScan->spillCost[spillCandidateRegNum];
+#ifdef TARGET_ARM
+            if (currentInterval->registerType == TYP_DOUBLE)
+            {
+                currentSpillWeight = max(currentSpillWeight, linearScan->spillCost[REG_NEXT(spillCandidateRegNum)]);
+            }
 #endif
+        }
+
         if (currentSpillWeight < bestSpillWeight)
         {
             bestSpillWeight    = currentSpillWeight;
diff --git a/src/coreclr/jit/lsra.h b/src/coreclr/jit/lsra.h
index d944c4530739d5..eda5d014c658a7 100644
--- a/src/coreclr/jit/lsra.h
+++ b/src/coreclr/jit/lsra.h
@@ -1455,6 +1455,7 @@ class LinearScan : public LinearScanInterface
 
 public:
     virtual void dumpLsraStatsCsv(FILE* file);
+    virtual void dumpLsraStatsSummary(FILE* file);
     static const char* getStatName(unsigned stat);
 
 #define INTRACK_STATS(x) x
diff --git a/src/coreclr/jit/lsraarm64.cpp b/src/coreclr/jit/lsraarm64.cpp
index 223dc906badbf2..a7a14fdfe54f96 100644
--- a/src/coreclr/jit/lsraarm64.cpp
+++ b/src/coreclr/jit/lsraarm64.cpp
@@ -1112,54 +1112,11 @@ int LinearScan::BuildHWIntrinsic(GenTreeHWIntrinsic* intrinsicTree)
             // RMW intrinsic operands doesn't have to be delayFree when they can be assigned the same register as op1Reg
             // (i.e. a register that corresponds to read-modify-write operand) and one of them is the last use.
 
-            bool op2DelayFree = isRMW;
-            bool op3DelayFree = isRMW;
-            bool op4DelayFree = isRMW;
-
             assert(intrin.op1 != nullptr);
 
-            if (isRMW && intrin.op1->OperIs(GT_LCL_VAR))
-            {
-                unsigned int varNum1    = intrin.op1->AsLclVar()->GetLclNum();
-                bool         op1LastUse = false;
-
-                unsigned int varNum2 = BAD_VAR_NUM;
-                unsigned int varNum3 = BAD_VAR_NUM;
-                unsigned int varNum4 = BAD_VAR_NUM;
-
-                if (intrin.op2->OperIs(GT_LCL_VAR))
-                {
-                    varNum2 = intrin.op2->AsLclVar()->GetLclNum();
-                    op1LastUse |= ((varNum1 == varNum2) && intrin.op2->HasLastUse());
-                }
-
-                if (intrin.op3 != nullptr)
-                {
-                    if (intrin.op3->OperIs(GT_LCL_VAR))
-                    {
-                        varNum3 = intrin.op3->AsLclVar()->GetLclNum();
-                        op1LastUse |= ((varNum1 == varNum3) && intrin.op3->HasLastUse());
-                    }
-
-                    if ((intrin.op4 != nullptr) && intrin.op4->OperIs(GT_LCL_VAR))
-                    {
-                        varNum4 = intrin.op4->AsLclVar()->GetLclNum();
-                        op1LastUse |= ((varNum1 == varNum4) && intrin.op4->HasLastUse());
-                    }
-                }
-
-                if (op1LastUse)
-                {
-                    op2DelayFree = (varNum1 != varNum2);
-                    op3DelayFree = (varNum1 != varNum3);
-                    op4DelayFree = (varNum1 != varNum4);
-                }
-            }
-
+            bool forceOp2DelayFree = false;
             if ((intrin.id == NI_Vector64_GetElement) || (intrin.id == NI_Vector128_GetElement))
             {
-                assert(!op2DelayFree);
-
                 if (!intrin.op2->IsCnsIntOrI() && (!intrin.op1->isContained() || intrin.op1->OperIsLocal()))
                 {
                     // If the index is not a constant and the object is not contained or is a local
@@ -1168,7 +1125,7 @@ int LinearScan::BuildHWIntrinsic(GenTreeHWIntrinsic* intrinsicTree)
                     // TODO-Cleanup: An internal register will never clobber a source; this code actually
                     // ensures that the index (op2) doesn't interfere with the target.
                     buildInternalIntRegisterDefForNode(intrinsicTree);
-                    op2DelayFree = true;
+                    forceOp2DelayFree = true;
                 }
 
                 if (!intrin.op2->IsCnsIntOrI() && !intrin.op1->isContained())
@@ -1179,15 +1136,22 @@ int LinearScan::BuildHWIntrinsic(GenTreeHWIntrinsic* intrinsicTree)
                 }
             }
 
-            srcCount += op2DelayFree ? BuildDelayFreeUses(intrin.op2) : BuildOperandUses(intrin.op2);
+            if (forceOp2DelayFree)
+            {
+                srcCount += BuildDelayFreeUses(intrin.op2);
+            }
+            else
+            {
+                srcCount += isRMW ? BuildDelayFreeUses(intrin.op2, intrin.op1) : BuildOperandUses(intrin.op2);
+            }
 
             if (intrin.op3 != nullptr)
             {
-                srcCount += op3DelayFree ? BuildDelayFreeUses(intrin.op3) : BuildOperandUses(intrin.op3);
+                srcCount += isRMW ? BuildDelayFreeUses(intrin.op3, intrin.op1) : BuildOperandUses(intrin.op3);
 
                 if (intrin.op4 != nullptr)
                 {
-                    srcCount += op4DelayFree ? BuildDelayFreeUses(intrin.op4) : BuildOperandUses(intrin.op4);
+                    srcCount += isRMW ? BuildDelayFreeUses(intrin.op4, intrin.op1) : BuildOperandUses(intrin.op4);
                 }
             }
         }
diff --git a/src/coreclr/jit/lsrabuild.cpp b/src/coreclr/jit/lsrabuild.cpp
index db02482b6b436a..dcea8813119196 100644
--- a/src/coreclr/jit/lsrabuild.cpp
+++ b/src/coreclr/jit/lsrabuild.cpp
@@ -2064,7 +2064,7 @@ void LinearScan::buildIntervals()
         printf("\n-----------------\n");
         printf("LIVENESS:\n");
         printf("-----------------\n");
-        foreach_block(compiler, block)
+        for (BasicBlock* const block : compiler->Blocks())
         {
             printf(FMT_BB " use def in out\n", block->bbNum);
             dumpConvertedVarSet(compiler, block->bbVarUse);
@@ -2584,7 +2584,7 @@ void LinearScan::buildIntervals()
 
 #ifdef DEBUG
     // Make sure we don't have any blocks that were not visited
-    foreach_block(compiler, block)
+    for (BasicBlock* const block : compiler->Blocks())
     {
         assert(isBlockVisited(block));
     }
@@ -3097,6 +3097,10 @@ int LinearScan::BuildDelayFreeUses(GenTree* node, GenTree* rmwNode, regMaskTP ca
     }
     if (use != nullptr)
     {
+        // If node != rmwNode, then definitely node should be marked as "delayFree".
+        // However, if node == rmwNode, then we can mark node as "delayFree" only
+        // none of the node/rmwNode are the last uses. If either of them are last use,
+        // we can safely reuse the rmwNode as destination.
         if ((use->getInterval() != rmwInterval) || (!rmwIsLastUse && !use->lastUse))
         {
             setDelayFree(use);
diff --git a/src/coreclr/jit/lsraxarch.cpp b/src/coreclr/jit/lsraxarch.cpp
index 1cd81124d05663..854e4521ec9001 100644
--- a/src/coreclr/jit/lsraxarch.cpp
+++ b/src/coreclr/jit/lsraxarch.cpp
@@ -1069,7 +1069,7 @@ int LinearScan::BuildCall(GenTreeCall* call)
         // The return value will be on the X87 stack, and we will need to move it.
         dstCandidates = allRegs(registerType);
 #else  // !TARGET_X86
-        dstCandidates = RBM_FLOATRET;
+        dstCandidates                     = RBM_FLOATRET;
 #endif // !TARGET_X86
     }
     else if (registerType == TYP_LONG)
@@ -1297,7 +1297,14 @@ int LinearScan::BuildBlockStore(GenTreeBlk* blkNode)
         switch (blkNode->gtBlkOpKind)
         {
             case GenTreeBlk::BlkOpKindUnroll:
-                if (size >= XMM_REGSIZE_BYTES)
+            {
+#ifdef TARGET_AMD64
+                const bool canUse16BytesSimdMov = !blkNode->IsOnHeapAndContainsReferences();
+                const bool willUseSimdMov       = canUse16BytesSimdMov && (size >= 16);
+#else
+                const bool willUseSimdMov = (size >= 16);
+#endif
+                if (willUseSimdMov)
                 {
                     buildInternalFloatRegisterDefForNode(blkNode, internalFloatRegCandidates());
                     SetContainsAVXFlags();
@@ -1310,7 +1317,8 @@ int LinearScan::BuildBlockStore(GenTreeBlk* blkNode)
                     srcRegMask = allByteRegs();
                 }
 #endif
-                break;
+            }
+            break;
 
             case GenTreeBlk::BlkOpKindRepInstr:
                 dstAddrRegMask = RBM_RDI;
@@ -2420,9 +2428,9 @@ int LinearScan::BuildHWIntrinsic(GenTreeHWIntrinsic* intrinsicTree)
 
                 // Any pair of the index, mask, or destination registers should be different
                 srcCount += BuildOperandUses(op1);
-                srcCount += BuildDelayFreeUses(op2);
-                srcCount += BuildDelayFreeUses(op3);
-                srcCount += BuildDelayFreeUses(op4);
+                srcCount += BuildDelayFreeUses(op2, op1);
+                srcCount += BuildDelayFreeUses(op3, op1);
+                srcCount += BuildDelayFreeUses(op4, op1);
 
                 // op5 should always be contained
                 assert(argList->Rest()->Current()->isContained());
@@ -2481,8 +2489,7 @@ int LinearScan::BuildHWIntrinsic(GenTreeHWIntrinsic* intrinsicTree)
                         // When op2 is not contained or if we are producing a scalar value
                         // we need to mark it as delay free because the operand and target
                         // exist in the same register set.
-
-                        srcCount += BuildDelayFreeUses(op2);
+                        srcCount += BuildDelayFreeUses(op2, op1);
                     }
                     else
                     {
@@ -2500,7 +2507,7 @@ int LinearScan::BuildHWIntrinsic(GenTreeHWIntrinsic* intrinsicTree)
 
                 if (op3 != nullptr)
                 {
-                    srcCount += isRMW ? BuildDelayFreeUses(op3) : BuildOperandUses(op3);
+                    srcCount += isRMW ? BuildDelayFreeUses(op3, op1) : BuildOperandUses(op3);
                 }
             }
         }
diff --git a/src/coreclr/jit/morph.cpp b/src/coreclr/jit/morph.cpp
index 546782cabe5eaf..6d7f8c7bc6fdc9 100644
--- a/src/coreclr/jit/morph.cpp
+++ b/src/coreclr/jit/morph.cpp
@@ -258,17 +258,26 @@ GenTree* Compiler::fgMorphCast(GenTree* tree)
     }
 #endif //! TARGET_64BIT
 
+#ifdef TARGET_ARMARCH
+    // AArch, unlike x86/amd64, has instructions that can cast directly from
+    // all integers (except for longs on AArch32 of course) to floats.
+    // Because there is no IL instruction conv.r4.un, uint/ulong -> float
+    // casts are always imported as CAST(float <- CAST(double <- uint/ulong)).
+    // We can eliminate the redundant intermediate cast as an optimization.
+    else if ((dstType == TYP_FLOAT) && (srcType == TYP_DOUBLE) && oper->OperIs(GT_CAST)
 #ifdef TARGET_ARM
-    else if ((dstType == TYP_FLOAT) && (srcType == TYP_DOUBLE) && (oper->gtOper == GT_CAST) &&
-             !varTypeIsLong(oper->AsCast()->CastOp()))
+             && !varTypeIsLong(oper->AsCast()->CastOp())
+#endif
+                 )
     {
-        // optimization: conv.r4(conv.r8(?)) -> conv.r4(d)
-        // except when the ultimate source is a long because there is no long-to-float helper, so it must be 2 step.
-        // This happens semi-frequently because there is no IL 'conv.r4.un'
         oper->gtType       = TYP_FLOAT;
         oper->CastToType() = TYP_FLOAT;
+
         return fgMorphTree(oper);
     }
+#endif // TARGET_ARMARCH
+
+#ifdef TARGET_ARM
     // converts long/ulong --> float/double casts into helper calls.
     else if (varTypeIsFloating(dstType) && varTypeIsLong(srcType))
     {
@@ -5500,8 +5509,16 @@ GenTree* Compiler::fgMorphArrayIndex(GenTree* tree)
             fgSetRngChkTarget(indexAddr);
         }
 
-        // Change `tree` into an indirection and return.
-        tree->ChangeOper(GT_IND);
+        if (!tree->TypeIs(TYP_STRUCT))
+        {
+            tree->ChangeOper(GT_IND);
+        }
+        else
+        {
+            DEBUG_DESTROY_NODE(tree);
+            tree = gtNewObjNode(elemStructType, indexAddr);
+            INDEBUG(tree->gtDebugFlags |= GTF_DEBUG_NODE_MORPHED);
+        }
         GenTreeIndir* const indir = tree->AsIndir();
         indir->Addr()             = indexAddr;
         bool canCSE               = indir->CanCSE();
@@ -5511,9 +5528,7 @@ GenTree* Compiler::fgMorphArrayIndex(GenTree* tree)
             indir->SetDoNotCSE();
         }
 
-#ifdef DEBUG
-        indexAddr->gtDebugFlags |= GTF_DEBUG_NODE_MORPHED;
-#endif // DEBUG
+        INDEBUG(indexAddr->gtDebugFlags |= GTF_DEBUG_NODE_MORPHED);
 
         return indir;
     }
@@ -8630,7 +8645,7 @@ void Compiler::fgMorphTailCallViaJitHelper(GenTreeCall* call)
         GenTree* objp       = call->gtCallThisArg->GetNode();
         call->gtCallThisArg = nullptr;
 
-        if ((call->IsDelegateInvoke() || call->IsVirtualVtable()) && !objp->IsLocal())
+        if ((call->IsDelegateInvoke() || call->IsVirtualVtable()) && !objp->OperIs(GT_LCL_VAR))
         {
             // tmp = "this"
             unsigned lclNum = lvaGrabTemp(true DEBUGARG("tail call thisptr"));
@@ -16933,7 +16948,7 @@ void Compiler::fgMorphStmts(BasicBlock* block, bool* lnot, bool* loadw)
 
     fgCurrentlyInUseArgTemps = hashBv::Create(this);
 
-    for (Statement* stmt : block->Statements())
+    for (Statement* const stmt : block->Statements())
     {
         if (fgRemoveRestOfBlock)
         {
@@ -18061,9 +18076,9 @@ void Compiler::fgExpandQmarkNodes()
 {
     if (compQmarkUsed)
     {
-        for (BasicBlock* block = fgFirstBB; block != nullptr; block = block->bbNext)
+        for (BasicBlock* const block : Blocks())
         {
-            for (Statement* stmt : block->Statements())
+            for (Statement* const stmt : block->Statements())
             {
                 GenTree* expr = stmt->GetRootNode();
 #ifdef DEBUG
@@ -18087,9 +18102,9 @@ void Compiler::fgExpandQmarkNodes()
  */
 void Compiler::fgPostExpandQmarkChecks()
 {
-    for (BasicBlock* block = fgFirstBB; block != nullptr; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
-        for (Statement* stmt : block->Statements())
+        for (Statement* const stmt : block->Statements())
         {
             GenTree* expr = stmt->GetRootNode();
             fgWalkTreePre(&expr, Compiler::fgAssertNoQmark, nullptr);
diff --git a/src/coreclr/jit/objectalloc.cpp b/src/coreclr/jit/objectalloc.cpp
index e41a6117517968..720ec2585c4d61 100644
--- a/src/coreclr/jit/objectalloc.cpp
+++ b/src/coreclr/jit/objectalloc.cpp
@@ -213,11 +213,9 @@ void ObjectAllocator::MarkEscapingVarsAndBuildConnGraph()
         }
     }
 
-    BasicBlock* block;
-
-    foreach_block(comp, block)
+    for (BasicBlock* const block : comp->Blocks())
     {
-        for (Statement* stmt : block->Statements())
+        for (Statement* const stmt : block->Statements())
         {
             BuildConnGraphVisitor buildConnGraphVisitor(this);
             buildConnGraphVisitor.WalkTree(stmt->GetRootNodePointer(), nullptr);
@@ -340,9 +338,7 @@ bool ObjectAllocator::MorphAllocObjNodes()
     m_PossiblyStackPointingPointers   = BitVecOps::MakeEmpty(&m_bitVecTraits);
     m_DefinitelyStackPointingPointers = BitVecOps::MakeEmpty(&m_bitVecTraits);
 
-    BasicBlock* block;
-
-    foreach_block(comp, block)
+    for (BasicBlock* const block : comp->Blocks())
     {
         const bool basicBlockHasNewObj       = (block->bbFlags & BBF_HAS_NEWOBJ) == BBF_HAS_NEWOBJ;
         const bool basicBlockHasBackwardJump = (block->bbFlags & BBF_BACKWARD_JUMP) == BBF_BACKWARD_JUMP;
@@ -353,7 +349,7 @@ bool ObjectAllocator::MorphAllocObjNodes()
         }
 #endif // DEBUG
 
-        for (Statement* stmt : block->Statements())
+        for (Statement* const stmt : block->Statements())
         {
             GenTree* stmtExpr = stmt->GetRootNode();
             GenTree* op2      = nullptr;
@@ -917,11 +913,9 @@ void ObjectAllocator::RewriteUses()
         }
     };
 
-    BasicBlock* block;
-
-    foreach_block(comp, block)
+    for (BasicBlock* const block : comp->Blocks())
     {
-        for (Statement* stmt : block->Statements())
+        for (Statement* const stmt : block->Statements())
         {
             RewriteUsesVisitor rewriteUsesVisitor(this);
             rewriteUsesVisitor.WalkTree(stmt->GetRootNodePointer(), nullptr);
diff --git a/src/coreclr/jit/optcse.cpp b/src/coreclr/jit/optcse.cpp
index c37e7207f088e4..0a202303efa8ff 100644
--- a/src/coreclr/jit/optcse.cpp
+++ b/src/coreclr/jit/optcse.cpp
@@ -779,7 +779,7 @@ unsigned Compiler::optValnumCSE_Locate()
     }
 #endif
 
-    for (BasicBlock* block = fgFirstBB; block != nullptr; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
         /* Make the block publicly available */
 
@@ -790,13 +790,13 @@ unsigned Compiler::optValnumCSE_Locate()
         noway_assert((block->bbFlags & (BBF_VISITED | BBF_MARKED)) == 0);
 
         /* Walk the statement trees in this basic block */
-        for (Statement* stmt : StatementList(block->FirstNonPhiDef()))
+        for (Statement* const stmt : block->NonPhiStatements())
         {
             const bool isReturn = stmt->GetRootNode()->OperIs(GT_RETURN);
 
             /* We walk the tree in the forwards direction (bottom up) */
             bool stmtHasArrLenCandidate = false;
-            for (GenTree* tree = stmt->GetTreeList(); tree != nullptr; tree = tree->gtNext)
+            for (GenTree* const tree : stmt->TreeList())
             {
                 if (tree->OperIsCompare() && stmtHasArrLenCandidate)
                 {
@@ -1009,7 +1009,7 @@ void Compiler::optValnumCSE_InitDataFlow()
         BitVecOps::AddElemD(cseLivenessTraits, cseCallKillsMask, cseAvailBit);
     }
 
-    for (BasicBlock* block = fgFirstBB; block; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
         /* Initialize the blocks's bbCseIn set */
 
@@ -1078,7 +1078,7 @@ void Compiler::optValnumCSE_InitDataFlow()
         }
     }
 
-    for (BasicBlock* block = fgFirstBB; block; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
         // If the block doesn't contains a call then skip it...
         //
@@ -1140,7 +1140,7 @@ void Compiler::optValnumCSE_InitDataFlow()
     if (verbose)
     {
         bool headerPrinted = false;
-        for (BasicBlock* block = fgFirstBB; block; block = block->bbNext)
+        for (BasicBlock* const block : Blocks())
         {
             if (block->bbCseGen != nullptr)
             {
@@ -1328,7 +1328,7 @@ void Compiler::optValnumCSE_DataFlow()
     {
         printf("\nAfter performing DataFlow for ValnumCSE's\n");
 
-        for (BasicBlock* block = fgFirstBB; block; block = block->bbNext)
+        for (BasicBlock* const block : Blocks())
         {
             printf(FMT_BB, block->bbNum);
             printf(" cseIn  = %s,", genES2str(cseLivenessTraits, block->bbCseIn));
@@ -1387,7 +1387,7 @@ void Compiler::optValnumCSE_Availablity()
 #endif
     EXPSET_TP available_cses = BitVecOps::MakeEmpty(cseLivenessTraits);
 
-    for (BasicBlock* block = fgFirstBB; block != nullptr; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
         // Make the block publicly available
 
@@ -1399,11 +1399,11 @@ void Compiler::optValnumCSE_Availablity()
 
         // Walk the statement trees in this basic block
 
-        for (Statement* stmt : StatementList(block->FirstNonPhiDef()))
+        for (Statement* const stmt : block->NonPhiStatements())
         {
             // We walk the tree in the forwards direction (bottom up)
 
-            for (GenTree* tree = stmt->GetTreeList(); tree != nullptr; tree = tree->gtNext)
+            for (GenTree* const tree : stmt->TreeList())
             {
                 bool isUse = false;
                 bool isDef = false;
@@ -3832,13 +3832,13 @@ void Compiler::optOptimizeCSEs()
 void Compiler::optCleanupCSEs()
 {
     // We must clear the BBF_VISITED and BBF_MARKED flags.
-    for (BasicBlock* block = fgFirstBB; block != nullptr; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
         // And clear all the "visited" bits on the block.
         block->bbFlags &= ~(BBF_VISITED | BBF_MARKED);
 
         // Walk the statement trees in this basic block.
-        for (Statement* stmt : StatementList(block->FirstNonPhiDef()))
+        for (Statement* const stmt : block->NonPhiStatements())
         {
             // We must clear the gtCSEnum field.
             for (GenTree* tree = stmt->GetRootNode(); tree; tree = tree->gtPrev)
@@ -3859,13 +3859,11 @@ void Compiler::optCleanupCSEs()
 
 void Compiler::optEnsureClearCSEInfo()
 {
-    for (BasicBlock* block = fgFirstBB; block; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
         assert((block->bbFlags & (BBF_VISITED | BBF_MARKED)) == 0);
 
-        // Initialize 'stmt' to the first non-Phi statement
-        // Walk the statement trees in this basic block
-        for (Statement* stmt : StatementList(block->FirstNonPhiDef()))
+        for (Statement* const stmt : block->NonPhiStatements())
         {
             for (GenTree* tree = stmt->GetRootNode(); tree; tree = tree->gtPrev)
             {
diff --git a/src/coreclr/jit/optimizer.cpp b/src/coreclr/jit/optimizer.cpp
index 460314a327f8d8..a7df5b95905a2d 100644
--- a/src/coreclr/jit/optimizer.cpp
+++ b/src/coreclr/jit/optimizer.cpp
@@ -69,7 +69,7 @@ void Compiler::optSetBlockWeights()
     bool       firstBBDominatesAllReturns = true;
     const bool usingProfileWeights        = fgIsUsingProfileWeights();
 
-    for (BasicBlock* block = fgFirstBB; block != nullptr; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
         /* Blocks that can't be reached via the first block are rarely executed */
         if (!fgReachable(fgFirstBB, block))
@@ -168,19 +168,17 @@ void Compiler::optMarkLoopBlocks(BasicBlock* begBlk, BasicBlock* endBlk, bool ex
     /* Build list of backedges for block begBlk */
     flowList* backedgeList = nullptr;
 
-    for (flowList* pred = begBlk->bbPreds; pred != nullptr; pred = pred->flNext)
+    for (BasicBlock* const predBlock : begBlk->PredBlocks())
     {
         /* Is this a backedge? */
-        if (pred->getBlock()->bbNum >= begBlk->bbNum)
+        if (predBlock->bbNum >= begBlk->bbNum)
         {
-            flowList* flow = new (this, CMK_FlowList) flowList(pred->getBlock(), backedgeList);
+            backedgeList = new (this, CMK_FlowList) flowList(predBlock, backedgeList);
 
 #if MEASURE_BLOCK_SIZE
             genFlowNodeCnt += 1;
             genFlowNodeSize += sizeof(flowList);
 #endif // MEASURE_BLOCK_SIZE
-
-            backedgeList = flow;
         }
     }
 
@@ -278,23 +276,20 @@ void Compiler::optUnmarkLoopBlocks(BasicBlock* begBlk, BasicBlock* endBlk)
 
     noway_assert(!opts.MinOpts());
 
-    BasicBlock* curBlk;
-    unsigned    backEdgeCount = 0;
+    unsigned backEdgeCount = 0;
 
-    for (flowList* pred = begBlk->bbPreds; pred != nullptr; pred = pred->flNext)
+    for (BasicBlock* const predBlock : begBlk->PredBlocks())
     {
-        curBlk = pred->getBlock();
-
-        /* is this a backward edge? (from curBlk to begBlk) */
+        /* is this a backward edge? (from predBlock to begBlk) */
 
-        if (begBlk->bbNum > curBlk->bbNum)
+        if (begBlk->bbNum > predBlock->bbNum)
         {
             continue;
         }
 
         /* We only consider back-edges that are BBJ_COND or BBJ_ALWAYS for loops */
 
-        if ((curBlk->bbJumpKind != BBJ_COND) && (curBlk->bbJumpKind != BBJ_ALWAYS))
+        if ((predBlock->bbJumpKind != BBJ_COND) && (predBlock->bbJumpKind != BBJ_ALWAYS))
         {
             continue;
         }
@@ -330,7 +325,7 @@ void Compiler::optUnmarkLoopBlocks(BasicBlock* begBlk, BasicBlock* endBlk)
     }
 #endif
 
-    curBlk = begBlk;
+    BasicBlock* curBlk = begBlk;
     while (true)
     {
         noway_assert(curBlk);
@@ -449,9 +444,6 @@ void Compiler::optUpdateLoopsBeforeRemoveBlock(BasicBlock* block, bool skipUnmar
 
         switch (block->bbJumpKind)
         {
-            unsigned     jumpCnt;
-            BasicBlock** jumpTab;
-
             case BBJ_NONE:
             case BBJ_COND:
                 if (block->bbNext == loop.lpEntry)
@@ -475,17 +467,14 @@ void Compiler::optUpdateLoopsBeforeRemoveBlock(BasicBlock* block, bool skipUnmar
                 break;
 
             case BBJ_SWITCH:
-                jumpCnt = block->bbJumpSwt->bbsCount;
-                jumpTab = block->bbJumpSwt->bbsDstTab;
-
-                do
+                for (BasicBlock* const bTarget : block->SwitchTargets())
                 {
-                    noway_assert(*jumpTab);
-                    if ((*jumpTab) == loop.lpEntry)
+                    if (bTarget == loop.lpEntry)
                     {
                         removeLoop = true;
+                        break;
                     }
-                } while (++jumpTab, --jumpCnt);
+                }
                 break;
 
             default:
@@ -497,21 +486,17 @@ void Compiler::optUpdateLoopsBeforeRemoveBlock(BasicBlock* block, bool skipUnmar
             /* Check if the entry has other predecessors outside the loop
              * TODO: Replace this when predecessors are available */
 
-            BasicBlock* auxBlock;
-            for (auxBlock = fgFirstBB; auxBlock; auxBlock = auxBlock->bbNext)
+            for (BasicBlock* const auxBlock : Blocks())
             {
                 /* Ignore blocks in the loop */
 
-                if (auxBlock->bbNum > loop.lpHead->bbNum && auxBlock->bbNum <= loop.lpBottom->bbNum)
+                if (loop.lpContains(auxBlock))
                 {
                     continue;
                 }
 
                 switch (auxBlock->bbJumpKind)
                 {
-                    unsigned     jumpCnt;
-                    BasicBlock** jumpTab;
-
                     case BBJ_NONE:
                     case BBJ_COND:
                         if (auxBlock->bbNext == loop.lpEntry)
@@ -535,17 +520,14 @@ void Compiler::optUpdateLoopsBeforeRemoveBlock(BasicBlock* block, bool skipUnmar
                         break;
 
                     case BBJ_SWITCH:
-                        jumpCnt = auxBlock->bbJumpSwt->bbsCount;
-                        jumpTab = auxBlock->bbJumpSwt->bbsDstTab;
-
-                        do
+                        for (BasicBlock* const bTarget : auxBlock->SwitchTargets())
                         {
-                            noway_assert(*jumpTab);
-                            if ((*jumpTab) == loop.lpEntry)
+                            if (bTarget == loop.lpEntry)
                             {
                                 removeLoop = false;
+                                break;
                             }
-                        } while (++jumpTab, --jumpCnt);
+                        }
                         break;
 
                     default:
@@ -1183,9 +1165,8 @@ bool Compiler::optRecordLoop(BasicBlock*   head,
 
         // Make sure the "iterVar" initialization is never skipped,
         // i.e. every pred of ENTRY other than HEAD is in the loop.
-        for (flowList* predEdge = entry->bbPreds; predEdge; predEdge = predEdge->flNext)
+        for (BasicBlock* const predBlock : entry->PredBlocks())
         {
-            BasicBlock* predBlock = predEdge->getBlock();
             if ((predBlock != head) && !optLoopTable[loopInd].lpContains(predBlock))
             {
                 goto DONE_LOOP;
@@ -1244,7 +1225,7 @@ bool Compiler::optRecordLoop(BasicBlock*   head,
             do
             {
                 block = block->bbNext;
-                for (Statement* stmt : block->Statements())
+                for (Statement* const stmt : block->Statements())
                 {
                     if (stmt->GetRootNode() == incr)
                     {
@@ -1318,38 +1299,35 @@ void Compiler::optPrintLoopRecording(unsigned loopInd) const
 
 void Compiler::optCheckPreds()
 {
-    BasicBlock* block;
-    BasicBlock* blockPred;
-    flowList*   pred;
-
-    for (block = fgFirstBB; block; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
-        for (pred = block->bbPreds; pred; pred = pred->flNext)
+        for (BasicBlock* const predBlock : block->PredBlocks())
         {
             // make sure this pred is part of the BB list
-            for (blockPred = fgFirstBB; blockPred; blockPred = blockPred->bbNext)
+            BasicBlock* bb;
+            for (bb = fgFirstBB; bb; bb = bb->bbNext)
             {
-                if (blockPred == pred->getBlock())
+                if (bb == predBlock)
                 {
                     break;
                 }
             }
-            noway_assert(blockPred);
-            switch (blockPred->bbJumpKind)
+            noway_assert(bb);
+            switch (bb->bbJumpKind)
             {
                 case BBJ_COND:
-                    if (blockPred->bbJumpDest == block)
+                    if (bb->bbJumpDest == block)
                     {
                         break;
                     }
                     FALLTHROUGH;
                 case BBJ_NONE:
-                    noway_assert(blockPred->bbNext == block);
+                    noway_assert(bb->bbNext == block);
                     break;
                 case BBJ_EHFILTERRET:
                 case BBJ_ALWAYS:
                 case BBJ_EHCATCHRET:
-                    noway_assert(blockPred->bbJumpDest == block);
+                    noway_assert(bb->bbJumpDest == block);
                     break;
                 default:
                     break;
@@ -1824,18 +1802,16 @@ class LoopSearch
             }
 
             // Add preds to the worklist, checking for side-entries.
-            for (flowList* predIter = block->bbPreds; predIter != nullptr; predIter = predIter->flNext)
+            for (BasicBlock* const predBlock : block->PredBlocks())
             {
-                BasicBlock* pred = predIter->getBlock();
-
-                unsigned int testNum = PositionNum(pred);
+                unsigned int testNum = PositionNum(predBlock);
 
                 if ((testNum < top->bbNum) || (testNum > bottom->bbNum))
                 {
                     // Pred is out of loop range
                     if (block == entry)
                     {
-                        if (pred == head)
+                        if (predBlock == head)
                         {
                             // This is the single entry we expect.
                             continue;
@@ -1843,9 +1819,9 @@ class LoopSearch
                         // ENTRY has some pred other than head outside the loop.  If ENTRY does not
                         // dominate this pred, we'll consider this a side-entry and skip this loop;
                         // otherwise the loop is still valid and this may be a (flow-wise) back-edge
-                        // of an outer loop.  For the dominance test, if `pred` is a new block, use
+                        // of an outer loop.  For the dominance test, if `predBlock` is a new block, use
                         // its unique predecessor since the dominator tree has info for that.
-                        BasicBlock* effectivePred = (pred->bbNum > oldBlockMaxNum ? pred->bbPrev : pred);
+                        BasicBlock* effectivePred = (predBlock->bbNum > oldBlockMaxNum ? predBlock->bbPrev : predBlock);
                         if (comp->fgDominate(entry, effectivePred))
                         {
                             // Outer loop back-edge
@@ -1858,32 +1834,33 @@ class LoopSearch
                 }
 
                 bool isFirstVisit;
-                if (pred == entry)
+                if (predBlock == entry)
                 {
                     // We have indeed found a cycle in the flow graph.
                     isFirstVisit = !foundCycle;
                     foundCycle   = true;
-                    assert(loopBlocks.IsMember(pred->bbNum));
+                    assert(loopBlocks.IsMember(predBlock->bbNum));
                 }
-                else if (loopBlocks.TestAndInsert(pred->bbNum))
+                else if (loopBlocks.TestAndInsert(predBlock->bbNum))
                 {
                     // Already visited this pred
                     isFirstVisit = false;
                 }
                 else
                 {
-                    // Add this pred to the worklist
-                    worklist.push_back(pred);
+                    // Add this predBlock to the worklist
+                    worklist.push_back(predBlock);
                     isFirstVisit = true;
                 }
 
-                if (isFirstVisit && (pred->bbNext != nullptr) && (PositionNum(pred->bbNext) == pred->bbNum))
+                if (isFirstVisit && (predBlock->bbNext != nullptr) &&
+                    (PositionNum(predBlock->bbNext) == predBlock->bbNum))
                 {
-                    // We've created a new block immediately after `pred` to
+                    // We've created a new block immediately after `predBlock` to
                     // reconnect what was fall-through.  Mark it as in-loop also;
                     // it needs to stay with `prev` and if it exits the loop we'd
                     // just need to re-create it if we tried to move it out.
-                    loopBlocks.Insert(pred->bbNext->bbNum);
+                    loopBlocks.Insert(predBlock->bbNext->bbNum);
                 }
             }
         }
@@ -2102,9 +2079,9 @@ class LoopSearch
         // of an edge from the run of blocks being moved to `newMoveAfter` -- doing so would
         // introduce a new lexical back-edge, which could (maybe?) confuse the loop search
         // algorithm, and isn't desirable layout anyway.
-        for (flowList* predIter = newMoveAfter->bbPreds; predIter != nullptr; predIter = predIter->flNext)
+        for (BasicBlock* const predBlock : newMoveAfter->PredBlocks())
         {
-            unsigned int predNum = predIter->getBlock()->bbNum;
+            unsigned int predNum = predBlock->bbNum;
 
             if ((predNum >= top->bbNum) && (predNum <= bottom->bbNum) && !loopBlocks.IsMember(predNum))
             {
@@ -2169,12 +2146,10 @@ class LoopSearch
     //
     bool CanTreatAsLoopBlocks(BasicBlock* firstNonLoopBlock, BasicBlock* lastNonLoopBlock)
     {
-        BasicBlock* nextLoopBlock = lastNonLoopBlock->bbNext;
-        for (BasicBlock* testBlock = firstNonLoopBlock; testBlock != nextLoopBlock; testBlock = testBlock->bbNext)
+        for (BasicBlock* const testBlock : comp->Blocks(firstNonLoopBlock, lastNonLoopBlock))
         {
-            for (flowList* predIter = testBlock->bbPreds; predIter != nullptr; predIter = predIter->flNext)
+            for (BasicBlock* const testPred : testBlock->PredBlocks())
             {
-                BasicBlock*  testPred           = predIter->getBlock();
                 unsigned int predPosNum         = PositionNum(testPred);
                 unsigned int firstNonLoopPosNum = PositionNum(firstNonLoopBlock);
                 unsigned int lastNonLoopPosNum  = PositionNum(lastNonLoopBlock);
@@ -2329,23 +2304,14 @@ class LoopSearch
                 break;
 
             case BBJ_SWITCH:
-
-                unsigned jumpCnt;
-                jumpCnt = block->bbJumpSwt->bbsCount;
-                BasicBlock** jumpTab;
-                jumpTab = block->bbJumpSwt->bbsDstTab;
-
-                do
+                for (BasicBlock* const exitPoint : block->SwitchTargets())
                 {
-                    noway_assert(*jumpTab);
-                    exitPoint = *jumpTab;
-
                     if (!loopBlocks.IsMember(exitPoint->bbNum))
                     {
                         lastExit = block;
                         exitCount++;
                     }
-                } while (++jumpTab, --jumpCnt);
+                }
                 break;
 
             default:
@@ -2389,7 +2355,7 @@ void Compiler::optFindNaturalLoops()
 
     LoopSearch search(this);
 
-    for (BasicBlock* head = fgFirstBB; head->bbNext; head = head->bbNext)
+    for (BasicBlock* head = fgFirstBB; head->bbNext != nullptr; head = head->bbNext)
     {
         BasicBlock* top = head->bbNext;
 
@@ -2401,9 +2367,9 @@ void Compiler::optFindNaturalLoops()
             continue;
         }
 
-        for (flowList* pred = top->bbPreds; pred; pred = pred->flNext)
+        for (BasicBlock* const predBlock : top->PredBlocks())
         {
-            if (search.FindLoop(head, top, pred->getBlock()))
+            if (search.FindLoop(head, top, predBlock))
             {
                 // Found a loop; record it and see if we've hit the limit.
                 bool recordedLoop = search.RecordLoop();
@@ -2500,16 +2466,9 @@ void Compiler::optFindNaturalLoops()
     // this -- the innermost loop labeling will be done last.
     for (unsigned char loopInd = 0; loopInd < optLoopCount; loopInd++)
     {
-        BasicBlock* first  = optLoopTable[loopInd].lpFirst;
-        BasicBlock* bottom = optLoopTable[loopInd].lpBottom;
-        for (BasicBlock* blk = first; blk != nullptr; blk = blk->bbNext)
+        for (BasicBlock* const blk : optLoopTable[loopInd].LoopBlocks())
         {
             blk->bbNatLoopNum = loopInd;
-            if (blk == bottom)
-            {
-                break;
-            }
-            assert(blk->bbNext != nullptr); // We should never reach nullptr.
         }
     }
 
@@ -2678,10 +2637,8 @@ void Compiler::optCopyBlkDest(BasicBlock* from, BasicBlock* to)
             break;
 
         case BBJ_SWITCH:
-        {
             to->bbJumpSwt = new (this, CMK_BasicBlock) BBswtDesc(this, from->bbJumpSwt);
-        }
-        break;
+            break;
 
         default:
             break;
@@ -2859,10 +2816,8 @@ bool Compiler::optCanonicalizeLoop(unsigned char loopInd)
     // This is ok, because after the first redirection, the topPredBlock branch target will no longer match the source
     // edge of the blockMap, so nothing will happen.
     bool firstPred = true;
-    for (flowList* topPred = t->bbPreds; topPred != nullptr; topPred = topPred->flNext)
+    for (BasicBlock* const topPredBlock : t->PredBlocks())
     {
-        BasicBlock* topPredBlock = topPred->getBlock();
-
         // Skip if topPredBlock is in the loop.
         // Note that this uses block number to detect membership in the loop. We are adding blocks during
         // canonicalization, and those block numbers will be new, and larger than previous blocks. However, we work
@@ -3770,7 +3725,7 @@ PhaseStatus Compiler::optUnrollLoops()
                     ++loopRetCount;
                 }
 
-                for (Statement* stmt : block->Statements())
+                for (Statement* const stmt : block->Statements())
                 {
                     gtSetStmtInfo(stmt);
                     loopCostSz += stmt->GetCostSz();
@@ -4251,7 +4206,7 @@ bool Compiler::optInvertWhileLoop(BasicBlock* block)
 
     unsigned estDupCostSz = 0;
 
-    for (Statement* stmt : bTest->Statements())
+    for (Statement* const stmt : bTest->Statements())
     {
         GenTree* tree = stmt->GetRootNode();
         gtPrepareCost(tree);
@@ -4340,7 +4295,7 @@ bool Compiler::optInvertWhileLoop(BasicBlock* block)
         //
         // If the condition has array.Length operations, also boost, as they are likely to be CSE'd.
 
-        for (Statement* stmt : bTest->Statements())
+        for (Statement* const stmt : bTest->Statements())
         {
             GenTree* tree = stmt->GetRootNode();
 
@@ -4399,7 +4354,7 @@ bool Compiler::optInvertWhileLoop(BasicBlock* block)
     BasicBlock* bNewCond = fgNewBBafter(BBJ_COND, block, /*extendRegion*/ true);
 
     // Clone each statement in bTest and append to bNewCond.
-    for (Statement* stmt : bTest->Statements())
+    for (Statement* const stmt : bTest->Statements())
     {
         GenTree* originalTree = stmt->GetRootNode();
         GenTree* clonedTree   = gtCloneExpr(originalTree);
@@ -4471,10 +4426,9 @@ bool Compiler::optInvertWhileLoop(BasicBlock* block)
 
     unsigned loopFirstNum  = bNewCond->bbNext->bbNum;
     unsigned loopBottomNum = bTest->bbNum;
-    for (flowList* pred = bTest->bbPreds; pred != nullptr; pred = pred->flNext)
+    for (BasicBlock* const predBlock : bTest->PredBlocks())
     {
-        BasicBlock* predBlock = pred->getBlock();
-        unsigned    bNum      = predBlock->bbNum;
+        unsigned bNum = predBlock->bbNum;
         if ((loopFirstNum <= bNum) && (bNum <= loopBottomNum))
         {
             // Looks like the predecessor is from within the potential loop; skip it.
@@ -4602,7 +4556,7 @@ PhaseStatus Compiler::optInvertLoops()
     }
 
     bool madeChanges = false; // Assume no changes made
-    for (BasicBlock* block = fgFirstBB; block; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
         // Make sure the appropriate fields are initialized
         //
@@ -4697,20 +4651,14 @@ PhaseStatus Compiler::optFindLoops()
          * lastBottom - used when we have multiple back-edges to the same top
          */
 
-        flowList* pred;
-
-        BasicBlock* top;
-
-        for (top = fgFirstBB; top; top = top->bbNext)
+        for (BasicBlock* const top : Blocks())
         {
             BasicBlock* foundBottom = nullptr;
 
-            for (pred = top->bbPreds; pred; pred = pred->flNext)
+            for (BasicBlock* const bottom : top->PredBlocks())
             {
                 /* Is this a loop candidate? - We look for "back edges" */
 
-                BasicBlock* bottom = pred->getBlock();
-
                 /* is this a backward edge? (from BOTTOM to TOP) */
 
                 if (top->bbNum > bottom->bbNum)
@@ -5360,7 +5308,7 @@ bool Compiler::optIsVarAssigned(BasicBlock* beg, BasicBlock* end, GenTree* skip,
     {
         noway_assert(beg != nullptr);
 
-        for (Statement* stmt : beg->Statements())
+        for (Statement* const stmt : beg->Statements())
         {
             if (fgWalkTreePre(stmt->GetRootNodePointer(), optIsVarAssgCB, &desc) != WALK_CONTINUE)
             {
@@ -5405,12 +5353,8 @@ bool Compiler::optIsVarAssgLoop(unsigned lnum, unsigned var)
 /*****************************************************************************/
 int Compiler::optIsSetAssgLoop(unsigned lnum, ALLVARSET_VALARG_TP vars, varRefKinds inds)
 {
-    LoopDsc* loop;
-
-    /* Get hold of the loop descriptor */
-
     noway_assert(lnum < optLoopCount);
-    loop = optLoopTable + lnum;
+    LoopDsc* loop = &optLoopTable[lnum];
 
     /* Do we already know what variables are assigned within this loop? */
 
@@ -5418,9 +5362,6 @@ int Compiler::optIsSetAssgLoop(unsigned lnum, ALLVARSET_VALARG_TP vars, varRefKi
     {
         isVarAssgDsc desc;
 
-        BasicBlock* beg;
-        BasicBlock* end;
-
         /* Prepare the descriptor used by the tree walker call-back */
 
         desc.ivaVar  = (unsigned)-1;
@@ -5435,14 +5376,9 @@ int Compiler::optIsSetAssgLoop(unsigned lnum, ALLVARSET_VALARG_TP vars, varRefKi
 
         /* Now walk all the statements of the loop */
 
-        beg = loop->lpHead->bbNext;
-        end = loop->lpBottom;
-
-        for (/**/; /**/; beg = beg->bbNext)
+        for (BasicBlock* const block : loop->LoopBlocks())
         {
-            noway_assert(beg);
-
-            for (Statement* stmt : StatementList(beg->FirstNonPhiDef()))
+            for (Statement* const stmt : block->NonPhiStatements())
             {
                 fgWalkTreePre(stmt->GetRootNodePointer(), optIsVarAssgCB, &desc);
 
@@ -5451,11 +5387,6 @@ int Compiler::optIsSetAssgLoop(unsigned lnum, ALLVARSET_VALARG_TP vars, varRefKi
                     loop->lpFlags |= LPFLG_ASGVARS_INC;
                 }
             }
-
-            if (beg == end)
-            {
-                break;
-            }
         }
 
         AllVarSetOps::Assign(this, loop->lpAsgVars, desc.ivaMaskVal);
@@ -6197,7 +6128,7 @@ void Compiler::optHoistLoopBlocks(unsigned loopNum, ArrayStack<BasicBlock*>* blo
 
         void HoistBlock(BasicBlock* block)
         {
-            for (Statement* stmt : StatementList(block->FirstNonPhiDef()))
+            for (Statement* const stmt : block->NonPhiStatements())
             {
                 WalkTree(stmt->GetRootNodePointer(), nullptr);
                 assert(m_valueStack.TopRef().Node() == stmt->GetRootNode());
@@ -6805,7 +6736,7 @@ void Compiler::fgCreateLoopPreHeader(unsigned lnum)
     // into the phi via the loop header block will now flow through the preheader
     // block from the header block.
 
-    for (Statement* stmt : top->Statements())
+    for (Statement* const stmt : top->Statements())
     {
         GenTree* tree = stmt->GetRootNode();
         if (tree->OperGet() != GT_ASG)
@@ -6851,10 +6782,8 @@ void Compiler::fgCreateLoopPreHeader(unsigned lnum)
     edgeToPreHeader->setEdgeWeights(preHead->bbWeight, preHead->bbWeight, preHead);
     bool checkNestedLoops = false;
 
-    for (flowList* pred = top->bbPreds; pred; pred = pred->flNext)
+    for (BasicBlock* const predBlock : top->PredBlocks())
     {
-        BasicBlock* predBlock = pred->getBlock();
-
         if (fgDominate(top, predBlock))
         {
             // note: if 'top' dominates predBlock, 'head' dominates predBlock too
@@ -7028,9 +6957,8 @@ void Compiler::optComputeLoopSideEffects()
 void Compiler::optComputeLoopNestSideEffects(unsigned lnum)
 {
     assert(optLoopTable[lnum].lpParent == BasicBlock::NOT_IN_LOOP); // Requires: lnum is outermost.
-    BasicBlock* botNext = optLoopTable[lnum].lpBottom->bbNext;
-    JITDUMP("optComputeLoopSideEffects botNext is " FMT_BB ", lnum is %d\n", botNext->bbNum, lnum);
-    for (BasicBlock* bbInLoop = optLoopTable[lnum].lpFirst; bbInLoop != botNext; bbInLoop = bbInLoop->bbNext)
+    JITDUMP("optComputeLoopSideEffects lnum is %d\n", lnum);
+    for (BasicBlock* const bbInLoop : optLoopTable[lnum].LoopBlocks())
     {
         if (!optComputeLoopSideEffectsOfBlock(bbInLoop))
         {
@@ -7084,9 +7012,9 @@ bool Compiler::optComputeLoopSideEffectsOfBlock(BasicBlock* blk)
     MemoryKindSet memoryHavoc = emptyMemoryKindSet;
 
     // Now iterate over the remaining statements, and their trees.
-    for (Statement* stmt : StatementList(blk->FirstNonPhiDef()))
+    for (Statement* const stmt : blk->NonPhiStatements())
     {
-        for (GenTree* tree = stmt->GetTreeList(); tree != nullptr; tree = tree->gtNext)
+        for (GenTree* const tree : stmt->TreeList())
         {
             genTreeOps oper = tree->OperGet();
 
@@ -7840,7 +7768,7 @@ void Compiler::optOptimizeBools()
     {
         change = false;
 
-        for (BasicBlock* b1 = fgFirstBB; b1; b1 = b1->bbNext)
+        for (BasicBlock* const b1 : Blocks())
         {
             /* We're only interested in conditional jumps here */
 
@@ -8233,7 +8161,7 @@ void Compiler::optRemoveRedundantZeroInits()
         for (Statement* stmt = block->FirstNonPhiDef(); stmt != nullptr;)
         {
             Statement* next = stmt->GetNextStmt();
-            for (GenTree* tree = stmt->GetTreeList(); tree != nullptr; tree = tree->gtNext)
+            for (GenTree* const tree : stmt->TreeList())
             {
                 if (((tree->gtFlags & GTF_CALL) != 0))
                 {
diff --git a/src/coreclr/jit/patchpoint.cpp b/src/coreclr/jit/patchpoint.cpp
index 8ce03ea9590620..bb5b5ffe0e79fc 100644
--- a/src/coreclr/jit/patchpoint.cpp
+++ b/src/coreclr/jit/patchpoint.cpp
@@ -50,7 +50,7 @@ class PatchpointTransformer
         }
 
         int count = 0;
-        for (BasicBlock* block = compiler->fgFirstBB->bbNext; block != nullptr; block = block->bbNext)
+        for (BasicBlock* const block : compiler->Blocks(compiler->fgFirstBB->bbNext))
         {
             if (block->bbFlags & BBF_PATCHPOINT)
             {
diff --git a/src/coreclr/jit/rangecheck.cpp b/src/coreclr/jit/rangecheck.cpp
index a8beca893765b1..5c95b91883c521 100644
--- a/src/coreclr/jit/rangecheck.cpp
+++ b/src/coreclr/jit/rangecheck.cpp
@@ -1445,9 +1445,9 @@ Compiler::fgWalkResult MapMethodDefsVisitor(GenTree** ptr, Compiler::fgWalkData*
 void RangeCheck::MapMethodDefs()
 {
     // First, gather where all definitions occur in the program and store it in a map.
-    for (BasicBlock* block = m_pCompiler->fgFirstBB; block != nullptr; block = block->bbNext)
+    for (BasicBlock* const block : m_pCompiler->Blocks())
     {
-        for (Statement* stmt : block->Statements())
+        for (Statement* const stmt : block->Statements())
         {
             MapMethodDefsData data(this, block, stmt);
             m_pCompiler->fgWalkTreePre(stmt->GetRootNodePointer(), MapMethodDefsVisitor, &data, false, true);
@@ -1474,11 +1474,11 @@ void RangeCheck::OptimizeRangeChecks()
 #endif
 
     // Walk through trees looking for arrBndsChk node and check if it can be optimized.
-    for (BasicBlock* block = m_pCompiler->fgFirstBB; block; block = block->bbNext)
+    for (BasicBlock* const block : m_pCompiler->Blocks())
     {
-        for (Statement* stmt : block->Statements())
+        for (Statement* const stmt : block->Statements())
         {
-            for (GenTree* tree = stmt->GetTreeList(); tree; tree = tree->gtNext)
+            for (GenTree* const tree : stmt->TreeList())
             {
                 if (IsOverBudget())
                 {
diff --git a/src/coreclr/jit/rationalize.cpp b/src/coreclr/jit/rationalize.cpp
index ea0e5fb9dc0ed3..ede632657f8cc5 100644
--- a/src/coreclr/jit/rationalize.cpp
+++ b/src/coreclr/jit/rationalize.cpp
@@ -302,14 +302,13 @@ void Rationalizer::ValidateStatement(Statement* stmt, BasicBlock* block)
 void Rationalizer::SanityCheck()
 {
     // TODO: assert(!IsLIR());
-    BasicBlock* block;
-    foreach_block(comp, block)
+    for (BasicBlock* const block : comp->Blocks())
     {
-        for (Statement* statement : block->Statements())
+        for (Statement* const stmt : block->Statements())
         {
-            ValidateStatement(statement, block);
+            ValidateStatement(stmt, block);
 
-            for (GenTree* tree = statement->GetTreeList(); tree; tree = tree->gtNext)
+            for (GenTree* const tree : stmt->TreeList())
             {
                 // QMARK and PUT_ARG_TYPE nodes should have been removed before this phase.
                 assert(!tree->OperIs(GT_QMARK, GT_PUTARG_TYPE));
@@ -933,7 +932,7 @@ PhaseStatus Rationalizer::DoPhase()
     comp->fgOrder   = Compiler::FGOrderLinear;
 
     RationalizeVisitor visitor(*this);
-    for (BasicBlock* block = comp->fgFirstBB; block != nullptr; block = block->bbNext)
+    for (BasicBlock* const block : comp->Blocks())
     {
         comp->compCurBB = block;
         m_block         = block;
@@ -949,7 +948,7 @@ PhaseStatus Rationalizer::DoPhase()
             continue;
         }
 
-        for (Statement* statement : StatementList(firstStatement))
+        for (Statement* const statement : block->Statements())
         {
             assert(statement->GetTreeList() != nullptr);
             assert(statement->GetTreeList()->gtPrev == nullptr);
diff --git a/src/coreclr/jit/redundantbranchopts.cpp b/src/coreclr/jit/redundantbranchopts.cpp
index 63125a8c6c3371..34fe9da3503995 100644
--- a/src/coreclr/jit/redundantbranchopts.cpp
+++ b/src/coreclr/jit/redundantbranchopts.cpp
@@ -21,7 +21,7 @@ PhaseStatus Compiler::optRedundantBranches()
 
     bool madeChanges = false;
 
-    for (BasicBlock* block = fgFirstBB; block != nullptr; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
         // Skip over any removed blocks.
         //
@@ -40,7 +40,7 @@ PhaseStatus Compiler::optRedundantBranches()
 
     // Reset visited flags, in case we set any.
     //
-    for (BasicBlock* block = fgFirstBB; block != nullptr; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
         block->bbFlags &= ~BBF_VISITED;
     }
@@ -311,7 +311,7 @@ bool Compiler::optJumpThread(BasicBlock* const block, BasicBlock* const domBlock
     //
     Statement* const lastStmt = block->lastStmt();
 
-    for (Statement* stmt = block->FirstNonPhiDef(); stmt != nullptr; stmt = stmt->GetNextStmt())
+    for (Statement* const stmt : block->NonPhiStatements())
     {
         GenTree* const tree = stmt->GetRootNode();
 
@@ -389,9 +389,8 @@ bool Compiler::optJumpThread(BasicBlock* const block, BasicBlock* const domBlock
     BasicBlock* const trueTarget        = block->bbJumpDest;
     BasicBlock* const falseTarget       = block->bbNext;
 
-    for (flowList* pred = block->bbPreds; pred != nullptr; pred = pred->flNext)
+    for (BasicBlock* const predBlock : block->PredBlocks())
     {
-        BasicBlock* const predBlock = pred->getBlock();
         numPreds++;
 
         // Treat switch preds as ambiguous for now.
@@ -510,10 +509,8 @@ bool Compiler::optJumpThread(BasicBlock* const block, BasicBlock* const domBlock
     // flow directly by changing their jump targets to the appropriate successor,
     // provided it's a permissable flow in our EH model.
     //
-    for (flowList* pred = block->bbPreds; pred != nullptr; pred = pred->flNext)
+    for (BasicBlock* const predBlock : block->PredBlocks())
     {
-        BasicBlock* const predBlock = pred->getBlock();
-
         if (predBlock->bbJumpKind == BBJ_SWITCH)
         {
             // Skip over switch preds, they will continue to flow to block.
@@ -633,7 +630,7 @@ bool Compiler::optReachable(BasicBlock* const fromBlock, BasicBlock* const toBlo
         return true;
     }
 
-    for (BasicBlock* block = fgFirstBB; block != nullptr; block = block->bbNext)
+    for (BasicBlock* const block : Blocks())
     {
         block->bbFlags &= ~BBF_VISITED;
     }
diff --git a/src/coreclr/jit/simdashwintrinsic.cpp b/src/coreclr/jit/simdashwintrinsic.cpp
index e8f742cfc78a9a..638353f5642c4b 100644
--- a/src/coreclr/jit/simdashwintrinsic.cpp
+++ b/src/coreclr/jit/simdashwintrinsic.cpp
@@ -479,6 +479,27 @@ GenTree* Compiler::impSimdAsHWIntrinsicSpecial(NamedIntrinsic       intrinsic,
             }
             break;
         }
+
+        case NI_VectorT128_Sum:
+        {
+            // TODO-XArch-CQ: We could support this all the way down to SSE2 and that might be
+            // worthwhile so we can accelerate cases like byte/sbyte and long/ulong
+
+            if (varTypeIsFloating(simdBaseType))
+            {
+                if (!compOpportunisticallyDependsOn(InstructionSet_SSE3))
+                {
+                    // Floating-point types require SSE3.HorizontalAdd
+                    return nullptr;
+                }
+            }
+            else if (!compOpportunisticallyDependsOn(InstructionSet_SSSE3))
+            {
+                // Integral types require SSSE3.HorizontalAdd
+                return nullptr;
+            }
+            break;
+        }
 #endif // TARGET_XARCH
 
         default:
@@ -719,12 +740,115 @@ GenTree* Compiler::impSimdAsHWIntrinsicSpecial(NamedIntrinsic       intrinsic,
                     }
                     break;
                 }
+                case NI_VectorT128_Sum:
+                {
+
+                    GenTree* tmp;
+                    unsigned vectorLength = getSIMDVectorLength(simdSize, simdBaseType);
+                    int      haddCount    = genLog2(vectorLength);
+
+                    NamedIntrinsic horizontalAdd =
+                        varTypeIsFloating(simdBaseType) ? NI_SSE3_HorizontalAdd : NI_SSSE3_HorizontalAdd;
+
+                    for (int i = 0; i < haddCount; i++)
+                    {
+                        op1 = impCloneExpr(op1, &tmp, clsHnd, (unsigned)CHECK_SPILL_ALL,
+                                           nullptr DEBUGARG("Clone op1 for Vector<T>.Sum"));
+                        op1 = gtNewSimdAsHWIntrinsicNode(simdType, op1, tmp, horizontalAdd, simdBaseJitType, simdSize);
+                    }
+
+                    return gtNewSimdAsHWIntrinsicNode(retType, op1, NI_Vector128_ToScalar, simdBaseJitType, simdSize);
+                }
+                case NI_VectorT256_Sum:
+                {
+                    // HorizontalAdd combines pairs so we need log2(vectorLength) passes to sum all elements together.
+                    unsigned vectorLength = getSIMDVectorLength(simdSize, simdBaseType);
+                    int haddCount = genLog2(vectorLength) - 1; // Minus 1 because for the last pass we split the vector
+                                                               // to low / high and add them together.
+                    GenTree*       tmp;
+                    NamedIntrinsic horizontalAdd = NI_AVX2_HorizontalAdd;
+                    NamedIntrinsic add           = NI_SSE2_Add;
+
+                    if (simdBaseType == TYP_DOUBLE)
+                    {
+                        horizontalAdd = NI_AVX_HorizontalAdd;
+                    }
+                    else if (simdBaseType == TYP_FLOAT)
+                    {
+                        horizontalAdd = NI_AVX_HorizontalAdd;
+                        add           = NI_SSE_Add;
+                    }
+
+                    for (int i = 0; i < haddCount; i++)
+                    {
+                        op1 = impCloneExpr(op1, &tmp, clsHnd, (unsigned)CHECK_SPILL_ALL,
+                                           nullptr DEBUGARG("Clone op1 for Vector<T>.Sum"));
+                        op1 = gtNewSimdAsHWIntrinsicNode(simdType, op1, tmp, horizontalAdd, simdBaseJitType, simdSize);
+                    }
+
+                    op1 = impCloneExpr(op1, &tmp, clsHnd, (unsigned)CHECK_SPILL_ALL,
+                                       nullptr DEBUGARG("Clone op1 for Vector<T>.Sum"));
+                    op1 = gtNewSimdAsHWIntrinsicNode(TYP_SIMD16, op1, gtNewIconNode(0x01, TYP_INT),
+                                                     NI_AVX_ExtractVector128, simdBaseJitType, simdSize);
+
+                    tmp = gtNewSimdAsHWIntrinsicNode(simdType, tmp, NI_Vector256_GetLower, simdBaseJitType, simdSize);
+                    op1 = gtNewSimdAsHWIntrinsicNode(TYP_SIMD16, op1, tmp, add, simdBaseJitType, 16);
+
+                    return gtNewSimdAsHWIntrinsicNode(retType, op1, NI_Vector128_ToScalar, simdBaseJitType, 16);
+                }
 #elif defined(TARGET_ARM64)
                 case NI_VectorT128_Abs:
                 {
                     assert(varTypeIsUnsigned(simdBaseType));
                     return op1;
                 }
+                case NI_VectorT128_Sum:
+                {
+                    GenTree* tmp;
+
+                    switch (simdBaseType)
+                    {
+                        case TYP_BYTE:
+                        case TYP_UBYTE:
+                        case TYP_SHORT:
+                        case TYP_USHORT:
+                        case TYP_INT:
+                        case TYP_UINT:
+                        {
+                            tmp = gtNewSimdAsHWIntrinsicNode(simdType, op1, NI_AdvSimd_Arm64_AddAcross, simdBaseJitType,
+                                                             simdSize);
+                            return gtNewSimdAsHWIntrinsicNode(retType, tmp, NI_Vector64_ToScalar, simdBaseJitType, 8);
+                        }
+                        case TYP_FLOAT:
+                        {
+                            unsigned vectorLength = getSIMDVectorLength(simdSize, simdBaseType);
+                            int      haddCount    = genLog2(vectorLength);
+
+                            for (int i = 0; i < haddCount; i++)
+                            {
+                                op1 = impCloneExpr(op1, &tmp, clsHnd, (unsigned)CHECK_SPILL_ALL,
+                                                   nullptr DEBUGARG("Clone op1 for Vector<T>.Sum"));
+                                op1 = gtNewSimdAsHWIntrinsicNode(simdType, op1, tmp, NI_AdvSimd_Arm64_AddPairwise,
+                                                                 simdBaseJitType, simdSize);
+                            }
+
+                            return gtNewSimdAsHWIntrinsicNode(retType, op1, NI_Vector128_ToScalar, simdBaseJitType,
+                                                              simdSize);
+                        }
+                        case TYP_DOUBLE:
+                        case TYP_LONG:
+                        case TYP_ULONG:
+                        {
+                            op1 = gtNewSimdAsHWIntrinsicNode(TYP_SIMD8, op1, NI_AdvSimd_Arm64_AddPairwiseScalar,
+                                                             simdBaseJitType, simdSize);
+                            return gtNewSimdAsHWIntrinsicNode(retType, op1, NI_Vector64_ToScalar, simdBaseJitType, 8);
+                        }
+                        default:
+                        {
+                            unreached();
+                        }
+                    }
+                }
 #else
 #error Unsupported platform
 #endif // !TARGET_XARCH && !TARGET_ARM64
diff --git a/src/coreclr/jit/simdashwintrinsiclistarm64.h b/src/coreclr/jit/simdashwintrinsiclistarm64.h
index 4eba54135a54b7..229222882f7202 100644
--- a/src/coreclr/jit/simdashwintrinsiclistarm64.h
+++ b/src/coreclr/jit/simdashwintrinsiclistarm64.h
@@ -132,6 +132,7 @@ SIMD_AS_HWINTRINSIC_ID(VectorT128,  op_Inequality,
 SIMD_AS_HWINTRINSIC_ID(VectorT128,  op_Multiply,                                            2,         {NI_VectorT128_op_Multiply,                     NI_VectorT128_op_Multiply,                      NI_VectorT128_op_Multiply,                      NI_VectorT128_op_Multiply,                      NI_VectorT128_op_Multiply,                      NI_VectorT128_op_Multiply,                      NI_Illegal,                                     NI_Illegal,                                     NI_VectorT128_op_Multiply,                      NI_VectorT128_op_Multiply},                     SimdAsHWIntrinsicFlag::None)
 SIMD_AS_HWINTRINSIC_ID(VectorT128,  op_Subtraction,                                         2,         {NI_AdvSimd_Subtract,                           NI_AdvSimd_Subtract,                            NI_AdvSimd_Subtract,                            NI_AdvSimd_Subtract,                            NI_AdvSimd_Subtract,                            NI_AdvSimd_Subtract,                            NI_AdvSimd_Subtract,                            NI_AdvSimd_Subtract,                            NI_AdvSimd_Subtract,                            NI_AdvSimd_Arm64_Subtract},                     SimdAsHWIntrinsicFlag::None)
 SIMD_AS_HWINTRINSIC_ID(VectorT128,  SquareRoot,                                             1,         {NI_Illegal,                                    NI_Illegal,                                     NI_Illegal,                                     NI_Illegal,                                     NI_Illegal,                                     NI_Illegal,                                     NI_Illegal,                                     NI_Illegal,                                     NI_AdvSimd_Arm64_Sqrt,                          NI_AdvSimd_Arm64_Sqrt},                         SimdAsHWIntrinsicFlag::None)
+SIMD_AS_HWINTRINSIC_ID(VectorT128,  Sum,                                                    1,         {NI_VectorT128_Sum,                             NI_VectorT128_Sum,                              NI_VectorT128_Sum,                              NI_VectorT128_Sum,                              NI_VectorT128_Sum,                              NI_VectorT128_Sum,                              NI_VectorT128_Sum,                              NI_VectorT128_Sum,                              NI_VectorT128_Sum,                              NI_VectorT128_Sum},                             SimdAsHWIntrinsicFlag::None)
 
 #undef SIMD_AS_HWINTRINSIC_NM
 #undef SIMD_AS_HWINTRINSIC_ID
diff --git a/src/coreclr/jit/simdashwintrinsiclistxarch.h b/src/coreclr/jit/simdashwintrinsiclistxarch.h
index af75fb75fae6d9..92d665c2de8a71 100644
--- a/src/coreclr/jit/simdashwintrinsiclistxarch.h
+++ b/src/coreclr/jit/simdashwintrinsiclistxarch.h
@@ -132,6 +132,7 @@ SIMD_AS_HWINTRINSIC_ID(VectorT128,  op_Inequality,
 SIMD_AS_HWINTRINSIC_ID(VectorT128,  op_Multiply,                                            2,         {NI_Illegal,                                NI_Illegal,                                 NI_VectorT128_op_Multiply,                  NI_VectorT128_op_Multiply,                  NI_VectorT128_op_Multiply,                  NI_VectorT128_op_Multiply,                  NI_Illegal,                                 NI_Illegal,                                 NI_VectorT128_op_Multiply,                  NI_VectorT128_op_Multiply},                 SimdAsHWIntrinsicFlag::None)
 SIMD_AS_HWINTRINSIC_ID(VectorT128,  op_Subtraction,                                         2,         {NI_SSE2_Subtract,                          NI_SSE2_Subtract,                           NI_SSE2_Subtract,                           NI_SSE2_Subtract,                           NI_SSE2_Subtract,                           NI_SSE2_Subtract,                           NI_SSE2_Subtract,                           NI_SSE2_Subtract,                           NI_SSE_Subtract,                            NI_SSE2_Subtract},                          SimdAsHWIntrinsicFlag::None)
 SIMD_AS_HWINTRINSIC_ID(VectorT128,  SquareRoot,                                             1,         {NI_Illegal,                                NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_SSE_Sqrt,                                NI_SSE2_Sqrt},                              SimdAsHWIntrinsicFlag::None)
+SIMD_AS_HWINTRINSIC_ID(VectorT128,  Sum,                                                    1,         {NI_Illegal,                                NI_Illegal,                                 NI_VectorT128_Sum,                          NI_VectorT128_Sum,                          NI_VectorT128_Sum,                          NI_VectorT128_Sum,                          NI_Illegal,                                 NI_Illegal,                                 NI_VectorT128_Sum,                          NI_VectorT128_Sum},                         SimdAsHWIntrinsicFlag::None)
 
 // *************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************
 //                     ISA          ID                          Name                        NumArg                                                                                                                                                                                                      Instructions                                                                                                                                                                                                                                           Flags
@@ -170,6 +171,7 @@ SIMD_AS_HWINTRINSIC_ID(VectorT256,  op_Inequality,
 SIMD_AS_HWINTRINSIC_ID(VectorT256,  op_Multiply,                                            2,         {NI_Illegal,                                NI_Illegal,                                 NI_VectorT256_op_Multiply,                  NI_VectorT256_op_Multiply,                  NI_VectorT256_op_Multiply,                  NI_VectorT256_op_Multiply,                  NI_Illegal,                                 NI_Illegal,                                 NI_VectorT256_op_Multiply,                  NI_VectorT256_op_Multiply},                 SimdAsHWIntrinsicFlag::None)
 SIMD_AS_HWINTRINSIC_ID(VectorT256,  op_Subtraction,                                         2,         {NI_AVX2_Subtract,                          NI_AVX2_Subtract,                           NI_AVX2_Subtract,                           NI_AVX2_Subtract,                           NI_AVX2_Subtract,                           NI_AVX2_Subtract,                           NI_AVX2_Subtract,                           NI_AVX2_Subtract,                           NI_AVX_Subtract,                            NI_AVX_Subtract},                           SimdAsHWIntrinsicFlag::None)
 SIMD_AS_HWINTRINSIC_ID(VectorT256,  SquareRoot,                                             1,         {NI_Illegal,                                NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_Illegal,                                 NI_AVX_Sqrt,                                NI_AVX_Sqrt},                               SimdAsHWIntrinsicFlag::None)
+SIMD_AS_HWINTRINSIC_ID(VectorT256,  Sum,                                                    1,         {NI_Illegal,                                NI_Illegal,                                 NI_VectorT256_Sum,                          NI_VectorT256_Sum,                          NI_VectorT256_Sum,                          NI_VectorT256_Sum,                          NI_Illegal,                                 NI_Illegal,                                 NI_VectorT256_Sum,                          NI_VectorT256_Sum},                         SimdAsHWIntrinsicFlag::None)
 
 #undef SIMD_AS_HWINTRINSIC_NM
 #undef SIMD_AS_HWINTRINSIC_ID
diff --git a/src/coreclr/jit/ssabuilder.cpp b/src/coreclr/jit/ssabuilder.cpp
index 46671f8444bcc5..ea5d708b208c54 100644
--- a/src/coreclr/jit/ssabuilder.cpp
+++ b/src/coreclr/jit/ssabuilder.cpp
@@ -89,7 +89,7 @@ void Compiler::fgResetForSsa()
         m_memorySsaMap[memoryKind] = nullptr;
     }
 
-    for (BasicBlock* blk = fgFirstBB; blk != nullptr; blk = blk->bbNext)
+    for (BasicBlock* const blk : Blocks())
     {
         // Eliminate phis.
         for (MemoryKind memoryKind : allMemoryKinds())
@@ -106,14 +106,13 @@ void Compiler::fgResetForSsa()
             }
         }
 
-        for (Statement* stmt : blk->Statements())
+        for (Statement* const stmt : blk->Statements())
         {
-            for (GenTree* tree = stmt->GetTreeList(); tree != nullptr; tree = tree->gtNext)
+            for (GenTree* const tree : stmt->TreeList())
             {
                 if (tree->IsLocal())
                 {
                     tree->AsLclVarCommon()->SetSsaNum(SsaConfig::RESERVED_SSA_NUM);
-                    continue;
                 }
             }
         }
@@ -486,7 +485,7 @@ void SsaBuilder::ComputeIteratedDominanceFrontier(BasicBlock* b, const BlkToBlkV
 static GenTree* GetPhiNode(BasicBlock* block, unsigned lclNum)
 {
     // Walk the statements for phi nodes.
-    for (Statement* stmt : block->Statements())
+    for (Statement* const stmt : block->Statements())
     {
         // A prefix of the statements of the block are phi definition nodes. If we complete processing
         // that prefix, exit.
@@ -540,7 +539,7 @@ void SsaBuilder::InsertPhi(BasicBlock* block, unsigned lclNum)
 
 #ifdef DEBUG
     unsigned seqNum = 1;
-    for (GenTree* node = stmt->GetTreeList(); node != nullptr; node = node->gtNext)
+    for (GenTree* const node : stmt->TreeList())
     {
         node->gtSeqNum = seqNum++;
     }
@@ -590,7 +589,7 @@ void SsaBuilder::AddPhiArg(
 
 #ifdef DEBUG
     unsigned seqNum = 1;
-    for (GenTree* node = stmt->GetTreeList(); node != nullptr; node = node->gtNext)
+    for (GenTree* const node : stmt->TreeList())
     {
         node->gtSeqNum = seqNum++;
     }
@@ -904,7 +903,7 @@ void SsaBuilder::AddDefToHandlerPhis(BasicBlock* block, unsigned lclNum, unsigne
                 bool phiFound = false;
 #endif
                 // A prefix of blocks statements will be SSA definitions.  Search those for "lclNum".
-                for (Statement* stmt : handler->Statements())
+                for (Statement* const stmt : handler->Statements())
                 {
                     // If the tree is not an SSA def, break out of the loop: we're done.
                     if (!stmt->IsPhiDefnStmt())
@@ -1055,9 +1054,9 @@ void SsaBuilder::BlockRenameVariables(BasicBlock* block)
     }
 
     // Walk the statements of the block and rename definitions and uses.
-    for (Statement* stmt : block->Statements())
+    for (Statement* const stmt : block->Statements())
     {
-        for (GenTree* tree = stmt->GetTreeList(); tree != nullptr; tree = tree->gtNext)
+        for (GenTree* const tree : stmt->TreeList())
         {
             if (tree->OperIs(GT_ASG))
             {
@@ -1120,7 +1119,7 @@ void SsaBuilder::AddPhiArgsToSuccessors(BasicBlock* block)
     for (BasicBlock* succ : block->GetAllSuccs(m_pCompiler))
     {
         // Walk the statements for phi nodes.
-        for (Statement* stmt : succ->Statements())
+        for (Statement* const stmt : succ->Statements())
         {
             // A prefix of the statements of the block are phi definition nodes. If we complete processing
             // that prefix, exit.
@@ -1251,7 +1250,7 @@ void SsaBuilder::AddPhiArgsToSuccessors(BasicBlock* block)
                 // For a filter, we consider the filter to be the "real" handler.
                 BasicBlock* handlerStart = succTry->ExFlowBlock();
 
-                for (Statement* stmt : handlerStart->Statements())
+                for (Statement* const stmt : handlerStart->Statements())
                 {
                     GenTree* tree = stmt->GetRootNode();
 
@@ -1393,7 +1392,7 @@ void SsaBuilder::RenameVariables()
 
     // Initialize the memory ssa numbers for unreachable blocks. ValueNum expects
     // memory ssa numbers to have some intitial value.
-    for (BasicBlock* block = m_pCompiler->fgFirstBB; block; block = block->bbNext)
+    for (BasicBlock* const block : m_pCompiler->Blocks())
     {
         if (block->bbIDom == nullptr)
         {
@@ -1528,7 +1527,7 @@ void SsaBuilder::Build()
     // tree is built. The pre/post order numbers that were generated previously and used for loop
     // recognition are still being used by optPerformHoistExpr via fgCreateLoopPreHeader. That's rather
     // odd, considering that SetupBBRoot may have added a new block.
-    for (BasicBlock* block = m_pCompiler->fgFirstBB; block != nullptr; block = block->bbNext)
+    for (BasicBlock* const block : m_pCompiler->Blocks())
     {
         block->bbIDom         = nullptr;
         block->bbPostOrderNum = 0;
diff --git a/src/coreclr/jit/stacklevelsetter.cpp b/src/coreclr/jit/stacklevelsetter.cpp
index 361a4faadf5370..da20ff6fe22574 100644
--- a/src/coreclr/jit/stacklevelsetter.cpp
+++ b/src/coreclr/jit/stacklevelsetter.cpp
@@ -42,12 +42,12 @@ StackLevelSetter::StackLevelSetter(Compiler* compiler)
 //
 PhaseStatus StackLevelSetter::DoPhase()
 {
-    for (BasicBlock* block = comp->fgFirstBB; block != nullptr; block = block->bbNext)
+    for (BasicBlock* const block : comp->Blocks())
     {
         ProcessBlock(block);
     }
-#if !FEATURE_FIXED_OUT_ARGS
 
+#if !FEATURE_FIXED_OUT_ARGS
     if (framePointerRequired)
     {
         comp->codeGen->setFramePointerRequired(true);
diff --git a/src/coreclr/jit/valuenum.cpp b/src/coreclr/jit/valuenum.cpp
index cff036bba092d9..e49ba55eca816a 100644
--- a/src/coreclr/jit/valuenum.cpp
+++ b/src/coreclr/jit/valuenum.cpp
@@ -3787,27 +3787,43 @@ ValueNum ValueNumStore::VNApplySelectorsTypeCheck(ValueNum elem, var_types indTy
     return elem;
 }
 
-ValueNum ValueNumStore::VNApplySelectorsAssignTypeCoerce(ValueNum elem, var_types indType, BasicBlock* block)
+//------------------------------------------------------------------------
+// VNApplySelectorsAssignTypeCoerce: Compute the value number corresponding to `srcVN`
+//    being written using an indirection of 'dstIndType'.
+//
+// Arguments:
+//    srcVN - value number for the value being stored;
+//    dstIndType - type of the indirection storing the value to the memory;
+//    block - block where the assignment occurs
+//
+// Return Value:
+//    The value number corresponding to memory after the assignment.
+//
+// Notes: It may insert a cast to dstIndType or return a unique value number for an incompatible indType.
+//
+ValueNum ValueNumStore::VNApplySelectorsAssignTypeCoerce(ValueNum srcVN, var_types dstIndType, BasicBlock* block)
 {
-    var_types elemTyp = TypeOfVN(elem);
+    var_types srcType = TypeOfVN(srcVN);
 
-    // Check if the elemTyp is matching/compatible
+    ValueNum dstVN;
 
-    if (indType != elemTyp)
+    // Check if the elemTyp is matching/compatible.
+    if (dstIndType != srcType)
     {
-        bool isConstant = IsVNConstant(elem);
-        if (isConstant && (elemTyp == genActualType(indType)))
+        bool isConstant = IsVNConstant(srcVN);
+        if (isConstant && (srcType == genActualType(dstIndType)))
         {
             // (i.e. We recorded a constant of TYP_INT for a TYP_BYTE field)
+            dstVN = srcVN;
         }
         else
         {
             // We are trying to write an 'elem' of type 'elemType' using 'indType' store
 
-            if (varTypeIsStruct(indType))
+            if (varTypeIsStruct(dstIndType))
             {
                 // return a new unique value number
-                elem = VNMakeNormalUnique(elem);
+                dstVN = VNMakeNormalUnique(srcVN);
 
                 JITDUMP("    *** Mismatched types in VNApplySelectorsAssignTypeCoerce (indType is TYP_STRUCT)\n");
             }
@@ -3816,14 +3832,18 @@ ValueNum ValueNumStore::VNApplySelectorsAssignTypeCoerce(ValueNum elem, var_type
                 // We are trying to write an 'elem' of type 'elemType' using 'indType' store
 
                 // insert a cast of elem to 'indType'
-                elem = VNForCast(elem, indType, elemTyp);
+                dstVN = VNForCast(srcVN, dstIndType, srcType);
 
                 JITDUMP("    Cast to %s inserted in VNApplySelectorsAssignTypeCoerce (elemTyp is %s)\n",
-                        varTypeName(indType), varTypeName(elemTyp));
+                        varTypeName(dstIndType), varTypeName(srcType));
             }
         }
     }
-    return elem;
+    else
+    {
+        dstVN = srcVN;
+    }
+    return dstVN;
 }
 
 //------------------------------------------------------------------------
@@ -6191,12 +6211,11 @@ void Compiler::fgValueNumber()
         {
             lvMemoryPerSsaData.GetSsaDefByIndex(i)->m_vnPair = noVnp;
         }
-        for (BasicBlock* blk = fgFirstBB; blk != nullptr; blk = blk->bbNext)
+        for (BasicBlock* const blk : Blocks())
         {
-            // Now iterate over the block's statements, and their trees.
-            for (Statement* stmt : StatementList(blk->FirstNonPhiDef()))
+            for (Statement* const stmt : blk->NonPhiStatements())
             {
-                for (GenTree* tree = stmt->GetTreeList(); tree != nullptr; tree = tree->gtNext)
+                for (GenTree* const tree : stmt->TreeList())
                 {
                     tree->gtVNPair.SetBoth(ValueNumStore::NoVN);
                 }
@@ -6542,7 +6561,7 @@ void Compiler::fgValueNumberBlock(BasicBlock* blk)
         }
 #endif
 
-        for (GenTree* tree = stmt->GetTreeList(); tree != nullptr; tree = tree->gtNext)
+        for (GenTree* const tree : stmt->TreeList())
         {
             fgValueNumberTree(tree);
         }
@@ -7410,18 +7429,26 @@ void Compiler::fgValueNumberTree(GenTree* tree)
                         //
                         if (lcl->gtVNPair.GetLiberal() == ValueNumStore::NoVN)
                         {
-                            // So far, we know about two of these cases:
+#ifdef DEBUG
+
+                            // So far, we know about three of these cases:
                             // Case 1) We have a local var who has never been defined but it's seen as a use.
                             //         This is the case of storeIndir(addr(lclvar)) = expr.  In this case since we only
                             //         take the address of the variable, this doesn't mean it's a use nor we have to
-                            //         initialize it, so in this very rare case, we fabricate a value number.
-                            // Case 2) Local variables that represent structs which are assigned using CpBlk.
+                            //         initialize it, so in this very rare case, we fabricate a value number;
+                            // Case 2) Local variables that represent structs which are assigned using CpBlk;
+                            // Case 3) Local variable was written using a partial write,
+                            //         for example, BLK<1>(ADDR(LCL_VAR int)) = 1, it will change only the first byte.
+                            //         Check that there was ld-addr-op on the local.
                             //
-                            // Make sure we have either case 1 or case 2
+                            // Make sure we have one of these cases.
                             //
-                            GenTree* nextNode = lcl->gtNext;
+                            const GenTree*   nextNode = lcl->gtNext;
+                            const LclVarDsc* varDsc   = lvaGetDesc(lcl);
+
                             assert((nextNode->gtOper == GT_ADDR && nextNode->AsOp()->gtOp1 == lcl) ||
-                                   varTypeIsStruct(lcl->TypeGet()));
+                                   varTypeIsStruct(lcl->TypeGet()) || varDsc->lvHasLdAddrOp);
+#endif // DEBUG
 
                             // We will assign a unique value number for these
                             //
@@ -7888,11 +7915,19 @@ void Compiler::fgValueNumberTree(GenTree* tree)
 
                                     if (fieldSeq == FieldSeqStore::NotAField())
                                     {
+                                        assert(!isEntire && "did not expect an entire NotAField write.");
                                         // We don't know where we're storing, so give the local a new, unique VN.
                                         // Do this by considering it an "entire" assignment, with an unknown RHS.
                                         isEntire = true;
                                         rhsVNPair.SetBoth(vnStore->VNForExpr(compCurBB, lclVarTree->TypeGet()));
                                     }
+                                    else if ((fieldSeq == nullptr) && !isEntire)
+                                    {
+                                        // It is a partial store of a LCL_VAR without using LCL_FLD.
+                                        // Generate a unique VN.
+                                        isEntire = true;
+                                        rhsVNPair.SetBoth(vnStore->VNForExpr(compCurBB, lclVarTree->TypeGet()));
+                                    }
 
                                     if (isEntire)
                                     {
diff --git a/src/coreclr/jit/valuenum.h b/src/coreclr/jit/valuenum.h
index 3d81e37a3c8d33..c1cf8af6c2a274 100644
--- a/src/coreclr/jit/valuenum.h
+++ b/src/coreclr/jit/valuenum.h
@@ -543,10 +543,7 @@ class ValueNumStore
     ValueNum VNApplySelectorsAssign(
         ValueNumKind vnk, ValueNum map, FieldSeqNode* fieldSeq, ValueNum rhs, var_types indType, BasicBlock* block);
 
-    // Used after VNApplySelectorsAssign has determined that "elem" is to be writen into a Map using VNForMapStore
-    // It determines whether the 'elem' is of an appropriate type to be writen using using an indirection of 'indType'
-    // It may insert a cast to indType or return a unique value number for an incompatible indType.
-    ValueNum VNApplySelectorsAssignTypeCoerce(ValueNum elem, var_types indType, BasicBlock* block);
+    ValueNum VNApplySelectorsAssignTypeCoerce(ValueNum srcElem, var_types dstIndType, BasicBlock* block);
 
     ValueNumPair VNPairApplySelectors(ValueNumPair map, FieldSeqNode* fieldSeq, var_types indType);
 
diff --git a/src/coreclr/md/enc/CMakeLists.txt b/src/coreclr/md/enc/CMakeLists.txt
index 6bd2518d868c90..d4abb371ffbc46 100644
--- a/src/coreclr/md/enc/CMakeLists.txt
+++ b/src/coreclr/md/enc/CMakeLists.txt
@@ -62,10 +62,6 @@ add_library_clr(mdruntimerw-dbi ${MDRUNTIMERW_SOURCES})
 set_target_properties(mdruntimerw-dbi PROPERTIES DBI_COMPONENT TRUE)
 target_precompile_headers(mdruntimerw-dbi PRIVATE stdafx.h)
 
-add_library_clr(mdruntimerw_crossgen ${MDRUNTIMERW_SOURCES})
-set_target_properties(mdruntimerw_crossgen PROPERTIES CROSSGEN_COMPONENT TRUE)
-target_precompile_headers(mdruntimerw_crossgen PRIVATE stdafx.h)
-
 add_library_clr(mdruntimerw_ppdb ${MDRUNTIMERW_SOURCES})
 target_compile_definitions(mdruntimerw_ppdb PRIVATE FEATURE_METADATA_EMIT_ALL FEATURE_METADATA_EMIT_PORTABLE_PDB)
 target_precompile_headers(mdruntimerw_ppdb PRIVATE stdafx.h)
diff --git a/src/coreclr/md/inc/VerifyLayouts.inc b/src/coreclr/md/inc/VerifyLayouts.inc
index 14e068ecefa3e0..2ca6384b868417 100644
--- a/src/coreclr/md/inc/VerifyLayouts.inc
+++ b/src/coreclr/md/inc/VerifyLayouts.inc
@@ -156,6 +156,9 @@ FIELD(CLiteWeightStgdbRW, m_wszFileName, sizeof(void*))
 FIELD(CLiteWeightStgdbRW, m_dwDatabaseLFT, 4)
 FIELD(CLiteWeightStgdbRW, m_dwDatabaseLFS, 4)
 FIELD(CLiteWeightStgdbRW, m_pStgIO, sizeof(void*))
+#ifdef FEATURE_METADATA_EMIT_PORTABLE_PDB
+FIELD(CLiteWeightStgdbRW, m_pPdbHeap, sizeof(void*))
+#endif
 END_TYPE(CLiteWeightStgdbRW, 8)
 
 USING_ALIAS(CLiteWeightStgdb__CMiniMdRW__, CLiteWeightStgdb<CMiniMdRW>)
diff --git a/src/coreclr/md/inc/metamodel.h b/src/coreclr/md/inc/metamodel.h
index e3206a589ad99e..a1cb17724601eb 100644
--- a/src/coreclr/md/inc/metamodel.h
+++ b/src/coreclr/md/inc/metamodel.h
@@ -594,6 +594,7 @@ class CMiniMdBase : public IMetaModelCommonRO
 
 
 protected:
+    DAC_ALIGNAS(8)
     CMiniMdSchema   m_Schema;                       // data header.
     ULONG           m_TblCount;                     // Tables in this database.
     BOOL            m_fVerifiedByTrustedSource;     // whether the data was verified by a trusted source
diff --git a/src/coreclr/md/runtime/CMakeLists.txt b/src/coreclr/md/runtime/CMakeLists.txt
index 6ff49d3e803e21..3e1fc8eda75c1a 100644
--- a/src/coreclr/md/runtime/CMakeLists.txt
+++ b/src/coreclr/md/runtime/CMakeLists.txt
@@ -59,10 +59,6 @@ add_library_clr(mdruntime-dbi ${MDRUNTIME_SOURCES})
 set_target_properties(mdruntime-dbi PROPERTIES DBI_COMPONENT TRUE)
 target_precompile_headers(mdruntime-dbi PRIVATE stdafx.h)
 
-add_library_clr(mdruntime_crossgen ${MDRUNTIME_SOURCES})
-set_target_properties(mdruntime_crossgen PROPERTIES CROSSGEN_COMPONENT TRUE)
-target_precompile_headers(mdruntime_crossgen PRIVATE stdafx.h)
-
 add_library_clr(mdruntime_ppdb ${MDRUNTIME_SOURCES})
 target_compile_definitions(mdruntime_ppdb PRIVATE FEATURE_METADATA_EMIT_ALL FEATURE_METADATA_EMIT_PORTABLE_PDB)
 target_precompile_headers(mdruntime_ppdb PRIVATE stdafx.h)
diff --git a/src/coreclr/pal/inc/pal.h b/src/coreclr/pal/inc/pal.h
index 25f16e4a42eec0..8e0553e02e8889 100644
--- a/src/coreclr/pal/inc/pal.h
+++ b/src/coreclr/pal/inc/pal.h
@@ -94,6 +94,8 @@ typedef PVOID NATIVE_LIBRARY_HANDLE;
 #define _M_ARM 7
 #elif defined(__aarch64__) && !defined(_M_ARM64)
 #define _M_ARM64 1
+#elif defined(__s390x__) && !defined(_M_S390X)
+#define _M_S390X 1
 #endif
 
 #if defined(_M_IX86) && !defined(HOST_X86)
@@ -104,6 +106,8 @@ typedef PVOID NATIVE_LIBRARY_HANDLE;
 #define HOST_ARM
 #elif defined(_M_ARM64) && !defined(HOST_ARM64)
 #define HOST_ARM64
+#elif defined(_M_S390X) && !defined(HOST_S390X)
+#define HOST_S390X
 #endif
 
 #endif // !_MSC_VER
@@ -2189,6 +2193,112 @@ typedef struct _KNONVOLATILE_CONTEXT_POINTERS {
 
 } KNONVOLATILE_CONTEXT_POINTERS, *PKNONVOLATILE_CONTEXT_POINTERS;
 
+#elif defined(HOST_S390X)
+
+// There is no context for s390x defined in winnt.h,
+// so we re-use the amd64 values.
+#define CONTEXT_S390X   0x100000
+
+#define CONTEXT_CONTROL (CONTEXT_S390X | 0x1L)
+#define CONTEXT_INTEGER (CONTEXT_S390X | 0x2L)
+#define CONTEXT_FLOATING_POINT  (CONTEXT_S390X | 0x4L)
+
+#define CONTEXT_FULL (CONTEXT_CONTROL | CONTEXT_INTEGER | CONTEXT_FLOATING_POINT)
+
+#define CONTEXT_ALL (CONTEXT_CONTROL | CONTEXT_INTEGER | CONTEXT_FLOATING_POINT)
+
+#define CONTEXT_EXCEPTION_ACTIVE 0x8000000
+#define CONTEXT_SERVICE_ACTIVE 0x10000000
+#define CONTEXT_EXCEPTION_REQUEST 0x40000000
+#define CONTEXT_EXCEPTION_REPORTING 0x80000000
+
+typedef struct DECLSPEC_ALIGN(8) _CONTEXT {
+
+    //
+    // Control flags.
+    //
+
+    DWORD ContextFlags;
+
+    //
+    // Integer registers.
+    //
+
+    union {
+        DWORD64 Gpr[16];
+        struct {
+            DWORD64 R0;
+            DWORD64 R1;
+            DWORD64 R2;
+            DWORD64 R3;
+            DWORD64 R4;
+            DWORD64 R5;
+            DWORD64 R6;
+            DWORD64 R7;
+            DWORD64 R8;
+            DWORD64 R9;
+            DWORD64 R10;
+            DWORD64 R11;
+            DWORD64 R12;
+            DWORD64 R13;
+            DWORD64 R14;
+            DWORD64 R15;
+        };
+    };
+
+    //
+    // Floating-point registers.
+    //
+
+    union {
+        DWORD64 Fpr[16];
+        struct {
+            DWORD64 F0;
+            DWORD64 F1;
+            DWORD64 F2;
+            DWORD64 F3;
+            DWORD64 F4;
+            DWORD64 F5;
+            DWORD64 F6;
+            DWORD64 F7;
+            DWORD64 F8;
+            DWORD64 F9;
+            DWORD64 F10;
+            DWORD64 F11;
+            DWORD64 F12;
+            DWORD64 F13;
+            DWORD64 F14;
+            DWORD64 F15;
+        };
+    };
+
+    //
+    // Control registers.
+    //
+
+    DWORD64 PSWMask;
+    DWORD64 PSWAddr;
+
+} CONTEXT, *PCONTEXT, *LPCONTEXT;
+
+//
+// Nonvolatile context pointer record.
+//
+
+typedef struct _KNONVOLATILE_CONTEXT_POINTERS {
+    PDWORD64 R6;
+    PDWORD64 R7;
+    PDWORD64 R8;
+    PDWORD64 R9;
+    PDWORD64 R10;
+    PDWORD64 R11;
+    PDWORD64 R12;
+    PDWORD64 R13;
+    PDWORD64 R14;
+    PDWORD64 R15;
+
+} KNONVOLATILE_CONTEXT_POINTERS, *PKNONVOLATILE_CONTEXT_POINTERS;
+
 #else
 #error Unknown architecture for defining CONTEXT.
 #endif
@@ -2324,6 +2434,8 @@ PALIMPORT BOOL PALAPI PAL_VirtualUnwindOutOfProc(CONTEXT *context, KNONVOLATILE_
 #define PAL_CS_NATIVE_DATA_SIZE 76
 #elif defined(__linux__) && defined(__x86_64__)
 #define PAL_CS_NATIVE_DATA_SIZE 96
+#elif defined(__linux__) && defined(HOST_S390X)
+#define PAL_CS_NATIVE_DATA_SIZE 96
 #elif defined(__NetBSD__) && defined(__amd64__)
 #define PAL_CS_NATIVE_DATA_SIZE 96
 #elif defined(__NetBSD__) && defined(__earm__)
@@ -2648,33 +2760,17 @@ VirtualFree(
         IN SIZE_T dwSize,
         IN DWORD dwFreeType);
 
+
 #if defined(HOST_OSX) && defined(HOST_ARM64)
-#ifdef __cplusplus
-extern "C++" {
-struct PAL_JITWriteEnableHolder
-{
-public:
-  PAL_JITWriteEnableHolder(bool jitWriteEnable)
-  {
-      m_jitWriteEnableRestore = JITWriteEnable(jitWriteEnable);
-  };
-  ~PAL_JITWriteEnableHolder()
-  {
-      JITWriteEnable(m_jitWriteEnableRestore);
-  }
 
-private:
-  bool JITWriteEnable(bool enable);
-  bool m_jitWriteEnableRestore;
-};
+PALIMPORT
+VOID
+PALAPI
+PAL_JitWriteProtect(bool writeEnable);
 
-inline
-PAL_JITWriteEnableHolder
-PAL_JITWriteEnable(IN bool enable) { return PAL_JITWriteEnableHolder(enable); }
-}
-#endif // __cplusplus
 #endif // defined(HOST_OSX) && defined(HOST_ARM64)
 
+
 PALIMPORT
 BOOL
 PALAPI
diff --git a/src/coreclr/pal/inc/rt/intsafe.h b/src/coreclr/pal/inc/rt/intsafe.h
index 9159c1bb1676f5..2b607e3a312e12 100644
--- a/src/coreclr/pal/inc/rt/intsafe.h
+++ b/src/coreclr/pal/inc/rt/intsafe.h
@@ -31,7 +31,7 @@
 #define LODWORD(_qw)    ((ULONG)(_qw))
 
 #if defined(MIDL_PASS) || defined(RC_INVOKED) || defined(_M_CEE_PURE) \
-    || defined(_M_AMD64) || defined(__ARM_ARCH)
+    || defined(_M_AMD64) || defined(__ARM_ARCH) || defined(_M_S390X)
 
 #ifndef UInt32x32To64
 #define UInt32x32To64(a, b) ((unsigned __int64)((ULONG)(a)) * (unsigned __int64)((ULONG)(b)))
diff --git a/src/coreclr/pal/inc/rt/palrt.h b/src/coreclr/pal/inc/rt/palrt.h
index db50a288af0bf6..0855f5991cd8c8 100644
--- a/src/coreclr/pal/inc/rt/palrt.h
+++ b/src/coreclr/pal/inc/rt/palrt.h
@@ -1215,6 +1215,14 @@ typedef struct _DISPATCHER_CONTEXT {
     BOOLEAN ControlPcIsUnwound;
 } DISPATCHER_CONTEXT, *PDISPATCHER_CONTEXT;
 
+#elif defined(HOST_S390X)
+
+typedef struct _DISPATCHER_CONTEXT {
+    // S390X does not build the VM or JIT at this point,
+    // so we only provide a dummy definition.
+    DWORD Reserved;
+} DISPATCHER_CONTEXT, *PDISPATCHER_CONTEXT;
+
 #else
 
 #error Unknown architecture for defining DISPATCHER_CONTEXT.
diff --git a/src/coreclr/pal/inc/unixasmmacros.inc b/src/coreclr/pal/inc/unixasmmacros.inc
index 3740ab1b365824..1fe285eef162d2 100644
--- a/src/coreclr/pal/inc/unixasmmacros.inc
+++ b/src/coreclr/pal/inc/unixasmmacros.inc
@@ -9,7 +9,7 @@
 #define LOCAL_LABEL(name) L##name
 #else
 #define C_FUNC(name) name
-#if defined(HOST_AMD64) || defined(HOST_X86)
+#if defined(HOST_AMD64) || defined(HOST_X86) || defined(HOST_S390X)
 #define EXTERNAL_C_FUNC(name) C_FUNC(name)@plt
 #else
 #define EXTERNAL_C_FUNC(name) C_FUNC(name)
@@ -41,4 +41,6 @@
 #include "unixasmmacrosarm.inc"
 #elif defined(HOST_ARM64)
 #include "unixasmmacrosarm64.inc"
+#elif defined(HOST_S390X)
+#include "unixasmmacross390x.inc"
 #endif
diff --git a/src/coreclr/pal/inc/unixasmmacross390x.inc b/src/coreclr/pal/inc/unixasmmacross390x.inc
new file mode 100644
index 00000000000000..ae6a894ad7cd5b
--- /dev/null
+++ b/src/coreclr/pal/inc/unixasmmacross390x.inc
@@ -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.
+
+.macro NESTED_ENTRY Name, Section, Handler
+        LEAF_ENTRY \Name, \Section
+        .ifnc \Handler, NoHandler
+        .cfi_personality 0x1b, C_FUNC(\Handler) // 0x1b == DW_EH_PE_pcrel | DW_EH_PE_sdata4
+        .endif
+.endm
+
+.macro NESTED_END Name, Section
+        LEAF_END \Name, \Section
+.endm
+
+.macro PATCH_LABEL Name
+        .global C_FUNC(\Name)
+C_FUNC(\Name):
+.endm
+
+.macro LEAF_ENTRY Name, Section
+        .global C_FUNC(\Name)
+        .type \Name, %function
+C_FUNC(\Name):
+        .cfi_startproc
+.endm
+
+.macro LEAF_END Name, Section
+        .size \Name, .-\Name
+        .cfi_endproc
+.endm
+
+.macro LEAF_END_MARKED Name, Section
+C_FUNC(\Name\()_End):
+        .global C_FUNC(\Name\()_End)
+        LEAF_END \Name, \Section
+.endm
+
diff --git a/src/coreclr/pal/prebuilt/idl/corprof_i.cpp b/src/coreclr/pal/prebuilt/idl/corprof_i.cpp
index 498c52b3914c3f..07b78a4fb33952 100644
--- a/src/coreclr/pal/prebuilt/idl/corprof_i.cpp
+++ b/src/coreclr/pal/prebuilt/idl/corprof_i.cpp
@@ -90,6 +90,9 @@ MIDL_DEFINE_GUID(IID, IID_ICorProfilerCallback9,0x27583EC3,0xC8F5,0x482F,0x80,0x
 MIDL_DEFINE_GUID(IID, IID_ICorProfilerCallback10,0xCEC5B60E,0xC69C,0x495F,0x87,0xF6,0x84,0xD2,0x8E,0xE1,0x6F,0xFB);
 
 
+MIDL_DEFINE_GUID(IID, IID_ICorProfilerCallback11,0x42350846,0xAAED,0x47F7,0xB1,0x28,0xFD,0x0C,0x98,0x88,0x1C,0xDE);
+
+
 MIDL_DEFINE_GUID(IID, IID_ICorProfilerInfo,0x28B5557D,0x3F3F,0x48b4,0x90,0xB2,0x5F,0x9E,0xEA,0x2F,0x6C,0x48);
 
 
@@ -141,6 +144,9 @@ MIDL_DEFINE_GUID(IID, IID_ICorProfilerInfo11,0x06398876,0x8987,0x4154,0xB6,0x21,
 MIDL_DEFINE_GUID(IID, IID_ICorProfilerInfo12,0x27b24ccd,0x1cb1,0x47c5,0x96,0xee,0x98,0x19,0x0d,0xc3,0x09,0x59);
 
 
+MIDL_DEFINE_GUID(IID, IID_ICorProfilerInfo13,0x19C4179D,0xF92C,0x4D25,0x9F,0x20,0x5F,0xEB,0xFB,0xBD,0x29,0x78);
+
+
 MIDL_DEFINE_GUID(IID, IID_ICorProfilerMethodEnum,0xFCCEE788,0x0088,0x454B,0xA8,0x11,0xC9,0x9F,0x29,0x8D,0x19,0x42);
 
 
diff --git a/src/coreclr/pal/prebuilt/inc/corprof.h b/src/coreclr/pal/prebuilt/inc/corprof.h
index 2311aa50686262..85ce86870bf8c0 100644
--- a/src/coreclr/pal/prebuilt/inc/corprof.h
+++ b/src/coreclr/pal/prebuilt/inc/corprof.h
@@ -4,10 +4,8 @@
 
 
  /* File created by MIDL compiler version 8.01.0622 */
-/* at Mon Jan 18 19:14:07 2038
- */
-/* Compiler settings for C:/git/runtime/src/coreclr/inc/corprof.idl:
-    Oicf, W1, Zp8, env=Win32 (32b run), target_arch=X86 8.01.0622 
+/* Compiler settings for corprof.idl:
+    Oicf, W1, Zp8, env=Win64 (32b run), target_arch=AMD64 8.01.0622 
     protocol : dce , ms_ext, c_ext, robust
     error checks: allocation ref bounds_check enum stub_data 
     VC __declspec() decoration level: 
@@ -115,6 +113,13 @@ typedef interface ICorProfilerCallback10 ICorProfilerCallback10;
 #endif  /* __ICorProfilerCallback10_FWD_DEFINED__ */
 
 
+#ifndef __ICorProfilerCallback11_FWD_DEFINED__
+#define __ICorProfilerCallback11_FWD_DEFINED__
+typedef interface ICorProfilerCallback11 ICorProfilerCallback11;
+
+#endif  /* __ICorProfilerCallback11_FWD_DEFINED__ */
+
+
 #ifndef __ICorProfilerInfo_FWD_DEFINED__
 #define __ICorProfilerInfo_FWD_DEFINED__
 typedef interface ICorProfilerInfo ICorProfilerInfo;
@@ -552,6 +557,7 @@ enum __MIDL___MIDL_itf_corprof_0000_0000_0005
         COR_PRF_ALL = 0x8fffffff,
         COR_PRF_REQUIRE_PROFILE_IMAGE   = ( ( COR_PRF_USE_PROFILE_IMAGES | COR_PRF_MONITOR_CODE_TRANSITIONS )  | COR_PRF_MONITOR_ENTERLEAVE ) ,
         COR_PRF_ALLOWABLE_AFTER_ATTACH  = ( ( ( ( ( ( ( ( ( ( COR_PRF_MONITOR_THREADS | COR_PRF_MONITOR_MODULE_LOADS )  | COR_PRF_MONITOR_ASSEMBLY_LOADS )  | COR_PRF_MONITOR_APPDOMAIN_LOADS )  | COR_PRF_ENABLE_STACK_SNAPSHOT )  | COR_PRF_MONITOR_GC )  | COR_PRF_MONITOR_SUSPENDS )  | COR_PRF_MONITOR_CLASS_LOADS )  | COR_PRF_MONITOR_EXCEPTIONS )  | COR_PRF_MONITOR_JIT_COMPILATION )  | COR_PRF_ENABLE_REJIT ) ,
+        COR_PRF_ALLOWABLE_NOTIFICATION_PROFILER = ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( COR_PRF_MONITOR_FUNCTION_UNLOADS | COR_PRF_MONITOR_CLASS_LOADS )  | COR_PRF_MONITOR_MODULE_LOADS )  | COR_PRF_MONITOR_ASSEMBLY_LOADS )  | COR_PRF_MONITOR_APPDOMAIN_LOADS )  | COR_PRF_MONITOR_JIT_COMPILATION )  | COR_PRF_MONITOR_EXCEPTIONS )  | COR_PRF_MONITOR_OBJECT_ALLOCATED )  | COR_PRF_MONITOR_THREADS )  | COR_PRF_MONITOR_CODE_TRANSITIONS )  | COR_PRF_MONITOR_CCW )  | COR_PRF_MONITOR_SUSPENDS )  | COR_PRF_MONITOR_CACHE_SEARCHES )  | COR_PRF_DISABLE_INLINING )  | COR_PRF_DISABLE_OPTIMIZATIONS )  | COR_PRF_ENABLE_OBJECT_ALLOCATED )  | COR_PRF_MONITOR_CLR_EXCEPTIONS )  | COR_PRF_ENABLE_STACK_SNAPSHOT )  | COR_PRF_USE_PROFILE_IMAGES )  | COR_PRF_DISABLE_ALL_NGEN_IMAGES ) ,
         COR_PRF_MONITOR_IMMUTABLE   = ( ( ( ( ( ( ( ( ( ( ( ( ( ( COR_PRF_MONITOR_CODE_TRANSITIONS | COR_PRF_MONITOR_REMOTING )  | COR_PRF_MONITOR_REMOTING_COOKIE )  | COR_PRF_MONITOR_REMOTING_ASYNC )  | COR_PRF_ENABLE_INPROC_DEBUGGING )  | COR_PRF_ENABLE_JIT_MAPS )  | COR_PRF_DISABLE_OPTIMIZATIONS )  | COR_PRF_DISABLE_INLINING )  | COR_PRF_ENABLE_OBJECT_ALLOCATED )  | COR_PRF_ENABLE_FUNCTION_ARGS )  | COR_PRF_ENABLE_FUNCTION_RETVAL )  | COR_PRF_ENABLE_FRAME_INFO )  | COR_PRF_USE_PROFILE_IMAGES )  | COR_PRF_DISABLE_TRANSPARENCY_CHECKS_UNDER_FULL_TRUST )  | COR_PRF_DISABLE_ALL_NGEN_IMAGES ) 
     }   COR_PRF_MONITOR;
 
@@ -569,6 +575,7 @@ enum __MIDL___MIDL_itf_corprof_0000_0000_0006
         COR_PRF_HIGH_MONITOR_LARGEOBJECT_ALLOCATED  = 0x40,
         COR_PRF_HIGH_MONITOR_EVENT_PIPE = 0x80,
         COR_PRF_HIGH_ALLOWABLE_AFTER_ATTACH = ( ( ( ( ( COR_PRF_HIGH_IN_MEMORY_SYMBOLS_UPDATED | COR_PRF_HIGH_MONITOR_DYNAMIC_FUNCTION_UNLOADS )  | COR_PRF_HIGH_BASIC_GC )  | COR_PRF_HIGH_MONITOR_GC_MOVED_OBJECTS )  | COR_PRF_HIGH_MONITOR_LARGEOBJECT_ALLOCATED )  | COR_PRF_HIGH_MONITOR_EVENT_PIPE ) ,
+        COR_PRF_HIGH_ALLOWABLE_NOTIFICATION_PROFILER    = ( ( ( ( ( ( COR_PRF_HIGH_IN_MEMORY_SYMBOLS_UPDATED | COR_PRF_HIGH_MONITOR_DYNAMIC_FUNCTION_UNLOADS )  | COR_PRF_HIGH_DISABLE_TIERED_COMPILATION )  | COR_PRF_HIGH_BASIC_GC )  | COR_PRF_HIGH_MONITOR_GC_MOVED_OBJECTS )  | COR_PRF_HIGH_MONITOR_LARGEOBJECT_ALLOCATED )  | COR_PRF_HIGH_MONITOR_EVENT_PIPE ) ,
         COR_PRF_HIGH_MONITOR_IMMUTABLE  = COR_PRF_HIGH_DISABLE_TIERED_COMPILATION
     }   COR_PRF_HIGH_MONITOR;
 
@@ -8351,11 +8358,829 @@ EXTERN_C const IID IID_ICorProfilerCallback10;
 #endif  /* __ICorProfilerCallback10_INTERFACE_DEFINED__ */
 
 
-/* interface __MIDL_itf_corprof_0000_0010 */
+#ifndef __ICorProfilerCallback11_INTERFACE_DEFINED__
+#define __ICorProfilerCallback11_INTERFACE_DEFINED__
+
+/* interface ICorProfilerCallback11 */
+/* [local][unique][uuid][object] */ 
+
+
+EXTERN_C const IID IID_ICorProfilerCallback11;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("42350846-AAED-47F7-B128-FD0C98881CDE")
+    ICorProfilerCallback11 : public ICorProfilerCallback10
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE LoadAsNotficationOnly( 
+            BOOL *pbNotificationOnly) = 0;
+        
+    };
+    
+    
+#else   /* C style interface */
+
+    typedef struct ICorProfilerCallback11Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ REFIID riid,
+            /* [annotation][iid_is][out] */ 
+            _COM_Outptr_  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ICorProfilerCallback11 * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ICorProfilerCallback11 * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *Initialize )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ IUnknown *pICorProfilerInfoUnk);
+        
+        HRESULT ( STDMETHODCALLTYPE *Shutdown )( 
+            ICorProfilerCallback11 * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *AppDomainCreationStarted )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ AppDomainID appDomainId);
+        
+        HRESULT ( STDMETHODCALLTYPE *AppDomainCreationFinished )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ AppDomainID appDomainId,
+            /* [in] */ HRESULT hrStatus);
+        
+        HRESULT ( STDMETHODCALLTYPE *AppDomainShutdownStarted )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ AppDomainID appDomainId);
+        
+        HRESULT ( STDMETHODCALLTYPE *AppDomainShutdownFinished )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ AppDomainID appDomainId,
+            /* [in] */ HRESULT hrStatus);
+        
+        HRESULT ( STDMETHODCALLTYPE *AssemblyLoadStarted )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ AssemblyID assemblyId);
+        
+        HRESULT ( STDMETHODCALLTYPE *AssemblyLoadFinished )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ AssemblyID assemblyId,
+            /* [in] */ HRESULT hrStatus);
+        
+        HRESULT ( STDMETHODCALLTYPE *AssemblyUnloadStarted )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ AssemblyID assemblyId);
+        
+        HRESULT ( STDMETHODCALLTYPE *AssemblyUnloadFinished )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ AssemblyID assemblyId,
+            /* [in] */ HRESULT hrStatus);
+        
+        HRESULT ( STDMETHODCALLTYPE *ModuleLoadStarted )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ ModuleID moduleId);
+        
+        HRESULT ( STDMETHODCALLTYPE *ModuleLoadFinished )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ ModuleID moduleId,
+            /* [in] */ HRESULT hrStatus);
+        
+        HRESULT ( STDMETHODCALLTYPE *ModuleUnloadStarted )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ ModuleID moduleId);
+        
+        HRESULT ( STDMETHODCALLTYPE *ModuleUnloadFinished )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ ModuleID moduleId,
+            /* [in] */ HRESULT hrStatus);
+        
+        HRESULT ( STDMETHODCALLTYPE *ModuleAttachedToAssembly )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ ModuleID moduleId,
+            /* [in] */ AssemblyID AssemblyId);
+        
+        HRESULT ( STDMETHODCALLTYPE *ClassLoadStarted )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ ClassID classId);
+        
+        HRESULT ( STDMETHODCALLTYPE *ClassLoadFinished )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ ClassID classId,
+            /* [in] */ HRESULT hrStatus);
+        
+        HRESULT ( STDMETHODCALLTYPE *ClassUnloadStarted )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ ClassID classId);
+        
+        HRESULT ( STDMETHODCALLTYPE *ClassUnloadFinished )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ ClassID classId,
+            /* [in] */ HRESULT hrStatus);
+        
+        HRESULT ( STDMETHODCALLTYPE *FunctionUnloadStarted )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ FunctionID functionId);
+        
+        HRESULT ( STDMETHODCALLTYPE *JITCompilationStarted )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ FunctionID functionId,
+            /* [in] */ BOOL fIsSafeToBlock);
+        
+        HRESULT ( STDMETHODCALLTYPE *JITCompilationFinished )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ FunctionID functionId,
+            /* [in] */ HRESULT hrStatus,
+            /* [in] */ BOOL fIsSafeToBlock);
+        
+        HRESULT ( STDMETHODCALLTYPE *JITCachedFunctionSearchStarted )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ FunctionID functionId,
+            /* [out] */ BOOL *pbUseCachedFunction);
+        
+        HRESULT ( STDMETHODCALLTYPE *JITCachedFunctionSearchFinished )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ FunctionID functionId,
+            /* [in] */ COR_PRF_JIT_CACHE result);
+        
+        HRESULT ( STDMETHODCALLTYPE *JITFunctionPitched )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ FunctionID functionId);
+        
+        HRESULT ( STDMETHODCALLTYPE *JITInlining )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ FunctionID callerId,
+            /* [in] */ FunctionID calleeId,
+            /* [out] */ BOOL *pfShouldInline);
+        
+        HRESULT ( STDMETHODCALLTYPE *ThreadCreated )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ ThreadID threadId);
+        
+        HRESULT ( STDMETHODCALLTYPE *ThreadDestroyed )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ ThreadID threadId);
+        
+        HRESULT ( STDMETHODCALLTYPE *ThreadAssignedToOSThread )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ ThreadID managedThreadId,
+            /* [in] */ DWORD osThreadId);
+        
+        HRESULT ( STDMETHODCALLTYPE *RemotingClientInvocationStarted )( 
+            ICorProfilerCallback11 * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *RemotingClientSendingMessage )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ GUID *pCookie,
+            /* [in] */ BOOL fIsAsync);
+        
+        HRESULT ( STDMETHODCALLTYPE *RemotingClientReceivingReply )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ GUID *pCookie,
+            /* [in] */ BOOL fIsAsync);
+        
+        HRESULT ( STDMETHODCALLTYPE *RemotingClientInvocationFinished )( 
+            ICorProfilerCallback11 * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *RemotingServerReceivingMessage )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ GUID *pCookie,
+            /* [in] */ BOOL fIsAsync);
+        
+        HRESULT ( STDMETHODCALLTYPE *RemotingServerInvocationStarted )( 
+            ICorProfilerCallback11 * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *RemotingServerInvocationReturned )( 
+            ICorProfilerCallback11 * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *RemotingServerSendingReply )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ GUID *pCookie,
+            /* [in] */ BOOL fIsAsync);
+        
+        HRESULT ( STDMETHODCALLTYPE *UnmanagedToManagedTransition )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ FunctionID functionId,
+            /* [in] */ COR_PRF_TRANSITION_REASON reason);
+        
+        HRESULT ( STDMETHODCALLTYPE *ManagedToUnmanagedTransition )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ FunctionID functionId,
+            /* [in] */ COR_PRF_TRANSITION_REASON reason);
+        
+        HRESULT ( STDMETHODCALLTYPE *RuntimeSuspendStarted )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ COR_PRF_SUSPEND_REASON suspendReason);
+        
+        HRESULT ( STDMETHODCALLTYPE *RuntimeSuspendFinished )( 
+            ICorProfilerCallback11 * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *RuntimeSuspendAborted )( 
+            ICorProfilerCallback11 * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *RuntimeResumeStarted )( 
+            ICorProfilerCallback11 * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *RuntimeResumeFinished )( 
+            ICorProfilerCallback11 * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *RuntimeThreadSuspended )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ ThreadID threadId);
+        
+        HRESULT ( STDMETHODCALLTYPE *RuntimeThreadResumed )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ ThreadID threadId);
+        
+        HRESULT ( STDMETHODCALLTYPE *MovedReferences )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ ULONG cMovedObjectIDRanges,
+            /* [size_is][in] */ ObjectID oldObjectIDRangeStart[  ],
+            /* [size_is][in] */ ObjectID newObjectIDRangeStart[  ],
+            /* [size_is][in] */ ULONG cObjectIDRangeLength[  ]);
+        
+        HRESULT ( STDMETHODCALLTYPE *ObjectAllocated )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ ObjectID objectId,
+            /* [in] */ ClassID classId);
+        
+        HRESULT ( STDMETHODCALLTYPE *ObjectsAllocatedByClass )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ ULONG cClassCount,
+            /* [size_is][in] */ ClassID classIds[  ],
+            /* [size_is][in] */ ULONG cObjects[  ]);
+        
+        HRESULT ( STDMETHODCALLTYPE *ObjectReferences )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ ObjectID objectId,
+            /* [in] */ ClassID classId,
+            /* [in] */ ULONG cObjectRefs,
+            /* [size_is][in] */ ObjectID objectRefIds[  ]);
+        
+        HRESULT ( STDMETHODCALLTYPE *RootReferences )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ ULONG cRootRefs,
+            /* [size_is][in] */ ObjectID rootRefIds[  ]);
+        
+        HRESULT ( STDMETHODCALLTYPE *ExceptionThrown )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ ObjectID thrownObjectId);
+        
+        HRESULT ( STDMETHODCALLTYPE *ExceptionSearchFunctionEnter )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ FunctionID functionId);
+        
+        HRESULT ( STDMETHODCALLTYPE *ExceptionSearchFunctionLeave )( 
+            ICorProfilerCallback11 * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *ExceptionSearchFilterEnter )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ FunctionID functionId);
+        
+        HRESULT ( STDMETHODCALLTYPE *ExceptionSearchFilterLeave )( 
+            ICorProfilerCallback11 * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *ExceptionSearchCatcherFound )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ FunctionID functionId);
+        
+        HRESULT ( STDMETHODCALLTYPE *ExceptionOSHandlerEnter )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ UINT_PTR __unused);
+        
+        HRESULT ( STDMETHODCALLTYPE *ExceptionOSHandlerLeave )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ UINT_PTR __unused);
+        
+        HRESULT ( STDMETHODCALLTYPE *ExceptionUnwindFunctionEnter )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ FunctionID functionId);
+        
+        HRESULT ( STDMETHODCALLTYPE *ExceptionUnwindFunctionLeave )( 
+            ICorProfilerCallback11 * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *ExceptionUnwindFinallyEnter )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ FunctionID functionId);
+        
+        HRESULT ( STDMETHODCALLTYPE *ExceptionUnwindFinallyLeave )( 
+            ICorProfilerCallback11 * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *ExceptionCatcherEnter )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ FunctionID functionId,
+            /* [in] */ ObjectID objectId);
+        
+        HRESULT ( STDMETHODCALLTYPE *ExceptionCatcherLeave )( 
+            ICorProfilerCallback11 * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *COMClassicVTableCreated )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ ClassID wrappedClassId,
+            /* [in] */ REFGUID implementedIID,
+            /* [in] */ void *pVTable,
+            /* [in] */ ULONG cSlots);
+        
+        HRESULT ( STDMETHODCALLTYPE *COMClassicVTableDestroyed )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ ClassID wrappedClassId,
+            /* [in] */ REFGUID implementedIID,
+            /* [in] */ void *pVTable);
+        
+        HRESULT ( STDMETHODCALLTYPE *ExceptionCLRCatcherFound )( 
+            ICorProfilerCallback11 * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *ExceptionCLRCatcherExecute )( 
+            ICorProfilerCallback11 * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *ThreadNameChanged )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ ThreadID threadId,
+            /* [in] */ ULONG cchName,
+            /* [annotation][in] */ 
+            _In_reads_opt_(cchName)  WCHAR name[  ]);
+        
+        HRESULT ( STDMETHODCALLTYPE *GarbageCollectionStarted )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ int cGenerations,
+            /* [size_is][in] */ BOOL generationCollected[  ],
+            /* [in] */ COR_PRF_GC_REASON reason);
+        
+        HRESULT ( STDMETHODCALLTYPE *SurvivingReferences )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ ULONG cSurvivingObjectIDRanges,
+            /* [size_is][in] */ ObjectID objectIDRangeStart[  ],
+            /* [size_is][in] */ ULONG cObjectIDRangeLength[  ]);
+        
+        HRESULT ( STDMETHODCALLTYPE *GarbageCollectionFinished )( 
+            ICorProfilerCallback11 * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *FinalizeableObjectQueued )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ DWORD finalizerFlags,
+            /* [in] */ ObjectID objectID);
+        
+        HRESULT ( STDMETHODCALLTYPE *RootReferences2 )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ ULONG cRootRefs,
+            /* [size_is][in] */ ObjectID rootRefIds[  ],
+            /* [size_is][in] */ COR_PRF_GC_ROOT_KIND rootKinds[  ],
+            /* [size_is][in] */ COR_PRF_GC_ROOT_FLAGS rootFlags[  ],
+            /* [size_is][in] */ UINT_PTR rootIds[  ]);
+        
+        HRESULT ( STDMETHODCALLTYPE *HandleCreated )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ GCHandleID handleId,
+            /* [in] */ ObjectID initialObjectId);
+        
+        HRESULT ( STDMETHODCALLTYPE *HandleDestroyed )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ GCHandleID handleId);
+        
+        HRESULT ( STDMETHODCALLTYPE *InitializeForAttach )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ IUnknown *pCorProfilerInfoUnk,
+            /* [in] */ void *pvClientData,
+            /* [in] */ UINT cbClientData);
+        
+        HRESULT ( STDMETHODCALLTYPE *ProfilerAttachComplete )( 
+            ICorProfilerCallback11 * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *ProfilerDetachSucceeded )( 
+            ICorProfilerCallback11 * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *ReJITCompilationStarted )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ FunctionID functionId,
+            /* [in] */ ReJITID rejitId,
+            /* [in] */ BOOL fIsSafeToBlock);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetReJITParameters )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ ModuleID moduleId,
+            /* [in] */ mdMethodDef methodId,
+            /* [in] */ ICorProfilerFunctionControl *pFunctionControl);
+        
+        HRESULT ( STDMETHODCALLTYPE *ReJITCompilationFinished )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ FunctionID functionId,
+            /* [in] */ ReJITID rejitId,
+            /* [in] */ HRESULT hrStatus,
+            /* [in] */ BOOL fIsSafeToBlock);
+        
+        HRESULT ( STDMETHODCALLTYPE *ReJITError )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ ModuleID moduleId,
+            /* [in] */ mdMethodDef methodId,
+            /* [in] */ FunctionID functionId,
+            /* [in] */ HRESULT hrStatus);
+        
+        HRESULT ( STDMETHODCALLTYPE *MovedReferences2 )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ ULONG cMovedObjectIDRanges,
+            /* [size_is][in] */ ObjectID oldObjectIDRangeStart[  ],
+            /* [size_is][in] */ ObjectID newObjectIDRangeStart[  ],
+            /* [size_is][in] */ SIZE_T cObjectIDRangeLength[  ]);
+        
+        HRESULT ( STDMETHODCALLTYPE *SurvivingReferences2 )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ ULONG cSurvivingObjectIDRanges,
+            /* [size_is][in] */ ObjectID objectIDRangeStart[  ],
+            /* [size_is][in] */ SIZE_T cObjectIDRangeLength[  ]);
+        
+        HRESULT ( STDMETHODCALLTYPE *ConditionalWeakTableElementReferences )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ ULONG cRootRefs,
+            /* [size_is][in] */ ObjectID keyRefIds[  ],
+            /* [size_is][in] */ ObjectID valueRefIds[  ],
+            /* [size_is][in] */ GCHandleID rootIds[  ]);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetAssemblyReferences )( 
+            ICorProfilerCallback11 * This,
+            /* [string][in] */ const WCHAR *wszAssemblyPath,
+            /* [in] */ ICorProfilerAssemblyReferenceProvider *pAsmRefProvider);
+        
+        HRESULT ( STDMETHODCALLTYPE *ModuleInMemorySymbolsUpdated )( 
+            ICorProfilerCallback11 * This,
+            ModuleID moduleId);
+        
+        HRESULT ( STDMETHODCALLTYPE *DynamicMethodJITCompilationStarted )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ FunctionID functionId,
+            /* [in] */ BOOL fIsSafeToBlock,
+            /* [in] */ LPCBYTE pILHeader,
+            /* [in] */ ULONG cbILHeader);
+        
+        HRESULT ( STDMETHODCALLTYPE *DynamicMethodJITCompilationFinished )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ FunctionID functionId,
+            /* [in] */ HRESULT hrStatus,
+            /* [in] */ BOOL fIsSafeToBlock);
+        
+        HRESULT ( STDMETHODCALLTYPE *DynamicMethodUnloaded )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ FunctionID functionId);
+        
+        HRESULT ( STDMETHODCALLTYPE *EventPipeEventDelivered )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ EVENTPIPE_PROVIDER provider,
+            /* [in] */ DWORD eventId,
+            /* [in] */ DWORD eventVersion,
+            /* [in] */ ULONG cbMetadataBlob,
+            /* [size_is][in] */ LPCBYTE metadataBlob,
+            /* [in] */ ULONG cbEventData,
+            /* [size_is][in] */ LPCBYTE eventData,
+            /* [in] */ LPCGUID pActivityId,
+            /* [in] */ LPCGUID pRelatedActivityId,
+            /* [in] */ ThreadID eventThread,
+            /* [in] */ ULONG numStackFrames,
+            /* [length_is][in] */ UINT_PTR stackFrames[  ]);
+        
+        HRESULT ( STDMETHODCALLTYPE *EventPipeProviderCreated )( 
+            ICorProfilerCallback11 * This,
+            /* [in] */ EVENTPIPE_PROVIDER provider);
+        
+        HRESULT ( STDMETHODCALLTYPE *LoadAsNotficationOnly )( 
+            ICorProfilerCallback11 * This,
+            BOOL *pbNotificationOnly);
+        
+        END_INTERFACE
+    } ICorProfilerCallback11Vtbl;
+
+    interface ICorProfilerCallback11
+    {
+        CONST_VTBL struct ICorProfilerCallback11Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ICorProfilerCallback11_QueryInterface(This,riid,ppvObject)  \
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ICorProfilerCallback11_AddRef(This) \
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ICorProfilerCallback11_Release(This)    \
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ICorProfilerCallback11_Initialize(This,pICorProfilerInfoUnk)    \
+    ( (This)->lpVtbl -> Initialize(This,pICorProfilerInfoUnk) ) 
+
+#define ICorProfilerCallback11_Shutdown(This)   \
+    ( (This)->lpVtbl -> Shutdown(This) ) 
+
+#define ICorProfilerCallback11_AppDomainCreationStarted(This,appDomainId)   \
+    ( (This)->lpVtbl -> AppDomainCreationStarted(This,appDomainId) ) 
+
+#define ICorProfilerCallback11_AppDomainCreationFinished(This,appDomainId,hrStatus) \
+    ( (This)->lpVtbl -> AppDomainCreationFinished(This,appDomainId,hrStatus) ) 
+
+#define ICorProfilerCallback11_AppDomainShutdownStarted(This,appDomainId)   \
+    ( (This)->lpVtbl -> AppDomainShutdownStarted(This,appDomainId) ) 
+
+#define ICorProfilerCallback11_AppDomainShutdownFinished(This,appDomainId,hrStatus) \
+    ( (This)->lpVtbl -> AppDomainShutdownFinished(This,appDomainId,hrStatus) ) 
+
+#define ICorProfilerCallback11_AssemblyLoadStarted(This,assemblyId) \
+    ( (This)->lpVtbl -> AssemblyLoadStarted(This,assemblyId) ) 
+
+#define ICorProfilerCallback11_AssemblyLoadFinished(This,assemblyId,hrStatus)   \
+    ( (This)->lpVtbl -> AssemblyLoadFinished(This,assemblyId,hrStatus) ) 
+
+#define ICorProfilerCallback11_AssemblyUnloadStarted(This,assemblyId)   \
+    ( (This)->lpVtbl -> AssemblyUnloadStarted(This,assemblyId) ) 
+
+#define ICorProfilerCallback11_AssemblyUnloadFinished(This,assemblyId,hrStatus) \
+    ( (This)->lpVtbl -> AssemblyUnloadFinished(This,assemblyId,hrStatus) ) 
+
+#define ICorProfilerCallback11_ModuleLoadStarted(This,moduleId) \
+    ( (This)->lpVtbl -> ModuleLoadStarted(This,moduleId) ) 
+
+#define ICorProfilerCallback11_ModuleLoadFinished(This,moduleId,hrStatus)   \
+    ( (This)->lpVtbl -> ModuleLoadFinished(This,moduleId,hrStatus) ) 
+
+#define ICorProfilerCallback11_ModuleUnloadStarted(This,moduleId)   \
+    ( (This)->lpVtbl -> ModuleUnloadStarted(This,moduleId) ) 
+
+#define ICorProfilerCallback11_ModuleUnloadFinished(This,moduleId,hrStatus) \
+    ( (This)->lpVtbl -> ModuleUnloadFinished(This,moduleId,hrStatus) ) 
+
+#define ICorProfilerCallback11_ModuleAttachedToAssembly(This,moduleId,AssemblyId)   \
+    ( (This)->lpVtbl -> ModuleAttachedToAssembly(This,moduleId,AssemblyId) ) 
+
+#define ICorProfilerCallback11_ClassLoadStarted(This,classId)   \
+    ( (This)->lpVtbl -> ClassLoadStarted(This,classId) ) 
+
+#define ICorProfilerCallback11_ClassLoadFinished(This,classId,hrStatus) \
+    ( (This)->lpVtbl -> ClassLoadFinished(This,classId,hrStatus) ) 
+
+#define ICorProfilerCallback11_ClassUnloadStarted(This,classId) \
+    ( (This)->lpVtbl -> ClassUnloadStarted(This,classId) ) 
+
+#define ICorProfilerCallback11_ClassUnloadFinished(This,classId,hrStatus)   \
+    ( (This)->lpVtbl -> ClassUnloadFinished(This,classId,hrStatus) ) 
+
+#define ICorProfilerCallback11_FunctionUnloadStarted(This,functionId)   \
+    ( (This)->lpVtbl -> FunctionUnloadStarted(This,functionId) ) 
+
+#define ICorProfilerCallback11_JITCompilationStarted(This,functionId,fIsSafeToBlock)    \
+    ( (This)->lpVtbl -> JITCompilationStarted(This,functionId,fIsSafeToBlock) ) 
+
+#define ICorProfilerCallback11_JITCompilationFinished(This,functionId,hrStatus,fIsSafeToBlock)  \
+    ( (This)->lpVtbl -> JITCompilationFinished(This,functionId,hrStatus,fIsSafeToBlock) ) 
+
+#define ICorProfilerCallback11_JITCachedFunctionSearchStarted(This,functionId,pbUseCachedFunction)  \
+    ( (This)->lpVtbl -> JITCachedFunctionSearchStarted(This,functionId,pbUseCachedFunction) ) 
+
+#define ICorProfilerCallback11_JITCachedFunctionSearchFinished(This,functionId,result)  \
+    ( (This)->lpVtbl -> JITCachedFunctionSearchFinished(This,functionId,result) ) 
+
+#define ICorProfilerCallback11_JITFunctionPitched(This,functionId)  \
+    ( (This)->lpVtbl -> JITFunctionPitched(This,functionId) ) 
+
+#define ICorProfilerCallback11_JITInlining(This,callerId,calleeId,pfShouldInline)   \
+    ( (This)->lpVtbl -> JITInlining(This,callerId,calleeId,pfShouldInline) ) 
+
+#define ICorProfilerCallback11_ThreadCreated(This,threadId) \
+    ( (This)->lpVtbl -> ThreadCreated(This,threadId) ) 
+
+#define ICorProfilerCallback11_ThreadDestroyed(This,threadId)   \
+    ( (This)->lpVtbl -> ThreadDestroyed(This,threadId) ) 
+
+#define ICorProfilerCallback11_ThreadAssignedToOSThread(This,managedThreadId,osThreadId)    \
+    ( (This)->lpVtbl -> ThreadAssignedToOSThread(This,managedThreadId,osThreadId) ) 
+
+#define ICorProfilerCallback11_RemotingClientInvocationStarted(This)    \
+    ( (This)->lpVtbl -> RemotingClientInvocationStarted(This) ) 
+
+#define ICorProfilerCallback11_RemotingClientSendingMessage(This,pCookie,fIsAsync)  \
+    ( (This)->lpVtbl -> RemotingClientSendingMessage(This,pCookie,fIsAsync) ) 
+
+#define ICorProfilerCallback11_RemotingClientReceivingReply(This,pCookie,fIsAsync)  \
+    ( (This)->lpVtbl -> RemotingClientReceivingReply(This,pCookie,fIsAsync) ) 
+
+#define ICorProfilerCallback11_RemotingClientInvocationFinished(This)   \
+    ( (This)->lpVtbl -> RemotingClientInvocationFinished(This) ) 
+
+#define ICorProfilerCallback11_RemotingServerReceivingMessage(This,pCookie,fIsAsync)    \
+    ( (This)->lpVtbl -> RemotingServerReceivingMessage(This,pCookie,fIsAsync) ) 
+
+#define ICorProfilerCallback11_RemotingServerInvocationStarted(This)    \
+    ( (This)->lpVtbl -> RemotingServerInvocationStarted(This) ) 
+
+#define ICorProfilerCallback11_RemotingServerInvocationReturned(This)   \
+    ( (This)->lpVtbl -> RemotingServerInvocationReturned(This) ) 
+
+#define ICorProfilerCallback11_RemotingServerSendingReply(This,pCookie,fIsAsync)    \
+    ( (This)->lpVtbl -> RemotingServerSendingReply(This,pCookie,fIsAsync) ) 
+
+#define ICorProfilerCallback11_UnmanagedToManagedTransition(This,functionId,reason) \
+    ( (This)->lpVtbl -> UnmanagedToManagedTransition(This,functionId,reason) ) 
+
+#define ICorProfilerCallback11_ManagedToUnmanagedTransition(This,functionId,reason) \
+    ( (This)->lpVtbl -> ManagedToUnmanagedTransition(This,functionId,reason) ) 
+
+#define ICorProfilerCallback11_RuntimeSuspendStarted(This,suspendReason)    \
+    ( (This)->lpVtbl -> RuntimeSuspendStarted(This,suspendReason) ) 
+
+#define ICorProfilerCallback11_RuntimeSuspendFinished(This) \
+    ( (This)->lpVtbl -> RuntimeSuspendFinished(This) ) 
+
+#define ICorProfilerCallback11_RuntimeSuspendAborted(This)  \
+    ( (This)->lpVtbl -> RuntimeSuspendAborted(This) ) 
+
+#define ICorProfilerCallback11_RuntimeResumeStarted(This)   \
+    ( (This)->lpVtbl -> RuntimeResumeStarted(This) ) 
+
+#define ICorProfilerCallback11_RuntimeResumeFinished(This)  \
+    ( (This)->lpVtbl -> RuntimeResumeFinished(This) ) 
+
+#define ICorProfilerCallback11_RuntimeThreadSuspended(This,threadId)    \
+    ( (This)->lpVtbl -> RuntimeThreadSuspended(This,threadId) ) 
+
+#define ICorProfilerCallback11_RuntimeThreadResumed(This,threadId)  \
+    ( (This)->lpVtbl -> RuntimeThreadResumed(This,threadId) ) 
+
+#define ICorProfilerCallback11_MovedReferences(This,cMovedObjectIDRanges,oldObjectIDRangeStart,newObjectIDRangeStart,cObjectIDRangeLength)  \
+    ( (This)->lpVtbl -> MovedReferences(This,cMovedObjectIDRanges,oldObjectIDRangeStart,newObjectIDRangeStart,cObjectIDRangeLength) ) 
+
+#define ICorProfilerCallback11_ObjectAllocated(This,objectId,classId)   \
+    ( (This)->lpVtbl -> ObjectAllocated(This,objectId,classId) ) 
+
+#define ICorProfilerCallback11_ObjectsAllocatedByClass(This,cClassCount,classIds,cObjects)  \
+    ( (This)->lpVtbl -> ObjectsAllocatedByClass(This,cClassCount,classIds,cObjects) ) 
+
+#define ICorProfilerCallback11_ObjectReferences(This,objectId,classId,cObjectRefs,objectRefIds) \
+    ( (This)->lpVtbl -> ObjectReferences(This,objectId,classId,cObjectRefs,objectRefIds) ) 
+
+#define ICorProfilerCallback11_RootReferences(This,cRootRefs,rootRefIds)    \
+    ( (This)->lpVtbl -> RootReferences(This,cRootRefs,rootRefIds) ) 
+
+#define ICorProfilerCallback11_ExceptionThrown(This,thrownObjectId) \
+    ( (This)->lpVtbl -> ExceptionThrown(This,thrownObjectId) ) 
+
+#define ICorProfilerCallback11_ExceptionSearchFunctionEnter(This,functionId)    \
+    ( (This)->lpVtbl -> ExceptionSearchFunctionEnter(This,functionId) ) 
+
+#define ICorProfilerCallback11_ExceptionSearchFunctionLeave(This)   \
+    ( (This)->lpVtbl -> ExceptionSearchFunctionLeave(This) ) 
+
+#define ICorProfilerCallback11_ExceptionSearchFilterEnter(This,functionId)  \
+    ( (This)->lpVtbl -> ExceptionSearchFilterEnter(This,functionId) ) 
+
+#define ICorProfilerCallback11_ExceptionSearchFilterLeave(This) \
+    ( (This)->lpVtbl -> ExceptionSearchFilterLeave(This) ) 
+
+#define ICorProfilerCallback11_ExceptionSearchCatcherFound(This,functionId) \
+    ( (This)->lpVtbl -> ExceptionSearchCatcherFound(This,functionId) ) 
+
+#define ICorProfilerCallback11_ExceptionOSHandlerEnter(This,__unused)   \
+    ( (This)->lpVtbl -> ExceptionOSHandlerEnter(This,__unused) ) 
+
+#define ICorProfilerCallback11_ExceptionOSHandlerLeave(This,__unused)   \
+    ( (This)->lpVtbl -> ExceptionOSHandlerLeave(This,__unused) ) 
+
+#define ICorProfilerCallback11_ExceptionUnwindFunctionEnter(This,functionId)    \
+    ( (This)->lpVtbl -> ExceptionUnwindFunctionEnter(This,functionId) ) 
+
+#define ICorProfilerCallback11_ExceptionUnwindFunctionLeave(This)   \
+    ( (This)->lpVtbl -> ExceptionUnwindFunctionLeave(This) ) 
+
+#define ICorProfilerCallback11_ExceptionUnwindFinallyEnter(This,functionId) \
+    ( (This)->lpVtbl -> ExceptionUnwindFinallyEnter(This,functionId) ) 
+
+#define ICorProfilerCallback11_ExceptionUnwindFinallyLeave(This)    \
+    ( (This)->lpVtbl -> ExceptionUnwindFinallyLeave(This) ) 
+
+#define ICorProfilerCallback11_ExceptionCatcherEnter(This,functionId,objectId)  \
+    ( (This)->lpVtbl -> ExceptionCatcherEnter(This,functionId,objectId) ) 
+
+#define ICorProfilerCallback11_ExceptionCatcherLeave(This)  \
+    ( (This)->lpVtbl -> ExceptionCatcherLeave(This) ) 
+
+#define ICorProfilerCallback11_COMClassicVTableCreated(This,wrappedClassId,implementedIID,pVTable,cSlots)   \
+    ( (This)->lpVtbl -> COMClassicVTableCreated(This,wrappedClassId,implementedIID,pVTable,cSlots) ) 
+
+#define ICorProfilerCallback11_COMClassicVTableDestroyed(This,wrappedClassId,implementedIID,pVTable)    \
+    ( (This)->lpVtbl -> COMClassicVTableDestroyed(This,wrappedClassId,implementedIID,pVTable) ) 
+
+#define ICorProfilerCallback11_ExceptionCLRCatcherFound(This)   \
+    ( (This)->lpVtbl -> ExceptionCLRCatcherFound(This) ) 
+
+#define ICorProfilerCallback11_ExceptionCLRCatcherExecute(This) \
+    ( (This)->lpVtbl -> ExceptionCLRCatcherExecute(This) ) 
+
+
+#define ICorProfilerCallback11_ThreadNameChanged(This,threadId,cchName,name)    \
+    ( (This)->lpVtbl -> ThreadNameChanged(This,threadId,cchName,name) ) 
+
+#define ICorProfilerCallback11_GarbageCollectionStarted(This,cGenerations,generationCollected,reason)   \
+    ( (This)->lpVtbl -> GarbageCollectionStarted(This,cGenerations,generationCollected,reason) ) 
+
+#define ICorProfilerCallback11_SurvivingReferences(This,cSurvivingObjectIDRanges,objectIDRangeStart,cObjectIDRangeLength)   \
+    ( (This)->lpVtbl -> SurvivingReferences(This,cSurvivingObjectIDRanges,objectIDRangeStart,cObjectIDRangeLength) ) 
+
+#define ICorProfilerCallback11_GarbageCollectionFinished(This)  \
+    ( (This)->lpVtbl -> GarbageCollectionFinished(This) ) 
+
+#define ICorProfilerCallback11_FinalizeableObjectQueued(This,finalizerFlags,objectID)   \
+    ( (This)->lpVtbl -> FinalizeableObjectQueued(This,finalizerFlags,objectID) ) 
+
+#define ICorProfilerCallback11_RootReferences2(This,cRootRefs,rootRefIds,rootKinds,rootFlags,rootIds)   \
+    ( (This)->lpVtbl -> RootReferences2(This,cRootRefs,rootRefIds,rootKinds,rootFlags,rootIds) ) 
+
+#define ICorProfilerCallback11_HandleCreated(This,handleId,initialObjectId) \
+    ( (This)->lpVtbl -> HandleCreated(This,handleId,initialObjectId) ) 
+
+#define ICorProfilerCallback11_HandleDestroyed(This,handleId)   \
+    ( (This)->lpVtbl -> HandleDestroyed(This,handleId) ) 
+
+
+#define ICorProfilerCallback11_InitializeForAttach(This,pCorProfilerInfoUnk,pvClientData,cbClientData)  \
+    ( (This)->lpVtbl -> InitializeForAttach(This,pCorProfilerInfoUnk,pvClientData,cbClientData) ) 
+
+#define ICorProfilerCallback11_ProfilerAttachComplete(This) \
+    ( (This)->lpVtbl -> ProfilerAttachComplete(This) ) 
+
+#define ICorProfilerCallback11_ProfilerDetachSucceeded(This)    \
+    ( (This)->lpVtbl -> ProfilerDetachSucceeded(This) ) 
+
+
+#define ICorProfilerCallback11_ReJITCompilationStarted(This,functionId,rejitId,fIsSafeToBlock)  \
+    ( (This)->lpVtbl -> ReJITCompilationStarted(This,functionId,rejitId,fIsSafeToBlock) ) 
+
+#define ICorProfilerCallback11_GetReJITParameters(This,moduleId,methodId,pFunctionControl)  \
+    ( (This)->lpVtbl -> GetReJITParameters(This,moduleId,methodId,pFunctionControl) ) 
+
+#define ICorProfilerCallback11_ReJITCompilationFinished(This,functionId,rejitId,hrStatus,fIsSafeToBlock)    \
+    ( (This)->lpVtbl -> ReJITCompilationFinished(This,functionId,rejitId,hrStatus,fIsSafeToBlock) ) 
+
+#define ICorProfilerCallback11_ReJITError(This,moduleId,methodId,functionId,hrStatus)   \
+    ( (This)->lpVtbl -> ReJITError(This,moduleId,methodId,functionId,hrStatus) ) 
+
+#define ICorProfilerCallback11_MovedReferences2(This,cMovedObjectIDRanges,oldObjectIDRangeStart,newObjectIDRangeStart,cObjectIDRangeLength) \
+    ( (This)->lpVtbl -> MovedReferences2(This,cMovedObjectIDRanges,oldObjectIDRangeStart,newObjectIDRangeStart,cObjectIDRangeLength) ) 
+
+#define ICorProfilerCallback11_SurvivingReferences2(This,cSurvivingObjectIDRanges,objectIDRangeStart,cObjectIDRangeLength)  \
+    ( (This)->lpVtbl -> SurvivingReferences2(This,cSurvivingObjectIDRanges,objectIDRangeStart,cObjectIDRangeLength) ) 
+
+
+#define ICorProfilerCallback11_ConditionalWeakTableElementReferences(This,cRootRefs,keyRefIds,valueRefIds,rootIds)  \
+    ( (This)->lpVtbl -> ConditionalWeakTableElementReferences(This,cRootRefs,keyRefIds,valueRefIds,rootIds) ) 
+
+
+#define ICorProfilerCallback11_GetAssemblyReferences(This,wszAssemblyPath,pAsmRefProvider)  \
+    ( (This)->lpVtbl -> GetAssemblyReferences(This,wszAssemblyPath,pAsmRefProvider) ) 
+
+
+#define ICorProfilerCallback11_ModuleInMemorySymbolsUpdated(This,moduleId)  \
+    ( (This)->lpVtbl -> ModuleInMemorySymbolsUpdated(This,moduleId) ) 
+
+
+#define ICorProfilerCallback11_DynamicMethodJITCompilationStarted(This,functionId,fIsSafeToBlock,pILHeader,cbILHeader)  \
+    ( (This)->lpVtbl -> DynamicMethodJITCompilationStarted(This,functionId,fIsSafeToBlock,pILHeader,cbILHeader) ) 
+
+#define ICorProfilerCallback11_DynamicMethodJITCompilationFinished(This,functionId,hrStatus,fIsSafeToBlock) \
+    ( (This)->lpVtbl -> DynamicMethodJITCompilationFinished(This,functionId,hrStatus,fIsSafeToBlock) ) 
+
+
+#define ICorProfilerCallback11_DynamicMethodUnloaded(This,functionId)   \
+    ( (This)->lpVtbl -> DynamicMethodUnloaded(This,functionId) ) 
+
+
+#define ICorProfilerCallback11_EventPipeEventDelivered(This,provider,eventId,eventVersion,cbMetadataBlob,metadataBlob,cbEventData,eventData,pActivityId,pRelatedActivityId,eventThread,numStackFrames,stackFrames)  \
+    ( (This)->lpVtbl -> EventPipeEventDelivered(This,provider,eventId,eventVersion,cbMetadataBlob,metadataBlob,cbEventData,eventData,pActivityId,pRelatedActivityId,eventThread,numStackFrames,stackFrames) ) 
+
+#define ICorProfilerCallback11_EventPipeProviderCreated(This,provider)  \
+    ( (This)->lpVtbl -> EventPipeProviderCreated(This,provider) ) 
+
+
+#define ICorProfilerCallback11_LoadAsNotficationOnly(This,pbNotificationOnly)   \
+    ( (This)->lpVtbl -> LoadAsNotficationOnly(This,pbNotificationOnly) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif  /* C style interface */
+
+
+
+
+#endif  /* __ICorProfilerCallback11_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_corprof_0000_0011 */
 /* [local] */ 
 
 typedef /* [public] */ 
-enum __MIDL___MIDL_itf_corprof_0000_0010_0001
+enum __MIDL___MIDL_itf_corprof_0000_0011_0001
     {
         COR_PRF_CODEGEN_DISABLE_INLINING    = 0x1,
         COR_PRF_CODEGEN_DISABLE_ALL_OPTIMIZATIONS   = 0x2
@@ -8363,8 +9188,8 @@ enum __MIDL___MIDL_itf_corprof_0000_0010_0001
 
 
 
-extern RPC_IF_HANDLE __MIDL_itf_corprof_0000_0010_v0_0_c_ifspec;
-extern RPC_IF_HANDLE __MIDL_itf_corprof_0000_0010_v0_0_s_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_corprof_0000_0011_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_corprof_0000_0011_v0_0_s_ifspec;
 
 #ifndef __ICorProfilerInfo_INTERFACE_DEFINED__
 #define __ICorProfilerInfo_INTERFACE_DEFINED__
diff --git a/src/coreclr/pal/src/CMakeLists.txt b/src/coreclr/pal/src/CMakeLists.txt
index 0c2021dab02d92..ba13ab392f0c53 100644
--- a/src/coreclr/pal/src/CMakeLists.txt
+++ b/src/coreclr/pal/src/CMakeLists.txt
@@ -49,6 +49,8 @@ elseif(CLR_CMAKE_HOST_ARCH_ARM64)
   set(PAL_ARCH_SOURCES_DIR arm64)
 elseif(CLR_CMAKE_HOST_ARCH_I386)
   set(PAL_ARCH_SOURCES_DIR i386)
+elseif(CLR_CMAKE_HOST_ARCH_S390X)
+  set(PAL_ARCH_SOURCES_DIR s390x)
 endif()
 
 if(CLR_CMAKE_USE_SYSTEM_LIBUNWIND)
@@ -112,7 +114,7 @@ if(CLR_CMAKE_HOST_ARCH_ARM)
   endif()
 endif(CLR_CMAKE_HOST_ARCH_ARM)
 
-if (CMAKE_CXX_COMPILER_ID MATCHES "GNU")
+if (CMAKE_CXX_COMPILER_ID MATCHES "GNU" AND (CLR_CMAKE_HOST_ARCH_AMD64 OR CLR_CMAKE_HOST_ARCH_I386))
   add_compile_options(-Wa,--divide)
 endif()
 
diff --git a/src/coreclr/pal/src/arch/s390x/asmconstants.h b/src/coreclr/pal/src/arch/s390x/asmconstants.h
new file mode 100644
index 00000000000000..e0079dc6ef38fd
--- /dev/null
+++ b/src/coreclr/pal/src/arch/s390x/asmconstants.h
@@ -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.
+
+#ifndef __PAL_S390X_ASMCONSTANTS_H__
+#define __PAL_S390X_ASMCONSTANTS_H__
+
+#define CONTEXT_S390X   0x100000
+
+#define CONTEXT_CONTROL 1 // PSW and R15
+#define CONTEXT_INTEGER 2 // R0-R14
+#define CONTEXT_FLOATING_POINT 4 // F0-F15
+
+#define CONTEXT_FULL (CONTEXT_CONTROL | CONTEXT_INTEGER | CONTEXT_FLOATING_POINT)
+
+#define CONTEXT_ContextFlags  0
+#define CONTEXT_R0            CONTEXT_ContextFlags+8
+#define CONTEXT_R1            CONTEXT_R0+8
+#define CONTEXT_R2            CONTEXT_R1+8
+#define CONTEXT_R3            CONTEXT_R2+8
+#define CONTEXT_R4            CONTEXT_R3+8
+#define CONTEXT_R5            CONTEXT_R4+8
+#define CONTEXT_R6            CONTEXT_R5+8
+#define CONTEXT_R7            CONTEXT_R6+8
+#define CONTEXT_R8            CONTEXT_R7+8
+#define CONTEXT_R9            CONTEXT_R8+8
+#define CONTEXT_R10           CONTEXT_R9+8
+#define CONTEXT_R11           CONTEXT_R10+8
+#define CONTEXT_R12           CONTEXT_R11+8
+#define CONTEXT_R13           CONTEXT_R12+8
+#define CONTEXT_R14           CONTEXT_R13+8
+#define CONTEXT_R15           CONTEXT_R14+8
+#define CONTEXT_F0            CONTEXT_R15+8
+#define CONTEXT_F1            CONTEXT_F0+8
+#define CONTEXT_F2            CONTEXT_F1+8
+#define CONTEXT_F3            CONTEXT_F2+8
+#define CONTEXT_F4            CONTEXT_F3+8
+#define CONTEXT_F5            CONTEXT_F4+8
+#define CONTEXT_F6            CONTEXT_F5+8
+#define CONTEXT_F7            CONTEXT_F6+8
+#define CONTEXT_F8            CONTEXT_F7+8
+#define CONTEXT_F9            CONTEXT_F8+8
+#define CONTEXT_F10           CONTEXT_F9+8
+#define CONTEXT_F11           CONTEXT_F10+8
+#define CONTEXT_F12           CONTEXT_F11+8
+#define CONTEXT_F13           CONTEXT_F12+8
+#define CONTEXT_F14           CONTEXT_F13+8
+#define CONTEXT_F15           CONTEXT_F14+8
+#define CONTEXT_PSWMask       CONTEXT_F15+8
+#define CONTEXT_PSWAddr       CONTEXT_PSWMask+8
+#define CONTEXT_Size          CONTEXT_PSWAddr+8
+
+#endif
diff --git a/src/coreclr/pal/src/arch/s390x/callsignalhandlerwrapper.S b/src/coreclr/pal/src/arch/s390x/callsignalhandlerwrapper.S
new file mode 100644
index 00000000000000..a290f5a580c78d
--- /dev/null
+++ b/src/coreclr/pal/src/arch/s390x/callsignalhandlerwrapper.S
@@ -0,0 +1,34 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+#include "unixasmmacros.inc"
+#include "asmconstants.h"
+
+.macro CALL_SIGNAL_HANDLER_WRAPPER Alignment
+
+.globl C_FUNC(SignalHandlerWorkerReturnOffset\Alignment)
+C_FUNC(SignalHandlerWorkerReturnOffset\Alignment):
+    .int LOCAL_LABEL(SignalHandlerWorkerReturn\Alignment)-C_FUNC(CallSignalHandlerWrapper\Alignment)
+
+// This function is never called, only a fake stack frame will be setup to have a return
+// address set to SignalHandlerWorkerReturn during SIGSEGV handling.
+// It enables the unwinder to unwind stack from the handling code to the actual failure site.
+NESTED_ENTRY CallSignalHandlerWrapper\Alignment, _TEXT, NoHandler
+    .cfi_def_cfa 15, 160
+    stmg    %r14, %r15, 112(%r15)
+    .cfi_offset 14, -48
+    .cfi_offset 15, -40
+    aghi    %r15, -160
+    .cfi_def_cfa_offset 320
+    brasl   %r14,EXTERNAL_C_FUNC(signal_handler_worker)
+LOCAL_LABEL(SignalHandlerWorkerReturn\Alignment):
+    lmg     %r14, %r15, 272(%r11)
+    .cfi_restore 15
+    .cfi_restore 14
+    .cfi_def_cfa 15, 160
+    br      %r14
+NESTED_END CallSignalHandlerWrapper\Alignment, _TEXT
+
+.endm
+
+CALL_SIGNAL_HANDLER_WRAPPER 0
diff --git a/src/coreclr/pal/src/arch/s390x/context2.S b/src/coreclr/pal/src/arch/s390x/context2.S
new file mode 100644
index 00000000000000..a44d81c19a2ebf
--- /dev/null
+++ b/src/coreclr/pal/src/arch/s390x/context2.S
@@ -0,0 +1,101 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+// Implementation of _CONTEXT_CaptureContext for the IBM s390x platform.
+// This function is processor dependent.  It is used by exception handling,
+// and is always apply to the current thread.
+//
+
+#include "unixasmmacros.inc"
+#include "asmconstants.h"
+
+// Incoming:
+//  R2: Context*
+//
+LEAF_ENTRY CONTEXT_CaptureContext, _TEXT
+
+    tm      CONTEXT_ContextFlags+3(%r2), CONTEXT_INTEGER
+    je      LOCAL_LABEL(Done_CONTEXT_INTEGER)
+    stmg    %r0, %r14, CONTEXT_R0(%r2)
+LOCAL_LABEL(Done_CONTEXT_INTEGER):
+
+    tm      CONTEXT_ContextFlags+3(%r2), CONTEXT_CONTROL
+    je      LOCAL_LABEL(Done_CONTEXT_CONTROL)
+    // Set PSW address to return address from %r14
+    stg     %r14, CONTEXT_PSWAddr(%r2)
+    // Extract PSW mask (CC is already changed; we ignore this here)
+    epsw    %r0, %r1
+    stm     %r0, %r1, CONTEXT_PSWMask(%r2)
+    // Stack pointer is still unchanged
+    stg     %r15, CONTEXT_R15(%r2)
+LOCAL_LABEL(Done_CONTEXT_CONTROL):
+
+    tm      CONTEXT_ContextFlags+3(%r2), CONTEXT_FLOATING_POINT
+    je      LOCAL_LABEL(Done_CONTEXT_FLOATING_POINT)
+    std     %f0, CONTEXT_F0(%r2)
+    std     %f1, CONTEXT_F1(%r2)
+    std     %f2, CONTEXT_F2(%r2)
+    std     %f3, CONTEXT_F3(%r2)
+    std     %f4, CONTEXT_F4(%r2)
+    std     %f5, CONTEXT_F5(%r2)
+    std     %f6, CONTEXT_F6(%r2)
+    std     %f7, CONTEXT_F7(%r2)
+    std     %f8, CONTEXT_F8(%r2)
+    std     %f9, CONTEXT_F9(%r2)
+    std     %f10, CONTEXT_F10(%r2)
+    std     %f11, CONTEXT_F11(%r2)
+    std     %f12, CONTEXT_F12(%r2)
+    std     %f13, CONTEXT_F13(%r2)
+    std     %f14, CONTEXT_F14(%r2)
+    std     %f15, CONTEXT_F15(%r2)
+LOCAL_LABEL(Done_CONTEXT_FLOATING_POINT):
+
+    br %r14
+LEAF_END CONTEXT_CaptureContext, _TEXT
+
+LEAF_ENTRY RtlCaptureContext, _TEXT
+    mvhhi    CONTEXT_ContextFlags+2(%r2), ((CONTEXT_S390X | CONTEXT_FULL) & 0xffff)
+    mvhhi    CONTEXT_ContextFlags(%r2), ((CONTEXT_S390X | CONTEXT_FULL) >> 16)
+    jg     C_FUNC(CONTEXT_CaptureContext)
+LEAF_END RtlCaptureContext, _TEXT
+
+LEAF_ENTRY RtlRestoreContext, _TEXT
+
+    lgr     %r1, %r14
+
+    tm      CONTEXT_ContextFlags+3(%r2), CONTEXT_FLOATING_POINT
+    je      LOCAL_LABEL(Done_Restore_CONTEXT_FLOATING_POINT)
+    ld      %f0, CONTEXT_F0(%r2)
+    ld      %f1, CONTEXT_F1(%r2)
+    ld      %f2, CONTEXT_F2(%r2)
+    ld      %f3, CONTEXT_F3(%r2)
+    ld      %f4, CONTEXT_F4(%r2)
+    ld      %f5, CONTEXT_F5(%r2)
+    ld      %f6, CONTEXT_F6(%r2)
+    ld      %f7, CONTEXT_F7(%r2)
+    ld      %f8, CONTEXT_F8(%r2)
+    ld      %f9, CONTEXT_F9(%r2)
+    ld      %f10, CONTEXT_F10(%r2)
+    ld      %f11, CONTEXT_F11(%r2)
+    ld      %f12, CONTEXT_F12(%r2)
+    ld      %f13, CONTEXT_F13(%r2)
+    ld      %f14, CONTEXT_F14(%r2)
+    ld      %f15, CONTEXT_F15(%r2)
+LOCAL_LABEL(Done_Restore_CONTEXT_FLOATING_POINT):
+
+    tm      CONTEXT_ContextFlags+3(%r2), CONTEXT_CONTROL
+    je      LOCAL_LABEL(Done_Restore_CONTEXT_CONTROL)
+    // We do *not* attempt to restore the PSW mask here!
+    lg      %r1, CONTEXT_PSWAddr(%r2)
+    lg      %r15, CONTEXT_R15(%r2)
+LOCAL_LABEL(Done_Restore_CONTEXT_CONTROL):
+
+    tm      CONTEXT_ContextFlags+3(%r2), CONTEXT_INTEGER
+    je      LOCAL_LABEL(Done_Restore_CONTEXT_INTEGER)
+    // We do *not* restore %r0 and %r1 here!
+    lmg     %r2, %r14, CONTEXT_R2(%r2)
+LOCAL_LABEL(Done_Restore_CONTEXT_INTEGER):
+
+    br %r1
+LEAF_END RtlRestoreContext, _TEXT
+
diff --git a/src/coreclr/pal/src/arch/s390x/debugbreak.S b/src/coreclr/pal/src/arch/s390x/debugbreak.S
new file mode 100644
index 00000000000000..3c38a09c257bf8
--- /dev/null
+++ b/src/coreclr/pal/src/arch/s390x/debugbreak.S
@@ -0,0 +1,10 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+#include "unixasmmacros.inc"
+
+LEAF_ENTRY DBG_DebugBreak, _TEXT
+        .word 0x0001
+        br %r14
+LEAF_END_MARKED DBG_DebugBreak, _TEXT
+
diff --git a/src/coreclr/pal/src/arch/s390x/exceptionhelper.S b/src/coreclr/pal/src/arch/s390x/exceptionhelper.S
new file mode 100644
index 00000000000000..321612746ce755
--- /dev/null
+++ b/src/coreclr/pal/src/arch/s390x/exceptionhelper.S
@@ -0,0 +1,55 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+#include "unixasmmacros.inc"
+#include "asmconstants.h"
+
+//////////////////////////////////////////////////////////////////////////
+//
+// This function creates a stack frame right below the target frame, restores all callee
+// saved registers from the passed in context, sets R15 to that frame and sets the
+// return address to the target frame's PSW address.
+// Then it uses the ThrowExceptionHelper to throw the passed in exception from that context.
+// EXTERN_C void ThrowExceptionFromContextInternal(CONTEXT* context, PAL_SEHException* ex);
+LEAF_ENTRY ThrowExceptionFromContextInternal, _TEXT
+        // Save callee-saved registers to the stack so that unwinding can work at
+        // any intermediate step while loading up target registers.
+        stmg    %r6, %r15, 48(%r15)
+        .cfi_offset 6, -112
+        .cfi_offset 7, -104
+        .cfi_offset 8, -96
+        .cfi_offset 9, -88
+        .cfi_offset 10, -80
+        .cfi_offset 11, -72
+        .cfi_offset 12, -64
+        .cfi_offset 13, -56
+        .cfi_offset 14, -48
+        .cfi_offset 15, -40
+
+        lg      %r6, CONTEXT_R6(%r2)
+        lg      %r7, CONTEXT_R7(%r2)
+        lg      %r8, CONTEXT_R8(%r2)
+        lg      %r9, CONTEXT_R9(%r2)
+        lg      %r10, CONTEXT_R10(%r2)
+        lg      %r11, CONTEXT_R11(%r2)
+        lg      %r12, CONTEXT_R12(%r2)
+        lg      %r13, CONTEXT_R13(%r2)
+        lg      %r14, CONTEXT_PSWAddr(%r2)
+        lg      %r15, CONTEXT_R15(%r2)
+        // After changing %r15, unwinding no longer finds the registers
+        // saved above.  Switch to the target frame at this point.
+        .cfi_restore 6
+        .cfi_restore 7
+        .cfi_restore 8
+        .cfi_restore 9
+        .cfi_restore 10
+        .cfi_restore 11
+        .cfi_restore 12
+        .cfi_restore 13
+        .cfi_restore 14
+        .cfi_restore 15
+
+        // The PAL_SEHException pointer
+        lgr    %r2, %r3
+        jg     EXTERNAL_C_FUNC(ThrowExceptionHelper)
+LEAF_END ThrowExceptionFromContextInternal, _TEXT
diff --git a/src/coreclr/pal/src/arch/s390x/processor.cpp b/src/coreclr/pal/src/arch/s390x/processor.cpp
new file mode 100644
index 00000000000000..d2d0fdd5e8f083
--- /dev/null
+++ b/src/coreclr/pal/src/arch/s390x/processor.cpp
@@ -0,0 +1,22 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+/*++
+
+
+
+Module Name:
+
+    processor.cpp
+
+Abstract:
+
+    Implementation of processor related functions for the IBM s390x
+    platforms. These functions are processor dependent.
+
+
+
+--*/
+
+#include "pal/palinternal.h"
+
diff --git a/src/coreclr/pal/src/arch/s390x/signalhandlerhelper.cpp b/src/coreclr/pal/src/arch/s390x/signalhandlerhelper.cpp
new file mode 100644
index 00000000000000..5e2e7219a84ba8
--- /dev/null
+++ b/src/coreclr/pal/src/arch/s390x/signalhandlerhelper.cpp
@@ -0,0 +1,69 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+#include "pal/dbgmsg.h"
+SET_DEFAULT_DEBUG_CHANNEL(EXCEPT); // some headers have code with asserts, so do this first
+
+#include "pal/palinternal.h"
+#include "pal/context.h"
+#include "pal/signal.hpp"
+#include "pal/utils.h"
+#include <sys/ucontext.h>
+
+/*++
+Function :
+    ExecuteHandlerOnCustomStack
+
+    Execute signal handler on a custom stack, the current stack pointer is specified by the customSp
+    If the customSp is 0, then the handler is executed on the original stack where the signal was fired.
+    It installs a fake stack frame to enable stack unwinding to the signal source location.
+
+Parameters :
+    POSIX signal handler parameter list ("man sigaction" for details)
+    returnPoint - context to which the function returns if the common_signal_handler returns
+
+    (no return value)
+--*/
+void ExecuteHandlerOnCustomStack(int code, siginfo_t *siginfo, void *context, size_t customSp, SignalHandlerWorkerReturnPoint* returnPoint)
+{
+    ucontext_t *ucontext = (ucontext_t *)context;
+    size_t faultSp = (size_t)MCREG_R15(ucontext->uc_mcontext);
+
+    _ASSERTE(IS_ALIGNED(faultSp, 8));
+
+    if (customSp == 0)
+    {
+        customSp = faultSp;
+    }
+
+    size_t fakeFrameReturnAddress;
+    fakeFrameReturnAddress = (size_t)SignalHandlerWorkerReturnOffset0 + (size_t)CallSignalHandlerWrapper0;
+
+    // Build fake stack frame to enable the stack unwinder to unwind from signal_handler_worker to the faulting instruction
+    size_t* saveArea = (size_t*)(customSp - 160);
+    saveArea[14] = (size_t)MCREG_PSWAddr(ucontext->uc_mcontext);
+    saveArea[15] = faultSp;
+    size_t sp = (size_t)saveArea - 160;
+
+    // Switch the current context to the signal_handler_worker and the custom stack
+    CONTEXT context2;
+    RtlCaptureContext(&context2);
+
+    context2.PSWAddr = (size_t)signal_handler_worker;
+    context2.R2 = code;
+    context2.R3 = (size_t)siginfo;
+    context2.R4 = (size_t)context;
+    context2.R5 = (size_t)returnPoint;
+    context2.R6 = (size_t)MCREG_R6(ucontext->uc_mcontext);
+    context2.R7 = (size_t)MCREG_R7(ucontext->uc_mcontext);
+    context2.R8 = (size_t)MCREG_R8(ucontext->uc_mcontext);
+    context2.R9 = (size_t)MCREG_R9(ucontext->uc_mcontext);
+    context2.R10 = (size_t)MCREG_R10(ucontext->uc_mcontext);
+    context2.R11 = (size_t)MCREG_R11(ucontext->uc_mcontext);
+    context2.R12 = (size_t)MCREG_R12(ucontext->uc_mcontext);
+    context2.R13 = (size_t)MCREG_R13(ucontext->uc_mcontext);
+    context2.R14 = fakeFrameReturnAddress;
+    context2.R15 = sp;
+
+    RtlRestoreContext(&context2, NULL);
+}
diff --git a/src/coreclr/pal/src/exception/remote-unwind.cpp b/src/coreclr/pal/src/exception/remote-unwind.cpp
index 2d00f09377a7a2..b82960cc723721 100644
--- a/src/coreclr/pal/src/exception/remote-unwind.cpp
+++ b/src/coreclr/pal/src/exception/remote-unwind.cpp
@@ -123,7 +123,7 @@ typedef BOOL(*UnwindReadMemoryCallback)(PVOID address, PVOID buffer, SIZE_T size
 #define PRId PRId32
 #define PRIA "08"
 #define PRIxA PRIA PRIx
-#elif defined(TARGET_AMD64) || defined(TARGET_ARM64)
+#elif defined(TARGET_AMD64) || defined(TARGET_ARM64) || defined(TARGET_S390X)
 #define PRIx PRIx64
 #define PRIu PRIu64
 #define PRId PRId64
@@ -1606,6 +1606,17 @@ static void GetContextPointers(unw_cursor_t *cursor, unw_context_t *unwContext,
     GetContextPointer(cursor, unwContext, UNW_AARCH64_X27, &contextPointers->X27);
     GetContextPointer(cursor, unwContext, UNW_AARCH64_X28, &contextPointers->X28);
     GetContextPointer(cursor, unwContext, UNW_AARCH64_X29, &contextPointers->Fp);
+#elif defined(TARGET_S390X)
+    GetContextPointer(cursor, unwContext, UNW_S390X_R6, &contextPointers->R6);
+    GetContextPointer(cursor, unwContext, UNW_S390X_R7, &contextPointers->R7);
+    GetContextPointer(cursor, unwContext, UNW_S390X_R8, &contextPointers->R8);
+    GetContextPointer(cursor, unwContext, UNW_S390X_R9, &contextPointers->R9);
+    GetContextPointer(cursor, unwContext, UNW_S390X_R10, &contextPointers->R10);
+    GetContextPointer(cursor, unwContext, UNW_S390X_R11, &contextPointers->R11);
+    GetContextPointer(cursor, unwContext, UNW_S390X_R12, &contextPointers->R12);
+    GetContextPointer(cursor, unwContext, UNW_S390X_R13, &contextPointers->R13);
+    GetContextPointer(cursor, unwContext, UNW_S390X_R14, &contextPointers->R14);
+    GetContextPointer(cursor, unwContext, UNW_S390X_R15, &contextPointers->R15);
 #else
 #error unsupported architecture
 #endif
@@ -1658,6 +1669,19 @@ static void UnwindContextToContext(unw_cursor_t *cursor, CONTEXT *winContext)
     unw_get_reg(cursor, UNW_AARCH64_X29, (unw_word_t *) &winContext->Fp);
     unw_get_reg(cursor, UNW_AARCH64_X30, (unw_word_t *) &winContext->Lr);
     TRACE("sp %p pc %p lr %p fp %p\n", winContext->Sp, winContext->Pc, winContext->Lr, winContext->Fp);
+#elif defined(TARGET_S390X)
+    unw_get_reg(cursor, UNW_REG_IP, (unw_word_t *) &winContext->PSWAddr);
+    unw_get_reg(cursor, UNW_REG_SP, (unw_word_t *) &winContext->R15);
+    unw_get_reg(cursor, UNW_S390X_R6, (unw_word_t *) &winContext->R6);
+    unw_get_reg(cursor, UNW_S390X_R7, (unw_word_t *) &winContext->R7);
+    unw_get_reg(cursor, UNW_S390X_R8, (unw_word_t *) &winContext->R8);
+    unw_get_reg(cursor, UNW_S390X_R9, (unw_word_t *) &winContext->R9);
+    unw_get_reg(cursor, UNW_S390X_R10, (unw_word_t *) &winContext->R10);
+    unw_get_reg(cursor, UNW_S390X_R11, (unw_word_t *) &winContext->R11);
+    unw_get_reg(cursor, UNW_S390X_R12, (unw_word_t *) &winContext->R12);
+    unw_get_reg(cursor, UNW_S390X_R13, (unw_word_t *) &winContext->R13);
+    unw_get_reg(cursor, UNW_S390X_R14, (unw_word_t *) &winContext->R14);
+    TRACE("sp %p pc %p lr %p\n", winContext->R15, winContext->PSWAddr, winContext->R14);
 #else
 #error unsupported architecture
 #endif
@@ -1746,6 +1770,18 @@ access_reg(unw_addr_space_t as, unw_regnum_t regnum, unw_word_t *valp, int write
     case UNW_AARCH64_X30:  *valp = (unw_word_t)winContext->Lr; break;
     case UNW_AARCH64_SP:   *valp = (unw_word_t)winContext->Sp; break;
     case UNW_AARCH64_PC:   *valp = (unw_word_t)winContext->Pc; break;
+#elif defined(TARGET_S390X)
+    case UNW_S390X_R6:     *valp = (unw_word_t)winContext->R6; break;
+    case UNW_S390X_R7:     *valp = (unw_word_t)winContext->R7; break;
+    case UNW_S390X_R8:     *valp = (unw_word_t)winContext->R8; break;
+    case UNW_S390X_R9:     *valp = (unw_word_t)winContext->R9; break;
+    case UNW_S390X_R10:    *valp = (unw_word_t)winContext->R10; break;
+    case UNW_S390X_R11:    *valp = (unw_word_t)winContext->R11; break;
+    case UNW_S390X_R12:    *valp = (unw_word_t)winContext->R12; break;
+    case UNW_S390X_R13:    *valp = (unw_word_t)winContext->R13; break;
+    case UNW_S390X_R14:    *valp = (unw_word_t)winContext->R14; break;
+    case UNW_S390X_R15:    *valp = (unw_word_t)winContext->R15; break;
+    case UNW_S390X_IP:     *valp = (unw_word_t)winContext->PSWAddr; break;
 #else
 #error unsupported architecture
 #endif
diff --git a/src/coreclr/pal/src/exception/seh-unwind.cpp b/src/coreclr/pal/src/exception/seh-unwind.cpp
index 5f4df9ae4dc781..b4427294e438da 100644
--- a/src/coreclr/pal/src/exception/seh-unwind.cpp
+++ b/src/coreclr/pal/src/exception/seh-unwind.cpp
@@ -115,6 +115,19 @@ enum
     ASSIGN_REG(Ebx)        \
     ASSIGN_REG(Esi)        \
     ASSIGN_REG(Edi)
+#elif (defined(HOST_UNIX) && defined(HOST_S390X))
+#define ASSIGN_UNWIND_REGS \
+    ASSIGN_REG(PSWAddr)    \
+    ASSIGN_REG(R6)         \
+    ASSIGN_REG(R7)         \
+    ASSIGN_REG(R8)         \
+    ASSIGN_REG(R9)         \
+    ASSIGN_REG(R10)        \
+    ASSIGN_REG(R11)        \
+    ASSIGN_REG(R12)        \
+    ASSIGN_REG(R13)        \
+    ASSIGN_REG(R14)        \
+    ASSIGN_REG(R15)
 #else
 #error unsupported architecture
 #endif
@@ -261,6 +274,18 @@ void UnwindContextToWinContext(unw_cursor_t *cursor, CONTEXT *winContext)
     // errors with "this target does not support pointer authentication"
     winContext->Pc = winContext->Pc & 0x7fffffffffffull;
 #endif // defined(TARGET_OSX) && defined(TARGET_ARM64)
+#elif (defined(HOST_UNIX) && defined(HOST_S390X))
+    unw_get_reg(cursor, UNW_REG_SP, (unw_word_t *) &winContext->R15);
+    unw_get_reg(cursor, UNW_REG_IP, (unw_word_t *) &winContext->PSWAddr);
+    unw_get_reg(cursor, UNW_S390X_R6, (unw_word_t *) &winContext->R6);
+    unw_get_reg(cursor, UNW_S390X_R7, (unw_word_t *) &winContext->R7);
+    unw_get_reg(cursor, UNW_S390X_R8, (unw_word_t *) &winContext->R8);
+    unw_get_reg(cursor, UNW_S390X_R9, (unw_word_t *) &winContext->R9);
+    unw_get_reg(cursor, UNW_S390X_R10, (unw_word_t *) &winContext->R10);
+    unw_get_reg(cursor, UNW_S390X_R11, (unw_word_t *) &winContext->R11);
+    unw_get_reg(cursor, UNW_S390X_R12, (unw_word_t *) &winContext->R12);
+    unw_get_reg(cursor, UNW_S390X_R13, (unw_word_t *) &winContext->R13);
+    unw_get_reg(cursor, UNW_S390X_R14, (unw_word_t *) &winContext->R14);
 #else
 #error unsupported architecture
 #endif
@@ -319,6 +344,17 @@ void GetContextPointers(unw_cursor_t *cursor, unw_context_t *unwContext, KNONVOL
     GetContextPointer(cursor, unwContext, UNW_AARCH64_X27, &contextPointers->X27);
     GetContextPointer(cursor, unwContext, UNW_AARCH64_X28, &contextPointers->X28);
     GetContextPointer(cursor, unwContext, UNW_AARCH64_X29, &contextPointers->Fp);
+#elif (defined(HOST_UNIX) && defined(HOST_S390X))
+    GetContextPointer(cursor, unwContext, UNW_S390X_R6, &contextPointers->R6);
+    GetContextPointer(cursor, unwContext, UNW_S390X_R7, &contextPointers->R7);
+    GetContextPointer(cursor, unwContext, UNW_S390X_R8, &contextPointers->R8);
+    GetContextPointer(cursor, unwContext, UNW_S390X_R9, &contextPointers->R9);
+    GetContextPointer(cursor, unwContext, UNW_S390X_R10, &contextPointers->R10);
+    GetContextPointer(cursor, unwContext, UNW_S390X_R11, &contextPointers->R11);
+    GetContextPointer(cursor, unwContext, UNW_S390X_R12, &contextPointers->R12);
+    GetContextPointer(cursor, unwContext, UNW_S390X_R13, &contextPointers->R13);
+    GetContextPointer(cursor, unwContext, UNW_S390X_R14, &contextPointers->R14);
+    GetContextPointer(cursor, unwContext, UNW_S390X_R15, &contextPointers->R15);
 #else
 #error unsupported architecture
 #endif
diff --git a/src/coreclr/pal/src/include/pal/context.h b/src/coreclr/pal/src/include/pal/context.h
index afbafe3fd9eb25..281c418aef4d2a 100644
--- a/src/coreclr/pal/src/include/pal/context.h
+++ b/src/coreclr/pal/src/include/pal/context.h
@@ -54,7 +54,28 @@ using asm_sigcontext::_xstate;
 #include <mach/mach_port.h>
 #endif // !HAVE_MACH_EXCEPTIONS else
 
-#if HAVE___GREGSET_T
+#ifdef HOST_S390X
+
+#define MCREG_PSWMask(mc)   ((mc).psw.mask)
+#define MCREG_PSWAddr(mc)   ((mc).psw.addr)
+#define MCREG_R0(mc)        ((mc).gregs[0])
+#define MCREG_R1(mc)        ((mc).gregs[1])
+#define MCREG_R2(mc)        ((mc).gregs[2])
+#define MCREG_R3(mc)        ((mc).gregs[3])
+#define MCREG_R4(mc)        ((mc).gregs[4])
+#define MCREG_R5(mc)        ((mc).gregs[5])
+#define MCREG_R6(mc)        ((mc).gregs[6])
+#define MCREG_R7(mc)        ((mc).gregs[7])
+#define MCREG_R8(mc)        ((mc).gregs[8])
+#define MCREG_R9(mc)        ((mc).gregs[9])
+#define MCREG_R10(mc)       ((mc).gregs[10])
+#define MCREG_R11(mc)       ((mc).gregs[11])
+#define MCREG_R12(mc)       ((mc).gregs[12])
+#define MCREG_R13(mc)       ((mc).gregs[13])
+#define MCREG_R14(mc)       ((mc).gregs[14])
+#define MCREG_R15(mc)       ((mc).gregs[15])
+
+#elif HAVE___GREGSET_T
 
 #ifdef HOST_64BIT
 #define MCREG_Rbx(mc)       ((mc).__gregs[_REG_RBX])
@@ -710,6 +731,8 @@ inline static DWORD64 CONTEXTGetPC(LPCONTEXT pContext)
     return pContext->Eip;
 #elif defined(HOST_ARM64) || defined(HOST_ARM)
     return pContext->Pc;
+#elif defined(HOST_S390X)
+    return pContext->PSWAddr;
 #else
 #error "don't know how to get the program counter for this architecture"
 #endif
@@ -723,6 +746,8 @@ inline static void CONTEXTSetPC(LPCONTEXT pContext, DWORD64 pc)
     pContext->Eip = pc;
 #elif defined(HOST_ARM64) || defined(HOST_ARM)
     pContext->Pc = pc;
+#elif defined(HOST_S390X)
+    pContext->PSWAddr = pc;
 #else
 #error "don't know how to set the program counter for this architecture"
 #endif
@@ -738,6 +763,8 @@ inline static DWORD64 CONTEXTGetFP(LPCONTEXT pContext)
     return pContext->R7;
 #elif defined(HOST_ARM64)
     return pContext->Fp;
+#elif defined(HOST_S390X)
+    return pContext->R11;
 #else
 #error "don't know how to get the frame pointer for this architecture"
 #endif
diff --git a/src/coreclr/pal/src/libunwind/CMakeLists.txt b/src/coreclr/pal/src/libunwind/CMakeLists.txt
index 44e9bc6c35eed3..6e31eae9f716ef 100644
--- a/src/coreclr/pal/src/libunwind/CMakeLists.txt
+++ b/src/coreclr/pal/src/libunwind/CMakeLists.txt
@@ -28,6 +28,8 @@ if(CLR_CMAKE_HOST_UNIX)
       set(arch arm)
     elseif(CLR_CMAKE_HOST_ARCH_I386)
         set(arch x86)
+    elseif(CLR_CMAKE_HOST_ARCH_S390X)
+      set(arch s390x)
     endif ()
 
     # Disable warning due to incorrect format specifier in debugging printf via the Debug macro
@@ -105,6 +107,10 @@ if(CLR_CMAKE_HOST_WIN32)
       set(TARGET_ARM 1)
       set(arch arm)
       add_definitions(-D__arm__)
+    elseif(CLR_CMAKE_TARGET_ARCH_S390X)
+      set(TARGET_S390X 1)
+      set(arch s390x)
+      add_definitions(-D__s390x__)
     else ()
       message(FATAL_ERROR "Unrecognized TARGET")
     endif ()
diff --git a/src/coreclr/pal/src/libunwind/include/tdep-s390x/libunwind_i.h b/src/coreclr/pal/src/libunwind/include/tdep-s390x/libunwind_i.h
index 8c34d6a9584670..ba75c0742f62cd 100644
--- a/src/coreclr/pal/src/libunwind/include/tdep-s390x/libunwind_i.h
+++ b/src/coreclr/pal/src/libunwind/include/tdep-s390x/libunwind_i.h
@@ -164,16 +164,16 @@ dwarf_get (struct dwarf_cursor *c, dwarf_loc_t loc, unw_word_t *val)
   if (DWARF_IS_NULL_LOC (loc))
     return -UNW_EBADREG;
 
+  /* GPRs may be saved in FPRs */
+  if (DWARF_IS_FP_LOC (loc))
+    return (*c->as->acc.access_fpreg) (c->as, DWARF_GET_LOC (loc), (unw_fpreg_t*)val,
+                                       0, c->as_arg);
   if (DWARF_IS_REG_LOC (loc))
     return (*c->as->acc.access_reg) (c->as, DWARF_GET_LOC (loc), val,
                                      0, c->as_arg);
   if (DWARF_IS_MEM_LOC (loc))
     return (*c->as->acc.access_mem) (c->as, DWARF_GET_LOC (loc), val,
                                      0, c->as_arg);
-  /* GPRs may be saved in FPRs */
-  if (DWARF_IS_FP_LOC (loc))
-    return (*c->as->acc.access_fpreg) (c->as, DWARF_GET_LOC (loc), (unw_fpreg_t*)val,
-                                       0, c->as_arg);
   assert(DWARF_IS_VAL_LOC (loc));
   *val = DWARF_GET_LOC (loc);
   return 0;
@@ -188,13 +188,13 @@ dwarf_put (struct dwarf_cursor *c, dwarf_loc_t loc, unw_word_t val)
   if (DWARF_IS_NULL_LOC (loc))
     return -UNW_EBADREG;
 
-  if (DWARF_IS_REG_LOC (loc))
-    return (*c->as->acc.access_reg) (c->as, DWARF_GET_LOC (loc), &val,
-                                     1, c->as_arg);
   /* GPRs may be saved in FPRs */
   if (DWARF_IS_FP_LOC (loc))
     return (*c->as->acc.access_fpreg) (c->as, DWARF_GET_LOC (loc), (unw_fpreg_t*) &val,
                                        1, c->as_arg);
+  if (DWARF_IS_REG_LOC (loc))
+    return (*c->as->acc.access_reg) (c->as, DWARF_GET_LOC (loc), &val,
+                                     1, c->as_arg);
 
   assert(DWARF_IS_MEM_LOC (loc));
   return (*c->as->acc.access_mem) (c->as, DWARF_GET_LOC (loc), &val,
diff --git a/src/coreclr/pal/src/libunwind/include/tdep/dwarf-config.h b/src/coreclr/pal/src/libunwind/include/tdep/dwarf-config.h
index c759a46c63b9da..e27e2a2369033d 100644
--- a/src/coreclr/pal/src/libunwind/include/tdep/dwarf-config.h
+++ b/src/coreclr/pal/src/libunwind/include/tdep/dwarf-config.h
@@ -15,6 +15,8 @@
 # include "tdep-ppc32/dwarf-config.h"
 #elif defined __powerpc64__
 # include "tdep-ppc64/dwarf-config.h"
+#elif defined __s390x__
+# include "tdep-s390x/dwarf-config.h"
 #elif defined __sh__
 # include "tdep-sh/dwarf-config.h"
 #elif defined __i386__
diff --git a/src/coreclr/pal/src/libunwind/libunwind-version.txt b/src/coreclr/pal/src/libunwind/libunwind-version.txt
index 9ebc86f5b15a7d..566086b14aee91 100644
--- a/src/coreclr/pal/src/libunwind/libunwind-version.txt
+++ b/src/coreclr/pal/src/libunwind/libunwind-version.txt
@@ -4,3 +4,4 @@ https://github.com/libunwind/libunwind/commit/9165d2a150d707d3037c2045f2cdc0fabd
 Remove upstream CMakelist.txt & src/CMakelist.txt, keep .NET Core custom version
 Keep .NET Core oop directory
 Apply https://github.com/libunwind/libunwind/pull/186
+Apply https://github.com/libunwind/libunwind/pull/245
diff --git a/src/coreclr/pal/src/libunwind/src/CMakeLists.txt b/src/coreclr/pal/src/libunwind/src/CMakeLists.txt
index 56420c1558f6c8..b6dee4f413a809 100644
--- a/src/coreclr/pal/src/libunwind/src/CMakeLists.txt
+++ b/src/coreclr/pal/src/libunwind/src/CMakeLists.txt
@@ -276,6 +276,35 @@ SET(libunwind_x86_64_la_SOURCES_x86_64
     x86_64/Gstash_frame.c x86_64/Gstep.c x86_64/Gtrace.c
 )
 
+# The list of files that go both into libunwind and libunwind-s390x:
+SET(libunwind_la_SOURCES_s390x_common
+    ${libunwind_la_SOURCES_common}
+    s390x/is_fpreg.c s390x/regname.c
+)
+
+# The list of files that go into libunwind:
+SET(libunwind_la_SOURCES_s390x
+    ${libunwind_la_SOURCES_s390x_common}
+    ${libunwind_la_SOURCES_local}
+    s390x/setcontext.S s390x/getcontext.S
+    s390x/Lapply_reg_state.c s390x/Lreg_states_iterate.c
+    s390x/Lcreate_addr_space.c s390x/Lget_save_loc.c s390x/Lglobal.c
+    s390x/Linit.c s390x/Linit_local.c s390x/Linit_remote.c
+    s390x/Lget_proc_info.c s390x/Lregs.c s390x/Lresume.c
+    s390x/Lis_signal_frame.c s390x/Lstep.c
+)
+
+# The list of files that go into libunwind-s390x:
+SET(libunwind_s390x_la_SOURCES_s390x
+    ${libunwind_la_SOURCES_s390x_common}
+    ${libunwind_la_SOURCES_generic}
+    s390x/Gapply_reg_state.c s390x/Greg_states_iterate.c
+    s390x/Gcreate_addr_space.c s390x/Gget_save_loc.c s390x/Gglobal.c
+    s390x/Ginit.c s390x/Ginit_local.c s390x/Ginit_remote.c
+    s390x/Gget_proc_info.c s390x/Gregs.c s390x/Gresume.c
+    s390x/Gis_signal_frame.c s390x/Gstep.c
+)
+
 if(CLR_CMAKE_HOST_UNIX)
     if(CLR_CMAKE_HOST_ARCH_ARM64)
         SET(libunwind_la_SOURCES                    ${libunwind_la_SOURCES_aarch64})
@@ -297,6 +326,10 @@ if(CLR_CMAKE_HOST_UNIX)
         SET(libunwind_remote_la_SOURCES             ${libunwind_x86_64_la_SOURCES_x86_64})
         SET(libunwind_elf_la_SOURCES                ${libunwind_elf64_la_SOURCES})
         list(APPEND libunwind_setjmp_la_SOURCES     x86_64/longjmp.S x86_64/siglongjmp.SA)
+    elseif(CLR_CMAKE_HOST_ARCH_S390X)
+        SET(libunwind_la_SOURCES                    ${libunwind_la_SOURCES_s390x})
+        SET(libunwind_remote_la_SOURCES             ${libunwind_s390x_la_SOURCES_s390x})
+        SET(libunwind_elf_la_SOURCES                ${libunwind_elf64_la_SOURCES})
     endif()
 
     if(CLR_CMAKE_HOST_OSX)
@@ -340,6 +373,10 @@ else(CLR_CMAKE_HOST_UNIX)
         SET(libunwind_remote_la_SOURCES             ${libunwind_x86_64_la_SOURCES_x86_64})
         SET(libunwind_elf_la_SOURCES                ${libunwind_elf64_la_SOURCES})
         list(APPEND libunwind_setjmp_la_SOURCES     x86_64/longjmp.S x86_64/siglongjmp.SA)
+    elseif(CLR_CMAKE_TARGET_ARCH_S390X)
+        SET(libunwind_la_SOURCES                    ${libunwind_la_SOURCES_s390x})
+        SET(libunwind_remote_la_SOURCES             ${libunwind_s390x_la_SOURCES_s390x})
+        SET(libunwind_elf_la_SOURCES                ${libunwind_elf64_la_SOURCES})
     endif()
 
     set_source_files_properties(${CLR_DIR}/pal/src/exception/remote-unwind.cpp PROPERTIES COMPILE_FLAGS /TP INCLUDE_DIRECTORIES ${CLR_DIR}/inc)
diff --git a/src/coreclr/pal/src/libunwind/src/s390x/Gresume.c b/src/coreclr/pal/src/libunwind/src/s390x/Gresume.c
index fd9d13027e2a85..bfc4d5cab4e465 100644
--- a/src/coreclr/pal/src/libunwind/src/s390x/Gresume.c
+++ b/src/coreclr/pal/src/libunwind/src/s390x/Gresume.c
@@ -68,7 +68,7 @@ s390x_local_resume (unw_addr_space_t as, unw_cursor_t *cursor, void *arg)
       sp = c->sigcontext_sp;
       ip = c->sigcontext_pc;
       __asm__ __volatile__ (
-        "lgr 15, %[sp]\n"
+        "lgr %%r15, %[sp]\n"
         "br %[ip]\n"
         : : [sp] "r" (sp), [ip] "r" (ip)
       );
@@ -86,7 +86,7 @@ s390x_local_resume (unw_addr_space_t as, unw_cursor_t *cursor, void *arg)
       sp = c->sigcontext_sp;
       ip = c->sigcontext_pc;
       __asm__ __volatile__ (
-        "lgr 15, %[sp]\n"
+        "lgr %%r15, %[sp]\n"
         "br %[ip]\n"
         : : [sp] "r" (sp), [ip] "r" (ip)
       );
diff --git a/src/coreclr/pal/src/map/virtual.cpp b/src/coreclr/pal/src/map/virtual.cpp
index cea55e86e2538f..645cf10aec8d6a 100644
--- a/src/coreclr/pal/src/map/virtual.cpp
+++ b/src/coreclr/pal/src/map/virtual.cpp
@@ -1761,21 +1761,26 @@ VirtualProtect(
 }
 
 #if defined(HOST_OSX) && defined(HOST_ARM64)
-bool
-PAL_JITWriteEnableHolder::JITWriteEnable(bool writeEnable)
+PALAPI VOID PAL_JitWriteProtect(bool writeEnable)
 {
-    // Use a thread local to track per thread JIT Write enable state
-    // Per Apple, new threads start with MAP_JIT pages readable and executable (R-X) by default.
-    thread_local bool enabled = false;
-    bool result = enabled;
-    if (enabled != writeEnable)
+    thread_local int enabledCount = 0;
+    if (writeEnable)
     {
-        pthread_jit_write_protect_np(writeEnable ? 0 : 1);
-        enabled = writeEnable;
+        if (enabledCount++ == 0)
+        {
+            pthread_jit_write_protect_np(0);
+        }
+    }
+    else
+    {
+        if (--enabledCount == 0)
+        {
+            pthread_jit_write_protect_np(1);
+        }
+        _ASSERTE(enabledCount >= 0);
     }
-    return result;
 }
-#endif
+#endif // HOST_OSX && HOST_ARM64
 
 #if HAVE_VM_ALLOCATE
 //---------------------------------------------------------------------------------------
diff --git a/src/coreclr/pal/src/misc/jitsupport.cpp b/src/coreclr/pal/src/misc/jitsupport.cpp
index 8678a479f10dc3..973de4033e3d4b 100644
--- a/src/coreclr/pal/src/misc/jitsupport.cpp
+++ b/src/coreclr/pal/src/misc/jitsupport.cpp
@@ -82,7 +82,7 @@ static const CpuCapability CpuCapabilities[] = {
 // If the capability name is not recognized or unused at present, zero is returned.
 static unsigned long LookupCpuCapabilityFlag(const char* start, size_t length)
 {
-    for (int i = 0; i < _countof(CpuCapabilities); i++)
+    for (size_t i = 0; i < _countof(CpuCapabilities); i++)
     {
         const char* capabilityName = CpuCapabilities[i].name;
         if ((length == strlen(capabilityName)) && (memcmp(start, capabilityName, length) == 0))
diff --git a/src/coreclr/pal/src/misc/perfjitdump.cpp b/src/coreclr/pal/src/misc/perfjitdump.cpp
index a1fe107421dcbf..d80bd58038cbad 100644
--- a/src/coreclr/pal/src/misc/perfjitdump.cpp
+++ b/src/coreclr/pal/src/misc/perfjitdump.cpp
@@ -46,6 +46,8 @@ namespace
         ELF_MACHINE = EM_X86_64,
 #elif defined(HOST_ARM64)
         ELF_MACHINE = EM_AARCH64,
+#elif defined(HOST_S390X)
+        ELF_MACHINE = EM_S390,
 #else
 #error ELF_MACHINE unsupported for target
 #endif
diff --git a/src/coreclr/pal/src/misc/sysinfo.cpp b/src/coreclr/pal/src/misc/sysinfo.cpp
index 1a9ca8fbfba72e..8f935b3e3ea1a8 100644
--- a/src/coreclr/pal/src/misc/sysinfo.cpp
+++ b/src/coreclr/pal/src/misc/sysinfo.cpp
@@ -558,7 +558,7 @@ PAL_GetLogicalProcessorCacheSizeFromOS()
     cacheSize = std::max(cacheSize, (size_t)sysconf(_SC_LEVEL4_CACHE_SIZE));
 #endif
 
-#if defined(TARGET_LINUX) && !defined(HOST_ARM)
+#if defined(TARGET_LINUX) && !defined(HOST_ARM) && !defined(HOST_X86)
     if (cacheSize == 0)
     {
         //
diff --git a/src/coreclr/pal/src/thread/context.cpp b/src/coreclr/pal/src/thread/context.cpp
index 5bb3a6079aaa11..8d630fa170fb43 100644
--- a/src/coreclr/pal/src/thread/context.cpp
+++ b/src/coreclr/pal/src/thread/context.cpp
@@ -45,6 +45,8 @@ extern PGET_GCMARKER_EXCEPTION_CODE g_getGcMarkerExceptionCode;
 #define CONTEXT_ALL_FLOATING CONTEXT_FLOATING_POINT
 #elif defined(HOST_ARM64)
 #define CONTEXT_ALL_FLOATING CONTEXT_FLOATING_POINT
+#elif defined(HOST_S390X)
+#define CONTEXT_ALL_FLOATING CONTEXT_FLOATING_POINT
 #else
 #error Unexpected architecture.
 #endif
@@ -169,6 +171,30 @@ typedef int __ptrace_request;
 	ASSIGN_REG(X27)     \
 	ASSIGN_REG(X28)
 
+#elif defined(HOST_S390X)
+#define ASSIGN_CONTROL_REGS \
+        ASSIGN_REG(PSWMask) \
+        ASSIGN_REG(PSWAddr) \
+        ASSIGN_REG(R15)     \
+
+#define ASSIGN_INTEGER_REGS \
+        ASSIGN_REG(R0)      \
+        ASSIGN_REG(R1)      \
+        ASSIGN_REG(R2)      \
+        ASSIGN_REG(R3)      \
+        ASSIGN_REG(R4)      \
+        ASSIGN_REG(R5)      \
+        ASSIGN_REG(R5)      \
+        ASSIGN_REG(R6)      \
+        ASSIGN_REG(R7)      \
+        ASSIGN_REG(R8)      \
+        ASSIGN_REG(R9)      \
+        ASSIGN_REG(R10)     \
+        ASSIGN_REG(R11)     \
+        ASSIGN_REG(R12)     \
+        ASSIGN_REG(R13)     \
+        ASSIGN_REG(R14)
+
 #else
 #error "Don't know how to assign registers on this architecture"
 #endif
@@ -436,7 +462,7 @@ void CONTEXTToNativeContext(CONST CONTEXT *lpContext, native_context_t *native)
 #undef ASSIGN_REG
 
 #if !HAVE_FPREGS_WITH_CW
-#if HAVE_GREGSET_T || HAVE_GREGSET_T
+#if (HAVE_GREGSET_T || HAVE___GREGSET_T) && !defined(HOST_S390X)
 #if HAVE_GREGSET_T
     if (native->uc_mcontext.fpregs == nullptr)
 #elif HAVE___GREGSET_T
@@ -448,7 +474,7 @@ void CONTEXTToNativeContext(CONST CONTEXT *lpContext, native_context_t *native)
         // whether CONTEXT_FLOATING_POINT is set in the CONTEXT's flags.
         return;
     }
-#endif // HAVE_GREGSET_T || HAVE_GREGSET_T
+#endif // (HAVE_GREGSET_T || HAVE___GREGSET_T) && !HOST_S390X
 #endif // !HAVE_FPREGS_WITH_CW
 
     if ((lpContext->ContextFlags & CONTEXT_FLOATING_POINT) == CONTEXT_FLOATING_POINT)
@@ -509,6 +535,10 @@ void CONTEXTToNativeContext(CONST CONTEXT *lpContext, native_context_t *native)
                 fp->D[i] = lpContext->D[i];
             }
         }
+#elif defined(HOST_S390X)
+        fpregset_t *fp = &native->uc_mcontext.fpregs;
+        static_assert_no_msg(sizeof(fp->fprs) == sizeof(lpContext->Fpr));
+        memcpy(fp->fprs, lpContext->Fpr, sizeof(lpContext->Fpr));
 #endif
     }
 
@@ -562,7 +592,7 @@ void CONTEXTFromNativeContext(const native_context_t *native, LPCONTEXT lpContex
 #undef ASSIGN_REG
 
 #if !HAVE_FPREGS_WITH_CW
-#if HAVE_GREGSET_T || HAVE___GREGSET_T
+#if (HAVE_GREGSET_T || HAVE___GREGSET_T) && !defined(HOST_S390X)
 #if HAVE_GREGSET_T
     if (native->uc_mcontext.fpregs == nullptr)
 #elif HAVE___GREGSET_T
@@ -584,7 +614,7 @@ void CONTEXTFromNativeContext(const native_context_t *native, LPCONTEXT lpContex
         // Bail out regardless of whether the caller wanted CONTEXT_FLOATING_POINT or CONTEXT_XSTATE
         return;
     }
-#endif // HAVE_GREGSET_T || HAVE___GREGSET_T
+#endif // (HAVE_GREGSET_T || HAVE___GREGSET_T) && !HOST_S390X
 #endif // !HAVE_FPREGS_WITH_CW
 
     if ((contextFlags & CONTEXT_FLOATING_POINT) == CONTEXT_FLOATING_POINT)
@@ -650,6 +680,10 @@ void CONTEXTFromNativeContext(const native_context_t *native, LPCONTEXT lpContex
             // Mark the context correctly
             lpContext->ContextFlags &= ~(ULONG)CONTEXT_FLOATING_POINT;
         }
+#elif defined(HOST_S390X)
+        const fpregset_t *fp = &native->uc_mcontext.fpregs;
+        static_assert_no_msg(sizeof(fp->fprs) == sizeof(lpContext->Fpr));
+        memcpy(lpContext->Fpr, fp->fprs, sizeof(lpContext->Fpr));
 #endif
     }
 
@@ -699,6 +733,8 @@ LPVOID GetNativeContextPC(const native_context_t *context)
     return (LPVOID) MCREG_Pc(context->uc_mcontext);
 #elif defined(HOST_ARM64)
     return (LPVOID) MCREG_Pc(context->uc_mcontext);
+#elif defined(HOST_S390X)
+    return (LPVOID) MCREG_PSWAddr(context->uc_mcontext);
 #else
 #   error implement me for this architecture
 #endif
@@ -727,6 +763,8 @@ LPVOID GetNativeContextSP(const native_context_t *context)
     return (LPVOID) MCREG_Sp(context->uc_mcontext);
 #elif defined(HOST_ARM64)
     return (LPVOID) MCREG_Sp(context->uc_mcontext);
+#elif defined(HOST_S390X)
+    return (LPVOID) MCREG_R15(context->uc_mcontext);
 #else
 #   error implement me for this architecture
 #endif
diff --git a/src/coreclr/scripts/jitrollingbuild.py b/src/coreclr/scripts/jitrollingbuild.py
index 83434438dac10a..c5bf6d065b590e 100644
--- a/src/coreclr/scripts/jitrollingbuild.py
+++ b/src/coreclr/scripts/jitrollingbuild.py
@@ -172,11 +172,12 @@ def determine_jit_name(coreclr_args):
         raise RuntimeError("Unknown OS.")
 
 
-def list_az_jits(filter_func=lambda unused: True):
+def list_az_jits(filter_func=lambda unused: True, prefix_string = None):
     """ List the JITs in Azure Storage using REST api
 
     Args:
         filter_func (lambda: string -> bool): filter to apply to the list. The filter takes a URL and returns True if this URL is acceptable.
+        prefix_string: Optional. Specifies a string prefix for the Azure Storage query.
 
     Returns:
         urls (list): set of URLs in Azure Storage that match the filter.
@@ -187,46 +188,72 @@ def list_az_jits(filter_func=lambda unused: True):
 
     # This URI will return *all* the blobs, for all git_hash/OS/architecture/build_type combinations.
     # pass "prefix=foo/bar/..." to only show a subset. Or, we can filter later using string search.
-    list_az_container_uri = az_blob_storage_container_uri + "?restype=container&comp=list&prefix=" + az_builds_root_folder + "/"
-
-    try:
-        contents = urllib.request.urlopen(list_az_container_uri).read().decode('utf-8')
-    except Exception as exception:
-        print("Didn't find any collections using {}".format(list_az_container_uri))
-        print("  Error: {}".format(exception))
-        return None
-
-    # Contents is an XML file with contents like:
-    # <EnumerationResults ContainerName="https://clrjit2.blob.core.windows.net/jitrollingbuild">
-    #   <Prefix>builds/</Prefix>
-    #   <Blobs>
-    #     <Blob>
-    #       <Name>builds/755f01659f03196487ec41225de8956911f8049b/Linux/x64/Checked/libclrjit.so</Name>
-    #       <Url>https://clrjit2.blob.core.windows.net/jitrollingbuild/builds/755f01659f03196487ec41225de8956911f8049b/Linux/x64/Checked/libclrjit.so</Url>
-    #       <Properties>
-    #         ...
-    #       </Properties>
-    #     </Blob>
-    #     <Blob>
-    #       <Name>builds/755f01659f03196487ec41225de8956911f8049b/OSX/x64/Checked/libclrjit.dylib</Name>
-    #       <Url>https://clrjit2.blob.core.windows.net/jitrollingbuild/builds/755f01659f03196487ec41225de8956911f8049b/OSX/x64/Checked/libclrjit.dylib</Url>
-    #       <Properties>
-    #         ...
-    #       </Properties>
-    #     </Blob>
-    #     ... etc. ...
-    #   </Blobs>
-    # </EnumerationResults>
     #
-    # We just want to extract the <Url> entries. We could probably use an XML parsing package, but we just
-    # use regular expressions.
+    # Note that there is a maximum number of results returned in one query of 5000. So we might need to
+    # iterate. In that case, the XML result contains a `<NextMarker>` element like:
+    #
+    # <NextMarker>2!184!MDAwMDkyIWJ1aWxkcy8wMTZlYzI5OTAzMzkwMmY2ZTY4Yzg0YWMwYTNlYzkxN2Y5MzA0OTQ2L0xpbnV4L3g2NC9DaGVja2VkL2xpYmNscmppdF93aW5fYXJtNjRfeDY0LnNvITAwMDAyOCE5OTk5LTEyLTMxVDIzOjU5OjU5Ljk5OTk5OTlaIQ--</NextMarker>
+    #
+    # which we need to pass to the REST API with `marker=...`.
 
-    urls_split = contents.split("<Url>")[1:]
     urls = []
-    for item in urls_split:
-        url = item.split("</Url>")[0].strip()
-        if filter_func(url):
-            urls.append(url)
+
+    list_az_container_uri_root = az_blob_storage_container_uri + "?restype=container&comp=list&prefix=" + az_builds_root_folder + "/"
+    if prefix_string:
+        list_az_container_uri_root += prefix_string
+
+    iter = 1
+    marker = ""
+
+    while True:
+        list_az_container_uri = list_az_container_uri_root + marker
+
+        try:
+            contents = urllib.request.urlopen(list_az_container_uri).read().decode('utf-8')
+        except Exception as exception:
+            print("Didn't find any collections using {}".format(list_az_container_uri))
+            print("  Error: {}".format(exception))
+            return None
+
+        # Contents is an XML file with contents like:
+        # <EnumerationResults ContainerName="https://clrjit2.blob.core.windows.net/jitrollingbuild">
+        #   <Prefix>builds/</Prefix>
+        #   <Blobs>
+        #     <Blob>
+        #       <Name>builds/755f01659f03196487ec41225de8956911f8049b/Linux/x64/Checked/libclrjit.so</Name>
+        #       <Url>https://clrjit2.blob.core.windows.net/jitrollingbuild/builds/755f01659f03196487ec41225de8956911f8049b/Linux/x64/Checked/libclrjit.so</Url>
+        #       <Properties>
+        #         ...
+        #       </Properties>
+        #     </Blob>
+        #     <Blob>
+        #       <Name>builds/755f01659f03196487ec41225de8956911f8049b/OSX/x64/Checked/libclrjit.dylib</Name>
+        #       <Url>https://clrjit2.blob.core.windows.net/jitrollingbuild/builds/755f01659f03196487ec41225de8956911f8049b/OSX/x64/Checked/libclrjit.dylib</Url>
+        #       <Properties>
+        #         ...
+        #       </Properties>
+        #     </Blob>
+        #     ... etc. ...
+        #   </Blobs>
+        # </EnumerationResults>
+        #
+        # We just want to extract the <Url> entries. We could probably use an XML parsing package, but we just
+        # use regular expressions.
+
+        urls_split = contents.split("<Url>")[1:]
+        for item in urls_split:
+            url = item.split("</Url>")[0].strip()
+            if filter_func(url):
+                urls.append(url)
+
+        # Look for a continuation marker.
+        re_match = re.match(r'.*<NextMarker>(.*)</NextMarker>.*', contents)
+        if re_match:
+            marker_text = re_match.group(1)
+            marker = "&marker=" + marker_text
+            iter += 1
+        else:
+            break
 
     return urls
 
@@ -449,7 +476,7 @@ def filter_jits(url):
         url = url.lower()
         return find_all or url.startswith(blob_prefix_filter)
 
-    return list_az_jits(filter_jits)
+    return list_az_jits(filter_jits, None if find_all else blob_filter_string)
 
 
 def download_command(coreclr_args):
diff --git a/src/coreclr/scripts/superpmi.proj b/src/coreclr/scripts/superpmi.proj
index 05ad302eba2de3..963e117688f572 100644
--- a/src/coreclr/scripts/superpmi.proj
+++ b/src/coreclr/scripts/superpmi.proj
@@ -85,6 +85,10 @@
     <WorkItemTimeout>5:00</WorkItemTimeout>
   </PropertyGroup>
 
+  <ItemGroup Condition=" '$(AGENT_OS)' == 'Windows_NT' ">
+    <HelixPreCommand Include="taskkill.exe /f /im corerun.exe"/>
+    <HelixPostCommand Include="taskkill.exe /f /im corerun.exe"/>
+  </ItemGroup>
   <!-- We're currently not using .dotnet on the Helix agents -->
   <!--
   <ItemGroup Condition=" '$(AGENT_OS)' == 'Windows_NT' ">
@@ -94,11 +98,12 @@
   <ItemGroup Condition=" '$(AGENT_OS)' != 'Windows_NT' ">
     <HelixPreCommand Include="export PATH=$HELIX_CORRELATION_PAYLOAD/.dotnet:$PATH" Condition=" '$(CollectionType)' == 'crossgen2' "/>
   </ItemGroup>
+  -->
 
   <PropertyGroup>
     <HelixPreCommands>@(HelixPreCommand)</HelixPreCommands>
+    <HelixPostCommands>@(HelixPostCommand)</HelixPostCommands>
   </PropertyGroup>
-  -->
 
   <ItemGroup>
     <HelixCorrelationPayload Include="$(CorrelationPayloadDirectory)">
diff --git a/src/coreclr/scripts/superpmi.py b/src/coreclr/scripts/superpmi.py
index 37f069d959cf8f..ce4332c314547e 100755
--- a/src/coreclr/scripts/superpmi.py
+++ b/src/coreclr/scripts/superpmi.py
@@ -262,9 +262,8 @@
 collect_parser.add_argument("collection_args", nargs='?', help="Arguments to pass to the SuperPMI collect command. This is a single string; quote it if necessary if the arguments contain spaces.")
 
 collect_parser.add_argument("--pmi", action="store_true", help="Run PMI on a set of directories or assemblies.")
-collect_parser.add_argument("--crossgen", action="store_true", help="Run crossgen on a set of directories or assemblies.")
 collect_parser.add_argument("--crossgen2", action="store_true", help="Run crossgen2 on a set of directories or assemblies.")
-collect_parser.add_argument("-assemblies", dest="assemblies", nargs="+", default=[], help="A list of managed dlls or directories to recursively use while collecting with PMI, crossgen, or crossgen2. Required if --pmi, --crossgen, or --crossgen2 is specified.")
+collect_parser.add_argument("-assemblies", dest="assemblies", nargs="+", default=[], help="A list of managed dlls or directories to recursively use while collecting with PMI or crossgen2. Required if --pmi or --crossgen2 is specified.")
 collect_parser.add_argument("-exclude", dest="exclude", nargs="+", default=[], help="A list of files or directories to exclude from the files and directories specified by `-assemblies`.")
 collect_parser.add_argument("-pmi_location", help="Path to pmi.dll to use during PMI run. Optional; pmi.dll will be downloaded from Azure Storage if necessary.")
 collect_parser.add_argument("-output_mch_path", help="Location to place the final MCH file.")
@@ -631,6 +630,39 @@ def create_unique_directory_name(root_directory, base_name):
     return full_path
 
 
+def create_unique_file_name(directory, base_name, extension):
+    """ Create a unique file name in the specified directory by joining `base_name` and `extension`.
+        If this name already exists, append ".1", ".2", ".3", etc., to the `base_name`
+        name component until the full file name is not found.
+
+    Args:
+        directory (str)  : directory in which a new file will be created
+        base_name (str)  : the base name of the new filename to be added
+        extension (str)  : the filename extension of the new filename to be added
+
+    Returns:
+        (str) The full absolute path of the new filename.
+    """
+
+    directory = os.path.abspath(directory)
+    if not os.path.isdir(directory):
+        try:
+            os.makedirs(directory)
+        except Exception as exception:
+            logging.critical(exception)
+            raise exception
+
+    full_path = os.path.join(directory, base_name + "." + extension)
+
+    count = 1
+    while os.path.isfile(full_path):
+        new_full_path = os.path.join(directory, base_name + "." + str(count) + "." + extension)
+        count += 1
+        full_path = new_full_path
+
+    return full_path
+
+
 def get_files_from_path(path, match_func=lambda path: True):
     """ Return all files in a directory tree matching a criteria.
 
@@ -906,15 +938,12 @@ def __init__(self, coreclr_args):
         if coreclr_args.host_os == "OSX":
             self.collection_shim_name = "libsuperpmi-shim-collector.dylib"
             self.corerun_tool_name = "corerun"
-            self.crossgen_tool_name = "crossgen"
         elif coreclr_args.host_os == "Linux":
             self.collection_shim_name = "libsuperpmi-shim-collector.so"
             self.corerun_tool_name = "corerun"
-            self.crossgen_tool_name = "crossgen"
         elif coreclr_args.host_os == "windows":
             self.collection_shim_name = "superpmi-shim-collector.dll"
             self.corerun_tool_name = "corerun.exe"
-            self.crossgen_tool_name = "crossgen.exe"
         else:
             raise RuntimeError("Unsupported OS.")
 
@@ -931,9 +960,6 @@ def __init__(self, coreclr_args):
             self.pmi_location = determine_pmi_location(coreclr_args)
             self.corerun = os.path.join(self.core_root, self.corerun_tool_name)
 
-        if coreclr_args.crossgen:
-            self.crossgen_tool = os.path.join(self.core_root, self.crossgen_tool_name)
-
         if coreclr_args.crossgen2:
             self.corerun = os.path.join(self.core_root, self.corerun_tool_name)
             if coreclr_args.dotnet_tool_path is None:
@@ -942,7 +968,7 @@ def __init__(self, coreclr_args):
                 self.crossgen2_driver_tool = coreclr_args.dotnet_tool_path
             logging.debug("Using crossgen2 driver tool %s", self.crossgen2_driver_tool)
 
-        if coreclr_args.pmi or coreclr_args.crossgen or coreclr_args.crossgen2:
+        if coreclr_args.pmi or coreclr_args.crossgen2:
             self.assemblies = coreclr_args.assemblies
             self.exclude = coreclr_args.exclude
 
@@ -1081,7 +1107,7 @@ def set_and_report_env(env, root_env, complus_env = None):
 
             # If we need them, collect all the assemblies we're going to use for the collection(s).
             # Remove the files matching the `-exclude` arguments (case-insensitive) from the list.
-            if self.coreclr_args.pmi or self.coreclr_args.crossgen or self.coreclr_args.crossgen2:
+            if self.coreclr_args.pmi or self.coreclr_args.crossgen2:
                 assemblies = []
                 for item in self.assemblies:
                     assemblies += get_files_from_path(item, match_func=lambda file: any(file.endswith(extension) for extension in [".dll", ".exe"]) and (self.exclude is None or not any(e.lower() in file.lower() for e in self.exclude)))
@@ -1180,84 +1206,6 @@ async def run_pmi(print_prefix, assembly, self):
                 os.environ.update(old_env)
             ################################################################################################ end of "self.coreclr_args.pmi is True"
 
-            ################################################################################################ Do collection using crossgen
-            if self.coreclr_args.crossgen is True:
-                logging.debug("Starting collection using crossgen")
-
-                async def run_crossgen(print_prefix, assembly, self):
-                    """ Run crossgen over all dlls
-                    """
-
-                    root_crossgen_output_filename = make_safe_filename("crossgen_" + assembly) + ".out.dll"
-                    crossgen_output_assembly_filename = os.path.join(self.temp_location, root_crossgen_output_filename)
-                    try:
-                        if os.path.exists(crossgen_output_assembly_filename):
-                            os.remove(crossgen_output_assembly_filename)
-                    except OSError as ose:
-                        if "[WinError 32] The process cannot access the file because it is being used by another " \
-                           "process:" in format(ose):
-                            logging.warning("Skipping file %s. Got error: %s", crossgen_output_assembly_filename, ose)
-                            return
-                        else:
-                            raise ose
-
-                    command = [self.crossgen_tool, "/Platform_Assemblies_Paths", self.core_root, "/in", assembly, "/out", crossgen_output_assembly_filename]
-                    command_string = " ".join(command)
-                    logging.debug("%s%s", print_prefix, command_string)
-
-                    # Save the stdout and stderr to files, so we can see if crossgen wrote any interesting messages.
-                    # Use the name of the assembly as the basename of the file. mkstemp() will ensure the file
-                    # is unique.
-                    root_output_filename = make_safe_filename("crossgen_" + assembly + "_")
-                    try:
-                        stdout_file_handle, stdout_filepath = tempfile.mkstemp(suffix=".stdout", prefix=root_output_filename, dir=self.temp_location)
-                        stderr_file_handle, stderr_filepath = tempfile.mkstemp(suffix=".stderr", prefix=root_output_filename, dir=self.temp_location)
-
-                        proc = await asyncio.create_subprocess_shell(
-                            command_string,
-                            stdout=stdout_file_handle,
-                            stderr=stderr_file_handle)
-
-                        await proc.communicate()
-
-                        os.close(stdout_file_handle)
-                        os.close(stderr_file_handle)
-
-                        # No need to keep zero-length files
-                        if is_zero_length_file(stdout_filepath):
-                            os.remove(stdout_filepath)
-                        if is_zero_length_file(stderr_filepath):
-                            os.remove(stderr_filepath)
-
-                        return_code = proc.returncode
-                        if return_code != 0:
-                            logging.debug("'%s': Error return code: %s", command_string, return_code)
-                            write_file_to_log(stdout_filepath, log_level=logging.DEBUG)
-
-                        write_file_to_log(stderr_filepath, log_level=logging.DEBUG)
-                    except OSError as ose:
-                        if "[WinError 32] The process cannot access the file because it is being used by another " \
-                           "process:" in format(ose):
-                            logging.warning("Skipping file %s. Got error: %s", root_output_filename, ose)
-                        else:
-                            raise ose
-
-                # Set environment variables.
-                crossgen_command_env = env_copy.copy()
-                crossgen_complus_env = complus_env.copy()
-                crossgen_complus_env["JitName"] = self.collection_shim_name
-                set_and_report_env(crossgen_command_env, root_env, crossgen_complus_env)
-
-                old_env = os.environ.copy()
-                os.environ.update(crossgen_command_env)
-
-                helper = AsyncSubprocessHelper(assemblies, verbose=True)
-                helper.run_to_completion(run_crossgen, self)
-
-                os.environ.clear()
-                os.environ.update(old_env)
-            ################################################################################################ end of "self.coreclr_args.crossgen is True"
-
             ################################################################################################ Do collection using crossgen2
             if self.coreclr_args.crossgen2 is True:
                 logging.debug("Starting collection using crossgen2")
@@ -1602,14 +1550,6 @@ def replay(self):
 
         result = True  # Assume success
 
-        # Possible return codes from SuperPMI
-        #
-        # 0  : success
-        # -1 : general fatal error (e.g., failed to initialize, failed to read files)
-        # -2 : JIT failed to initialize
-        # 1  : there were compilation failures
-        # 2  : there were assembly diffs
-
         with TempDir() as temp_location:
             logging.debug("")
             logging.debug("Temp Location: %s", temp_location)
@@ -1681,8 +1621,12 @@ def replay(self):
                 if return_code == 0:
                     logging.info("Clean SuperPMI replay")
                 else:
-                    files_with_replay_failures.append(mch_file)
                     result = False
+                    # Don't report as replay failure missing data (return code 3).
+                    # Anything else, such as compilation failure (return code 1, typically a JIT assert) will be
+                    # reported as a replay failure.
+                    if return_code != 3:
+                        files_with_replay_failures.append(mch_file)
 
                 if is_nonzero_length_file(fail_mcl_file):
                     # Unclean replay. Examine the contents of the fail.mcl file to dig into failures.
@@ -1754,14 +1698,6 @@ def replay_with_asm_diffs(self):
 
         result = True  # Assume success
 
-        # Possible return codes from SuperPMI
-        #
-        # 0  : success
-        # -1 : general fatal error (e.g., failed to initialize, failed to read files)
-        # -2 : JIT failed to initialize
-        # 1  : there were compilation failures
-        # 2  : there were assembly diffs
-
         # Set up some settings we'll use below.
 
         asm_complus_vars = {
@@ -1829,6 +1765,9 @@ def replay_with_asm_diffs(self):
         files_with_asm_diffs = []
         files_with_replay_failures = []
 
+        # List of all Markdown summary files
+        all_md_summary_files = []
+
         with TempDir(self.coreclr_args.temp_dir, self.coreclr_args.skip_cleanup) as temp_location:
             logging.debug("")
             logging.debug("Temp Location: %s", temp_location)
@@ -1889,8 +1828,12 @@ def replay_with_asm_diffs(self):
                         if return_code == 0:
                             logging.info("Clean SuperPMI replay")
                         else:
-                            files_with_replay_failures.append(mch_file)
                             result = False
+                            # Don't report as replay failure asm diffs (return code 2) or missing data (return code 3).
+                            # Anything else, such as compilation failure (return code 1, typically a JIT assert) will be
+                            # reported as a replay failure.
+                            if return_code != 2 and return_code != 3:
+                                files_with_replay_failures.append(mch_file)
 
                 artifacts_base_name = create_artifacts_base_name(self.coreclr_args, mch_file)
 
@@ -2023,7 +1966,10 @@ async def create_one_artifact(jit_path: str, location: str, flags) -> str:
                             jit_analyze_path = find_file(jit_analyze_file, path_var.split(os.pathsep))
                             if jit_analyze_path is not None:
                                 # It appears we have a built jit-analyze on the path, so try to run it.
-                                command = [ jit_analyze_path, "-r", "--base", base_asm_location, "--diff", diff_asm_location ]
+                                md_summary_file = os.path.join(asm_root_dir, "summary.md")
+                                summary_file_info = ( mch_file, md_summary_file )
+                                all_md_summary_files.append(summary_file_info)
+                                command = [ jit_analyze_path, "--md", md_summary_file, "-r", "--base", base_asm_location, "--diff", diff_asm_location ]
                                 run_and_log(command, logging.INFO)
                                 ran_jit_analyze = True
 
@@ -2056,8 +2002,32 @@ async def create_one_artifact(jit_path: str, location: str, flags) -> str:
 
             ################################################################################################ end of for mch_file in self.mch_files
 
+        # Report the overall results summary of the asmdiffs run
+
         logging.info("Asm diffs summary:")
 
+        # Construct an overall Markdown summary file.
+
+        if len(all_md_summary_files) > 0:
+            overall_md_summary_file = create_unique_file_name(self.coreclr_args.spmi_location, "diff_summary", "md")
+            if not os.path.isdir(self.coreclr_args.spmi_location):
+                os.makedirs(self.coreclr_args.spmi_location)
+            if os.path.isfile(overall_md_summary_file):
+                os.remove(overall_md_summary_file)
+
+            with open(overall_md_summary_file, "w") as write_fh:
+                for summary_file_info in all_md_summary_files:
+                    summary_mch  = summary_file_info[0]
+                    summary_mch_filename = os.path.basename(summary_mch) # Display just the MCH filename, not the full path
+                    summary_file = summary_file_info[1]
+                    with open(summary_file, "r") as read_fh:
+                        write_fh.write("## " + summary_mch_filename + ":\n\n")
+                        shutil.copyfileobj(read_fh, write_fh)
+
+            logging.info("  Summary Markdown file: %s", overall_md_summary_file)
+
+        # Report the set of MCH files with asm diffs and replay failures.
+
         if len(files_with_replay_failures) != 0:
             logging.info("  Replay failures in %s MCH files:", len(files_with_replay_failures))
             for file in files_with_replay_failures:
@@ -2407,45 +2377,69 @@ def list_superpmi_collections_container_via_rest_api(path_filter=lambda unused:
 
     # This URI will return *all* the blobs, for all jit-ee-version/OS/architecture combinations.
     # pass "prefix=foo/bar/..." to only show a subset. Or, we can filter later using string search.
-    list_superpmi_container_uri = az_blob_storage_superpmi_container_uri + "?restype=container&comp=list&prefix=" + az_collections_root_folder + "/"
-
-    try:
-        contents = urllib.request.urlopen(list_superpmi_container_uri).read().decode('utf-8')
-    except Exception as exception:
-        logging.error("Didn't find any collections using %s", list_superpmi_container_uri)
-        logging.error("  Error: %s", exception)
-        return None
-
-    # Contents is an XML file with contents like:
     #
-    # <EnumerationResults ContainerName="https://clrjit.blob.core.windows.net/superpmi/collections">
-    #   <Blobs>
-    #     <Blob>
-    #       <Name>jit-ee-guid/Linux/x64/Linux.x64.Checked.frameworks.mch.zip</Name>
-    #       <Url>https://clrjit.blob.core.windows.net/superpmi/collections/jit-ee-guid/Linux/x64/Linux.x64.Checked.frameworks.mch.zip</Url>
-    #       <Properties>
-    #         ...
-    #       </Properties>
-    #     </Blob>
-    #     <Blob>
-    #       <Name>jit-ee-guid/Linux/x64/Linux.x64.Checked.mch.zip</Name>
-    #       <Url>https://clrjit.blob.core.windows.net/superpmi/collections/jit-ee-guid/Linux/x64/Linux.x64.Checked.mch.zip</Url>
-    #     ... etc. ...
-    #   </Blobs>
-    # </EnumerationResults>
+    # Note that there is a maximum number of results returned in one query of 5000. So we might need to
+    # iterate. In that case, the XML result contains a `<NextMarker>` element like:
     #
-    # We just want to extract the <Url> entries. We could probably use an XML parsing package, but we just
-    # use regular expressions.
-
-    url_prefix = az_blob_storage_superpmi_container_uri + "/" + az_collections_root_folder + "/"
+    # <NextMarker>2!184!MDAwMDkyIWJ1aWxkcy8wMTZlYzI5OTAzMzkwMmY2ZTY4Yzg0YWMwYTNlYzkxN2Y5MzA0OTQ2L0xpbnV4L3g2NC9DaGVja2VkL2xpYmNscmppdF93aW5fYXJtNjRfeDY0LnNvITAwMDAyOCE5OTk5LTEyLTMxVDIzOjU5OjU5Ljk5OTk5OTlaIQ--</NextMarker>
+    #
+    # which we need to pass to the REST API with `marker=...`.
 
-    urls_split = contents.split("<Url>")[1:]
     paths = []
-    for item in urls_split:
-        url = item.split("</Url>")[0].strip()
-        path = remove_prefix(url, url_prefix)
-        if path_filter(path):
-            paths.append(path)
+
+    list_superpmi_container_uri_base = az_blob_storage_superpmi_container_uri + "?restype=container&comp=list&prefix=" + az_collections_root_folder + "/"
+
+    iter = 1
+    marker = ""
+
+    while True:
+        list_superpmi_container_uri = list_superpmi_container_uri_base + marker
+
+        try:
+            contents = urllib.request.urlopen(list_superpmi_container_uri).read().decode('utf-8')
+        except Exception as exception:
+            logging.error("Didn't find any collections using %s", list_superpmi_container_uri)
+            logging.error("  Error: %s", exception)
+            return None
+
+        # Contents is an XML file with contents like:
+        #
+        # <EnumerationResults ContainerName="https://clrjit.blob.core.windows.net/superpmi/collections">
+        #   <Blobs>
+        #     <Blob>
+        #       <Name>jit-ee-guid/Linux/x64/Linux.x64.Checked.frameworks.mch.zip</Name>
+        #       <Url>https://clrjit.blob.core.windows.net/superpmi/collections/jit-ee-guid/Linux/x64/Linux.x64.Checked.frameworks.mch.zip</Url>
+        #       <Properties>
+        #         ...
+        #       </Properties>
+        #     </Blob>
+        #     <Blob>
+        #       <Name>jit-ee-guid/Linux/x64/Linux.x64.Checked.mch.zip</Name>
+        #       <Url>https://clrjit.blob.core.windows.net/superpmi/collections/jit-ee-guid/Linux/x64/Linux.x64.Checked.mch.zip</Url>
+        #     ... etc. ...
+        #   </Blobs>
+        # </EnumerationResults>
+        #
+        # We just want to extract the <Url> entries. We could probably use an XML parsing package, but we just
+        # use regular expressions.
+
+        url_prefix = az_blob_storage_superpmi_container_uri + "/" + az_collections_root_folder + "/"
+
+        urls_split = contents.split("<Url>")[1:]
+        for item in urls_split:
+            url = item.split("</Url>")[0].strip()
+            path = remove_prefix(url, url_prefix)
+            if path_filter(path):
+                paths.append(path)
+
+        # Look for a continuation marker.
+        re_match = re.match(r'.*<NextMarker>(.*)</NextMarker>.*', contents)
+        if re_match:
+            marker_text = re_match.group(1)
+            marker = "&marker=" + marker_text
+            iter += 1
+        else:
+            break
 
     return paths
 
@@ -3234,7 +3228,7 @@ def setup_spmi_location_arg(spmi_location):
     log_file = None
     if coreclr_args.log_file is None:
         if hasattr(coreclr_args, "spmi_location"):
-            log_file = os.path.join(coreclr_args.spmi_location, "superpmi.log")
+            log_file = create_unique_file_name(coreclr_args.spmi_location, "superpmi", "log")
             if not os.path.isdir(coreclr_args.spmi_location):
                 os.makedirs(coreclr_args.spmi_location)
     else:
@@ -3411,11 +3405,6 @@ def verify_replay_common_args():
                             lambda unused: True,
                             "Unable to set pmi")
 
-        coreclr_args.verify(args,
-                            "crossgen",
-                            lambda unused: True,
-                            "Unable to set crossgen")
-
         coreclr_args.verify(args,
                             "crossgen2",
                             lambda unused: True,
@@ -3488,8 +3477,8 @@ def verify_replay_common_args():
                             lambda unused: True,
                             "Unable to set tiered_compilation")
 
-        if (args.collection_command is None) and (args.pmi is False) and (args.crossgen is False) and (args.crossgen2 is False):
-            print("Either a collection command or `--pmi` or `--crossgen` or `--crossgen2` must be specified")
+        if (args.collection_command is None) and (args.pmi is False) and (args.crossgen2 is False):
+            print("Either a collection command or `--pmi` or `--crossgen2` must be specified")
             sys.exit(1)
 
         if (args.collection_command is not None) and (len(args.assemblies) > 0):
@@ -3500,13 +3489,13 @@ def verify_replay_common_args():
             print("Don't specify `-exclude` if a collection command is given")
             sys.exit(1)
 
-        if ((args.pmi is True) or (args.crossgen is True) or (args.crossgen2 is True)) and (len(args.assemblies) == 0):
-            print("Specify `-assemblies` if `--pmi` or `--crossgen` or `--crossgen2` is given")
+        if ((args.pmi is True) or (args.crossgen2 is True)) and (len(args.assemblies) == 0):
+            print("Specify `-assemblies` if `--pmi` or `--crossgen2` is given")
             sys.exit(1)
 
         if args.collection_command is None and args.merge_mch_files is not True:
             assert args.collection_args is None
-            assert (args.pmi is True) or (args.crossgen is True) or (args.crossgen2 is True)
+            assert (args.pmi is True) or (args.crossgen2 is True)
             assert len(args.assemblies) > 0
 
         if coreclr_args.merge_mch_files:
diff --git a/src/coreclr/scripts/superpmi_setup.py b/src/coreclr/scripts/superpmi_setup.py
index e4b9b638d8c3f8..7fd7d62b256009 100644
--- a/src/coreclr/scripts/superpmi_setup.py
+++ b/src/coreclr/scripts/superpmi_setup.py
@@ -28,7 +28,7 @@
 # | x86   | Windows.10.Amd64.X86 |                                                                                                                                      |
 # | x64   | Windows.10.Amd64.X86 | Ubuntu.1804.Amd64                                                                                                                    |
 # | arm   | -                    | (Ubuntu.1804.Arm32)Ubuntu.1804.Armarch@mcr.microsoft.com/dotnet-buildtools/prereqs:ubuntu-18.04-helix-arm32v7-bfcd90a-20200121150440 |
-# | arm64 | Windows.10.Arm64     | (Ubuntu.1804.Arm64)Ubuntu.1804.ArmArch@mcr.microsoft.com/dotnet-buildtools/prereqs:ubuntu-18.04-helix-arm64v8-a45aeeb-20190620155855 |
+# | arm64 | Windows.10.Arm64     | (Ubuntu.1804.Arm64)Ubuntu.1804.ArmArch@mcr.microsoft.com/dotnet-buildtools/prereqs:ubuntu-18.04-helix-arm64v8-20210531091519-97d8652 |
 ################################################################################
 ################################################################################
 
@@ -59,6 +59,46 @@
 is_windows = platform.system() == "Windows"
 
 native_binaries_to_ignore = [
+    "api-ms-win-core-console-l1-1-0.dll",
+    "api-ms-win-core-datetime-l1-1-0.dll",
+    "api-ms-win-core-debug-l1-1-0.dll",
+    "api-ms-win-core-errorhandling-l1-1-0.dll",
+    "api-ms-win-core-file-l1-1-0.dll",
+    "api-ms-win-core-file-l1-2-0.dll",
+    "api-ms-win-core-file-l2-1-0.dll",
+    "api-ms-win-core-handle-l1-1-0.dll",
+    "api-ms-win-core-heap-l1-1-0.dll",
+    "api-ms-win-core-interlocked-l1-1-0.dll",
+    "api-ms-win-core-libraryloader-l1-1-0.dll",
+    "api-ms-win-core-localization-l1-2-0.dll",
+    "api-ms-win-core-memory-l1-1-0.dll",
+    "api-ms-win-core-namedpipe-l1-1-0.dll",
+    "api-ms-win-core-processenvironment-l1-1-0.dll",
+    "api-ms-win-core-processthreads-l1-1-0.dll",
+    "api-ms-win-core-processthreads-l1-1-1.dll",
+    "api-ms-win-core-profile-l1-1-0.dll",
+    "api-ms-win-core-rtlsupport-l1-1-0.dll",
+    "api-ms-win-core-string-l1-1-0.dll",
+    "api-ms-win-core-synch-l1-1-0.dll",
+    "api-ms-win-core-synch-l1-2-0.dll",
+    "api-ms-win-core-sysinfo-l1-1-0.dll",
+    "api-ms-win-core-timezone-l1-1-0.dll",
+    "api-ms-win-core-util-l1-1-0.dll",
+    "api-ms-win-crt-conio-l1-1-0.dll",
+    "api-ms-win-crt-convert-l1-1-0.dll",
+    "api-ms-win-crt-environment-l1-1-0.dll",
+    "api-ms-win-crt-filesystem-l1-1-0.dll",
+    "api-ms-win-crt-heap-l1-1-0.dll",
+    "api-ms-win-crt-locale-l1-1-0.dll",
+    "api-ms-win-crt-math-l1-1-0.dll",
+    "api-ms-win-crt-multibyte-l1-1-0.dll",
+    "api-ms-win-crt-private-l1-1-0.dll",
+    "api-ms-win-crt-process-l1-1-0.dll",
+    "api-ms-win-crt-runtime-l1-1-0.dll",
+    "api-ms-win-crt-stdio-l1-1-0.dll",
+    "api-ms-win-crt-string-l1-1-0.dll",
+    "api-ms-win-crt-time-l1-1-0.dll",
+    "api-ms-win-crt-utility-l1-1-0.dll",
     "clretwrc.dll",
     "clrgc.dll",
     "clrjit.dll",
@@ -68,6 +108,9 @@
     "clrjit_unix_arm_x86.dll",
     "clrjit_unix_arm64_arm64.dll",
     "clrjit_unix_arm64_x64.dll",
+    "clrjit_unix_armel_arm.dll",
+    "clrjit_unix_armel_arm64.dll",
+    "clrjit_unix_armel_x64.dll",
     "clrjit_unix_armel_x86.dll",
     "clrjit_unix_osx_arm64_arm64.dll",
     "clrjit_unix_osx_arm64_x64.dll",
@@ -92,6 +135,7 @@
     "CoreShim.dll",
     "createdump.exe",
     "crossgen.exe",
+    "crossgen2.exe",
     "dbgshim.dll",
     "ilasm.exe",
     "ildasm.exe",
@@ -108,12 +152,15 @@
     "mscordbi.dll",
     "mscorrc.dll",
     "msdia140.dll",
+    "R2RDump.exe",
+    "R2RTest.exe",
     "superpmi.exe",
     "superpmi-shim-collector.dll",
     "superpmi-shim-counter.dll",
     "superpmi-shim-simple.dll",
     "System.IO.Compression.Native.dll",
     "ucrtbase.dll",
+    "xunit.console.exe",
 ]
 
 MAX_FILES_COUNT = 1500
@@ -202,7 +249,9 @@ def sorter_by_size(pair):
         # Credit: https://stackoverflow.com/a/19859907
         dirs[:] = [d for d in dirs if d not in exclude_directories]
         for name in files:
-            if name in exclude_files:
+            # Make the exclude check case-insensitive
+            exclude_files_lower = [filename.lower() for filename in exclude_files]
+            if name.lower() in exclude_files_lower:
                 continue
             curr_file_path = path.join(file_path, name)
 
@@ -443,7 +492,7 @@ def main(main_args):
         if arch == "arm":
             helix_queue = "(Ubuntu.1804.Arm32)Ubuntu.1804.Armarch@mcr.microsoft.com/dotnet-buildtools/prereqs:ubuntu-18.04-helix-arm32v7-bfcd90a-20200121150440"
         elif arch == "arm64":
-            helix_queue = "(Ubuntu.1804.Arm64)Ubuntu.1804.ArmArch@mcr.microsoft.com/dotnet-buildtools/prereqs:ubuntu-18.04-helix-arm64v8-a45aeeb-20190620155855"
+            helix_queue = "(Ubuntu.1804.Arm64)Ubuntu.1804.ArmArch@mcr.microsoft.com/dotnet-buildtools/prereqs:ubuntu-18.04-helix-arm64v8-20210531091519-97d8652"
         else:
             helix_queue = "Ubuntu.1804.Amd64"
 
diff --git a/src/coreclr/tools/CMakeLists.txt b/src/coreclr/tools/CMakeLists.txt
index e2e3083136be4f..8bc7696b332ddc 100644
--- a/src/coreclr/tools/CMakeLists.txt
+++ b/src/coreclr/tools/CMakeLists.txt
@@ -1,4 +1,3 @@
-add_subdirectory(crossgen)
 if (CLR_CMAKE_TARGET_WIN32 AND NOT CLR_CMAKE_CROSS_ARCH)
   add_subdirectory(GenClrDebugResource)
   add_subdirectory(InjectResource)
diff --git a/src/coreclr/tools/Common/Compiler/DevirtualizationManager.cs b/src/coreclr/tools/Common/Compiler/DevirtualizationManager.cs
index 6b2ff1b95cfaae..aba41341a27095 100644
--- a/src/coreclr/tools/Common/Compiler/DevirtualizationManager.cs
+++ b/src/coreclr/tools/Common/Compiler/DevirtualizationManager.cs
@@ -1,8 +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;
 using Internal.TypeSystem;
-
+using CORINFO_DEVIRTUALIZATION_DETAIL = Internal.JitInterface.CORINFO_DEVIRTUALIZATION_DETAIL;
 using Debug = System.Diagnostics.Debug;
 
 namespace ILCompiler
@@ -53,17 +54,19 @@ public virtual bool IsEffectivelySealed(MethodDesc method)
         /// Note that if <paramref name="implType"/> is a value type, the result of the resolution
         /// might have to be treated as an unboxing thunk by the caller.
         /// </remarks>
-        public MethodDesc ResolveVirtualMethod(MethodDesc declMethod, TypeDesc implType)
+        public MethodDesc ResolveVirtualMethod(MethodDesc declMethod, TypeDesc implType, out CORINFO_DEVIRTUALIZATION_DETAIL devirtualizationDetail)
         {
             Debug.Assert(declMethod.IsVirtual);
 
             // We're operating on virtual methods. This means that if implType is an array, we need
             // to get the type that has all the virtual methods provided by the class library.
-            return ResolveVirtualMethod(declMethod, implType.GetClosestDefType());
+            return ResolveVirtualMethod(declMethod, implType.GetClosestDefType(), out devirtualizationDetail);
         }
 
-        protected virtual MethodDesc ResolveVirtualMethod(MethodDesc declMethod, DefType implType)
+        protected virtual MethodDesc ResolveVirtualMethod(MethodDesc declMethod, DefType implType, out CORINFO_DEVIRTUALIZATION_DETAIL devirtualizationDetail)
         {
+            devirtualizationDetail = CORINFO_DEVIRTUALIZATION_DETAIL.CORINFO_DEVIRTUALIZATION_UNKNOWN;
+
             MethodDesc impl;
 
             if (declMethod.OwningType.IsInterface)
@@ -84,20 +87,97 @@ protected virtual MethodDesc ResolveVirtualMethod(MethodDesc declMethod, DefType
                             {
                                 // We cannot resolve the interface as we don't know with exact enough detail which interface
                                 // of multiple possible interfaces is being called.
+                                devirtualizationDetail = CORINFO_DEVIRTUALIZATION_DETAIL.CORINFO_DEVIRTUALIZATION_MULTIPLE_IMPL;
                                 return null;
                             }
                         }
                     }
                 }
 
-                impl = implType.ResolveInterfaceMethodTarget(declMethod);
+                if (!implType.CanCastTo(declMethod.OwningType))
+                {
+                    devirtualizationDetail = CORINFO_DEVIRTUALIZATION_DETAIL.CORINFO_DEVIRTUALIZATION_FAILED_CAST;
+                    return null;
+                }
+
+                impl = implType.ResolveInterfaceMethodTargetWithVariance(declMethod);
                 if (impl != null)
                 {
                     impl = implType.FindVirtualFunctionTargetMethodOnObjectType(impl);
                 }
+                else
+                {
+                    MethodDesc dimMethod = null;
+                    // This isn't the correct lookup algorithm for variant default interface methods
+                    // but as we will drop any results we find in any case, it doesn't matter much.
+                    // Non-variant dispatch can simply use ResolveInterfaceMethodToDefaultImplementationOnType
+                    // but that implemenation currently cannot handle variance.
+
+                    MethodDesc defaultInterfaceDispatchDeclMethod = null;
+                    foreach (TypeDesc iface in implType.RuntimeInterfaces)
+                    {
+                        if (iface == declMethod.OwningType)
+                        {
+                            defaultInterfaceDispatchDeclMethod = declMethod;
+                            break;
+                        }
+                        if (iface.HasSameTypeDefinition(declMethod.OwningType) && iface.CanCastTo(declMethod.OwningType))
+                        {
+                            defaultInterfaceDispatchDeclMethod = iface.FindMethodOnTypeWithMatchingTypicalMethod(declMethod);
+                            // Prefer to find the exact match, so don't break immediately
+                        }
+                    }
+
+                    if (defaultInterfaceDispatchDeclMethod != null)
+                    {
+                        switch (implType.ResolveInterfaceMethodToDefaultImplementationOnType(defaultInterfaceDispatchDeclMethod, out dimMethod))
+                        {
+                            case DefaultInterfaceMethodResolution.Diamond:
+                            case DefaultInterfaceMethodResolution.Reabstraction:
+                                devirtualizationDetail = CORINFO_DEVIRTUALIZATION_DETAIL.CORINFO_DEVIRTUALIZATION_FAILED_DIM;
+                                return null;
+
+                            case DefaultInterfaceMethodResolution.DefaultImplementation:
+                                if (dimMethod.OwningType.HasInstantiation || (declMethod != defaultInterfaceDispatchDeclMethod))
+                                {
+                                    // If we devirtualized into a default interface method on a generic type, we should actually return an
+                                    // instantiating stub but this is not happening.
+                                    // Making this work is tracked by https://github.com/dotnet/runtime/issues/9588
+
+                                    // In addition, we fail here for variant default interface dispatch
+                                    devirtualizationDetail = CORINFO_DEVIRTUALIZATION_DETAIL.CORINFO_DEVIRTUALIZATION_FAILED_DIM;
+                                    return null;
+                                }
+                                else
+                                {
+                                    impl = dimMethod;
+                                }
+                                break;
+                        }
+                    }
+                }
             }
             else
             {
+                // The derived class should be a subclass of the the base class.
+                // this check is perfomed via typedef checking instead of casting, as we accept canon methods calling exact types
+                TypeDesc checkType;
+                for (checkType = implType; checkType != null && !checkType.HasSameTypeDefinition(declMethod.OwningType); checkType = checkType.BaseType)
+                { }
+
+                if ((checkType == null) || (checkType.ConvertToCanonForm(CanonicalFormKind.Specific) != declMethod.OwningType.ConvertToCanonForm(CanonicalFormKind.Specific)))
+                {
+                    // The derived class should be a subclass of the the base class.
+                    devirtualizationDetail = CORINFO_DEVIRTUALIZATION_DETAIL.CORINFO_DEVIRTUALIZATION_FAILED_SUBCLASS;
+                    return null;
+                }
+                else
+                {
+                    // At this point, the decl method may be only canonically compatible, but not an exact match to a method in the type hierarchy
+                    // Convert it to an exact match. (Or if it is an exact match, the FindMethodOnTypeWithMatchingTypicalMethod will be a no-op)
+                    declMethod = checkType.FindMethodOnTypeWithMatchingTypicalMethod(declMethod);
+                }
+
                 impl = implType.FindVirtualFunctionTargetMethodOnObjectType(declMethod);
                 if (impl != null && (impl != declMethod))
                 {
@@ -106,7 +186,14 @@ protected virtual MethodDesc ResolveVirtualMethod(MethodDesc declMethod, DefType
 
                     if (slotDefiningMethodImpl != slotDefiningMethodDecl)
                     {
-                        // We cannot resolve virtual method in case the impl is a different slot from the declMethod
+                        // If the derived method's slot does not match the vtable slot,
+                        // bail on devirtualization, as the method was installed into
+                        // the vtable slot via an explicit override and even if the
+                        // method is final, the slot may not be.
+                        //
+                        // Note the jit could still safely devirtualize if it had an exact
+                        // class, but such cases are likely rare.
+                        devirtualizationDetail = CORINFO_DEVIRTUALIZATION_DETAIL.CORINFO_DEVIRTUALIZATION_FAILED_SLOT;
                         impl = null;
                     }
                 }
diff --git a/src/coreclr/tools/Common/Internal/Runtime/ModuleHeaders.cs b/src/coreclr/tools/Common/Internal/Runtime/ModuleHeaders.cs
index feacb0ba06d5d9..eee208cfb2de0f 100644
--- a/src/coreclr/tools/Common/Internal/Runtime/ModuleHeaders.cs
+++ b/src/coreclr/tools/Common/Internal/Runtime/ModuleHeaders.cs
@@ -15,7 +15,7 @@ internal struct ReadyToRunHeaderConstants
         public const uint Signature = 0x00525452; // 'RTR'
 
         public const ushort CurrentMajorVersion = 5;
-        public const ushort CurrentMinorVersion = 3;
+        public const ushort CurrentMinorVersion = 4;
     }
 
 #pragma warning disable 0169
diff --git a/src/coreclr/tools/Common/Internal/Runtime/ReadyToRunConstants.cs b/src/coreclr/tools/Common/Internal/Runtime/ReadyToRunConstants.cs
index fe2c5a9bd4a1d7..6f718756b205fb 100644
--- a/src/coreclr/tools/Common/Internal/Runtime/ReadyToRunConstants.cs
+++ b/src/coreclr/tools/Common/Internal/Runtime/ReadyToRunConstants.cs
@@ -4,6 +4,9 @@
 using System;
 using Internal.TypeSystem;
 
+// If any of these constants change, update src/coreclr/inc/readytorun.h and
+// src/coreclr/tools/Common/Internal/Runtime/ModuleHeaders.cs with the new R2R minor version
+
 namespace Internal.ReadyToRunConstants
 {
     [Flags]
@@ -31,6 +34,7 @@ public enum ReadyToRunMethodSigFlags : byte
         READYTORUN_METHOD_SIG_MemberRefToken = 0x10,
         READYTORUN_METHOD_SIG_Constrained = 0x20,
         READYTORUN_METHOD_SIG_OwnerType = 0x40,
+        READYTORUN_METHOD_SIG_UpdateContext = 0x80,
     }
 
     [Flags]
@@ -51,6 +55,13 @@ public enum ReadyToRunTypeLayoutFlags : byte
         READYTORUN_LAYOUT_GCLayout_Empty = 0x10,
     }
 
+    [Flags]
+    public enum ReadyToRunVirtualFunctionOverrideFlags : uint
+    {
+        None = 0x00,
+        VirtualFunctionOverriden = 0x01,
+    }
+
     public enum DictionaryEntryKind
     {
         EmptySlot = 0,
@@ -121,6 +132,9 @@ public enum ReadyToRunFixupKind
         Verify_FieldOffset = 0x31,  // Generate a runtime check to ensure that the field offset matches between compile and runtime. Unlike CheckFieldOffset, this will generate a runtime exception on failure instead of silently dropping the method
         Verify_TypeLayout = 0x32,  // Generate a runtime check to ensure that the type layout (size, alignment, HFA, reference map) matches between compile and runtime. Unlike Check_TypeLayout, this will generate a runtime failure instead of silently dropping the method
 
+        Check_VirtualFunctionOverride = 0x33, // Generate a runtime check to ensure that virtual function resolution has equivalent behavior at runtime as at compile time. If not equivalent, code will not be used
+        Verify_VirtualFunctionOverride = 0x34, // Generate a runtime check to ensure that virtual function resolution has equivalent behavior at runtime as at compile time. If not equivalent, generate runtime failure.
+
         ModuleOverride = 0x80,
         // followed by sig-encoded UInt with assemblyref index into either the assemblyref
         // table of the MSIL metadata of the master context module for the signature or
diff --git a/src/coreclr/tools/Common/JitInterface/CorInfoImpl.cs b/src/coreclr/tools/Common/JitInterface/CorInfoImpl.cs
index 43991db1ef644f..f102d06976af10 100644
--- a/src/coreclr/tools/Common/JitInterface/CorInfoImpl.cs
+++ b/src/coreclr/tools/Common/JitInterface/CorInfoImpl.cs
@@ -561,8 +561,8 @@ private Object HandleToObject(IntPtr handle)
         private CORINFO_CLASS_STRUCT_* ObjectToHandle(TypeDesc type) => (CORINFO_CLASS_STRUCT_*)ObjectToHandle((Object)type);
         private FieldDesc HandleToObject(CORINFO_FIELD_STRUCT_* field) => (FieldDesc)HandleToObject((IntPtr)field);
         private CORINFO_FIELD_STRUCT_* ObjectToHandle(FieldDesc field) => (CORINFO_FIELD_STRUCT_*)ObjectToHandle((object)field);
-        private MethodIL HandleToObject(CORINFO_MODULE_STRUCT_* module) => (MethodIL)HandleToObject((IntPtr)module);
-        private CORINFO_MODULE_STRUCT_* ObjectToHandle(MethodIL methodIL) => (CORINFO_MODULE_STRUCT_*)ObjectToHandle((object)methodIL);
+        private MethodILScope HandleToObject(CORINFO_MODULE_STRUCT_* module) => (MethodIL)HandleToObject((IntPtr)module);
+        private CORINFO_MODULE_STRUCT_* ObjectToHandle(MethodILScope methodIL) => (CORINFO_MODULE_STRUCT_*)ObjectToHandle((object)methodIL);
         private MethodSignature HandleToObject(MethodSignatureInfo* method) => (MethodSignature)HandleToObject((IntPtr)method);
         private MethodSignatureInfo* ObjectToHandle(MethodSignature method) => (MethodSignatureInfo*)ObjectToHandle((object)method);
 
@@ -1138,12 +1138,14 @@ private bool resolveVirtualMethod(CORINFO_DEVIRTUALIZATION_INFO* info)
             info->devirtualizedMethod = null;
             info->requiresInstMethodTableArg = false;
             info->exactContext = null;
+            info->detail = CORINFO_DEVIRTUALIZATION_DETAIL.CORINFO_DEVIRTUALIZATION_UNKNOWN;
 
             TypeDesc objType = HandleToObject(info->objClass);
 
             // __Canon cannot be devirtualized
             if (objType.IsCanonicalDefinitionType(CanonicalFormKind.Any))
             {
+                info->detail = CORINFO_DEVIRTUALIZATION_DETAIL.CORINFO_DEVIRTUALIZATION_FAILED_CANON;
                 return false;
             }
 
@@ -1160,23 +1162,141 @@ private bool resolveVirtualMethod(CORINFO_DEVIRTUALIZATION_INFO* info)
                 }
             }
 
-            MethodDesc impl = _compilation.ResolveVirtualMethod(decl, objType);
+            MethodDesc originalImpl = _compilation.ResolveVirtualMethod(decl, objType, out info->detail);
 
-            if (impl == null)
+            if (originalImpl == null)
             {
+                // If this assert fires, we failed to devirtualize, probably due to a failure to resolve the
+                // virtual to an exact target. This should never happen in practice if the input IL is valid,
+                // and the algorithm for virtual function resolution is correct; however, if it does, this is
+                // a safe condition, and we could delete this assert. This assert exists in order to help identify
+                // cases where the virtual function resolution algorithm either does not function, or is not used
+                // correctly.
+#if DEBUG
+                if (info->detail == CORINFO_DEVIRTUALIZATION_DETAIL.CORINFO_DEVIRTUALIZATION_UNKNOWN)
+                {
+                    Console.Error.WriteLine($"Failed devirtualization with unexpected unknown failure while compiling {MethodBeingCompiled} with decl {decl} targetting type {objType}");
+                    Debug.Assert(info->detail != CORINFO_DEVIRTUALIZATION_DETAIL.CORINFO_DEVIRTUALIZATION_UNKNOWN);
+                }
+#endif
                 return false;
             }
 
-            if (impl.OwningType.IsValueType)
+            TypeDesc owningType = originalImpl.OwningType;
+
+            // RyuJIT expects to get the canonical form back
+            MethodDesc impl = originalImpl.GetCanonMethodTarget(CanonicalFormKind.Specific);
+
+            bool unboxingStub = impl.OwningType.IsValueType;
+
+            MethodDesc nonUnboxingImpl = impl;
+            if (unboxingStub)
             {
                 impl = getUnboxingThunk(impl);
             }
 
+#if READYTORUN
+            // As there are a variety of situations where the resolved virtual method may be different at compile and runtime (primarily due to subtle differences
+            // in the virtual resolution algorithm between the runtime and the compiler, although details such as whether or not type equivalence is enabled
+            // can also have an effect), record any decisions made, and if there are differences, simply skip use of the compiled method.
+            var resolver = _compilation.NodeFactory.Resolver;
+
+            MethodWithToken methodWithTokenDecl;
+
+            if (info->pResolvedTokenVirtualMethod != null)
+            {
+                methodWithTokenDecl = ComputeMethodWithToken(decl, ref *info->pResolvedTokenVirtualMethod, null, false);
+            }
+            else
+            {
+                ModuleToken declToken = resolver.GetModuleTokenForMethod(decl.GetTypicalMethodDefinition(), throwIfNotFound: false);
+                if (declToken.IsNull)
+                {
+                    info->detail = CORINFO_DEVIRTUALIZATION_DETAIL.CORINFO_DEVIRTUALIZATION_FAILED_DECL_NOT_REPRESENTABLE;
+                    return false;
+                }
+                if (!_compilation.CompilationModuleGroup.VersionsWithTypeReference(decl.OwningType))
+                {
+                    info->detail = CORINFO_DEVIRTUALIZATION_DETAIL.CORINFO_DEVIRTUALIZATION_FAILED_DECL_NOT_REPRESENTABLE;
+                    return false;
+                }
+                methodWithTokenDecl = new MethodWithToken(decl, declToken, null, false, null, devirtualizedMethodOwner: decl.OwningType);
+            }
+            MethodWithToken methodWithTokenImpl;
+
+            if (decl == originalImpl)
+            {
+                methodWithTokenImpl = methodWithTokenDecl;
+                if (info->pResolvedTokenVirtualMethod != null)
+                {
+                    info->resolvedTokenDevirtualizedMethod = *info->pResolvedTokenVirtualMethod;
+                }
+                else
+                {
+                    info->resolvedTokenDevirtualizedMethod = CreateResolvedTokenFromMethod(this, decl, methodWithTokenDecl);
+                }
+                info->resolvedTokenDevirtualizedUnboxedMethod = default(CORINFO_RESOLVED_TOKEN);
+            }
+            else
+            {
+                methodWithTokenImpl = new MethodWithToken(nonUnboxingImpl, resolver.GetModuleTokenForMethod(nonUnboxingImpl.GetTypicalMethodDefinition()), null, unboxingStub, null, devirtualizedMethodOwner: impl.OwningType);
+
+                info->resolvedTokenDevirtualizedMethod = CreateResolvedTokenFromMethod(this, impl, methodWithTokenImpl);
+
+                if (unboxingStub)
+                {
+                    info->resolvedTokenDevirtualizedUnboxedMethod = info->resolvedTokenDevirtualizedMethod;
+                    info->resolvedTokenDevirtualizedUnboxedMethod.tokenContext = contextFromMethod(nonUnboxingImpl);
+                    info->resolvedTokenDevirtualizedUnboxedMethod.hMethod = ObjectToHandle(nonUnboxingImpl);
+                }
+                else
+                {
+                    info->resolvedTokenDevirtualizedUnboxedMethod = default(CORINFO_RESOLVED_TOKEN);
+                }
+            }
+
+            // Testing has not shown that concerns about virtual matching are significant
+            // Only generate verification for builds with the stress mode enabled
+            if (_compilation.SymbolNodeFactory.VerifyTypeAndFieldLayout)
+            {
+                ISymbolNode virtualResolutionNode = _compilation.SymbolNodeFactory.CheckVirtualFunctionOverride(methodWithTokenDecl, objType, methodWithTokenImpl);
+                _methodCodeNode.Fixups.Add(virtualResolutionNode);
+            }
+#else
+            info->resolvedTokenDevirtualizedMethod = default(CORINFO_RESOLVED_TOKEN);
+            info->resolvedTokenDevirtualizedUnboxedMethod = default(CORINFO_RESOLVED_TOKEN);
+#endif
+            info->detail = CORINFO_DEVIRTUALIZATION_DETAIL.CORINFO_DEVIRTUALIZATION_SUCCESS;
             info->devirtualizedMethod = ObjectToHandle(impl);
             info->requiresInstMethodTableArg = false;
-            info->exactContext = contextFromType(impl.OwningType);
+            info->exactContext = contextFromType(owningType);
 
             return true;
+
+#if READYTORUN
+            static CORINFO_RESOLVED_TOKEN CreateResolvedTokenFromMethod(CorInfoImpl jitInterface, MethodDesc method, MethodWithToken methodWithToken)
+            {
+                CORINFO_RESOLVED_TOKEN result = default(CORINFO_RESOLVED_TOKEN);
+                MethodILScope scope = jitInterface._compilation.GetMethodIL(methodWithToken.Method);
+                if (scope == null)
+                {
+                    scope = Internal.IL.EcmaMethodILScope.Create((EcmaMethod)methodWithToken.Method.GetTypicalMethodDefinition());
+                }
+                result.tokenScope = jitInterface.ObjectToHandle(scope);
+                result.tokenContext = jitInterface.contextFromMethod(method);
+                result.token = methodWithToken.Token.Token;
+                if (methodWithToken.Token.TokenType != CorTokenType.mdtMethodDef)
+                {
+                    Debug.Assert(false); // This should never happen, but we protect against total failure with the throw below.
+                    throw new RequiresRuntimeJitException("Attempt to devirtualize and unable to create token for devirtualized method");
+                }
+                result.tokenType = CorInfoTokenKind.CORINFO_TOKENKIND_DevirtualizedMethod;
+                result.hClass = jitInterface.ObjectToHandle(methodWithToken.OwningType);
+                result.hMethod = jitInterface.ObjectToHandle(method);
+
+                return result;
+            }
+#endif
         }
 
         private CORINFO_METHOD_STRUCT_* getUnboxedEntry(CORINFO_METHOD_STRUCT_* ftn, ref bool requiresInstMethodTableArg)
@@ -1331,11 +1451,11 @@ private void methodMustBeLoadedBeforeCodeIsRun(CORINFO_METHOD_STRUCT_* method)
         private CORINFO_METHOD_STRUCT_* mapMethodDeclToMethodImpl(CORINFO_METHOD_STRUCT_* method)
         { throw new NotImplementedException("mapMethodDeclToMethodImpl"); }
 
-        private static object ResolveTokenWithSubstitution(MethodIL methodIL, mdToken token, Instantiation typeInst, Instantiation methodInst)
+        private static object ResolveTokenWithSubstitution(MethodILScope methodIL, mdToken token, Instantiation typeInst, Instantiation methodInst)
         {
             // Grab the generic definition of the method IL, resolve the token within the definition,
             // and instantiate it with the given context.
-            object result = methodIL.GetMethodILDefinition().GetObject((int)token);
+            object result = methodIL.GetMethodILScopeDefinition().GetObject((int)token);
 
             if (result is MethodDesc methodResult)
             {
@@ -1353,7 +1473,7 @@ private static object ResolveTokenWithSubstitution(MethodIL methodIL, mdToken to
             return result;
         }
 
-        private static object ResolveTokenInScope(MethodIL methodIL, object typeOrMethodContext, mdToken token)
+        private static object ResolveTokenInScope(MethodILScope methodIL, object typeOrMethodContext, mdToken token)
         {
             MethodDesc owningMethod = methodIL.OwningMethod;
 
@@ -1445,7 +1565,7 @@ private object GetRuntimeDeterminedObjectForToken(ref CORINFO_RESOLVED_TOKEN pRe
                         /* If the resolved type is not runtime determined there's a chance we went down this path
                            because there was a literal typeof(__Canon) in the compiled IL - check for that
                            by resolving the token in the definition. */
-                        ((TypeDesc)methodIL.GetMethodILDefinition().GetObject((int)pResolvedToken.token)).IsCanonicalDefinitionType(CanonicalFormKind.Any));
+                        ((TypeDesc)methodIL.GetMethodILScopeDefinition().GetObject((int)pResolvedToken.token)).IsCanonicalDefinitionType(CanonicalFormKind.Any));
                 }
 
                 if (pResolvedToken.tokenType == CorInfoTokenKind.CORINFO_TOKENKIND_Newarr)
@@ -1473,9 +1593,8 @@ private void resolveToken(ref CORINFO_RESOLVED_TOKEN pResolvedToken)
             bool recordToken = _compilation.CompilationModuleGroup.VersionsWithType(owningType) && owningType is EcmaType;
 #endif
 
-            if (result is MethodDesc)
+            if (result is MethodDesc method)
             {
-                MethodDesc method = result as MethodDesc;
                 pResolvedToken.hMethod = ObjectToHandle(method);
 
                 TypeDesc owningClass = method.OwningType;
@@ -1488,7 +1607,9 @@ private void resolveToken(ref CORINFO_RESOLVED_TOKEN pResolvedToken)
 #if READYTORUN
                 if (recordToken)
                 {
-                    _compilation.NodeFactory.Resolver.AddModuleTokenForMethod(method, HandleToModuleToken(ref pResolvedToken));
+                    ModuleToken methodModuleToken = HandleToModuleToken(ref pResolvedToken);
+                    var resolver = _compilation.NodeFactory.Resolver;
+                    resolver.AddModuleTokenForMethod(method, methodModuleToken);
                 }
 #else
                 _compilation.NodeFactory.MetadataManager.GetDependenciesDueToAccess(ref _additionalDependencies, _compilation.NodeFactory, methodIL, method);
@@ -1612,7 +1733,7 @@ private bool isValidStringRef(CORINFO_MODULE_STRUCT_* module, uint metaTOK)
 
         private char* getStringLiteral(CORINFO_MODULE_STRUCT_* module, uint metaTOK, ref int length)
         {
-            MethodIL methodIL = HandleToObject(module);
+            MethodILScope methodIL = HandleToObject(module);
             string s = (string)methodIL.GetObject((int)metaTOK);
             length = (int)s.Length;
             return (char*)GetPin(s);
diff --git a/src/coreclr/tools/Common/JitInterface/CorInfoTypes.cs b/src/coreclr/tools/Common/JitInterface/CorInfoTypes.cs
index 91114435396e75..73f7a5f4eef7c1 100644
--- a/src/coreclr/tools/Common/JitInterface/CorInfoTypes.cs
+++ b/src/coreclr/tools/Common/JitInterface/CorInfoTypes.cs
@@ -1072,17 +1072,24 @@ public unsafe struct CORINFO_CALL_INFO
 
     public enum CORINFO_DEVIRTUALIZATION_DETAIL
     {
-        CORINFO_DEVIRTUALIZATION_UNKNOWN,         // no details available
-        CORINFO_DEVIRTUALIZATION_SUCCESS,         // devirtualization was successful
-        CORINFO_DEVIRTUALIZATION_FAILED_CANON,    // object class was canonical
-        CORINFO_DEVIRTUALIZATION_FAILED_COM,      // object class was com
-        CORINFO_DEVIRTUALIZATION_FAILED_CAST,     // object class could not be cast to interface class
-        CORINFO_DEVIRTUALIZATION_FAILED_LOOKUP,   // interface method could not be found
-        CORINFO_DEVIRTUALIZATION_FAILED_DIM,      // interface method was default interface method
-        CORINFO_DEVIRTUALIZATION_FAILED_SUBCLASS, // object not subclass of base class
-        CORINFO_DEVIRTUALIZATION_FAILED_SLOT,     // virtual method installed via explicit override
-        CORINFO_DEVIRTUALIZATION_FAILED_BUBBLE,   // devirtualization crossed version bubble
-        CORINFO_DEVIRTUALIZATION_COUNT,           // sentinel for maximum value
+        CORINFO_DEVIRTUALIZATION_UNKNOWN,                              // no details available
+        CORINFO_DEVIRTUALIZATION_SUCCESS,                              // devirtualization was successful
+        CORINFO_DEVIRTUALIZATION_FAILED_CANON,                         // object class was canonical
+        CORINFO_DEVIRTUALIZATION_FAILED_COM,                           // object class was com
+        CORINFO_DEVIRTUALIZATION_FAILED_CAST,                          // object class could not be cast to interface class
+        CORINFO_DEVIRTUALIZATION_FAILED_LOOKUP,                        // interface method could not be found
+        CORINFO_DEVIRTUALIZATION_FAILED_DIM,                           // interface method was default interface method
+        CORINFO_DEVIRTUALIZATION_FAILED_SUBCLASS,                      // object not subclass of base class
+        CORINFO_DEVIRTUALIZATION_FAILED_SLOT,                          // virtual method installed via explicit override
+        CORINFO_DEVIRTUALIZATION_FAILED_BUBBLE,                        // devirtualization crossed version bubble
+        CORINFO_DEVIRTUALIZATION_MULTIPLE_IMPL,                        // object has multiple implementations of interface class
+        CORINFO_DEVIRTUALIZATION_FAILED_BUBBLE_CLASS_DECL,             // decl method is defined on class and decl method not in version bubble, and decl method not in closest to version bubble
+        CORINFO_DEVIRTUALIZATION_FAILED_BUBBLE_INTERFACE_DECL,         // decl method is defined on interface and not in version bubble, and implementation type not entirely defined in bubble
+        CORINFO_DEVIRTUALIZATION_FAILED_BUBBLE_IMPL,                   // object class not defined within version bubble
+        CORINFO_DEVIRTUALIZATION_FAILED_BUBBLE_IMPL_NOT_REFERENCEABLE, // object class cannot be referenced from R2R code due to missing tokens
+        CORINFO_DEVIRTUALIZATION_FAILED_DUPLICATE_INTERFACE,           // crossgen2 virtual method algorithm and runtime algorithm differ in the presence of duplicate interface implementations
+        CORINFO_DEVIRTUALIZATION_FAILED_DECL_NOT_REPRESENTABLE,        // Decl method cannot be represented in R2R image
+        CORINFO_DEVIRTUALIZATION_COUNT,                                // sentinel for maximum value
     }
 
     public unsafe struct CORINFO_DEVIRTUALIZATION_INFO
@@ -1093,6 +1100,7 @@ public unsafe struct CORINFO_DEVIRTUALIZATION_INFO
         public CORINFO_METHOD_STRUCT_* virtualMethod;
         public CORINFO_CLASS_STRUCT_* objClass;
         public CORINFO_CONTEXT_STRUCT* context;
+        public CORINFO_RESOLVED_TOKEN* pResolvedTokenVirtualMethod;
 
         //
         // [Out] results of resolveVirtualMethod.
@@ -1107,6 +1115,8 @@ public unsafe struct CORINFO_DEVIRTUALIZATION_INFO
         public bool requiresInstMethodTableArg { get { return _requiresInstMethodTableArg != 0; } set { _requiresInstMethodTableArg = value ? (byte)1 : (byte)0; } }
         public CORINFO_CONTEXT_STRUCT* exactContext;
         public CORINFO_DEVIRTUALIZATION_DETAIL detail;
+        public CORINFO_RESOLVED_TOKEN resolvedTokenDevirtualizedMethod;
+        public CORINFO_RESOLVED_TOKEN resolvedTokenDevirtualizedUnboxedMethod;
     }
 
     //----------------------------------------------------------------------------
diff --git a/src/coreclr/tools/Common/Pgo/PgoFormat.cs b/src/coreclr/tools/Common/Pgo/PgoFormat.cs
index 99164557fee8a4..afc05ae3d8b758 100644
--- a/src/coreclr/tools/Common/Pgo/PgoFormat.cs
+++ b/src/coreclr/tools/Common/Pgo/PgoFormat.cs
@@ -79,6 +79,14 @@ public struct PgoSchemaElem
                             ((InstrumentationKind & PgoInstrumentationKind.MarshalMask) == PgoInstrumentationKind.EightByte)));
     }
 
+    // Flags stored in 'Other' field of TypeHandleHistogram*Count entries.
+    [Flags]
+    public enum ClassProfileFlags : uint
+    {
+        IsInterface = 0x40000000,
+        IsClass = 0x80000000,
+    }
+
     public class PgoProcessor
     {
         private enum InstrumentationDataProcessingState
diff --git a/src/coreclr/tools/Common/TypeSystem/Common/MetadataFieldLayoutAlgorithm.cs b/src/coreclr/tools/Common/TypeSystem/Common/MetadataFieldLayoutAlgorithm.cs
index 2bf40935a38b60..4109bb701aa9ac 100644
--- a/src/coreclr/tools/Common/TypeSystem/Common/MetadataFieldLayoutAlgorithm.cs
+++ b/src/coreclr/tools/Common/TypeSystem/Common/MetadataFieldLayoutAlgorithm.cs
@@ -782,10 +782,9 @@ public LayoutInt CalculateFieldBaseOffset(MetadataType type, bool requiresAlign8
             if (!type.IsValueType && type.HasBaseType)
             {
                 cumulativeInstanceFieldPos = type.BaseType.InstanceByteCountUnaligned;
-                if (!type.BaseType.InstanceByteCountUnaligned.IsIndeterminate)
+                if (!cumulativeInstanceFieldPos.IsIndeterminate)
                 {
-                    cumulativeInstanceFieldPos = type.BaseType.InstanceByteCountUnaligned;
-                    if (type.BaseType.IsZeroSizedReferenceType && ((MetadataType)type.BaseType).HasLayout())
+                    if (requiresAlignedBase && type.BaseType.IsZeroSizedReferenceType && ((MetadataType)type.BaseType).HasLayout())
                     {
                         cumulativeInstanceFieldPos += LayoutInt.One;
                     }
diff --git a/src/coreclr/tools/Common/TypeSystem/Common/MetadataVirtualMethodAlgorithm.cs b/src/coreclr/tools/Common/TypeSystem/Common/MetadataVirtualMethodAlgorithm.cs
index 5a33ab437a5f87..8b878afcc0c061 100644
--- a/src/coreclr/tools/Common/TypeSystem/Common/MetadataVirtualMethodAlgorithm.cs
+++ b/src/coreclr/tools/Common/TypeSystem/Common/MetadataVirtualMethodAlgorithm.cs
@@ -459,6 +459,11 @@ private static void FindBaseUnificationGroup(MetadataType currentType, Unificati
 
             foreach (MethodDesc memberMethod in unificationGroup.Members)
             {
+                // If a method is both overriden via MethodImpl and name/sig, we don't remove it from the unification list
+                // as the local MethodImpl takes priority over the name/sig match, and prevents the slot disunificaiton
+                if (FindSlotDefiningMethodForVirtualMethod(memberMethod) == FindSlotDefiningMethodForVirtualMethod(originalDefiningMethod))
+                    continue;
+
                 MethodDesc nameSigMatchMemberMethod = FindMatchingVirtualMethodOnTypeByNameAndSigWithSlotCheck(memberMethod, currentType, reverseMethodSearch: true);
                 if (nameSigMatchMemberMethod != null && nameSigMatchMemberMethod != memberMethod)
                 {
@@ -665,7 +670,7 @@ public static MethodDesc ResolveVariantInterfaceMethodToVirtualMethodOnType(Meth
 
             foreach (TypeDesc iface in currentType.RuntimeInterfaces)
             {
-                if (iface.CanCastTo(interfaceType))
+                if (iface.HasSameTypeDefinition(interfaceType) && iface.CanCastTo(interfaceType))
                 {
                     implMethod = iface.FindMethodOnTypeWithMatchingTypicalMethod(interfaceMethod);
                     Debug.Assert(implMethod != null);
diff --git a/src/coreclr/tools/Common/TypeSystem/Common/TypeSystemHelpers.cs b/src/coreclr/tools/Common/TypeSystem/Common/TypeSystemHelpers.cs
index 2442f04fee8963..3732586a45e75a 100644
--- a/src/coreclr/tools/Common/TypeSystem/Common/TypeSystemHelpers.cs
+++ b/src/coreclr/tools/Common/TypeSystem/Common/TypeSystemHelpers.cs
@@ -382,6 +382,26 @@ public static MethodDesc ResolveInterfaceMethodTarget(this TypeDesc thisType, Me
             return result;
         }
 
+        /// <summary>
+        /// Scan the type and its base types for an implementation of an interface method. Returns null if no
+        /// implementation is found.
+        /// </summary>
+        public static MethodDesc ResolveInterfaceMethodTargetWithVariance(this TypeDesc thisType, MethodDesc interfaceMethodToResolve)
+        {
+            Debug.Assert(interfaceMethodToResolve.OwningType.IsInterface);
+
+            MethodDesc result = null;
+            TypeDesc currentType = thisType;
+            do
+            {
+                result = currentType.ResolveVariantInterfaceMethodToVirtualMethodOnType(interfaceMethodToResolve);
+                currentType = currentType.BaseType;
+            }
+            while (result == null && currentType != null);
+
+            return result;
+        }
+
         public static bool ContainsSignatureVariables(this TypeDesc thisType, bool treatGenericParameterLikeSignatureVariable = false)
         {
             switch (thisType.Category)
diff --git a/src/coreclr/tools/Common/TypeSystem/IL/EcmaMethodIL.cs b/src/coreclr/tools/Common/TypeSystem/IL/EcmaMethodIL.cs
index 02e5207c90a8b7..ce2ced7e34ded5 100644
--- a/src/coreclr/tools/Common/TypeSystem/IL/EcmaMethodIL.cs
+++ b/src/coreclr/tools/Common/TypeSystem/IL/EcmaMethodIL.cs
@@ -11,7 +11,10 @@
 
 namespace Internal.IL
 {
-    public sealed partial class EcmaMethodIL : MethodIL
+    // Marker interface implemented by EcmaMethodIL and EcmaMethodILScope
+    public interface IEcmaMethodIL { }
+
+    public sealed partial class EcmaMethodIL : MethodIL, IEcmaMethodIL
     {
         private readonly EcmaModule _module;
         private readonly EcmaMethod _method;
@@ -140,4 +143,46 @@ public override object GetObject(int token, NotFoundBehavior notFoundBehavior =
             return _module.GetObject(MetadataTokens.EntityHandle(token), notFoundBehavior);
         }
     }
+
+    public sealed partial class EcmaMethodILScope : MethodILScope, IEcmaMethodIL
+    {
+        private readonly EcmaModule _module;
+        private readonly EcmaMethod _method;
+
+        public static EcmaMethodILScope Create(EcmaMethod method)
+        {
+            return new EcmaMethodILScope(method);
+        }
+
+        private EcmaMethodILScope(EcmaMethod method)
+        {
+            _method = method;
+            _module = method.Module;
+        }
+
+        public EcmaModule Module
+        {
+            get
+            {
+                return _module;
+            }
+        }
+
+        public override MethodDesc OwningMethod
+        {
+            get
+            {
+                return _method;
+            }
+        }
+
+        public override object GetObject(int token, NotFoundBehavior notFoundBehavior = NotFoundBehavior.Throw)
+        {
+            // UserStrings cannot be wrapped in EntityHandle
+            if ((token & 0xFF000000) == 0x70000000)
+                return _module.GetUserString(MetadataTokens.UserStringHandle(token));
+
+            return _module.GetObject(MetadataTokens.EntityHandle(token), notFoundBehavior);
+        }
+    }
 }
diff --git a/src/coreclr/tools/Common/TypeSystem/IL/MethodIL.cs b/src/coreclr/tools/Common/TypeSystem/IL/MethodIL.cs
index cfe1f93998b08b..2f8b54249197e2 100644
--- a/src/coreclr/tools/Common/TypeSystem/IL/MethodIL.cs
+++ b/src/coreclr/tools/Common/TypeSystem/IL/MethodIL.cs
@@ -53,13 +53,40 @@ public ILExceptionRegion(
     /// Represents a method body.
     /// </summary>
     [System.Diagnostics.DebuggerTypeProxy(typeof(MethodILDebugView))]
-    public abstract partial class MethodIL
+    public abstract partial class MethodILScope
     {
         /// <summary>
-        /// Gets the method whose body this <see cref="MethodIL"/> represents.
+        /// Gets the method whose body this <see cref=""/> represents.
         /// </summary>
         public abstract MethodDesc OwningMethod { get; }
 
+        /// <summary>
+        /// Gets the open (uninstantiated) version of the <see cref="MethodILScope"/>.
+        /// </summary>
+        public virtual MethodILScope GetMethodILScopeDefinition()
+        {
+            return this;
+        }
+
+        /// <summary>
+        /// Resolves a token from within the method body into a type system object
+        /// (typically a <see cref="MethodDesc"/>, <see cref="FieldDesc"/>, <see cref="TypeDesc"/>,
+        /// or <see cref="MethodSignature"/>).
+        /// </summary>
+        public abstract Object GetObject(int token, NotFoundBehavior notFoundBehavior = NotFoundBehavior.Throw);
+
+        public override string ToString()
+        {
+            return OwningMethod.ToString();
+        }
+    }
+
+    /// <summary>
+    /// Represents a method body.
+    /// </summary>
+    [System.Diagnostics.DebuggerTypeProxy(typeof(MethodILDebugView))]
+    public abstract partial class MethodIL : MethodILScope
+    {
         /// <summary>
         /// Gets the maximum possible stack depth this method declares.
         /// </summary>
@@ -81,18 +108,16 @@ public abstract partial class MethodIL
         /// </summary>
         public abstract LocalVariableDefinition[] GetLocals();
 
-        /// <summary>
-        /// Resolves a token from within the method body into a type system object
-        /// (typically a <see cref="MethodDesc"/>, <see cref="FieldDesc"/>, <see cref="TypeDesc"/>,
-        /// or <see cref="MethodSignature"/>).
-        /// </summary>
-        public abstract Object GetObject(int token, NotFoundBehavior notFoundBehavior = NotFoundBehavior.Throw);
-
         /// <summary>
         /// Gets a list of exception regions this method body defines.
         /// </summary>
         public abstract ILExceptionRegion[] GetExceptionRegions();
 
+        public override sealed MethodILScope GetMethodILScopeDefinition()
+        {
+            return GetMethodILDefinition();
+        }
+
         /// <summary>
         /// Gets the open (uninstantiated) version of the <see cref="MethodIL"/>.
         /// </summary>
@@ -100,10 +125,5 @@ public virtual MethodIL GetMethodILDefinition()
         {
             return this;
         }
-
-        public override string ToString()
-        {
-            return OwningMethod.ToString();
-        }
     }
 }
diff --git a/src/coreclr/tools/Common/TypeSystem/Interop/IL/MarshalHelpers.cs b/src/coreclr/tools/Common/TypeSystem/Interop/IL/MarshalHelpers.cs
index 64ba412f6afbcf..458b4c6a6b676e 100644
--- a/src/coreclr/tools/Common/TypeSystem/Interop/IL/MarshalHelpers.cs
+++ b/src/coreclr/tools/Common/TypeSystem/Interop/IL/MarshalHelpers.cs
@@ -450,6 +450,9 @@ internal static MarshallerKind GetMarshallerKind(
                 {
                     case NativeTypeKind.Array:
                         {
+                            if (isField)
+                                return MarshallerKind.Invalid;
+
                             var arrayType = (ArrayType)type;
 
                             elementMarshallerKind = GetArrayElementMarshallerKind(
diff --git a/src/coreclr/tools/Common/TypeSystem/Interop/IL/MarshalUtils.cs b/src/coreclr/tools/Common/TypeSystem/Interop/IL/MarshalUtils.cs
index 84dcc80be1323e..33c609ee23b807 100644
--- a/src/coreclr/tools/Common/TypeSystem/Interop/IL/MarshalUtils.cs
+++ b/src/coreclr/tools/Common/TypeSystem/Interop/IL/MarshalUtils.cs
@@ -23,8 +23,8 @@ public static bool IsBlittableType(TypeDesc type)
                 && !baseType.IsWellKnownType(WellKnownType.Object)
                 && !baseType.IsWellKnownType(WellKnownType.ValueType);
 
-            // Type is blittable only if parent is also blittable and is not empty.
-            if (hasNonTrivialParent && (!IsBlittableType(baseType) || baseType.IsZeroSizedReferenceType))
+            // Type is blittable only if parent is also blittable.
+            if (hasNonTrivialParent && !IsBlittableType(baseType))
             {
                 return false;
             }
diff --git a/src/coreclr/tools/ILVerify/ILVerify.csproj b/src/coreclr/tools/ILVerify/ILVerify.csproj
index 606b4ea4c8fa7e..28f18b58cb004a 100644
--- a/src/coreclr/tools/ILVerify/ILVerify.csproj
+++ b/src/coreclr/tools/ILVerify/ILVerify.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>netcoreapp3.1</TargetFramework>
+    <TargetFramework>$(NetCoreAppToolCurrent)</TargetFramework>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <UseAppHost>false</UseAppHost>
     <RollForward>Major</RollForward>
diff --git a/src/coreclr/tools/StressLogAnalyzer/StressLogPlugin/StressLogPlugin.cpp b/src/coreclr/tools/StressLogAnalyzer/StressLogPlugin/StressLogPlugin.cpp
index 8b4efa8aa38a56..42e778312dcbc9 100644
--- a/src/coreclr/tools/StressLogAnalyzer/StressLogPlugin/StressLogPlugin.cpp
+++ b/src/coreclr/tools/StressLogAnalyzer/StressLogPlugin/StressLogPlugin.cpp
@@ -139,6 +139,7 @@ d(IS_PLAN_PINNED_PLUG,          ThreadStressLog::gcPlanPinnedPlugMsg())
 d(IS_DESIRED_NEW_ALLOCATION,    ThreadStressLog::gcDesiredNewAllocationMsg())                                               \
 d(IS_MAKE_UNUSED_ARRAY,         ThreadStressLog::gcMakeUnusedArrayMsg())                                                    \
 d(IS_START_BGC_THREAD,          ThreadStressLog::gcStartBgcThread())                                                        \
+d(IS_RELOCATE_REFERENCE,        ThreadStressLog::gcRelocateReferenceMsg())                                                  \
 d(IS_UNINTERESTING,             "")
 
 enum InterestingStringId : unsigned char
@@ -469,6 +470,26 @@ bool FilterMessage(StressLog::StressLogHeader* hdr, ThreadStressLog* tsl, uint32
     case    IS_START_BGC_THREAD:
         RememberThreadForHeap(tsl->threadId, (int64_t)args[0], GC_THREAD_BG);
         break;
+    case    IS_RELOCATE_REFERENCE:
+        if (s_valueFilterCount > 0)
+        {
+            size_t src = (size_t)args[0];
+            size_t dst_from = (size_t)args[1];
+            size_t dst_to = (size_t)args[2];
+            // print this message if the source or destination contain (part of) the range we're looking for
+            for (int i = 0; i < s_valueFilterCount; i++)
+            {
+                if ((s_valueFilter[i].end < src || src < s_valueFilter[i].start) &&
+                    (s_valueFilter[i].end < dst_from || dst_from < s_valueFilter[i].start) &&
+                    (s_valueFilter[i].end < dst_to || dst_to < s_valueFilter[i].start))
+                {
+                    // empty intersection with both the source and the destination
+                    continue;
+                }
+                return true;
+            }
+        }
+        break;
     }
     return fLevelFilter || s_interestingStringFilter[isd];
 }
@@ -521,7 +542,7 @@ static ThreadStressLogDesc s_threadStressLogDesc[MAX_THREADSTRESSLOGS];
 static int s_threadStressLogCount;
 static LONG s_wrappedWriteThreadCount;
 
-static const LONG MAX_MESSAGE_COUNT = 1024 * 1024 * 1024;
+static const LONG MAX_MESSAGE_COUNT = 64 * 1024 * 1024;
 static StressThreadAndMsg* s_threadMsgBuf;
 static volatile LONG s_msgCount = 0;
 static volatile LONG s_totalMsgCount = 0;
@@ -956,6 +977,10 @@ bool ParseOptions(int argc, wchar_t* argv[])
                 return false;
             }
         }
+        else
+        {
+            return false;
+        }
         i++;
     }
     return true;
diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/CodeGen/ReadyToRunObjectWriter.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/CodeGen/ReadyToRunObjectWriter.cs
index e54207ff00fb17..74da51246b620c 100644
--- a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/CodeGen/ReadyToRunObjectWriter.cs
+++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/CodeGen/ReadyToRunObjectWriter.cs
@@ -198,11 +198,7 @@ public void EmitPortableExecutable()
 
                 if (_nodeFactory.CompilationModuleGroup.IsCompositeBuildMode && _componentModule == null)
                 {
-                    headerBuilder = PEHeaderProvider.Create(
-                        imageCharacteristics: Characteristics.ExecutableImage | Characteristics.Dll,
-                        dllCharacteristics: default(DllCharacteristics),
-                        Subsystem.Unknown,
-                        _nodeFactory.Target);
+                    headerBuilder = PEHeaderProvider.Create(Subsystem.Unknown, _nodeFactory.Target);
                     peIdProvider = new Func<IEnumerable<Blob>, BlobContentId>(content => BlobContentId.FromHash(CryptographicHashProvider.ComputeSourceHash(content)));
                     timeDateStamp = null;
                     r2rHeaderExportSymbol = _nodeFactory.Header;
@@ -210,7 +206,7 @@ public void EmitPortableExecutable()
                 else
                 {
                     PEReader inputPeReader = (_componentModule != null ? _componentModule.PEReader : _nodeFactory.CompilationModuleGroup.CompilationModuleSet.First().PEReader);
-                    headerBuilder = PEHeaderProvider.Copy(inputPeReader.PEHeaders, _nodeFactory.Target);
+                    headerBuilder = PEHeaderProvider.Create(inputPeReader.PEHeaders.PEHeader.Subsystem, _nodeFactory.Target);
                     timeDateStamp = inputPeReader.PEHeaders.CoffHeader.TimeDateStamp;
                     r2rHeaderExportSymbol = null;
                 }
diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/CompilationModuleGroup.ReadyToRun.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/CompilationModuleGroup.ReadyToRun.cs
index e2ec6059d5dc77..6ef8c57322d6f9 100644
--- a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/CompilationModuleGroup.ReadyToRun.cs
+++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/CompilationModuleGroup.ReadyToRun.cs
@@ -25,6 +25,14 @@ partial class CompilationModuleGroup
         /// <returns>True if the given type versions with the current compilation module group</returns>
         public virtual bool VersionsWithType(TypeDesc typeDesc) => ContainsType(typeDesc);
 
+        /// <summary>
+        /// Returns true when all of the tokens necessary to refer to a given type belong to the same version
+        /// bubble as the compilation module group. By default return the same outcome as VersionsWithType.
+        /// </summary>
+        /// <param name="typeDesc">Type to check</param>
+        /// <returns>True if the given type can safely be referred to within the current compilation module group</returns>
+        public virtual bool VersionsWithTypeReference(TypeDesc typeDesc) => VersionsWithType(typeDesc);
+
         /// <summary>
         /// Returns true when a given method belongs to the same version bubble as the compilation module group.
         /// By default return the same outcome as ContainsMethodBody.
diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/DevirtualizationManager.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/DevirtualizationManager.cs
index 189dd6a0adc563..ab85bb84936f71 100644
--- a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/DevirtualizationManager.cs
+++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/DevirtualizationManager.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using Internal.TypeSystem;
+using CORINFO_DEVIRTUALIZATION_DETAIL = Internal.JitInterface.CORINFO_DEVIRTUALIZATION_DETAIL;
 
 namespace ILCompiler.DependencyAnalysis.ReadyToRun
 {
@@ -24,44 +25,191 @@ public override bool IsEffectivelySealed(MethodDesc method)
             return _compilationModuleGroup.VersionsWithMethodBody(method) && base.IsEffectivelySealed(method);
         }
 
-        protected override MethodDesc ResolveVirtualMethod(MethodDesc declMethod, DefType implType)
+        protected override MethodDesc ResolveVirtualMethod(MethodDesc declMethod, DefType implType, out CORINFO_DEVIRTUALIZATION_DETAIL devirtualizationDetail)
         {
-            if (_compilationModuleGroup.VersionsWithMethodBody(declMethod) &&
-                _compilationModuleGroup.VersionsWithType(implType))
+            devirtualizationDetail = CORINFO_DEVIRTUALIZATION_DETAIL.CORINFO_DEVIRTUALIZATION_UNKNOWN;
+
+            // Versioning resiliency rules here are complex
+            // Decl method checking
+            // 1. If the declMethod is a class method, then we do not need to check if it is within the version bubble with a VersionsWithCode check
+            //    but the metadata for the open definition must be within the bubble, or the decl method is in the direct parent type
+            //    of a type which is in the version bubble relative to the implType.
+            // 2. If the declMethod is an interface method, we can allow it if interface type is defined within the version
+            //    bubble, or if the implementation type hierarchy is entirely within the version bubble (excluding System.Object and System.ValueType).
+            // 3. At all times the declMethod must be representable as a token. That check is handled internally in the
+            //    jit interface logic after the logic that executes here.
+            //
+            // ImplType checking
+            // 1. At all times the metadata definition of the implementation type must version with the application.
+            // 2. Additionally, the exact implementation type must be representable within the R2R image (this is checked via VersionsWithTypeReference
+            //
+            // Result method checking
+            // 1. Ensure that the resolved result versions with the code, or is the decl method
+            // 2. Devirtualizing to a default interface method is not currently considered to be useful, and how to check for version
+            //    resilience has not yet been analyzed.
+            // 3. When checking that the resolved result versions with the code, validate that all of the types
+            //    From implType to the owning type of resolved result method also version with the code.
+
+            bool declMethodCheckFailed;
+            var firstTypeInImplTypeHierarchyNotInVersionBubble = FindVersionBubbleEdge(_compilationModuleGroup, implType, out TypeDesc lastTypeInHierarchyInVersionBubble);
+            if (!declMethod.OwningType.IsInterface)
+            {
+                if (_compilationModuleGroup.VersionsWithType(declMethod.OwningType.GetTypeDefinition()))
+                {
+                    declMethodCheckFailed = false;
+                }
+                else
+                {
+                    if (firstTypeInImplTypeHierarchyNotInVersionBubble != declMethod.OwningType)
+                    {
+                        devirtualizationDetail = CORINFO_DEVIRTUALIZATION_DETAIL.CORINFO_DEVIRTUALIZATION_FAILED_BUBBLE_CLASS_DECL;
+                        declMethodCheckFailed = true;
+                    }
+                    else
+                    {
+                        declMethodCheckFailed = false;
+                    }
+                }
+            }
+            else
+            {
+                if (_compilationModuleGroup.VersionsWithType(declMethod.OwningType.GetTypeDefinition()))
+                {
+                    declMethodCheckFailed = false;
+                }
+                else
+                {
+                    if (firstTypeInImplTypeHierarchyNotInVersionBubble == null || implType.IsValueType || firstTypeInImplTypeHierarchyNotInVersionBubble.IsObject)
+                        declMethodCheckFailed = false;
+                    else
+                    {
+                        devirtualizationDetail = CORINFO_DEVIRTUALIZATION_DETAIL.CORINFO_DEVIRTUALIZATION_FAILED_BUBBLE_INTERFACE_DECL;
+                        declMethodCheckFailed = true;
+                    }
+                }
+            }
+
+            if (declMethodCheckFailed)
+                return null;
+
+            // Impl type check
+            if (!_compilationModuleGroup.VersionsWithType(implType.GetTypeDefinition()))
             {
-                /**
-                 * It is possible for us to hit a scenario where a type implements
-                 * the same interface more than once due to generic instantiations.
-                 *
-                 * In some instances of those cases, the VirtualMethodAlgorithm
-                 * does not produce identical output as CoreCLR would, leading to
-                 * behavioral differences in compiled outputs.
-                 *
-                 * Instead of fixing the algorithm (in which the work to fix it is
-                 * tracked in https://github.com/dotnet/corert/issues/208), the
-                 * following duplication detection algorithm will detect the case and
-                 * refuse to devirtualize for those scenarios.
-                 */
-                if (declMethod.OwningType.IsInterface)
+                devirtualizationDetail = CORINFO_DEVIRTUALIZATION_DETAIL.CORINFO_DEVIRTUALIZATION_FAILED_BUBBLE_IMPL;
+                return null;
+            }
+
+            if (!_compilationModuleGroup.VersionsWithTypeReference(implType))
+            {
+                devirtualizationDetail = CORINFO_DEVIRTUALIZATION_DETAIL.CORINFO_DEVIRTUALIZATION_FAILED_BUBBLE_IMPL_NOT_REFERENCEABLE;
+                return null;
+            }
+
+            /**
+                * It is possible for us to hit a scenario where a type implements
+                * the same interface more than once due to generic instantiations.
+                *
+                * In some instances of those cases, the VirtualMethodAlgorithm
+                * does not produce identical output as CoreCLR would, leading to
+                * behavioral differences in compiled outputs.
+                *
+                * Instead of fixing the algorithm (in which the work to fix it is
+                * tracked in https://github.com/dotnet/corert/issues/208), the
+                * following duplication detection algorithm will detect the case and
+                * refuse to devirtualize for those scenarios.
+                */
+            if (declMethod.OwningType.IsInterface)
+            {
+                DefType[] implTypeRuntimeInterfaces = implType.RuntimeInterfaces;
+                for (int i = 0; i < implTypeRuntimeInterfaces.Length; i++)
                 {
-                    DefType[] implTypeRuntimeInterfaces = implType.RuntimeInterfaces;
-                    for (int i = 0; i < implTypeRuntimeInterfaces.Length; i++)
+                    for (int j = i + 1; j < implTypeRuntimeInterfaces.Length; j++)
                     {
-                        for (int j = i + 1; j < implTypeRuntimeInterfaces.Length; j++)
+                        if (implTypeRuntimeInterfaces[i] == implTypeRuntimeInterfaces[j])
                         {
-                            if (implTypeRuntimeInterfaces[i] == implTypeRuntimeInterfaces[j])
-                            {
-                                return null;
-                            }
+                            devirtualizationDetail = CORINFO_DEVIRTUALIZATION_DETAIL.CORINFO_DEVIRTUALIZATION_FAILED_DUPLICATE_INTERFACE;
+                            return null;
                         }
                     }
                 }
+            }
+
 
-                return base.ResolveVirtualMethod(declMethod, implType);
+            if (declMethod.OwningType.IsInterface)
+            {
+                // Check for ComImport class, as we don't support devirtualization of ComImport classes
+                // Run this check on all platforms, to avoid possible future versioning problems if we implement
+                // COM on other architectures.
+                if (!implType.IsObject)
+                {
+                    TypeDesc typeThatDerivesFromObject = implType;
+                    while(!typeThatDerivesFromObject.BaseType.IsObject)
+                    {
+                        typeThatDerivesFromObject = typeThatDerivesFromObject.BaseType;
+                    }
+
+                    if (typeThatDerivesFromObject is Internal.TypeSystem.Ecma.EcmaType ecmaType)
+                    {
+                        if ((ecmaType.Attributes & System.Reflection.TypeAttributes.Import) != 0)
+                        {
+                            devirtualizationDetail = CORINFO_DEVIRTUALIZATION_DETAIL.CORINFO_DEVIRTUALIZATION_FAILED_COM;
+                            return null;
+                        }
+                    }
+                }
             }
 
-            // Cannot devirtualize across version bubble boundary
+            MethodDesc resolvedVirtualMethod = base.ResolveVirtualMethod(declMethod, implType, out devirtualizationDetail);
+
+            if (resolvedVirtualMethod != null)
+            {
+                // Validate that the inheritance chain for resolution is within version bubble
+                // The rule is somewhat tricky here.
+                // If the resolved method is the declMethod, then only types which derive from the
+                // OwningType of the decl method need to be within the version bubble.
+                //
+                // If not, then then all the types from the implType to the Owning type of the resolved
+                // virtual method must be within the version bubble.
+                if (firstTypeInImplTypeHierarchyNotInVersionBubble == null)
+                {
+                    // The entire type hierarchy of the implType is within the version bubble, and there is no more to check
+                    return resolvedVirtualMethod;
+                }
+
+                if (declMethod == resolvedVirtualMethod && firstTypeInImplTypeHierarchyNotInVersionBubble == declMethod.OwningType)
+                {
+                    // Exact match for use of decl method check
+                    return resolvedVirtualMethod;
+                }
+
+                // Ensure that declMethod is implemented on a type within the type hierarchy that is within the version bubble
+                for (TypeDesc typeExamine = resolvedVirtualMethod.OwningType; typeExamine != null; typeExamine = typeExamine.BaseType)
+                {
+                    if (typeExamine == lastTypeInHierarchyInVersionBubble)
+                    {
+                        return resolvedVirtualMethod;
+                    }
+                }
+                devirtualizationDetail = CORINFO_DEVIRTUALIZATION_DETAIL.CORINFO_DEVIRTUALIZATION_FAILED_BUBBLE;
+            }
+
+            // Cannot devirtualize, as we can't resolve to a target.
             return null;
+
+            // This function returns the type where the metadata is not in the version bubble of the application, and has an out parameter
+            // which is the last type examined before that is found via a base type walk.
+            static TypeDesc FindVersionBubbleEdge(CompilationModuleGroup compilationModuleGroup, TypeDesc type, out TypeDesc lastTypeInVersionBubble)
+            {
+                lastTypeInVersionBubble = null;
+                while (compilationModuleGroup.VersionsWithType(type.GetTypeDefinition()))
+                {
+                    lastTypeInVersionBubble = type;
+                    type = type.BaseType;
+                    if (type == null)
+                        return null;
+                }
+                return type;
+            }
         }
     }
 }
diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/InstrumentationDataTableNode.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/InstrumentationDataTableNode.cs
index 5b4b2f5c7826da..90883bf0b073d4 100644
--- a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/InstrumentationDataTableNode.cs
+++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/InstrumentationDataTableNode.cs
@@ -93,7 +93,7 @@ private int TypeToInt(TypeSystemEntityOrUnknown type)
                 {
                     return computedInt;
                 }
-                if (type.AsType != null && _compilationGroup.VersionsWithType(type.AsType))
+                if (type.AsType != null && _compilationGroup.VersionsWithTypeReference(type.AsType))
                 {
                     Import typeHandleImport = (Import)_symbolFactory.CreateReadyToRunHelper(ReadyToRunHelperId.TypeHandle, type.AsType);
                     _imports.Add(typeHandleImport);
diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/ModuleTokenResolver.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/ModuleTokenResolver.cs
index 8ee9b426d5626c..86d507ab57af8d 100644
--- a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/ModuleTokenResolver.cs
+++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/ModuleTokenResolver.cs
@@ -139,7 +139,8 @@ public void AddModuleTokenForMethod(MethodDesc method, ModuleToken token)
             {
                 MemberReference memberRef = token.MetadataReader.GetMemberReference((MemberReferenceHandle)token.Handle);
                 EntityHandle owningTypeHandle = memberRef.Parent;
-                AddModuleTokenForType(method.OwningType, new ModuleToken(token.Module, owningTypeHandle));
+                TypeDesc owningType = (TypeDesc)token.Module.GetObject(owningTypeHandle, NotFoundBehavior.Throw);
+                AddModuleTokenForType(owningType, new ModuleToken(token.Module, owningTypeHandle));
                 memberRef.DecodeMethodSignature<DummyTypeInfo, ModuleTokenResolver>(new TokenResolverProvider(this, token.Module), this);
             }
         }
diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/RuntimeFunctionsTableNode.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/RuntimeFunctionsTableNode.cs
index c2ab705ef5c2f6..f2d72fd9d4d2f1 100644
--- a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/RuntimeFunctionsTableNode.cs
+++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/RuntimeFunctionsTableNode.cs
@@ -67,6 +67,7 @@ public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)
                 LayoutRuntimeFunctions();
 
             ObjectDataBuilder runtimeFunctionsBuilder = new ObjectDataBuilder(factory, relocsOnly);
+            runtimeFunctionsBuilder.RequireInitialAlignment(4);
 
             // Add the symbol representing this object node
             runtimeFunctionsBuilder.AddSymbol(this);
diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/SignatureBuilder.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/SignatureBuilder.cs
index a91aecaa25e417..4f0fc3ddb21c4f 100644
--- a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/SignatureBuilder.cs
+++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/SignatureBuilder.cs
@@ -417,7 +417,7 @@ public void EmitMethodSignature(
                 flags |= (uint)ReadyToRunMethodSigFlags.READYTORUN_METHOD_SIG_OwnerType;
             }
 
-            EmitMethodSpecificationSignature(method, flags, enforceDefEncoding, context);
+            EmitMethodSpecificationSignature(method, flags, enforceDefEncoding, enforceOwningType, context);
 
             if (method.ConstrainedType != null)
             {
@@ -438,9 +438,10 @@ public void EmitMethodRefToken(ModuleToken memberRefToken)
         }
 
         private void EmitMethodSpecificationSignature(MethodWithToken method, 
-            uint flags, bool enforceDefEncoding, SignatureContext context)
+            uint flags, bool enforceDefEncoding, bool enforceOwningType, SignatureContext context)
         {
             ModuleToken methodToken = method.Token;
+
             if (method.Method.HasInstantiation && !method.Method.IsGenericMethodDefinition)
             {
                 flags |= (uint)ReadyToRunMethodSigFlags.READYTORUN_METHOD_SIG_MethodInstantiation;
@@ -469,7 +470,23 @@ private void EmitMethodSpecificationSignature(MethodWithToken method,
                     throw new NotImplementedException();
             }
 
+            if ((method.Token.Module != context.LocalContext) && !enforceOwningType)
+            {
+                // If enforeOwningType is set, this is an entry for the InstanceEntryPoint or InstrumentationDataTable nodes
+                // which are not used in quite the same way, and for which the MethodDef is always matched to the module
+                // which defines the type
+                flags |= (uint)ReadyToRunMethodSigFlags.READYTORUN_METHOD_SIG_UpdateContext;
+            }
+
             EmitUInt(flags);
+
+            if ((flags & (uint)ReadyToRunMethodSigFlags.READYTORUN_METHOD_SIG_UpdateContext) != 0)
+            {
+                uint moduleIndex = (uint)context.Resolver.GetModuleIndex(method.Token.Module);
+                EmitUInt(moduleIndex);
+                context = context.InnerContext(method.Token.Module);
+            }
+
             if ((flags & (uint)ReadyToRunMethodSigFlags.READYTORUN_METHOD_SIG_OwnerType) != 0)
             {
                 // The type here should be the type referred to by the memberref (if this is one, not the type where the method was eventually found!
diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/VirtualResolutionFixupSignature.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/VirtualResolutionFixupSignature.cs
new file mode 100644
index 00000000000000..20a428e3931100
--- /dev/null
+++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/VirtualResolutionFixupSignature.cs
@@ -0,0 +1,104 @@
+// 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 Internal.Text;
+using Internal.TypeSystem;
+using Internal.TypeSystem.Ecma;
+using Internal.TypeSystem.Interop;
+using Internal.ReadyToRunConstants;
+using Internal.CorConstants;
+using Internal.JitInterface;
+
+namespace ILCompiler.DependencyAnalysis.ReadyToRun
+{
+    public class VirtualResolutionFixupSignature : Signature, IEquatable<VirtualResolutionFixupSignature>
+    {
+        private readonly ReadyToRunFixupKind _fixupKind;
+
+        private readonly MethodWithToken _declMethod;
+        private readonly TypeDesc _implType;
+        private readonly MethodWithToken _implMethod;
+
+        public VirtualResolutionFixupSignature(ReadyToRunFixupKind fixupKind, MethodWithToken declMethod, TypeDesc implType, MethodWithToken implMethod)
+        {
+            _fixupKind = fixupKind;
+            _declMethod = declMethod;
+            _implType = implType;
+            _implMethod = implMethod;
+
+            // Ensure types in signature are loadable and resolvable, otherwise we'll fail later while emitting the signature
+            CompilerTypeSystemContext compilerContext = (CompilerTypeSystemContext)declMethod.Method.Context;
+            compilerContext.EnsureLoadableMethod(declMethod.Method);
+            compilerContext.EnsureLoadableType(implType);
+            if (implMethod != null)
+                compilerContext.EnsureLoadableMethod(implMethod.Method);
+        }
+
+        public override int ClassCode => 1092747257;
+
+        public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)
+        {
+            ObjectDataSignatureBuilder dataBuilder = new ObjectDataSignatureBuilder();
+
+            if (!relocsOnly)
+            {
+                dataBuilder.AddSymbol(this);
+
+                SignatureContext innerContext = dataBuilder.EmitFixup(factory, _fixupKind, _declMethod.Token.Module, factory.SignatureContext);
+                dataBuilder.EmitUInt((uint)(_implMethod != null ? ReadyToRunVirtualFunctionOverrideFlags.VirtualFunctionOverriden : ReadyToRunVirtualFunctionOverrideFlags.None));
+                dataBuilder.EmitMethodSignature(_declMethod, enforceDefEncoding: false, enforceOwningType: false, innerContext, isInstantiatingStub: false);
+                dataBuilder.EmitTypeSignature(_implType, innerContext);
+                if (_implMethod != null)
+                    dataBuilder.EmitMethodSignature(_implMethod, enforceDefEncoding: false, enforceOwningType: false, innerContext, isInstantiatingStub: false);
+            }
+
+            return dataBuilder.ToObjectData();
+        }
+
+        public override void AppendMangledName(NameMangler nameMangler, Utf8StringBuilder sb)
+        {
+            sb.Append(nameMangler.CompilationUnitPrefix);
+            sb.Append($@"VirtualResolutionFixupSignature({_fixupKind.ToString()}): ");
+            _declMethod.AppendMangledName(nameMangler, sb);
+            sb.Append(":");
+            sb.Append(nameMangler.GetMangledTypeName(_implType));
+            sb.Append(":");
+            if (_implMethod == null)
+                sb.Append("(null)");
+            else
+                _implMethod.AppendMangledName(nameMangler, sb);
+        }
+
+        public override int CompareToImpl(ISortableNode other, CompilerComparer comparer)
+        {
+            VirtualResolutionFixupSignature otherNode = (VirtualResolutionFixupSignature)other;
+            int result = ((int)_fixupKind).CompareTo((int)otherNode._fixupKind);
+            if (result != 0)
+                return result;
+
+            result = comparer.Compare(_implType, otherNode._implType);
+            if (result != 0)
+                return result;
+
+            result = _declMethod.CompareTo(otherNode._declMethod, comparer);
+            if (result != 0)
+                return result;
+
+            // Handle null _implMethod scenario
+            if (_implMethod == otherNode._implMethod)
+                return 0;
+
+            return _implMethod.CompareTo(otherNode._implMethod, comparer);
+        }
+
+        public override string ToString()
+        {
+            return $"VirtualResolutionFixupSignature {_fixupKind} {_declMethod} {_implType} {_implMethod}";
+        }
+
+        public bool Equals(VirtualResolutionFixupSignature other) => object.ReferenceEquals(other, this);
+    }
+}
diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRunCodegenNodeFactory.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRunCodegenNodeFactory.cs
index 1a577b32b86246..da9c4592b549a6 100644
--- a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRunCodegenNodeFactory.cs
+++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRunCodegenNodeFactory.cs
@@ -53,7 +53,7 @@ public sealed class NodeFactory
 
         public TargetDetails Target { get; }
 
-        public CompilationModuleGroup CompilationModuleGroup { get; }
+        public ReadyToRunCompilationModuleGroupBase CompilationModuleGroup { get; }
 
         public ProfileDataManager ProfileDataManager { get; }
 
@@ -149,7 +149,7 @@ public override int GetHashCode()
 
         public NodeFactory(
             CompilerTypeSystemContext context,
-            CompilationModuleGroup compilationModuleGroup,
+            ReadyToRunCompilationModuleGroupBase compilationModuleGroup,
             ProfileDataManager profileDataManager,
             NameMangler nameMangler,
             CopiedCorHeaderNode corHeaderNode,
@@ -165,7 +165,7 @@ public NodeFactory(
             MetadataManager = new ReadyToRunTableManager(context);
             CopiedCorHeaderNode = corHeaderNode;
             DebugDirectoryNode = debugDirectoryNode;
-            Resolver = new ModuleTokenResolver(compilationModuleGroup, TypeSystemContext);
+            Resolver = compilationModuleGroup.Resolver;
             Header = new GlobalHeaderNode(Target, flags);
             if (!win32Resources.IsEmpty)
                 Win32ResourcesNode = new Win32ResourcesNode(win32Resources);
@@ -243,11 +243,16 @@ private void CreateNodeCaches()
                 return new TypeFixupSignature(key.FixupKind, key.TypeDesc);
             });
 
+            _virtualResolutionSignatures = new NodeCache<VirtualResolutionFixupSignatureFixupKey, VirtualResolutionFixupSignature>(key =>
+            {
+                return new ReadyToRun.VirtualResolutionFixupSignature(key.FixupKind, key.DeclMethod, key.ImplType, key.ImplMethod);
+            });
+
             _dynamicHelperCellCache = new NodeCache<DynamicHelperCellKey, ISymbolNode>(key =>
             {
                 return new DelayLoadHelperMethodImport(
                     this,
-                    DispatchImports,
+                    DispatchImports, 
                     ReadyToRunHelper.DelayLoad_Helper_Obj,
                     key.Method,
                     useVirtualCall: false,
@@ -504,6 +509,50 @@ public TypeFixupSignature TypeSignature(ReadyToRunFixupKind fixupKind, TypeDesc
             return _typeSignatures.GetOrAdd(fixupKey);
         }
 
+        private struct VirtualResolutionFixupSignatureFixupKey : IEquatable<VirtualResolutionFixupSignatureFixupKey>
+        {
+            public readonly ReadyToRunFixupKind FixupKind;
+            public readonly MethodWithToken DeclMethod;
+            public readonly TypeDesc ImplType;
+            public readonly MethodWithToken ImplMethod;
+
+            public VirtualResolutionFixupSignatureFixupKey(ReadyToRunFixupKind fixupKind, MethodWithToken declMethod, TypeDesc implType, MethodWithToken implMethod)
+            {
+                FixupKind = fixupKind;
+                DeclMethod = declMethod;
+                ImplType = implType;
+                ImplMethod = implMethod;
+            }
+
+            public bool Equals(VirtualResolutionFixupSignatureFixupKey other)
+            {
+                return FixupKind == other.FixupKind && DeclMethod.Equals(other.DeclMethod) && ImplType == other.ImplType && 
+                    ((ImplMethod == null && other.ImplMethod == null) || (ImplMethod != null && ImplMethod.Equals(other.ImplMethod)));
+            }
+
+            public override bool Equals(object obj)
+            {
+                return obj is VirtualResolutionFixupSignatureFixupKey other && Equals(other);
+            }
+
+            public override int GetHashCode()
+            {
+                if (ImplMethod != null)
+                    return HashCode.Combine(FixupKind, DeclMethod, ImplType, ImplMethod);
+                else
+                    return HashCode.Combine(FixupKind, DeclMethod, ImplType);
+            }
+
+            public override string ToString() => $"'{FixupKind}' '{DeclMethod}' on '{ImplType}' results in '{(ImplMethod != null ? ImplMethod.ToString() : "null")}'";
+        }
+
+        private NodeCache<VirtualResolutionFixupSignatureFixupKey, VirtualResolutionFixupSignature> _virtualResolutionSignatures;
+
+        public VirtualResolutionFixupSignature VirtualResolutionFixupSignature(ReadyToRunFixupKind fixupKind, MethodWithToken declMethod, TypeDesc implType, MethodWithToken implMethod)
+        {
+            return _virtualResolutionSignatures.GetOrAdd(new VirtualResolutionFixupSignatureFixupKey(fixupKind, declMethod, implType, implMethod));
+        }
+
         private struct ImportThunkKey : IEquatable<ImportThunkKey>
         {
             public readonly ReadyToRunHelper Helper;
diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRunSymbolNodeFactory.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRunSymbolNodeFactory.cs
index a5f6bbeb7c9e53..38b1893f531628 100644
--- a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRunSymbolNodeFactory.cs
+++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRunSymbolNodeFactory.cs
@@ -135,6 +135,11 @@ private void CreateNodeCaches()
                 );
             });
 
+            _virtualFunctionOverrideCache = new NodeCache<VirtualResolutionFixupSignature, ISymbolNode>(key =>
+            {
+                return new PrecodeHelperImport(_codegenNodeFactory, key);
+            });
+
             _genericLookupHelpers = new NodeCache<GenericLookupKey, ISymbolNode>(key =>
             {
                 return new DelayLoadHelperImport(
@@ -441,6 +446,15 @@ public ISymbolNode CheckTypeLayout(TypeDesc type)
             return _checkTypeLayoutCache.GetOrAdd(type);
         }
 
+        private NodeCache<VirtualResolutionFixupSignature, ISymbolNode> _virtualFunctionOverrideCache;
+
+        public ISymbolNode CheckVirtualFunctionOverride(MethodWithToken declMethod, TypeDesc implType, MethodWithToken implMethod)
+        {
+            return _virtualFunctionOverrideCache.GetOrAdd(_codegenNodeFactory.VirtualResolutionFixupSignature(
+                _verifyTypeAndFieldLayout ? ReadyToRunFixupKind.Verify_VirtualFunctionOverride : ReadyToRunFixupKind.Check_VirtualFunctionOverride,
+                declMethod, implType, implMethod));
+        }
+
         struct MethodAndCallSite : IEquatable<MethodAndCallSite>
         {
             public readonly MethodWithToken Method;
diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/NoMethodsCompilationModuleGroup.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/NoMethodsCompilationModuleGroup.cs
index a98dd12ef5b27e..beaf854a71adc2 100644
--- a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/NoMethodsCompilationModuleGroup.cs
+++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/NoMethodsCompilationModuleGroup.cs
@@ -16,7 +16,7 @@ namespace ILCompiler
     public class NoMethodsCompilationModuleGroup : ReadyToRunCompilationModuleGroupBase
     {
         public NoMethodsCompilationModuleGroup(
-            TypeSystemContext context,
+            CompilerTypeSystemContext context,
             bool isCompositeBuildMode,
             bool isInputBubble,
             IEnumerable<EcmaModule> compilationModuleSet,
diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/ReadyToRunCodegenCompilation.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/ReadyToRunCodegenCompilation.cs
index 0573222b6791be..1dce9f8f67f538 100644
--- a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/ReadyToRunCodegenCompilation.cs
+++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/ReadyToRunCodegenCompilation.cs
@@ -123,9 +123,9 @@ public bool IsEffectivelySealed(MethodDesc method)
             return _devirtualizationManager.IsEffectivelySealed(method);
         }
 
-        public MethodDesc ResolveVirtualMethod(MethodDesc declMethod, TypeDesc implType)
+        public MethodDesc ResolveVirtualMethod(MethodDesc declMethod, TypeDesc implType, out CORINFO_DEVIRTUALIZATION_DETAIL devirtualizationDetail)
         {
-            return _devirtualizationManager.ResolveVirtualMethod(declMethod, implType);
+            return _devirtualizationManager.ResolveVirtualMethod(declMethod, implType, out devirtualizationDetail);
         }
 
         public bool IsModuleInstrumented(ModuleDesc module)
diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/ReadyToRunCodegenCompilationBuilder.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/ReadyToRunCodegenCompilationBuilder.cs
index de5ca06d1d1e8d..fa4d3182e9afb6 100644
--- a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/ReadyToRunCodegenCompilationBuilder.cs
+++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/ReadyToRunCodegenCompilationBuilder.cs
@@ -248,7 +248,7 @@ public override ICompilation ToCompilation()
 
             NodeFactory factory = new NodeFactory(
                 _context,
-                _compilationGroup,
+                (ReadyToRunCompilationModuleGroupBase)_compilationGroup,
                 _profileData,
                 _nameMangler,
                 corHeaderNode,
diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/ReadyToRunCompilationModuleGroupBase.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/ReadyToRunCompilationModuleGroupBase.cs
index 92ef5346c770fd..08cdc64d09819d 100644
--- a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/ReadyToRunCompilationModuleGroupBase.cs
+++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/ReadyToRunCompilationModuleGroupBase.cs
@@ -23,12 +23,14 @@ public abstract class ReadyToRunCompilationModuleGroupBase : CompilationModuleGr
         private readonly bool _isInputBubble;
         private readonly ConcurrentDictionary<TypeDesc, CompilationUnitSet> _layoutCompilationUnits = new ConcurrentDictionary<TypeDesc, CompilationUnitSet>();
         private readonly ConcurrentDictionary<TypeDesc, bool> _versionsWithTypeCache = new ConcurrentDictionary<TypeDesc, bool>();
+        private readonly ConcurrentDictionary<TypeDesc, bool> _versionsWithTypeReferenceCache = new ConcurrentDictionary<TypeDesc, bool>();
         private readonly ConcurrentDictionary<MethodDesc, bool> _versionsWithMethodCache = new ConcurrentDictionary<MethodDesc, bool>();
         private readonly Dictionary<ModuleDesc, CompilationUnitIndex> _moduleCompilationUnits = new Dictionary<ModuleDesc, CompilationUnitIndex>();
         private CompilationUnitIndex _nextCompilationUnit = CompilationUnitIndex.FirstDynamicallyAssigned;
+        private ModuleTokenResolver _tokenResolver = null;
 
         public ReadyToRunCompilationModuleGroupBase(
-            TypeSystemContext context,
+            CompilerTypeSystemContext context,
             bool isCompositeBuildMode,
             bool isInputBubble,
             IEnumerable<EcmaModule> compilationModuleSet,
@@ -45,6 +47,16 @@ public ReadyToRunCompilationModuleGroupBase(
             _versionBubbleModuleSet.UnionWith(_compilationModuleSet);
 
             _compileGenericDependenciesFromVersionBubbleModuleSet = compileGenericDependenciesFromVersionBubbleModuleSet;
+
+            _tokenResolver = new ModuleTokenResolver(this, context);
+        }
+
+        public ModuleTokenResolver Resolver => _tokenResolver;
+
+        public void AssociateTokenResolver(ModuleTokenResolver tokenResolver)
+        {
+            Debug.Assert(_tokenResolver == null);
+            _tokenResolver = tokenResolver;
         }
 
         public sealed override bool ContainsType(TypeDesc type)
@@ -292,6 +304,11 @@ public sealed override bool VersionsWithType(TypeDesc typeDesc)
                 _versionsWithTypeCache.GetOrAdd(typeDesc, ComputeTypeVersionsWithCode);
         }
 
+        public sealed override bool VersionsWithTypeReference(TypeDesc typeDesc)
+        {
+            return _versionsWithTypeReferenceCache.GetOrAdd(typeDesc, ComputeTypeReferenceVersionsWithCode);
+        }
+
 
         public sealed override bool VersionsWithMethodBody(MethodDesc method)
         {
@@ -399,6 +416,74 @@ private bool ComputeTypeVersionsWithCode(TypeDesc type)
             return ComputeInstantiationVersionsWithCode(type.Instantiation, type);
         }
 
+        private bool ComputeTypeReferenceVersionsWithCode(TypeDesc type)
+        {
+            // Type represented by simple element type
+            if (type.IsPrimitive || type.IsVoid || type.IsObject || type.IsString)
+                return true;
+
+            if (VersionsWithType(type))
+                return true;
+
+            if (type.IsParameterizedType)
+            {
+                return VersionsWithTypeReference(type.GetParameterType());
+            }
+
+            if (type.IsFunctionPointer)
+            {
+                MethodSignature ptrSignature = ((FunctionPointerType)type).Signature;
+
+                if (!VersionsWithTypeReference(ptrSignature.ReturnType))
+                    return false;
+
+                for (int i = 0; i < ptrSignature.Length; i++)
+                {
+                    if (!VersionsWithTypeReference(ptrSignature[i]))
+                        return false;
+                }
+                if (ptrSignature.HasEmbeddedSignatureData)
+                {
+                    foreach (var embeddedSigData in ptrSignature.GetEmbeddedSignatureData())
+                    {
+                        if (embeddedSigData.type != null)
+                        {
+                            if (!VersionsWithTypeReference(embeddedSigData.type))
+                                return false;
+                        }
+                    }
+                }
+            }
+
+            if (type is EcmaType ecmaType)
+            {
+                return !_tokenResolver.GetModuleTokenForType(ecmaType, false).IsNull;
+            }
+
+            if (type.GetTypeDefinition() == type)
+            {
+                // Must not be an ECMA type, which are the only form of simple type which cannot reach here
+                return false;
+            }
+
+            if (type.HasInstantiation)
+            {
+                if (!VersionsWithTypeReference(type.GetTypeDefinition()))
+                    return false;
+
+                foreach (TypeDesc instParam in type.Instantiation)
+                {
+                    if (!VersionsWithTypeReference(instParam))
+                        return false;
+                }
+
+                return true;
+            }
+
+            Debug.Assert(false, "Unhandled form of type in VersionsWithTypeReference");
+            return false;
+        }
+
         private bool ComputeInstantiationVersionsWithCode(Instantiation inst, TypeSystemEntity entityWithInstantiation)
         {
             for (int iInstantiation = 0; iInstantiation < inst.Length; iInstantiation++)
@@ -407,7 +492,7 @@ private bool ComputeInstantiationVersionsWithCode(Instantiation inst, TypeSystem
 
                 if (!ComputeInstantiationTypeVersionsWithCode(this, instType))
                 {
-                    if (instType.IsPrimitive)
+                    if (instType.IsPrimitive || instType.IsObject || instType.IsString)
                     {
                         // Primitive type instantiations are only instantiated in the module of the generic defining type
                         // if the generic does not apply interface constraints to that type parameter, or if System.Private.CoreLib is part of the version bubble
@@ -423,8 +508,20 @@ private bool ComputeInstantiationVersionsWithCode(Instantiation inst, TypeSystem
                         }
 
                         GenericParameterDesc genericParam = (GenericParameterDesc)entityDefinitionInstantiation[iInstantiation];
-                        if (genericParam.HasReferenceTypeConstraint)
-                            return false;
+                        if (instType.IsPrimitive)
+                        {
+                            if (genericParam.HasReferenceTypeConstraint)
+                                return false;
+                        }
+                        else
+                        {
+                            Debug.Assert(instType.IsString || instType.IsObject);
+                            if (genericParam.HasNotNullableValueTypeConstraint)
+                                return false;
+
+                            if (instType.IsString && genericParam.HasDefaultConstructorConstraint)
+                                return false;
+                        }
 
                         // This checks to see if the type constraints list is empty
                         if (genericParam.TypeConstraints.GetEnumerator().MoveNext())
diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/ReadyToRunSingleAssemblyCompilationModuleGroup.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/ReadyToRunSingleAssemblyCompilationModuleGroup.cs
index 44c3da4633796d..f3c2bd46bc4563 100644
--- a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/ReadyToRunSingleAssemblyCompilationModuleGroup.cs
+++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/ReadyToRunSingleAssemblyCompilationModuleGroup.cs
@@ -17,7 +17,7 @@ public class ReadyToRunSingleAssemblyCompilationModuleGroup : ReadyToRunCompilat
         private bool _profileGuidedCompileRestrictionSet;
 
         public ReadyToRunSingleAssemblyCompilationModuleGroup(
-            TypeSystemContext context,
+            CompilerTypeSystemContext context,
             bool isCompositeBuildMode,
             bool isInputBubble,
             IEnumerable<EcmaModule> compilationModuleSet,
diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/SingleMethodCompilationModuleGroup.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/SingleMethodCompilationModuleGroup.cs
index ee98f72e438717..d091b8f21af34b 100644
--- a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/SingleMethodCompilationModuleGroup.cs
+++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/SingleMethodCompilationModuleGroup.cs
@@ -17,7 +17,7 @@ public class SingleMethodCompilationModuleGroup : ReadyToRunCompilationModuleGro
         private MethodDesc _method;
 
         public SingleMethodCompilationModuleGroup(
-            TypeSystemContext context,
+            CompilerTypeSystemContext context,
             bool isCompositeBuildMode,
             bool isInputBubble,
             IEnumerable<EcmaModule> compilationModuleSet,
diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/IBC/MIbcProfileParser.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/IBC/MIbcProfileParser.cs
index 22e54a8922adb8..07d8b0c53d0f7f 100644
--- a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/IBC/MIbcProfileParser.cs
+++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/IBC/MIbcProfileParser.cs
@@ -35,7 +35,7 @@ TypeSystemEntityOrUnknown IPgoSchemaDataLoader<TypeSystemEntityOrUnknown>.TypeFr
                 try
                 {
                     if (token == 0)
-                        return new TypeSystemEntityOrUnknown(0);
+                        return new TypeSystemEntityOrUnknown(null);
                     if ((token & 0xFF000000) == 0)
                     {
                         // token type is 0, therefore it can't be a type
diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/ILCompiler.ReadyToRun.csproj b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/ILCompiler.ReadyToRun.csproj
index bedb1ce62e3a8f..c1a8ea5d772129 100644
--- a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/ILCompiler.ReadyToRun.csproj
+++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/ILCompiler.ReadyToRun.csproj
@@ -181,6 +181,7 @@
     <Compile Include="Compiler\DependencyAnalysis\ReadyToRun\TransitionBlock.cs" />
     <Compile Include="Compiler\DependencyAnalysis\ReadyToRun\TypeFixupSignature.cs" />
     <Compile Include="Compiler\DependencyAnalysis\ReadyToRun\TypesTableNode.cs" />
+    <Compile Include="Compiler\DependencyAnalysis\ReadyToRun\VirtualResolutionFixupSignature.cs" />
     <Compile Include="Compiler\DependencyAnalysis\ReadyToRun\Win32ResourcesNode.cs" />
     <Compile Include="Compiler\DependencyAnalysis\ReadyToRunSymbolNodeFactory.cs" />
     <Compile Include="Compiler\DependencyAnalysis\SortableDependencyNodeCompilerSpecific.cs" />
diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/JitInterface/CorInfoImpl.ReadyToRun.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/JitInterface/CorInfoImpl.ReadyToRun.cs
index 0119522f0af4e4..e3da2dc734fef5 100644
--- a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/JitInterface/CorInfoImpl.ReadyToRun.cs
+++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/JitInterface/CorInfoImpl.ReadyToRun.cs
@@ -23,7 +23,7 @@
 using ILCompiler;
 using ILCompiler.DependencyAnalysis;
 using ILCompiler.DependencyAnalysis.ReadyToRun;
-
+using System.Text;
 
 namespace Internal.JitInterface
 {
@@ -221,6 +221,9 @@ public override int GetHashCode()
 
         public bool Equals(MethodWithToken methodWithToken)
         {
+            if (methodWithToken == null)
+                return false;
+
             bool equals = Method == methodWithToken.Method && Token.Equals(methodWithToken.Token)
                 && OwningType == methodWithToken.OwningType && ConstrainedType == methodWithToken.ConstrainedType
                 && Unboxing == methodWithToken.Unboxing;
@@ -247,6 +250,24 @@ public void AppendMangledName(NameMangler nameMangler, Utf8StringBuilder sb)
                 sb.Append("; UNBOXING");
         }
 
+        public override string ToString()
+        {
+            StringBuilder debuggingName = new StringBuilder();
+            debuggingName.Append(Method.ToString());
+            if (ConstrainedType != null)
+            {
+                debuggingName.Append(" @ ");
+                debuggingName.Append(ConstrainedType.ToString());
+            }
+
+            debuggingName.Append("; ");
+            debuggingName.Append(Token.ToString());
+            if (Unboxing)
+                debuggingName.Append("; UNBOXING");
+
+            return debuggingName.ToString();
+        }
+
         public int CompareTo(MethodWithToken other, TypeSystemComparer comparer)
         {
             int result;
@@ -918,7 +939,9 @@ private MethodWithToken ComputeMethodWithToken(MethodDesc method, ref CORINFO_RE
 
         private ModuleToken HandleToModuleToken(ref CORINFO_RESOLVED_TOKEN pResolvedToken, MethodDesc methodDesc, out object context, ref TypeDesc constrainedType)
         {
-            if (methodDesc != null && (_compilation.NodeFactory.CompilationModuleGroup.VersionsWithMethodBody(methodDesc) || methodDesc.IsPInvoke))
+            if (methodDesc != null && (_compilation.NodeFactory.CompilationModuleGroup.VersionsWithMethodBody(methodDesc) 
+                || (pResolvedToken.tokenType == CorInfoTokenKind.CORINFO_TOKENKIND_DevirtualizedMethod) 
+                || methodDesc.IsPInvoke))
             {
                 if ((CorTokenType)(unchecked((uint)pResolvedToken.token) & 0xFF000000u) == CorTokenType.mdtMethodDef &&
                     methodDesc?.GetTypicalMethodDefinition() is EcmaMethod ecmaMethod)
@@ -954,8 +977,8 @@ private ModuleToken HandleToModuleToken(ref CORINFO_RESOLVED_TOKEN pResolvedToke
             // within the current version bubble**, but this happens to be good enough because
             // we only do this replacement within CoreLib to replace method bodies in places
             // that we cannot express in C# right now and for p/invokes in large version bubbles).
-            MethodIL methodILDef = methodIL.GetMethodILDefinition();
-            bool isFauxMethodIL = !(methodILDef is EcmaMethodIL);
+            MethodILScope methodILDef = methodIL.GetMethodILScopeDefinition();
+            bool isFauxMethodIL = !(methodILDef is IEcmaMethodIL);
             if (isFauxMethodIL)
             {
                 object resultDef = methodILDef.GetObject((int)pResolvedToken.token);
@@ -1015,10 +1038,10 @@ private ModuleToken HandleToModuleToken(ref CORINFO_RESOLVED_TOKEN pResolvedToke
 
         private InfoAccessType constructStringLiteral(CORINFO_MODULE_STRUCT_* module, mdToken metaTok, ref void* ppValue)
         {
-            MethodIL methodIL = HandleToObject(module);
+            MethodILScope methodIL = HandleToObject(module);
 
             // If this is not a MethodIL backed by a physical method body, we need to remap the token.
-            Debug.Assert(methodIL.GetMethodILDefinition() is EcmaMethodIL);
+            Debug.Assert(methodIL.GetMethodILScopeDefinition() is EcmaMethodIL);
 
             EcmaMethod method = (EcmaMethod)methodIL.OwningMethod.GetTypicalMethodDefinition();
             ISymbolNode stringObject = _compilation.SymbolNodeFactory.StringLiteral(
@@ -1523,7 +1546,7 @@ private void ceeInfoGetCallInfo(
                     exactType == MethodBeingCompiled.OwningType)
                 {
                     var methodIL = HandleToObject(pResolvedToken.tokenScope);
-                    var rawMethod = (MethodDesc)methodIL.GetMethodILDefinition().GetObject((int)pResolvedToken.token);
+                    var rawMethod = (MethodDesc)methodIL.GetMethodILScopeDefinition().GetObject((int)pResolvedToken.token);
                     if (IsTypeSpecForTypicalInstantiation(rawMethod.OwningType))
                     {
                         pResult->contextHandle = contextFromMethodBeingCompiled();
diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/ObjectWriter/R2RPEBuilder.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/ObjectWriter/R2RPEBuilder.cs
index 3f6764b0e804ba..c7212368ace07a 100644
--- a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/ObjectWriter/R2RPEBuilder.cs
+++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/ObjectWriter/R2RPEBuilder.cs
@@ -489,7 +489,7 @@ private void SetPEHeaderTimeStamp(Stream outputStream, int timeDateStamp)
                 DosHeaderSize +
                 PESignatureSize +
                 sizeof(short) +     // Machine
-                sizeof(short);      //NumberOfSections
+                sizeof(short);      // NumberOfSections
 
             outputStream.Seek(seekSize, SeekOrigin.Begin);
             outputStream.Write(patchedTimestamp, 0, patchedTimestamp.Length);
@@ -664,52 +664,28 @@ protected override BlobBuilder SerializeSection(string name, SectionLocation loc
     }
     
     /// <summary>
-    /// Simple helper for filling in PE header information by either copying over
-    /// data from a pre-existing input PE header (used for single-assembly R2R files)
-    /// or by explicitly specifying the image characteristics (for composite R2R).
+    /// Simple helper for filling in PE header information.
     /// </summary>
     static class PEHeaderProvider
     {
-        /// <summary>
-        /// Copy PE headers into a PEHeaderBuilder used by PEBuilder.
-        /// </summary>
-        /// <param name="peHeaders">Headers to copy</param>
-        /// <param name="target">Target architecture to set in the header</param>
-        public static PEHeaderBuilder Copy(PEHeaders peHeaders, TargetDetails target)
-        {
-            return Create(
-                peHeaders.CoffHeader.Characteristics,
-                peHeaders.PEHeader.DllCharacteristics,
-                peHeaders.PEHeader.Subsystem,
-                target);
-        }
-
         /// <summary>
         /// Fill in PE header information into a PEHeaderBuilder used by PEBuilder.
         /// </summary>
-        /// <param name="relocsStripped">Relocs are not present in the PE executable</param>
-        /// <param name="dllCharacteristics">Extra DLL characteristics to apply</param>
         /// <param name="subsystem">Targeting subsystem</param>
         /// <param name="target">Target architecture to set in the header</param>
-        public static PEHeaderBuilder Create(Characteristics imageCharacteristics, DllCharacteristics dllCharacteristics, Subsystem subsystem, TargetDetails target)
+        public static PEHeaderBuilder Create(Subsystem subsystem, TargetDetails target)
         {
             bool is64BitTarget = target.PointerSize == sizeof(long);
 
-            imageCharacteristics &= ~(Characteristics.Bit32Machine | Characteristics.LargeAddressAware);
-            imageCharacteristics |= (is64BitTarget ? Characteristics.LargeAddressAware : Characteristics.Bit32Machine);
+            Characteristics imageCharacteristics = Characteristics.ExecutableImage | Characteristics.Dll;
+            imageCharacteristics |= is64BitTarget ? Characteristics.LargeAddressAware : Characteristics.Bit32Machine;
 
-            ulong imageBase = PE32HeaderConstants.ImageBase;
-            if (target.IsWindows && is64BitTarget && (imageBase <= uint.MaxValue))
-            {
-                // Base addresses below 4 GiB are reserved for WoW on x64 and disallowed on ARM64.
-                // If the input assembly was compiled for anycpu, its base address is 32-bit and we need to fix it.
-                imageBase = (imageCharacteristics & Characteristics.Dll) != 0 ? PE64HeaderConstants.DllImageBase : PE64HeaderConstants.ExeImageBase;
-            }
+            ulong imageBase = is64BitTarget ? PE64HeaderConstants.DllImageBase : PE32HeaderConstants.ImageBase;
 
             int fileAlignment = 0x200;
             if (!target.IsWindows && !is64BitTarget)
             {
-                // To minimize wasted VA space on 32 bit systems align file to page bounaries (presumed to be 4K).
+                // To minimize wasted VA space on 32-bit systems, align file to page boundaries (presumed to be 4K)
                 fileAlignment = 0x1000;
             }
 
@@ -721,13 +697,11 @@ public static PEHeaderBuilder Create(Characteristics imageCharacteristics, DllCh
                 sectionAlignment = fileAlignment;
             }
 
-            dllCharacteristics &= DllCharacteristics.AppContainer;
-
-            // In Crossgen1, this is under a debug-specific condition 'if (0 == CLRConfig::GetConfigValue(CLRConfig::INTERNAL_NoASLRForNgen))'
-            dllCharacteristics |= DllCharacteristics.DynamicBase;
-
             // Without NxCompatible the PE executable cannot execute on Windows ARM64
-            dllCharacteristics |= DllCharacteristics.NxCompatible | DllCharacteristics.TerminalServerAware;
+            DllCharacteristics dllCharacteristics =
+                DllCharacteristics.DynamicBase |
+                DllCharacteristics.NxCompatible |
+                DllCharacteristics.TerminalServerAware;
 
             if (is64BitTarget)
             {
diff --git a/src/coreclr/tools/aot/ILCompiler.Reflection.ReadyToRun/ILCompiler.Reflection.ReadyToRun.csproj b/src/coreclr/tools/aot/ILCompiler.Reflection.ReadyToRun/ILCompiler.Reflection.ReadyToRun.csproj
index 6259c0639e36db..1424375efc4e33 100644
--- a/src/coreclr/tools/aot/ILCompiler.Reflection.ReadyToRun/ILCompiler.Reflection.ReadyToRun.csproj
+++ b/src/coreclr/tools/aot/ILCompiler.Reflection.ReadyToRun/ILCompiler.Reflection.ReadyToRun.csproj
@@ -14,7 +14,6 @@
     <OutputPath>$(RuntimeBinDir)</OutputPath>
     <Platforms>AnyCPU;x64</Platforms>
     <PlatformTarget>AnyCPU</PlatformTarget>
-    <LangVersion>7.3</LangVersion>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/src/coreclr/tools/aot/ILCompiler.Reflection.ReadyToRun/ReadyToRunMethod.cs b/src/coreclr/tools/aot/ILCompiler.Reflection.ReadyToRun/ReadyToRunMethod.cs
index 18ca5eb3b0816f..9032ef27421797 100644
--- a/src/coreclr/tools/aot/ILCompiler.Reflection.ReadyToRun/ReadyToRunMethod.cs
+++ b/src/coreclr/tools/aot/ILCompiler.Reflection.ReadyToRun/ReadyToRunMethod.cs
@@ -305,7 +305,7 @@ private void EnsureRuntimeFunctions()
             if (this._runtimeFunctions == null)
             {
                 this._runtimeFunctions = new List<RuntimeFunction>();
-                this.ParseRuntimeFunctions();
+                this.ParseRuntimeFunctions(false);
             }
         }
 
@@ -474,17 +474,21 @@ public ReadyToRunMethod(
 
         private void EnsureInitialized()
         {
-            if (_gcInfo == null && GcInfoRva != 0)
+            if (_gcInfo == null)
             {
-                int gcInfoOffset = _readyToRunReader.CompositeReader.GetOffset(GcInfoRva);
-                if (_readyToRunReader.Machine == Machine.I386)
-                {
-                    _gcInfo = new x86.GcInfo(_readyToRunReader.Image, gcInfoOffset, _readyToRunReader.Machine, _readyToRunReader.ReadyToRunHeader.MajorVersion);
-                }
-                else
+                ParseRuntimeFunctions(true);
+                if (GcInfoRva != 0)
                 {
-                    // Arm and Arm64 use the same GcInfo format as Amd64
-                    _gcInfo = new Amd64.GcInfo(_readyToRunReader.Image, gcInfoOffset, _readyToRunReader.Machine, _readyToRunReader.ReadyToRunHeader.MajorVersion);
+                    int gcInfoOffset = _readyToRunReader.CompositeReader.GetOffset(GcInfoRva);
+                    if (_readyToRunReader.Machine == Machine.I386)
+                    {
+                        _gcInfo = new x86.GcInfo(_readyToRunReader.Image, gcInfoOffset, _readyToRunReader.Machine, _readyToRunReader.ReadyToRunHeader.MajorVersion);
+                    }
+                    else
+                    {
+                        // Arm and Arm64 use the same GcInfo format as Amd64
+                        _gcInfo = new Amd64.GcInfo(_readyToRunReader.Image, gcInfoOffset, _readyToRunReader.Machine, _readyToRunReader.ReadyToRunHeader.MajorVersion);
+                    }
                 }
             }
             if (_pgoInfo == null)
@@ -547,7 +551,7 @@ private void EnsureFixupCells()
         /// Get the RVAs of the runtime functions for each method
         /// based on <a href="https://github.com/dotnet/coreclr/blob/master/src/zap/zapcode.cpp">ZapUnwindInfo::Save</a>
         /// </summary>
-        private void ParseRuntimeFunctions()
+        private void ParseRuntimeFunctions(bool partial)
         {
             int runtimeFunctionId = EntryPointRuntimeFunctionId;
             int runtimeFunctionSize = _readyToRunReader.CalculateRuntimeFunctionSize();
@@ -602,6 +606,11 @@ private void ParseRuntimeFunctions()
                     }
                 }
 
+                if (partial)
+                {
+                    return;
+                }
+
                 RuntimeFunction rtf = new RuntimeFunction(
                     _readyToRunReader,
                     runtimeFunctionId,
diff --git a/src/coreclr/tools/aot/ILCompiler.Reflection.ReadyToRun/ReadyToRunSignature.cs b/src/coreclr/tools/aot/ILCompiler.Reflection.ReadyToRun/ReadyToRunSignature.cs
index 91a1da0cdb06f7..a71ad97519f5c3 100644
--- a/src/coreclr/tools/aot/ILCompiler.Reflection.ReadyToRun/ReadyToRunSignature.cs
+++ b/src/coreclr/tools/aot/ILCompiler.Reflection.ReadyToRun/ReadyToRunSignature.cs
@@ -457,14 +457,16 @@ protected void UpdateOffset(int offset)
         /// </summary>
         /// <param name="r2rReader">R2RReader object representing the PE file containing the ECMA metadata</param>
         /// <param name="offset">Signature offset within the PE file byte array</param>
-        public R2RSignatureDecoder(IR2RSignatureTypeProvider<TType, TMethod, TGenericContext> provider, TGenericContext context, MetadataReader metadataReader, ReadyToRunReader r2rReader, int offset)
+        public R2RSignatureDecoder(IR2RSignatureTypeProvider<TType, TMethod, TGenericContext> provider, TGenericContext context, MetadataReader metadataReader, ReadyToRunReader r2rReader, int offset, bool skipOverrideMetadataReader = false)
         {
             Context = context;
             _provider = provider;
             _image = r2rReader.Image;
             _originalOffset = _offset = offset;
             _contextReader = r2rReader;
-            MetadataReader moduleOverrideMetadataReader = TryGetModuleOverrideMetadataReader();
+            MetadataReader moduleOverrideMetadataReader = null;
+            if (!skipOverrideMetadataReader)
+                moduleOverrideMetadataReader = TryGetModuleOverrideMetadataReader();
             _metadataReader = moduleOverrideMetadataReader ?? metadataReader;
             _outerReader = moduleOverrideMetadataReader ?? metadataReader;
             Reset();
@@ -479,14 +481,16 @@ public R2RSignatureDecoder(IR2RSignatureTypeProvider<TType, TMethod, TGenericCon
         /// <param name="offset">Signature offset within the signature byte array</param>
         /// <param name="outerReader">Metadata reader representing the outer signature context</param>
         /// <param name="contextReader">Top-level signature context reader</param>
-        public R2RSignatureDecoder(IR2RSignatureTypeProvider<TType, TMethod, TGenericContext> provider, TGenericContext context, MetadataReader metadataReader, byte[] signature, int offset, MetadataReader outerReader, ReadyToRunReader contextReader)
+        public R2RSignatureDecoder(IR2RSignatureTypeProvider<TType, TMethod, TGenericContext> provider, TGenericContext context, MetadataReader metadataReader, byte[] signature, int offset, MetadataReader outerReader, ReadyToRunReader contextReader, bool skipOverrideMetadataReader = false)
         {
             Context = context;
             _provider = provider;
             _image = signature;
             _originalOffset = _offset = offset;
             _contextReader = contextReader;
-            MetadataReader moduleOverrideMetadataReader = TryGetModuleOverrideMetadataReader();
+            MetadataReader moduleOverrideMetadataReader = null;
+            if (!skipOverrideMetadataReader)
+                moduleOverrideMetadataReader = TryGetModuleOverrideMetadataReader();
             _metadataReader = moduleOverrideMetadataReader ?? metadataReader;
             _outerReader = moduleOverrideMetadataReader ?? outerReader;
             Reset();
@@ -805,6 +809,24 @@ public TMethod ParseMethod()
         {
             uint methodFlags = ReadUInt();
 
+            if ((methodFlags & (uint)ReadyToRunMethodSigFlags.READYTORUN_METHOD_SIG_UpdateContext) != 0)
+            {
+                int moduleIndex = (int)ReadUInt();
+                IAssemblyMetadata refAsmReader = _contextReader.OpenReferenceAssembly(moduleIndex);
+                var refAsmDecoder = new R2RSignatureDecoder<TType, TMethod, TGenericContext>(_provider, Context, refAsmReader.MetadataReader, _image, _offset, _outerReader, _contextReader, skipOverrideMetadataReader: true);
+                var result = refAsmDecoder.ParseMethodWithMethodFlags(methodFlags);
+                _offset = refAsmDecoder.Offset;
+                return result;
+            }
+            else
+            {
+                return ParseMethodWithMethodFlags(methodFlags);
+            }
+        }
+
+
+        private TMethod ParseMethodWithMethodFlags(uint methodFlags)
+        {
             TType owningTypeOverride = default(TType);
             if ((methodFlags & (uint)ReadyToRunMethodSigFlags.READYTORUN_METHOD_SIG_OwnerType) != 0)
             {
@@ -1348,6 +1370,28 @@ private ReadyToRunSignature ParseSignature(ReadyToRunFixupKind fixupType, String
                         builder.Append(" (VERIFY_TYPE_LAYOUT)");
                     break;
 
+                case ReadyToRunFixupKind.Check_VirtualFunctionOverride:
+                case ReadyToRunFixupKind.Verify_VirtualFunctionOverride:
+                    ReadyToRunVirtualFunctionOverrideFlags flags = (ReadyToRunVirtualFunctionOverrideFlags)ReadUInt();
+                    ParseMethod(builder);
+                    builder.Append($" ImplType :");
+                    ParseType(builder);
+                    if (flags.HasFlag(ReadyToRunVirtualFunctionOverrideFlags.VirtualFunctionOverriden))
+                    {
+                        builder.Append($" ImplMethod :");
+                        ParseMethod(builder);
+                    }
+                    else
+                    {
+                        builder.Append("Not Overriden");
+                    }
+
+                    if (fixupType == ReadyToRunFixupKind.Check_TypeLayout)
+                        builder.Append(" (CHECK_VIRTUAL_FUNCTION_OVERRIDE)");
+                    else
+                        builder.Append(" (VERIFY_VIRTUAL_FUNCTION_OVERRIDE)");
+                    break;
+
                 case ReadyToRunFixupKind.Check_FieldOffset:
                     builder.Append($"{ReadUInt()} ");
                     ParseField(builder);
diff --git a/src/coreclr/tools/aot/ILCompiler.TypeSystem.ReadyToRun.Tests/InstanceFieldLayoutTests.cs b/src/coreclr/tools/aot/ILCompiler.TypeSystem.ReadyToRun.Tests/InstanceFieldLayoutTests.cs
index 03b5b160fdaf87..e92749b5ab272d 100644
--- a/src/coreclr/tools/aot/ILCompiler.TypeSystem.ReadyToRun.Tests/InstanceFieldLayoutTests.cs
+++ b/src/coreclr/tools/aot/ILCompiler.TypeSystem.ReadyToRun.Tests/InstanceFieldLayoutTests.cs
@@ -96,12 +96,12 @@ public void TestExplicitTypeLayoutWithInheritance()
                 if (f.Name == "Lol")
                 {
                     // First field after base class, with offset 0 so it should lie on the byte count of 
-                    // the base class = 24
+                    // the base class = 20
                     Assert.Equal(20, f.Offset.AsInt);
                 }
                 else if (f.Name == "Omg")
                 {
-                    // Offset 20 from base class byte count = 44
+                    // Offset 20 from base class byte count = 40
                     Assert.Equal(40, f.Offset.AsInt);
                 }
                 else
diff --git a/src/coreclr/tools/aot/ILCompiler.TypeSystem.ReadyToRun.Tests/MarshalUtilsTests.cs b/src/coreclr/tools/aot/ILCompiler.TypeSystem.ReadyToRun.Tests/MarshalUtilsTests.cs
index c3befa87af72d4..3523f5d62f8e14 100644
--- a/src/coreclr/tools/aot/ILCompiler.TypeSystem.ReadyToRun.Tests/MarshalUtilsTests.cs
+++ b/src/coreclr/tools/aot/ILCompiler.TypeSystem.ReadyToRun.Tests/MarshalUtilsTests.cs
@@ -74,10 +74,10 @@ public void IsBlittableType_TypeWithBlittableBase_ReturnsTrue(string className)
         [InlineData("ClassWithExplicitEmptyBase")]
         [InlineData("ClassWithExplicitEmptySizeZeroBase")]
         [InlineData("ClassWithSequentialEmptyBase")]
-        public void IsBlittableType_TypeWithEmptyBase_ReturnsFalse(string className)
+        public void IsBlittableType_TypeWithEmptyBase_ReturnsTrue(string className)
         {
             TypeDesc classWithEmptyBase = _testModule.GetType("Marshalling", className);
-            Assert.False(MarshalUtils.IsBlittableType(classWithEmptyBase));
+            Assert.True(MarshalUtils.IsBlittableType(classWithEmptyBase));
         }
     }
 }
diff --git a/src/coreclr/tools/dotnet-pgo/Program.cs b/src/coreclr/tools/dotnet-pgo/Program.cs
index b8828d7df6fb6c..00ee6f87121366 100644
--- a/src/coreclr/tools/dotnet-pgo/Program.cs
+++ b/src/coreclr/tools/dotnet-pgo/Program.cs
@@ -396,28 +396,31 @@ static int InnerCompareMibcMain(CommandLineOptions options)
             FileInfo file1 = options.CompareMibc[0];
             FileInfo file2 = options.CompareMibc[1];
 
+            // Look for the shortest unique names for the input files.
+            string name1 = file1.Name;
+            string name2 = file2.Name;
+            string path1 = Path.GetDirectoryName(file1.FullName);
+            string path2 = Path.GetDirectoryName(file2.FullName);
+            while (name1 == name2)
+            {
+                name1 = Path.Combine(Path.GetFileName(path1), name1);
+                name2 = Path.Combine(Path.GetFileName(path2), name2);
+                path1 = Path.GetDirectoryName(path1);
+                path2 = Path.GetDirectoryName(path2);
+            }
+
             PEReader mibc1 = MIbcProfileParser.OpenMibcAsPEReader(file1.FullName);
             PEReader mibc2 = MIbcProfileParser.OpenMibcAsPEReader(file2.FullName);
             var tsc = new TypeRefTypeSystem.TypeRefTypeSystemContext(new PEReader[] { mibc1, mibc2 });
 
             ProfileData profile1 = MIbcProfileParser.ParseMIbcFile(tsc, mibc1, null, onlyDefinedInAssembly: null);
             ProfileData profile2 = MIbcProfileParser.ParseMIbcFile(tsc, mibc2, null, onlyDefinedInAssembly: null);
-            PrintOutput($"Comparing {file1.Name} to {file2.Name}");
-            PrintOutput($"Statistics for {file1.Name}");
-            PrintStats(profile1, file1.Name, profile2, file2.Name);
+            PrintOutput($"Comparing {name1} to {name2}");
+            PrintOutput($"Statistics for {name1}");
+            PrintMibcStats(profile1);
             PrintOutput("");
-            PrintOutput($"Statistics for {file2.Name}");
-            PrintStats(profile2, file2.Name, profile1, file1.Name);
-
-            static void PrintStats(ProfileData self, string selfName, ProfileData other, string otherName)
-            {
-                var methods = self.GetAllMethodProfileData().ToList();
-                var profiledMethods = methods.Where(spd => spd.SchemaData != null).ToList();
-                var otherMethods = other.GetAllMethodProfileData().ToList();
-                var otherProfiledMethods = otherMethods.Where(spd => spd.SchemaData != null).ToList();
-                PrintMibcStats(self);
-                PrintOutput($"# Profiled methods in {selfName} not in {otherName}: {profiledMethods.Select(m => m.Method).Except(otherProfiledMethods.Select(m => m.Method)).Count()}");
-            }
+            PrintOutput($"Statistics for {name2}");
+            PrintMibcStats(profile2);
 
             PrintOutput("");
             PrintOutput("Comparison");
@@ -426,6 +429,8 @@ static void PrintStats(ProfileData self, string selfName, ProfileData other, str
             var profiledMethods1 = methods1.Where(m => m.SchemaData != null).ToList();
             var profiledMethods2 = methods2.Where(m => m.SchemaData != null).ToList();
 
+            PrintOutput($"# Profiled methods in {name1} not in {name2}: {profiledMethods1.Select(m => m.Method).Except(profiledMethods2.Select(m => m.Method)).Count()}");
+            PrintOutput($"# Profiled methods in {name2} not in {name1}: {profiledMethods2.Select(m => m.Method).Except(profiledMethods1.Select(m => m.Method)).Count()}");
             PrintOutput($"# Methods with profile data in both .mibc files: {profiledMethods1.Select(m => m.Method).Intersect(profiledMethods2.Select(m => m.Method)).Count()}");
             var fgMatches = new List<(MethodProfileData prof1, MethodProfileData prof2)>();
             var fgMismatches = new List<(MethodProfileData prof1, MethodProfileData prof2, List<string> mismatches)>();
@@ -436,16 +441,6 @@ static void PrintStats(ProfileData self, string selfName, ProfileData other, str
                 if (prof2?.SchemaData == null)
                     continue;
 
-                Dictionary<int, PgoSchemaElem> GroupBlocks(MethodProfileData data)
-                    => data.SchemaData
-                       .Where(e => e.InstrumentationKind == PgoInstrumentationKind.BasicBlockIntCount || e.InstrumentationKind == PgoInstrumentationKind.BasicBlockLongCount)
-                       .ToDictionary(e => e.ILOffset);
-
-                Dictionary<(int, int), PgoSchemaElem> GroupEdges(MethodProfileData data)
-                    => data.SchemaData
-                       .Where(e => e.InstrumentationKind == PgoInstrumentationKind.EdgeIntCount || e.InstrumentationKind == PgoInstrumentationKind.EdgeLongCount)
-                       .ToDictionary(e => (e.ILOffset, e.Other));
-
                 var (blocks1, blocks2) = (GroupBlocks(prof1), GroupBlocks(prof2));
                 var (edges1, edges2) = (GroupEdges(prof1), GroupEdges(prof2));
 
@@ -456,9 +451,9 @@ Dictionary<int, PgoSchemaElem> GroupBlocks(MethodProfileData data)
                     var in2 = blocks2.Keys.Where(k => !blocks1.ContainsKey(k)).ToList();
 
                     foreach (var m1 in in1)
-                        mismatches.Add($"{file1.Name} has a block at {m1:x} not present in {file2.Name}");
+                        mismatches.Add($"{name1} has a block at {m1:x} not present in {name2}");
                     foreach (var m2 in in2)
-                        mismatches.Add($"{file2.Name} has a block at {m2:x} not present in {file1.Name}");
+                        mismatches.Add($"{name2} has a block at {m2:x} not present in {name1}");
                 }
 
                 if (edges1.Count > 0 && edges2.Count > 0)
@@ -467,9 +462,9 @@ Dictionary<int, PgoSchemaElem> GroupBlocks(MethodProfileData data)
                     var in2 = edges2.Keys.Where(k => !edges1.ContainsKey(k)).ToList();
 
                     foreach (var (from, to) in in1)
-                        mismatches.Add($"{file1.Name} has an edge {from:x}->{to:x} not present in {file2.Name}");
+                        mismatches.Add($"{name1} has an edge {from:x}->{to:x} not present in {name2}");
                     foreach (var (from, to) in in2)
-                        mismatches.Add($"{file2.Name} has an edge {from:x}->{to:x} not present in {file1.Name}");
+                        mismatches.Add($"{name2} has an edge {from:x}->{to:x} not present in {name1}");
                 }
 
                 if (mismatches.Count > 0)
@@ -495,10 +490,10 @@ Dictionary<int, PgoSchemaElem> GroupBlocks(MethodProfileData data)
             if (fgMatches.Count > 0)
             {
                 PrintOutput("");
-                PrintOutput($"When comparing the flow-graphs of the matching methods, their overlaps break down as follows:");
+                PrintOutput($"Comparing methods with matching flow-graphs");
 
-                List<double> blockOverlaps = new List<double>();
-                List<double> edgeOverlaps = new List<double>();
+                var blockOverlaps = new List<(MethodDesc Method, double Overlap)>();
+                var edgeOverlaps = new List<(MethodDesc Method, double Overlap)>();
 
                 foreach ((MethodProfileData prof1, MethodProfileData prof2) in fgMatches)
                 {
@@ -512,6 +507,12 @@ double Overlap<TKey>(Dictionary<TKey, PgoSchemaElem> left, Dictionary<TKey, PgoS
                         Debug.Assert(left.Keys.All(k => right.ContainsKey(k)));
                         Debug.Assert(right.Keys.All(k => left.ContainsKey(k)));
 
+                        if (leftTotal == 0 && rightTotal == 0)
+                            return 1;
+
+                        if (leftTotal == 0 || rightTotal == 0)
+                            return 0;
+
                         var leftPW = left.ToDictionary(k => k.Key, k => k.Value.DataLong / (double)leftTotal);
                         var rightPW = right.ToDictionary(k => k.Key, k => k.Value.DataLong / (double)rightTotal);
 
@@ -519,26 +520,27 @@ double Overlap<TKey>(Dictionary<TKey, PgoSchemaElem> left, Dictionary<TKey, PgoS
                         return overlap;
                     }
 
+                    Debug.Assert(prof1.Method == prof2.Method);
                     if (blocks1.Count > 0 && blocks2.Count > 0)
-                        blockOverlaps.Add(Overlap(blocks1, blocks2));
+                        blockOverlaps.Add((prof1.Method, Overlap(blocks1, blocks2)));
 
                     if (edges1.Count > 0 && edges2.Count > 0)
-                        edgeOverlaps.Add(Overlap(edges1, edges2));
+                        edgeOverlaps.Add((prof1.Method, Overlap(edges1, edges2)));
                 }
 
-                void PrintHistogram(List<double> overlaps)
+                void PrintHistogram(List<(MethodDesc Method, double Overlap)> overlaps)
                 {
                     int maxWidth = Console.WindowWidth - 10;
                     const int maxLabelWidth = 4; // to print "100%".
                     int barMaxWidth = maxWidth - (maxLabelWidth + 10); // Leave 10 chars for writing other things on the line
                     const int bucketSize = 5;
                     int width = Console.WindowWidth - 10;
-                    var sorted = overlaps.OrderByDescending(d => d).ToList();
+                    var sorted = overlaps.OrderByDescending(t => t.Overlap).ToList();
 
                     void PrintBar(string label, ref int curIndex, Func<double, bool> include, bool forcePrint)
                     {
                         int count = 0;
-                        while (curIndex < sorted.Count && include(sorted[curIndex]))
+                        while (curIndex < sorted.Count && include(sorted[curIndex].Overlap))
                         {
                             count++;
                             curIndex++;
@@ -574,23 +576,85 @@ void PrintBar(string label, ref int curIndex, Func<double, bool> include, bool f
                     for (int proportion = 100 - bucketSize; proportion >= 0; proportion -= bucketSize)
                         PrintBar($">{(int)proportion,2}%", ref curIndex, d => d * 100 > proportion, true);
                     PrintBar("0%", ref curIndex, d => true, false);
+
+                    var wtf = sorted.Where(t => double.IsNaN(t.Overlap)).ToList();
+                    PrintOutput(FormattableString.Invariant($"The average overlap is {sorted.Average(t => t.Overlap)*100:F2}% for the {sorted.Count} methods with matching flow graphs and profile data"));
+                    double mse = sorted.Sum(t => (100 - t.Overlap*100) * (100 - t.Overlap*100)) / sorted.Count;
+                    PrintOutput(FormattableString.Invariant($"The mean squared error is {mse:F2}"));
+                    PrintOutput(FormattableString.Invariant($"There are {sorted.Count(t => t.Overlap < 0.5)}/{sorted.Count} methods with overlaps < 50%:"));
+                    foreach (var badMethod in sorted.Where(t => t.Overlap < 0.5).OrderBy(t => t.Overlap))
+                    {
+                        PrintOutput(FormattableString.Invariant($"  {badMethod.Method} ({badMethod.Overlap * 100:F2}%)"));
+                    }
                 }
 
                 // Need UTF8 for the block chars.
                 Console.OutputEncoding = Encoding.UTF8;
                 if (blockOverlaps.Count > 0)
                 {
+                    PrintOutput("The overlap of the block counts break down as follows:");
                     PrintHistogram(blockOverlaps);
-                    PrintOutput("(using block counts)");
+                    PrintOutput("");
                 }
 
                 if (edgeOverlaps.Count > 0)
                 {
-                    if (blockOverlaps.Count > 0)
-                        PrintOutput("");
-
+                    PrintOutput("The overlap of the edge counts break down as follows:");
                     PrintHistogram(edgeOverlaps);
-                    PrintOutput("(using edge counts)");
+                    PrintOutput("");
+                }
+
+                var changes = new List<(MethodDesc method, int ilOffset, GetLikelyClassResult result1, GetLikelyClassResult result2)>();
+                int devirtToSame = 0;
+                int devirtToSameLikelihood100 = 0;
+                int devirtToSameLikelihood70 = 0;
+                foreach ((MethodProfileData prof1, MethodProfileData prof2) in fgMatches)
+                {
+                    List<int> typeHandleHistogramCallSites =
+                        prof1.SchemaData.Concat(prof2.SchemaData)
+                        .Where(e => e.InstrumentationKind == PgoInstrumentationKind.GetLikelyClass || e.InstrumentationKind == PgoInstrumentationKind.TypeHandleHistogramTypeHandle)
+                        .Select(e => e.ILOffset)
+                        .Distinct()
+                        .ToList();
+
+                    foreach (int callsite in typeHandleHistogramCallSites)
+                    {
+                        GetLikelyClassResult result1 = GetLikelyClass(prof1.SchemaData, callsite);
+                        GetLikelyClassResult result2 = GetLikelyClass(prof2.SchemaData, callsite);
+                        if (result1.Devirtualizes != result2.Devirtualizes || (result1.Devirtualizes && result2.Devirtualizes && result1.Type != result2.Type))
+                            changes.Add((prof1.Method, callsite, result1, result2));
+
+                        if (result1.Devirtualizes && result2.Devirtualizes && result1.Type == result2.Type)
+                        {
+                            devirtToSame++;
+                            devirtToSameLikelihood100 += result1.Likelihood == 100 && result2.Likelihood == 100 ? 1 : 0;
+                            devirtToSameLikelihood70 += result1.Likelihood >= 70 && result2.Likelihood >= 70 ? 1 : 0;
+                        }
+                    }
+                }
+
+                PrintOutput($"There are {changes.Count(t => t.result1.Devirtualizes && !t.result2.Devirtualizes)} sites that devirtualize with {name1} but not with {name2}");
+                PrintOutput($"There are {changes.Count(t => !t.result1.Devirtualizes && t.result2.Devirtualizes)} sites that do not devirtualize with {name1} but do with {name2}");
+                PrintOutput($"There are {changes.Count(t => t.result1.Devirtualizes && t.result2.Devirtualizes && t.result1.Type != t.result2.Type)} sites that change devirtualized type");
+                PrintOutput($"There are {devirtToSame} sites that devirtualize to the same type before and after");
+                PrintOutput($"  Of these, {devirtToSameLikelihood100} have a likelihood of 100 in both .mibc files");
+                PrintOutput($"  and {devirtToSameLikelihood70} have a likelihood >= 70 in both .mibc files");
+
+                foreach (var group in changes.GroupBy(g => g.method))
+                {
+                    PrintOutput($"  In {group.Key}");
+                    foreach (var change in group)
+                    {
+                        string FormatDevirt(GetLikelyClassResult result)
+                        {
+                            if (result.Type != null)
+                                return $"{result.Type}, likelihood {result.Likelihood}{(result.Devirtualizes ? "" : " (does not devirt)")}";
+
+                            return $"(null)";
+                        }
+
+                        PrintOutput($"    At +{change.ilOffset:x}: {FormatDevirt(change.result1)} vs {FormatDevirt(change.result2)}");
+                    }
                 }
             }
 
@@ -607,8 +671,115 @@ static void PrintMibcStats(ProfileData data)
             PrintOutput($"# Methods with 64-bit block counts: {profiledMethods.Count(spd => spd.SchemaData.Any(elem => elem.InstrumentationKind == PgoInstrumentationKind.BasicBlockLongCount))}");
             PrintOutput($"# Methods with 32-bit edge counts: {profiledMethods.Count(spd => spd.SchemaData.Any(elem => elem.InstrumentationKind == PgoInstrumentationKind.EdgeIntCount))}");
             PrintOutput($"# Methods with 64-bit edge counts: {profiledMethods.Count(spd => spd.SchemaData.Any(elem => elem.InstrumentationKind == PgoInstrumentationKind.EdgeLongCount))}");
-            PrintOutput($"# Methods with type handle histograms: {profiledMethods.Count(spd => spd.SchemaData.Any(elem => elem.InstrumentationKind == PgoInstrumentationKind.TypeHandleHistogramTypeHandle))}");
-            PrintOutput($"# Methods with GetLikelyClass data: {profiledMethods.Count(spd => spd.SchemaData.Any(elem => elem.InstrumentationKind == PgoInstrumentationKind.GetLikelyClass))}");
+            int numTypeHandleHistograms = profiledMethods.Sum(spd => spd.SchemaData.Count(elem => elem.InstrumentationKind == PgoInstrumentationKind.TypeHandleHistogramTypeHandle));
+            int methodsWithTypeHandleHistograms = profiledMethods.Count(spd => spd.SchemaData.Any(elem => elem.InstrumentationKind == PgoInstrumentationKind.TypeHandleHistogramTypeHandle));
+            PrintOutput($"# Type handle histograms: {numTypeHandleHistograms} in {methodsWithTypeHandleHistograms} methods");
+            int numGetLikelyClass = profiledMethods.Sum(spd => spd.SchemaData.Count(elem => elem.InstrumentationKind == PgoInstrumentationKind.GetLikelyClass));
+            int methodsWithGetLikelyClass = profiledMethods.Count(spd => spd.SchemaData.Any(elem => elem.InstrumentationKind == PgoInstrumentationKind.GetLikelyClass));
+            PrintOutput($"# GetLikelyClass data: {numGetLikelyClass} in {methodsWithGetLikelyClass} methods");
+
+            var histogramCallSites = new List<(MethodProfileData mpd, int ilOffset)>();
+            foreach (var mpd in profiledMethods)
+            {
+                var sites =
+                    mpd.SchemaData
+                    .Where(e => e.InstrumentationKind == PgoInstrumentationKind.TypeHandleHistogramTypeHandle || e.InstrumentationKind == PgoInstrumentationKind.GetLikelyClass)
+                    .Select(e => e.ILOffset)
+                    .Distinct();
+
+                histogramCallSites.AddRange(sites.Select(ilOffset => (mpd, ilOffset)));
+            }
+
+            int CountGetLikelyClass(Func<GetLikelyClassResult, bool> predicate)
+                => histogramCallSites.Count(t => predicate(GetLikelyClass(t.mpd.SchemaData, t.ilOffset)));
+
+            PrintOutput($"# Call sites where getLikelyClass is null: {CountGetLikelyClass(r => r.IsNull)}");
+            PrintOutput($"# Call sites where getLikelyClass is unknown: {CountGetLikelyClass(r => r.IsUnknown)}");
+            PrintOutput($"# Call sites where getLikelyClass returns data that devirtualizes: {CountGetLikelyClass(r => r.Devirtualizes)}");
+
+            static bool PresentAndZero(MethodProfileData mpd, PgoInstrumentationKind kind)
+                => mpd.SchemaData.Any(e => e.InstrumentationKind == kind) && mpd.SchemaData.Sum(e => e.InstrumentationKind == kind ? e.DataLong : 0) == 0;
+
+            static bool CountersSumToZero(MethodProfileData data)
+                => PresentAndZero(data, PgoInstrumentationKind.BasicBlockIntCount) ||
+                   PresentAndZero(data, PgoInstrumentationKind.BasicBlockLongCount) ||
+                   PresentAndZero(data, PgoInstrumentationKind.EdgeIntCount) ||
+                   PresentAndZero(data, PgoInstrumentationKind.EdgeLongCount);
+
+            List<MethodProfileData> methodsWithZeroCounters = profiledMethods.Where(CountersSumToZero).ToList();
+            if (methodsWithZeroCounters.Count > 0)
+            {
+                PrintOutput($"There are {methodsWithZeroCounters.Count} methods whose counters sum to 0:");
+                foreach (MethodProfileData mpd in methodsWithZeroCounters)
+                    PrintOutput($"  {mpd.Method}");
+            }
+        }
+
+        private struct GetLikelyClassResult
+        {
+            public bool IsNull;
+            public bool IsUnknown;
+            public TypeDesc Type;
+            public int Likelihood;
+            public bool Devirtualizes;
+        }
+
+        private static GetLikelyClassResult GetLikelyClass(PgoSchemaElem[] schema, int ilOffset)
+        {
+            const int UNKNOWN_TYPEHANDLE_MIN = 1;
+            const int UNKNOWN_TYPEHANDLE_MAX = 33;
+
+            static bool IsUnknownTypeHandle(int handle)
+                => handle >= UNKNOWN_TYPEHANDLE_MIN && handle <= UNKNOWN_TYPEHANDLE_MAX;
+
+            for (int i = 0; i < schema.Length; i++)
+            {
+                var elem = schema[i];
+                if (elem.InstrumentationKind == PgoInstrumentationKind.GetLikelyClass)
+                {
+                    Trace.Assert(elem.Count == 1);
+                    return new GetLikelyClassResult
+                    {
+                        IsUnknown = IsUnknownTypeHandle(((TypeSystemEntityOrUnknown[])elem.DataObject)[0].AsUnknown),
+                        Likelihood = (byte)elem.Other,
+                    };
+                }
+
+                bool isHistogramCount =
+                    elem.InstrumentationKind == PgoInstrumentationKind.TypeHandleHistogramIntCount ||
+                    elem.InstrumentationKind == PgoInstrumentationKind.TypeHandleHistogramLongCount;
+
+                if (isHistogramCount && elem.Count == 1 && i + 1 < schema.Length && schema[i + 1].InstrumentationKind == PgoInstrumentationKind.TypeHandleHistogramTypeHandle)
+                {
+                    var handles = (TypeSystemEntityOrUnknown[])schema[i + 1].DataObject;
+                    var histogram = handles.Where(e => !e.IsNull).GroupBy(e => e).ToList();
+                    if (histogram.Count == 0)
+                        return new GetLikelyClassResult { IsNull = true };
+
+                    int totalCount = histogram.Sum(g => g.Count());
+                    // The number of unknown type handles matters for the likelihood, but not for the most likely class that we pick, so we can remove them now.
+                    histogram.RemoveAll(e => IsUnknownTypeHandle(e.Key.AsUnknown));
+                    if (histogram.Count == 0)
+                        return new GetLikelyClassResult { IsUnknown = true };
+
+                    // Now return the most likely one
+                    var best = histogram.OrderByDescending(h => h.Count()).First();
+                    Trace.Assert(best.Key.AsType != null);
+                    int likelihood = best.Count() * 100 / totalCount;
+                    // The threshold is different for interfaces and classes.
+                    // A flag in the Other field of the TypeHandleHistogram*Count entry indicates which kind of call site this is.
+                    bool isInterface = (elem.Other & (uint)ClassProfileFlags.IsInterface) != 0;
+                    int threshold = isInterface ? 25 : 30;
+                    return new GetLikelyClassResult
+                    {
+                        Type = best.Key.AsType,
+                        Likelihood = likelihood,
+                        Devirtualizes = likelihood >= threshold,
+                    };
+                }
+            }
+
+            return new GetLikelyClassResult { IsNull = true };
         }
 
         private static Dictionary<int, PgoSchemaElem> GroupBlocks(MethodProfileData data)
@@ -1139,6 +1310,8 @@ FlowGraph GetFlowGraph(MethodDesc desc)
                             SampleProfile sp = SampleProfile.Create(il, GetFlowGraph(g.Key), g.Select(t => t.Offset));
                             sampleProfiles.Add(g.Key, sp);
                         }
+
+                        PrintOutput($"Profile is based on {samples.Count} samples");
                     }
                     else
                     {
@@ -1149,6 +1322,7 @@ FlowGraph GetFlowGraph(MethodDesc desc)
                         Dictionary<(ulong startRun, ulong endRun), long> runs = new Dictionary<(ulong startRun, ulong endRun), long>();
                         List<(ulong start, ulong end)> lbrRuns = new List<(ulong start, ulong end)>();
                         LbrEntry64[] lbr64Arr = null;
+                        long numLbrRecords = 0;
                         foreach (var e in traceLog.Events)
                         {
                             if (e.TaskGuid != lbrGuid)
@@ -1158,6 +1332,8 @@ FlowGraph GetFlowGraph(MethodDesc desc)
                             if (e.Opcode != (TraceEventOpcode)32)
                                 continue;
 
+                            numLbrRecords++;
+
                             unsafe
                             {
                                 Span<LbrEntry64> lbr;
@@ -1291,6 +1467,8 @@ FlowGraph GetFlowGraph(MethodDesc desc)
 
                             sampleProfiles.Add(g.Key.Method, ep);
                         }
+
+                        PrintOutput($"Profile is based on {numLbrRecords} LBR records");
                     }
                 }
 
diff --git a/src/coreclr/unwinder/s390x/unwinder_s390x.cpp b/src/coreclr/unwinder/s390x/unwinder_s390x.cpp
new file mode 100644
index 00000000000000..66cb24b46e6e75
--- /dev/null
+++ b/src/coreclr/unwinder/s390x/unwinder_s390x.cpp
@@ -0,0 +1,11 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+//
+
+#include "stdafx.h"
+#include "utilcode.h"
+#include "crosscomp.h"
+
+#error Unsupported platform
+
diff --git a/src/coreclr/utilcode/CMakeLists.txt b/src/coreclr/utilcode/CMakeLists.txt
index fec22cf9dce38a..1ae433adbfd893 100644
--- a/src/coreclr/utilcode/CMakeLists.txt
+++ b/src/coreclr/utilcode/CMakeLists.txt
@@ -76,10 +76,6 @@ set(UTILCODE_DAC_SOURCES
   hostimpl.cpp
 )
 
-set(UTILCODE_CROSSGEN_SOURCES
-  ${UTILCODE_COMMON_SOURCES}
-  hostimpl.cpp
-)
 
 set(UTILCODE_STATICNOHOST_SOURCES
   ${UTILCODE_COMMON_SOURCES}
@@ -90,7 +86,6 @@ set (UTILCODE_DEPENDENCIES eventing_headers)
 
 convert_to_absolute_path(UTILCODE_SOURCES ${UTILCODE_SOURCES})
 convert_to_absolute_path(UTILCODE_DAC_SOURCES ${UTILCODE_DAC_SOURCES})
-convert_to_absolute_path(UTILCODE_CROSSGEN_SOURCES ${UTILCODE_CROSSGEN_SOURCES})
 convert_to_absolute_path(UTILCODE_STATICNOHOST_SOURCES ${UTILCODE_STATICNOHOST_SOURCES})
 
 add_library_clr(utilcode_dac STATIC ${UTILCODE_DAC_SOURCES})
@@ -98,11 +93,9 @@ add_library_clr(utilcode_obj OBJECT ${UTILCODE_SOURCES})
 add_library(utilcode INTERFACE)
 target_sources(utilcode INTERFACE $<TARGET_OBJECTS:utilcode_obj>)
 add_library_clr(utilcodestaticnohost STATIC ${UTILCODE_STATICNOHOST_SOURCES})
-add_library_clr(utilcode_crossgen STATIC ${UTILCODE_CROSSGEN_SOURCES})
 
 if(CLR_CMAKE_HOST_UNIX)
   target_link_libraries(utilcodestaticnohost  nativeresourcestring)
-  target_link_libraries(utilcode_crossgen  nativeresourcestring)
   target_link_libraries(utilcode_dac nativeresourcestring)
   target_link_libraries(utilcode INTERFACE nativeresourcestring)
   add_dependencies(utilcode_dac coreclrpal)
@@ -114,20 +107,16 @@ if(CLR_CMAKE_HOST_WIN32)
     target_compile_definitions(utilcodestaticnohost PRIVATE _CRTIMP=) # use static version of crt
 
     link_natvis_sources_for_target(utilcodestaticnohost INTERFACE utilcode.natvis)
-    link_natvis_sources_for_target(utilcode_crossgen INTERFACE utilcode.natvis)
     link_natvis_sources_for_target(utilcode_dac INTERFACE utilcode.natvis)
     link_natvis_sources_for_target(utilcode INTERFACE utilcode.natvis)
 endif(CLR_CMAKE_HOST_WIN32)
 
 set_target_properties(utilcode_dac PROPERTIES DAC_COMPONENT TRUE)
-set_target_properties(utilcode_crossgen PROPERTIES CROSSGEN_COMPONENT TRUE)
 target_compile_definitions(utilcode_dac PRIVATE SELF_NO_HOST)
 target_compile_definitions(utilcodestaticnohost PRIVATE SELF_NO_HOST)
 add_dependencies(utilcode_dac ${UTILCODE_DEPENDENCIES})
 add_dependencies(utilcode_obj ${UTILCODE_DEPENDENCIES})
-add_dependencies(utilcode_crossgen ${UTILCODE_DEPENDENCIES})
 add_dependencies(utilcodestaticnohost ${UTILCODE_DEPENDENCIES})
 target_precompile_headers(utilcode_dac PRIVATE [["stdafx.h"]])
 target_precompile_headers(utilcode_obj PRIVATE [["stdafx.h"]])
-target_precompile_headers(utilcode_crossgen PRIVATE [["stdafx.h"]])
 target_precompile_headers(utilcodestaticnohost PRIVATE [["stdafx.h"]])
diff --git a/src/coreclr/utilcode/loaderheap.cpp b/src/coreclr/utilcode/loaderheap.cpp
index 33974b9e290764..adaf07d8f5825f 100644
--- a/src/coreclr/utilcode/loaderheap.cpp
+++ b/src/coreclr/utilcode/loaderheap.cpp
@@ -1330,8 +1330,14 @@ void *UnlockedLoaderHeap::UnlockedAllocMem_NoThrow(size_t dwSize
         if (pData)
         {
 #ifdef _DEBUG
+            BYTE *pAllocatedBytes = (BYTE*)pData;
+            ExecutableWriterHolder<void> dataWriterHolder;
+            if (m_Options & LHF_EXECUTABLE)
+            {
+                dataWriterHolder = ExecutableWriterHolder<void>(pData, dwSize);
+                pAllocatedBytes = (BYTE *)dataWriterHolder.GetRW();
+            }
 
-            BYTE *pAllocatedBytes = (BYTE *)pData;
 #if LOADER_HEAP_DEBUG_BOUNDARY > 0
             // Don't fill the memory we allocated - it is assumed to be zeroed - fill the memory after it
             memset(pAllocatedBytes + dwRequestedSize, 0xEE, LOADER_HEAP_DEBUG_BOUNDARY);
@@ -1344,7 +1350,7 @@ void *UnlockedLoaderHeap::UnlockedAllocMem_NoThrow(size_t dwSize
 
             if (!m_fExplicitControl)
             {
-                LoaderHeapValidationTag *pTag = AllocMem_GetTag(pData, dwRequestedSize);
+                LoaderHeapValidationTag *pTag = AllocMem_GetTag(pAllocatedBytes, dwRequestedSize);
                 pTag->m_allocationType  = kAllocMem;
                 pTag->m_dwRequestedSize = dwRequestedSize;
                 pTag->m_szFile          = szFile;
@@ -1514,7 +1520,14 @@ void UnlockedLoaderHeap::UnlockedBackoutMem(void *pMem,
     {
         // Cool. This was the last block allocated. We can just undo the allocation instead
         // of going to the freelist.
-        memset(pMem, 0x00, dwSize); // Fill freed region with 0
+        void *pMemRW = pMem;
+        ExecutableWriterHolder<void> memWriterHolder;
+        if (m_Options & LHF_EXECUTABLE)
+        {
+            memWriterHolder = ExecutableWriterHolder<void>(pMem, dwSize);
+            pMemRW = memWriterHolder.GetRW();
+        }
+        memset(pMemRW, 0x00, dwSize); // Fill freed region with 0
         m_pAllocPtr = (BYTE*)pMem;
     }
     else
@@ -1626,7 +1639,14 @@ void *UnlockedLoaderHeap::UnlockedAllocAlignedMem_NoThrow(size_t  dwRequestedSiz
     ((BYTE*&)pResult) += extra;
 
 #ifdef _DEBUG
-     BYTE *pAllocatedBytes = (BYTE *)pResult;
+    BYTE *pAllocatedBytes = (BYTE *)pResult;
+    ExecutableWriterHolder<void> resultWriterHolder;
+    if (m_Options & LHF_EXECUTABLE)
+    {
+        resultWriterHolder = ExecutableWriterHolder<void>(pResult, dwSize - extra);
+        pAllocatedBytes = (BYTE *)resultWriterHolder.GetRW();
+    }
+
 #if LOADER_HEAP_DEBUG_BOUNDARY > 0
     // Don't fill the entire memory - we assume it is all zeroed -just the memory after our alloc
     memset(pAllocatedBytes + dwRequestedSize, 0xee, LOADER_HEAP_DEBUG_BOUNDARY);
@@ -1656,7 +1676,7 @@ void *UnlockedLoaderHeap::UnlockedAllocAlignedMem_NoThrow(size_t  dwRequestedSiz
 
     if (!m_fExplicitControl)
     {
-        LoaderHeapValidationTag *pTag = AllocMem_GetTag(((BYTE*)pResult) - extra, dwRequestedSize + extra);
+        LoaderHeapValidationTag *pTag = AllocMem_GetTag(pAllocatedBytes - extra, dwRequestedSize + extra);
         pTag->m_allocationType  = kAllocMem;
         pTag->m_dwRequestedSize = dwRequestedSize + extra;
         pTag->m_szFile          = szFile;
diff --git a/src/coreclr/utilcode/pedecoder.cpp b/src/coreclr/utilcode/pedecoder.cpp
index 3b46c56a415879..639cb02099bf4d 100644
--- a/src/coreclr/utilcode/pedecoder.cpp
+++ b/src/coreclr/utilcode/pedecoder.cpp
@@ -1034,14 +1034,29 @@ CHECK PEDecoder::CheckCorHeader() const
 
     IMAGE_COR20_HEADER *pCor = GetCorHeader();
 
+    // Currently composite r2r images miss some information, for example the version is 0.0.
+    // We may want to change that to something more conforming and explicit.
+    // For now, for compatibility purposes, we will accept that as a valid format.
+    bool possiblyCompositeR2R =
+        pCor->MinorRuntimeVersion == 0 &&
+        pCor->MajorRuntimeVersion == 0;
+
     //CHECK(((ULONGLONG)pCor & 0x3)==0);
 
     // If the file is COM+ 1.0, which by definition has nothing the runtime can
     // use, or if the file requires a newer version of this engine than us,
     // it cannot be run by this engine.
-    CHECK(VAL16(pCor->MajorRuntimeVersion) > 1 && VAL16(pCor->MajorRuntimeVersion) <= COR_VERSION_MAJOR);
+    if (!possiblyCompositeR2R)
+        CHECK(VAL16(pCor->MajorRuntimeVersion) > 1 && VAL16(pCor->MajorRuntimeVersion) <= COR_VERSION_MAJOR);
 
+#ifdef HOST_WINDOWS
     CHECK(CheckDirectory(&pCor->MetaData, IMAGE_SCN_MEM_WRITE, HasNativeHeader() ? NULL_OK : NULL_NOT_OK));
+#else
+    CHECK(CheckDirectory(
+        &pCor->MetaData,
+        possiblyCompositeR2R ? 0 : IMAGE_SCN_MEM_WRITE,
+        HasNativeHeader() ? NULL_OK : NULL_NOT_OK));
+#endif
     CHECK(CheckDirectory(&pCor->Resources, IMAGE_SCN_MEM_WRITE, NULL_OK));
     CHECK(CheckDirectory(&pCor->StrongNameSignature, IMAGE_SCN_MEM_WRITE, NULL_OK));
     CHECK(CheckDirectory(&pCor->CodeManagerTable, IMAGE_SCN_MEM_WRITE, NULL_OK));
@@ -1083,7 +1098,7 @@ CHECK PEDecoder::CheckCorHeader() const
 
     // IL library files (really a misnomer - these are native images or ReadyToRun images)
     // only they can have a native image header
-    if ((pCor->Flags&VAL32(COMIMAGE_FLAGS_IL_LIBRARY)) == 0)
+    if ((pCor->Flags&VAL32(COMIMAGE_FLAGS_IL_LIBRARY)) == 0 && !possiblyCompositeR2R)
     {
         CHECK(VAL32(pCor->ManagedNativeHeader.Size) == 0);
     }
@@ -1769,7 +1784,7 @@ void PEDecoder::LayoutILOnly(void *base, bool enableExecution) const
                            PAGE_READONLY, &oldProtection))
         ThrowLastError();
 
-    // Finally, apply proper protection to copied sections
+    // Finally, apply proper protection to copied sections    
     for (section = sectionStart; section < sectionEnd; section++)
     {
         // Add appropriate page protection.
diff --git a/src/coreclr/vm/CMakeLists.txt b/src/coreclr/vm/CMakeLists.txt
index d38633d6951a46..1d682d2a428bbf 100644
--- a/src/coreclr/vm/CMakeLists.txt
+++ b/src/coreclr/vm/CMakeLists.txt
@@ -566,6 +566,10 @@ if(FEATURE_COMWRAPPERS OR FEATURE_OBJCMARSHAL)
     if (FEATURE_COMWRAPPERS)
         list(APPEND VM_SOURCES_WKS
             interoplibinterface.cpp
+            rcwrefcache.cpp
+        )
+        list(APPEND VM_HEADERS_WKS
+            rcwrefcache.h
         )
     endif (FEATURE_COMWRAPPERS)
 
@@ -626,7 +630,6 @@ if(CLR_CMAKE_TARGET_WIN32)
         mngstdinterfaces.cpp
         notifyexternals.cpp
         olecontexthelpers.cpp
-        rcwrefcache.cpp
         runtimecallablewrapper.cpp
         stdinterfaces.cpp
         stdinterfaces_wrapper.cpp
@@ -644,7 +647,6 @@ if(CLR_CMAKE_TARGET_WIN32)
         mngstdinterfaces.h
         notifyexternals.h
         olecontexthelpers.h
-        rcwrefcache.h
         runtimecallablewrapper.h
         stdinterfaces.h
         stdinterfaces_internal.h
diff --git a/src/coreclr/vm/ClrEtwAll.man b/src/coreclr/vm/ClrEtwAll.man
index 79e1f17b069be8..d8a275c6da6295 100644
--- a/src/coreclr/vm/ClrEtwAll.man
+++ b/src/coreclr/vm/ClrEtwAll.man
@@ -87,6 +87,8 @@
                              message="$(string.RuntimePublisher.TypeDiagnosticKeywordMessage)" symbol="CLR_TYPEDIAGNOSTIC_KEYWORD" />
                     <keyword name="JitInstrumentationDataKeyword" mask="0x10000000000"
                              message="$(string.RuntimePublisher.JitInstrumentationDataKeywordMessage)" symbol="CLR_JITINSTRUMENTEDDATA_KEYWORD" />
+                    <keyword name="ProfilerKeyword" mask="0x20000000000"
+                             message="$(string.RuntimePublisher.ProfilerKeywordMessage)" symbol="CLR_PROFILER_KEYWORD" />
                 </keywords>
                 <!--Tasks-->
                 <tasks>
@@ -429,7 +431,14 @@
                             <opcode name="ExecutionCheckpoint" message="$(string.RuntimePublisher.ExecutionCheckpointOpcodeMessage)" symbol="CLR_EXECUTIONCHECKPOINT_OPCODE" value="11"> </opcode>
                         </opcodes>
                     </task>
-                <!--Next available ID is 36-->
+                    <task name="Profiler" symbol="CLR_PROFILER_TASK"
+                          value="36" eventGUID="{68895E46-FD03-4528-89D2-5E1FBB1D3BCF}"
+                          message="$(string.RuntimePublisher.ProfilerTaskMessage)">
+                        <opcodes>
+                            <opcode name="Profiler" message="$(string.RuntimePublisher.ProfilerOpcodeMessage)" symbol="CLR_PROFILER_OPCODE" value="11"/>
+                        </opcodes>
+                    </task>
+                <!--Next available ID is 37-->
                 </tasks>
                 <!--Maps-->
                 <maps>
@@ -2896,6 +2905,17 @@
                             </ExecutionCheckpoint>
                         </UserData>
                     </template>
+
+                    <template tid="ProfilerMessage">
+                      <data name="ClrInstanceID" inType="win:UInt16"/>
+                      <data name="Message" inType="win:UnicodeString" />
+                      <UserData>
+                        <Settings xmlns="myNs">
+                          <ClrInstanceID> %1 </ClrInstanceID>
+                          <Message> %2 </Message>
+                        </Settings>
+                      </UserData>
+                    </template>
                 </templates>
 
                 <events>
@@ -3921,6 +3941,11 @@
                            task="JitInstrumentationData"
                            symbol="JitInstrumentationDataVerbose" message="$(string.RuntimePublisher.JitInstrumentationDataEventMessage)"/>
 
+                    <event value="299" version="0" level="win:Informational"  template="ProfilerMessage"
+                           keywords ="ProfilerKeyword" opcode="Profiler"
+                           task="Profiler"
+                           symbol="ProfilerMessage" message="$(string.RuntimePublisher.ProfilerEventMessage)"/>
+
                     <!-- Execution Checkpoint event 300 -->
                     <event value="300" version="0" level="win:Informational"  template="ExecutionCheckpoint"
                            keywords ="PerfTrackKeyword" opcode="ExecutionCheckpoint" task="ExecutionCheckpoint" symbol="ExecutionCheckpoint"
@@ -7183,6 +7208,7 @@
                 <string id="RuntimePublisher.AssemblyLoadFromResolveHandlerInvokedEventMessage" value="ClrInstanceID=%1;%nAssemblyName=%2;%nIsTrackedLoad=%3;%nRequestingAssemblyPath=%4;%nComputedRequestedAssemblyPath=%5" />
                 <string id="RuntimePublisher.KnownPathProbedEventMessage" value="ClrInstanceID=%1;%nFilePath=%2;%nSource=%3;%nResult=%4" />
                 <string id="RuntimePublisher.JitInstrumentationDataEventMessage" value="%MethodId=%4" />
+                <string id="RuntimePublisher.ProfilerEventMessage" value="%Message=%2" />
                 <string id="RuntimePublisher.ResolutionAttemptedEventMessage" value="ClrInstanceID=%1;%nAssemblyName=%2;%nStage=%3;%nAssemblyLoadContext=%4;%nResult=%5;%nResultAssemblyName=%6;%nResultAssemblyPath=%7;%nErrorMessage=%8" />
                 <string id="RuntimePublisher.StackEventMessage" value="ClrInstanceID=%1;%nReserved1=%2;%nReserved2=%3;%nFrameCount=%4;%nStack=%5" />
                 <string id="RuntimePublisher.AppDomainMemAllocatedEventMessage" value="AppDomainID=%1;%nAllocated=%2;%nClrInstanceID=%3" />
@@ -7383,6 +7409,7 @@
                 <string id="RuntimePublisher.TypeLoadTaskMessage" value="TypeLoad" />
                 <string id="RuntimePublisher.JitInstrumentationDataTaskMessage" value="JitInstrumentationData" />
                 <string id="RuntimePublisher.ExecutionCheckpointTaskMessage" value="ExecutionCheckpoint" />
+                <string id="RuntimePublisher.ProfilerTaskMessage" value="Profiler" />
 
                 <string id="RundownPublisher.EEStartupTaskMessage" value="Runtime" />
                 <string id="RundownPublisher.MethodTaskMessage" value="Method" />
@@ -7712,6 +7739,7 @@
                 <string id="RuntimePublisher.MethodDiagnosticKeywordMessage" value="MethodDiagnostic" />
                 <string id="RuntimePublisher.TypeDiagnosticKeywordMessage" value="TypeDiagnostic" />
                 <string id="RuntimePublisher.JitInstrumentationDataKeywordMessage" value="JitInstrumentationData" />
+                <string id="RuntimePublisher.ProfilerKeywordMessage" value="Profiler" />
                 <string id="RuntimePublisher.GenAwareBeginEventMessage" value="NONE" />
                 <string id="RuntimePublisher.GenAwareEndEventMessage" value="NONE" />
                 <string id="RundownPublisher.LoaderKeywordMessage" value="Loader" />
@@ -7855,6 +7883,8 @@
 
                 <string id="RuntimePublisher.ExecutionCheckpointOpcodeMessage" value="ExecutionCheckpoint" />
 
+                <string id="RuntimePublisher.ProfilerOpcodeMessage" value="ProfilerMessage" />
+
                 <string id="RundownPublisher.MethodDCStartOpcodeMessage" value="DCStart" />
                 <string id="RundownPublisher.MethodDCEndOpcodeMessage" value="DCStop" />
                 <string id="RundownPublisher.MethodDCStartVerboseOpcodeMessage" value="DCStartVerbose" />
diff --git a/src/coreclr/vm/amd64/cgenamd64.cpp b/src/coreclr/vm/amd64/cgenamd64.cpp
index 153993cb37c2dd..d00f7b74df0d48 100644
--- a/src/coreclr/vm/amd64/cgenamd64.cpp
+++ b/src/coreclr/vm/amd64/cgenamd64.cpp
@@ -450,7 +450,7 @@ void EncodeLoadAndJumpThunk (LPBYTE pBuffer, LPVOID pv, LPVOID pTarget)
     _ASSERTE(DbgIsExecutable(pBuffer, 22));
 }
 
-void emitCOMStubCall (ComCallMethodDesc *pCOMMethod, PCODE target)
+void emitCOMStubCall (ComCallMethodDesc *pCOMMethodRX, ComCallMethodDesc *pCOMMethodRW, PCODE target)
 {
     CONTRACT_VOID
     {
@@ -460,7 +460,8 @@ void emitCOMStubCall (ComCallMethodDesc *pCOMMethod, PCODE target)
     }
     CONTRACT_END;
 
-    BYTE *pBuffer = (BYTE*)pCOMMethod - COMMETHOD_CALL_PRESTUB_SIZE;
+    BYTE *pBufferRX = (BYTE*)pCOMMethodRX - COMMETHOD_CALL_PRESTUB_SIZE;
+    BYTE *pBufferRW = (BYTE*)pCOMMethodRW - COMMETHOD_CALL_PRESTUB_SIZE;
 
     // We need the target to be in a 64-bit aligned memory location and the call instruction
     // to immediately precede the ComCallMethodDesc. We'll generate an indirect call to avoid
@@ -471,21 +472,21 @@ void emitCOMStubCall (ComCallMethodDesc *pCOMMethod, PCODE target)
     // nop                              90
     // call [$ - 10]                    ff 15 f0 ff ff ff
 
-    *((UINT64 *)&pBuffer[COMMETHOD_CALL_PRESTUB_ADDRESS_OFFSET]) = (UINT64)target;
+    *((UINT64 *)&pBufferRW[COMMETHOD_CALL_PRESTUB_ADDRESS_OFFSET]) = (UINT64)target;
 
-    pBuffer[-2]  = 0x90;
-    pBuffer[-1]  = 0x90;
+    pBufferRW[-2]  = 0x90;
+    pBufferRW[-1]  = 0x90;
 
-    pBuffer[0] = 0xFF;
-    pBuffer[1] = 0x15;
-    *((UINT32 UNALIGNED *)&pBuffer[2]) = (UINT32)(COMMETHOD_CALL_PRESTUB_ADDRESS_OFFSET - COMMETHOD_CALL_PRESTUB_SIZE);
+    pBufferRW[0] = 0xFF;
+    pBufferRW[1] = 0x15;
+    *((UINT32 UNALIGNED *)&pBufferRW[2]) = (UINT32)(COMMETHOD_CALL_PRESTUB_ADDRESS_OFFSET - COMMETHOD_CALL_PRESTUB_SIZE);
 
-    _ASSERTE(DbgIsExecutable(pBuffer, COMMETHOD_CALL_PRESTUB_SIZE));
+    _ASSERTE(DbgIsExecutable(pBufferRX, COMMETHOD_CALL_PRESTUB_SIZE));
 
     RETURN;
 }
 
-void emitJump(LPBYTE pBuffer, LPVOID target)
+void emitJump(LPBYTE pBufferRX, LPBYTE pBufferRW, LPVOID target)
 {
     CONTRACTL
     {
@@ -493,25 +494,25 @@ void emitJump(LPBYTE pBuffer, LPVOID target)
         GC_NOTRIGGER;
         MODE_ANY;
 
-        PRECONDITION(CheckPointer(pBuffer));
+        PRECONDITION(CheckPointer(pBufferRX));
     }
     CONTRACTL_END;
 
     // mov rax, 123456789abcdef0h       48 b8 xx xx xx xx xx xx xx xx
     // jmp rax                          ff e0
 
-    pBuffer[0]  = 0x48;
-    pBuffer[1]  = 0xB8;
+    pBufferRW[0]  = 0x48;
+    pBufferRW[1]  = 0xB8;
 
-    *((UINT64 UNALIGNED *)&pBuffer[2]) = (UINT64)target;
+    *((UINT64 UNALIGNED *)&pBufferRW[2]) = (UINT64)target;
 
-    pBuffer[10] = 0xFF;
-    pBuffer[11] = 0xE0;
+    pBufferRW[10] = 0xFF;
+    pBufferRW[11] = 0xE0;
 
-    _ASSERTE(DbgIsExecutable(pBuffer, 12));
+    _ASSERTE(DbgIsExecutable(pBufferRX, 12));
 }
 
-void UMEntryThunkCode::Encode(BYTE* pTargetCode, void* pvSecretParam)
+void UMEntryThunkCode::Encode(UMEntryThunkCode *pEntryThunkCodeRX, BYTE* pTargetCode, void* pvSecretParam)
 {
     CONTRACTL
     {
@@ -542,7 +543,7 @@ void UMEntryThunkCode::Encode(BYTE* pTargetCode, void* pvSecretParam)
     m_jmpRAX[1]  = 0xFF;
     m_jmpRAX[2]  = 0xE0;
 
-    _ASSERTE(DbgIsExecutable(&m_movR10[0], &m_jmpRAX[3]-&m_movR10[0]));
+    _ASSERTE(DbgIsExecutable(&pEntryThunkCodeRX->m_movR10[0], &pEntryThunkCodeRX->m_jmpRAX[3]-&pEntryThunkCodeRX->m_movR10[0]));
 }
 
 void UMEntryThunkCode::Poison()
@@ -555,15 +556,18 @@ void UMEntryThunkCode::Poison()
     }
     CONTRACTL_END;
 
-    m_execstub    = (BYTE *)UMEntryThunk::ReportViolation;
+    ExecutableWriterHolder<UMEntryThunkCode> thunkWriterHolder(this, sizeof(UMEntryThunkCode));
+    UMEntryThunkCode *pThisRW = thunkWriterHolder.GetRW();
+
+    pThisRW->m_execstub    = (BYTE *)UMEntryThunk::ReportViolation;
 
-    m_movR10[0]  = REX_PREFIX_BASE | REX_OPERAND_SIZE_64BIT;
+    pThisRW->m_movR10[0]  = REX_PREFIX_BASE | REX_OPERAND_SIZE_64BIT;
 #ifdef _WIN32
     // mov rcx, pUMEntryThunk // 48 b9 xx xx xx xx xx xx xx xx
-    m_movR10[1]  = 0xB9;
+    pThisRW->m_movR10[1]  = 0xB9;
 #else
     // mov rdi, pUMEntryThunk // 48 bf xx xx xx xx xx xx xx xx
-    m_movR10[1]  = 0xBF;
+    pThisRW->m_movR10[1]  = 0xBF;
 #endif
 
     ClrFlushInstructionCache(&m_movR10[0], &m_jmpRAX[3]-&m_movR10[0]);
@@ -647,7 +651,7 @@ INT32 rel32UsingJumpStub(INT32 UNALIGNED * pRel32, PCODE target, MethodDesc *pMe
     return static_cast<INT32>(offset);
 }
 
-INT32 rel32UsingPreallocatedJumpStub(INT32 UNALIGNED * pRel32, PCODE target, PCODE jumpStubAddr, bool emitJump)
+INT32 rel32UsingPreallocatedJumpStub(INT32 UNALIGNED * pRel32, PCODE target, PCODE jumpStubAddrRX, PCODE jumpStubAddrRW, bool emitJump)
 {
     CONTRACTL
     {
@@ -657,12 +661,12 @@ INT32 rel32UsingPreallocatedJumpStub(INT32 UNALIGNED * pRel32, PCODE target, PCO
     CONTRACTL_END;
 
     TADDR baseAddr = (TADDR)pRel32 + 4;
-    _ASSERTE(FitsInI4(jumpStubAddr - baseAddr));
+    _ASSERTE(FitsInI4(jumpStubAddrRX - baseAddr));
 
     INT_PTR offset = target - baseAddr;
     if (!FitsInI4(offset) INDEBUG(|| PEDecoder::GetForceRelocs()))
     {
-        offset = jumpStubAddr - baseAddr;
+        offset = jumpStubAddrRX - baseAddr;
         if (!FitsInI4(offset))
         {
             _ASSERTE(!"jump stub was not in expected range");
@@ -671,11 +675,11 @@ INT32 rel32UsingPreallocatedJumpStub(INT32 UNALIGNED * pRel32, PCODE target, PCO
 
         if (emitJump)
         {
-            emitBackToBackJump((LPBYTE)jumpStubAddr, (LPVOID)target);
+            emitBackToBackJump((LPBYTE)jumpStubAddrRX, (LPBYTE)jumpStubAddrRW, (LPVOID)target);
         }
         else
         {
-            _ASSERTE(decodeBackToBackJump(jumpStubAddr) == target);
+            _ASSERTE(decodeBackToBackJump(jumpStubAddrRX) == target);
         }
     }
 
@@ -862,7 +866,9 @@ EXTERN_C PCODE VirtualMethodFixupWorker(TransitionBlock * pTransitionBlock, CORC
             *(INT32 *)(pNewValue+1) = rel32UsingJumpStub((INT32*)(&pThunk->callJmp[1]), pCode, pMD, NULL);
 
             _ASSERTE(IS_ALIGNED(pThunk, sizeof(INT64)));
-            FastInterlockCompareExchangeLong((INT64*)pThunk, newValue, oldValue);
+
+            ExecutableWriterHolder<INT64> thunkWriterHolder((INT64*)pThunk, sizeof(INT64));
+            FastInterlockCompareExchangeLong(thunkWriterHolder.GetRW(), newValue, oldValue);
 
             FlushInstructionCache(GetCurrentProcess(), pThunk, 8);
         }
@@ -888,14 +894,17 @@ EXTERN_C PCODE VirtualMethodFixupWorker(TransitionBlock * pTransitionBlock, CORC
 #define BEGIN_DYNAMIC_HELPER_EMIT(size) \
     SIZE_T cb = size; \
     SIZE_T cbAligned = ALIGN_UP(cb, DYNAMIC_HELPER_ALIGNMENT); \
-    BYTE * pStart = (BYTE *)(void *)pAllocator->GetDynamicHelpersHeap()->AllocAlignedMem(cbAligned, DYNAMIC_HELPER_ALIGNMENT); \
+    BYTE * pStartRX = (BYTE *)(void*)pAllocator->GetDynamicHelpersHeap()->AllocAlignedMem(cbAligned, DYNAMIC_HELPER_ALIGNMENT); \
+    ExecutableWriterHolder<BYTE> startWriterHolder(pStartRX, cbAligned); \
+    BYTE * pStart = startWriterHolder.GetRW(); \
+    size_t rxOffset = pStartRX - pStart; \
     BYTE * p = pStart;
 
 #define END_DYNAMIC_HELPER_EMIT() \
     _ASSERTE(pStart + cb == p); \
     while (p < pStart + cbAligned) *p++ = X86_INSTR_INT3; \
-    ClrFlushInstructionCache(pStart, cbAligned); \
-    return (PCODE)pStart
+    ClrFlushInstructionCache(pStartRX, cbAligned); \
+    return (PCODE)pStartRX
 
 PCODE DynamicHelpers::CreateHelper(LoaderAllocator * pAllocator, TADDR arg, PCODE target)
 {
@@ -913,13 +922,13 @@ PCODE DynamicHelpers::CreateHelper(LoaderAllocator * pAllocator, TADDR arg, PCOD
     p += 8;
 
     *p++ = X86_INSTR_JMP_REL32; // jmp rel32
-    *(INT32 *)p = rel32UsingJumpStub((INT32 *)p, target, NULL, pAllocator);
+    *(INT32 *)p = rel32UsingJumpStub((INT32 *)(p + rxOffset), target, NULL, pAllocator);
     p += 4;
 
     END_DYNAMIC_HELPER_EMIT();
 }
 
-void DynamicHelpers::EmitHelperWithArg(BYTE*& p, LoaderAllocator * pAllocator, TADDR arg, PCODE target)
+void DynamicHelpers::EmitHelperWithArg(BYTE*& p, size_t rxOffset, LoaderAllocator * pAllocator, TADDR arg, PCODE target)
 {
     CONTRACTL
     {
@@ -940,7 +949,7 @@ void DynamicHelpers::EmitHelperWithArg(BYTE*& p, LoaderAllocator * pAllocator, T
     p += 8;
 
     *p++ = X86_INSTR_JMP_REL32; // jmp rel32
-    *(INT32 *)p = rel32UsingJumpStub((INT32 *)p, target, NULL, pAllocator);
+    *(INT32 *)p = rel32UsingJumpStub((INT32 *)(p + rxOffset), target, NULL, pAllocator);
     p += 4;
 }
 
@@ -948,7 +957,7 @@ PCODE DynamicHelpers::CreateHelperWithArg(LoaderAllocator * pAllocator, TADDR ar
 {
     BEGIN_DYNAMIC_HELPER_EMIT(15);
 
-    EmitHelperWithArg(p, pAllocator, arg, target);
+    EmitHelperWithArg(p, rxOffset, pAllocator, arg, target);
 
     END_DYNAMIC_HELPER_EMIT();
 }
@@ -976,7 +985,7 @@ PCODE DynamicHelpers::CreateHelper(LoaderAllocator * pAllocator, TADDR arg, TADD
     p += 8;
 
     *p++ = X86_INSTR_JMP_REL32; // jmp rel32
-    *(INT32 *)p = rel32UsingJumpStub((INT32 *)p, target, NULL, pAllocator);
+    *(INT32 *)p = rel32UsingJumpStub((INT32 *)(p + rxOffset), target, NULL, pAllocator);
     p += 4;
 
     END_DYNAMIC_HELPER_EMIT();
@@ -1005,7 +1014,7 @@ PCODE DynamicHelpers::CreateHelperArgMove(LoaderAllocator * pAllocator, TADDR ar
     p += 8;
 
     *p++ = X86_INSTR_JMP_REL32; // jmp rel32
-    *(INT32 *)p = rel32UsingJumpStub((INT32 *)p, target, NULL, pAllocator);
+    *(INT32 *)p = rel32UsingJumpStub((INT32 *)(p + rxOffset), target, NULL, pAllocator);
     p += 4;
 
     END_DYNAMIC_HELPER_EMIT();
@@ -1071,7 +1080,7 @@ PCODE DynamicHelpers::CreateHelperWithTwoArgs(LoaderAllocator * pAllocator, TADD
     p += 8;
 
     *p++ = X86_INSTR_JMP_REL32; // jmp rel32
-    *(INT32 *)p = rel32UsingJumpStub((INT32 *)p, target, NULL, pAllocator);
+    *(INT32 *)p = rel32UsingJumpStub((INT32 *)(p + rxOffset), target, NULL, pAllocator);
     p += 4;
 
     END_DYNAMIC_HELPER_EMIT();
@@ -1100,7 +1109,7 @@ PCODE DynamicHelpers::CreateHelperWithTwoArgs(LoaderAllocator * pAllocator, TADD
     p += 8;
 
     *p++ = X86_INSTR_JMP_REL32; // jmp rel32
-    *(INT32 *)p = rel32UsingJumpStub((INT32 *)p, target, NULL, pAllocator);
+    *(INT32 *)p = rel32UsingJumpStub((INT32 *)(p + rxOffset), target, NULL, pAllocator);
     p += 4;
 
     END_DYNAMIC_HELPER_EMIT();
@@ -1117,9 +1126,10 @@ PCODE DynamicHelpers::CreateDictionaryLookupHelper(LoaderAllocator * pAllocator,
         GetEEFuncEntryPoint(JIT_GenericHandleClassWithSlotAndModule));
 
     GenericHandleArgs * pArgs = (GenericHandleArgs *)(void *)pAllocator->GetDynamicHelpersHeap()->AllocAlignedMem(sizeof(GenericHandleArgs), DYNAMIC_HELPER_ALIGNMENT);
-    pArgs->dictionaryIndexAndSlot = dictionaryIndexAndSlot;
-    pArgs->signature = pLookup->signature;
-    pArgs->module = (CORINFO_MODULE_HANDLE)pModule;
+    ExecutableWriterHolder<GenericHandleArgs> argsWriterHolder(pArgs, sizeof(GenericHandleArgs));
+    argsWriterHolder.GetRW()->dictionaryIndexAndSlot = dictionaryIndexAndSlot;
+    argsWriterHolder.GetRW()->signature = pLookup->signature;
+    argsWriterHolder.GetRW()->module = (CORINFO_MODULE_HANDLE)pModule;
 
     WORD slotOffset = (WORD)(dictionaryIndexAndSlot & 0xFFFF) * sizeof(Dictionary*);
 
@@ -1131,7 +1141,7 @@ PCODE DynamicHelpers::CreateDictionaryLookupHelper(LoaderAllocator * pAllocator,
         // rcx/rdi contains the generic context parameter
         // mov rdx/rsi,pArgs
         // jmp helperAddress
-        EmitHelperWithArg(p, pAllocator, (TADDR)pArgs, helperAddress);
+        EmitHelperWithArg(p, rxOffset, pAllocator, (TADDR)pArgs, helperAddress);
 
         END_DYNAMIC_HELPER_EMIT();
     }
@@ -1238,7 +1248,7 @@ PCODE DynamicHelpers::CreateDictionaryLookupHelper(LoaderAllocator * pAllocator,
 
                 // mov rdx|rsi,pArgs
                 // jmp helperAddress
-                EmitHelperWithArg(p, pAllocator, (TADDR)pArgs, helperAddress);
+                EmitHelperWithArg(p, rxOffset, pAllocator, (TADDR)pArgs, helperAddress);
             }
         }
 
diff --git a/src/coreclr/vm/amd64/cgencpu.h b/src/coreclr/vm/amd64/cgencpu.h
index 7312ad0a019fef..6300876fa330e3 100644
--- a/src/coreclr/vm/amd64/cgencpu.h
+++ b/src/coreclr/vm/amd64/cgencpu.h
@@ -370,11 +370,11 @@ INT32 rel32UsingJumpStub(INT32 UNALIGNED * pRel32, PCODE target, MethodDesc *pMe
     LoaderAllocator *pLoaderAllocator = NULL, bool throwOnOutOfMemoryWithinRange = true);
 
 // Get Rel32 destination, emit jumpStub if necessary into a preallocated location
-INT32 rel32UsingPreallocatedJumpStub(INT32 UNALIGNED * pRel32, PCODE target, PCODE jumpStubAddr, bool emitJump);
+INT32 rel32UsingPreallocatedJumpStub(INT32 UNALIGNED * pRel32, PCODE target, PCODE jumpStubAddr, PCODE jumpStubAddrRW, bool emitJump);
 
-void emitCOMStubCall (ComCallMethodDesc *pCOMMethod, PCODE target);
+void emitCOMStubCall (ComCallMethodDesc *pCOMMethodRX, ComCallMethodDesc *pCOMMethodRW, PCODE target);
 
-void emitJump(LPBYTE pBuffer, LPVOID target);
+void emitJump(LPBYTE pBufferRX, LPBYTE pBufferRW, LPVOID target);
 
 BOOL isJumpRel32(PCODE pCode);
 PCODE decodeJump32(PCODE pCode);
@@ -388,11 +388,11 @@ PCODE decodeJump64(PCODE pCode);
 // For all other platforms back to back jumps don't require anything special
 // That is why we have these two wrapper functions that call emitJump and decodeJump
 //
-inline void emitBackToBackJump(LPBYTE pBuffer, LPVOID target)
+inline void emitBackToBackJump(LPBYTE pBufferRX, LPBYTE pBufferRW, LPVOID target)
 {
     WRAPPER_NO_CONTRACT;
 
-    emitJump(pBuffer, target);
+    emitJump(pBufferRX, pBufferRW, target);
 }
 
 inline BOOL isBackToBackJump(PCODE pCode)
@@ -438,7 +438,7 @@ struct DECLSPEC_ALIGN(8) UMEntryThunkCode
     BYTE            m_jmpRAX[3];    // JMP RAX
     BYTE            m_padding2[5];
 
-    void Encode(BYTE* pTargetCode, void* pvSecretParam);
+    void Encode(UMEntryThunkCode *pEntryThunkCodeRX, BYTE* pTargetCode, void* pvSecretParam);
     void Poison();
 
     LPCBYTE GetEntryPoint() const
@@ -610,19 +610,19 @@ class CallCountingStubShort : public CallCountingStub
 
 #ifndef DACCESS_COMPILE
 public:
-    CallCountingStubShort(CallCount *remainingCallCountCell, PCODE targetForMethod)
+    CallCountingStubShort(CallCountingStubShort* stubRX, CallCount *remainingCallCountCell, PCODE targetForMethod)
         : m_part0{                                              0x48, 0xb8},            //     mov  rax,
         m_remainingCallCountCell(remainingCallCountCell),                               //               <imm64>
         m_part1{                                                0x66, 0xff, 0x08,       //     dec  word ptr [rax]
                                                                 0x0f, 0x85},            //     jnz  
         m_rel32TargetForMethod(                                                         //          <rel32>
             GetRelative32BitOffset(
-                &m_rel32TargetForMethod,
+                &stubRX->m_rel32TargetForMethod,
                 targetForMethod)),
         m_part2{                                                0xe8},                  //     call
         m_rel32TargetForThresholdReached(                                               //          <rel32>
             GetRelative32BitOffset(
-                &m_rel32TargetForThresholdReached,
+                &stubRX->m_rel32TargetForThresholdReached,
                 TargetForThresholdReached)),
                                                                                         // (rip == stub-identifying token)
         m_alignmentPadding{}
diff --git a/src/coreclr/vm/amd64/virtualcallstubcpu.hpp b/src/coreclr/vm/amd64/virtualcallstubcpu.hpp
index 860a681e213527..70b2de5813438e 100644
--- a/src/coreclr/vm/amd64/virtualcallstubcpu.hpp
+++ b/src/coreclr/vm/amd64/virtualcallstubcpu.hpp
@@ -97,7 +97,7 @@ struct LookupHolder
 {
     static void InitializeStatic();
 
-    void  Initialize(PCODE resolveWorkerTarget, size_t dispatchToken);
+    void  Initialize(LookupHolder* pLookupHolderRX, PCODE resolveWorkerTarget, size_t dispatchToken);
 
     LookupStub*    stub()         { LIMITED_METHOD_CONTRACT;  return &_stub;    }
 
@@ -317,7 +317,7 @@ struct DispatchHolder
 {
     static void InitializeStatic();
 
-    void  Initialize(PCODE implTarget, PCODE failTarget, size_t expectedMT,
+    void  Initialize(DispatchHolder* pDispatchHolderRX, PCODE implTarget, PCODE failTarget, size_t expectedMT,
                      DispatchStub::DispatchStubType type);
 
     static size_t GetHolderSize(DispatchStub::DispatchStubType type)
@@ -453,7 +453,8 @@ struct ResolveHolder
 {
     static void  InitializeStatic();
 
-    void  Initialize(PCODE resolveWorkerTarget, PCODE patcherTarget,
+    void  Initialize(ResolveHolder* pResolveHolderRX, 
+                     PCODE resolveWorkerTarget, PCODE patcherTarget,
                      size_t dispatchToken, UINT32 hashedToken,
                      void * cacheAddr, INT32* counterAddr);
 
@@ -573,7 +574,7 @@ void LookupHolder::InitializeStatic()
     lookupInit.part3 [1]           = 0xE0;
 }
 
-void  LookupHolder::Initialize(PCODE resolveWorkerTarget, size_t dispatchToken)
+void  LookupHolder::Initialize(LookupHolder* pLookupHolderRX, PCODE resolveWorkerTarget, size_t dispatchToken)
 {
     _stub = lookupInit;
 
@@ -632,7 +633,7 @@ void DispatchHolder::InitializeStatic()
     dispatchLongInit.part5 [1]        = 0xE0;
 };
 
-void  DispatchHolder::Initialize(PCODE implTarget, PCODE failTarget, size_t expectedMT,
+void  DispatchHolder::Initialize(DispatchHolder* pDispatchHolderRX, PCODE implTarget, PCODE failTarget, size_t expectedMT,
                                DispatchStub::DispatchStubType type)
 {
     //
@@ -650,17 +651,18 @@ void  DispatchHolder::Initialize(PCODE implTarget, PCODE failTarget, size_t expe
     //
     if (type == DispatchStub::e_TYPE_SHORT)
     {
-        DispatchStubShort *shortStub = const_cast<DispatchStubShort *>(stub()->getShortStub());
+        DispatchStubShort *shortStubRW = const_cast<DispatchStubShort *>(stub()->getShortStub());
+        DispatchStubShort *shortStubRX = const_cast<DispatchStubShort *>(pDispatchHolderRX->stub()->getShortStub());
 
         // initialize the static data
-        *shortStub = dispatchShortInit;
+        *shortStubRW = dispatchShortInit;
 
         // fill in the dynamic data
-        size_t displ = (failTarget - ((PCODE) &shortStub->_failDispl + sizeof(DISPL)));
+        size_t displ = (failTarget - ((PCODE) &shortStubRX->_failDispl + sizeof(DISPL)));
         CONSISTENCY_CHECK(FitsInI4(displ));
-        shortStub->_failDispl   = (DISPL) displ;
-        shortStub->_implTarget  = (size_t) implTarget;
-        CONSISTENCY_CHECK((PCODE)&shortStub->_failDispl + sizeof(DISPL) + shortStub->_failDispl == failTarget);
+        shortStubRW->_failDispl   = (DISPL) displ;
+        shortStubRW->_implTarget  = (size_t) implTarget;
+        CONSISTENCY_CHECK((PCODE)&shortStubRX->_failDispl + sizeof(DISPL) + shortStubRX->_failDispl == failTarget);
     }
     else
     {
@@ -769,7 +771,8 @@ void ResolveHolder::InitializeStatic()
     resolveInit.part10 [1]             = 0xE0;
 };
 
-void  ResolveHolder::Initialize(PCODE resolveWorkerTarget, PCODE patcherTarget,
+void  ResolveHolder::Initialize(ResolveHolder* pResolveHolderRX, 
+                                PCODE resolveWorkerTarget, PCODE patcherTarget,
                                 size_t dispatchToken, UINT32 hashedToken,
                                 void * cacheAddr, INT32* counterAddr)
 {
diff --git a/src/coreclr/vm/appdomain.cpp b/src/coreclr/vm/appdomain.cpp
index 8fa02c4f12179b..f7bf57c5b52cf1 100644
--- a/src/coreclr/vm/appdomain.cpp
+++ b/src/coreclr/vm/appdomain.cpp
@@ -47,10 +47,13 @@
 #include "runtimecallablewrapper.h"
 #include "mngstdinterfaces.h"
 #include "olevariant.h"
-#include "rcwrefcache.h"
 #include "olecontexthelpers.h"
 #endif // FEATURE_COMINTEROP
 
+#if defined(FEATURE_COMWRAPPERS)
+#include "rcwrefcache.h"
+#endif // FEATURE_COMWRAPPERS
+
 #include "typeequivalencehash.hpp"
 
 #include "appdomain.inl"
@@ -1502,7 +1505,14 @@ void SystemDomain::LoadBaseSystemClasses()
     g_pThreadClass = CoreLibBinder::GetClass(CLASS__THREAD);
 
 #ifdef FEATURE_COMINTEROP
-    g_pBaseCOMObject = CoreLibBinder::GetClass(CLASS__COM_OBJECT);
+    if (g_pConfig->IsBuiltInCOMSupported())
+    {
+        g_pBaseCOMObject = CoreLibBinder::GetClass(CLASS__COM_OBJECT);
+    }
+    else
+    {
+        g_pBaseCOMObject = NULL;
+    }
 #endif
 
     g_pIDynamicInterfaceCastableInterface = CoreLibBinder::GetClass(CLASS__IDYNAMICINTERFACECASTABLE);
@@ -2024,31 +2034,31 @@ void SystemDomain::NotifyProfilerStartup()
     CONTRACTL_END;
 
     {
-        BEGIN_PIN_PROFILER(CORProfilerTrackAppDomainLoads());
+        BEGIN_PROFILER_CALLBACK(CORProfilerTrackAppDomainLoads());
         _ASSERTE(System());
-        g_profControlBlock.pProfInterface->AppDomainCreationStarted((AppDomainID) System());
-        END_PIN_PROFILER();
+        (&g_profControlBlock)->AppDomainCreationStarted((AppDomainID) System());
+        END_PROFILER_CALLBACK();
     }
 
     {
-        BEGIN_PIN_PROFILER(CORProfilerTrackAppDomainLoads());
+        BEGIN_PROFILER_CALLBACK(CORProfilerTrackAppDomainLoads());
         _ASSERTE(System());
-        g_profControlBlock.pProfInterface->AppDomainCreationFinished((AppDomainID) System(), S_OK);
-        END_PIN_PROFILER();
+        (&g_profControlBlock)->AppDomainCreationFinished((AppDomainID) System(), S_OK);
+        END_PROFILER_CALLBACK();
     }
 
     {
-        BEGIN_PIN_PROFILER(CORProfilerTrackAppDomainLoads());
+        BEGIN_PROFILER_CALLBACK(CORProfilerTrackAppDomainLoads());
         _ASSERTE(System()->DefaultDomain());
-        g_profControlBlock.pProfInterface->AppDomainCreationStarted((AppDomainID) System()->DefaultDomain());
-        END_PIN_PROFILER();
+        (&g_profControlBlock)->AppDomainCreationStarted((AppDomainID) System()->DefaultDomain());
+        END_PROFILER_CALLBACK();
     }
 
     {
-        BEGIN_PIN_PROFILER(CORProfilerTrackAppDomainLoads());
+        BEGIN_PROFILER_CALLBACK(CORProfilerTrackAppDomainLoads());
         _ASSERTE(System()->DefaultDomain());
-        g_profControlBlock.pProfInterface->AppDomainCreationFinished((AppDomainID) System()->DefaultDomain(), S_OK);
-        END_PIN_PROFILER();
+        (&g_profControlBlock)->AppDomainCreationFinished((AppDomainID) System()->DefaultDomain(), S_OK);
+        END_PROFILER_CALLBACK();
     }
 }
 
@@ -2063,31 +2073,31 @@ HRESULT SystemDomain::NotifyProfilerShutdown()
     CONTRACTL_END;
 
     {
-        BEGIN_PIN_PROFILER(CORProfilerTrackAppDomainLoads());
+        BEGIN_PROFILER_CALLBACK(CORProfilerTrackAppDomainLoads());
         _ASSERTE(System());
-        g_profControlBlock.pProfInterface->AppDomainShutdownStarted((AppDomainID) System());
-        END_PIN_PROFILER();
+        (&g_profControlBlock)->AppDomainShutdownStarted((AppDomainID) System());
+        END_PROFILER_CALLBACK();
     }
 
     {
-        BEGIN_PIN_PROFILER(CORProfilerTrackAppDomainLoads());
+        BEGIN_PROFILER_CALLBACK(CORProfilerTrackAppDomainLoads());
         _ASSERTE(System());
-        g_profControlBlock.pProfInterface->AppDomainShutdownFinished((AppDomainID) System(), S_OK);
-        END_PIN_PROFILER();
+        (&g_profControlBlock)->AppDomainShutdownFinished((AppDomainID) System(), S_OK);
+        END_PROFILER_CALLBACK();
     }
 
     {
-        BEGIN_PIN_PROFILER(CORProfilerTrackAppDomainLoads());
+        BEGIN_PROFILER_CALLBACK(CORProfilerTrackAppDomainLoads());
         _ASSERTE(System()->DefaultDomain());
-        g_profControlBlock.pProfInterface->AppDomainShutdownStarted((AppDomainID) System()->DefaultDomain());
-        END_PIN_PROFILER();
+        (&g_profControlBlock)->AppDomainShutdownStarted((AppDomainID) System()->DefaultDomain());
+        END_PROFILER_CALLBACK();
     }
 
     {
-        BEGIN_PIN_PROFILER(CORProfilerTrackAppDomainLoads());
+        BEGIN_PROFILER_CALLBACK(CORProfilerTrackAppDomainLoads());
         _ASSERTE(System()->DefaultDomain());
-        g_profControlBlock.pProfInterface->AppDomainShutdownFinished((AppDomainID) System()->DefaultDomain(), S_OK);
-        END_PIN_PROFILER();
+        (&g_profControlBlock)->AppDomainShutdownFinished((AppDomainID) System()->DefaultDomain(), S_OK);
+        END_PROFILER_CALLBACK();
     }
     return (S_OK);
 }
@@ -2113,8 +2123,10 @@ AppDomain::AppDomain()
     m_dwFlags = 0;
 #ifdef FEATURE_COMINTEROP
     m_pRCWCache = NULL;
+#endif //FEATURE_COMINTEROP
+#ifdef FEATURE_COMWRAPPERS
     m_pRCWRefCache = NULL;
-#endif // FEATURE_COMINTEROP
+#endif // FEATURE_COMWRAPPERS
 
     m_handleStore = NULL;
 
@@ -4418,7 +4430,7 @@ void AppDomain::NotifyDebuggerUnload()
 
 #ifndef CROSSGEN_COMPILE
 
-#ifdef FEATURE_COMINTEROP
+#ifdef FEATURE_COMWRAPPERS
 
 RCWRefCache *AppDomain::GetRCWRefCache()
 {
@@ -4440,6 +4452,9 @@ RCWRefCache *AppDomain::GetRCWRefCache()
     }
     RETURN m_pRCWRefCache;
 }
+#endif // FEATURE_COMWRAPPERS
+
+#ifdef FEATURE_COMINTEROP
 
 RCWCache *AppDomain::CreateRCWCache()
 {
diff --git a/src/coreclr/vm/appdomain.hpp b/src/coreclr/vm/appdomain.hpp
index 84101004f84f4a..0487299c5f26c9 100644
--- a/src/coreclr/vm/appdomain.hpp
+++ b/src/coreclr/vm/appdomain.hpp
@@ -48,8 +48,10 @@ class TypeEquivalenceHashTable;
 
 #ifdef FEATURE_COMINTEROP
 class RCWCache;
+#endif //FEATURE_COMINTEROP
+#ifdef FEATURE_COMWRAPPERS
 class RCWRefCache;
-#endif // FEATURE_COMINTEROP
+#endif // FEATURE_COMWRAPPERS
 
 #ifdef _MSC_VER
 #pragma warning(push)
@@ -1972,9 +1974,13 @@ class AppDomain : public BaseDomain
         return m_pRCWCache;
     }
 
-    RCWRefCache *GetRCWRefCache();
 #endif // FEATURE_COMINTEROP
 
+#ifdef FEATURE_COMWRAPPERS
+public:
+    RCWRefCache *GetRCWRefCache();
+#endif // FEATURE_COMWRAPPERS
+
     TPIndex GetTPIndex()
     {
         LIMITED_METHOD_CONTRACT;
@@ -2240,10 +2246,11 @@ class AppDomain : public BaseDomain
 #ifdef FEATURE_COMINTEROP
     // this cache stores the RCWs in this domain
     RCWCache *m_pRCWCache;
-
+#endif //FEATURE_COMINTEROP
+#ifdef FEATURE_COMWRAPPERS
     // this cache stores the RCW -> CCW references in this domain
     RCWRefCache *m_pRCWRefCache;
-#endif // FEATURE_COMINTEROP
+#endif // FEATURE_COMWRAPPERS
 
     // The thread-pool index of this app domain among existing app domains (starting from 1)
     TPIndex m_tpIndex;
diff --git a/src/coreclr/vm/arm/cgencpu.h b/src/coreclr/vm/arm/cgencpu.h
index 4f6e1deb4fe45f..88d0c6802b69df 100644
--- a/src/coreclr/vm/arm/cgencpu.h
+++ b/src/coreclr/vm/arm/cgencpu.h
@@ -232,7 +232,7 @@ inline void ClearITState(T_CONTEXT *context) {
 }
 
 #ifdef FEATURE_COMINTEROP
-void emitCOMStubCall (ComCallMethodDesc *pCOMMethod, PCODE target);
+void emitCOMStubCall (ComCallMethodDesc *pCOMMethodRX, ComCallMethodDesc *pCOMMethodRW, PCODE target);
 #endif // FEATURE_COMINTEROP
 
 //------------------------------------------------------------------------
@@ -283,14 +283,14 @@ inline int16_t decodeUnconditionalBranchThumb(LPBYTE pBuffer)
 }
 
 //------------------------------------------------------------------------
-inline void emitJump(LPBYTE pBuffer, LPVOID target)
+inline void emitJump(LPBYTE pBufferRX, LPBYTE pBufferRW, LPVOID target)
 {
     LIMITED_METHOD_CONTRACT;
 
     // The PC-relative load we emit below requires 4-byte alignment for the offset to be calculated correctly.
-    _ASSERTE(((UINT_PTR)pBuffer & 3) == 0);
+    _ASSERTE(((UINT_PTR)pBufferRX & 3) == 0);
 
-    DWORD * pCode = (DWORD *)pBuffer;
+    DWORD * pCode = (DWORD *)pBufferRW;
 
     // ldr pc, [pc, #0]
     pCode[0] = 0xf000f8df;
@@ -335,10 +335,10 @@ inline BOOL isBackToBackJump(PCODE pBuffer)
 }
 
 //------------------------------------------------------------------------
-inline void emitBackToBackJump(LPBYTE pBuffer, LPVOID target)
+inline void emitBackToBackJump(LPBYTE pBufferRX, LPBYTE pBufferRW, LPVOID target)
 {
     WRAPPER_NO_CONTRACT;
-    emitJump(pBuffer, target);
+    emitJump(pBufferRX, pBufferRW, target);
 }
 
 //------------------------------------------------------------------------
@@ -943,7 +943,7 @@ struct DECLSPEC_ALIGN(4) UMEntryThunkCode
     TADDR       m_pTargetCode;
     TADDR       m_pvSecretParam;
 
-    void Encode(BYTE* pTargetCode, void* pvSecretParam);
+    void Encode(UMEntryThunkCode *pEntryThunkCodeRX, BYTE* pTargetCode, void* pvSecretParam);
     void Poison();
 
     LPCBYTE GetEntryPoint() const
@@ -1055,7 +1055,7 @@ struct StubPrecode {
     TADDR   m_pTarget;
     TADDR   m_pMethodDesc;
 
-    void Init(MethodDesc* pMD, LoaderAllocator *pLoaderAllocator);
+    void Init(StubPrecode* pPrecodeRX, MethodDesc* pMD, LoaderAllocator *pLoaderAllocator);
 
     TADDR GetMethodDesc()
     {
@@ -1078,7 +1078,8 @@ struct StubPrecode {
         }
         CONTRACTL_END;
 
-        InterlockedExchange((LONG*)&m_pTarget, (LONG)GetPreStubEntryPoint());
+        ExecutableWriterHolder<StubPrecode> precodeWriterHolder(this, sizeof(StubPrecode));
+        InterlockedExchange((LONG*)&precodeWriterHolder.GetRW()->m_pTarget, (LONG)GetPreStubEntryPoint());
     }
 
     BOOL SetTargetInterlocked(TADDR target, TADDR expected)
@@ -1090,8 +1091,9 @@ struct StubPrecode {
         }
         CONTRACTL_END;
 
+        ExecutableWriterHolder<StubPrecode> precodeWriterHolder(this, sizeof(StubPrecode));
         return (TADDR)InterlockedCompareExchange(
-            (LONG*)&m_pTarget, (LONG)target, (LONG)expected) == expected;
+            (LONG*)&precodeWriterHolder.GetRW()->m_pTarget, (LONG)target, (LONG)expected) == expected;
     }
 
 #ifdef FEATURE_PREJIT
@@ -1114,7 +1116,7 @@ struct NDirectImportPrecode {
                             // takes advantage of this to detect NDirectImportPrecode.
     TADDR   m_pTarget;
 
-    void Init(MethodDesc* pMD, LoaderAllocator *pLoaderAllocator);
+    void Init(NDirectImportPrecode* pPrecodeRX, MethodDesc* pMD, LoaderAllocator *pLoaderAllocator);
 
     TADDR GetMethodDesc()
     {
@@ -1155,7 +1157,7 @@ struct FixupPrecode {
     BYTE    m_PrecodeChunkIndex;
     TADDR   m_pTarget;
 
-    void Init(MethodDesc* pMD, LoaderAllocator *pLoaderAllocator, int iMethodDescChunkIndex = 0, int iPrecodeChunkIndex = 0);
+    void Init(FixupPrecode* pPrecodeRX, MethodDesc* pMD, LoaderAllocator *pLoaderAllocator, int iMethodDescChunkIndex = 0, int iPrecodeChunkIndex = 0);
 
     TADDR GetBase()
     {
@@ -1182,7 +1184,8 @@ struct FixupPrecode {
         }
         CONTRACTL_END;
 
-        InterlockedExchange((LONG*)&m_pTarget, (LONG)GetEEFuncEntryPoint(PrecodeFixupThunk));
+        ExecutableWriterHolder<FixupPrecode> precodeWriterHolder(this, sizeof(FixupPrecode));
+        InterlockedExchange((LONG*)&precodeWriterHolder.GetRW()->m_pTarget, (LONG)GetEEFuncEntryPoint(PrecodeFixupThunk));
     }
 
     BOOL SetTargetInterlocked(TADDR target, TADDR expected)
@@ -1194,8 +1197,9 @@ struct FixupPrecode {
         }
         CONTRACTL_END;
 
+        ExecutableWriterHolder<FixupPrecode> precodeWriterHolder(this, sizeof(FixupPrecode));
         return (TADDR)InterlockedCompareExchange(
-            (LONG*)&m_pTarget, (LONG)target, (LONG)expected) == expected;
+            (LONG*)&precodeWriterHolder.GetRW()->m_pTarget, (LONG)target, (LONG)expected) == expected;
     }
 
     static BOOL IsFixupPrecodeByASM(PCODE addr)
@@ -1261,7 +1265,8 @@ struct ThisPtrRetBufPrecode {
         }
         CONTRACTL_END;
 
-        return FastInterlockCompareExchange((LONG*)&m_pTarget, (LONG)target, (LONG)expected) == (LONG)expected;
+        ExecutableWriterHolder<ThisPtrRetBufPrecode> precodeWriterHolder(this, sizeof(ThisPtrRetBufPrecode)); 
+        return FastInterlockCompareExchange((LONG*)&precodeWriterHolder.GetRW()->m_pTarget, (LONG)target, (LONG)expected) == (LONG)expected;
     }
 };
 typedef DPTR(ThisPtrRetBufPrecode) PTR_ThisPtrRetBufPrecode;
@@ -1364,7 +1369,7 @@ class CallCountingStubShort : public CallCountingStub
 
 #ifndef DACCESS_COMPILE
 public:
-    CallCountingStubShort(CallCount *remainingCallCountCell, PCODE targetForMethod)
+    CallCountingStubShort(CallCountingStubShort* stubRX, CallCount *remainingCallCountCell, PCODE targetForMethod)
         : m_part0{  0xb401,                 //     push {r0}
                     0xf8df, 0xc01c,         //     ldr  r12, [pc, #(m_remainingCallCountCell)]
                     0xf8bc, 0x0000,         //     ldrh r0, [r12]
diff --git a/src/coreclr/vm/arm/stubs.cpp b/src/coreclr/vm/arm/stubs.cpp
index 1ca6fd09642d03..aac3e25b18146f 100644
--- a/src/coreclr/vm/arm/stubs.cpp
+++ b/src/coreclr/vm/arm/stubs.cpp
@@ -98,7 +98,7 @@ class ThumbCondJump : public InstructionFormat
         //Encoding 1|0|1|1|op|0|i|1|imm5|Rn
         //op = Bit3(variation)
         //Rn = Bits2-0(variation)
-        virtual VOID EmitInstruction(UINT refsize, __int64 fixedUpReference, BYTE *pOutBuffer, UINT variationCode, BYTE *pDataBuffer)
+        virtual VOID EmitInstruction(UINT refsize, __int64 fixedUpReference, BYTE *pOutBufferRX, BYTE *pOutBufferRW, UINT variationCode, BYTE *pDataBuffer)
         {
             LIMITED_METHOD_CONTRACT
 
@@ -109,8 +109,8 @@ class ThumbCondJump : public InstructionFormat
 
             _ASSERTE((fixedUpReference & 0x1) == 0);
 
-            pOutBuffer[0] = static_cast<BYTE>(((0x3e & fixedUpReference) << 2) | (0x7 & variationCode));
-            pOutBuffer[1] = static_cast<BYTE>(0xb1 | (0x8 & variationCode)| ((0x40 & fixedUpReference)>>5));
+            pOutBufferRW[0] = static_cast<BYTE>(((0x3e & fixedUpReference) << 2) | (0x7 & variationCode));
+            pOutBufferRW[1] = static_cast<BYTE>(0xb1 | (0x8 & variationCode)| ((0x40 & fixedUpReference)>>5));
         }
 };
 
@@ -138,7 +138,7 @@ class ThumbNearJump : public InstructionFormat
             return 0;
         }
 
-        virtual VOID EmitInstruction(UINT refsize, __int64 fixedUpReference, BYTE *pOutBuffer, UINT cond, BYTE *pDataBuffer)
+        virtual VOID EmitInstruction(UINT refsize, __int64 fixedUpReference, BYTE *pOutBufferRX, BYTE *pOutBufferRW, UINT cond, BYTE *pDataBuffer)
         {
             LIMITED_METHOD_CONTRACT
 
@@ -155,8 +155,8 @@ class ThumbNearJump : public InstructionFormat
                         _ASSERTE(!"Expected refSize to be 2");
 
                     //Emit T2 encoding of B<c> <label> instruction
-                    pOutBuffer[0] = static_cast<BYTE>((fixedUpReference & 0x1fe)>>1);
-                    pOutBuffer[1] = static_cast<BYTE>(0xe0 | ((fixedUpReference & 0xe00)>>9));
+                    pOutBufferRW[0] = static_cast<BYTE>((fixedUpReference & 0x1fe)>>1);
+                    pOutBufferRW[1] = static_cast<BYTE>(0xe0 | ((fixedUpReference & 0xe00)>>9));
                 }
                 else if(fixedUpReference >= -16777216 && fixedUpReference <= 16777214)
                 {
@@ -167,10 +167,10 @@ class ThumbNearJump : public InstructionFormat
                     int s = (fixedUpReference & 0x1000000) >> 24;
                     int i1 = (fixedUpReference & 0x800000) >> 23;
                     int i2 = (fixedUpReference & 0x400000) >> 22;
-                    pOutBuffer[0] = static_cast<BYTE>((fixedUpReference & 0xff000) >> 12);
-                    pOutBuffer[1] = static_cast<BYTE>(0xf0 | (s << 2) |( (fixedUpReference & 0x300000) >>20));
-                    pOutBuffer[2] = static_cast<BYTE>((fixedUpReference & 0x1fe) >> 1);
-                    pOutBuffer[3] = static_cast<BYTE>(0x90 | (~(i1^s)) << 5 | (~(i2^s)) << 3 | (fixedUpReference & 0xe00) >> 9);
+                    pOutBufferRW[0] = static_cast<BYTE>((fixedUpReference & 0xff000) >> 12);
+                    pOutBufferRW[1] = static_cast<BYTE>(0xf0 | (s << 2) |( (fixedUpReference & 0x300000) >>20));
+                    pOutBufferRW[2] = static_cast<BYTE>((fixedUpReference & 0x1fe) >> 1);
+                    pOutBufferRW[3] = static_cast<BYTE>(0x90 | (~(i1^s)) << 5 | (~(i2^s)) << 3 | (fixedUpReference & 0xe00) >> 9);
                 }
                 else
                 {
@@ -185,8 +185,8 @@ class ThumbNearJump : public InstructionFormat
                         _ASSERTE(!"Expected refSize to be 2");
 
                     //Emit T1 encoding of B<c> <label> instruction
-                    pOutBuffer[0] = static_cast<BYTE>((fixedUpReference & 0x1fe)>>1);
-                    pOutBuffer[1] = static_cast<BYTE>(0xd0 | (cond & 0xf));
+                    pOutBufferRW[0] = static_cast<BYTE>((fixedUpReference & 0x1fe)>>1);
+                    pOutBufferRW[1] = static_cast<BYTE>(0xd0 | (cond & 0xf));
                 }
                 else if(fixedUpReference >= -1048576 && fixedUpReference <= 1048574)
                 {
@@ -194,10 +194,10 @@ class ThumbNearJump : public InstructionFormat
                         _ASSERTE(!"Expected refSize to be 4");
 
                     //Emit T3 encoding of B<c> <label> instruction
-                    pOutBuffer[0] = static_cast<BYTE>(((cond & 0x3) << 6) | ((fixedUpReference & 0x3f000) >>12));
-                    pOutBuffer[1] = static_cast<BYTE>(0xf0 | ((fixedUpReference & 0x100000) >>18) | ((cond & 0xc) >> 2));
-                    pOutBuffer[2] = static_cast<BYTE>((fixedUpReference & 0x1fe) >> 1);
-                    pOutBuffer[3] = static_cast<BYTE>(0x80 | ((fixedUpReference & 0x40000) >> 13) | ((fixedUpReference & 0x80000) >> 16) | ((fixedUpReference & 0xe00) >> 9));
+                    pOutBufferRW[0] = static_cast<BYTE>(((cond & 0x3) << 6) | ((fixedUpReference & 0x3f000) >>12));
+                    pOutBufferRW[1] = static_cast<BYTE>(0xf0 | ((fixedUpReference & 0x100000) >>18) | ((cond & 0xc) >> 2));
+                    pOutBufferRW[2] = static_cast<BYTE>((fixedUpReference & 0x1fe) >> 1);
+                    pOutBufferRW[3] = static_cast<BYTE>(0x80 | ((fixedUpReference & 0x40000) >> 13) | ((fixedUpReference & 0x80000) >> 16) | ((fixedUpReference & 0xe00) >> 9));
                 }
                 else
                 {
@@ -714,7 +714,7 @@ void FixupPrecode::EnumMemoryRegions(CLRDataEnumMemoryFlags flags)
 
 #ifndef DACCESS_COMPILE
 
-void StubPrecode::Init(MethodDesc* pMD, LoaderAllocator *pLoaderAllocator)
+void StubPrecode::Init(StubPrecode* pPrecodeRX, MethodDesc* pMD, LoaderAllocator *pLoaderAllocator)
 {
     WRAPPER_NO_CONTRACT;
 
@@ -748,7 +748,7 @@ void StubPrecode::Fixup(DataImage *image)
 }
 #endif // FEATURE_NATIVE_IMAGE_GENERATION
 
-void NDirectImportPrecode::Init(MethodDesc* pMD, LoaderAllocator *pLoaderAllocator)
+void NDirectImportPrecode::Init(NDirectImportPrecode* pPrecodeRX, MethodDesc* pMD, LoaderAllocator *pLoaderAllocator)
 {
     WRAPPER_NO_CONTRACT;
 
@@ -782,7 +782,7 @@ void NDirectImportPrecode::Fixup(DataImage *image)
 }
 #endif
 
-void FixupPrecode::Init(MethodDesc* pMD, LoaderAllocator *pLoaderAllocator, int iMethodDescChunkIndex /*=0*/, int iPrecodeChunkIndex /*=0*/)
+void FixupPrecode::Init(FixupPrecode* pPrecodeRX, MethodDesc* pMD, LoaderAllocator *pLoaderAllocator, int iMethodDescChunkIndex /*=0*/, int iPrecodeChunkIndex /*=0*/)
 {
     WRAPPER_NO_CONTRACT;
 
@@ -915,7 +915,7 @@ Note that ResolveWorkerChainLookupAsmStub currently points directly
 to ResolveWorkerAsmStub; in the future, this could be separate.
 */
 
-void  LookupHolder::Initialize(PCODE resolveWorkerTarget, size_t dispatchToken)
+void  LookupHolder::Initialize(LookupHolder* pLookupHolderRX, PCODE resolveWorkerTarget, size_t dispatchToken)
 {
     // Called directly by JITTED code
     // See ResolveWorkerAsmStub
@@ -932,7 +932,7 @@ void  LookupHolder::Initialize(PCODE resolveWorkerTarget, size_t dispatchToken)
     _ASSERTE(4 == LookupStub::entryPointLen);
 }
 
-void  DispatchHolder::Initialize(PCODE implTarget, PCODE failTarget, size_t expectedMT)
+void  DispatchHolder::Initialize(DispatchHolder* pDispatchHolderRX, PCODE implTarget, PCODE failTarget, size_t expectedMT)
 {
     // Called directly by JITTED code
     // DispatchHolder._stub._entryPoint(r0:object, r1, r2, r3, r4:IndirectionCell)
@@ -1004,7 +1004,8 @@ void  DispatchHolder::Initialize(PCODE implTarget, PCODE failTarget, size_t expe
     _stub._implTarget = implTarget;
 }
 
-void ResolveHolder::Initialize(PCODE resolveWorkerTarget, PCODE patcherTarget,
+void ResolveHolder::Initialize(ResolveHolder* pResolveHolderRX,
+                               PCODE resolveWorkerTarget, PCODE patcherTarget,
                                 size_t dispatchToken, UINT32 hashedToken,
                                 void * cacheAddr, INT32 * counterAddr)
 {
@@ -1980,7 +1981,7 @@ class UMEntryThunk * UMEntryThunk::Decode(void *pCallback)
     return NULL;
 }
 
-void UMEntryThunkCode::Encode(BYTE* pTargetCode, void* pvSecretParam)
+void UMEntryThunkCode::Encode(UMEntryThunkCode *pEntryThunkCodeRX, BYTE* pTargetCode, void* pvSecretParam)
 {
     // ldr r12, [pc + 8]
     m_code[0] = 0xf8df;
@@ -1992,19 +1993,22 @@ void UMEntryThunkCode::Encode(BYTE* pTargetCode, void* pvSecretParam)
     m_pTargetCode = (TADDR)pTargetCode;
     m_pvSecretParam = (TADDR)pvSecretParam;
 
-    FlushInstructionCache(GetCurrentProcess(),&m_code,sizeof(m_code));
+    FlushInstructionCache(GetCurrentProcess(),&pEntryThunkCodeRX->m_code,sizeof(m_code));
 }
 
 #ifndef DACCESS_COMPILE
 
 void UMEntryThunkCode::Poison()
 {
-    m_pTargetCode = (TADDR)UMEntryThunk::ReportViolation;
+    ExecutableWriterHolder<UMEntryThunkCode> thunkWriterHolder(this, sizeof(UMEntryThunkCode));
+    UMEntryThunkCode *pThisRW = thunkWriterHolder.GetRW();
+
+    pThisRW->m_pTargetCode = (TADDR)UMEntryThunk::ReportViolation;
 
     // ldr r0, [pc + 8]
-    m_code[0] = 0x4802;
+    pThisRW->m_code[0] = 0x4802;
     // nop
-    m_code[1] = 0xbf00;
+    pThisRW->m_code[1] = 0xbf00;
 
     ClrFlushInstructionCache(&m_code,sizeof(m_code));
 }
@@ -2052,7 +2056,7 @@ VOID ResetCurrentContext()
 
 
 #ifdef FEATURE_COMINTEROP
-void emitCOMStubCall (ComCallMethodDesc *pCOMMethod, PCODE target)
+void emitCOMStubCall (ComCallMethodDesc *pCOMMethodRX, ComCallMethodDesc *pCOMMethodRW, PCODE target)
 {
     WRAPPER_NO_CONTRACT;
 
@@ -2065,16 +2069,17 @@ void emitCOMStubCall (ComCallMethodDesc *pCOMMethod, PCODE target)
         0xf8df, 0xf004
     };
 
-    BYTE *pBuffer = (BYTE*)pCOMMethod - COMMETHOD_CALL_PRESTUB_SIZE;
+    BYTE *pBufferRX = (BYTE*)pCOMMethodRX - COMMETHOD_CALL_PRESTUB_SIZE;
+    BYTE *pBufferRW = (BYTE*)pCOMMethodRW - COMMETHOD_CALL_PRESTUB_SIZE;
 
-    memcpy(pBuffer, rgCode, sizeof(rgCode));
-    *((PCODE*)(pBuffer + sizeof(rgCode) + 2)) = target;
+    memcpy(pBufferRW, rgCode, sizeof(rgCode));
+    *((PCODE*)(pBufferRW + sizeof(rgCode) + 2)) = target;
 
     // Ensure that the updated instructions get actually written
-    ClrFlushInstructionCache(pBuffer, COMMETHOD_CALL_PRESTUB_SIZE);
+    ClrFlushInstructionCache(pBufferRX, COMMETHOD_CALL_PRESTUB_SIZE);
 
-    _ASSERTE(IS_ALIGNED(pBuffer + COMMETHOD_CALL_PRESTUB_ADDRESS_OFFSET, sizeof(void*)) &&
-             *((PCODE*)(pBuffer + COMMETHOD_CALL_PRESTUB_ADDRESS_OFFSET)) == target);
+    _ASSERTE(IS_ALIGNED(pBufferRX + COMMETHOD_CALL_PRESTUB_ADDRESS_OFFSET, sizeof(void*)) &&
+             *((PCODE*)(pBufferRX + COMMETHOD_CALL_PRESTUB_ADDRESS_OFFSET)) == target);
 }
 #endif // FEATURE_COMINTEROP
 
@@ -2103,14 +2108,17 @@ void MovRegImm(BYTE* p, int reg, TADDR imm)
 #define BEGIN_DYNAMIC_HELPER_EMIT(size) \
     SIZE_T cb = size; \
     SIZE_T cbAligned = ALIGN_UP(cb, DYNAMIC_HELPER_ALIGNMENT); \
-    BYTE * pStart = (BYTE *)(void *)pAllocator->GetDynamicHelpersHeap()->AllocAlignedMem(cbAligned, DYNAMIC_HELPER_ALIGNMENT); \
+    BYTE * pStartRX = (BYTE *)(void*)pAllocator->GetDynamicHelpersHeap()->AllocAlignedMem(cbAligned, DYNAMIC_HELPER_ALIGNMENT); \
+    ExecutableWriterHolder<BYTE> startWriterHolder(pStartRX, cbAligned); \
+    BYTE * pStart = startWriterHolder.GetRW(); \
+    size_t rxOffset = pStartRX - pStart; \
     BYTE * p = pStart;
 
 #define END_DYNAMIC_HELPER_EMIT() \
     _ASSERTE(pStart + cb == p); \
     while (p < pStart + cbAligned) { *(WORD *)p = 0xdefe; p += 2; } \
-    ClrFlushInstructionCache(pStart, cbAligned); \
-    return (PCODE)((TADDR)pStart | THUMB_CODE)
+    ClrFlushInstructionCache(pStartRX, cbAligned); \
+    return (PCODE)((TADDR)pStartRX | THUMB_CODE)
 
 PCODE DynamicHelpers::CreateHelper(LoaderAllocator * pAllocator, TADDR arg, PCODE target)
 {
@@ -2133,7 +2141,7 @@ PCODE DynamicHelpers::CreateHelper(LoaderAllocator * pAllocator, TADDR arg, PCOD
     END_DYNAMIC_HELPER_EMIT();
 }
 
-void DynamicHelpers::EmitHelperWithArg(BYTE*& p, LoaderAllocator * pAllocator, TADDR arg, PCODE target)
+void DynamicHelpers::EmitHelperWithArg(BYTE*& p, size_t rxOffset, LoaderAllocator * pAllocator, TADDR arg, PCODE target)
 {
     // mov r1, arg
     MovRegImm(p, 1, arg);
@@ -2152,7 +2160,7 @@ PCODE DynamicHelpers::CreateHelperWithArg(LoaderAllocator * pAllocator, TADDR ar
 {
     BEGIN_DYNAMIC_HELPER_EMIT(18);
 
-    EmitHelperWithArg(p, pAllocator, arg, target);
+    EmitHelperWithArg(p, rxOffset, pAllocator, arg, target);
 
     END_DYNAMIC_HELPER_EMIT();
 }
@@ -2308,9 +2316,10 @@ PCODE DynamicHelpers::CreateDictionaryLookupHelper(LoaderAllocator * pAllocator,
         GetEEFuncEntryPoint(JIT_GenericHandleClassWithSlotAndModule));
 
     GenericHandleArgs * pArgs = (GenericHandleArgs *)(void *)pAllocator->GetDynamicHelpersHeap()->AllocAlignedMem(sizeof(GenericHandleArgs), DYNAMIC_HELPER_ALIGNMENT);
-    pArgs->dictionaryIndexAndSlot = dictionaryIndexAndSlot;
-    pArgs->signature = pLookup->signature;
-    pArgs->module = (CORINFO_MODULE_HANDLE)pModule;
+    ExecutableWriterHolder<GenericHandleArgs> argsWriterHolder(pArgs, sizeof(GenericHandleArgs));
+    argsWriterHolder.GetRW()->dictionaryIndexAndSlot = dictionaryIndexAndSlot;
+    argsWriterHolder.GetRW()->signature = pLookup->signature;
+    argsWriterHolder.GetRW()->module = (CORINFO_MODULE_HANDLE)pModule;
 
     WORD slotOffset = (WORD)(dictionaryIndexAndSlot & 0xFFFF) * sizeof(Dictionary*);
 
@@ -2320,7 +2329,7 @@ PCODE DynamicHelpers::CreateDictionaryLookupHelper(LoaderAllocator * pAllocator,
     {
         BEGIN_DYNAMIC_HELPER_EMIT(18);
 
-        EmitHelperWithArg(p, pAllocator, (TADDR)pArgs, helperAddress);
+        EmitHelperWithArg(p, rxOffset, pAllocator, (TADDR)pArgs, helperAddress);
 
         END_DYNAMIC_HELPER_EMIT();
     }
@@ -2426,7 +2435,7 @@ PCODE DynamicHelpers::CreateDictionaryLookupHelper(LoaderAllocator * pAllocator,
             *(WORD *)p = 0x4618;
             p += 2;
 
-            EmitHelperWithArg(p, pAllocator, (TADDR)pArgs, helperAddress);
+            EmitHelperWithArg(p, rxOffset, pAllocator, (TADDR)pArgs, helperAddress);
         }
 
         END_DYNAMIC_HELPER_EMIT();
diff --git a/src/coreclr/vm/arm/virtualcallstubcpu.hpp b/src/coreclr/vm/arm/virtualcallstubcpu.hpp
index 0abf9ad572294e..919845c5ad2b81 100644
--- a/src/coreclr/vm/arm/virtualcallstubcpu.hpp
+++ b/src/coreclr/vm/arm/virtualcallstubcpu.hpp
@@ -74,7 +74,7 @@ struct LookupHolder
 {
     static void InitializeStatic() { LIMITED_METHOD_CONTRACT; }
 
-    void  Initialize(PCODE resolveWorkerTarget, size_t dispatchToken);
+    void  Initialize(LookupHolder* pLookupHolderRX, PCODE resolveWorkerTarget, size_t dispatchToken);
 
     LookupStub*    stub()               { LIMITED_METHOD_CONTRACT;  return &_stub;    }
 
@@ -122,7 +122,7 @@ struct DispatchStub
         LIMITED_METHOD_CONTRACT;
         _ASSERTE(slotTypeRef != nullptr);
 
-        *slotTypeRef = EntryPointSlots::SlotType_Normal;
+        *slotTypeRef = EntryPointSlots::SlotType_Executable;
         return (TADDR)&_implTarget;
     }
 
@@ -168,7 +168,7 @@ struct DispatchHolder
         static_assert_no_msg(((offsetof(DispatchHolder, _stub) + offsetof(DispatchStub, _implTarget)) % sizeof(void *)) == 0);
     }
 
-    void  Initialize(PCODE implTarget, PCODE failTarget, size_t expectedMT);
+    void  Initialize(DispatchHolder* pDispatchHolderRX, PCODE implTarget, PCODE failTarget, size_t expectedMT);
 
     DispatchStub* stub()      { LIMITED_METHOD_CONTRACT;  return &_stub; }
 
@@ -262,7 +262,8 @@ struct ResolveHolder
 {
     static void  InitializeStatic() { LIMITED_METHOD_CONTRACT; }
 
-    void  Initialize(PCODE resolveWorkerTarget, PCODE patcherTarget,
+    void  Initialize(ResolveHolder* pResolveHolderRX,
+                     PCODE resolveWorkerTarget, PCODE patcherTarget,
                      size_t dispatchToken, UINT32 hashedToken,
                      void * cacheAddr, INT32 * counterAddr);
 
diff --git a/src/coreclr/vm/arm64/arm64singlestepper.cpp b/src/coreclr/vm/arm64/arm64singlestepper.cpp
index 9ad561018c0809..d45925311a33ec 100644
--- a/src/coreclr/vm/arm64/arm64singlestepper.cpp
+++ b/src/coreclr/vm/arm64/arm64singlestepper.cpp
@@ -206,9 +206,8 @@ void Arm64SingleStepper::Apply(T_CONTEXT *pCtx)
     //     control in the breakpoint fixup logic we can then reset the PC to its proper location.
 
     unsigned int idxNextInstruction = 0;
-#if defined(HOST_OSX) && defined(HOST_ARM64)
-    auto jitWriteEnableHolder = PAL_JITWriteEnable(true);
-#endif // defined(HOST_OSX) && defined(HOST_ARM64)
+
+    ExecutableWriterHolder<DWORD> codeWriterHolder(m_rgCode, sizeof(m_rgCode));
 
     if (TryEmulate(pCtx, opcode, false))
     {
@@ -220,11 +219,11 @@ void Arm64SingleStepper::Apply(T_CONTEXT *pCtx)
     {
         LOG((LF_CORDB, LL_INFO100000, "Arm64SingleStepper: Case 2: CopyInstruction.\n"));
         // Case 2: In all other cases copy the instruction to the buffer and we'll run it directly.
-        m_rgCode[idxNextInstruction++] = opcode;
+        codeWriterHolder.GetRW()[idxNextInstruction++] = opcode;
     }
 
     // Always terminate the redirection buffer with a breakpoint.
-    m_rgCode[idxNextInstruction++] = kBreakpointOp;
+    codeWriterHolder.GetRW()[idxNextInstruction++] = kBreakpointOp;
     _ASSERTE(idxNextInstruction <= kMaxCodeBuffer);
 
     // Set the thread up so it will redirect to our buffer when execution resumes.
diff --git a/src/coreclr/vm/arm64/asmhelpers.S b/src/coreclr/vm/arm64/asmhelpers.S
index 78790be1d1a2ca..e6b47d07b2b0c7 100644
--- a/src/coreclr/vm/arm64/asmhelpers.S
+++ b/src/coreclr/vm/arm64/asmhelpers.S
@@ -213,7 +213,7 @@ LEAF_END ThePreStubPatch, _TEXT
     LEAF_END_MARKED \name, _TEXT
 .endm
 
-// void JIT_UpdateWriteBarrierState(bool skipEphemeralCheck)
+// void JIT_UpdateWriteBarrierState(bool skipEphemeralCheck, size_t writeableOffset)
 //
 // Update shadow copies of the various state info required for barrier
 //
@@ -232,6 +232,7 @@ WRITE_BARRIER_ENTRY JIT_UpdateWriteBarrierState
     // x12 will be used for pointers
 
     mov x8, x0
+    mov x9, x1 
 
     PREPARE_EXTERNAL_VAR g_card_table, x12
     ldr  x0, [x12]
@@ -272,6 +273,7 @@ LOCAL_LABEL(EphemeralCheckEnabled):
 #ifdef FEATURE_WRITEBARRIER_COPY
     PREPARE_EXTERNAL_VAR JIT_WriteBarrier_Table_Loc, x12
     ldr  x12, [x12]
+    add  x12, x12, x9
 #else // FEATURE_WRITEBARRIER_COPY
     adr  x12, LOCAL_LABEL(wbs_begin)
 #endif // FEATURE_WRITEBARRIER_COPY
diff --git a/src/coreclr/vm/arm64/asmhelpers.asm b/src/coreclr/vm/arm64/asmhelpers.asm
index 304a6592a6de31..ffbeb9fd1acb35 100644
--- a/src/coreclr/vm/arm64/asmhelpers.asm
+++ b/src/coreclr/vm/arm64/asmhelpers.asm
@@ -289,7 +289,7 @@ ThePreStubPatchLabel
     LEAF_END
 
 ;-----------------------------------------------------------------------------
-; void JIT_UpdateWriteBarrierState(bool skipEphemeralCheck)
+; void JIT_UpdateWriteBarrierState(bool skipEphemeralCheck, size_t writeableOffset)
 ;
 ; Update shadow copies of the various state info required for barrier
 ;
diff --git a/src/coreclr/vm/arm64/cgencpu.h b/src/coreclr/vm/arm64/cgencpu.h
index c87dbb11601f84..83e56cfb9f9b96 100644
--- a/src/coreclr/vm/arm64/cgencpu.h
+++ b/src/coreclr/vm/arm64/cgencpu.h
@@ -274,7 +274,7 @@ inline NEON128 GetSimdMem(PCODE ip)
 }
 
 #ifdef FEATURE_COMINTEROP
-void emitCOMStubCall (ComCallMethodDesc *pCOMMethod, PCODE target);
+void emitCOMStubCall (ComCallMethodDesc *pCOMMethodRX, ComCallMethodDesc *pCOMMethodRW, PCODE target);
 #endif // FEATURE_COMINTEROP
 
 inline BOOL ClrFlushInstructionCache(LPCVOID pCodeAddr, size_t sizeOfCode)
@@ -288,10 +288,10 @@ inline BOOL ClrFlushInstructionCache(LPCVOID pCodeAddr, size_t sizeOfCode)
 }
 
 //------------------------------------------------------------------------
-inline void emitJump(LPBYTE pBuffer, LPVOID target)
+inline void emitJump(LPBYTE pBufferRX, LPBYTE pBufferRW, LPVOID target)
 {
     LIMITED_METHOD_CONTRACT;
-    UINT32* pCode = (UINT32*)pBuffer;
+    UINT32* pCode = (UINT32*)pBufferRW;
 
     // We require 8-byte alignment so the LDR instruction is aligned properly
     _ASSERTE(((UINT_PTR)pCode & 7) == 0);
@@ -304,7 +304,7 @@ inline void emitJump(LPBYTE pBuffer, LPVOID target)
     pCode[1] = 0xD61F0200UL;   // br  x16
 
     // Ensure that the updated instructions get updated in the I-Cache
-    ClrFlushInstructionCache(pCode, 8);
+    ClrFlushInstructionCache(pBufferRX, 8);
 
     *((LPVOID *)(pCode + 2)) = target;   // 64-bit target address
 
@@ -341,10 +341,10 @@ inline BOOL isBackToBackJump(PCODE pBuffer)
 }
 
 //------------------------------------------------------------------------
-inline void emitBackToBackJump(LPBYTE pBuffer, LPVOID target)
+inline void emitBackToBackJump(LPBYTE pBufferRX, LPBYTE pBufferRW, LPVOID target)
 {
     WRAPPER_NO_CONTRACT;
-    emitJump(pBuffer, target);
+    emitJump(pBufferRX, pBufferRW, target);
 }
 
 //------------------------------------------------------------------------
@@ -433,7 +433,7 @@ class StubLinkerCPU : public StubLinker
 
 private:
     void EmitLoadStoreRegPairImm(DWORD flags, int regNum1, int regNum2, IntReg Xn, int offset, BOOL isVec);
-    void EmitLoadStoreRegImm(DWORD flags, int regNum, IntReg Xn, int offset, BOOL isVec);
+    void EmitLoadStoreRegImm(DWORD flags, int regNum, IntReg Xn, int offset, BOOL isVec, int log2Size = 3);
 public:
 
     // BitFlags for EmitLoadStoreReg(Pair)Imm methods
@@ -484,7 +484,7 @@ class StubLinkerCPU : public StubLinker
     void EmitLoadStoreRegPairImm(DWORD flags, IntReg Xt1, IntReg Xt2, IntReg Xn, int offset=0);
     void EmitLoadStoreRegPairImm(DWORD flags, VecReg Vt1, VecReg Vt2, IntReg Xn, int offset=0);
 
-    void EmitLoadStoreRegImm(DWORD flags, IntReg Xt, IntReg Xn, int offset=0);
+    void EmitLoadStoreRegImm(DWORD flags, IntReg Xt, IntReg Xn, int offset=0, int log2Size = 3);
     void EmitLoadStoreRegImm(DWORD flags, VecReg Vt, IntReg Xn, int offset=0);
 
     void EmitLoadRegReg(IntReg Xt, IntReg Xn, IntReg Xm, DWORD option);
@@ -515,7 +515,7 @@ struct DECLSPEC_ALIGN(16) UMEntryThunkCode
     TADDR       m_pTargetCode;
     TADDR       m_pvSecretParam;
 
-    void Encode(BYTE* pTargetCode, void* pvSecretParam);
+    void Encode(UMEntryThunkCode *pEntryThunkCodeRX, BYTE* pTargetCode, void* pvSecretParam);
     void Poison();
 
     LPCBYTE GetEntryPoint() const
@@ -583,7 +583,7 @@ struct StubPrecode {
     TADDR   m_pTarget;
     TADDR   m_pMethodDesc;
 
-    void Init(MethodDesc* pMD, LoaderAllocator *pLoaderAllocator);
+    void Init(StubPrecode* pPrecodeRX, MethodDesc* pMD, LoaderAllocator *pLoaderAllocator);
 
     TADDR GetMethodDesc()
     {
@@ -606,7 +606,8 @@ struct StubPrecode {
         }
         CONTRACTL_END;
 
-        InterlockedExchange64((LONGLONG*)&m_pTarget, (TADDR)GetPreStubEntryPoint());
+        ExecutableWriterHolder<StubPrecode> precodeWriterHolder(this, sizeof(StubPrecode)); 
+        InterlockedExchange64((LONGLONG*)&precodeWriterHolder.GetRW()->m_pTarget, (TADDR)GetPreStubEntryPoint());
     }
 
     BOOL SetTargetInterlocked(TADDR target, TADDR expected)
@@ -618,8 +619,9 @@ struct StubPrecode {
         }
         CONTRACTL_END;
 
+        ExecutableWriterHolder<StubPrecode> precodeWriterHolder(this, sizeof(StubPrecode)); 
         return (TADDR)InterlockedCompareExchange64(
-            (LONGLONG*)&m_pTarget, (TADDR)target, (TADDR)expected) == expected;
+            (LONGLONG*)&precodeWriterHolder.GetRW()->m_pTarget, (TADDR)target, (TADDR)expected) == expected;
     }
 
 #ifdef FEATURE_PREJIT
@@ -643,7 +645,7 @@ struct NDirectImportPrecode {
     TADDR   m_pTarget;
     TADDR   m_pMethodDesc;
 
-    void Init(MethodDesc* pMD, LoaderAllocator *pLoaderAllocator);
+    void Init(NDirectImportPrecode* pPrecodeRX, MethodDesc* pMD, LoaderAllocator *pLoaderAllocator);
 
     TADDR GetMethodDesc()
     {
@@ -689,7 +691,7 @@ struct FixupPrecode {
     BYTE    m_PrecodeChunkIndex;
     TADDR   m_pTarget;
 
-    void Init(MethodDesc* pMD, LoaderAllocator *pLoaderAllocator, int iMethodDescChunkIndex = 0, int iPrecodeChunkIndex = 0);
+    void Init(FixupPrecode* pPrecodeRX, MethodDesc* pMD, LoaderAllocator *pLoaderAllocator, int iMethodDescChunkIndex = 0, int iPrecodeChunkIndex = 0);
     void InitCommon()
     {
         WRAPPER_NO_CONTRACT;
@@ -730,7 +732,8 @@ struct FixupPrecode {
         }
         CONTRACTL_END;
 
-        InterlockedExchange64((LONGLONG*)&m_pTarget, (TADDR)GetEEFuncEntryPoint(PrecodeFixupThunk));
+        ExecutableWriterHolder<FixupPrecode> precodeWriterHolder(this, sizeof(FixupPrecode));
+        InterlockedExchange64((LONGLONG*)&precodeWriterHolder.GetRW()->m_pTarget, (TADDR)GetEEFuncEntryPoint(PrecodeFixupThunk));
     }
 
     BOOL SetTargetInterlocked(TADDR target, TADDR expected)
@@ -742,8 +745,9 @@ struct FixupPrecode {
         }
         CONTRACTL_END;
 
+        ExecutableWriterHolder<FixupPrecode> precodeWriterHolder(this, sizeof(FixupPrecode));
         return (TADDR)InterlockedCompareExchange64(
-            (LONGLONG*)&m_pTarget, (TADDR)target, (TADDR)expected) == expected;
+            (LONGLONG*)&precodeWriterHolder.GetRW()->m_pTarget, (TADDR)target, (TADDR)expected) == expected;
     }
 
     static BOOL IsFixupPrecodeByASM(PCODE addr)
@@ -802,8 +806,9 @@ struct ThisPtrRetBufPrecode {
         }
         CONTRACTL_END;
 
+        ExecutableWriterHolder<ThisPtrRetBufPrecode> precodeWriterHolder(this, sizeof(ThisPtrRetBufPrecode)); 
         return (TADDR)InterlockedCompareExchange64(
-            (LONGLONG*)&m_pTarget, (TADDR)target, (TADDR)expected) == expected;
+            (LONGLONG*)&precodeWriterHolder.GetRW()->m_pTarget, (TADDR)target, (TADDR)expected) == expected;
     }
 };
 typedef DPTR(ThisPtrRetBufPrecode) PTR_ThisPtrRetBufPrecode;
@@ -871,7 +876,7 @@ class CallCountingStubShort : public CallCountingStub
 
 #ifndef DACCESS_COMPILE
 public:
-    CallCountingStubShort(CallCount *remainingCallCountCell, PCODE targetForMethod)
+    CallCountingStubShort(CallCountingStubShort* stubRX, CallCount *remainingCallCountCell, PCODE targetForMethod)
         : m_part0{  0x58000149,             //     ldr  x9, [pc, #(m_remainingCallCountCell)]
                     0x7940012a,             //     ldrh w10, [x9]
                     0x7100054a,             //     subs w10, w10, #1
diff --git a/src/coreclr/vm/arm64/stubs.cpp b/src/coreclr/vm/arm64/stubs.cpp
index bfff364d57e6c6..54cf1c49275487 100644
--- a/src/coreclr/vm/arm64/stubs.cpp
+++ b/src/coreclr/vm/arm64/stubs.cpp
@@ -58,7 +58,7 @@ class ConditionalBranchInstructionFormat : public InstructionFormat
         // Encoding 0|1|0|1|0|1|0|0|imm19|0|cond
         // cond = Bits3-0(variation)
         // imm19 = bits19-0(fixedUpReference/4), will be SignExtended
-        virtual VOID EmitInstruction(UINT refSize, __int64 fixedUpReference, BYTE *pOutBuffer, UINT variationCode, BYTE *pDataBuffer)
+        virtual VOID EmitInstruction(UINT refSize, __int64 fixedUpReference, BYTE *pOutBufferRX, BYTE *pOutBufferRW, UINT variationCode, BYTE *pDataBuffer)
         {
             LIMITED_METHOD_CONTRACT;
 
@@ -70,10 +70,10 @@ class ConditionalBranchInstructionFormat : public InstructionFormat
             _ASSERTE((fixedUpReference & 0x3) == 0);
             DWORD imm19 = (DWORD)(0x7FFFF & (fixedUpReference >> 2));
 
-            pOutBuffer[0] = static_cast<BYTE>((0x7 & imm19 /* Bits2-0(imm19) */) << 5  | (0xF & variationCode /* cond */));
-            pOutBuffer[1] = static_cast<BYTE>((0x7F8 & imm19 /* Bits10-3(imm19) */) >> 3);
-            pOutBuffer[2] = static_cast<BYTE>((0x7F800 & imm19 /* Bits19-11(imm19) */) >> 11);
-            pOutBuffer[3] = static_cast<BYTE>(0x54);
+            pOutBufferRW[0] = static_cast<BYTE>((0x7 & imm19 /* Bits2-0(imm19) */) << 5  | (0xF & variationCode /* cond */));
+            pOutBufferRW[1] = static_cast<BYTE>((0x7F8 & imm19 /* Bits10-3(imm19) */) >> 3);
+            pOutBufferRW[2] = static_cast<BYTE>((0x7F800 & imm19 /* Bits19-11(imm19) */) >> 11);
+            pOutBufferRW[3] = static_cast<BYTE>(0x54);
         }
 };
 
@@ -148,14 +148,14 @@ class BranchInstructionFormat : public InstructionFormat
             }
         }
 
-        virtual VOID EmitInstruction(UINT refSize, __int64 fixedUpReference, BYTE *pOutBuffer, UINT variationCode, BYTE *pDataBuffer)
+        virtual VOID EmitInstruction(UINT refSize, __int64 fixedUpReference, BYTE *pOutBufferRX, BYTE *pOutBufferRW, UINT variationCode, BYTE *pDataBuffer)
         {
             LIMITED_METHOD_CONTRACT;
 
             if (IsIndirect(variationCode))
             {
                 _ASSERTE(((UINT_PTR)pDataBuffer & 7) == 0);
-                __int64 dataOffset = pDataBuffer - pOutBuffer;
+                __int64 dataOffset = pDataBuffer - pOutBufferRW;
 
                 if (dataOffset < -1048576 || dataOffset > 1048572)
                     COMPlusThrow(kNotSupportedException);
@@ -165,25 +165,25 @@ class BranchInstructionFormat : public InstructionFormat
                 // +0: ldr x16, [pc, #dataOffset]
                 // +4: ldr x16, [x16]
                 // +8: b(l)r x16
-                *((DWORD*)pOutBuffer) = (0x58000010 | (imm19 << 5));
-                *((DWORD*)(pOutBuffer+4)) = 0xF9400210;
+                *((DWORD*)pOutBufferRW) = (0x58000010 | (imm19 << 5));
+                *((DWORD*)(pOutBufferRW+4)) = 0xF9400210;
                 if (IsCall(variationCode))
                 {
-                    *((DWORD*)(pOutBuffer+8)) = 0xD63F0200; // blr x16
+                    *((DWORD*)(pOutBufferRW+8)) = 0xD63F0200; // blr x16
                 }
                 else
                 {
-                    *((DWORD*)(pOutBuffer+8)) = 0xD61F0200; // br x16
+                    *((DWORD*)(pOutBufferRW+8)) = 0xD61F0200; // br x16
                 }
 
 
-                *((__int64*)pDataBuffer) = fixedUpReference + (__int64)pOutBuffer;
+                *((__int64*)pDataBuffer) = fixedUpReference + (__int64)pOutBufferRX;
             }
             else
             {
 
                 _ASSERTE(((UINT_PTR)pDataBuffer & 7) == 0);
-                __int64 dataOffset = pDataBuffer - pOutBuffer;
+                __int64 dataOffset = pDataBuffer - pOutBufferRW;
 
                 if (dataOffset < -1048576 || dataOffset > 1048572)
                     COMPlusThrow(kNotSupportedException);
@@ -192,17 +192,17 @@ class BranchInstructionFormat : public InstructionFormat
 
                 // +0: ldr x16, [pc, #dataOffset]
                 // +4: b(l)r x16
-                *((DWORD*)pOutBuffer) = (0x58000010 | (imm19 << 5));
+                *((DWORD*)pOutBufferRW) = (0x58000010 | (imm19 << 5));
                 if (IsCall(variationCode))
                 {
-                    *((DWORD*)(pOutBuffer+4)) = 0xD63F0200; // blr x16
+                    *((DWORD*)(pOutBufferRW+4)) = 0xD63F0200; // blr x16
                 }
                 else
                 {
-                    *((DWORD*)(pOutBuffer+4)) = 0xD61F0200; // br x16
+                    *((DWORD*)(pOutBufferRW+4)) = 0xD61F0200; // br x16
                 }
 
-                if (!ClrSafeInt<__int64>::addition(fixedUpReference, (__int64)pOutBuffer, fixedUpReference))
+                if (!ClrSafeInt<__int64>::addition(fixedUpReference, (__int64)pOutBufferRX, fixedUpReference))
                     COMPlusThrowArithmetic();
                 *((__int64*)pDataBuffer) = fixedUpReference;
             }
@@ -239,7 +239,7 @@ class LoadFromLabelInstructionFormat : public InstructionFormat
             return fExternal;
         }
 
-        virtual VOID EmitInstruction(UINT refSize, __int64 fixedUpReference, BYTE *pOutBuffer, UINT variationCode, BYTE *pDataBuffer)
+        virtual VOID EmitInstruction(UINT refSize, __int64 fixedUpReference, BYTE *pOutBufferRX, BYTE *pOutBufferRW, UINT variationCode, BYTE *pDataBuffer)
         {
             LIMITED_METHOD_CONTRACT;
             // VariationCode is used to indicate the register the label is going to be loaded
@@ -252,11 +252,11 @@ class LoadFromLabelInstructionFormat : public InstructionFormat
             _ASSERTE((variationCode & 0x1F) != 31);
 
             // adrp Xt, #Page_of_fixedUpReference
-            *((DWORD*)pOutBuffer) = ((9<<28) | ((imm & 3)<<29) | (imm>>2)<<5 | (variationCode&0x1F));
+            *((DWORD*)pOutBufferRW) = ((9<<28) | ((imm & 3)<<29) | (imm>>2)<<5 | (variationCode&0x1F));
 
             // ldr Xt, [Xt, #offset_of_fixedUpReference_to_its_page]
-            UINT64 target = (UINT64)(fixedUpReference + pOutBuffer)>>3;
-            *((DWORD*)(pOutBuffer+4)) = ( 0xF9400000 | ((target & 0x1FF)<<10) | (variationCode & 0x1F)<<5 | (variationCode & 0x1F));
+            UINT64 target = (UINT64)(fixedUpReference + pOutBufferRX)>>3;
+            *((DWORD*)(pOutBufferRW+4)) = ( 0xF9400000 | ((target & 0x1FF)<<10) | (variationCode & 0x1F)<<5 | (variationCode & 0x1F));
         }
 };
 
@@ -567,14 +567,10 @@ void FixupPrecode::EnumMemoryRegions(CLRDataEnumMemoryFlags flags)
 #endif // DACCESS_COMPILE
 
 #ifndef DACCESS_COMPILE
-void StubPrecode::Init(MethodDesc* pMD, LoaderAllocator *pLoaderAllocator)
+void StubPrecode::Init(StubPrecode* pPrecodeRX, MethodDesc* pMD, LoaderAllocator *pLoaderAllocator)
 {
     WRAPPER_NO_CONTRACT;
 
-#if defined(HOST_OSX) && defined(HOST_ARM64)
-    auto jitWriteEnableHolder = PAL_JITWriteEnable(true);
-#endif // defined(HOST_OSX) && defined(HOST_ARM64)
-
     int n = 0;
 
     m_rgCode[n++] = 0x10000089; // adr x9, #16
@@ -604,14 +600,10 @@ void StubPrecode::Fixup(DataImage *image)
 }
 #endif // FEATURE_NATIVE_IMAGE_GENERATION
 
-void NDirectImportPrecode::Init(MethodDesc* pMD, LoaderAllocator *pLoaderAllocator)
+void NDirectImportPrecode::Init(NDirectImportPrecode* pPrecodeRX, MethodDesc* pMD, LoaderAllocator *pLoaderAllocator)
 {
     WRAPPER_NO_CONTRACT;
 
-#if defined(HOST_OSX) && defined(HOST_ARM64)
-    auto jitWriteEnableHolder = PAL_JITWriteEnable(true);
-#endif // defined(HOST_OSX) && defined(HOST_ARM64)
-
     int n = 0;
 
     m_rgCode[n++] = 0x1000008B; // adr x11, #16
@@ -641,14 +633,10 @@ void NDirectImportPrecode::Fixup(DataImage *image)
 }
 #endif
 
-void FixupPrecode::Init(MethodDesc* pMD, LoaderAllocator *pLoaderAllocator, int iMethodDescChunkIndex /*=0*/, int iPrecodeChunkIndex /*=0*/)
+void FixupPrecode::Init(FixupPrecode* pPrecodeRX, MethodDesc* pMD, LoaderAllocator *pLoaderAllocator, int iMethodDescChunkIndex /*=0*/, int iPrecodeChunkIndex /*=0*/)
 {
     WRAPPER_NO_CONTRACT;
 
-#if defined(HOST_OSX) && defined(HOST_ARM64)
-    auto jitWriteEnableHolder = PAL_JITWriteEnable(true);
-#endif // defined(HOST_OSX) && defined(HOST_ARM64)
-
     InitCommon();
 
     // Initialize chunk indices only if they are not initialized yet. This is necessary to make MethodDesc::Reset work.
@@ -670,7 +658,7 @@ void FixupPrecode::Init(MethodDesc* pMD, LoaderAllocator *pLoaderAllocator, int
             *(void**)GetBase() = (BYTE*)pMD - (iMethodDescChunkIndex * MethodDesc::ALIGNMENT);
     }
 
-    _ASSERTE(GetMethodDesc() == (TADDR)pMD);
+    _ASSERTE(pPrecodeRX->GetMethodDesc() == (TADDR)pMD);
 
     if (pLoaderAllocator != NULL)
     {
@@ -1034,7 +1022,7 @@ void HijackFrame::UpdateRegDisplay(const PREGDISPLAY pRD)
 
 #ifdef FEATURE_COMINTEROP
 
-void emitCOMStubCall (ComCallMethodDesc *pCOMMethod, PCODE target)
+void emitCOMStubCall (ComCallMethodDesc *pCOMMethodRX, ComCallMethodDesc *pCOMMethodRW, PCODE target)
 {
     WRAPPER_NO_CONTRACT;
 
@@ -1051,16 +1039,17 @@ void emitCOMStubCall (ComCallMethodDesc *pCOMMethod, PCODE target)
         0xd61f0140
     };
 
-    BYTE *pBuffer = (BYTE*)pCOMMethod - COMMETHOD_CALL_PRESTUB_SIZE;
+    BYTE *pBufferRX = (BYTE*)pCOMMethodRX - COMMETHOD_CALL_PRESTUB_SIZE;
+    BYTE *pBufferRW = (BYTE*)pCOMMethodRW - COMMETHOD_CALL_PRESTUB_SIZE;
 
-    memcpy(pBuffer, rgCode, sizeof(rgCode));
-    *((PCODE*)(pBuffer + sizeof(rgCode) + 4)) = target;
+    memcpy(pBufferRW, rgCode, sizeof(rgCode));
+    *((PCODE*)(pBufferRW + sizeof(rgCode) + 4)) = target;
 
     // Ensure that the updated instructions get actually written
-    ClrFlushInstructionCache(pBuffer, COMMETHOD_CALL_PRESTUB_SIZE);
+    ClrFlushInstructionCache(pBufferRX, COMMETHOD_CALL_PRESTUB_SIZE);
 
-    _ASSERTE(IS_ALIGNED(pBuffer + COMMETHOD_CALL_PRESTUB_ADDRESS_OFFSET, sizeof(void*)) &&
-             *((PCODE*)(pBuffer + COMMETHOD_CALL_PRESTUB_ADDRESS_OFFSET)) == target);
+    _ASSERTE(IS_ALIGNED(pBufferRX + COMMETHOD_CALL_PRESTUB_ADDRESS_OFFSET, sizeof(void*)) &&
+             *((PCODE*)(pBufferRX + COMMETHOD_CALL_PRESTUB_ADDRESS_OFFSET)) == target);
 }
 #endif // FEATURE_COMINTEROP
 
@@ -1070,15 +1059,16 @@ void JIT_TailCall()
 }
 
 #if !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
-EXTERN_C void JIT_UpdateWriteBarrierState(bool skipEphemeralCheck);
+EXTERN_C void JIT_UpdateWriteBarrierState(bool skipEphemeralCheck, size_t writeableOffset);
+
+extern "C" void STDCALL JIT_PatchedCodeStart();
+extern "C" void STDCALL JIT_PatchedCodeLast();
 
 static void UpdateWriteBarrierState(bool skipEphemeralCheck)
 {
-#if defined(HOST_OSX) && defined(HOST_ARM64)
-    auto jitWriteEnableHolder = PAL_JITWriteEnable(true);
-#endif // defined(HOST_OSX) && defined(HOST_ARM64)
-
-    JIT_UpdateWriteBarrierState(GCHeapUtilities::IsServerHeap());
+    BYTE *writeBarrierCodeStart = GetWriteBarrierCodeLocation((void*)JIT_PatchedCodeStart);
+    ExecutableWriterHolder<BYTE> writeBarrierWriterHolder(writeBarrierCodeStart, (BYTE*)JIT_PatchedCodeLast - (BYTE*)JIT_PatchedCodeStart);
+    JIT_UpdateWriteBarrierState(GCHeapUtilities::IsServerHeap(), writeBarrierWriterHolder.GetRW() - writeBarrierCodeStart);
 }
 
 void InitJITHelpers1()
@@ -1198,7 +1188,7 @@ AdjustContextForVirtualStub(
     {
         pExceptionRecord->ExceptionAddress = (PVOID)callsite;
     }
-	
+
     SetIP(pContext, callsite);
 
     return TRUE;
@@ -1224,11 +1214,8 @@ UMEntryThunk * UMEntryThunk::Decode(void *pCallback)
     return NULL;
 }
 
-void UMEntryThunkCode::Encode(BYTE* pTargetCode, void* pvSecretParam)
+void UMEntryThunkCode::Encode(UMEntryThunkCode *pEntryThunkCodeRX, BYTE* pTargetCode, void* pvSecretParam)
 {
-#if defined(HOST_OSX) && defined(HOST_ARM64)
-    auto jitWriteEnableHolder = PAL_JITWriteEnable(true);
-#endif // defined(HOST_OSX) && defined(HOST_ARM64)
     // adr x12, _label
     // ldp x16, x12, [x12]
     // br x16
@@ -1244,21 +1231,21 @@ void UMEntryThunkCode::Encode(BYTE* pTargetCode, void* pvSecretParam)
 
     m_pTargetCode = (TADDR)pTargetCode;
     m_pvSecretParam = (TADDR)pvSecretParam;
-    FlushInstructionCache(GetCurrentProcess(),&m_code,sizeof(m_code));
+    FlushInstructionCache(GetCurrentProcess(),&pEntryThunkCodeRX->m_code,sizeof(m_code));
 }
 
 #ifndef DACCESS_COMPILE
 
 void UMEntryThunkCode::Poison()
 {
-#if defined(HOST_OSX) && defined(HOST_ARM64)
-    auto jitWriteEnableHolder = PAL_JITWriteEnable(true);
-#endif // defined(HOST_OSX) && defined(HOST_ARM64)
+    ExecutableWriterHolder<UMEntryThunkCode> thunkWriterHolder(this, sizeof(UMEntryThunkCode));
+    UMEntryThunkCode *pThisRW = thunkWriterHolder.GetRW();
 
-    m_pTargetCode = (TADDR)UMEntryThunk::ReportViolation;
+    pThisRW->m_pTargetCode = (TADDR)UMEntryThunk::ReportViolation;
 
     // ldp x16, x0, [x12]
-    m_code[1] = 0xa9400190;
+    pThisRW->m_code[1] = 0xa9400190;
+
     ClrFlushInstructionCache(&m_code,sizeof(m_code));
 }
 
@@ -1567,29 +1554,32 @@ void StubLinkerCPU::EmitLoadStoreRegPairImm(DWORD flags, int regNum1, int regNum
 }
 
 
-void StubLinkerCPU::EmitLoadStoreRegImm(DWORD flags, IntReg Xt, IntReg Xn, int offset)
+void StubLinkerCPU::EmitLoadStoreRegImm(DWORD flags, IntReg Xt, IntReg Xn, int offset, int log2Size)
 {
-    EmitLoadStoreRegImm(flags, (int)Xt, Xn, offset, FALSE);
+    EmitLoadStoreRegImm(flags, (int)Xt, Xn, offset, FALSE, log2Size);
 }
 void StubLinkerCPU::EmitLoadStoreRegImm(DWORD flags, VecReg Vt, IntReg Xn, int offset)
 {
     EmitLoadStoreRegImm(flags, (int)Vt, Xn, offset, TRUE);
 }
 
-void StubLinkerCPU::EmitLoadStoreRegImm(DWORD flags, int regNum, IntReg Xn, int offset, BOOL isVec)
+void StubLinkerCPU::EmitLoadStoreRegImm(DWORD flags, int regNum, IntReg Xn, int offset, BOOL isVec, int log2Size)
 {
     // Encoding:
     // wb=1 : [size(2)=11] | 1 | 1 | 1 | [IsVec(1)] | 0 | [!writeBack(1)] | 0 | [isLoad(1)] | 0 | [imm(7)] | [!postIndex(1)] | [Xn(5)] | [Xt(5)]
     // wb=0 : [size(2)=11] | 1 | 1 | 1 | [IsVec(1)] | 0 | [!writeBack(1)] | 0 | [isLoad(1)] | [          imm(12)           ] | [Xn(5)] | [Xt(5)]
     // where IsVec=0 for IntReg, 1 for VecReg
 
+    _ASSERTE((log2Size & ~0x3ULL) == 0);
+
     BOOL isLoad    = flags & 1;
     BOOL writeBack = flags & 2;
     BOOL postIndex = flags & 4;
     if (writeBack)
     {
         _ASSERTE(-256 <= offset && offset <= 255);
-        Emit32((DWORD) ( (0x1F<<27) |
+        Emit32((DWORD) ( (log2Size << 30) |
+                         (0x7<<27) |
                          (!!isVec<<26) |
                          (!writeBack<<24) |
                          (!!isLoad<<22) |
@@ -1602,13 +1592,16 @@ void StubLinkerCPU::EmitLoadStoreRegImm(DWORD flags, int regNum, IntReg Xn, int
     }
     else
     {
-        _ASSERTE((0 <= offset) && (offset <= 32760));
-        _ASSERTE((offset & 7) == 0);
-        Emit32((DWORD) ( (0x1F<<27) |
+        int scaledOffset = 0xFFF & (offset >> log2Size);
+
+        _ASSERTE(offset == (scaledOffset << log2Size));
+
+        Emit32((DWORD) ( (log2Size << 30) |
+                         (0x7<<27) |
                          (!!isVec<<26) |
                          (!writeBack<<24) |
                          (!!isLoad<<22) |
-                         ((0xFFF & (offset >> 3)) << 10) |
+                         (scaledOffset << 10) |
                          (Xn<<5) |
                          (regNum))
               );
@@ -1715,15 +1708,25 @@ VOID StubLinkerCPU::EmitShuffleThunk(ShuffleEntry *pShuffleEntryArray)
         {
             // If source is present in register then destination must also be a register
             _ASSERTE(pEntry->dstofs & ShuffleEntry::REGMASK);
+            _ASSERTE(!(pEntry->dstofs & ShuffleEntry::FPREGMASK));
+            _ASSERTE(!(pEntry->srcofs & ShuffleEntry::FPREGMASK));
 
-            EmitMovReg(IntReg(pEntry->dstofs & ShuffleEntry::OFSMASK), IntReg(pEntry->srcofs & ShuffleEntry::OFSMASK));
+            EmitMovReg(IntReg(pEntry->dstofs & ShuffleEntry::OFSREGMASK), IntReg(pEntry->srcofs & ShuffleEntry::OFSREGMASK));
         }
         else if (pEntry->dstofs & ShuffleEntry::REGMASK)
         {
             // source must be on the stack
             _ASSERTE(!(pEntry->srcofs & ShuffleEntry::REGMASK));
+            _ASSERTE(!(pEntry->dstofs & ShuffleEntry::FPREGMASK));
+
 
-            EmitLoadStoreRegImm(eLOAD, IntReg(pEntry->dstofs & ShuffleEntry::OFSMASK), RegSp, pEntry->srcofs * sizeof(void*));
+#if !defined(TARGET_OSX)
+            EmitLoadStoreRegImm(eLOAD, IntReg(pEntry->dstofs & ShuffleEntry::OFSREGMASK), RegSp, pEntry->srcofs * sizeof(void*));
+#else
+            int log2Size = (pEntry->srcofs >> 12);
+            int srcOffset = int(pEntry->srcofs & 0xfff) << log2Size;
+            EmitLoadStoreRegImm(eLOAD, IntReg(pEntry->dstofs & ShuffleEntry::OFSREGMASK), RegSp, srcOffset, log2Size);
+#endif
         }
         else
         {
@@ -1733,8 +1736,22 @@ VOID StubLinkerCPU::EmitShuffleThunk(ShuffleEntry *pShuffleEntryArray)
             // dest must be on the stack
             _ASSERTE(!(pEntry->dstofs & ShuffleEntry::REGMASK));
 
+#if !defined(TARGET_OSX)
             EmitLoadStoreRegImm(eLOAD, IntReg(9), RegSp, pEntry->srcofs * sizeof(void*));
             EmitLoadStoreRegImm(eSTORE, IntReg(9), RegSp, pEntry->dstofs * sizeof(void*));
+#else
+            // Decode ShuffleIterator::GetNextOfs() encoded entries
+            // See comments in that function
+
+            // We expect src and dst stack size to be the same.
+            _ASSERTE((pEntry->srcofs >> 12) == (pEntry->dstofs >> 12));
+            int log2Size = (pEntry->srcofs >> 12);
+            int srcOffset = int(pEntry->srcofs & 0xfff) << log2Size;
+            int dstOffset = int(pEntry->dstofs & 0xfff) << log2Size;
+
+            EmitLoadStoreRegImm(eLOAD, IntReg(9), RegSp, srcOffset, log2Size);
+            EmitLoadStoreRegImm(eSTORE, IntReg(9), RegSp, dstOffset, log2Size);
+#endif
         }
     }
 
@@ -1757,7 +1774,7 @@ VOID StubLinkerCPU::EmitComputedInstantiatingMethodStub(MethodDesc* pSharedMD, s
         _ASSERTE(pEntry->dstofs != ShuffleEntry::HELPERREG);
         _ASSERTE(pEntry->srcofs != ShuffleEntry::HELPERREG);
 
-        EmitMovReg(IntReg(pEntry->dstofs & ShuffleEntry::OFSMASK), IntReg(pEntry->srcofs & ShuffleEntry::OFSMASK));
+        EmitMovReg(IntReg(pEntry->dstofs & ShuffleEntry::OFSREGMASK), IntReg(pEntry->srcofs & ShuffleEntry::OFSREGMASK));
     }
 
     MetaSig msig(pSharedMD);
@@ -1833,32 +1850,20 @@ void StubLinkerCPU::EmitCallManagedMethod(MethodDesc *pMD, BOOL fTailCall)
 
 #define DYNAMIC_HELPER_ALIGNMENT sizeof(TADDR)
 
-#if defined(HOST_OSX) && defined(HOST_ARM64)
-#define BEGIN_DYNAMIC_HELPER_EMIT(size) \
-    SIZE_T cb = size; \
-    SIZE_T cbAligned = ALIGN_UP(cb, DYNAMIC_HELPER_ALIGNMENT); \
-    BYTE * pStart = (BYTE *)(void *)pAllocator->GetDynamicHelpersHeap()->AllocAlignedMem(cbAligned, DYNAMIC_HELPER_ALIGNMENT); \
-    BYTE * p = pStart; \
-    auto jitWriteEnableHolder = PAL_JITWriteEnable(true);
-
-#define END_DYNAMIC_HELPER_EMIT() \
-    _ASSERTE(pStart + cb == p); \
-    while (p < pStart + cbAligned) { *(DWORD*)p = 0xBADC0DF0; p += 4; }\
-    ClrFlushInstructionCache(pStart, cbAligned); \
-    return (PCODE)pStart
-#else // defined(HOST_OSX) && defined(HOST_ARM64)
 #define BEGIN_DYNAMIC_HELPER_EMIT(size) \
     SIZE_T cb = size; \
     SIZE_T cbAligned = ALIGN_UP(cb, DYNAMIC_HELPER_ALIGNMENT); \
-    BYTE * pStart = (BYTE *)(void *)pAllocator->GetDynamicHelpersHeap()->AllocAlignedMem(cbAligned, DYNAMIC_HELPER_ALIGNMENT); \
+    BYTE * pStartRX = (BYTE *)(void*)pAllocator->GetDynamicHelpersHeap()->AllocAlignedMem(cbAligned, DYNAMIC_HELPER_ALIGNMENT); \
+    ExecutableWriterHolder<BYTE> startWriterHolder(pStartRX, cbAligned); \
+    BYTE * pStart = startWriterHolder.GetRW(); \
+    size_t rxOffset = pStartRX - pStart; \
     BYTE * p = pStart;
 
 #define END_DYNAMIC_HELPER_EMIT() \
     _ASSERTE(pStart + cb == p); \
     while (p < pStart + cbAligned) { *(DWORD*)p = 0xBADC0DF0; p += 4; }\
-    ClrFlushInstructionCache(pStart, cbAligned); \
-    return (PCODE)pStart
-#endif // defined(HOST_OSX) && defined(HOST_ARM64)
+    ClrFlushInstructionCache(pStartRX, cbAligned); \
+    return (PCODE)pStartRX
 
 // Uses x8 as scratch register to store address of data label
 // After load x8 is increment to point to next data
@@ -1902,7 +1907,7 @@ PCODE DynamicHelpers::CreateHelper(LoaderAllocator * pAllocator, TADDR arg, PCOD
 }
 
 // Caller must ensure sufficient byte are allocated including padding (if applicable)
-void DynamicHelpers::EmitHelperWithArg(BYTE*& p, LoaderAllocator * pAllocator, TADDR arg, PCODE target)
+void DynamicHelpers::EmitHelperWithArg(BYTE*& p, size_t rxOffset, LoaderAllocator * pAllocator, TADDR arg, PCODE target)
 {
     STANDARD_VM_CONTRACT;
 
@@ -1940,7 +1945,7 @@ PCODE DynamicHelpers::CreateHelperWithArg(LoaderAllocator * pAllocator, TADDR ar
 
     BEGIN_DYNAMIC_HELPER_EMIT(32);
 
-    EmitHelperWithArg(p, pAllocator, arg, target);
+    EmitHelperWithArg(p, rxOffset, pAllocator, arg, target);
 
     END_DYNAMIC_HELPER_EMIT();
 }
@@ -2142,9 +2147,10 @@ PCODE DynamicHelpers::CreateDictionaryLookupHelper(LoaderAllocator * pAllocator,
         GetEEFuncEntryPoint(JIT_GenericHandleClassWithSlotAndModule));
 
     GenericHandleArgs * pArgs = (GenericHandleArgs *)(void *)pAllocator->GetDynamicHelpersHeap()->AllocAlignedMem(sizeof(GenericHandleArgs), DYNAMIC_HELPER_ALIGNMENT);
-    pArgs->dictionaryIndexAndSlot = dictionaryIndexAndSlot;
-    pArgs->signature = pLookup->signature;
-    pArgs->module = (CORINFO_MODULE_HANDLE)pModule;
+    ExecutableWriterHolder<GenericHandleArgs> argsWriterHolder(pArgs, sizeof(GenericHandleArgs));
+    argsWriterHolder.GetRW()->dictionaryIndexAndSlot = dictionaryIndexAndSlot;
+    argsWriterHolder.GetRW()->signature = pLookup->signature;
+    argsWriterHolder.GetRW()->module = (CORINFO_MODULE_HANDLE)pModule;
 
     WORD slotOffset = (WORD)(dictionaryIndexAndSlot & 0xFFFF) * sizeof(Dictionary*);
 
@@ -2157,7 +2163,7 @@ PCODE DynamicHelpers::CreateDictionaryLookupHelper(LoaderAllocator * pAllocator,
         // reuse EmitHelperWithArg for below two operations
         // X1 <- pArgs
         // branch to helperAddress
-        EmitHelperWithArg(p, pAllocator, (TADDR)pArgs, helperAddress);
+        EmitHelperWithArg(p, rxOffset, pAllocator, (TADDR)pArgs, helperAddress);
 
         END_DYNAMIC_HELPER_EMIT();
     }
@@ -2295,7 +2301,7 @@ PCODE DynamicHelpers::CreateDictionaryLookupHelper(LoaderAllocator * pAllocator,
             // reuse EmitHelperWithArg for below two operations
             // X1 <- pArgs
             // branch to helperAddress
-            EmitHelperWithArg(p, pAllocator, (TADDR)pArgs, helperAddress);
+            EmitHelperWithArg(p, rxOffset, pAllocator, (TADDR)pArgs, helperAddress);
         }
 
         // datalabel:
diff --git a/src/coreclr/vm/arm64/virtualcallstubcpu.hpp b/src/coreclr/vm/arm64/virtualcallstubcpu.hpp
index 890cf39cbaa8ec..bdb78617e84e0b 100644
--- a/src/coreclr/vm/arm64/virtualcallstubcpu.hpp
+++ b/src/coreclr/vm/arm64/virtualcallstubcpu.hpp
@@ -46,7 +46,7 @@ struct LookupHolder
 public:
     static void InitializeStatic() { }
 
-    void  Initialize(PCODE resolveWorkerTarget, size_t dispatchToken)
+    void  Initialize(LookupHolder* pLookupHolderRX, PCODE resolveWorkerTarget, size_t dispatchToken)
     {
         // adr x9, _resolveWorkerTarget
         // ldp x10, x12, [x9]
@@ -80,7 +80,7 @@ struct DispatchStub
         LIMITED_METHOD_CONTRACT;
         _ASSERTE(slotTypeRef != nullptr);
 
-        *slotTypeRef = EntryPointSlots::SlotType_Normal;
+        *slotTypeRef = EntryPointSlots::SlotType_Executable;
         return (TADDR)&_implTarget;
     }
 
@@ -106,7 +106,7 @@ struct DispatchHolder
         static_assert_no_msg(((offsetof(DispatchHolder, _stub) + offsetof(DispatchStub, _implTarget)) % sizeof(void *)) == 0);
     }
 
-    void  Initialize(PCODE implTarget, PCODE failTarget, size_t expectedMT)
+    void  Initialize(DispatchHolder* pDispatchHolderRX, PCODE implTarget, PCODE failTarget, size_t expectedMT)
     {
         // ldr x13, [x0] ; methodTable from object in x0
         // adr x9, _expectedMT ; _expectedMT is at offset 28 from pc
@@ -180,7 +180,8 @@ struct ResolveHolder
 {
     static void  InitializeStatic() { }
 
-    void Initialize(PCODE resolveWorkerTarget, PCODE patcherTarget,
+    void Initialize(ResolveHolder* pResolveHolderRX,
+                    PCODE resolveWorkerTarget, PCODE patcherTarget,
                     size_t dispatchToken, UINT32 hashedToken,
                     void * cacheAddr, INT32 * counterAddr)
     {
diff --git a/src/coreclr/vm/array.cpp b/src/coreclr/vm/array.cpp
index 8ef78b688a95c7..ae91f700fbcd62 100644
--- a/src/coreclr/vm/array.cpp
+++ b/src/coreclr/vm/array.cpp
@@ -1191,6 +1191,11 @@ class ArrayStubCache : public StubCacheBase
     virtual UINT Length(const BYTE *pRawStub);
 
 public:
+public:
+    ArrayStubCache(LoaderHeap* heap) : StubCacheBase(heap)
+    {
+    }
+
     static ArrayStubCache * GetArrayStubCache()
     {
         STANDARD_VM_CONTRACT;
@@ -1199,7 +1204,7 @@ class ArrayStubCache : public StubCacheBase
 
         if (s_pArrayStubCache == NULL)
         {
-            ArrayStubCache * pArrayStubCache = new ArrayStubCache();
+            ArrayStubCache * pArrayStubCache = new ArrayStubCache(SystemDomain::GetGlobalLoaderAllocator()->GetStubHeap());
             if (FastInterlockCompareExchangePointer(&s_pArrayStubCache, pArrayStubCache, NULL) != NULL)
                 delete pArrayStubCache;
         }
diff --git a/src/coreclr/vm/assembly.cpp b/src/coreclr/vm/assembly.cpp
index 6f45022d10b777..9d4cd4ab7ce457 100644
--- a/src/coreclr/vm/assembly.cpp
+++ b/src/coreclr/vm/assembly.cpp
@@ -270,10 +270,10 @@ void ProfilerCallAssemblyUnloadStarted(Assembly* assemblyUnloaded)
 {
     WRAPPER_NO_CONTRACT;
     {
-        BEGIN_PIN_PROFILER(CORProfilerPresent());
+        BEGIN_PROFILER_CALLBACK(CORProfilerPresent());
         GCX_PREEMP();
-        g_profControlBlock.pProfInterface->AssemblyUnloadStarted((AssemblyID)assemblyUnloaded);
-        END_PIN_PROFILER();
+        (&g_profControlBlock)->AssemblyUnloadStarted((AssemblyID)assemblyUnloaded);
+        END_PROFILER_CALLBACK();
     }
 }
 
@@ -281,10 +281,10 @@ void ProfilerCallAssemblyUnloadFinished(Assembly* assemblyUnloaded)
 {
     WRAPPER_NO_CONTRACT;
     {
-        BEGIN_PIN_PROFILER(CORProfilerPresent());
+        BEGIN_PROFILER_CALLBACK(CORProfilerPresent());
         GCX_PREEMP();
-        g_profControlBlock.pProfInterface->AssemblyUnloadFinished((AssemblyID) assemblyUnloaded, S_OK);
-        END_PIN_PROFILER();
+        (&g_profControlBlock)->AssemblyUnloadFinished((AssemblyID) assemblyUnloaded, S_OK);
+        END_PROFILER_CALLBACK();
     }
 }
 #endif
@@ -347,10 +347,10 @@ Assembly * Assembly::Create(
 
 #ifdef PROFILING_SUPPORTED
     {
-        BEGIN_PIN_PROFILER(CORProfilerTrackAssemblyLoads());
+        BEGIN_PROFILER_CALLBACK(CORProfilerTrackAssemblyLoads());
         GCX_COOP();
-        g_profControlBlock.pProfInterface->AssemblyLoadStarted((AssemblyID)(Assembly *) pAssembly);
-        END_PIN_PROFILER();
+        (&g_profControlBlock)->AssemblyLoadStarted((AssemblyID)(Assembly *) pAssembly);
+        END_PROFILER_CALLBACK();
     }
 
     // Need TRY/HOOK instead of holder so we can get HR of exception thrown for profiler callback
@@ -363,11 +363,11 @@ Assembly * Assembly::Create(
     EX_HOOK
     {
         {
-            BEGIN_PIN_PROFILER(CORProfilerTrackAssemblyLoads());
+            BEGIN_PROFILER_CALLBACK(CORProfilerTrackAssemblyLoads());
             GCX_COOP();
-            g_profControlBlock.pProfInterface->AssemblyLoadFinished((AssemblyID)(Assembly *) pAssembly,
+            (&g_profControlBlock)->AssemblyLoadFinished((AssemblyID)(Assembly *) pAssembly,
                                                                     GET_EXCEPTION()->GetHR());
-            END_PIN_PROFILER();
+            END_PROFILER_CALLBACK();
         }
     }
     EX_END_HOOK;
diff --git a/src/coreclr/vm/callcounting.cpp b/src/coreclr/vm/callcounting.cpp
index 1a19c43a67fa5a..bdc4bc8a6d67fd 100644
--- a/src/coreclr/vm/callcounting.cpp
+++ b/src/coreclr/vm/callcounting.cpp
@@ -251,10 +251,6 @@ const CallCountingStub *CallCountingManager::CallCountingStubAllocator::Allocate
     }
     CONTRACTL_END;
 
-#if defined(HOST_OSX) && defined(HOST_ARM64)
-    auto jitWriteEnableHolder = PAL_JITWriteEnable(true);
-#endif // defined(HOST_OSX) && defined(HOST_ARM64)
-
     LoaderHeap *heap = m_heap;
     if (heap == nullptr)
     {
@@ -281,7 +277,9 @@ const CallCountingStub *CallCountingManager::CallCountingStubAllocator::Allocate
             if (CallCountingStubShort::CanUseFor(allocationAddressHolder, targetForMethod))
         #endif
             {
-                stub = new(allocationAddressHolder) CallCountingStubShort(remainingCallCountCell, targetForMethod);
+                ExecutableWriterHolder<void> writerHolder(allocationAddressHolder, sizeInBytes);
+                new(writerHolder.GetRW()) CallCountingStubShort((CallCountingStubShort*)(void*)allocationAddressHolder, remainingCallCountCell, targetForMethod);
+                stub = (CallCountingStub*)(void*)allocationAddressHolder;
                 allocationAddressHolder.SuppressRelease();
                 break;
             }
@@ -290,7 +288,9 @@ const CallCountingStub *CallCountingManager::CallCountingStubAllocator::Allocate
     #ifdef TARGET_AMD64
         sizeInBytes = sizeof(CallCountingStubLong);
         void *allocationAddress = (void *)heap->AllocAlignedMem(sizeInBytes, CallCountingStub::Alignment);
-        stub = new(allocationAddress) CallCountingStubLong(remainingCallCountCell, targetForMethod);
+        ExecutableWriterHolder<void> writerHolder(allocationAddress, sizeInBytes);
+        new(writerHolder.GetRW()) CallCountingStubLong(remainingCallCountCell, targetForMethod);
+        stub = (CallCountingStub*)allocationAddress;
     #else
         UNREACHABLE();
     #endif
diff --git a/src/coreclr/vm/callhelpers.cpp b/src/coreclr/vm/callhelpers.cpp
index fa32e4e299013b..1a1545d7e9bd7e 100644
--- a/src/coreclr/vm/callhelpers.cpp
+++ b/src/coreclr/vm/callhelpers.cpp
@@ -62,10 +62,6 @@ void CallDescrWorkerWithHandler(
 
 #endif
 
-#if defined(HOST_OSX) && defined(HOST_ARM64)
-    auto jitWriteEnableHolder = PAL_JITWriteEnable(false);
-#endif // defined(HOST_OSX) && defined(HOST_ARM64)
-
     BEGIN_CALL_TO_MANAGEDEX(fCriticalCall ? EEToManagedCriticalCall : EEToManagedDefault);
 
     CallDescrWorker(pCallDescrData);
diff --git a/src/coreclr/vm/callingconvention.h b/src/coreclr/vm/callingconvention.h
index deab21ca97efe6..00cc47e9661d0c 100644
--- a/src/coreclr/vm/callingconvention.h
+++ b/src/coreclr/vm/callingconvention.h
@@ -423,11 +423,12 @@ class ArgIteratorTemplate : public ARGITERATOR_BASE
                             //@todo: Is it more apropos to call LookupApproxFieldTypeHandle() here?	
                             TypeHandle fldHnd = pFD->GetApproxFieldTypeHandleThrowing();	
                             CONSISTENCY_CHECK(!fldHnd.IsNull());
-                            pMT = fldHnd.GetMethodTable();	
+                            pMT = fldHnd.GetMethodTable();
+                            FALLTHROUGH;
                         }	
-                        case ELEMENT_TYPE_PTR:	
-                        case ELEMENT_TYPE_I:	
-                        case ELEMENT_TYPE_U:	
+                        case ELEMENT_TYPE_PTR:
+                        case ELEMENT_TYPE_I:
+                        case ELEMENT_TYPE_U:
                         case ELEMENT_TYPE_I4:	
                         case ELEMENT_TYPE_U4:
                         {	
@@ -715,6 +716,11 @@ class ArgIteratorTemplate : public ARGITERATOR_BASE
             pLoc->m_byteStackIndex = TransitionBlock::GetStackArgumentByteIndexFromOffset(argOffset);
             const bool isValueType = (m_argType == ELEMENT_TYPE_VALUETYPE);
             const bool isFloatHfa = (isValueType && !m_argTypeHandle.IsNull() && m_argTypeHandle.IsHFA());
+            if (isFloatHfa)
+            {
+                CorInfoHFAElemType type = m_argTypeHandle.GetHFAType();
+                pLoc->setHFAFieldSize(type);
+            }
             pLoc->m_byteStackSize = StackElemSize(byteArgSize, isValueType, isFloatHfa);
         }
     }
diff --git a/src/coreclr/vm/ceeload.cpp b/src/coreclr/vm/ceeload.cpp
index d95c02ac94951c..a41ed4c81a5937 100644
--- a/src/coreclr/vm/ceeload.cpp
+++ b/src/coreclr/vm/ceeload.cpp
@@ -163,10 +163,10 @@ void Module::DoInit(AllocMemTracker *pamTracker, LPCWSTR szName)
 
 #ifdef PROFILING_SUPPORTED
     {
-        BEGIN_PIN_PROFILER(CORProfilerTrackModuleLoads());
+        BEGIN_PROFILER_CALLBACK(CORProfilerTrackModuleLoads());
         GCX_COOP();
-        g_profControlBlock.pProfInterface->ModuleLoadStarted((ModuleID) this);
-        END_PIN_PROFILER();
+        (&g_profControlBlock)->ModuleLoadStarted((ModuleID) this);
+        END_PROFILER_CALLBACK();
     }
     // Need TRY/HOOK instead of holder so we can get HR of exception thrown for profiler callback
     EX_TRY
@@ -180,9 +180,9 @@ void Module::DoInit(AllocMemTracker *pamTracker, LPCWSTR szName)
     EX_HOOK
     {
         {
-            BEGIN_PIN_PROFILER(CORProfilerTrackModuleLoads());
-            g_profControlBlock.pProfInterface->ModuleLoadFinished((ModuleID) this, GET_EXCEPTION()->GetHR());
-            END_PIN_PROFILER();
+            BEGIN_PROFILER_CALLBACK(CORProfilerTrackModuleLoads());
+            (&g_profControlBlock)->ModuleLoadFinished((ModuleID) this, GET_EXCEPTION()->GetHR());
+            END_PROFILER_CALLBACK();
         }
     }
     EX_END_HOOK;
@@ -291,20 +291,20 @@ void Module::NotifyProfilerLoadFinished(HRESULT hr)
         BOOL profilerCallbackHappened = FALSE;
         // Notify the profiler, this may cause metadata to be updated
         {
-            BEGIN_PIN_PROFILER(CORProfilerTrackModuleLoads());
+            BEGIN_PROFILER_CALLBACK(CORProfilerTrackModuleLoads());
             {
                 GCX_PREEMP();
-                g_profControlBlock.pProfInterface->ModuleLoadFinished((ModuleID) this, hr);
+                (&g_profControlBlock)->ModuleLoadFinished((ModuleID) this, hr);
 
                 if (SUCCEEDED(hr))
                 {
-                    g_profControlBlock.pProfInterface->ModuleAttachedToAssembly((ModuleID) this,
+                    (&g_profControlBlock)->ModuleAttachedToAssembly((ModuleID) this,
                                                                                 (AssemblyID)m_pAssembly);
                 }
 
                 profilerCallbackHappened = TRUE;
             }
-            END_PIN_PROFILER();
+            END_PROFILER_CALLBACK();
         }
 
         // If there are more types than before, add these new types to the
@@ -315,13 +315,13 @@ void Module::NotifyProfilerLoadFinished(HRESULT hr)
         }
 
         {
-            BEGIN_PIN_PROFILER(CORProfilerTrackAssemblyLoads());
+            BEGIN_PROFILER_CALLBACK(CORProfilerTrackAssemblyLoads());
             if (IsManifest())
             {
                 GCX_COOP();
-                g_profControlBlock.pProfInterface->AssemblyLoadFinished((AssemblyID) m_pAssembly, hr);
+                (&g_profControlBlock)->AssemblyLoadFinished((AssemblyID) m_pAssembly, hr);
             }
-            END_PIN_PROFILER();
+            END_PROFILER_CALLBACK();
         }
     }
 }
@@ -1219,7 +1219,7 @@ void Module::Destruct()
     LOG((LF_EEMEM, INFO3, "Deleting module %x\n", this));
 #ifdef PROFILING_SUPPORTED
     {
-        BEGIN_PIN_PROFILER(CORProfilerTrackModuleLoads());
+        BEGIN_PROFILER_CALLBACK(CORProfilerTrackModuleLoads());
         if (!IsBeingUnloaded())
         {
             // Profiler is causing some peripheral class loads. Probably this just needs
@@ -1227,14 +1227,14 @@ void Module::Destruct()
             EX_TRY
             {
                 GCX_PREEMP();
-                g_profControlBlock.pProfInterface->ModuleUnloadStarted((ModuleID) this);
+                (&g_profControlBlock)->ModuleUnloadStarted((ModuleID) this);
             }
             EX_CATCH
             {
             }
             EX_END_CATCH(SwallowAllExceptions);
         }
-        END_PIN_PROFILER();
+        END_PROFILER_CALLBACK();
     }
 #endif // PROFILING_SUPPORTED
 
@@ -1277,19 +1277,19 @@ void Module::Destruct()
 
 #ifdef PROFILING_SUPPORTED
     {
-        BEGIN_PIN_PROFILER(CORProfilerTrackModuleLoads());
+        BEGIN_PROFILER_CALLBACK(CORProfilerTrackModuleLoads());
         // Profiler is causing some peripheral class loads. Probably this just needs
         // to be turned into a Fault_not_fatal and moved to a specific place inside the profiler.
         EX_TRY
         {
             GCX_PREEMP();
-            g_profControlBlock.pProfInterface->ModuleUnloadFinished((ModuleID) this, S_OK);
+            (&g_profControlBlock)->ModuleUnloadFinished((ModuleID) this, S_OK);
         }
         EX_CATCH
         {
         }
         EX_END_CATCH(SwallowAllExceptions);
-        END_PIN_PROFILER();
+        END_PROFILER_CALLBACK();
     }
 
     if (m_pValidatedEmitter.Load() != NULL)
@@ -3129,7 +3129,7 @@ void Module::StartUnload()
     WRAPPER_NO_CONTRACT;
 #ifdef PROFILING_SUPPORTED
     {
-        BEGIN_PIN_PROFILER(CORProfilerTrackModuleLoads());
+        BEGIN_PROFILER_CALLBACK(CORProfilerTrackModuleLoads());
         if (!IsBeingUnloaded())
         {
             // Profiler is causing some peripheral class loads. Probably this just needs
@@ -3137,14 +3137,14 @@ void Module::StartUnload()
             EX_TRY
             {
                 GCX_PREEMP();
-                g_profControlBlock.pProfInterface->ModuleUnloadStarted((ModuleID) this);
+                (&g_profControlBlock)->ModuleUnloadStarted((ModuleID) this);
             }
             EX_CATCH
             {
             }
             EX_END_CATCH(SwallowAllExceptions);
         }
-        END_PIN_PROFILER();
+        END_PROFILER_CALLBACK();
     }
 #endif // PROFILING_SUPPORTED
 
@@ -3607,11 +3607,11 @@ void Module::SetSymbolBytes(LPCBYTE pbSyms, DWORD cbSyms)
     IfFailThrow(HRESULT_FROM_WIN32(dwError));
 
 #if PROFILING_SUPPORTED && !defined(CROSSGEN_COMPILE)
-    BEGIN_PIN_PROFILER(CORProfilerInMemorySymbolsUpdatesEnabled());
+    BEGIN_PROFILER_CALLBACK(CORProfilerInMemorySymbolsUpdatesEnabled());
     {
-        g_profControlBlock.pProfInterface->ModuleInMemorySymbolsUpdated((ModuleID) this);
+        (&g_profControlBlock)->ModuleInMemorySymbolsUpdated((ModuleID) this);
     }
-    END_PIN_PROFILER();
+    END_PROFILER_CALLBACK();
 #endif //PROFILING_SUPPORTED && !defined(CROSSGEN_COMPILE)
 
     ETW::CodeSymbolLog::EmitCodeSymbols(this);
@@ -6329,13 +6329,16 @@ void Module::FixupVTables()
                         (UINT_PTR)&(pPointers[iMethod]), pMD->m_pszDebugMethodName, pMD));
 
                     UMEntryThunk *pUMEntryThunk = (UMEntryThunk*)(void*)(GetDllThunkHeap()->AllocAlignedMem(sizeof(UMEntryThunk), CODE_SIZE_ALIGN)); // UMEntryThunk contains code
-                    FillMemory(pUMEntryThunk, sizeof(*pUMEntryThunk), 0);
+                    ExecutableWriterHolder<UMEntryThunk> uMEntryThunkWriterHolder(pUMEntryThunk, sizeof(UMEntryThunk));
+                    FillMemory(uMEntryThunkWriterHolder.GetRW(), sizeof(UMEntryThunk), 0);
 
                     UMThunkMarshInfo *pUMThunkMarshInfo = (UMThunkMarshInfo*)(void*)(GetThunkHeap()->AllocAlignedMem(sizeof(UMThunkMarshInfo), CODE_SIZE_ALIGN));
-                    FillMemory(pUMThunkMarshInfo, sizeof(*pUMThunkMarshInfo), 0);
+                    ExecutableWriterHolder<UMThunkMarshInfo> uMThunkMarshInfoWriterHolder(pUMThunkMarshInfo, sizeof(UMThunkMarshInfo));
+                    FillMemory(uMThunkMarshInfoWriterHolder.GetRW(), sizeof(UMThunkMarshInfo), 0);
+
+                    uMThunkMarshInfoWriterHolder.GetRW()->LoadTimeInit(pMD);
+                    uMEntryThunkWriterHolder.GetRW()->LoadTimeInit(pUMEntryThunk, NULL, NULL, pUMThunkMarshInfo, pMD);
 
-                    pUMThunkMarshInfo->LoadTimeInit(pMD);
-                    pUMEntryThunk->LoadTimeInit(NULL, NULL, pUMThunkMarshInfo, pMD);
                     SetTargetForVTableEntry(hInstThis, (BYTE **)&pPointers[iMethod], (BYTE *)pUMEntryThunk->GetCode());
 
                     pData->MarkMethodFixedUp(iFixup, iMethod);
diff --git a/src/coreclr/vm/ceemain.cpp b/src/coreclr/vm/ceemain.cpp
index eb31d0f928de5e..cdc5925234af92 100644
--- a/src/coreclr/vm/ceemain.cpp
+++ b/src/coreclr/vm/ceemain.cpp
@@ -489,15 +489,9 @@ void InitGSCookie()
 
     volatile GSCookie * pGSCookiePtr = GetProcessGSCookiePtr();
 
-#ifdef TARGET_UNIX
-    // On Unix, the GS cookie is stored in a read only data segment
-    DWORD newProtection = PAGE_READWRITE;
-#else // TARGET_UNIX
-    DWORD newProtection = PAGE_EXECUTE_READWRITE;
-#endif // !TARGET_UNIX
-
+    // The GS cookie is stored in a read only data segment
     DWORD oldProtection;
-    if(!ClrVirtualProtect((LPVOID)pGSCookiePtr, sizeof(GSCookie), newProtection, &oldProtection))
+    if(!ClrVirtualProtect((LPVOID)pGSCookiePtr, sizeof(GSCookie), PAGE_READWRITE, &oldProtection))
     {
         ThrowLastError();
     }
@@ -709,11 +703,6 @@ void EEStartupHelper()
         }
 #endif
 
-#ifdef PROFILING_SUPPORTED
-        // The diagnostics server might register a profiler for delayed startup, indicate here that 
-        // it is not currently set. This will be set to TRUE if a profiler is registered.
-       g_profControlBlock.fIsStoredProfilerRegistered = FALSE;
-#endif // PROFILING_SUPPORTED
 #ifdef FEATURE_PERFTRACING
         DiagnosticServerAdapter::Initialize();
         DiagnosticServerAdapter::PauseForDiagnosticsMonitor();
@@ -990,10 +979,6 @@ void EEStartupHelper()
 
         Assembly::Initialize();
 
-#if defined(HOST_OSX) && defined(HOST_ARM64)
-        PAL_JITWriteEnable(true);
-#endif // defined(HOST_OSX) && defined(HOST_ARM64)
-
         SystemDomain::System()->Init();
 
 #ifdef PROFILING_SUPPORTED
@@ -1414,10 +1399,10 @@ void STDMETHODCALLTYPE EEShutDownHelper(BOOL fIsDllUnloading)
             // Don't call back in to the profiler if we are being torn down, it might be unloaded
             if (!fIsDllUnloading)
             {
-                BEGIN_PIN_PROFILER(CORProfilerPresent());
+                BEGIN_PROFILER_CALLBACK(CORProfilerPresent());
                 GCX_PREEMP();
-                g_profControlBlock.pProfInterface->Shutdown();
-                END_PIN_PROFILER();
+                (&g_profControlBlock)->Shutdown();
+                END_PROFILER_CALLBACK();
             }
 
             g_fEEShutDown |= ShutDown_Profiler;
diff --git a/src/coreclr/vm/class.cpp b/src/coreclr/vm/class.cpp
index 17417e0b760906..6f2da9db3c29d3 100644
--- a/src/coreclr/vm/class.cpp
+++ b/src/coreclr/vm/class.cpp
@@ -94,7 +94,7 @@ void EEClass::Destruct(MethodTable * pOwningMT)
 #ifdef PROFILING_SUPPORTED
     // If profiling, then notify the class is getting unloaded.
     {
-        BEGIN_PIN_PROFILER(CORProfilerTrackClasses());
+        BEGIN_PROFILER_CALLBACK(CORProfilerTrackClasses());
         {
             // Calls to the profiler callback may throw, or otherwise fail, if
             // the profiler AVs/throws an unhandled exception/etc. We don't want
@@ -115,7 +115,7 @@ void EEClass::Destruct(MethodTable * pOwningMT)
             {
                 GCX_PREEMP();
 
-                g_profControlBlock.pProfInterface->ClassUnloadStarted((ClassID) pOwningMT);
+                (&g_profControlBlock)->ClassUnloadStarted((ClassID) pOwningMT);
             }
             EX_CATCH
             {
@@ -125,7 +125,7 @@ void EEClass::Destruct(MethodTable * pOwningMT)
             }
             EX_END_CATCH(RethrowTerminalExceptions);
         }
-        END_PIN_PROFILER();
+        END_PROFILER_CALLBACK();
     }
 #endif // PROFILING_SUPPORTED
 
@@ -178,7 +178,7 @@ void EEClass::Destruct(MethodTable * pOwningMT)
 #ifdef PROFILING_SUPPORTED
     // If profiling, then notify the class is getting unloaded.
     {
-        BEGIN_PIN_PROFILER(CORProfilerTrackClasses());
+        BEGIN_PROFILER_CALLBACK(CORProfilerTrackClasses());
         {
             // See comments in the call to ClassUnloadStarted for details on this
             // FAULT_NOT_FATAL marker and exception swallowing.
@@ -186,14 +186,14 @@ void EEClass::Destruct(MethodTable * pOwningMT)
             EX_TRY
             {
                 GCX_PREEMP();
-                g_profControlBlock.pProfInterface->ClassUnloadFinished((ClassID) pOwningMT, S_OK);
+                (&g_profControlBlock)->ClassUnloadFinished((ClassID) pOwningMT, S_OK);
             }
             EX_CATCH
             {
             }
             EX_END_CATCH(RethrowTerminalExceptions);
         }
-        END_PIN_PROFILER();
+        END_PROFILER_CALLBACK();
     }
 #endif // PROFILING_SUPPORTED
 
diff --git a/src/coreclr/vm/classlayoutinfo.cpp b/src/coreclr/vm/classlayoutinfo.cpp
index 612c119be79f01..07667804110c1f 100644
--- a/src/coreclr/vm/classlayoutinfo.cpp
+++ b/src/coreclr/vm/classlayoutinfo.cpp
@@ -653,12 +653,8 @@ VOID EEClassLayoutInfo::CollectLayoutFieldMetadataThrowing(
         DEBUGARG(szName)
         );
 
-    // Type is blittable only if parent is also blittable and is not empty.
-    if (isBlittable && fHasNonTrivialParent)
-    {
-        isBlittable = pParentMT->IsBlittable()  // Check parent
-            && (!pParentLayoutInfo || !pParentLayoutInfo->IsZeroSized()); // Ensure non-zero size
-    }
+    // Type is blittable only if parent is also blittable
+    isBlittable = isBlittable && (fHasNonTrivialParent ? pParentMT->IsBlittable() : TRUE);
     pEEClassLayoutInfoOut->SetIsBlittable(isBlittable);
 
     S_UINT32 cbSortArraySize = S_UINT32(cTotalFields) * S_UINT32(sizeof(LayoutRawFieldInfo*));
diff --git a/src/coreclr/vm/clrtocomcall.cpp b/src/coreclr/vm/clrtocomcall.cpp
index f8339b0ccc5d85..e56d6621939008 100644
--- a/src/coreclr/vm/clrtocomcall.cpp
+++ b/src/coreclr/vm/clrtocomcall.cpp
@@ -1014,17 +1014,20 @@ LPVOID ComPlusCall::GetRetThunk(UINT numStackBytes)
     {
         // cache miss -> create a new thunk
         AllocMemTracker dummyAmTracker;
-        pRetThunk = (LPVOID)dummyAmTracker.Track(SystemDomain::GetGlobalLoaderAllocator()->GetExecutableHeap()->AllocMem(S_SIZE_T((numStackBytes == 0) ? 1 : 3)));
+        size_t thunkSize = (numStackBytes == 0) ? 1 : 3;
+        pRetThunk = (LPVOID)dummyAmTracker.Track(SystemDomain::GetGlobalLoaderAllocator()->GetExecutableHeap()->AllocMem(S_SIZE_T(thunkSize)));
+
+        ExecutableWriterHolder<BYTE> thunkWriterHolder((BYTE *)pRetThunk, thunkSize);
+        BYTE *pThunkRW = thunkWriterHolder.GetRW();
 
-        BYTE *pThunk = (BYTE *)pRetThunk;
         if (numStackBytes == 0)
         {
-            pThunk[0] = 0xc3;
+            pThunkRW[0] = 0xc3;
         }
         else
         {
-            pThunk[0] = 0xc2;
-            *(USHORT *)&pThunk[1] = (USHORT)numStackBytes;
+            pThunkRW[0] = 0xc2;
+            *(USHORT *)&pThunkRW[1] = (USHORT)numStackBytes;
         }
 
         // add it to the cache
diff --git a/src/coreclr/vm/clsload.cpp b/src/coreclr/vm/clsload.cpp
index 65692222bb3e1d..62eccc0995ffe7 100644
--- a/src/coreclr/vm/clsload.cpp
+++ b/src/coreclr/vm/clsload.cpp
@@ -3452,7 +3452,7 @@ void ClassLoader::Notify(TypeHandle typeHnd)
 
 #ifdef PROFILING_SUPPORTED
     {
-        BEGIN_PIN_PROFILER(CORProfilerTrackClasses());
+        BEGIN_PROFILER_CALLBACK(CORProfilerTrackClasses());
         // We don't tell profilers about typedescs, as per IF above.  Also, we don't
         // tell profilers about:
         if (
@@ -3465,7 +3465,7 @@ void ClassLoader::Notify(TypeHandle typeHnd)
         {
             LOG((LF_CLASSLOADER, LL_INFO1000, "Notifying profiler of Started1 %p %s\n", pMT, pMT->GetDebugClassName()));
             // Record successful load of the class for the profiler
-            g_profControlBlock.pProfInterface->ClassLoadStarted(TypeHandleToClassID(typeHnd));
+            (&g_profControlBlock)->ClassLoadStarted(TypeHandleToClassID(typeHnd));
 
             //
             // Profiler can turn off TrackClasses during the Started() callback.  Need to
@@ -3474,11 +3474,11 @@ void ClassLoader::Notify(TypeHandle typeHnd)
             if (CORProfilerTrackClasses())
             {
                 LOG((LF_CLASSLOADER, LL_INFO1000, "Notifying profiler of Finished1 %p %s\n", pMT, pMT->GetDebugClassName()));
-                g_profControlBlock.pProfInterface->ClassLoadFinished(TypeHandleToClassID(typeHnd),
+                (&g_profControlBlock)->ClassLoadFinished(TypeHandleToClassID(typeHnd),
                     S_OK);
             }
         }
-        END_PIN_PROFILER();
+        END_PROFILER_CALLBACK();
     }
 #endif //PROFILING_SUPPORTED
 
diff --git a/src/coreclr/vm/codeman.cpp b/src/coreclr/vm/codeman.cpp
index 592ff2e1c38bb6..349a76039cd46c 100644
--- a/src/coreclr/vm/codeman.cpp
+++ b/src/coreclr/vm/codeman.cpp
@@ -1718,8 +1718,8 @@ static void LoadAndInitializeJIT(LPCWSTR pwzJitName, OUT HINSTANCE* phJit, OUT I
 }
 
 #ifdef FEATURE_MERGE_JIT_AND_ENGINE
-EXTERN_C void __stdcall jitStartup(ICorJitHost* host);
-EXTERN_C ICorJitCompiler* __stdcall getJit();
+EXTERN_C void jitStartup(ICorJitHost* host);
+EXTERN_C ICorJitCompiler* getJit();
 #endif // FEATURE_MERGE_JIT_AND_ENGINE
 
 BOOL EEJitManager::LoadJIT()
@@ -1901,10 +1901,6 @@ TaggedMemAllocPtr CodeFragmentHeap::RealAllocAlignedMem(size_t  dwRequestedSize
 {
     CrstHolder ch(&m_CritSec);
 
-#if defined(HOST_OSX) && defined(HOST_ARM64)
-    auto jitWriteEnableHolder = PAL_JITWriteEnable(true);
-#endif // defined(HOST_OSX) && defined(HOST_ARM64)
-
     dwRequestedSize = ALIGN_UP(dwRequestedSize, sizeof(TADDR));
 
     // We will try to batch up allocation of small blocks into one large allocation
@@ -1981,11 +1977,10 @@ void CodeFragmentHeap::RealBackoutMem(void *pMem
 {
     CrstHolder ch(&m_CritSec);
 
-#if defined(HOST_OSX) && defined(HOST_ARM64)
-    auto jitWriteEnableHolder = PAL_JITWriteEnable(true);
-#endif // defined(HOST_OSX) && defined(HOST_ARM64)
-
-    ZeroMemory((BYTE *)pMem, dwSize);
+    {
+        ExecutableWriterHolder<BYTE> memWriterHolder((BYTE*)pMem, dwSize);
+        ZeroMemory(memWriterHolder.GetRW(), dwSize);
+    }
 
     //
     // Try to coalesce blocks if possible
@@ -2300,7 +2295,8 @@ HeapList* LoaderCodeHeap::CreateCodeHeap(CodeHeapRequestInfo *pInfo, LoaderHeap
          ));
 
 #ifdef TARGET_64BIT
-    emitJump(pHp->CLRPersonalityRoutine, (void *)ProcessCLRException);
+    ExecutableWriterHolder<BYTE> personalityRoutineWriterHolder(pHp->CLRPersonalityRoutine, 12);
+    emitJump(pHp->CLRPersonalityRoutine, personalityRoutineWriterHolder.GetRW(), (void *)ProcessCLRException);
 #endif // TARGET_64BIT
 
     pCodeHeap.SuppressRelease();
@@ -2689,6 +2685,7 @@ void EEJitManager::allocCode(MethodDesc* pMD, size_t blockSize, size_t reserveFo
         pCodeHdr = ((CodeHeader *)pCode) - 1;
 
         *pAllocatedSize = sizeof(CodeHeader) + totalSize;
+#define FEATURE_WXORX        
 #ifdef FEATURE_WXORX
         pCodeHdrRW = (CodeHeader *)new BYTE[*pAllocatedSize];
 #else
@@ -3001,13 +2998,13 @@ JumpStubBlockHeader *  EEJitManager::allocJumpStubBlock(MethodDesc* pMD, DWORD n
     requestInfo.setThrowOnOutOfMemoryWithinRange(throwOnOutOfMemoryWithinRange);
 
     TADDR                  mem;
-    JumpStubBlockHeader *  pBlock;
+    ExecutableWriterHolder<JumpStubBlockHeader> blockWriterHolder;
 
     // Scope the lock
     {
         CrstHolder ch(&m_CodeHeapCritSec);
 
-        mem = (TADDR) allocCodeRaw(&requestInfo, sizeof(TADDR), blockSize, CODE_SIZE_ALIGN, &pCodeHeap);
+        mem = (TADDR) allocCodeRaw(&requestInfo, sizeof(CodeHeader), blockSize, CODE_SIZE_ALIGN, &pCodeHeap);
         if (mem == NULL)
         {
             _ASSERTE(!throwOnOutOfMemoryWithinRange);
@@ -3016,27 +3013,28 @@ JumpStubBlockHeader *  EEJitManager::allocJumpStubBlock(MethodDesc* pMD, DWORD n
 
         // CodeHeader comes immediately before the block
         CodeHeader * pCodeHdr = (CodeHeader *) (mem - sizeof(CodeHeader));
-        pCodeHdr->SetStubCodeBlockKind(STUB_CODE_BLOCK_JUMPSTUB);
+        ExecutableWriterHolder<CodeHeader> codeHdrWriterHolder(pCodeHdr, sizeof(CodeHeader));
+        codeHdrWriterHolder.GetRW()->SetStubCodeBlockKind(STUB_CODE_BLOCK_JUMPSTUB);
 
         NibbleMapSetUnlocked(pCodeHeap, mem, TRUE);
 
-        pBlock = (JumpStubBlockHeader *)mem;
+        blockWriterHolder = ExecutableWriterHolder<JumpStubBlockHeader>((JumpStubBlockHeader *)mem, sizeof(JumpStubBlockHeader));
 
-        _ASSERTE(IS_ALIGNED(pBlock, CODE_SIZE_ALIGN));
+        _ASSERTE(IS_ALIGNED(blockWriterHolder.GetRW(), CODE_SIZE_ALIGN));
     }
 
-    pBlock->m_next            = NULL;
-    pBlock->m_used            = 0;
-    pBlock->m_allocated       = numJumps;
+    blockWriterHolder.GetRW()->m_next            = NULL;
+    blockWriterHolder.GetRW()->m_used            = 0;
+    blockWriterHolder.GetRW()->m_allocated       = numJumps;
     if (pMD && pMD->IsLCGMethod())
-        pBlock->SetHostCodeHeap(static_cast<HostCodeHeap*>(pCodeHeap->pHeap));
+        blockWriterHolder.GetRW()->SetHostCodeHeap(static_cast<HostCodeHeap*>(pCodeHeap->pHeap));
     else
-        pBlock->SetLoaderAllocator(pLoaderAllocator);
+        blockWriterHolder.GetRW()->SetLoaderAllocator(pLoaderAllocator);
 
     LOG((LF_JIT, LL_INFO1000, "Allocated new JumpStubBlockHeader for %d stubs at" FMT_ADDR " in loader allocator " FMT_ADDR "\n",
-         numJumps, DBG_ADDR(pBlock) , DBG_ADDR(pLoaderAllocator) ));
+         numJumps, DBG_ADDR(mem) , DBG_ADDR(pLoaderAllocator) ));
 
-    RETURN(pBlock);
+    RETURN((JumpStubBlockHeader*)mem);
 }
 
 void * EEJitManager::allocCodeFragmentBlock(size_t blockSize, unsigned alignment, LoaderAllocator *pLoaderAllocator, StubCodeBlockKind kind)
@@ -3067,7 +3065,8 @@ void * EEJitManager::allocCodeFragmentBlock(size_t blockSize, unsigned alignment
 
         // CodeHeader comes immediately before the block
         CodeHeader * pCodeHdr = (CodeHeader *) (mem - sizeof(CodeHeader));
-        pCodeHdr->SetStubCodeBlockKind(kind);
+        ExecutableWriterHolder<CodeHeader> codeHdrWriterHolder(pCodeHdr, sizeof(CodeHeader));
+        codeHdrWriterHolder.GetRW()->SetStubCodeBlockKind(kind);
 
         NibbleMapSetUnlocked(pCodeHeap, mem, TRUE);
 
@@ -3459,10 +3458,6 @@ void EEJitManager::CleanupCodeHeaps()
     HostCodeHeap *pHeap = m_cleanupList;
     m_cleanupList = NULL;
 
-#if defined(HOST_OSX) && defined(HOST_ARM64)
-    auto jitWriteEnableHolder = PAL_JITWriteEnable(true);
-#endif // defined(HOST_OSX) && defined(HOST_ARM64)
-
     while (pHeap)
     {
         HostCodeHeap *pNextHeap = pHeap->m_pNextHeapToRelease;
@@ -3574,10 +3569,6 @@ void EEJitManager::DeleteCodeHeap(HeapList *pHeapList)
                               (const BYTE*)pHeapList->startAddress,
                               (const BYTE*)pHeapList->endAddress     ));
 
-    // pHeapList is allocated in pHeap, so only need to delete the CodeHeap itself
-    // !!! For SoC, compiler inserts code to write a special cookie at pHeapList->pHeap after delete operator, at least for debug code.
-    // !!! Since pHeapList is deleted at the same time as pHeap, this causes AV.
-    // delete pHeapList->pHeap;
     CodeHeap* pHeap = pHeapList->pHeap;
     delete pHeap;
     delete pHeapList;
@@ -4078,6 +4069,23 @@ void GetUnmanagedStackWalkInfo(IN  ULONG64   ControlPc,
                     else
                     {
                         _ASSERTE(pFuncEntry);
+#ifdef _TARGET_AMD64_
+                        // On amd64, match RtlLookupFunctionEntry behavior by resolving indirect function entries
+                        // back to the associated owning function entry.
+                        if ((functionEntry.UnwindData & RUNTIME_FUNCTION_INDIRECT) != 0)
+                        {
+                            DWORD dwRvaOfOwningFunctionEntry = (functionEntry.UnwindData & ~RUNTIME_FUNCTION_INDIRECT);
+                            taFuncEntry = peDecoder.GetRvaData(dwRvaOfOwningFunctionEntry);
+                            hr = DacReadAll(taFuncEntry, &functionEntry, sizeof(functionEntry), false);
+                            if (FAILED(hr))
+                            {
+                                return;
+                            }
+
+                            _ASSERTE((functionEntry.UnwindData & RUNTIME_FUNCTION_INDIRECT) == 0);
+                        }
+#endif // _TARGET_AMD64_
+
                         *pFuncEntry = (UINT_PTR)(T_RUNTIME_FUNCTION*)PTR_RUNTIME_FUNCTION(taFuncEntry);
                         break;
                     }
@@ -4942,10 +4950,6 @@ void ExecutionManager::Unload(LoaderAllocator *pLoaderAllocator)
         GC_NOTRIGGER;
     } CONTRACTL_END;
 
-#if defined(HOST_OSX) && defined(HOST_ARM64)
-    auto jitWriteEnableHolder = PAL_JITWriteEnable(true);
-#endif // defined(HOST_OSX) && defined(HOST_ARM64)
-
     // a size of 0 is a signal to Nirvana to flush the entire cache
     FlushInstructionCache(GetCurrentProcess(),0,0);
 
@@ -5113,9 +5117,18 @@ PCODE ExecutionManager::getNextJumpStub(MethodDesc* pMD, PCODE target,
         POSTCONDITION((RETVAL != NULL) || !throwOnOutOfMemoryWithinRange);
     } CONTRACT_END;
 
-    DWORD            numJumpStubs   = DEFAULT_JUMPSTUBS_PER_BLOCK;  // a block of 32 JumpStubs
     BYTE *           jumpStub       = NULL;
+    BYTE *           jumpStubRW     = NULL;
     bool             isLCG          = pMD && pMD->IsLCGMethod();
+    // For LCG we request a small block of 4 jumpstubs, because we can not share them
+    // with any other methods and very frequently our method only needs one jump stub.
+    // Using 4 gives a request size of (32 + 4*12) or 80 bytes.
+    // Also note that request sizes are rounded up to a multiples of 16.
+    // The request size is calculated into 'blockSize' in allocJumpStubBlock.
+    // For x64 the value of BACK_TO_BACK_JUMP_ALLOCATE_SIZE is 12 bytes
+    // and the sizeof(JumpStubBlockHeader) is 32.
+    //
+    DWORD            numJumpStubs   = isLCG ? 4 : DEFAULT_JUMPSTUBS_PER_BLOCK;
     JumpStubCache *  pJumpStubCache = (JumpStubCache *) pLoaderAllocator->m_pJumpStubCache;
 
     if (isLCG)
@@ -5127,6 +5140,7 @@ PCODE ExecutionManager::getNextJumpStub(MethodDesc* pMD, PCODE target,
 
     JumpStubBlockHeader ** ppHead   = &(pJumpStubCache->m_pBlocks);
     JumpStubBlockHeader *  curBlock = *ppHead;
+    ExecutableWriterHolder<JumpStubBlockHeader> curBlockWriterHolder;
 
     // allocate a new jumpstub from 'curBlock' if it is not fully allocated
     //
@@ -5141,6 +5155,9 @@ PCODE ExecutionManager::getNextJumpStub(MethodDesc* pMD, PCODE target,
             if ((loAddr <= jumpStub) && (jumpStub <= hiAddr))
             {
                 // We will update curBlock->m_used at "DONE"
+                size_t blockSize = sizeof(JumpStubBlockHeader) + (size_t) numJumpStubs * BACK_TO_BACK_JUMP_ALLOCATE_SIZE;
+                curBlockWriterHolder = ExecutableWriterHolder<JumpStubBlockHeader>(curBlock, blockSize);
+                jumpStubRW = (BYTE *)((TADDR)jumpStub + (TADDR)curBlockWriterHolder.GetRW() - (TADDR)curBlock);
                 goto DONE;
             }
         }
@@ -5151,17 +5168,6 @@ PCODE ExecutionManager::getNextJumpStub(MethodDesc* pMD, PCODE target,
 
     if (isLCG)
     {
-        // For LCG we request a small block of 4 jumpstubs, because we can not share them
-        // with any other methods and very frequently our method only needs one jump stub.
-        // Using 4 gives a request size of (32 + 4*12) or 80 bytes.
-        // Also note that request sizes are rounded up to a multiples of 16.
-        // The request size is calculated into 'blockSize' in allocJumpStubBlock.
-        // For x64 the value of BACK_TO_BACK_JUMP_ALLOCATE_SIZE is 12 bytes
-        // and the sizeof(JumpStubBlockHeader) is 32.
-        //
-
-        numJumpStubs = 4;
-
 #ifdef TARGET_AMD64
         // Note this these values are not requirements, instead we are
         // just confirming the values that are mentioned in the comments.
@@ -5190,11 +5196,14 @@ PCODE ExecutionManager::getNextJumpStub(MethodDesc* pMD, PCODE target,
         RETURN(NULL);
     }
 
+    curBlockWriterHolder = ExecutableWriterHolder<JumpStubBlockHeader>(curBlock, sizeof(JumpStubBlockHeader) + ((size_t) (curBlock->m_used + 1) * BACK_TO_BACK_JUMP_ALLOCATE_SIZE));
+
+    jumpStubRW = (BYTE *) curBlockWriterHolder.GetRW() + sizeof(JumpStubBlockHeader) + ((size_t) curBlock->m_used * BACK_TO_BACK_JUMP_ALLOCATE_SIZE);
     jumpStub = (BYTE *) curBlock + sizeof(JumpStubBlockHeader) + ((size_t) curBlock->m_used * BACK_TO_BACK_JUMP_ALLOCATE_SIZE);
 
     _ASSERTE((loAddr <= jumpStub) && (jumpStub <= hiAddr));
 
-    curBlock->m_next = *ppHead;
+    curBlockWriterHolder.GetRW()->m_next = *ppHead;
     *ppHead = curBlock;
 
 DONE:
@@ -5206,7 +5215,7 @@ PCODE ExecutionManager::getNextJumpStub(MethodDesc* pMD, PCODE target,
     _ASSERTE(((UINT_PTR)jumpStub & 7) == 0);
 #endif
 
-    emitBackToBackJump(jumpStub, (void*) target);
+    emitBackToBackJump(jumpStub, jumpStubRW, (void*) target);
 
 #ifdef FEATURE_PERFMAP
     PerfMap::LogStubs(__FUNCTION__, "emitBackToBackJump", (PCODE)jumpStub, BACK_TO_BACK_JUMP_ALLOCATE_SIZE);
@@ -5223,7 +5232,7 @@ PCODE ExecutionManager::getNextJumpStub(MethodDesc* pMD, PCODE target,
 
     pJumpStubCache->m_Table.Add(entry);
 
-    curBlock->m_used++;    // record that we have used up one more jumpStub in the block
+    curBlockWriterHolder.GetRW()->m_used++;    // record that we have used up one more jumpStub in the block
 
     // Every time we create a new jumpStub thunk one of these counters is incremented
     if (isLCG)
diff --git a/src/coreclr/vm/comcallablewrapper.cpp b/src/coreclr/vm/comcallablewrapper.cpp
index 018cb91076e74f..dfee278b891537 100644
--- a/src/coreclr/vm/comcallablewrapper.cpp
+++ b/src/coreclr/vm/comcallablewrapper.cpp
@@ -553,10 +553,11 @@ extern "C" PCODE ComPreStubWorker(ComPrestubMethodFrame *pPFrame, UINT64 *pError
 
             UINT_PTR* ppofs = (UINT_PTR*)  (((BYTE*)pCMD) - COMMETHOD_CALL_PRESTUB_SIZE + COMMETHOD_CALL_PRESTUB_ADDRESS_OFFSET);
 
+            ExecutableWriterHolder<UINT_PTR> ppofsWriterHolder(ppofs, sizeof(UINT_PTR));
 #ifdef TARGET_X86
-            *ppofs = ((UINT_PTR)pStub - (size_t)pCMD);
+            *ppofsWriterHolder.GetRW() = ((UINT_PTR)pStub - (size_t)pCMD);
 #else
-            *ppofs = ((UINT_PTR)pStub);
+            *ppofsWriterHolder.GetRW() = ((UINT_PTR)pStub);
 #endif
 
             // Return the address of the prepad. The prepad will regenerate the hidden parameter and due
@@ -3213,6 +3214,7 @@ void ComMethodTable::LayOutClassMethodTable()
     unsigned cbAlloc = 0;
     NewExecutableHolder<BYTE>  pMDMemoryPtr = NULL;
     BYTE*  pMethodDescMemory = NULL;
+    size_t writeableOffset = 0;
     unsigned cbNumParentVirtualMethods = 0;
     unsigned cbTotalParentFields = 0;
     unsigned cbParentComMTSlots = 0;
@@ -3309,6 +3311,7 @@ void ComMethodTable::LayOutClassMethodTable()
 
     if (!m_pMT->HasGenericClassInstantiationInHierarchy())
     {
+        ExecutableWriterHolder<BYTE> methodDescMemoryWriteableHolder;
         //
         // Allocate method desc's for the rest of the slots.
         //
@@ -3317,12 +3320,15 @@ void ComMethodTable::LayOutClassMethodTable()
         if (cbAlloc > 0)
         {
             pMDMemoryPtr = (BYTE*) new (executable) BYTE[cbAlloc + sizeof(UINT_PTR)];
-            pMethodDescMemory = (BYTE*)pMDMemoryPtr;
+            pMethodDescMemory = pMDMemoryPtr;
+
+            methodDescMemoryWriteableHolder = ExecutableWriterHolder<BYTE>(pMethodDescMemory, cbAlloc + sizeof(UINT_PTR));
+            writeableOffset = methodDescMemoryWriteableHolder.GetRW() - pMethodDescMemory;
 
             // initialize the method desc memory to zero
-            FillMemory(pMethodDescMemory, cbAlloc, 0x0);
+            FillMemory(pMethodDescMemory + writeableOffset, cbAlloc, 0x0);
 
-            *(UINT_PTR *)pMethodDescMemory = cbMethodDescs; // fill in the size of the method desc's
+            *(UINT_PTR *)(pMethodDescMemory + writeableOffset) = cbMethodDescs; // fill in the size of the method desc's
 
             // move past the size
             pMethodDescMemory += sizeof(UINT_PTR);
@@ -3396,11 +3402,12 @@ void ComMethodTable::LayOutClassMethodTable()
                 {
                     // some bytes are reserved for CALL xxx before the method desc
                     ComCallMethodDesc* pNewMD = (ComCallMethodDesc *) (pMethodDescMemory + COMMETHOD_PREPAD);
+                    ComCallMethodDesc* pNewMDRW = (ComCallMethodDesc *) (pMethodDescMemory + writeableOffset + COMMETHOD_PREPAD);
                     NewCOMMethodDescs.Append(pNewMD);
 
-                    pNewMD->InitMethod(pMD, NULL);
+                    pNewMDRW->InitMethod(pMD, NULL);
 
-                    emitCOMStubCall(pNewMD, GetEEFuncEntryPoint(ComCallPreStub));
+                    emitCOMStubCall(pNewMD, pNewMDRW, GetEEFuncEntryPoint(ComCallPreStub));
 
                     FillInComVtableSlot(pComVtable, cbPrevSlots++, pNewMD);
 
@@ -3428,11 +3435,12 @@ void ComMethodTable::LayOutClassMethodTable()
                 {
                     // some bytes are reserved for CALL xxx before the method desc
                     ComCallMethodDesc* pNewMD = (ComCallMethodDesc *) (pMethodDescMemory + COMMETHOD_PREPAD);
+                    ComCallMethodDesc* pNewMDRW = (ComCallMethodDesc *) (pMethodDescMemory + writeableOffset + COMMETHOD_PREPAD);
                     NewCOMMethodDescs.Append(pNewMD);
 
-                    pNewMD->InitMethod(pMD, NULL);
+                    pNewMDRW->InitMethod(pMD, NULL);
 
-                    emitCOMStubCall(pNewMD, GetEEFuncEntryPoint(ComCallPreStub));
+                    emitCOMStubCall(pNewMD, pNewMDRW, GetEEFuncEntryPoint(ComCallPreStub));
 
                     FillInComVtableSlot(pComVtable, cbPrevSlots++, pNewMD);
 
@@ -3457,11 +3465,13 @@ void ComMethodTable::LayOutClassMethodTable()
                     {
                         // some bytes are reserved for CALL xxx before the method desc
                         ComCallMethodDesc* pNewMD = (ComCallMethodDesc *) (pMethodDescMemory + COMMETHOD_PREPAD);
+                        ComCallMethodDesc* pNewMDRW = (ComCallMethodDesc *) (pMethodDescMemory + writeableOffset + COMMETHOD_PREPAD);
+
                         NewCOMMethodDescs.Append(pNewMD);
 
-                        pNewMD->InitMethod(pMD, NULL);
+                        pNewMDRW->InitMethod(pMD, NULL);
 
-                        emitCOMStubCall(pNewMD, GetEEFuncEntryPoint(ComCallPreStub));
+                        emitCOMStubCall(pNewMD, pNewMDRW, GetEEFuncEntryPoint(ComCallPreStub));
 
                         FillInComVtableSlot(pComVtable, cbPrevSlots++, pNewMD);
 
@@ -3485,11 +3495,12 @@ void ComMethodTable::LayOutClassMethodTable()
                     // set up a getter method
                     // some bytes are reserved for CALL xxx before the method desc
                     ComCallMethodDesc* pNewMD = (ComCallMethodDesc *) (pMethodDescMemory + COMMETHOD_PREPAD);
+                    ComCallMethodDesc* pNewMDRW = (ComCallMethodDesc *) (pMethodDescMemory + writeableOffset + COMMETHOD_PREPAD);
                     NewCOMMethodDescs.Append(pNewMD);
 
-                    pNewMD->InitField(pFD, TRUE);
+                    pNewMDRW->InitField(pFD, TRUE);
 
-                    emitCOMStubCall(pNewMD, GetEEFuncEntryPoint(ComCallPreStub));
+                    emitCOMStubCall(pNewMD, pNewMDRW, GetEEFuncEntryPoint(ComCallPreStub));
 
                     FillInComVtableSlot(pComVtable, cbPrevSlots++, pNewMD);
 
@@ -3498,11 +3509,12 @@ void ComMethodTable::LayOutClassMethodTable()
                     // setup a setter method
                     // some bytes are reserved for CALL xxx before the method desc
                     pNewMD = (ComCallMethodDesc *) (pMethodDescMemory + COMMETHOD_PREPAD);
+                    pNewMDRW = (ComCallMethodDesc *) (pMethodDescMemory + writeableOffset + COMMETHOD_PREPAD);
                     NewCOMMethodDescs.Append(pNewMD);
 
-                    pNewMD->InitField(pFD, FALSE);
+                    pNewMDRW->InitField(pFD, FALSE);
 
-                    emitCOMStubCall(pNewMD, GetEEFuncEntryPoint(ComCallPreStub));
+                    emitCOMStubCall(pNewMD, pNewMDRW, GetEEFuncEntryPoint(ComCallPreStub));
 
                     FillInComVtableSlot(pComVtable, cbPrevSlots++, pNewMD);
 
@@ -3520,16 +3532,18 @@ void ComMethodTable::LayOutClassMethodTable()
         if (IsLayoutComplete())
             return;
 
+        ExecutableWriterHolder<ComMethodTable> comMTWriterHolder(this, sizeof(ComMethodTable) + cbTempVtable.Value());
+
         // IDispatch vtable follows the header
-        CopyMemory(this + 1, pDispVtable, cbTempVtable.Value());
+        CopyMemory(comMTWriterHolder.GetRW() + 1, pDispVtable, cbTempVtable.Value());
 
         // Set the layout complete flag and release the lock.
-        m_Flags |= enum_LayoutComplete;
+        comMTWriterHolder.GetRW()->m_Flags |= enum_LayoutComplete;
 
         // We've successfully laid out the class method table so we need to suppress the release of the
         // memory for the ComCallMethodDescs and store it inside the ComMethodTable so we can
         // release it when we clean up the ComMethodTable.
-        m_pMDescr = (BYTE*)pMDMemoryPtr;
+        comMTWriterHolder.GetRW()->m_pMDescr = (BYTE*)pMDMemoryPtr;
         pMDMemoryPtr.SuppressRelease();
         NewCOMMethodDescsHolder.SuppressRelease();
     }
@@ -3673,12 +3687,16 @@ BOOL ComMethodTable::LayOutInterfaceMethodTable(MethodTable* pClsMT)
         if (IsLayoutComplete())
             return TRUE;
 
+        ExecutableWriterHolder<ComMethodTable> comMTWriterHolder(this, sizeof(ComMethodTable) + cbTempVtable.Value());
+        size_t writeableOffset = (BYTE*)comMTWriterHolder.GetRW() - (BYTE*)this;
+
         // IUnk vtable follows the header
-        CopyMemory(this + 1, pUnkVtable, cbTempVtable.Value());
+        CopyMemory(comMTWriterHolder.GetRW() + 1, pUnkVtable, cbTempVtable.Value());
 
         // Finish by emitting stubs and initializing the slots
         pUnkVtable = (IUnkVtable *)(this + 1);
         pComVtable = ((SLOT*)pUnkVtable) + cbExtraSlots;
+        SLOT *pComVtableRW = (SLOT*)((BYTE*)pComVtable + writeableOffset);
 
         // Method descs are at the end of the vtable
         // m_cbSlots interfaces methods + IUnk methods
@@ -3687,25 +3705,27 @@ BOOL ComMethodTable::LayOutInterfaceMethodTable(MethodTable* pClsMT)
         for (i = 0; i < cbSlots; i++)
         {
             ComCallMethodDesc* pNewMD = (ComCallMethodDesc *) (pMethodDescMemory + COMMETHOD_PREPAD);
+            ComCallMethodDesc* pNewMDRW = (ComCallMethodDesc *) (pMethodDescMemory + writeableOffset + COMMETHOD_PREPAD);
+
             MethodDesc* pIntfMD  = m_pMT->GetMethodDescForSlot(i);
 
-            emitCOMStubCall(pNewMD, GetEEFuncEntryPoint(ComCallPreStub));
+            emitCOMStubCall(pNewMD, pNewMDRW, GetEEFuncEntryPoint(ComCallPreStub));
 
             UINT slotIndex = (pIntfMD->GetComSlot() - cbExtraSlots);
-            FillInComVtableSlot(pComVtable, slotIndex, pNewMD);
+            FillInComVtableSlot(pComVtableRW, slotIndex, pNewMD);
 
             pMethodDescMemory += (COMMETHOD_PREPAD + sizeof(ComCallMethodDesc));
         }
 
         // Set the layout complete flag and release the lock.
-        m_Flags |= enum_LayoutComplete;
+        comMTWriterHolder.GetRW()->m_Flags |= enum_LayoutComplete;
         NewCOMMethodDescsHolder.SuppressRelease();
     }
 
 #ifdef PROFILING_SUPPORTED
     // Notify profiler of the CCW, so it can avoid double-counting.
     {
-        BEGIN_PIN_PROFILER(CORProfilerTrackCCW());
+        BEGIN_PROFILER_CALLBACK(CORProfilerTrackCCW());
 #if defined(_DEBUG)
         WCHAR rIID[40]; // {00000000-0000-0000-0000-000000000000}
         GuidToLPWSTR(m_IID, rIID, lengthof(rIID));
@@ -3715,11 +3735,11 @@ BOOL ComMethodTable::LayOutInterfaceMethodTable(MethodTable* pClsMT)
         LOG((LF_CORPROF, LL_INFO100, "COMClassicVTableCreated Class:%#x, IID:{%08x-...}, vTbl:%#08x\n",
              pItfClass, m_IID.Data1, pUnkVtable));
 #endif
-        g_profControlBlock.pProfInterface->COMClassicVTableCreated((ClassID) TypeHandle(pItfClass).AsPtr(),
+        (&g_profControlBlock)->COMClassicVTableCreated((ClassID) TypeHandle(pItfClass).AsPtr(),
                                                                    m_IID,
                                                                    pUnkVtable,
                                                                    m_cbSlots+cbExtraSlots);
-        END_PIN_PROFILER();
+        END_PROFILER_CALLBACK();
    }
 #endif // PROFILING_SUPPORTED
 
@@ -3812,8 +3832,9 @@ DispatchInfo *ComMethodTable::GetDispatchInfo()
         // Synchronize the DispatchInfo with the actual object.
         pDispInfo->SynchWithManagedView();
 
+        ExecutableWriterHolder<ComMethodTable> comMTWriterHolder(this, sizeof(ComMethodTable));
         // Swap the lock into the class member in a thread safe manner.
-        if (NULL == FastInterlockCompareExchangePointer(&m_pDispatchInfo, pDispInfo.GetValue(), NULL))
+        if (NULL == FastInterlockCompareExchangePointer(&comMTWriterHolder.GetRW()->m_pDispatchInfo, pDispInfo.GetValue(), NULL))
             pDispInfo.SuppressRelease();
 
     }
@@ -4476,29 +4497,31 @@ ComMethodTable* ComCallWrapperTemplate::CreateComMethodTableForClass(MethodTable
 
     _ASSERTE(!cbNewSlots.IsOverflow() && !cbTotalSlots.IsOverflow() && !cbVtable.IsOverflow());
 
+    ExecutableWriterHolder<ComMethodTable> comMTWriterHolder(pComMT, cbToAlloc.Value());
+    ComMethodTable* pComMTRW = comMTWriterHolder.GetRW();
 
     // set up the header
-    pComMT->m_ptReserved = (SLOT)(size_t)0xDEADC0FF;          // reserved
-    pComMT->m_pMT  = pClassMT; // pointer to the class method table
-    pComMT->m_cbRefCount = 0;
-    pComMT->m_pMDescr = NULL;
-    pComMT->m_pITypeInfo = NULL;
-    pComMT->m_pDispatchInfo = NULL;
-    pComMT->m_cbSlots = cbTotalSlots.Value(); // number of slots not counting IDisp methods.
-    pComMT->m_IID = GUID_NULL;
+    pComMTRW->m_ptReserved = (SLOT)(size_t)0xDEADC0FF;          // reserved
+    pComMTRW->m_pMT  = pClassMT; // pointer to the class method table
+    pComMTRW->m_cbRefCount = 0;
+    pComMTRW->m_pMDescr = NULL;
+    pComMTRW->m_pITypeInfo = NULL;
+    pComMTRW->m_pDispatchInfo = NULL;
+    pComMTRW->m_cbSlots = cbTotalSlots.Value(); // number of slots not counting IDisp methods.
+    pComMTRW->m_IID = GUID_NULL;
 
 
     // Set the flags.
-    pComMT->m_Flags = enum_ClassVtableMask | ClassItfType;
+    pComMTRW->m_Flags = enum_ClassVtableMask | ClassItfType;
 
     // Determine if the interface is visible from COM.
     if (IsTypeVisibleFromCom(TypeHandle(pComMT->m_pMT)))
-        pComMT->m_Flags |= enum_ComVisible;
+        pComMTRW->m_Flags |= enum_ComVisible;
 
 #if _DEBUG
     {
         // In debug set all the vtable slots to 0xDEADCA11.
-        SLOT *pComVTable = (SLOT*)(pComMT + 1);
+        SLOT *pComVTable = (SLOT*)(pComMTRW + 1);
         for (unsigned iComSlots = 0; iComSlots < cbTotalSlots.Value() + cbExtraSlots; iComSlots++)
             *(pComVTable + iComSlots) = (SLOT)(size_t)0xDEADCA11;
     }
@@ -4552,34 +4575,37 @@ ComMethodTable* ComCallWrapperTemplate::CreateComMethodTableForInterface(MethodT
 
     _ASSERTE(!cbVtable.IsOverflow() && !cbMethDescs.IsOverflow());
 
+    ExecutableWriterHolder<ComMethodTable> comMTWriterHolder(pComMT, cbToAlloc.Value());
+    ComMethodTable* pComMTRW = comMTWriterHolder.GetRW();
+
     // set up the header
-    pComMT->m_ptReserved = (SLOT)(size_t)0xDEADC0FF;          // reserved
-    pComMT->m_pMT  = pInterfaceMT; // pointer to the interface's method table
-    pComMT->m_cbSlots = cbComSlots; // number of slots not counting IUnk
-    pComMT->m_cbRefCount = 0;
-    pComMT->m_pMDescr = NULL;
-    pComMT->m_pITypeInfo = NULL;
-    pComMT->m_pDispatchInfo = NULL;
+    pComMTRW->m_ptReserved = (SLOT)(size_t)0xDEADC0FF;          // reserved
+    pComMTRW->m_pMT  = pInterfaceMT; // pointer to the interface's method table
+    pComMTRW->m_cbSlots = cbComSlots; // number of slots not counting IUnk
+    pComMTRW->m_cbRefCount = 0;
+    pComMTRW->m_pMDescr = NULL;
+    pComMTRW->m_pITypeInfo = NULL;
+    pComMTRW->m_pDispatchInfo = NULL;
 
     // Set the flags.
-    pComMT->m_Flags = ItfType;
+    pComMTRW->m_Flags = ItfType;
 
     // Set the IID of the interface.
-    pInterfaceMT->GetGuid(&pComMT->m_IID, TRUE);
-    pComMT->m_Flags |= enum_GuidGenerated;
+    pInterfaceMT->GetGuid(&pComMTRW->m_IID, TRUE);
+    pComMTRW->m_Flags |= enum_GuidGenerated;
 
     // Determine if the interface is visible from COM.
     if (IsTypeVisibleFromCom(TypeHandle(pComMT->m_pMT)))
-        pComMT->m_Flags |= enum_ComVisible;
+        pComMTRW->m_Flags |= enum_ComVisible;
 
     // Determine if the interface is a COM imported class interface.
     if (pItfClass->GetClass()->IsComClassInterface())
-        pComMT->m_Flags |= enum_ComClassItf;
+        pComMTRW->m_Flags |= enum_ComClassItf;
 
 #ifdef _DEBUG
     {
         // In debug set all the vtable slots to 0xDEADCA11.
-        SLOT *pComVTable = (SLOT*)(pComMT + 1);
+        SLOT *pComVTable = (SLOT*)(pComMTRW + 1);
         for (unsigned iComSlots = 0; iComSlots < cbComSlots + cbExtraSlots; iComSlots++)
             *(pComVTable + iComSlots) = (SLOT)(size_t)0xDEADCA11;
     }
@@ -4612,36 +4638,38 @@ ComMethodTable* ComCallWrapperTemplate::CreateComMethodTableForBasic(MethodTable
     unsigned cbToAlloc   = sizeof(ComMethodTable) + cbVtable;
 
     NewExecutableHolder<ComMethodTable> pComMT = (ComMethodTable*) new (executable) BYTE[cbToAlloc];
+    ExecutableWriterHolder<ComMethodTable> comMTWriterHolder(pComMT, cbToAlloc);
+    ComMethodTable* pComMTRW = comMTWriterHolder.GetRW();
 
     // set up the header
-    pComMT->m_ptReserved = (SLOT)(size_t)0xDEADC0FF;
-    pComMT->m_pMT  = pMT;
-    pComMT->m_cbSlots = 0;  // number of slots not counting IUnk
-    pComMT->m_cbRefCount = 0;
-    pComMT->m_pMDescr = NULL;
-    pComMT->m_pITypeInfo = NULL;
-    pComMT->m_pDispatchInfo = NULL;
+    pComMTRW->m_ptReserved = (SLOT)(size_t)0xDEADC0FF;
+    pComMTRW->m_pMT  = pMT;
+    pComMTRW->m_cbSlots = 0;  // number of slots not counting IUnk
+    pComMTRW->m_cbRefCount = 0;
+    pComMTRW->m_pMDescr = NULL;
+    pComMTRW->m_pITypeInfo = NULL;
+    pComMTRW->m_pDispatchInfo = NULL;
 
     // Initialize the flags.
-    pComMT->m_Flags =  enum_IsBasic;
-    pComMT->m_Flags |= enum_ClassVtableMask | ClassItfType;
+    pComMTRW->m_Flags =  enum_IsBasic;
+    pComMTRW->m_Flags |= enum_ClassVtableMask | ClassItfType;
 
     // Set the IID of the interface.
-    pComMT->m_IID = IID_IUnknown;
-    pComMT->m_Flags |= enum_GuidGenerated;
+    pComMTRW->m_IID = IID_IUnknown;
+    pComMTRW->m_Flags |= enum_GuidGenerated;
 
     // Determine if the interface is visible from COM.
     if (IsTypeVisibleFromCom(TypeHandle(pComMT->m_pMT)))
-        pComMT->m_Flags |= enum_ComVisible;
+        pComMTRW->m_Flags |= enum_ComVisible;
 
     // Determine if the interface is a COM imported class interface.
     if (pMT->GetClass()->IsComClassInterface())
-        pComMT->m_Flags |= enum_ComClassItf;
+        pComMTRW->m_Flags |= enum_ComClassItf;
 
 #ifdef _DEBUG_0xDEADCA11
     {
         // In debug set all the vtable slots to 0xDEADCA11.
-        SLOT *pComVTable = (SLOT*)(pComMT + 1);
+        SLOT *pComVTable = (SLOT*)(pComMTRW + 1);
         for (unsigned iComSlots = 0; iComSlots < DEBUG_AssertSlots + cbExtraSlots; iComSlots++)
             *(pComVTable + iComSlots) = (SLOT)(size_t)0xDEADCA11;
     }
@@ -4830,7 +4858,7 @@ ComCallWrapperTemplate* ComCallWrapperTemplate::CreateTemplate(TypeHandle thClas
         // Notify profiler of the CCW, so it can avoid double-counting.
         if (pTemplate->SupportsIClassX())
         {
-            BEGIN_PIN_PROFILER(CORProfilerTrackCCW());
+            BEGIN_PROFILER_CALLBACK(CORProfilerTrackCCW());
             // When under the profiler, we'll eagerly generate the IClassX CMT.
             pTemplate->GetClassComMT();
 
@@ -4852,11 +4880,11 @@ ComCallWrapperTemplate* ComCallWrapperTemplate::CreateTemplate(TypeHandle thClas
             LOG((LF_CORPROF, LL_INFO100, "COMClassicVTableCreated TypeHandle:%#x, IID:{%08x-...}, vTbl:%#08x\n",
                  thClass.AsPtr(), IClassXIID.Data1, pComVtable));
 #endif
-            g_profControlBlock.pProfInterface->COMClassicVTableCreated(
+            (&g_profControlBlock)->COMClassicVTableCreated(
                 (ClassID) thClass.AsPtr(), IClassXIID, pComVtable,
                 pTemplate->m_pClassComMT->m_cbSlots +
                     ComMethodTable::GetNumExtraSlots(pTemplate->m_pClassComMT->GetInterfaceType()));
-            END_PIN_PROFILER();
+            END_PROFILER_CALLBACK();
         }
 #endif // PROFILING_SUPPORTED
         RETURN pTemplate;
diff --git a/src/coreclr/vm/comcallablewrapper.h b/src/coreclr/vm/comcallablewrapper.h
index 4d3335e76fee53..2581ddf832fd5d 100644
--- a/src/coreclr/vm/comcallablewrapper.h
+++ b/src/coreclr/vm/comcallablewrapper.h
@@ -503,7 +503,8 @@ struct ComMethodTable
     {
         LIMITED_METHOD_CONTRACT;
 
-        return InterlockedIncrement(&m_cbRefCount);
+        ExecutableWriterHolder<ComMethodTable> comMTWriterHolder(this, sizeof(ComMethodTable));
+        return InterlockedIncrement(&comMTWriterHolder.GetRW()->m_cbRefCount);
     }
 
     LONG Release()
@@ -517,9 +518,10 @@ struct ComMethodTable
         }
         CONTRACTL_END;
 
+        ExecutableWriterHolder<ComMethodTable> comMTWriterHolder(this, sizeof(ComMethodTable));
         // use a different var here becuase cleanup will delete the object
         // so can no longer make member refs
-        LONG cbRef = InterlockedDecrement(&m_cbRefCount);
+        LONG cbRef = InterlockedDecrement(&comMTWriterHolder.GetRW()->m_cbRefCount);
         if (cbRef == 0)
             Cleanup();
 
@@ -759,8 +761,9 @@ struct ComMethodTable
         // Generate the IClassX IID if it hasn't been generated yet.
         if (!(m_Flags & enum_GuidGenerated))
         {
-            GenerateClassItfGuid(TypeHandle(m_pMT), &m_IID);
-            m_Flags |= enum_GuidGenerated;
+            ExecutableWriterHolder<ComMethodTable> comMTWriterHolder(this, sizeof(ComMethodTable));
+            GenerateClassItfGuid(TypeHandle(m_pMT), &comMTWriterHolder.GetRW()->m_IID);
+            comMTWriterHolder.GetRW()->m_Flags |= enum_GuidGenerated;
         }
 
         return m_IID;
diff --git a/src/coreclr/vm/comdelegate.cpp b/src/coreclr/vm/comdelegate.cpp
index a500c76603f188..b6c17260a1302b 100644
--- a/src/coreclr/vm/comdelegate.cpp
+++ b/src/coreclr/vm/comdelegate.cpp
@@ -147,8 +147,11 @@ class ShuffleIterator
     }
 
     // Get next offset to shuffle. There has to be at least one offset left.
-    // For register arguments it returns regNum | ShuffleEntry::REGMASK | ShuffleEntry::FPREGMASK.
-    // For stack arguments it returns stack offset in bytes with negative sign.
+    // It returns an offset encoded properly for a ShuffleEntry offset.
+    // - For floating register arguments it returns regNum | ShuffleEntry::REGMASK | ShuffleEntry::FPREGMASK.
+    // - For register arguments it returns regNum | ShuffleEntry::REGMASK.
+    // - For stack arguments it returns stack offset index in stack slots for most architectures. For macOS-arm64,
+    //     it returns an encoded stack offset, see below.
     int GetNextOfs()
     {
         int index;
@@ -189,6 +192,8 @@ class ShuffleIterator
         if (m_currentByteStackIndex < m_argLocDesc->m_byteStackSize)
         {
             const unsigned byteIndex = m_argLocDesc->m_byteStackIndex + m_currentByteStackIndex;
+
+#if !defined(TARGET_OSX) || !defined(TARGET_ARM64)
             index = byteIndex / TARGET_POINTER_SIZE;
             m_currentByteStackIndex += TARGET_POINTER_SIZE;
 
@@ -198,7 +203,68 @@ class ShuffleIterator
                 COMPlusThrow(kNotSupportedException);
             }
 
-            return -(int)byteIndex;
+            // Only Apple Silicon ABI currently supports unaligned stack argument shuffling
+            _ASSERTE(byteIndex == unsigned(index * TARGET_POINTER_SIZE));
+            return index;
+#else
+            // Tha Apple Silicon ABI does not consume an entire stack slot for every argument
+            // Arguments smaller than TARGET_POINTER_SIZE are always aligned to their argument size
+            // But may not begin at the beginning of a stack slot
+            //
+            // The argument location description has been updated to describe the stack offest and
+            // size in bytes.  We will use it as our source of truth.
+            //
+            // The ShuffleEntries will be implemented by the Arm64 StubLinkerCPU::EmitLoadStoreRegImm
+            // using the 12-bit scaled immediate stack offset. The load/stores can be implemented as 1/2/4/8
+            // bytes each (natural binary sizes).
+            //
+            // Each offset is encode as a log2 size and a 12-bit unsigned scaled offset.
+            // We only emit offsets of these natural binary sizes
+            //
+            // We choose the offset based on the ABI stack alignment requirements
+            // - Small integers are shuffled based on their size
+            // - HFA are shuffled based on their element size
+            // - Others are shuffled in full 8 byte chunks.
+            int bytesRemaining = m_argLocDesc->m_byteStackSize - m_currentByteStackIndex;
+            int log2Size = 3;
+
+            // If isHFA, shuffle based on field size
+            // otherwise shuffle based on stack size
+            switch(m_argLocDesc->m_hfaFieldSize ? m_argLocDesc->m_hfaFieldSize : m_argLocDesc->m_byteStackSize)
+            {
+                case 1:
+                    log2Size = 0;
+                    break;
+                case 2:
+                    log2Size = 1;
+                    break;
+                case 4:
+                    log2Size = 2;
+                    break;
+                case 3: // Unsupported Size
+                case 5: // Unsupported Size
+                case 6: // Unsupported Size
+                case 7: // Unsupported Size
+                    _ASSERTE(false);
+                    break;
+                default: // Should be a multiple of 8 (TARGET_POINTER_SIZE)
+                    _ASSERTE(bytesRemaining >= TARGET_POINTER_SIZE);
+                    break;
+            }
+
+            m_currentByteStackIndex += (1 << log2Size);
+
+            // Delegates cannot handle overly large argument stacks due to shuffle entry encoding limitations.
+            // Arm64 current implementation only supports 12 bit unsigned scaled offset
+            if ((byteIndex >> log2Size) > 0xfff)
+            {
+                COMPlusThrow(kNotSupportedException);
+            }
+
+            _ASSERTE((byteIndex & ((1 << log2Size) - 1)) == 0);
+
+            return (byteIndex >> log2Size) | (log2Size << 12);
+#endif
         }
 
         // There are no more offsets to get, the caller should not have called us
@@ -274,31 +340,8 @@ BOOL AddNextShuffleEntryToArray(ArgLocDesc sArgSrc, ArgLocDesc sArgDst, SArray<S
         // different).
         if (srcOffset != dstOffset)
         {
-            if (srcOffset <= 0)
-            {
-                // It was a stack byte offset.
-                const unsigned srcStackByteOffset = -srcOffset;
-                _ASSERT(((srcStackByteOffset % TARGET_POINTER_SIZE) == 0) && "NYI: does not support shuffling of such args");
-                entry.srcofs = (UINT16)(srcStackByteOffset / TARGET_POINTER_SIZE);
-            }
-            else
-            {
-                _ASSERT((srcOffset & ShuffleEntry::REGMASK) != 0);
-                entry.srcofs = (UINT16)srcOffset;
-            }
-
-            if (dstOffset <= 0)
-            {
-                // It was a stack byte offset.
-                const unsigned dstStackByteOffset = -dstOffset;
-                _ASSERT((dstStackByteOffset % TARGET_POINTER_SIZE) == 0 && "NYI: does not support shuffling of such args");
-                entry.dstofs = (UINT16)(dstStackByteOffset / TARGET_POINTER_SIZE);
-            }
-            else
-            {
-                _ASSERT((dstOffset & ShuffleEntry::REGMASK) != 0);
-                entry.dstofs = (UINT16)dstOffset;
-            }
+            entry.srcofs = (UINT16)srcOffset;
+            entry.dstofs = (UINT16)dstOffset;
 
             if (shuffleType == ShuffleComputationType::InstantiatingStub)
             {
@@ -657,7 +700,7 @@ VOID GenerateShuffleArray(MethodDesc* pInvoke, MethodDesc *pTargetMeth, SArray<S
     }
 
     entry.srcofs = ShuffleEntry::SENTINEL;
-    entry.dstofs = static_cast<UINT16>(stackSizeDelta);
+    entry.stacksizedelta = static_cast<UINT16>(stackSizeDelta);
     pShuffleEntryArray->Append(entry);
 
 #else
@@ -777,7 +820,8 @@ Stub* COMDelegate::SetupShuffleThunk(MethodTable * pDelMT, MethodDesc *pTargetMe
     {
         if (FastInterlockCompareExchangePointer(&pClass->m_pInstRetBuffCallStub, pShuffleThunk, NULL ) != NULL)
         {
-            pShuffleThunk->DecRef();
+            ExecutableWriterHolder<Stub> shuffleThunkWriterHolder(pShuffleThunk, sizeof(Stub));
+            shuffleThunkWriterHolder.GetRW()->DecRef();
             pShuffleThunk = pClass->m_pInstRetBuffCallStub;
         }
     }
@@ -785,7 +829,8 @@ Stub* COMDelegate::SetupShuffleThunk(MethodTable * pDelMT, MethodDesc *pTargetMe
     {
         if (FastInterlockCompareExchangePointer(&pClass->m_pStaticCallStub, pShuffleThunk, NULL ) != NULL)
         {
-            pShuffleThunk->DecRef();
+            ExecutableWriterHolder<Stub> shuffleThunkWriterHolder(pShuffleThunk, sizeof(Stub));
+            shuffleThunkWriterHolder.GetRW()->DecRef();
             pShuffleThunk = pClass->m_pStaticCallStub;
         }
     }
@@ -1001,10 +1046,6 @@ FCIMPL5(FC_BOOL_RET, COMDelegate::BindToMethodInfo, Object* refThisUNSAFE, Objec
                                             flags,
                                             &fIsOpenDelegate))
     {
-#if defined(HOST_OSX) && defined(HOST_ARM64)
-        auto jitWriteEnableHolder = PAL_JITWriteEnable(true);
-#endif // defined(HOST_OSX) && defined(HOST_ARM64)
-
         // Initialize the delegate to point to the target method.
         BindToMethod(&gc.refThis,
                      &gc.refFirstArg,
@@ -1213,7 +1254,9 @@ LPVOID COMDelegate::ConvertToCallback(OBJECTREF pDelegateObj)
                 GCX_PREEMP();
 
                 pUMThunkMarshInfo = new UMThunkMarshInfo();
-                pUMThunkMarshInfo->LoadTimeInit(pInvokeMeth);
+
+                ExecutableWriterHolder<UMThunkMarshInfo> uMThunkMarshInfoWriterHolder(pUMThunkMarshInfo, sizeof(UMThunkMarshInfo));
+                uMThunkMarshInfoWriterHolder.GetRW()->LoadTimeInit(pInvokeMeth);
 
                 g_IBCLogger.LogEEClassCOWTableAccess(pMT);
                 if (FastInterlockCompareExchangePointer(&(pClass->m_pUMThunkMarshInfo),
@@ -1239,8 +1282,11 @@ LPVOID COMDelegate::ConvertToCallback(OBJECTREF pDelegateObj)
             // This target should not ever be used. We are storing it in the thunk for better diagnostics of "call on collected delegate" crashes.
             PCODE pManagedTargetForDiagnostics = (pDelegate->GetMethodPtrAux() != NULL) ? pDelegate->GetMethodPtrAux() : pDelegate->GetMethodPtr();
 
+            ExecutableWriterHolder<UMEntryThunk> uMEntryThunkWriterHolder(pUMEntryThunk, sizeof(UMEntryThunk));
+
             // MethodDesc is passed in for profiling to know the method desc of target
-            pUMEntryThunk->LoadTimeInit(
+            uMEntryThunkWriterHolder.GetRW()->LoadTimeInit(
+                pUMEntryThunk,
                 pManagedTargetForDiagnostics,
                 objhnd,
                 pUMThunkMarshInfo, pInvokeMeth);
@@ -1572,10 +1618,6 @@ FCIMPL3(void, COMDelegate::DelegateConstruct, Object* refThisUNSAFE, Object* tar
     // try to catch the easy garbage.
     _ASSERTE(isMemoryReadable(method, 1));
 
-#if defined(HOST_OSX) && defined(HOST_ARM64)
-    auto jitWriteEnableHolder = PAL_JITWriteEnable(true);
-#endif // defined(HOST_OSX) && defined(HOST_ARM64)
-
     MethodTable *pMTTarg = NULL;
 
     if (gc.target != NULL)
@@ -1887,7 +1929,8 @@ PCODE COMDelegate::TheDelegateInvokeStub()
         if (InterlockedCompareExchangeT<PCODE>(&s_pInvokeStub, pCandidate->GetEntryPoint(), NULL) != NULL)
         {
             // if we are here someone managed to set the stub before us so we release the current
-            pCandidate->DecRef();
+            ExecutableWriterHolder<Stub> candidateWriterHolder(pCandidate, sizeof(Stub));
+            candidateWriterHolder.GetRW()->DecRef();
         }
     }
 
@@ -2306,7 +2349,9 @@ FCIMPL1(PCODE, COMDelegate::GetMulticastInvoke, Object* refThisIn)
             Stub *pCandidate = sl.Link(SystemDomain::GetGlobalLoaderAllocator()->GetStubHeap(), NEWSTUB_FL_MULTICAST);
 
             Stub *pWinner = m_pMulticastStubCache->AttemptToSetStub(hash,pCandidate);
-            pCandidate->DecRef();
+            ExecutableWriterHolder<Stub> candidateWriterHolder(pCandidate, sizeof(Stub));
+            candidateWriterHolder.GetRW()->DecRef();
+
             if (!pWinner)
                 COMPlusThrowOM();
 
diff --git a/src/coreclr/vm/comdelegate.h b/src/coreclr/vm/comdelegate.h
index b9ddb37d0b8b1e..87997fd20cfbc2 100644
--- a/src/coreclr/vm/comdelegate.h
+++ b/src/coreclr/vm/comdelegate.h
@@ -202,7 +202,7 @@ struct ShuffleEntry
 
     union {
         UINT16    dstofs;           //if srcofs != SENTINEL
-        UINT16    stacksizedelta;   //if dstofs == SENTINEL, difference in stack size between virtual and static sigs
+        UINT16    stacksizedelta;   //if srcofs == SENTINEL, difference in stack size between virtual and static sigs
     };
 };
 
diff --git a/src/coreclr/vm/cominterfacemarshaler.cpp b/src/coreclr/vm/cominterfacemarshaler.cpp
index a04ddc991ed9c1..13b29066d8c13b 100644
--- a/src/coreclr/vm/cominterfacemarshaler.cpp
+++ b/src/coreclr/vm/cominterfacemarshaler.cpp
@@ -400,6 +400,7 @@ VOID COMInterfaceMarshaler::InitializeObjectClass(IUnknown *pIncomingIP)
         // This was previously provided by IProvideClassinfo. If the type handle isn't
         // set fallback to the opaque __ComObject type.
         m_typeHandle = TypeHandle(g_pBaseCOMObject);
+        _ASSERTE(!m_typeHandle.IsNull());
     }
 }
 
diff --git a/src/coreclr/vm/common.h b/src/coreclr/vm/common.h
index 1951003113ec90..f0bade34506c61 100644
--- a/src/coreclr/vm/common.h
+++ b/src/coreclr/vm/common.h
@@ -367,6 +367,7 @@ inline void ClrRestoreNonvolatileContext(PCONTEXT ContextRecord)
 #include "pefile.inl"
 #include "excep.h"
 #include "method.hpp"
+#include "field.h"
 #include "callingconvention.h"
 #include "frames.h"
 #include "qcall.h"
diff --git a/src/coreclr/vm/comsynchronizable.cpp b/src/coreclr/vm/comsynchronizable.cpp
index bc79ffcd8fa9f8..39f00d06741933 100644
--- a/src/coreclr/vm/comsynchronizable.cpp
+++ b/src/coreclr/vm/comsynchronizable.cpp
@@ -1009,16 +1009,16 @@ void QCALLTYPE ThreadNative::InformThreadNameChange(QCall::ThreadHandle thread,
 
 #ifdef PROFILING_SUPPORTED
     {
-        BEGIN_PIN_PROFILER(CORProfilerTrackThreads());
+        BEGIN_PROFILER_CALLBACK(CORProfilerTrackThreads());
         if (name == NULL)
         {
-            g_profControlBlock.pProfInterface->ThreadNameChanged((ThreadID)pThread, 0, NULL);
+            (&g_profControlBlock)->ThreadNameChanged((ThreadID)pThread, 0, NULL);
         }
         else
         {
-            g_profControlBlock.pProfInterface->ThreadNameChanged((ThreadID)pThread, len, (WCHAR*)name);
+            (&g_profControlBlock)->ThreadNameChanged((ThreadID)pThread, len, (WCHAR*)name);
         }
-        END_PIN_PROFILER();
+        END_PROFILER_CALLBACK();
     }
 #endif // PROFILING_SUPPORTED
 
diff --git a/src/coreclr/vm/comtoclrcall.cpp b/src/coreclr/vm/comtoclrcall.cpp
index 30c5dc3bd9dd57..008df2efa13d0c 100644
--- a/src/coreclr/vm/comtoclrcall.cpp
+++ b/src/coreclr/vm/comtoclrcall.cpp
@@ -788,14 +788,17 @@ PCODE ComCallMethodDesc::CreateCOMToCLRStub(DWORD dwStubFlags, MethodDesc **ppSt
     // make sure our native stack computation in code:ComCallMethodDesc.InitNativeInfo is right
     _ASSERTE(HasMarshalError() || !pStubMD->IsILStub() || pStubMD->AsDynamicMethodDesc()->GetNativeStackArgSize() == m_StackBytes);
 #else // TARGET_X86
+
+    ExecutableWriterHolder<ComCallMethodDesc> comCallMDWriterHolder(this, sizeof(ComCallMethodDesc));
+
     if (pStubMD->IsILStub())
     {
-        m_StackBytes = pStubMD->AsDynamicMethodDesc()->GetNativeStackArgSize();
+        comCallMDWriterHolder.GetRW()->m_StackBytes = pStubMD->AsDynamicMethodDesc()->GetNativeStackArgSize();
         _ASSERTE(m_StackBytes == pStubMD->SizeOfArgStack());
     }
     else
     {
-        m_StackBytes = pStubMD->SizeOfArgStack();
+        comCallMDWriterHolder.GetRW()->m_StackBytes = pStubMD->SizeOfArgStack();
     }
 #endif // TARGET_X86
 
@@ -882,10 +885,11 @@ void ComCallMethodDesc::InitRuntimeNativeInfo(MethodDesc *pStubMD)
     }
 
     // write the computed data into this ComCallMethodDesc
-    m_dwSlotInfo = (wSourceSlotEDX | (wStubStackSlotCount << 16));
+    ExecutableWriterHolder<ComCallMethodDesc> comCallMDWriterHolder(this, sizeof(ComCallMethodDesc));
+    comCallMDWriterHolder.GetRW()->m_dwSlotInfo = (wSourceSlotEDX | (wStubStackSlotCount << 16));
     if (pwStubStackSlotOffsets != NULL)
     {
-        if (FastInterlockCompareExchangePointer(&m_pwStubStackSlotOffsets, pwStubStackSlotOffsets.GetValue(), NULL) == NULL)
+        if (FastInterlockCompareExchangePointer(&comCallMDWriterHolder.GetRW()->m_pwStubStackSlotOffsets, pwStubStackSlotOffsets.GetValue(), NULL) == NULL)
         {
             pwStubStackSlotOffsets.SuppressRelease();
         }
@@ -895,22 +899,23 @@ void ComCallMethodDesc::InitRuntimeNativeInfo(MethodDesc *pStubMD)
     // Fill in return thunk with proper native arg size.
     //
 
-    BYTE *pMethodDescMemory = ((BYTE*)this) + GetOffsetOfReturnThunk();
+    BYTE *pMethodDescMemoryRX = ((BYTE*)this) + GetOffsetOfReturnThunk();
+    BYTE *pMethodDescMemoryRW = ((BYTE*)comCallMDWriterHolder.GetRW()) + GetOffsetOfReturnThunk();
 
     //
     // encodes a "ret nativeArgSize" to return and
     // pop off the args off the stack
     //
-    pMethodDescMemory[0] = 0xc2;
+    pMethodDescMemoryRW[0] = 0xc2;
 
     UINT16 nativeArgSize = GetNumStackBytes();
 
     if (!(nativeArgSize < 0x7fff))
         COMPlusThrow(kTypeLoadException, IDS_EE_SIGTOOCOMPLEX);
 
-    *(SHORT *)&pMethodDescMemory[1] = nativeArgSize;
+    *(SHORT *)&pMethodDescMemoryRW[1] = nativeArgSize;
 
-    FlushInstructionCache(GetCurrentProcess(), pMethodDescMemory, sizeof pMethodDescMemory[0] + sizeof(SHORT));
+    FlushInstructionCache(GetCurrentProcess(), pMethodDescMemoryRX, sizeof pMethodDescMemoryRX[0] + sizeof(SHORT));
 #endif // TARGET_X86
 }
 #endif //CROSSGEN_COMPILE
@@ -1013,7 +1018,6 @@ void ComCallMethodDesc::InitNativeInfo()
                 CONSISTENCY_CHECK_MSGF(false, ("BreakOnComToClrNativeInfoInit: '%s' ", szDebugName));
 #endif // _DEBUG
 
-#ifdef TARGET_X86
             MetaSig fsig(pFD);
             fsig.NextArg();
 
@@ -1030,6 +1034,10 @@ void ComCallMethodDesc::InitNativeInfo()
 #endif
                              );
 
+            if (info.GetMarshalType() == MarshalInfo::MARSHAL_TYPE_UNKNOWN)
+                info.ThrowTypeLoadExceptionForInvalidFieldMarshal(pFD, info.GetErrorResourceId());
+
+#ifdef TARGET_X86
             if (IsFieldGetter())
             {
                 // getter takes 'this' and the output argument by-ref
@@ -1433,7 +1441,8 @@ PCODE ComCall::GetComCallMethodStub(ComCallMethodDesc *pCMD)
     // Compute stack layout and prepare the return thunk on x86
     pCMD->InitRuntimeNativeInfo(pStubMD);
 
-    InterlockedCompareExchangeT<PCODE>(pCMD->GetAddrOfILStubField(), pTempILStub, NULL);
+    ExecutableWriterHolder<PCODE> addrOfILStubWriterHolder(pCMD->GetAddrOfILStubField(), sizeof(PCODE));
+    InterlockedCompareExchangeT<PCODE>(addrOfILStubWriterHolder.GetRW(), pTempILStub, NULL);
 
 #ifdef TARGET_X86
     // Finally, we need to build a stub that represents the entire call.  This
diff --git a/src/coreclr/vm/crossgen/CMakeLists.txt b/src/coreclr/vm/crossgen/CMakeLists.txt
deleted file mode 100644
index deb6d49e176b56..00000000000000
--- a/src/coreclr/vm/crossgen/CMakeLists.txt
+++ /dev/null
@@ -1,279 +0,0 @@
-set(VM_CROSSGEN_SOURCES
-  ../appdomain.cpp
-  ../array.cpp
-  ../assembly.cpp
-  ../assemblyloadcontext.cpp
-  ../assemblyspec.cpp
-  ../baseassemblyspec.cpp
-  ../binder.cpp
-  ../bundle.cpp
-  ../callconvbuilder.cpp
-  ../castcache.cpp
-  ../ceeload.cpp
-  ../ceemain.cpp
-  ../class.cpp
-  ../classhash.cpp
-  ../classlayoutinfo.cpp
-  ../clrex.cpp
-  ../clsload.cpp
-  ../codeman.cpp
-  ../codeversion.cpp
-  ../comdelegate.cpp
-  ../compile.cpp
-  ../contractimpl.cpp
-  ../coreassemblyspec.cpp
-  ../corebindresult.cpp
-  ../corelib.cpp
-  ../crossgencompile.cpp
-  ../custommarshalerinfo.cpp
-  ../dataimage.cpp
-  ../debuginfostore.cpp
-  ../decodemd.cpp
-  ../dllimport.cpp
-  ../dllimportcallback.cpp
-  ../domainfile.cpp
-  ../ecall.cpp
-  ../eeconfig.cpp
-  ../eehash.cpp
-  ../eetwain.cpp
-  ../excep.cpp
-  ../field.cpp
-  ../fieldmarshaler.cpp
-  ../formattype.cpp
-  ../frames.cpp
-  ../gcinfodecoder.cpp
-  ../genericdict.cpp
-  ../generics.cpp
-  ../genmeth.cpp
-  ../hash.cpp
-  ../ilinstrumentation.cpp
-  ../ilmarshalers.cpp
-  ../ilstubcache.cpp
-  ../ilstubresolver.cpp
-  ../inlinetracking.cpp
-  ../instmethhash.cpp
-  ../interoputil.cpp
-  ../invokeutil.cpp
-  ../jithost.cpp
-  ../jitinterface.cpp
-  ../loaderallocator.cpp
-  ../memberload.cpp
-  ../method.cpp
-  ../methodimpl.cpp
-  ../methodtable.cpp
-  ../methodtablebuilder.cpp
-  ../mlinfo.cpp
-  ../nativeimage.cpp
-  ../olevariant.cpp
-  ../pefile.cpp
-  ../peimage.cpp
-  ../peimagelayout.cpp
-  ../pendingload.cpp
-  ../precode.cpp
-  ../sigformat.cpp
-  ../siginfo.cpp
-  ../simplerwlock.cpp
-  ../spinlock.cpp
-  ../stackingallocator.cpp
-  ../stubcache.cpp
-  ../stubgen.cpp
-  ../stublink.cpp
-  ../tailcallhelp.cpp
-  ../typectxt.cpp
-  ../typedesc.cpp
-  ../typeequivalencehash.cpp
-  ../typehandle.cpp
-  ../typehash.cpp
-  ../typeparse.cpp
-  ../typestring.cpp
-  ../util.cpp
-  ../vars.cpp
-  ../versionresilienthashcode.cpp
-  ../zapsig.cpp
-)
-
-set(VM_CROSSGEN_HEADERS
-  ../appdomain.hpp
-  ../appdomain.inl
-  ../array.h
-  ../assembly.hpp
-  ../assemblyloadcontext.h
-  ../assemblyspec.hpp
-  ../assemblyspecbase.h
-  ../baseassemblyspec.h
-  ../baseassemblyspec.inl
-  ../binder.h
-  ../ceeload.h
-  ../ceeload.inl
-  ../ceemain.h
-  ../class.h
-  ../class.inl
-  ../classhash.h
-  ../clrex.h
-  ../clsload.hpp
-  ../clsload.inl
-  ../codeman.h
-  ../codeversion.h
-  ../comdelegate.h
-  ../compile.h
-  ../contractimpl.h
-  ../corelib.h
-  ../custommarshalerinfo.h
-  ../dataimage.h
-  ../debuginfostore.h
-  ../decodemd.h
-  ../dllimport.h
-  ../dllimportcallback.h
-  ../domainfile.h
-  ../domainfile.inl
-  ../ecall.h
-  ../eeconfig.h
-  ../eehash.h
-  ../eehash.inl
-  ../excep.h
-  ../field.h
-  ../fieldmarshaler.h
-  ../genericdict.h
-  ../generics.h
-  ../hash.h
-  ../ilinstrumentation.h
-  ../ilmarshalers.h
-  ../ilstubcache.h
-  ../ilstubresolver.h
-  ../inlinetracking.h
-  ../instmethhash.h
-  ../interoputil.h
-  ../invokeutil.h
-  ../jithost.h
-  ../jitinterface.h
-  ../loaderallocator.hpp
-  ../loaderallocator.inl
-  ../memberload.h
-  ../method.hpp
-  ../method.inl
-  ../methodimpl.h
-  ../methodtable.h
-  ../methodtable.inl
-  ../methodtablebuilder.h
-  ../methodtablebuilder.inl
-  ../mlinfo.h
-  ../olevariant.h
-  ../pefile.h
-  ../pefile.inl
-  ../peimage.h
-  ../peimage.inl
-  ../peimagelayout.h
-  ../peimagelayout.inl
-  ../pendingload.h
-  ../precode.h
-  ../sigformat.h
-  ../siginfo.hpp
-  ../simplerwlock.hpp
-  ../spinlock.h
-  ../stackingallocator.h
-  ../stubcache.h
-  ../stubgen.h
-  ../stublink.h
-  ../stublink.inl
-  ../tailcallhelp.h
-  ../typectxt.h
-  ../typedesc.h
-  ../typedesc.inl
-  ../typeequivalencehash.hpp
-  ../typehandle.h
-  ../typehandle.inl
-  ../typehash.h
-  ../typeparse.h
-  ../typestring.h
-  ../util.hpp
-  ../vars.hpp
-  ../versionresilienthashcode.h
-  ../zapsig.h
-)
-
-if(FEATURE_READYTORUN)
-  list(APPEND VM_CROSSGEN_SOURCES
-    ../readytoruninfo.cpp
-  )
-  list(APPEND VM_CROSSGEN_HEADERS
-    ../readytoruninfo.h
-  )
-endif(FEATURE_READYTORUN)
-
-include_directories(BEFORE ..)
-include_directories(${CLR_DIR}/gc)
-include_directories(../${ARCH_SOURCES_DIR})
-
-if(CLR_CMAKE_TARGET_ARCH_AMD64)
-  list(APPEND VM_CROSSGEN_SOURCES
-    ../${ARCH_SOURCES_DIR}/stublinkeramd64.cpp
-  )
-  list(APPEND VM_CROSSGEN_HEADERS
-    ../${ARCH_SOURCES_DIR}/stublinkeramd64.h
-  )
-elseif(CLR_CMAKE_TARGET_ARCH_I386)
-  list(APPEND VM_CROSSGEN_SOURCES
-    ../${ARCH_SOURCES_DIR}/stublinkerx86.cpp
-    ../gcdecode.cpp
-  )
-  list(APPEND VM_CROSSGEN_HEADERS
-    ../${ARCH_SOURCES_DIR}/stublinkerx86.h
-  )
-elseif(CLR_CMAKE_TARGET_ARCH_ARM)
-  list(APPEND VM_CROSSGEN_SOURCES
-    ../${ARCH_SOURCES_DIR}/stubs.cpp
-  )
-elseif(CLR_CMAKE_TARGET_ARCH_ARM64)
-  list(APPEND VM_CROSSGEN_SOURCES
-    ../${ARCH_SOURCES_DIR}/stubs.cpp
-  )
-else()
-  clr_unknown_arch()
-endif()
-
-if (CLR_CMAKE_TARGET_WIN32)
-
-  # COM interop scenarios
-  list(APPEND VM_CROSSGEN_SOURCES
-    ../classcompat.cpp
-    ../comtoclrcall.cpp
-    ../clrtocomcall.cpp
-    ../runtimecallablewrapper.cpp
-  )
-  list(APPEND VM_CROSSGEN_HEADERS
-    ../classcompat.h
-    ../clrtocomcall.h
-    ../comtoclrcall.h
-    ../runtimecallablewrapper.h
-  )
-
-  list(APPEND VM_CROSSGEN_SOURCES ${VM_CROSSGEN_HEADERS})
-endif (CLR_CMAKE_TARGET_WIN32)
-
-if (CLR_CMAKE_HOST_LINUX)
-  list(APPEND VM_CROSSGEN_SOURCES
-    ../perfmap.cpp
-    ../perfinfo.cpp
-  )
-endif (CLR_CMAKE_HOST_LINUX)
-
-add_library_clr(cee_crossgen ${VM_CROSSGEN_SOURCES})
-add_dependencies(cee_crossgen eventing_headers)
-set_target_properties(cee_crossgen PROPERTIES CROSSGEN_COMPONENT TRUE)
-target_precompile_headers(cee_crossgen PRIVATE [["common.h"]])
-if (MSVC)
-  # corelib.cpp does not compile with precompiled header file
-  set_source_files_properties(../corelib.cpp PROPERTIES COMPILE_FLAGS "/Y-")
-endif()
-
-add_library_clr(corelib_crossgen ../corelib.cpp)
-add_dependencies(corelib_crossgen eventing_headers)
-target_compile_definitions(corelib_crossgen
-    PRIVATE
-        EnC_SUPPORTED
-        FEATURE_EVENT_TRACE
-        FEATURE_MULTICOREJIT
-        CROSSGEN_CORELIB)
-
-set_target_properties(corelib_crossgen PROPERTIES CROSSGEN_COMPONENT TRUE)
-
diff --git a/src/coreclr/vm/crossgencompile.cpp b/src/coreclr/vm/crossgencompile.cpp
index a4fdab8e69ba34..8622505081b14f 100644
--- a/src/coreclr/vm/crossgencompile.cpp
+++ b/src/coreclr/vm/crossgencompile.cpp
@@ -123,7 +123,7 @@ DWORD GetCurrentExceptionCode()
 // disable PROFILING_SUPPORTED for crossgen because of it affects data layout and FCall tables.
 //
 
-UINT_PTR EEToProfInterfaceImpl::EEFunctionIDMapper(FunctionID funcId, BOOL * pbHookFunction)
+UINT_PTR EEToProfInterfaceImpl::EEFunctionIDMapper(FunctionID funcId, BOOL *pbHookFunction)
 {
     UNREACHABLE();
 }
@@ -253,7 +253,7 @@ INT32 rel32UsingJumpStub(INT32 UNALIGNED * pRel32, PCODE target, MethodDesc *pMe
     return 0;
 }
 
-INT32 rel32UsingPreallocatedJumpStub(INT32 UNALIGNED * pRel32, PCODE target, PCODE jumpStubAddr, bool emitJump)
+INT32 rel32UsingPreallocatedJumpStub(INT32 UNALIGNED * pRel32, PCODE target, PCODE jumpStubAddrRX, PCODE jumpStubAddrRW, bool emitJump)
 {
     // crossgen does not have jump stubs
     return 0;
@@ -271,6 +271,11 @@ void CrawlFrame::GetExactGenericInstantiations(Instantiation *pClassInst, Instan
     UNREACHABLE();
 }
 
+void SetObjectReferenceUnchecked(OBJECTREF *dst,OBJECTREF ref)
+{
+    UNREACHABLE();
+}
+
 BOOL Object::SupportsInterface(OBJECTREF pObj, MethodTable* pInterfaceMT)
 {
     UNREACHABLE();
diff --git a/src/coreclr/vm/dataimage.cpp b/src/coreclr/vm/dataimage.cpp
index d619efc1ebf498..de8569cb342cf9 100644
--- a/src/coreclr/vm/dataimage.cpp
+++ b/src/coreclr/vm/dataimage.cpp
@@ -1246,7 +1246,7 @@ class ZapStubPrecode : public ZapNode
 
         StubPrecode precode;
 
-        precode.Init(m_pMD);
+        precode.Init(&precode, m_pMD);
 
         SSIZE_T offset;
         ZapNode * pNode = pImage->m_pDataImage->GetNodeForStructure(m_pMD, &offset);
@@ -1275,7 +1275,7 @@ class ZapNDirectImportPrecode : public ZapStubPrecode
 
         StubPrecode precode;
 
-        precode.Init(m_pMD);
+        precode.Init(&precode, m_pMD);
 
         SSIZE_T offset;
         ZapNode * pNode = pImage->m_pDataImage->GetNodeForStructure(m_pMD, &offset);
diff --git a/src/coreclr/vm/dllimportcallback.cpp b/src/coreclr/vm/dllimportcallback.cpp
index d21259f60bd655..4a88f81df5210e 100644
--- a/src/coreclr/vm/dllimportcallback.cpp
+++ b/src/coreclr/vm/dllimportcallback.cpp
@@ -64,7 +64,7 @@ class UMEntryThunkFreeList
         return pThunk;
     }
 
-    void AddToList(UMEntryThunk *pThunk)
+    void AddToList(UMEntryThunk *pThunkRX, UMEntryThunk *pThunkRW)
     {
         CONTRACTL
         {
@@ -74,22 +74,19 @@ class UMEntryThunkFreeList
 
         CrstHolder ch(&m_crst);
 
-#if defined(HOST_OSX) && defined(HOST_ARM64)
-        auto jitWriteEnableHolder = PAL_JITWriteEnable(true);
-#endif // defined(HOST_OSX) && defined(HOST_ARM64)
-
         if (m_pHead == NULL)
         {
-            m_pHead = pThunk;
-            m_pTail = pThunk;
+            m_pHead = pThunkRX;
+            m_pTail = pThunkRX;
         }
         else
         {
-            m_pTail->m_pNextFreeThunk = pThunk;
-            m_pTail = pThunk;
+            ExecutableWriterHolder<UMEntryThunk> tailThunkWriterHolder(m_pTail, sizeof(UMEntryThunk));
+            tailThunkWriterHolder.GetRW()->m_pNextFreeThunk = pThunkRX;
+            m_pTail = pThunkRX;
         }
 
-        pThunk->m_pNextFreeThunk = NULL;
+        pThunkRW->m_pNextFreeThunk = NULL;
 
         ++m_count;
     }
@@ -158,9 +155,6 @@ UMEntryThunk *UMEntryThunkCache::GetUMEntryThunk(MethodDesc *pMD)
     else
     {
         // cache miss -> create a new thunk
-#if defined(HOST_OSX) && defined(HOST_ARM64)
-        auto jitWriteEnableHolder = PAL_JITWriteEnable(true);
-#endif // defined(HOST_OSX) && defined(HOST_ARM64)
         pThunk = UMEntryThunk::CreateUMEntryThunk();
         Holder<UMEntryThunk *, DoNothing, UMEntryThunk::FreeUMEntryThunk> umHolder;
         umHolder.Assign(pThunk);
@@ -170,7 +164,9 @@ UMEntryThunk *UMEntryThunkCache::GetUMEntryThunk(MethodDesc *pMD)
         miHolder.Assign(pMarshInfo);
 
         pMarshInfo->LoadTimeInit(pMD);
-        pThunk->LoadTimeInit(NULL, NULL, pMarshInfo, pMD);
+
+        ExecutableWriterHolder<UMEntryThunk> thunkWriterHolder(pThunk, sizeof(UMEntryThunk));
+        thunkWriterHolder.GetRW()->LoadTimeInit(pThunk, NULL, NULL, pMarshInfo, pMD);
 
         // add it to the cache
         CacheElement element;
@@ -281,11 +277,8 @@ void STDCALL UMEntryThunk::DoRunTimeInit(UMEntryThunk* pUMEntryThunk)
     {
         GCX_PREEMP();
 
-#if defined(HOST_OSX) && defined(HOST_ARM64)
-        auto jitWriteEnableHolder = PAL_JITWriteEnable(true);
-#endif // defined(HOST_OSX) && defined(HOST_ARM64)
-
-        pUMEntryThunk->RunTimeInit();
+        ExecutableWriterHolder<UMEntryThunk> uMEntryThunkWriterHolder(pUMEntryThunk, sizeof(UMEntryThunk));
+        uMEntryThunkWriterHolder.GetRW()->RunTimeInit(pUMEntryThunk);
     }
 
     UNINSTALL_UNWIND_AND_CONTINUE_HANDLER;
@@ -323,19 +316,16 @@ void UMEntryThunk::Terminate()
     }
     CONTRACTL_END;
 
+    ExecutableWriterHolder<UMEntryThunk> thunkWriterHolder(this, sizeof(UMEntryThunk));
     m_code.Poison();
 
     if (GetObjectHandle())
     {
-#if defined(HOST_OSX) && defined(HOST_ARM64)
-        auto jitWriteEnableHolder = PAL_JITWriteEnable(true);
-#endif // defined(HOST_OSX) && defined(HOST_ARM64)
-
         DestroyLongWeakHandle(GetObjectHandle());
-        m_pObjectHandle = 0;
+        thunkWriterHolder.GetRW()->m_pObjectHandle = 0;
     }
 
-    s_thunkFreeList.AddToList(this);
+    s_thunkFreeList.AddToList(this, thunkWriterHolder.GetRW());
 }
 
 VOID UMEntryThunk::FreeUMEntryThunk(UMEntryThunk* p)
diff --git a/src/coreclr/vm/dllimportcallback.h b/src/coreclr/vm/dllimportcallback.h
index ec57ebb009d334..14b7db5704824f 100644
--- a/src/coreclr/vm/dllimportcallback.h
+++ b/src/coreclr/vm/dllimportcallback.h
@@ -137,7 +137,8 @@ class UMEntryThunk
     static VOID FreeUMEntryThunk(UMEntryThunk* p);
 
 #ifndef DACCESS_COMPILE
-    VOID LoadTimeInit(PCODE                   pManagedTarget,
+    VOID LoadTimeInit(UMEntryThunk           *pUMEntryThunkRX,
+                      PCODE                   pManagedTarget,
                       OBJECTHANDLE            pObjectHandle,
                       UMThunkMarshInfo       *pUMThunkMarshInfo,
                       MethodDesc             *pMD)
@@ -152,17 +153,13 @@ class UMEntryThunk
         }
         CONTRACTL_END;
 
-#if defined(HOST_OSX) && defined(HOST_ARM64)
-        auto jitWriteEnableHolder = PAL_JITWriteEnable(true);
-#endif // defined(HOST_OSX) && defined(HOST_ARM64)
-
         m_pManagedTarget = pManagedTarget;
         m_pObjectHandle     = pObjectHandle;
         m_pUMThunkMarshInfo = pUMThunkMarshInfo;
 
         m_pMD = pMD;    // For debugging and profiling, so they can identify the target
 
-        m_code.Encode((BYTE*)TheUMThunkPreStub(), this);
+        m_code.Encode(&pUMEntryThunkRX->m_code, (BYTE*)TheUMThunkPreStub(), pUMEntryThunkRX);
 
 #ifdef _DEBUG
         m_state = kLoadTimeInited;
@@ -171,26 +168,23 @@ class UMEntryThunk
 
     void Terminate();
 
-    VOID RunTimeInit()
+    VOID RunTimeInit(UMEntryThunk *pUMEntryThunkRX)
     {
         STANDARD_VM_CONTRACT;
 
         // Ensure method's module is activate in app domain
         m_pMD->EnsureActive();
 
-        m_pUMThunkMarshInfo->RunTimeInit();
+        ExecutableWriterHolder<UMThunkMarshInfo> uMThunkMarshInfoWriterHolder(m_pUMThunkMarshInfo, sizeof(UMThunkMarshInfo));
+        uMThunkMarshInfoWriterHolder.GetRW()->RunTimeInit();
 
         // Ensure that we have either the managed target or the delegate.
         if (m_pObjectHandle == NULL && m_pManagedTarget == NULL)
             m_pManagedTarget = m_pMD->GetMultiCallableAddrOfCode();
 
-        m_code.Encode((BYTE*)m_pUMThunkMarshInfo->GetExecStubEntryPoint(), this);
+        m_code.Encode(&pUMEntryThunkRX->m_code, (BYTE*)m_pUMThunkMarshInfo->GetExecStubEntryPoint(), pUMEntryThunkRX);
 
 #ifdef _DEBUG
-#if defined(HOST_OSX) && defined(HOST_ARM64)
-    auto jitWriteEnableHolder = PAL_JITWriteEnable(true);
-#endif // defined(HOST_OSX) && defined(HOST_ARM64)
-
         m_state = kRunTimeInited;
 #endif // _DEBUG
     }
diff --git a/src/coreclr/vm/dynamicmethod.cpp b/src/coreclr/vm/dynamicmethod.cpp
index 1a5320bb5fb1f3..9dae86aca93773 100644
--- a/src/coreclr/vm/dynamicmethod.cpp
+++ b/src/coreclr/vm/dynamicmethod.cpp
@@ -463,7 +463,8 @@ HeapList* HostCodeHeap::InitializeHeapList(CodeHeapRequestInfo *pInfo)
     pHp->reserveForJumpStubs = 0;
 
 #ifdef HOST_64BIT
-    emitJump(pHp->CLRPersonalityRoutine, (void *)ProcessCLRException);
+    ExecutableWriterHolder<BYTE> personalityRoutineWriterHolder(pHp->CLRPersonalityRoutine, 12);
+    emitJump(pHp->CLRPersonalityRoutine, personalityRoutineWriterHolder.GetRW(), (void *)ProcessCLRException);
 #endif
 
     size_t nibbleMapSize = HEAP2MAPSIZE(ROUND_UP_TO_PAGE(pHp->maxCodeHeapSize));
@@ -498,6 +499,14 @@ HostCodeHeap::TrackAllocation* HostCodeHeap::AllocFromFreeList(size_t header, si
                 // found a block
                 LOG((LF_BCL, LL_INFO100, "Level2 - CodeHeap [0x%p] - Block found, size 0x%X\n", this, pCurrent->size));
 
+                ExecutableWriterHolder<TrackAllocation> previousWriterHolder;
+                if (pPrevious)
+                {
+                    previousWriterHolder = ExecutableWriterHolder<TrackAllocation>(pPrevious, sizeof(TrackAllocation));
+                }
+
+                ExecutableWriterHolder<TrackAllocation> currentWriterHolder(pCurrent, sizeof(TrackAllocation));
+
                 // The space left is not big enough for a new block, let's just
                 // update the TrackAllocation record for the current block
                 if (pCurrent->size - realSize < max(HOST_CODEHEAP_SIZE_ALIGN, sizeof(TrackAllocation)))
@@ -506,7 +515,7 @@ HostCodeHeap::TrackAllocation* HostCodeHeap::AllocFromFreeList(size_t header, si
                     // remove current
                     if (pPrevious)
                     {
-                        pPrevious->pNext = pCurrent->pNext;
+                        previousWriterHolder.GetRW()->pNext = pCurrent->pNext;
                     }
                     else
                     {
@@ -517,12 +526,15 @@ HostCodeHeap::TrackAllocation* HostCodeHeap::AllocFromFreeList(size_t header, si
                 {
                     // create a new TrackAllocation after the memory we just allocated and insert it into the free list
                     TrackAllocation *pNewCurrent = (TrackAllocation*)((BYTE*)pCurrent + realSize);
-                    pNewCurrent->pNext = pCurrent->pNext;
-                    pNewCurrent->size = pCurrent->size - realSize;
+                    
+                    ExecutableWriterHolder<TrackAllocation> newCurrentWriterHolder(pNewCurrent, sizeof(TrackAllocation));
+                    newCurrentWriterHolder.GetRW()->pNext = pCurrent->pNext;
+                    newCurrentWriterHolder.GetRW()->size = pCurrent->size - realSize;
+
                     LOG((LF_BCL, LL_INFO100, "Level2 - CodeHeap [0x%p] - Item changed %p, new size 0x%X\n", this, pNewCurrent, pNewCurrent->size));
                     if (pPrevious)
                     {
-                        pPrevious->pNext = pNewCurrent;
+                        previousWriterHolder.GetRW()->pNext = pNewCurrent;
                     }
                     else
                     {
@@ -530,10 +542,10 @@ HostCodeHeap::TrackAllocation* HostCodeHeap::AllocFromFreeList(size_t header, si
                     }
 
                     // We only need to update the size of the current block if we are creating a new block
-                    pCurrent->size = realSize;
+                    currentWriterHolder.GetRW()->size = realSize;
                 }
 
-                pCurrent->pHeap = this;
+                currentWriterHolder.GetRW()->pHeap = this;
 
                 LOG((LF_BCL, LL_INFO100, "Level2 - CodeHeap [0x%p] - Allocation returned %p, size 0x%X - data -> %p\n", this, pCurrent, pCurrent->size, pPointer));
                 return pCurrent;
@@ -546,7 +558,7 @@ HostCodeHeap::TrackAllocation* HostCodeHeap::AllocFromFreeList(size_t header, si
     return NULL;
 }
 
-void HostCodeHeap::AddToFreeList(TrackAllocation *pBlockToInsert)
+void HostCodeHeap::AddToFreeList(TrackAllocation *pBlockToInsert, TrackAllocation *pBlockToInsertRW)
 {
     CONTRACTL
     {
@@ -558,10 +570,6 @@ void HostCodeHeap::AddToFreeList(TrackAllocation *pBlockToInsert)
 
     LOG((LF_BCL, LL_INFO100, "Level2 - CodeHeap [0x%p] - Add to FreeList [%p, 0x%X]\n", this, pBlockToInsert, pBlockToInsert->size));
 
-#if defined(HOST_OSX) && defined(HOST_ARM64)
-    auto jitWriteEnableHolder = PAL_JITWriteEnable(true);
-#endif // defined(HOST_OSX) && defined(HOST_ARM64)
-
     // append to the list in the proper position and coalesce if needed
     if (m_pFreeList)
     {
@@ -572,10 +580,13 @@ void HostCodeHeap::AddToFreeList(TrackAllocation *pBlockToInsert)
             if (pCurrent > pBlockToInsert)
             {
                 // found the point of insertion
-                pBlockToInsert->pNext = pCurrent;
+                pBlockToInsertRW->pNext = pCurrent;
+                ExecutableWriterHolder<TrackAllocation> previousWriterHolder;
+
                 if (pPrevious)
                 {
-                    pPrevious->pNext = pBlockToInsert;
+                    previousWriterHolder = ExecutableWriterHolder<TrackAllocation>(pPrevious, sizeof(TrackAllocation));
+                    previousWriterHolder.GetRW()->pNext = pBlockToInsert;
                     LOG((LF_BCL, LL_INFO100, "Level2 - CodeHeap [0x%p] - Insert block [%p, 0x%X] -> [%p, 0x%X] -> [%p, 0x%X]\n", this,
                                                                         pPrevious, pPrevious->size,
                                                                         pBlockToInsert, pBlockToInsert->size,
@@ -595,8 +606,8 @@ void HostCodeHeap::AddToFreeList(TrackAllocation *pBlockToInsert)
                                                                         pBlockToInsert, pBlockToInsert->size,
                                                                         pCurrent, pCurrent->size,
                                                                         pCurrent->size + pBlockToInsert->size));
-                    pBlockToInsert->pNext = pCurrent->pNext;
-                    pBlockToInsert->size += pCurrent->size;
+                    pBlockToInsertRW->pNext = pCurrent->pNext;
+                    pBlockToInsertRW->size += pCurrent->size;
                 }
 
                 if (pPrevious && (BYTE*)pPrevious + pPrevious->size == (BYTE*)pBlockToInsert)
@@ -606,8 +617,8 @@ void HostCodeHeap::AddToFreeList(TrackAllocation *pBlockToInsert)
                                                                         pPrevious, pPrevious->size,
                                                                         pBlockToInsert, pBlockToInsert->size,
                                                                         pPrevious->size + pBlockToInsert->size));
-                    pPrevious->pNext = pBlockToInsert->pNext;
-                    pPrevious->size += pBlockToInsert->size;
+                    previousWriterHolder.GetRW()->pNext = pBlockToInsert->pNext;
+                    previousWriterHolder.GetRW()->size += pBlockToInsert->size;
                 }
 
                 return;
@@ -616,8 +627,10 @@ void HostCodeHeap::AddToFreeList(TrackAllocation *pBlockToInsert)
             pCurrent = pCurrent->pNext;
         }
         _ASSERTE(pPrevious && pCurrent == NULL);
-        pBlockToInsert->pNext = NULL;
+        pBlockToInsertRW->pNext = NULL;
         // last in the list
+        ExecutableWriterHolder<TrackAllocation> previousWriterHolder2(pPrevious, sizeof(TrackAllocation));
+
         if ((BYTE*)pPrevious + pPrevious->size == (BYTE*)pBlockToInsert)
         {
             // coalesce with previous
@@ -625,11 +638,11 @@ void HostCodeHeap::AddToFreeList(TrackAllocation *pBlockToInsert)
                                                                 pPrevious, pPrevious->size,
                                                                 pBlockToInsert, pBlockToInsert->size,
                                                                 pPrevious->size + pBlockToInsert->size));
-            pPrevious->size += pBlockToInsert->size;
+            previousWriterHolder2.GetRW()->size += pBlockToInsert->size;
         }
         else
         {
-            pPrevious->pNext = pBlockToInsert;
+            previousWriterHolder2.GetRW()->pNext = pBlockToInsert;
             LOG((LF_BCL, LL_INFO100, "Level2 - CodeHeap [0x%p] - Insert block [%p, 0x%X] to end after [%p, 0x%X]\n", this,
                                                                 pBlockToInsert, pBlockToInsert->size,
                                                                 pPrevious, pPrevious->size));
@@ -639,7 +652,7 @@ void HostCodeHeap::AddToFreeList(TrackAllocation *pBlockToInsert)
 
     }
     // first in the list
-    pBlockToInsert->pNext = m_pFreeList;
+    pBlockToInsertRW->pNext = m_pFreeList;
     m_pFreeList = pBlockToInsert;
     LOG((LF_BCL, LL_INFO100, "Level2 - CodeHeap [0x%p] - Insert block [%p, 0x%X] to head\n", this,
                                                         m_pFreeList, m_pFreeList->size));
@@ -674,7 +687,8 @@ void* HostCodeHeap::AllocMemForCode_NoThrow(size_t header, size_t size, DWORD al
 
     // Pointer to the TrackAllocation record is stored just before the code header
     CodeHeader * pHdr = (CodeHeader *)pCode - 1;
-    *((TrackAllocation **)(pHdr) - 1) = pTracker;
+    ExecutableWriterHolder<TrackAllocation *> trackerWriterHolder((TrackAllocation **)(pHdr) - 1, sizeof(TrackAllocation *));
+    *trackerWriterHolder.GetRW() = pTracker;
 
     _ASSERTE(pCode + size <= (BYTE*)pTracker + pTracker->size);
 
@@ -742,10 +756,12 @@ HostCodeHeap::TrackAllocation* HostCodeHeap::AllocMemory_NoThrow(size_t header,
             }
 
             TrackAllocation *pBlockToInsert = (TrackAllocation*)(void*)m_pLastAvailableCommittedAddr;
-            pBlockToInsert->pNext = NULL;
-            pBlockToInsert->size = sizeToCommit;
+            ExecutableWriterHolder<TrackAllocation> blockToInsertWriterHolder(pBlockToInsert, sizeof(TrackAllocation));
+
+            blockToInsertWriterHolder.GetRW()->pNext = NULL;
+            blockToInsertWriterHolder.GetRW()->size = sizeToCommit;
             m_pLastAvailableCommittedAddr += sizeToCommit;
-            AddToFreeList(pBlockToInsert);
+            AddToFreeList(pBlockToInsert, blockToInsertWriterHolder.GetRW());
             pTracker = AllocFromFreeList(header, size, alignment, reserveForJumpStubs);
             _ASSERTE(pTracker != NULL);
         }
@@ -831,7 +847,8 @@ void HostCodeHeap::FreeMemForCode(void * codeStart)
     LIMITED_METHOD_CONTRACT;
 
     TrackAllocation *pTracker = HostCodeHeap::GetTrackAllocation((TADDR)codeStart);
-    AddToFreeList(pTracker);
+    ExecutableWriterHolder<TrackAllocation> trackerWriterHolder(pTracker, sizeof(TrackAllocation));
+    AddToFreeList(pTracker, trackerWriterHolder.GetRW());
 
     m_ApproximateLargestBlock += pTracker->size;
 
diff --git a/src/coreclr/vm/dynamicmethod.h b/src/coreclr/vm/dynamicmethod.h
index c287e31456d3f6..3690d55d41ce74 100644
--- a/src/coreclr/vm/dynamicmethod.h
+++ b/src/coreclr/vm/dynamicmethod.h
@@ -286,7 +286,7 @@ class HostCodeHeap : CodeHeap
     HostCodeHeap(EEJitManager *pJitManager);
     HeapList* InitializeHeapList(CodeHeapRequestInfo *pInfo);
     TrackAllocation* AllocFromFreeList(size_t header, size_t size, DWORD alignment, size_t reserveForJumpStubs);
-    void AddToFreeList(TrackAllocation *pBlockToInsert);
+    void AddToFreeList(TrackAllocation *pBlockToInsert, TrackAllocation *pBlockToInsertRW);
 
     TrackAllocation* AllocMemory_NoThrow(size_t header, size_t size, DWORD alignment, size_t reserveForJumpStubs);
 
diff --git a/src/coreclr/vm/ecall.cpp b/src/coreclr/vm/ecall.cpp
index b5a9e17e7545f0..c6d1b6d2f1eddd 100644
--- a/src/coreclr/vm/ecall.cpp
+++ b/src/coreclr/vm/ecall.cpp
@@ -430,11 +430,10 @@ PCODE ECall::GetFCallImpl(MethodDesc * pMD, BOOL * pfSharedOrDynamicFCallImpl /*
     // COM imported classes have special constructors
     if (pMT->IsComObjectType()
 #ifdef FEATURE_COMINTEROP
-        && pMT != g_pBaseCOMObject
+        && (g_pBaseCOMObject == NULL || pMT != g_pBaseCOMObject)
 #endif // FEATURE_COMINTEROP
     )
     {
-#ifdef FEATURE_COMINTEROP
         if (pfSharedOrDynamicFCallImpl)
             *pfSharedOrDynamicFCallImpl = TRUE;
 
@@ -443,9 +442,6 @@ PCODE ECall::GetFCallImpl(MethodDesc * pMD, BOOL * pfSharedOrDynamicFCallImpl /*
 
         // FCComCtor does not need to be in the fcall hashtable since it does not erect frame.
         return GetEEFuncEntryPoint(FCComCtor);
-#else
-        COMPlusThrow(kPlatformNotSupportedException, IDS_EE_ERROR_COM);
-#endif // FEATURE_COMINTEROP
     }
 
     if (!pMD->GetModule()->IsSystem())
@@ -566,9 +562,7 @@ BOOL ECall::IsSharedFCallImpl(PCODE pImpl)
     PCODE pNativeCode = pImpl;
 
     return
-#ifdef FEATURE_COMINTEROP
         (pNativeCode == GetEEFuncEntryPoint(FCComCtor)) ||
-#endif
         (pNativeCode == GetEEFuncEntryPoint(COMDelegate::DelegateConstruct));
 }
 
@@ -614,7 +608,12 @@ BOOL ECall::CheckUnusedECalls(SetSHash<DWORD>& usedIDs)
 }
 
 
-#if defined(FEATURE_COMINTEROP) && !defined(CROSSGEN_COMPILE)
+#if !defined(CROSSGEN_COMPILE)
+// This function is a stub implementation for the constructor of a ComImport class.
+// The actual work to implement COM Activation (and built-in COM support checks) is done as part
+// of the implementation of object allocation. As a result, the constructor itself has no extra
+// work to do once the object has been allocated. As a result, we just provide a dummy implementation
+// here since a constructor has to have an implementation.
 FCIMPL1(VOID, FCComCtor, LPVOID pV)
 {
     FCALL_CONTRACT;
@@ -622,7 +621,7 @@ FCIMPL1(VOID, FCComCtor, LPVOID pV)
     FCUnique(0x34);
 }
 FCIMPLEND
-#endif // FEATURE_COMINTEROP && !CROSSGEN_COMPILE
+#endif // !CROSSGEN_COMPILE
 
 
 
diff --git a/src/coreclr/vm/ecall.h b/src/coreclr/vm/ecall.h
index 387bbc2e9ddf6a..9b946ad1982222 100644
--- a/src/coreclr/vm/ecall.h
+++ b/src/coreclr/vm/ecall.h
@@ -134,8 +134,6 @@ class ECall
         static LPVOID GetQCallImpl(MethodDesc * pMD);
 };
 
-#ifdef FEATURE_COMINTEROP
 extern "C" FCDECL1(VOID, FCComCtor, LPVOID pV);
-#endif
 
 #endif // _ECALL_H_
diff --git a/src/coreclr/vm/ecalllist.h b/src/coreclr/vm/ecalllist.h
index 48a2d7d322e574..1822422f5961c2 100644
--- a/src/coreclr/vm/ecalllist.h
+++ b/src/coreclr/vm/ecalllist.h
@@ -209,7 +209,6 @@ FCFuncStart(gCOMTypeHandleFuncs)
     FCFuncElement("GetNumVirtualsAndStaticVirtuals", RuntimeTypeHandle::GetNumVirtualsAndStaticVirtuals)
     QCFuncElement("VerifyInterfaceIsImplemented", RuntimeTypeHandle::VerifyInterfaceIsImplemented)
     QCFuncElement("GetInterfaceMethodImplementation", RuntimeTypeHandle::GetInterfaceMethodImplementation)
-    FCFuncElement("IsComObject", RuntimeTypeHandle::IsComObject)
     FCFuncElement("IsValueType", RuntimeTypeHandle::IsValueType)
     FCFuncElement("IsInterface", RuntimeTypeHandle::IsInterface)
     FCFuncElement("IsByRefLike", RuntimeTypeHandle::IsByRefLike)
@@ -768,7 +767,6 @@ FCFuncStart(gInteropMarshalFuncs)
 
 #ifdef FEATURE_COMINTEROP
     FCFuncElement("GetHRForException", MarshalNative::GetHRForException)
-    FCFuncElement("IsComObject", MarshalNative::IsComObject)
     FCFuncElement("GetObjectForIUnknownNative", MarshalNative::GetObjectForIUnknownNative)
     FCFuncElement("GetUniqueObjectForIUnknownNative", MarshalNative::GetUniqueObjectForIUnknownNative)
     FCFuncElement("GetNativeVariantForObjectNative", MarshalNative::GetNativeVariantForObjectNative)
diff --git a/src/coreclr/vm/eetoprofinterfaceimpl.cpp b/src/coreclr/vm/eetoprofinterfaceimpl.cpp
index 34cd1475a42363..745f2b6ef1ca10 100644
--- a/src/coreclr/vm/eetoprofinterfaceimpl.cpp
+++ b/src/coreclr/vm/eetoprofinterfaceimpl.cpp
@@ -103,15 +103,17 @@ enum ClrToProfEntrypointFlags
 };
 
 #define ASSERT_EVAC_COUNTER_NONZERO()   \
-    _ASSERTE((GetThreadNULLOk() == NULL) ||                                             \
-             (GetThreadNULLOk()->GetProfilerEvacuationCounter() != 0U))
+    _ASSERTE(m_pProfilerInfo->dwProfilerEvacuationCounter.Load() > 0)
 
 #define CHECK_PROFILER_STATUS(ee2pFlags)                                                \
     /* If one of these asserts fires, perhaps you forgot to use                     */  \
-    /* BEGIN/END_PIN_PROFILER                                                       */  \
+    /* BEGIN/END_PROFILER_CALLBACK                                                  */  \
     ASSERT_EVAC_COUNTER_NONZERO();                                                      \
-    _ASSERTE(g_profControlBlock.pProfInterface.Load() != NULL);                         \
-    _ASSERTE(g_profControlBlock.pProfInterface == this);                                \
+    /* Either we are initializing, or we have the ProfToEEInterfaceImpl             */  \
+    _ASSERTE((((ee2pFlags) & kEE2PAllowableWhileInitializing) != 0) || (m_pProfilerInfo->pProfInterface.Load() != NULL));   \
+    /* If we are initializing, null is fine. Otherwise we want to make sure we haven't messed up the association between */ \
+    /* EEToProfInterfaceImpl/ProfToEEInterfaceImpl somehow.                         */  \
+    _ASSERTE((((ee2pFlags) & kEE2PAllowableWhileInitializing) != 0) || (m_pProfilerInfo->pProfInterface == this));          \
     /* Early abort if...                                                            */  \
     if (                                                                                \
         /* Profiler isn't active,                                                   */  \
@@ -121,7 +123,7 @@ enum ClrToProfEntrypointFlags
         /* on a detaching profiler, and b) the profiler is detaching                */  \
         !(                                                                              \
             (((ee2pFlags) & kEE2PAllowableWhileDetaching) != 0) &&                      \
-            (g_profControlBlock.curProfStatus.Get() == kProfStatusDetaching)            \
+            (m_pProfilerInfo->curProfStatus.Get() == kProfStatusDetaching)            \
          ) &&                                                                           \
                                                                                         \
         /* and it's not the case that both a) this callback is allowed              */  \
@@ -129,9 +131,9 @@ enum ClrToProfEntrypointFlags
         !(                                                                              \
             (((ee2pFlags) & kEE2PAllowableWhileInitializing) != 0) &&                   \
             (                                                                           \
-              (g_profControlBlock.curProfStatus.Get()                                   \
+              (m_pProfilerInfo->curProfStatus.Get()                                   \
                   == kProfStatusInitializingForStartupLoad) ||                          \
-              (g_profControlBlock.curProfStatus.Get()                                   \
+              (m_pProfilerInfo->curProfStatus.Get()                                   \
                   == kProfStatusInitializingForAttachLoad)                              \
             )                                                                           \
          )                                                                              \
@@ -412,14 +414,13 @@ EEToProfInterfaceImpl::EEToProfInterfaceImpl() :
     m_pCallback8(NULL),
     m_pCallback9(NULL),
     m_pCallback10(NULL),
+    m_pCallback11(NULL),
     m_hmodProfilerDLL(NULL),
     m_fLoadedViaAttach(FALSE),
     m_pProfToEE(NULL),
     m_pProfilersFuncIDMapper(NULL),
     m_pProfilersFuncIDMapper2(NULL),
     m_pProfilersFuncIDMapper2ClientData(NULL),
-    m_GUID(k_guidZero),
-    m_lGUIDCount(0),
     m_pGCRefDataFreeList(NULL),
     m_csGCRefDataFreeList(NULL),
     m_pEnter(NULL),
@@ -437,6 +438,7 @@ EEToProfInterfaceImpl::EEToProfInterfaceImpl() :
     m_pTailcall3WithInfo(NULL),
     m_fUnrevertiblyModifiedIL(FALSE),
     m_fModifiedRejitState(FALSE),
+    m_pProfilerInfo(NULL),
     m_pFunctionIDHashTable(NULL),
     m_pFunctionIDHashTableRWLock(NULL),
     m_dwConcurrentGCWaitTimeoutInMs(INFINITE),
@@ -585,6 +587,12 @@ HRESULT EEToProfInterfaceImpl::Init(
     return S_OK;
 }
 
+void EEToProfInterfaceImpl::SetProfilerInfo(ProfilerInfo *pProfilerInfo)
+{
+    LIMITED_METHOD_CONTRACT;
+    m_pProfilerInfo = pProfilerInfo;
+    m_pProfToEE->SetProfilerInfo(pProfilerInfo);
+}
 
 //---------------------------------------------------------------------------------------
 //
@@ -660,18 +668,39 @@ HRESULT EEToProfInterfaceImpl::CreateProfiler(
 
     // ATTENTION: Please update EEToProfInterfaceImpl::~EEToProfInterfaceImpl() after adding the next ICorProfilerCallback interface here !!!
 
-    // The profiler may optionally support ICorProfilerCallback3,4,5,6,7,8,9,10.  Let's check.
-    ReleaseHolder<ICorProfilerCallback10> pCallback10;
+    // The profiler may optionally support ICorProfilerCallback3,4,5,6,7,8,9,10,11.  Let's check.
+    ReleaseHolder<ICorProfilerCallback11> pCallback11;
     hr = m_pCallback2->QueryInterface(
-        IID_ICorProfilerCallback10,
-        (LPVOID *)&pCallback10);
-    if (SUCCEEDED(hr) && (pCallback10 != NULL))
+        IID_ICorProfilerCallback11,
+        (LPVOID *)&pCallback11);
+    if (SUCCEEDED(hr) && (pCallback11 != NULL))
+    {
+        _ASSERTE(m_pCallback11 == NULL);
+        m_pCallback11 = pCallback11.Extract();
+        pCallback11 = NULL;
+    }
+
+    if (m_pCallback11 == NULL)
+    {
+        ReleaseHolder<ICorProfilerCallback10> pCallback10;
+        hr = m_pCallback2->QueryInterface(
+            IID_ICorProfilerCallback10,
+            (LPVOID *)&pCallback10);
+        if (SUCCEEDED(hr) && (pCallback10 != NULL))
+        {
+            _ASSERTE(m_pCallback10 == NULL);
+            m_pCallback10 = pCallback10.Extract();
+            pCallback10 = NULL;
+        }
+    }
+    else
     {
         _ASSERTE(m_pCallback10 == NULL);
-        m_pCallback10 = pCallback10.Extract();
-        pCallback10 = NULL;
+        m_pCallback10 = static_cast<ICorProfilerCallback10 *>(m_pCallback11);
+        m_pCallback10->AddRef();
     }
 
+
     // Due to inheritance, if we have an interface we must also have
     // all the previous versions
     if (m_pCallback10 == NULL)
@@ -847,7 +876,7 @@ EEToProfInterfaceImpl::~EEToProfInterfaceImpl()
     // scan through list of detaching profilers to make sure none of them give a
     // GetEEToProfPtr() equal to this
 #ifdef FEATURE_PROFAPI_ATTACH_DETACH
-    _ASSERTE(ProfilingAPIDetach::GetEEToProfPtr() == NULL);
+    _ASSERTE(!ProfilingAPIDetach::IsEEToProfPtrRegisteredForDetach(this));
 #endif // FEATURE_PROFAPI_ATTACH_DETACH
 
     // Release user-specified profiler DLL
@@ -912,6 +941,12 @@ EEToProfInterfaceImpl::~EEToProfInterfaceImpl()
             m_pCallback10 = NULL;
         }
 
+        if (m_pCallback11 != NULL)
+        {
+            m_pCallback11->Release();
+            m_pCallback11 = NULL;
+        }
+
         // Only unload the V4 profiler if this is not part of shutdown.  This protects
         // Whidbey profilers that aren't used to being FreeLibrary'd.
         if (fIsV4Profiler && !g_fEEShutDown)
@@ -972,8 +1007,6 @@ EEToProfInterfaceImpl::~EEToProfInterfaceImpl()
         m_pSavedAllocDataBlock = NULL;
     }
 
-    m_GUID = k_guidZero;
-
     if (m_csGCRefDataFreeList != NULL)
     {
         ClrDeleteCriticalSection(m_csGCRefDataFreeList);
@@ -993,70 +1026,6 @@ EEToProfInterfaceImpl::~EEToProfInterfaceImpl()
     }
 }
 
-
-
-//---------------------------------------------------------------------------------------
-//
-// Initialize the GUID used for the cookie in remoting callbacks.  If already
-// initialized, this just does nothing and returns S_OK.
-//
-// Return Value:
-//      HRESULT indicating success or failure.  If the GUID was already initialized,
-//      just returns S_OK
-//
-//
-
-HRESULT EEToProfInterfaceImpl::InitGUID()
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        CANNOT_TAKE_LOCK;
-        ASSERT_NO_EE_LOCKS_HELD();
-    }
-    CONTRACTL_END;
-
-    if (IsEqualGUID(m_GUID, k_guidZero))
-    {
-        return CoCreateGuid(&m_GUID);
-    }
-
-    return S_OK;
-}
-
-//---------------------------------------------------------------------------------------
-//
-// Returns a GUID suitable for use as a remoting callback cookie for this thread.
-// The GUID is based on the template GUID (m_GUID), the current thread, and
-// a counter.
-//
-// Arguments:
-//      pGUID - [out] The GUID requested
-//
-
-void EEToProfInterfaceImpl::GetGUID(GUID * pGUID)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        ASSERT_NO_EE_LOCKS_HELD();
-    }
-    CONTRACTL_END;
-
-    // the member GUID and the argument should both be valid
-    _ASSERTE(!(IsEqualGUID(m_GUID, k_guidZero)));
-    _ASSERTE(pGUID);
-
-    // Copy the contents of the template GUID
-    memcpy(pGUID, &m_GUID, sizeof(GUID));
-
-    // Adjust the last two bytes
-    pGUID->Data4[6] = (BYTE) GetCurrentThreadId();
-    pGUID->Data4[7] = (BYTE) InterlockedIncrement((LPLONG)&m_lGUIDCount);
-}
-
 //---------------------------------------------------------------------------------------
 //
 // Wrapper around calling profiler's FunctionIDMapper hook.  Called by JIT.
@@ -1955,14 +1924,13 @@ HRESULT EEToProfInterfaceImpl::EnsureProfilerDetachable()
 {
     LIMITED_METHOD_CONTRACT;
 
-    if (((g_profControlBlock.dwEventMask & COR_PRF_MONITOR_IMMUTABLE) != 0) ||
-        ((g_profControlBlock.dwEventMaskHigh & COR_PRF_HIGH_MONITOR_IMMUTABLE) != 0))
+    if (m_pProfilerInfo->eventMask.IsEventMaskSet(COR_PRF_MONITOR_IMMUTABLE) ||
+        m_pProfilerInfo->eventMask.IsEventMaskHighSet(COR_PRF_HIGH_MONITOR_IMMUTABLE))
     {
         LOG((
             LF_CORPROF,
             LL_ERROR,
-            "**PROF: Profiler may not detach because it set an immutable flag.  Flags = 0x%x.\n",
-            g_profControlBlock.dwEventMask));
+            "**PROF: Profiler may not detach because it set an immutable flag.\n"));
 
         return CORPROF_E_IMMUTABLE_FLAGS_SET;
     }
@@ -2172,6 +2140,15 @@ HRESULT EEToProfInterfaceImpl::SetEventMask(DWORD dwEventMask, DWORD dwEventMask
     }
     CONTRACTL_END;
 
+    BOOL isMainProfiler = g_profControlBlock.IsMainProfiler(this);
+
+    if (!isMainProfiler &&
+        ((dwEventMask & ~COR_PRF_ALLOWABLE_NOTIFICATION_PROFILER)
+            || (dwEventMaskHigh & ~COR_PRF_HIGH_ALLOWABLE_NOTIFICATION_PROFILER)))
+    {
+        return E_INVALIDARG;
+    }
+
     static const DWORD kEventFlagsRequiringSlowPathEnterLeaveHooks =
         COR_PRF_ENABLE_FUNCTION_ARGS   |
         COR_PRF_ENABLE_FUNCTION_RETVAL |
@@ -2222,17 +2199,17 @@ HRESULT EEToProfInterfaceImpl::SetEventMask(DWORD dwEventMask, DWORD dwEventMask
     // not trying to set an immutable attribute
     // FUTURE: If we add immutable flags to the high event mask, this would be a good
     // place to check for them as well.
-    if (g_profControlBlock.curProfStatus.Get() != kProfStatusInitializingForStartupLoad)
+    if (m_pProfilerInfo->curProfStatus.Get() != kProfStatusInitializingForStartupLoad)
     {
 #ifdef _DEBUG
         if (((dwEventMask & dwImmutableEventFlags) !=
-                (g_profControlBlock.dwEventMask & dwImmutableEventFlags)) ||
+                (m_pProfilerInfo->eventMask.GetEventMask() & dwImmutableEventFlags)) ||
 #else //!_DEBUG
         if (((dwEventMask & COR_PRF_MONITOR_IMMUTABLE) !=
-                (g_profControlBlock.dwEventMask & COR_PRF_MONITOR_IMMUTABLE)) ||
+                (m_pProfilerInfo->eventMask.GetEventMask() & COR_PRF_MONITOR_IMMUTABLE)) ||
 #endif //_DEBUG
             ((dwEventMaskHigh & COR_PRF_HIGH_MONITOR_IMMUTABLE) !=
-                (g_profControlBlock.dwEventMaskHigh & COR_PRF_HIGH_MONITOR_IMMUTABLE)))
+                (m_pProfilerInfo->eventMask.GetEventMaskHigh() & COR_PRF_HIGH_MONITOR_IMMUTABLE)))
         {
             // FUTURE: Should we have a dedicated HRESULT for setting immutable flag?
             return E_FAIL;
@@ -2254,7 +2231,7 @@ HRESULT EEToProfInterfaceImpl::SetEventMask(DWORD dwEventMask, DWORD dwEventMask
 
     // After fast path ELT hooks are set in Initial callback, the startup profiler is not allowed to change flags
     // that require slow path ELT hooks or disable ELT hooks.
-    if ((g_profControlBlock.curProfStatus.Get() == kProfStatusInitializingForStartupLoad) &&
+    if ((m_pProfilerInfo->curProfStatus.Get() == kProfStatusInitializingForStartupLoad) &&
         (
             (m_pEnter3    != NULL) ||
             (m_pLeave3    != NULL) ||
@@ -2266,13 +2243,13 @@ HRESULT EEToProfInterfaceImpl::SetEventMask(DWORD dwEventMask, DWORD dwEventMask
         )
        )
     {
-        _ASSERTE((g_profControlBlock.dwEventMask & kEventFlagsRequiringSlowPathEnterLeaveHooks) == 0);
+        _ASSERTE(!m_pProfilerInfo->eventMask.IsEventMaskSet(kEventFlagsRequiringSlowPathEnterLeaveHooks));
         return CORPROF_E_INCONSISTENT_WITH_FLAGS;
     }
 
     // After slow path ELT hooks are set in Initial callback, the startup profiler is not allowed to remove
     // all flags that require slow path ELT hooks or to change the flag to disable the ELT hooks.
-    if ((g_profControlBlock.curProfStatus.Get() == kProfStatusInitializingForStartupLoad) &&
+    if ((m_pProfilerInfo->curProfStatus.Get() == kProfStatusInitializingForStartupLoad) &&
         (
             (m_pEnter3WithInfo    != NULL) ||
             (m_pLeave3WithInfo    != NULL) ||
@@ -2284,7 +2261,7 @@ HRESULT EEToProfInterfaceImpl::SetEventMask(DWORD dwEventMask, DWORD dwEventMask
         )
        )
     {
-        _ASSERTE((g_profControlBlock.dwEventMask & kEventFlagsRequiringSlowPathEnterLeaveHooks) != 0);
+        _ASSERTE(m_pProfilerInfo->eventMask.IsEventMaskSet(kEventFlagsRequiringSlowPathEnterLeaveHooks));
         return CORPROF_E_INCONSISTENT_WITH_FLAGS;
     }
 
@@ -2295,7 +2272,7 @@ HRESULT EEToProfInterfaceImpl::SetEventMask(DWORD dwEventMask, DWORD dwEventMask
         (
             (
                 // Old flags
-                ((g_profControlBlock.dwEventMask & kEventFlagsAffectingEnterLeaveHooks) ^
+                ((m_pProfilerInfo->eventMask.GetEventMask() & kEventFlagsAffectingEnterLeaveHooks) ^
                 // XORed w/ the new flags
                 (dwEventMask & kEventFlagsAffectingEnterLeaveHooks))
             ) != 0
@@ -2316,13 +2293,18 @@ HRESULT EEToProfInterfaceImpl::SetEventMask(DWORD dwEventMask, DWORD dwEventMask
             (m_pTailcall          != NULL)
         );
 
+    if (fEnterLeaveHooksAffected && !isMainProfiler)
+    {
+        return E_INVALIDARG;
+    }
+
     BOOL fNeedToTurnOffConcurrentGC = FALSE;
 
     if (((dwEventMask & COR_PRF_MONITOR_GC) != 0) &&
-        ((g_profControlBlock.dwEventMask & COR_PRF_MONITOR_GC) == 0))
+        ((m_pProfilerInfo->eventMask.GetEventMask() & COR_PRF_MONITOR_GC) == 0))
     {
         // We don't need to worry about startup load as we'll turn off concurrent GC later
-        if (g_profControlBlock.curProfStatus.Get() != kProfStatusInitializingForStartupLoad)
+        if (m_pProfilerInfo->curProfStatus.Get() != kProfStatusInitializingForStartupLoad)
         {
             // Since we're not an initializing startup profiler, the EE must be fully started up
             // so we can check whether concurrent GC is on
@@ -2341,7 +2323,7 @@ HRESULT EEToProfInterfaceImpl::SetEventMask(DWORD dwEventMask, DWORD dwEventMask
 
             // If we are attaching and we are turning on COR_PRF_MONITOR_GC, turn off concurrent GC later
             // in this function
-            if (g_profControlBlock.curProfStatus.Get() == kProfStatusInitializingForAttachLoad)
+            if (m_pProfilerInfo->curProfStatus.Get() == kProfStatusInitializingForAttachLoad)
             {
                 if (GCHeapUtilities::GetGCHeap()->IsConcurrentGCEnabled())
                 {
@@ -2375,12 +2357,12 @@ HRESULT EEToProfInterfaceImpl::SetEventMask(DWORD dwEventMask, DWORD dwEventMask
 
     if ((dwEventMask & COR_PRF_ENABLE_REJIT) != 0)
     {
-        if ((g_profControlBlock.curProfStatus.Get() != kProfStatusInitializingForStartupLoad) && !ReJitManager::IsReJITEnabled())
+        if ((m_pProfilerInfo->curProfStatus.Get() != kProfStatusInitializingForStartupLoad) && !ReJitManager::IsReJITEnabled())
         {
             return CORPROF_E_REJIT_NOT_ENABLED;
         }
 
-        g_profControlBlock.pProfInterface->SetModifiedRejitState();
+        m_pProfilerInfo->pProfInterface->SetModifiedRejitState();
     }
 
     // High event bits
@@ -2398,8 +2380,10 @@ HRESULT EEToProfInterfaceImpl::SetEventMask(DWORD dwEventMask, DWORD dwEventMask
     }
 
     // Now save the modified masks
-    g_profControlBlock.dwEventMask = dwEventMask;
-    g_profControlBlock.dwEventMaskHigh = dwEventMaskHigh;
+    m_pProfilerInfo->eventMask.SetEventMask(dwEventMask);
+    m_pProfilerInfo->eventMask.SetEventMaskHigh(dwEventMaskHigh);
+
+    g_profControlBlock.UpdateGlobalEventMask();
 
     if (fEnterLeaveHooksAffected)
     {
@@ -2410,26 +2394,13 @@ HRESULT EEToProfInterfaceImpl::SetEventMask(DWORD dwEventMask, DWORD dwEventMask
         }
     }
 
-    if (g_profControlBlock.curProfStatus.Get() == kProfStatusInitializingForStartupLoad)
-    {
-        // If the profiler has requested remoting cookies so that it can
-        // track logical call stacks, then we must initialize the cookie
-        // template.
-        if ((g_profControlBlock.dwEventMask & COR_PRF_MONITOR_REMOTING_COOKIE)
-            == COR_PRF_MONITOR_REMOTING_COOKIE)
-        {
-            hr = InitGUID();
-            if (FAILED(hr))
-            {
-                return hr;
-            }
-        }
-    }
-
     // Turn off concurrent GC as the last step so that we don't need to turn it back on if something
     // else failed after that
     if (fNeedToTurnOffConcurrentGC)
     {
+        // Remember that we've turned off concurrent GC and we'll turn it back on in TerminateProfiling
+        g_profControlBlock.fConcurrentGCDisabledForAttach = TRUE;
+
         // Turn off concurrent GC if it is on so that user can walk the heap safely in GC callbacks
         IGCHeap * pGCHeap = GCHeapUtilities::GetGCHeap();
 
@@ -2460,13 +2431,14 @@ HRESULT EEToProfInterfaceImpl::SetEventMask(DWORD dwEventMask, DWORD dwEventMask
                 m_bHasTimedOutWaitingForConcurrentGC = TRUE;
             }
 
+            // TODO: think about race conditions... I am pretty sure there is one
+            // Remember that we've turned off concurrent GC and we'll turn it back on in TerminateProfiling
+            g_profControlBlock.fConcurrentGCDisabledForAttach = FALSE;
             pGCHeap->TemporaryEnableConcurrentGC();
+            
             return hr;
         }
 
-        // Remember that we've turned off concurrent GC and we'll turn it back on in TerminateProfiling
-        g_profControlBlock.fConcurrentGCDisabledForAttach = TRUE;
-
         LOG((LF_CORPROF, LL_INFO10, "**PROF: Concurrent GC has been turned off at attach.\n"));
     }
 
@@ -5338,290 +5310,6 @@ HRESULT EEToProfInterfaceImpl::RuntimeThreadResumed(ThreadID resumedThreadId)
     }
 }
 
-//---------------------------------------------------------------------------------------
-// REMOTING
-//
-
-HRESULT EEToProfInterfaceImpl::RemotingClientInvocationStarted()
-{
-    CONTRACTL
-    {
-        // Yay!
-        NOTHROW;
-
-        // Yay!
-        GC_TRIGGERS;
-
-        // Yay!
-        MODE_PREEMPTIVE;
-
-        // Yay!
-        CAN_TAKE_LOCK;
-
-        // Yay!
-        ASSERT_NO_EE_LOCKS_HELD();
-
-    }
-    CONTRACTL_END;
-
-    CLR_TO_PROFILER_ENTRYPOINT((LF_CORPROF,
-                                LL_INFO1000,
-                                "**PROF: RemotingClientInvocationStarted. ThreadID: 0x%p\n",
-                                GetThreadNULLOk()));
-
-    {
-        // All callbacks are really NOTHROW, but that's enforced partially by the profiler,
-        // whose try/catch blocks aren't visible to the contract system
-        PERMANENT_CONTRACT_VIOLATION(ThrowsViolation, ReasonProfilerCallout);
-        return m_pCallback2->RemotingClientInvocationStarted();
-    }
-}
-
-HRESULT EEToProfInterfaceImpl::RemotingClientSendingMessage(GUID *pCookie, BOOL fIsAsync)
-{
-    CONTRACTL
-    {
-        // Yay!
-        NOTHROW;
-
-        // Yay!
-        GC_TRIGGERS;
-
-        // Yay!
-        MODE_PREEMPTIVE;
-
-        // Yay!
-        CAN_TAKE_LOCK;
-
-        // Yay!
-        ASSERT_NO_EE_LOCKS_HELD();
-
-    }
-    CONTRACTL_END;
-
-    CLR_TO_PROFILER_ENTRYPOINT((LF_CORPROF,
-                                LL_INFO1000,
-                                "**PROF: RemotingClientSendingMessage. ThreadID: 0x%p\n",
-                                GetThreadNULLOk()));
-
-    {
-        // All callbacks are really NOTHROW, but that's enforced partially by the profiler,
-        // whose try/catch blocks aren't visible to the contract system
-        PERMANENT_CONTRACT_VIOLATION(ThrowsViolation, ReasonProfilerCallout);
-        return m_pCallback2->RemotingClientSendingMessage(pCookie, fIsAsync);
-    }
-}
-
-HRESULT EEToProfInterfaceImpl::RemotingClientReceivingReply(GUID * pCookie, BOOL fIsAsync)
-{
-    CONTRACTL
-    {
-        // Yay!
-        NOTHROW;
-
-        // Yay!
-        GC_TRIGGERS;
-
-        // Yay!
-        MODE_PREEMPTIVE;
-
-        // Yay!
-        CAN_TAKE_LOCK;
-
-        // Yay!
-        ASSERT_NO_EE_LOCKS_HELD();
-
-    }
-    CONTRACTL_END;
-
-    CLR_TO_PROFILER_ENTRYPOINT((LF_CORPROF,
-                                LL_INFO1000,
-                                "**PROF: RemotingClientReceivingReply. ThreadID: 0x%p\n",
-                                GetThreadNULLOk()));
-
-    {
-        // All callbacks are really NOTHROW, but that's enforced partially by the profiler,
-        // whose try/catch blocks aren't visible to the contract system
-        PERMANENT_CONTRACT_VIOLATION(ThrowsViolation, ReasonProfilerCallout);
-        return m_pCallback2->RemotingClientReceivingReply(pCookie, fIsAsync);
-    }
-}
-
-HRESULT EEToProfInterfaceImpl::RemotingClientInvocationFinished()
-{
-    CONTRACTL
-    {
-        // Yay!
-        NOTHROW;
-
-        // Yay!
-        GC_TRIGGERS;
-
-        // Yay!
-        MODE_PREEMPTIVE;
-
-        // Yay!
-        CAN_TAKE_LOCK;
-
-        // Yay!
-        ASSERT_NO_EE_LOCKS_HELD();
-
-    }
-    CONTRACTL_END;
-
-    CLR_TO_PROFILER_ENTRYPOINT((LF_CORPROF,
-                                LL_INFO1000,
-                                "**PROF: RemotingClientInvocationFinished. ThreadID: 0x%p\n",
-                                GetThreadNULLOk()));
-
-    {
-        // All callbacks are really NOTHROW, but that's enforced partially by the profiler,
-        // whose try/catch blocks aren't visible to the contract system
-        PERMANENT_CONTRACT_VIOLATION(ThrowsViolation, ReasonProfilerCallout);
-        return m_pCallback2->RemotingClientInvocationFinished();
-    }
-}
-
-HRESULT EEToProfInterfaceImpl::RemotingServerReceivingMessage(GUID *pCookie, BOOL fIsAsync)
-{
-    CONTRACTL
-    {
-        // Yay!
-        NOTHROW;
-
-        // Yay!
-        GC_TRIGGERS;
-
-        // Yay!
-        MODE_PREEMPTIVE;
-
-        // Yay!
-        CAN_TAKE_LOCK;
-
-        // Yay!
-        ASSERT_NO_EE_LOCKS_HELD();
-
-    }
-    CONTRACTL_END;
-
-    CLR_TO_PROFILER_ENTRYPOINT((LF_CORPROF,
-                                LL_INFO1000,
-                                "**PROF: RemotingServerReceivingMessage. ThreadID: 0x%p\n",
-                                GetThreadNULLOk()));
-
-    {
-        // All callbacks are really NOTHROW, but that's enforced partially by the profiler,
-        // whose try/catch blocks aren't visible to the contract system
-        PERMANENT_CONTRACT_VIOLATION(ThrowsViolation, ReasonProfilerCallout);
-        return m_pCallback2->RemotingServerReceivingMessage(pCookie, fIsAsync);
-    }
-}
-
-HRESULT EEToProfInterfaceImpl::RemotingServerInvocationStarted()
-{
-    CONTRACTL
-    {
-        // Yay!
-        NOTHROW;
-
-        // Yay!
-        GC_TRIGGERS;
-
-        // Yay!
-        MODE_PREEMPTIVE;
-
-        // Yay!
-        CAN_TAKE_LOCK;
-
-        // Yay!
-        ASSERT_NO_EE_LOCKS_HELD();
-
-    }
-    CONTRACTL_END;
-
-    CLR_TO_PROFILER_ENTRYPOINT((LF_CORPROF,
-                                LL_INFO1000,
-                                "**PROF: RemotingServerInvocationStarted. ThreadID: 0x%p\n",
-                                GetThreadNULLOk()));
-
-    {
-        // All callbacks are really NOTHROW, but that's enforced partially by the profiler,
-        // whose try/catch blocks aren't visible to the contract system
-        PERMANENT_CONTRACT_VIOLATION(ThrowsViolation, ReasonProfilerCallout);
-        return m_pCallback2->RemotingServerInvocationStarted();
-    }
-}
-
-HRESULT EEToProfInterfaceImpl::RemotingServerInvocationReturned()
-{
-    CONTRACTL
-    {
-        // Yay!
-        NOTHROW;
-
-        // Yay!
-        GC_TRIGGERS;
-
-        // Yay!
-        MODE_PREEMPTIVE;
-
-        // Yay!
-        CAN_TAKE_LOCK;
-
-        // Yay!
-        ASSERT_NO_EE_LOCKS_HELD();
-
-    }
-    CONTRACTL_END;
-
-    CLR_TO_PROFILER_ENTRYPOINT((LF_CORPROF,
-                                LL_INFO1000,
-                                "**PROF: RemotingServerInvocationReturned. ThreadID: 0x%p\n",
-                                GetThreadNULLOk()));
-
-    {
-        // All callbacks are really NOTHROW, but that's enforced partially by the profiler,
-        // whose try/catch blocks aren't visible to the contract system
-        PERMANENT_CONTRACT_VIOLATION(ThrowsViolation, ReasonProfilerCallout);
-        return m_pCallback2->RemotingServerInvocationReturned();
-    }
-}
-
-HRESULT EEToProfInterfaceImpl::RemotingServerSendingReply(GUID *pCookie, BOOL fIsAsync)
-{
-    CONTRACTL
-    {
-        // Yay!
-        NOTHROW;
-
-        // Yay!
-        GC_TRIGGERS;
-
-        // Yay!
-        MODE_PREEMPTIVE;
-
-        // Yay!
-        CAN_TAKE_LOCK;
-
-        // Yay!
-        ASSERT_NO_EE_LOCKS_HELD();
-
-    }
-    CONTRACTL_END;
-
-    CLR_TO_PROFILER_ENTRYPOINT((LF_CORPROF,
-                                LL_INFO1000,
-                                "**PROF: RemotingServerSendingReply. ThreadID: 0x%p\n",
-                                GetThreadNULLOk()));
-
-    {
-        // All callbacks are really NOTHROW, but that's enforced partially by the profiler,
-        // whose try/catch blocks aren't visible to the contract system
-        PERMANENT_CONTRACT_VIOLATION(ThrowsViolation, ReasonProfilerCallout);
-        return m_pCallback2->RemotingServerSendingReply(pCookie, fIsAsync);
-    }
-}
-
 //---------------------------------------------------------------------------------------
 // GC EVENTS
 //
@@ -6354,4 +6042,31 @@ HRESULT EEToProfInterfaceImpl::EventPipeProviderCreated(EventPipeProvider *provi
 #endif // FEATURE_PERFTRACING
 }
 
+HRESULT EEToProfInterfaceImpl::LoadAsNotficationOnly(BOOL *pbNotificationOnly)
+{
+    CONTRACTL
+    {
+        NOTHROW;
+        GC_NOTRIGGER;
+        MODE_ANY;
+    }
+    CONTRACTL_END;
+
+    // This one API is special, we call in to the profiler before we've set up any of our 
+    // machinery to do asserts (m_pProfilerInfo in specific). So we can't use 
+    // CLR_TO_PROFILER_ENTRYPOINT here.
+
+    LOG((LF_CORPROF,
+        LL_INFO1000,
+        "**PROF: LoadAsNotficationOnly.\n"));
+
+    if (m_pCallback11 == NULL)
+    {
+        *pbNotificationOnly = FALSE;
+        return S_OK;
+    }
+
+    return m_pCallback11->LoadAsNotficationOnly(pbNotificationOnly);
+}
+
 #endif // PROFILING_SUPPORTED
diff --git a/src/coreclr/vm/eetoprofinterfaceimpl.h b/src/coreclr/vm/eetoprofinterfaceimpl.h
index c43b859946540f..4ec468a4150c7d 100644
--- a/src/coreclr/vm/eetoprofinterfaceimpl.h
+++ b/src/coreclr/vm/eetoprofinterfaceimpl.h
@@ -33,10 +33,9 @@ class ProfToEEInterfaceImpl;
 interface IAssemblyBindingClosure;
 struct AssemblyReferenceClosureWalkContextForProfAPI;
 
-const GUID k_guidZero = {0};
-
 class EEToProfInterfaceImpl
 {
+    friend class ProfControlBlock;
 public:
 
     //
@@ -54,6 +53,8 @@ class EEToProfInterfaceImpl
         BOOL fLoadedViaAttach,
         DWORD dwConcurrentGCWaitTimeoutInMs);
 
+    void SetProfilerInfo(ProfilerInfo *pProfilerInfo);
+    
     BOOL IsCallback3Supported();
     BOOL IsCallback4Supported();
     BOOL IsCallback5Supported();
@@ -118,15 +119,6 @@ class EEToProfInterfaceImpl
 
     UINT_PTR EEFunctionIDMapper(FunctionID funcId, BOOL * pbHookFunction);
 
-    // This fills in the non call-specific portions of the cookie GUID.
-    // This should only be called once at startup if necessary.
-    HRESULT InitGUID();
-
-    // This will assign a mostly-unique GUID.  If enough calls to GetGUID
-    // are made from the same thread, then the GUIDs will cycle.
-    // (Current, it will cycle every 256 calls)
-    void GetGUID(GUID * pGUID);
-
     //
     // Initialize callback
     //
@@ -376,31 +368,6 @@ class EEToProfInterfaceImpl
         /* [in] */ REFGUID implementedIID,
         /* [in] */ void * pVTable);
 
-    //
-    // Remoting Events
-    //
-
-    HRESULT RemotingClientInvocationStarted();
-
-    HRESULT RemotingClientSendingMessage(GUID * pCookie,
-                                         BOOL fIsAsync);
-
-    HRESULT RemotingClientReceivingReply(GUID * pCookie,
-                                         BOOL fIsAsync);
-
-    HRESULT RemotingClientInvocationFinished();
-
-    HRESULT RemotingServerReceivingMessage(GUID * pCookie,
-                                           BOOL fIsAsync);
-
-    HRESULT RemotingServerInvocationStarted();
-
-    HRESULT RemotingServerInvocationReturned();
-
-    HRESULT RemotingServerSendingReply(GUID * pCookie,
-                                       BOOL fIsAsync);
-
-
     //
     // GC Events
     //
@@ -507,6 +474,8 @@ class EEToProfInterfaceImpl
 
     HRESULT EventPipeProviderCreated(EventPipeProvider *provider);
 
+    HRESULT LoadAsNotficationOnly(BOOL *pbNotificationOnly);
+
 private:
 
     //
@@ -578,6 +547,7 @@ class EEToProfInterfaceImpl
     ICorProfilerCallback8  * m_pCallback8;
     ICorProfilerCallback9  * m_pCallback9;
     ICorProfilerCallback10 * m_pCallback10;
+    ICorProfilerCallback11 * m_pCallback11;
 
     HMODULE                 m_hmodProfilerDLL;
 
@@ -589,13 +559,6 @@ class EEToProfInterfaceImpl
     FunctionIDMapper2 * m_pProfilersFuncIDMapper2;
     void * m_pProfilersFuncIDMapper2ClientData;
 
-    // This is used as a cookie template for remoting calls
-    GUID m_GUID;
-
-    // This is an incrementing counter for constructing unique GUIDS from
-    // m_GUID
-    LONG m_lGUIDCount;
-
     // This will contain a list of free ref data structs, so they
     // don't have to be re-allocated on every GC
     GCReferencesData * m_pGCRefDataFreeList;
@@ -628,6 +591,7 @@ class EEToProfInterfaceImpl
 
     // Remember whether the profiler has enabled Rejit, and prevent detach if it has.
     BOOL                    m_fModifiedRejitState;
+    ProfilerInfo           *m_pProfilerInfo;
 
     GCReferencesData * AllocateMovedReferencesData();
 
diff --git a/src/coreclr/vm/eetoprofinterfaceimpl.inl b/src/coreclr/vm/eetoprofinterfaceimpl.inl
index 48a07b5a237013..1ed73db1f583ac 100644
--- a/src/coreclr/vm/eetoprofinterfaceimpl.inl
+++ b/src/coreclr/vm/eetoprofinterfaceimpl.inl
@@ -247,7 +247,7 @@ inline BOOL EEToProfInterfaceImpl::RequiresGenericsContextForEnterLeave()
 
     return
         CORProfilerPresent() &&
-        ((g_profControlBlock.dwEventMask & COR_PRF_ENABLE_FRAME_INFO) != 0) &&
+        ((&g_profControlBlock)->globalEventMask.IsEventMaskSet(COR_PRF_ENABLE_FRAME_INFO)) &&
         (
             (m_pEnter2            != NULL) ||
             (m_pLeave2            != NULL) ||
diff --git a/src/coreclr/vm/eetoprofinterfacewrapper.inl b/src/coreclr/vm/eetoprofinterfacewrapper.inl
index bdf328e4c7ad23..afa00001b17b8a 100644
--- a/src/coreclr/vm/eetoprofinterfacewrapper.inl
+++ b/src/coreclr/vm/eetoprofinterfacewrapper.inl
@@ -32,15 +32,15 @@ class EEToProfilerExceptionInterfaceWrapper
     {
         WRAPPER_NO_CONTRACT;
         {
-            BEGIN_PIN_PROFILER(CORProfilerTrackExceptions());
+            BEGIN_PROFILER_CALLBACK(CORProfilerTrackExceptions());
             _ASSERTE(pThread->PreemptiveGCDisabled());
 
             // Get a reference to the object that won't move
             OBJECTREF thrown = pThread->GetThrowable();
 
-            g_profControlBlock.pProfInterface->ExceptionThrown(
+            (&g_profControlBlock)->ExceptionThrown(
                 reinterpret_cast<ObjectID>((*(BYTE **)&thrown)));
-            END_PIN_PROFILER();
+            END_PROFILER_CALLBACK();
         }
     }
 
@@ -53,14 +53,14 @@ class EEToProfilerExceptionInterfaceWrapper
         WRAPPER_NO_CONTRACT;
         // Notify the profiler of the function being searched for a handler.
         {
-            BEGIN_PIN_PROFILER(CORProfilerTrackExceptions());
+            BEGIN_PROFILER_CALLBACK(CORProfilerTrackExceptions());
             if (!pFunction->IsNoMetadata())
             {
                 GCX_PREEMP();
-                g_profControlBlock.pProfInterface->ExceptionSearchFunctionEnter(
+                (&g_profControlBlock)->ExceptionSearchFunctionEnter(
                     (FunctionID) pFunction);
             }
-            END_PIN_PROFILER();
+            END_PROFILER_CALLBACK();
         }
     }
 
@@ -69,13 +69,13 @@ class EEToProfilerExceptionInterfaceWrapper
         WRAPPER_NO_CONTRACT;
         // Notify the profiler of the function being searched for a handler.
         {
-            BEGIN_PIN_PROFILER(CORProfilerTrackExceptions());
+            BEGIN_PROFILER_CALLBACK(CORProfilerTrackExceptions());
             if (!pFunction->IsNoMetadata())
             {
                 GCX_PREEMP();
-                g_profControlBlock.pProfInterface->ExceptionSearchFunctionLeave();
+                (&g_profControlBlock)->ExceptionSearchFunctionLeave();
             }
-            END_PIN_PROFILER();
+            END_PROFILER_CALLBACK();
         }
     }
 
@@ -84,14 +84,14 @@ class EEToProfilerExceptionInterfaceWrapper
         WRAPPER_NO_CONTRACT;
         // Notify the profiler of the filter.
         {
-            BEGIN_PIN_PROFILER(CORProfilerTrackExceptions());
+            BEGIN_PROFILER_CALLBACK(CORProfilerTrackExceptions());
             if (!pFunc->IsNoMetadata())
             {
                 GCX_PREEMP();
-                g_profControlBlock.pProfInterface->ExceptionSearchFilterEnter(
+                (&g_profControlBlock)->ExceptionSearchFilterEnter(
                     (FunctionID) pFunc);
             }
-            END_PIN_PROFILER();
+            END_PROFILER_CALLBACK();
         }
     }
 
@@ -100,10 +100,10 @@ class EEToProfilerExceptionInterfaceWrapper
         WRAPPER_NO_CONTRACT;
         // Notify the profiler of the filter.
         {
-            BEGIN_PIN_PROFILER(CORProfilerTrackExceptions());
+            BEGIN_PROFILER_CALLBACK(CORProfilerTrackExceptions());
             GCX_PREEMP();
-            g_profControlBlock.pProfInterface->ExceptionSearchFilterLeave();
-            END_PIN_PROFILER();
+            (&g_profControlBlock)->ExceptionSearchFilterLeave();
+            END_PROFILER_CALLBACK();
         }
     }
 
@@ -111,14 +111,14 @@ class EEToProfilerExceptionInterfaceWrapper
     {
         WRAPPER_NO_CONTRACT;
         {
-            BEGIN_PIN_PROFILER(CORProfilerTrackExceptions());
+            BEGIN_PROFILER_CALLBACK(CORProfilerTrackExceptions());
             if (!pFunc->IsNoMetadata())
             {
                 GCX_PREEMP();
-                g_profControlBlock.pProfInterface->ExceptionSearchCatcherFound(
+                (&g_profControlBlock)->ExceptionSearchCatcherFound(
                     (FunctionID) pFunc);
             }
-            END_PIN_PROFILER();
+            END_PROFILER_CALLBACK();
         }
     }
 
@@ -130,13 +130,13 @@ class EEToProfilerExceptionInterfaceWrapper
         WRAPPER_NO_CONTRACT;
         // Notify the profiler of the function being searched for a handler.
         {
-            BEGIN_PIN_PROFILER(CORProfilerTrackExceptions());
+            BEGIN_PROFILER_CALLBACK(CORProfilerTrackExceptions());
             if (!pFunc->IsNoMetadata())
             {
-                g_profControlBlock.pProfInterface->ExceptionUnwindFunctionEnter(
+                (&g_profControlBlock)->ExceptionUnwindFunctionEnter(
                     (FunctionID) pFunc);
             }
-            END_PIN_PROFILER();
+            END_PROFILER_CALLBACK();
         }
     }
 
@@ -145,12 +145,12 @@ class EEToProfilerExceptionInterfaceWrapper
         WRAPPER_NO_CONTRACT;
         // Notify the profiler that searching this function is over.
         {
-            BEGIN_PIN_PROFILER(CORProfilerTrackExceptions());
+            BEGIN_PROFILER_CALLBACK(CORProfilerTrackExceptions());
             if (!pFunction->IsNoMetadata())
             {
-                g_profControlBlock.pProfInterface->ExceptionUnwindFunctionLeave();
+                (&g_profControlBlock)->ExceptionUnwindFunctionLeave();
             }
-            END_PIN_PROFILER();
+            END_PROFILER_CALLBACK();
         }
     }
 
@@ -159,13 +159,13 @@ class EEToProfilerExceptionInterfaceWrapper
         WRAPPER_NO_CONTRACT;
         // Notify the profiler of the function being searched for a handler.
         {
-            BEGIN_PIN_PROFILER(CORProfilerTrackExceptions());
+            BEGIN_PROFILER_CALLBACK(CORProfilerTrackExceptions());
             if (!pFunc->IsNoMetadata())
             {
-                g_profControlBlock.pProfInterface->ExceptionUnwindFinallyEnter(
+                (&g_profControlBlock)->ExceptionUnwindFinallyEnter(
                     (FunctionID) pFunc);
             }
-            END_PIN_PROFILER();
+            END_PROFILER_CALLBACK();
         }
     }
 
@@ -174,9 +174,9 @@ class EEToProfilerExceptionInterfaceWrapper
         WRAPPER_NO_CONTRACT;
         // Notify the profiler of the function being searched for a handler.
         {
-            BEGIN_PIN_PROFILER(CORProfilerTrackExceptions());
-            g_profControlBlock.pProfInterface->ExceptionUnwindFinallyLeave();
-            END_PIN_PROFILER();
+            BEGIN_PROFILER_CALLBACK(CORProfilerTrackExceptions());
+            (&g_profControlBlock)->ExceptionUnwindFinallyLeave();
+            END_PROFILER_CALLBACK();
         }
     }
 
@@ -185,7 +185,7 @@ class EEToProfilerExceptionInterfaceWrapper
         WRAPPER_NO_CONTRACT;
         // Notify the profiler.
         {
-            BEGIN_PIN_PROFILER(CORProfilerTrackExceptions());
+            BEGIN_PROFILER_CALLBACK(CORProfilerTrackExceptions());
             if (!pFunc->IsNoMetadata())
             {
                 // <TODO>Remove the thrown variable as well as the
@@ -197,13 +197,13 @@ class EEToProfilerExceptionInterfaceWrapper
                 GCPROTECT_BEGIN(thrown);
                 thrown = pThread->GetThrowable();
                 {
-                    g_profControlBlock.pProfInterface->ExceptionCatcherEnter(
+                    (&g_profControlBlock)->ExceptionCatcherEnter(
                         (FunctionID) pFunc,
                         reinterpret_cast<ObjectID>((*(BYTE **)&thrown)));
                 }
                 GCPROTECT_END();
             }
-            END_PIN_PROFILER();
+            END_PROFILER_CALLBACK();
         }
     }
 
@@ -212,9 +212,9 @@ class EEToProfilerExceptionInterfaceWrapper
         WRAPPER_NO_CONTRACT;
         // Notify the profiler of the function being searched for a handler.
         {
-            BEGIN_PIN_PROFILER(CORProfilerTrackExceptions());
-            g_profControlBlock.pProfInterface->ExceptionCatcherLeave();
-            END_PIN_PROFILER();
+            BEGIN_PROFILER_CALLBACK(CORProfilerTrackExceptions());
+            (&g_profControlBlock)->ExceptionCatcherLeave();
+            END_PROFILER_CALLBACK();
         }
     }
 
diff --git a/src/coreclr/vm/eventing/eventpipe/ds-rt-coreclr.h b/src/coreclr/vm/eventing/eventpipe/ds-rt-coreclr.h
index 58263ae1a79176..8094d7b22d9dce 100644
--- a/src/coreclr/vm/eventing/eventpipe/ds-rt-coreclr.h
+++ b/src/coreclr/vm/eventing/eventpipe/ds-rt-coreclr.h
@@ -310,10 +310,12 @@ ds_rt_profiler_startup (DiagnosticsStartupProfilerCommandPayload *payload)
 	STATIC_CONTRACT_NOTHROW;
 
 	HRESULT hr = S_OK;
-	EX_TRY {
-		memcpy(&(g_profControlBlock.clsStoredProfilerGuid), reinterpret_cast<const CLSID *>(ds_startup_profiler_command_payload_get_profiler_guid_cref (payload)), sizeof(CLSID));
-		g_profControlBlock.sStoredProfilerPath.Set(reinterpret_cast<LPCWSTR>(ds_startup_profiler_command_payload_get_profiler_path (payload)));
-		g_profControlBlock.fIsStoredProfilerRegistered = TRUE;
+	EX_TRY {        
+		StoredProfilerNode *profilerData = new StoredProfilerNode();
+		profilerData->guid = *(reinterpret_cast<const CLSID *>(ds_startup_profiler_command_payload_get_profiler_guid_cref (payload)));
+		profilerData->path.Set(reinterpret_cast<LPCWSTR>(ds_startup_profiler_command_payload_get_profiler_path (payload)));
+
+		g_profControlBlock.storedProfilers.InsertHead(profilerData);
 	}
 	EX_CATCH_HRESULT (hr);
 
diff --git a/src/coreclr/vm/eventing/eventpipe/ep-rt-coreclr.h b/src/coreclr/vm/eventing/eventpipe/ep-rt-coreclr.h
index a6400416a4e144..607286d048bab0 100644
--- a/src/coreclr/vm/eventing/eventpipe/ep-rt-coreclr.h
+++ b/src/coreclr/vm/eventing/eventpipe/ep-rt-coreclr.h
@@ -12,6 +12,7 @@
 #include "fstream.h"
 #include "typestring.h"
 #include "win32threadpool.h"
+#include "clrversion.h"
 
 #undef EP_ARRAY_SIZE
 #define EP_ARRAY_SIZE(expr) (sizeof(expr) / sizeof ((expr) [0]))
@@ -1161,6 +1162,25 @@ ep_rt_coreclr_config_lock_get (void)
 	return &_ep_rt_coreclr_config_lock_handle;
 }
 
+static
+inline
+const ep_char8_t *
+ep_rt_entrypoint_assembly_name_get_utf8 (void)
+{
+	STATIC_CONTRACT_NOTHROW;
+
+	return reinterpret_cast<const ep_char8_t*>(GetAppDomain ()->GetRootAssembly ()->GetSimpleName ());
+}
+
+static
+const ep_char8_t *
+ep_rt_runtime_version_get_utf8 (void)
+{
+	STATIC_CONTRACT_NOTHROW;
+
+	return reinterpret_cast<const ep_char8_t*>(CLR_PRODUCT_VERSION);
+}
+
 /*
 * Atomics.
 */
@@ -1448,10 +1468,6 @@ void
 ep_rt_prepare_provider_invoke_callback (EventPipeProviderCallbackData *provider_callback_data)
 {
 	STATIC_CONTRACT_NOTHROW;
-
-#if defined(HOST_OSX) && defined(HOST_ARM64)
-	auto jitWriteEnableHolder = PAL_JITWriteEnable(false);
-#endif // defined(HOST_OSX) && defined(HOST_ARM64)
 }
 
 static
@@ -1645,9 +1661,9 @@ ep_rt_notify_profiler_provider_created (EventPipeProvider *provider)
 
 #ifndef DACCESS_COMPILE
 		// Let the profiler know the provider has been created so it can register if it wants to
-		BEGIN_PIN_PROFILER (CORProfilerIsMonitoringEventPipe ());
-		g_profControlBlock.pProfInterface->EventPipeProviderCreated (provider);
-		END_PIN_PROFILER ();
+		BEGIN_PROFILER_CALLBACK (CORProfilerTrackEventPipe ());
+		(&g_profControlBlock)->EventPipeProviderCreated (provider);
+		END_PROFILER_CALLBACK ();
 #endif // DACCESS_COMPILE
 }
 
diff --git a/src/coreclr/vm/eventpipeadapter.h b/src/coreclr/vm/eventpipeadapter.h
index 1510622a2658b7..28a0c9fb1d60ca 100644
--- a/src/coreclr/vm/eventpipeadapter.h
+++ b/src/coreclr/vm/eventpipeadapter.h
@@ -200,7 +200,8 @@ class EventPipeAdapter final
 		EventPipeSerializationFormat format,
 		const bool rundownRequested,
 		IpcStream *const stream,
-		EventPipeSessionSynchronousCallback callback)
+		EventPipeSessionSynchronousCallback callback,
+		void *callbackAdditionalData)
 	{
 		CONTRACTL
 		{
@@ -222,7 +223,8 @@ class EventPipeAdapter final
 			format,
 			rundownRequested,
 			stream,
-			callback);
+			callback,
+			callbackAdditionalData);
 		ep_rt_utf8_string_free (outputPathUTF8);
 		return result;
 	}
diff --git a/src/coreclr/vm/eventpipeinternal.cpp b/src/coreclr/vm/eventpipeinternal.cpp
index 7d0e429be2e08b..7097cb6208d34b 100644
--- a/src/coreclr/vm/eventpipeinternal.cpp
+++ b/src/coreclr/vm/eventpipeinternal.cpp
@@ -42,6 +42,7 @@ UINT64 QCALLTYPE EventPipeInternal::Enable(
             format,
             true,
             nullptr,
+            nullptr,
             nullptr);
         EventPipeAdapter::StartStreaming(sessionID);
     }
diff --git a/src/coreclr/vm/eventtrace.cpp b/src/coreclr/vm/eventtrace.cpp
index 99620ac07e2a8b..14bd22538d2b58 100644
--- a/src/coreclr/vm/eventtrace.cpp
+++ b/src/coreclr/vm/eventtrace.cpp
@@ -682,13 +682,13 @@ void ETW::GCLog::MovedReference(
     // ProfAPI
     if (fAllowProfApiNotification)
     {
-        BEGIN_PIN_PROFILER(CORProfilerTrackGC() || CORProfilerTrackGCMovedObjects());
-        g_profControlBlock.pProfInterface->MovedReference(pbMemBlockStart,
+        BEGIN_PROFILER_CALLBACK(CORProfilerTrackGC() || CORProfilerTrackGCMovedObjects());
+        (&g_profControlBlock)->MovedReference(pbMemBlockStart,
                                                           pbMemBlockEnd,
                                                           cbRelocDistance,
                                                           &(pCtxForEtwAndProfapi->pctxProfAPI),
                                                           fCompacting);
-        END_PIN_PROFILER();
+        END_PROFILER_CALLBACK();
     }
 #endif // PROFILING_SUPPORTED
 
@@ -808,9 +808,9 @@ VOID ETW::GCLog::EndMovedReferences(size_t profilingContext, BOOL fAllowProfApiN
     // ProfAPI
     if (fAllowProfApiNotification)
     {
-        BEGIN_PIN_PROFILER(CORProfilerTrackGC() || CORProfilerTrackGCMovedObjects());
-        g_profControlBlock.pProfInterface->EndMovedReferences(&(pCtxForEtwAndProfapi->pctxProfAPI));
-        END_PIN_PROFILER();
+        BEGIN_PROFILER_CALLBACK(CORProfilerTrackGC() || CORProfilerTrackGCMovedObjects());
+        (&g_profControlBlock)->EndMovedReferences(&(pCtxForEtwAndProfapi->pctxProfAPI));
+        END_PROFILER_CALLBACK();
     }
 #endif //PROFILING_SUPPORTED
 
diff --git a/src/coreclr/vm/exceptionhandling.cpp b/src/coreclr/vm/exceptionhandling.cpp
index 963df734959f86..7fff234ca85ef3 100644
--- a/src/coreclr/vm/exceptionhandling.cpp
+++ b/src/coreclr/vm/exceptionhandling.cpp
@@ -1219,7 +1219,7 @@ lExit: ;
                 invalidRevPInvoke = gcInfoDecoder.GetReversePInvokeFrameStackSlot() != NO_REVERSE_PINVOKE_FRAME;
 #else // USE_GC_INFO_DECODER
                 hdrInfo gcHdrInfo;
-                DecodeGCHdrInfo(gcInfoToken, 0, &gcHdrInfo);
+                DecodeGCHdrInfo(codeInfo.GetGCInfoToken(), 0, &gcHdrInfo);
                 invalidRevPInvoke = gcHdrInfo.revPInvokeOffset != INVALID_REV_PINVOKE_OFFSET;
 #endif // USE_GC_INFO_DECODER
 
@@ -4640,7 +4640,7 @@ VOID DECLSPEC_NORETURN UnwindManagedExceptionPass1(PAL_SEHException& ex, CONTEXT
         invalidRevPInvoke = gcInfoDecoder.GetReversePInvokeFrameStackSlot() != NO_REVERSE_PINVOKE_FRAME;
 #else // USE_GC_INFO_DECODER
         hdrInfo gcHdrInfo;
-        DecodeGCHdrInfo(gcInfoToken, 0, &gcHdrInfo);
+        DecodeGCHdrInfo(codeInfo.GetGCInfoToken(), 0, &gcHdrInfo);
         invalidRevPInvoke = gcHdrInfo.revPInvokeOffset != INVALID_REV_PINVOKE_OFFSET;
 #endif // USE_GC_INFO_DECODER
 
diff --git a/src/coreclr/vm/fcall.h b/src/coreclr/vm/fcall.h
index b330797631de05..ff8e488515faec 100644
--- a/src/coreclr/vm/fcall.h
+++ b/src/coreclr/vm/fcall.h
@@ -1145,6 +1145,7 @@ struct FCSigCheck {
 #define HCIMPL2_IV(rettype, funcname, a1, a2) rettype F_CALL_CONV funcname(int /* EAX */, int /* EDX */, a1, a2) { HCIMPL_PROLOG(funcname)
 #define HCIMPL2VA(rettype, funcname, a1, a2) rettype F_CALL_VA_CONV funcname(a1, a2, ...) { HCIMPL_PROLOG(funcname)
 #define HCIMPL3(rettype, funcname, a1, a2, a3) rettype F_CALL_CONV funcname(int /* EAX */, a2, a1, a3) { HCIMPL_PROLOG(funcname)
+#define HCIMPL3_RAW(rettype, funcname, a1, a2, a3) rettype F_CALL_CONV funcname(int /* EAX */, a2, a1, a3) {
 #define HCIMPL4(rettype, funcname, a1, a2, a3, a4) rettype F_CALL_CONV funcname(int /* EAX */, a2, a1, a4, a3) { HCIMPL_PROLOG(funcname)
 #define HCIMPL5(rettype, funcname, a1, a2, a3, a4, a5) rettype F_CALL_CONV funcname(int /* EAX */, a2, a1, a5, a4, a3) { HCIMPL_PROLOG(funcname)
 
@@ -1169,6 +1170,7 @@ struct FCSigCheck {
 #define HCIMPL2_IV(rettype, funcname, a1, a2) rettype F_CALL_CONV funcname(a1, a2) { HCIMPL_PROLOG(funcname)
 #define HCIMPL2VA(rettype, funcname, a1, a2) rettype F_CALL_VA_CONV funcname(a1, a2, ...) { HCIMPL_PROLOG(funcname)
 #define HCIMPL3(rettype, funcname, a1, a2, a3) rettype F_CALL_CONV funcname(a1, a2, a3) { HCIMPL_PROLOG(funcname)
+#define HCIMPL3_RAW(rettype, funcname, a1, a2, a3) rettype F_CALL_CONV funcname(a1, a2, a3) {
 #define HCIMPL4(rettype, funcname, a1, a2, a3, a4) rettype F_CALL_CONV funcname(a1, a2, a4, a3) { HCIMPL_PROLOG(funcname)
 #define HCIMPL5(rettype, funcname, a1, a2, a3, a4, a5) rettype F_CALL_CONV funcname(a1, a2, a5, a4, a3) { HCIMPL_PROLOG(funcname)
 
@@ -1194,6 +1196,7 @@ struct FCSigCheck {
 #define HCIMPL2_IV(rettype, funcname, a1, a2) rettype F_CALL_CONV funcname(a1, a2) { HCIMPL_PROLOG(funcname)
 #define HCIMPL2VA(rettype, funcname, a1, a2) rettype F_CALL_VA_CONV funcname(a1, a2, ...) { HCIMPL_PROLOG(funcname)
 #define HCIMPL3(rettype, funcname, a1, a2, a3) rettype F_CALL_CONV funcname(a1, a2, a3) { HCIMPL_PROLOG(funcname)
+#define HCIMPL3_RAW(rettype, funcname, a1, a2, a3) rettype F_CALL_CONV funcname(a1, a2, a3) {
 #define HCIMPL4(rettype, funcname, a1, a2, a3, a4) rettype F_CALL_CONV funcname(a1, a2, a3, a4) { HCIMPL_PROLOG(funcname)
 #define HCIMPL5(rettype, funcname, a1, a2, a3, a4, a5) rettype F_CALL_CONV funcname(a1, a2, a3, a4, a5) { HCIMPL_PROLOG(funcname)
 
diff --git a/src/coreclr/vm/field.cpp b/src/coreclr/vm/field.cpp
index 025d9ab8d0b3b9..74ff8415098171 100644
--- a/src/coreclr/vm/field.cpp
+++ b/src/coreclr/vm/field.cpp
@@ -18,6 +18,25 @@
 
 #include "peimagelayout.inl"
 
+#ifndef DACCESS_COMPILE
+VOID FieldDesc::SetStaticOBJECTREF(OBJECTREF objRef)
+{
+    CONTRACTL
+    {
+        THROWS;
+        GC_TRIGGERS;
+        MODE_COOPERATIVE;
+        INJECT_FAULT(COMPlusThrowOM());
+    }
+    CONTRACTL_END
+
+    GCPROTECT_BEGIN(objRef);
+    OBJECTREF *pObjRef = (OBJECTREF *)GetCurrentStaticAddress();
+    SetObjectReference(pObjRef, objRef);
+    GCPROTECT_END();
+}
+#endif
+
 // called from code:MethodTableBuilder::InitializeFieldDescs#InitCall
 VOID FieldDesc::Init(mdFieldDef mb, CorElementType FieldType, DWORD dwMemberAttrs, BOOL fIsStatic, BOOL fIsRVA, BOOL fIsThreadLocal, LPCSTR pszFieldName)
 {
diff --git a/src/coreclr/vm/field.h b/src/coreclr/vm/field.h
index be57bec9d0c605..8fa87edc30f269 100644
--- a/src/coreclr/vm/field.h
+++ b/src/coreclr/vm/field.h
@@ -483,22 +483,7 @@ class FieldDesc
         return *(OBJECTREF *)GetCurrentStaticAddress();
     }
 
-    VOID SetStaticOBJECTREF(OBJECTREF objRef)
-    {
-        CONTRACTL
-        {
-            THROWS;
-            GC_TRIGGERS;
-            MODE_COOPERATIVE;
-            INJECT_FAULT(COMPlusThrowOM());
-        }
-        CONTRACTL_END
-
-        GCPROTECT_BEGIN(objRef);
-        OBJECTREF *pObjRef = (OBJECTREF *)GetCurrentStaticAddress();
-        SetObjectReference(pObjRef, objRef);
-        GCPROTECT_END();
-    }
+    VOID SetStaticOBJECTREF(OBJECTREF objRef);
 
     void*   GetStaticValuePtr()
     {
diff --git a/src/coreclr/vm/gccover.cpp b/src/coreclr/vm/gccover.cpp
index 9765633eb5996f..be856dbe1a63ae 100644
--- a/src/coreclr/vm/gccover.cpp
+++ b/src/coreclr/vm/gccover.cpp
@@ -491,6 +491,8 @@ void GCCoverageInfo::SprinkleBreakpoints(
 #if (defined(TARGET_X86) || defined(TARGET_AMD64)) && USE_DISASSEMBLER
 
     BYTE * codeStart = (BYTE *)pCode;
+    ExecutableWriterHolder<BYTE> codeWriterHolder;
+    size_t writeableOffset;
 
     memcpy(saveAddr, codeStart, codeSize);
 
@@ -499,6 +501,12 @@ void GCCoverageInfo::SprinkleBreakpoints(
     {
         DWORD oldProtect;
         ClrVirtualProtect(codeStart, codeSize, PAGE_EXECUTE_READWRITE, &oldProtect);
+        writeableOffset = 0;
+    }
+    else
+    {
+        codeWriterHolder = ExecutableWriterHolder<BYTE>(codeStart, codeSize);
+        writeableOffset = codeWriterHolder.GetRW() - codeStart;
     }
 
     PBYTE cur;
@@ -579,7 +587,7 @@ void GCCoverageInfo::SprinkleBreakpoints(
             if(safePointDecoder.IsSafePoint((UINT32)(cur + len - codeStart + regionOffsetAdj)))
 #endif
             {
-               *cur = INTERRUPT_INSTR_CALL;        // return value.  May need to protect
+               *(cur + writeableOffset) = INTERRUPT_INSTR_CALL;        // return value.  May need to protect
             }
             break;
 
@@ -614,7 +622,7 @@ void GCCoverageInfo::SprinkleBreakpoints(
 
         if (prevDirectCallTargetMD != 0)
         {
-            ReplaceInstrAfterCall(cur, prevDirectCallTargetMD);
+            ReplaceInstrAfterCall(cur + writeableOffset, prevDirectCallTargetMD);
         }
 
         // For fully interruptible code, we end up whacking every instruction
@@ -625,7 +633,7 @@ void GCCoverageInfo::SprinkleBreakpoints(
         _ASSERTE(FitsIn<DWORD>(dwRelOffset));
         if (codeMan->IsGcSafe(&codeInfo, static_cast<DWORD>(dwRelOffset)))
         {
-            *cur = INTERRUPT_INSTR;
+            *(cur + writeableOffset) = INTERRUPT_INSTR;
         }
 
 #ifdef TARGET_X86
@@ -633,7 +641,7 @@ void GCCoverageInfo::SprinkleBreakpoints(
         // our unwinding logic works there.
         if (codeMan->IsInPrologOrEpilog((cur - codeStart) + (DWORD)regionOffsetAdj, gcInfoToken, NULL))
         {
-            *cur = INTERRUPT_INSTR;
+            *(cur + writeableOffset) = INTERRUPT_INSTR;
         }
 #endif
 
@@ -801,14 +809,21 @@ void replaceSafePointInstructionWithGcStressInstr(UINT32 safePointOffset, LPVOID
     // instruction will not be a call instruction.
     //_ASSERTE(instructionIsACallThroughRegister ^ instructionIsACallThroughImmediate);
 
+#if defined(TARGET_ARM)
+    size_t instrLen = sizeof(WORD);
+#else
+    size_t instrLen = sizeof(DWORD);
+#endif
+
+    ExecutableWriterHolder<BYTE> instrPtrWriterHolder(instrPtr - instrLen, 2 * instrLen);
     if(instructionIsACallThroughRegister)
     {
         // If it is call by register then cannot know MethodDesc so replace the call instruction with illegal instruction
         // safe point will be replaced with appropriate illegal instruction at execution time when reg value is known
 #if defined(TARGET_ARM)
-        *((WORD*)instrPtr - 1) = INTERRUPT_INSTR_CALL;
+        *((WORD*)instrPtrWriterHolder.GetRW()) = INTERRUPT_INSTR_CALL;
 #elif defined(TARGET_ARM64)
-        *((DWORD*)instrPtr - 1) = INTERRUPT_INSTR_CALL;
+        *((DWORD*)instrPtrWriterHolder.GetRW()) = INTERRUPT_INSTR_CALL;
 #endif // _TARGET_XXXX_
     }
     else if(instructionIsACallThroughImmediate)
@@ -856,7 +871,7 @@ void replaceSafePointInstructionWithGcStressInstr(UINT32 safePointOffset, LPVOID
 
                 if (fGcStressOnDirectCalls.val(CLRConfig::INTERNAL_GcStressOnDirectCalls))
                 {
-                    ReplaceInstrAfterCall(instrPtr, targetMD);
+                    ReplaceInstrAfterCall(instrPtrWriterHolder.GetRW() + instrLen, targetMD);
                 }
             }
         }
@@ -910,25 +925,27 @@ bool replaceInterruptibleRangesWithGcStressInstr (UINT32 startOffset, UINT32 sto
     // Need to do two iterations if interruptible range spans across hot & cold region
     while(acrossHotRegion--)
     {
-        PBYTE instrPtr = rangeStart;
-        while(instrPtr < rangeStop)
+        ExecutableWriterHolder<BYTE> instrPtrWriterHolder(rangeStart, rangeStop - rangeStart);
+        PBYTE instrPtrRW =  instrPtrWriterHolder.GetRW();
+        PBYTE rangeStopRW = instrPtrRW + (rangeStop - rangeStart);
+        while(instrPtrRW < rangeStopRW)
         {
             // The instruction about to be replaced cannot already be a gcstress instruction
-            _ASSERTE(!IsGcCoverageInterruptInstruction(instrPtr));
+            _ASSERTE(!IsGcCoverageInterruptInstruction(instrPtrRW));
 #if defined(TARGET_ARM)
-            size_t instrLen = GetARMInstructionLength(instrPtr);
+            size_t instrLen = GetARMInstructionLength(instrPtrRW);
 
             if (instrLen == 2)
-                *((WORD*)instrPtr)  = INTERRUPT_INSTR;
+                *((WORD*)instrPtrRW)  = INTERRUPT_INSTR;
             else
             {
-                *((DWORD*)instrPtr) = INTERRUPT_INSTR_32;
+                *((DWORD*)instrPtrRW) = INTERRUPT_INSTR_32;
             }
 
-            instrPtr += instrLen;
+            instrPtrRW += instrLen;
 #elif defined(TARGET_ARM64)
-            *((DWORD*)instrPtr) = INTERRUPT_INSTR;
-            instrPtr += 4;
+            *((DWORD*)instrPtrRW) = INTERRUPT_INSTR;
+            instrPtrRW += 4;
 #endif // TARGET_XXXX_
 
         }
@@ -1239,19 +1256,16 @@ bool IsGcCoverageInterrupt(LPVOID ip)
 
 void RemoveGcCoverageInterrupt(TADDR instrPtr, BYTE * savedInstrPtr, GCCoverageInfo* gcCover, DWORD offset)
 {
-#if defined(HOST_OSX) && defined(HOST_ARM64)
-        auto jitWriteEnableHolder = PAL_JITWriteEnable(true);
-#endif // defined(HOST_OSX) && defined(HOST_ARM64)
-
+    ExecutableWriterHolder<void> instrPtrWriterHolder((void*)instrPtr, 4);
 #ifdef TARGET_ARM
         if (GetARMInstructionLength(savedInstrPtr) == 2)
-            *(WORD *)instrPtr  = *(WORD *)savedInstrPtr;
+        *(WORD *)instrPtrWriterHolder.GetRW()  = *(WORD *)savedInstrPtr;
         else
-            *(DWORD *)instrPtr = *(DWORD *)savedInstrPtr;
+        *(DWORD *)instrPtrWriterHolder.GetRW() = *(DWORD *)savedInstrPtr;
 #elif defined(TARGET_ARM64)
-        *(DWORD *)instrPtr = *(DWORD *)savedInstrPtr;
+    *(DWORD *)instrPtrWriterHolder.GetRW() = *(DWORD *)savedInstrPtr;
 #else
-        *(BYTE *)instrPtr = *savedInstrPtr;
+    *(BYTE *)instrPtrWriterHolder.GetRW() = *savedInstrPtr;
 #endif
 
 #ifdef TARGET_X86
@@ -1623,6 +1637,7 @@ void DoGcStress (PCONTEXT regs, NativeCodeVersion nativeCodeVersion)
         PBYTE target = getTargetOfCall((BYTE*) instrPtr, regs, (BYTE**)&nextInstr);
         if (target != 0)
         {
+            ExecutableWriterHolder<BYTE> nextInstrWriterHolder(nextInstr, sizeof(DWORD));
             if (!pThread->PreemptiveGCDisabled())
             {
                 // We are in preemptive mode in JITTed code. This implies that we are into IL stub
@@ -1630,13 +1645,13 @@ void DoGcStress (PCONTEXT regs, NativeCodeVersion nativeCodeVersion)
 #ifdef TARGET_ARM
                 size_t instrLen = GetARMInstructionLength(nextInstr);
                 if (instrLen == 2)
-                    *(WORD*)nextInstr  = INTERRUPT_INSTR;
+                    *(WORD*)nextInstrWriterHolder.GetRW()  = INTERRUPT_INSTR;
                 else
-                    *(DWORD*)nextInstr = INTERRUPT_INSTR_32;
+                    *(DWORD*)nextInstrWriterHolder.GetRW() = INTERRUPT_INSTR_32;
 #elif defined(TARGET_ARM64)
-                *(DWORD*)nextInstr = INTERRUPT_INSTR;
+                *(DWORD*)nextInstrWriterHolder.GetRW() = INTERRUPT_INSTR;
 #else
-                *nextInstr = INTERRUPT_INSTR;
+                *nextInstrWriterHolder.GetRW() = INTERRUPT_INSTR;
 #endif
             }
             else
@@ -1649,7 +1664,7 @@ void DoGcStress (PCONTEXT regs, NativeCodeVersion nativeCodeVersion)
                     // It could become a problem if 64bit does partially interrupt work.
                     // OK, we have the MD, mark the instruction after the CALL
                     // appropriately
-                    ReplaceInstrAfterCall(nextInstr, targetMD);
+                    ReplaceInstrAfterCall(nextInstrWriterHolder.GetRW(), targetMD);
                 }
             }
         }
diff --git a/src/coreclr/vm/gcenv.ee.cpp b/src/coreclr/vm/gcenv.ee.cpp
index 4df3e3ae1cb53a..5be5bc2d9ecf96 100644
--- a/src/coreclr/vm/gcenv.ee.cpp
+++ b/src/coreclr/vm/gcenv.ee.cpp
@@ -559,7 +559,7 @@ BOOL ProfilerShouldTrackConditionalWeakTableElements()
 void ProfilerEndConditionalWeakTableElementReferences(void* heapId)
 {
 #if defined (GC_PROFILING)
-    g_profControlBlock.pProfInterface->EndConditionalWeakTableElementReferences(heapId);
+    (&g_profControlBlock)->EndConditionalWeakTableElementReferences(heapId);
 #else
     UNREFERENCED_PARAMETER(heapId);
 #endif // defined (GC_PROFILING)
@@ -570,7 +570,7 @@ void ProfilerEndConditionalWeakTableElementReferences(void* heapId)
 void ProfilerEndRootReferences2(void* heapId)
 {
 #if defined (GC_PROFILING)
-    g_profControlBlock.pProfInterface->EndRootReferences2(heapId);
+    (&g_profControlBlock)->EndRootReferences2(heapId);
 #else
     UNREFERENCED_PARAMETER(heapId);
 #endif // defined (GC_PROFILING)
@@ -603,24 +603,24 @@ void ScanHandleForProfilerAndETW(Object** pRef, Object* pSec, uint32_t flags, Sc
     {
         if (!isDependent)
         {
-            BEGIN_PIN_PROFILER(CORProfilerTrackGC());
-            g_profControlBlock.pProfInterface->RootReference2(
+            BEGIN_PROFILER_CALLBACK(CORProfilerTrackGC());
+            (&g_profControlBlock)->RootReference2(
                 (uint8_t *)*pRef,
                 kEtwGCRootKindHandle,
                 (EtwGCRootFlags)flags,
                 pRef,
                 &pSC->pHeapId);
-            END_PIN_PROFILER();
+            END_PROFILER_CALLBACK();
         }
         else
         {
-            BEGIN_PIN_PROFILER(CORProfilerTrackConditionalWeakTableElements());
-            g_profControlBlock.pProfInterface->ConditionalWeakTableElementReference(
+            BEGIN_PROFILER_CALLBACK(CORProfilerTrackConditionalWeakTableElements());
+            (&g_profControlBlock)->ConditionalWeakTableElementReference(
                 (uint8_t*)*pRef,
                 (uint8_t*)pSec,
                 pRef,
                 &pSC->pHeapId);
-            END_PIN_PROFILER();
+            END_PROFILER_CALLBACK();
         }
     }
 #endif // GC_PROFILING
@@ -739,10 +739,10 @@ void GCProfileWalkHeap(bool etwOnly)
 
 #if defined (GC_PROFILING)
     {
-        BEGIN_PIN_PROFILER(!etwOnly && CORProfilerTrackGC());
+        BEGIN_PROFILER_CALLBACK(!etwOnly && CORProfilerTrackGC());
         GCProfileWalkHeapWorker(TRUE /* fProfilerPinned */, fShouldWalkHeapRootsForEtw, fShouldWalkHeapObjectsForEtw);
         fWalkedHeapForProfiler = TRUE;
-        END_PIN_PROFILER();
+        END_PROFILER_CALLBACK();
     }
 #endif // defined (GC_PROFILING)
 
@@ -759,7 +759,7 @@ void GCProfileWalkHeap(bool etwOnly)
 
 void WalkFReachableObjects(bool isCritical, void* objectID)
 {
-	g_profControlBlock.pProfInterface->FinalizeableObjectQueued(isCritical, (ObjectID)objectID);
+	(&g_profControlBlock)->FinalizeableObjectQueued(isCritical, (ObjectID)objectID);
 }
 
 static fq_walk_fn g_FQWalkFn = &WalkFReachableObjects;
@@ -770,7 +770,7 @@ void GCToEEInterface::DiagGCStart(int gen, bool isInduced)
     DiagUpdateGenerationBounds();
     GarbageCollectionStartedCallback(gen, isInduced);
     {
-        BEGIN_PIN_PROFILER(CORProfilerTrackGC());
+        BEGIN_PROFILER_CALLBACK(CORProfilerTrackGC());
         size_t context = 0;
 
         // When we're walking objects allocated by class, then we don't want to walk the large
@@ -778,8 +778,8 @@ void GCToEEInterface::DiagGCStart(int gen, bool isInduced)
         GCHeapUtilities::GetGCHeap()->DiagWalkHeap(&AllocByClassHelper, (void *)&context, 0, false);
 
         // Notify that we've reached the end of the Gen 0 scan
-        g_profControlBlock.pProfInterface->EndAllocByClass(&context);
-        END_PIN_PROFILER();
+        (&g_profControlBlock)->EndAllocByClass(&context);
+        END_PROFILER_CALLBACK();
     }
 
 #endif // GC_PROFILING
@@ -815,12 +815,9 @@ void GCToEEInterface::DiagGCEnd(size_t index, int gen, int reason, bool fConcurr
 void GCToEEInterface::DiagWalkFReachableObjects(void* gcContext)
 {
 #ifdef GC_PROFILING
-    if (CORProfilerTrackGC())
-    {
-        BEGIN_PIN_PROFILER(CORProfilerPresent());
-        GCHeapUtilities::GetGCHeap()->DiagWalkFinalizeQueue(gcContext, g_FQWalkFn);
-        END_PIN_PROFILER();
-    }
+    BEGIN_PROFILER_CALLBACK(CORProfilerTrackGC());
+    GCHeapUtilities::GetGCHeap()->DiagWalkFinalizeQueue(gcContext, g_FQWalkFn);
+    END_PROFILER_CALLBACK();
 #endif //GC_PROFILING
 }
 
diff --git a/src/coreclr/vm/gchandleutilities.cpp b/src/coreclr/vm/gchandleutilities.cpp
index 2086dacdc62ec1..dcc3682e5b3e9b 100644
--- a/src/coreclr/vm/gchandleutilities.cpp
+++ b/src/coreclr/vm/gchandleutilities.cpp
@@ -22,9 +22,9 @@ void ValidateHandleAssignment(OBJECTHANDLE handle, OBJECTREF objRef)
 void DiagHandleCreated(OBJECTHANDLE handle, OBJECTREF objRef)
 {
 #ifdef GC_PROFILING
-    BEGIN_PIN_PROFILER(CORProfilerTrackGC());
-    g_profControlBlock.pProfInterface->HandleCreated((uintptr_t)handle, (ObjectID)OBJECTREF_TO_UNCHECKED_OBJECTREF(objRef));
-    END_PIN_PROFILER();
+    BEGIN_PROFILER_CALLBACK(CORProfilerTrackGC());
+    (&g_profControlBlock)->HandleCreated((uintptr_t)handle, (ObjectID)OBJECTREF_TO_UNCHECKED_OBJECTREF(objRef));
+    END_PROFILER_CALLBACK();
 #else
     UNREFERENCED_PARAMETER(handle);
     UNREFERENCED_PARAMETER(objRef);
@@ -34,9 +34,9 @@ void DiagHandleCreated(OBJECTHANDLE handle, OBJECTREF objRef)
 void DiagHandleDestroyed(OBJECTHANDLE handle)
 {
 #ifdef GC_PROFILING
-    BEGIN_PIN_PROFILER(CORProfilerTrackGC());
-    g_profControlBlock.pProfInterface->HandleDestroyed((uintptr_t)handle);
-    END_PIN_PROFILER();
+    BEGIN_PROFILER_CALLBACK(CORProfilerTrackGC());
+    (&g_profControlBlock)->HandleDestroyed((uintptr_t)handle);
+    END_PROFILER_CALLBACK();
 #else
     UNREFERENCED_PARAMETER(handle);
 #endif // GC_PROFILING
diff --git a/src/coreclr/vm/gchelpers.cpp b/src/coreclr/vm/gchelpers.cpp
index 74412a9e06d658..0cecfc624a7445 100644
--- a/src/coreclr/vm/gchelpers.cpp
+++ b/src/coreclr/vm/gchelpers.cpp
@@ -930,15 +930,25 @@ OBJECTREF AllocateObject(MethodTable *pMT
 #ifdef FEATURE_COMINTEROP_UNMANAGED_ACTIVATION
     if (fHandleCom && pMT->IsComObjectType())
     {
+        if (!g_pConfig->IsBuiltInCOMSupported())
+        {
+            COMPlusThrow(kNotSupportedException, W("NotSupported_COM"));
+        }
+
         // Create a instance of __ComObject here is not allowed as we don't know what COM object to create
         if (pMT == g_pBaseCOMObject)
             COMPlusThrow(kInvalidComObjectException, IDS_EE_NO_BACKING_CLASS_FACTORY);
 
         oref = OBJECTREF_TO_UNCHECKED_OBJECTREF(AllocateComObject_ForManaged(pMT));
     }
-    else
 #endif // FEATURE_COMINTEROP_UNMANAGED_ACTIVATION
+#else  // FEATURE_COMINTEROP
+    if (pMT->IsComObjectType())
+    {
+        COMPlusThrow(kPlatformNotSupportedException, IDS_EE_ERROR_COM);
+    }
 #endif // FEATURE_COMINTEROP
+    else
     {
         GC_ALLOC_FLAGS flags = GC_ALLOC_NO_FLAGS;
         if (pMT->ContainsPointers())
diff --git a/src/coreclr/vm/genanalysis.cpp b/src/coreclr/vm/genanalysis.cpp
index 29cb5fc5a6fda3..fa2fcdf0a224da 100644
--- a/src/coreclr/vm/genanalysis.cpp
+++ b/src/coreclr/vm/genanalysis.cpp
@@ -81,6 +81,7 @@ uint32_t gcGenAnalysisBufferMB = 0;
         EP_SERIALIZATION_FORMAT_NETTRACE_V4,
         false,
         nullptr,
+        nullptr,
         nullptr
     );
     if (gcGenAnalysisEventPipeSessionId > 0)
diff --git a/src/coreclr/vm/i386/cgencpu.h b/src/coreclr/vm/i386/cgencpu.h
index 04de3f584ae9e3..6d6ef230b808a4 100644
--- a/src/coreclr/vm/i386/cgencpu.h
+++ b/src/coreclr/vm/i386/cgencpu.h
@@ -278,17 +278,18 @@ inline INT32 rel32UsingJumpStub(INT32 UNALIGNED * pRel32, PCODE target, MethodDe
 }
 
 #ifdef FEATURE_COMINTEROP
-inline void emitCOMStubCall (ComCallMethodDesc *pCOMMethod, PCODE target)
+inline void emitCOMStubCall (ComCallMethodDesc *pCOMMethodRX, ComCallMethodDesc *pCOMMethodRW, PCODE target)
 {
     WRAPPER_NO_CONTRACT;
 
-    BYTE *pBuffer = (BYTE*)pCOMMethod - COMMETHOD_CALL_PRESTUB_SIZE;
+    BYTE *pBufferRW = (BYTE*)pCOMMethodRW - COMMETHOD_CALL_PRESTUB_SIZE;
+    BYTE *pBufferRX = (BYTE*)pCOMMethodRX - COMMETHOD_CALL_PRESTUB_SIZE;
 
-    pBuffer[0] = X86_INSTR_CALL_REL32; //CALLNEAR32
-    *((LPVOID*)(1+pBuffer)) = (LPVOID) (((LPBYTE)target) - (pBuffer+5));
+    pBufferRW[0] = X86_INSTR_CALL_REL32; //CALLNEAR32
+    *((LPVOID*)(1+pBufferRW)) = (LPVOID) (((LPBYTE)target) - (pBufferRX+5));
 
-    _ASSERTE(IS_ALIGNED(pBuffer + COMMETHOD_CALL_PRESTUB_ADDRESS_OFFSET, sizeof(void*)) &&
-        *((SSIZE_T*)(pBuffer + COMMETHOD_CALL_PRESTUB_ADDRESS_OFFSET)) == ((LPBYTE)target - (LPBYTE)pCOMMethod));
+    _ASSERTE(IS_ALIGNED(pBufferRX + COMMETHOD_CALL_PRESTUB_ADDRESS_OFFSET, sizeof(void*)) &&
+        *((SSIZE_T*)(pBufferRX + COMMETHOD_CALL_PRESTUB_ADDRESS_OFFSET)) == ((LPBYTE)target - (LPBYTE)pCOMMethodRX));
 }
 #endif // FEATURE_COMINTEROP
 
@@ -378,12 +379,12 @@ inline BOOL isCallRegisterIndirect(const BYTE *pRetAddr)
 }
 
 //------------------------------------------------------------------------
-inline void emitJump(LPBYTE pBuffer, LPVOID target)
+inline void emitJump(LPBYTE pBufferRX, LPBYTE pBufferRW, LPVOID target)
 {
     LIMITED_METHOD_CONTRACT;
 
-    pBuffer[0] = X86_INSTR_JMP_REL32; //JUMPNEAR32
-    *((LPVOID*)(1+pBuffer)) = (LPVOID) (((LPBYTE)target) - (pBuffer+5));
+    pBufferRW[0] = X86_INSTR_JMP_REL32; //JUMPNEAR32
+    *((LPVOID*)(1+pBufferRW)) = (LPVOID) (((LPBYTE)target) - (pBufferRX+5));
 }
 
 //------------------------------------------------------------------------
@@ -420,10 +421,10 @@ inline PCODE decodeJump(PCODE pCode)
 //
 
 //------------------------------------------------------------------------
-inline void emitBackToBackJump(LPBYTE pBuffer, LPVOID target)
+inline void emitBackToBackJump(LPBYTE pBufferRX, LPBYTE pBufferRW, LPVOID target)
 {
     WRAPPER_NO_CONTRACT;
-    emitJump(pBuffer, target);
+    emitJump(pBufferRX, pBufferRW, target);
 }
 
 //------------------------------------------------------------------------
@@ -457,7 +458,7 @@ struct DECLSPEC_ALIGN(4) UMEntryThunkCode
     BYTE            m_jmp;      //JMP NEAR32
     const BYTE *    m_execstub; // pointer to destination code  // make sure the backpatched portion is dword aligned.
 
-    void Encode(BYTE* pTargetCode, void* pvSecretParam);
+    void Encode(UMEntryThunkCode *pEntryThunkCodeRX, BYTE* pTargetCode, void* pvSecretParam);
     void Poison();
 
     LPCBYTE GetEntryPoint() const
@@ -620,19 +621,19 @@ class CallCountingStubShort : public CallCountingStub
 
 #ifndef DACCESS_COMPILE
 public:
-    CallCountingStubShort(CallCount *remainingCallCountCell, PCODE targetForMethod)
+    CallCountingStubShort(CallCountingStubShort* stubRX, CallCount *remainingCallCountCell, PCODE targetForMethod)
         : m_part0{                                              0xb8},                  //     mov  eax,
         m_remainingCallCountCell(remainingCallCountCell),                               //               <imm32>
         m_part1{                                                0x66, 0xff, 0x08,       //     dec  word ptr [eax]
                                                                 0x0f, 0x85},            //     jnz  
         m_rel32TargetForMethod(                                                         //          <rel32>
             GetRelative32BitOffset(
-                &m_rel32TargetForMethod,
+                &stubRX->m_rel32TargetForMethod,
                 targetForMethod)),
         m_part2{                                                0xe8},                  //     call
         m_rel32TargetForThresholdReached(                                               //          <rel32>
             GetRelative32BitOffset(
-                &m_rel32TargetForThresholdReached,
+                &stubRX->m_rel32TargetForThresholdReached,
                 TargetForThresholdReached)),
                                                                                         // (eip == stub-identifying token)
         m_alignmentPadding{                                     0xcc}                   //     int  3
diff --git a/src/coreclr/vm/i386/cgenx86.cpp b/src/coreclr/vm/i386/cgenx86.cpp
index c8a38e2f3b3fdf..6af331cc6a351c 100644
--- a/src/coreclr/vm/i386/cgenx86.cpp
+++ b/src/coreclr/vm/i386/cgenx86.cpp
@@ -1199,7 +1199,7 @@ extern "C" DWORD __stdcall xmmYmmStateSupport()
 
 #endif // !TARGET_UNIX
 
-void UMEntryThunkCode::Encode(BYTE* pTargetCode, void* pvSecretParam)
+void UMEntryThunkCode::Encode(UMEntryThunkCode *pEntryThunkCodeRX, BYTE* pTargetCode, void* pvSecretParam)
 {
     LIMITED_METHOD_CONTRACT;
 
@@ -1210,19 +1210,22 @@ void UMEntryThunkCode::Encode(BYTE* pTargetCode, void* pvSecretParam)
     m_movEAX     = X86_INSTR_MOV_EAX_IMM32;
     m_uet        = pvSecretParam;
     m_jmp        = X86_INSTR_JMP_REL32;
-    m_execstub   = (BYTE*) ((pTargetCode) - (4+((BYTE*)&m_execstub)));
+    m_execstub   = (BYTE*) ((pTargetCode) - (4+((BYTE*)&pEntryThunkCodeRX->m_execstub)));
 
-    FlushInstructionCache(GetCurrentProcess(),GetEntryPoint(),sizeof(UMEntryThunkCode));
+    FlushInstructionCache(GetCurrentProcess(),pEntryThunkCodeRX->GetEntryPoint(),sizeof(UMEntryThunkCode));
 }
 
 void UMEntryThunkCode::Poison()
 {
     LIMITED_METHOD_CONTRACT;
 
-    m_execstub = (BYTE*) ((BYTE*)UMEntryThunk::ReportViolation - (4+((BYTE*)&m_execstub)));
+    ExecutableWriterHolder<UMEntryThunkCode> thunkWriterHolder(this, sizeof(UMEntryThunkCode));
+    UMEntryThunkCode *pThisRW = thunkWriterHolder.GetRW();
+
+    pThisRW->m_execstub = (BYTE*) ((BYTE*)UMEntryThunk::ReportViolation - (4+((BYTE*)&m_execstub)));
 
     // mov ecx, imm32
-    m_movEAX = 0xb9;
+    pThisRW->m_movEAX = 0xb9;
 
     ClrFlushInstructionCache(GetEntryPoint(),sizeof(UMEntryThunkCode));
 }
@@ -1354,7 +1357,9 @@ EXTERN_C PVOID STDCALL VirtualMethodFixupWorker(Object * pThisPtr,  CORCOMPILE_V
             *(INT32 *)(&pNewValue[1]) = (INT32) pcRelOffset;
 
             _ASSERTE(IS_ALIGNED(pThunk, sizeof(INT64)));
-            FastInterlockCompareExchangeLong((INT64*)pThunk, newValue, oldValue);
+
+            ExecutableWriterHolder<INT64> thunkWriterHolder((INT64*)pThunk, sizeof(INT64));
+            FastInterlockCompareExchangeLong(thunkWriterHolder.GetRW(), newValue, oldValue);
 
             FlushInstructionCache(GetCurrentProcess(), pThunk, 8);
         }
@@ -1375,14 +1380,17 @@ EXTERN_C PVOID STDCALL VirtualMethodFixupWorker(Object * pThisPtr,  CORCOMPILE_V
 #define BEGIN_DYNAMIC_HELPER_EMIT(size) \
     SIZE_T cb = size; \
     SIZE_T cbAligned = ALIGN_UP(cb, DYNAMIC_HELPER_ALIGNMENT); \
-    BYTE * pStart = (BYTE *)(void *)pAllocator->GetDynamicHelpersHeap()->AllocAlignedMem(cbAligned, DYNAMIC_HELPER_ALIGNMENT); \
+    BYTE * pStartRX = (BYTE *)(void*)pAllocator->GetDynamicHelpersHeap()->AllocAlignedMem(cbAligned, DYNAMIC_HELPER_ALIGNMENT); \
+    ExecutableWriterHolder<BYTE> startWriterHolder(pStartRX, cbAligned); \
+    BYTE * pStart = startWriterHolder.GetRW(); \
+    size_t rxOffset = pStartRX - pStart; \
     BYTE * p = pStart;
 
 #define END_DYNAMIC_HELPER_EMIT() \
     _ASSERTE(pStart + cb == p); \
     while (p < pStart + cbAligned) *p++ = X86_INSTR_INT3; \
-    ClrFlushInstructionCache(pStart, cbAligned); \
-    return (PCODE)pStart
+    ClrFlushInstructionCache(pStartRX, cbAligned); \
+    return (PCODE)pStartRX
 
 PCODE DynamicHelpers::CreateHelper(LoaderAllocator * pAllocator, TADDR arg, PCODE target)
 {
@@ -1395,13 +1403,13 @@ PCODE DynamicHelpers::CreateHelper(LoaderAllocator * pAllocator, TADDR arg, PCOD
     p += 4;
 
     *p++ = X86_INSTR_JMP_REL32; // jmp rel32
-    *(INT32 *)p = rel32UsingJumpStub((INT32 *)p, target);
+    *(INT32 *)p = rel32UsingJumpStub((INT32 *)(p + rxOffset), target);
     p += 4;
 
     END_DYNAMIC_HELPER_EMIT();
 }
 
-void DynamicHelpers::EmitHelperWithArg(BYTE*& p, LoaderAllocator * pAllocator, TADDR arg, PCODE target)
+void DynamicHelpers::EmitHelperWithArg(BYTE*& p, size_t rxOffset, LoaderAllocator * pAllocator, TADDR arg, PCODE target)
 {
     CONTRACTL
     {
@@ -1417,7 +1425,7 @@ void DynamicHelpers::EmitHelperWithArg(BYTE*& p, LoaderAllocator * pAllocator, T
     p += 4;
 
     *p++ = X86_INSTR_JMP_REL32; // jmp rel32
-    *(INT32 *)p = rel32UsingJumpStub((INT32 *)p, target);
+    *(INT32 *)p = rel32UsingJumpStub((INT32 *)(p + rxOffset), target);
     p += 4;
 }
 
@@ -1425,7 +1433,7 @@ PCODE DynamicHelpers::CreateHelperWithArg(LoaderAllocator * pAllocator, TADDR ar
 {
     BEGIN_DYNAMIC_HELPER_EMIT(10);
 
-    EmitHelperWithArg(p, pAllocator, arg, target);
+    EmitHelperWithArg(p, rxOffset, pAllocator, arg, target);
 
     END_DYNAMIC_HELPER_EMIT();
 }
@@ -1443,7 +1451,7 @@ PCODE DynamicHelpers::CreateHelper(LoaderAllocator * pAllocator, TADDR arg, TADD
     p += 4;
 
     *p++ = X86_INSTR_JMP_REL32; // jmp rel32
-    *(INT32 *)p = rel32UsingJumpStub((INT32 *)p, target);
+    *(INT32 *)p = rel32UsingJumpStub((INT32 *)(p + rxOffset), target);
     p += 4;
 
     END_DYNAMIC_HELPER_EMIT();
@@ -1461,7 +1469,7 @@ PCODE DynamicHelpers::CreateHelperArgMove(LoaderAllocator * pAllocator, TADDR ar
     p += 4;
 
     *p++ = X86_INSTR_JMP_REL32; // jmp rel32
-    *(INT32 *)p = rel32UsingJumpStub((INT32 *)p, target);
+    *(INT32 *)p = rel32UsingJumpStub((INT32 *)(p + rxOffset), target);
     p += 4;
 
     END_DYNAMIC_HELPER_EMIT();
@@ -1547,9 +1555,9 @@ PCODE DynamicHelpers::CreateHelperWithTwoArgs(LoaderAllocator * pAllocator, TADD
 
     *p++ = X86_INSTR_JMP_REL32; // jmp rel32
 #ifdef UNIX_X86_ABI
-    *(INT32 *)p = rel32UsingJumpStub((INT32 *)p, (PCODE)DynamicHelperArgsStub);
+    *(INT32 *)p = rel32UsingJumpStub((INT32 *)(p + rxOffset), (PCODE)DynamicHelperArgsStub);
 #else
-    *(INT32 *)p = rel32UsingJumpStub((INT32 *)p, target);
+    *(INT32 *)p = rel32UsingJumpStub((INT32 *)(p + rxOffset), target);
 #endif
     p += 4;
 
@@ -1596,9 +1604,9 @@ PCODE DynamicHelpers::CreateHelperWithTwoArgs(LoaderAllocator * pAllocator, TADD
 
     *p++ = X86_INSTR_JMP_REL32; // jmp rel32
 #ifdef UNIX_X86_ABI
-    *(INT32 *)p = rel32UsingJumpStub((INT32 *)p, (PCODE)DynamicHelperArgsStub);
+    *(INT32 *)p = rel32UsingJumpStub((INT32 *)(p + rxOffset), (PCODE)DynamicHelperArgsStub);
 #else
-    *(INT32 *)p = rel32UsingJumpStub((INT32 *)p, target);
+    *(INT32 *)p = rel32UsingJumpStub((INT32 *)(p + rxOffset), target);
 #endif
     p += 4;
 
@@ -1616,9 +1624,10 @@ PCODE DynamicHelpers::CreateDictionaryLookupHelper(LoaderAllocator * pAllocator,
         GetEEFuncEntryPoint(JIT_GenericHandleClassWithSlotAndModule));
 
     GenericHandleArgs * pArgs = (GenericHandleArgs *)(void *)pAllocator->GetDynamicHelpersHeap()->AllocAlignedMem(sizeof(GenericHandleArgs), DYNAMIC_HELPER_ALIGNMENT);
-    pArgs->dictionaryIndexAndSlot = dictionaryIndexAndSlot;
-    pArgs->signature = pLookup->signature;
-    pArgs->module = (CORINFO_MODULE_HANDLE)pModule;
+    ExecutableWriterHolder<GenericHandleArgs> argsWriterHolder(pArgs, sizeof(GenericHandleArgs));
+    argsWriterHolder.GetRW()->dictionaryIndexAndSlot = dictionaryIndexAndSlot;
+    argsWriterHolder.GetRW()->signature = pLookup->signature;
+    argsWriterHolder.GetRW()->module = (CORINFO_MODULE_HANDLE)pModule;
 
     WORD slotOffset = (WORD)(dictionaryIndexAndSlot & 0xFFFF) * sizeof(Dictionary*);
 
@@ -1630,7 +1639,7 @@ PCODE DynamicHelpers::CreateDictionaryLookupHelper(LoaderAllocator * pAllocator,
         // ecx contains the generic context parameter
         // mov edx,pArgs
         // jmp helperAddress
-        EmitHelperWithArg(p, pAllocator, (TADDR)pArgs, helperAddress);
+        EmitHelperWithArg(p, rxOffset, pAllocator, (TADDR)pArgs, helperAddress);
 
         END_DYNAMIC_HELPER_EMIT();
     }
@@ -1707,7 +1716,7 @@ PCODE DynamicHelpers::CreateDictionaryLookupHelper(LoaderAllocator * pAllocator,
 
                 // mov edx,pArgs
                 // jmp helperAddress
-                EmitHelperWithArg(p, pAllocator, (TADDR)pArgs, helperAddress);
+                EmitHelperWithArg(p, rxOffset, pAllocator, (TADDR)pArgs, helperAddress);
             }
         }
 
diff --git a/src/coreclr/vm/i386/stublinkerx86.cpp b/src/coreclr/vm/i386/stublinkerx86.cpp
index 8817bf1cc4fe48..61c5dfd90cbfc8 100644
--- a/src/coreclr/vm/i386/stublinkerx86.cpp
+++ b/src/coreclr/vm/i386/stublinkerx86.cpp
@@ -145,7 +145,7 @@ class X64NearJumpSetup : public InstructionFormat
             }
         }
 
-        virtual VOID EmitInstruction(UINT refsize, __int64 fixedUpReference, BYTE *pOutBuffer, UINT variationCode, BYTE *pDataBuffer)
+        virtual VOID EmitInstruction(UINT refsize, __int64 fixedUpReference, BYTE *pOutBufferRX, BYTE *pOutBufferRW, UINT variationCode, BYTE *pDataBuffer)
         {
             LIMITED_METHOD_CONTRACT
             if (k8 == refsize)
@@ -158,19 +158,19 @@ class X64NearJumpSetup : public InstructionFormat
             }
             else if (k64Small == refsize)
             {
-                UINT64 TargetAddress = (INT64)pOutBuffer + fixedUpReference + GetSizeOfInstruction(refsize, variationCode);
+                UINT64 TargetAddress = (INT64)pOutBufferRX + fixedUpReference + GetSizeOfInstruction(refsize, variationCode);
                 _ASSERTE(FitsInU4(TargetAddress));
 
                 // mov eax, imm32  ; zero-extended
-                pOutBuffer[0] = 0xB8;
-                *((UINT32*)&pOutBuffer[1]) = (UINT32)TargetAddress;
+                pOutBufferRW[0] = 0xB8;
+                *((UINT32*)&pOutBufferRW[1]) = (UINT32)TargetAddress;
             }
             else if (k64 == refsize)
             {
                 // mov rax, imm64
-                pOutBuffer[0] = REX_PREFIX_BASE | REX_OPERAND_SIZE_64BIT;
-                pOutBuffer[1] = 0xB8;
-                *((UINT64*)&pOutBuffer[2]) = (UINT64)(((INT64)pOutBuffer) + fixedUpReference + GetSizeOfInstruction(refsize, variationCode));
+                pOutBufferRW[0] = REX_PREFIX_BASE | REX_OPERAND_SIZE_64BIT;
+                pOutBufferRW[1] = 0xB8;
+                *((UINT64*)&pOutBufferRW[2]) = (UINT64)(((INT64)pOutBufferRX) + fixedUpReference + GetSizeOfInstruction(refsize, variationCode));
             }
             else
             {
@@ -274,32 +274,32 @@ class X64NearJumpExecute : public InstructionFormat
             }
         }
 
-        virtual VOID EmitInstruction(UINT refsize, __int64 fixedUpReference, BYTE *pOutBuffer, UINT variationCode, BYTE *pDataBuffer)
+        virtual VOID EmitInstruction(UINT refsize, __int64 fixedUpReference, BYTE *pOutBufferRX, BYTE *pOutBufferRW, UINT variationCode, BYTE *pDataBuffer)
         {
             LIMITED_METHOD_CONTRACT
             if (k8 == refsize)
             {
-                pOutBuffer[0] = 0xeb;
-                *((__int8*)(pOutBuffer+1)) = (__int8)fixedUpReference;
+                pOutBufferRW[0] = 0xeb;
+                *((__int8*)(pOutBufferRW+1)) = (__int8)fixedUpReference;
             }
             else if (k32 == refsize)
             {
-                pOutBuffer[0] = 0xe9;
-                *((__int32*)(pOutBuffer+1)) = (__int32)fixedUpReference;
+                pOutBufferRW[0] = 0xe9;
+                *((__int32*)(pOutBufferRW+1)) = (__int32)fixedUpReference;
             }
             else if (k64Small == refsize)
             {
                 // REX.W jmp rax
-                pOutBuffer[0] = REX_PREFIX_BASE | REX_OPERAND_SIZE_64BIT;
-                pOutBuffer[1] = 0xFF;
-                pOutBuffer[2] = 0xE0;
+                pOutBufferRW[0] = REX_PREFIX_BASE | REX_OPERAND_SIZE_64BIT;
+                pOutBufferRW[1] = 0xFF;
+                pOutBufferRW[2] = 0xE0;
             }
             else if (k64 == refsize)
             {
                 // REX.W jmp rax
-                pOutBuffer[0] = REX_PREFIX_BASE | REX_OPERAND_SIZE_64BIT;
-                pOutBuffer[1] = 0xFF;
-                pOutBuffer[2] = 0xE0;
+                pOutBufferRW[0] = REX_PREFIX_BASE | REX_OPERAND_SIZE_64BIT;
+                pOutBufferRW[1] = 0xFF;
+                pOutBufferRW[2] = 0xE0;
             }
             else
             {
@@ -410,43 +410,43 @@ class X86NearJump : public InstructionFormat
             }
         }
 
-        virtual VOID EmitInstruction(UINT refsize, __int64 fixedUpReference, BYTE *pOutBuffer, UINT variationCode, BYTE *pDataBuffer)
+        virtual VOID EmitInstruction(UINT refsize, __int64 fixedUpReference, BYTE *pOutBufferRX, BYTE *pOutBufferRW, UINT variationCode, BYTE *pDataBuffer)
         {
             LIMITED_METHOD_CONTRACT
             if (k8 == refsize)
             {
-                pOutBuffer[0] = 0xeb;
-                *((__int8*)(pOutBuffer+1)) = (__int8)fixedUpReference;
+                pOutBufferRW[0] = 0xeb;
+                *((__int8*)(pOutBufferRW+1)) = (__int8)fixedUpReference;
             }
             else if (k32 == refsize)
             {
-                pOutBuffer[0] = 0xe9;
-                *((__int32*)(pOutBuffer+1)) = (__int32)fixedUpReference;
+                pOutBufferRW[0] = 0xe9;
+                *((__int32*)(pOutBufferRW+1)) = (__int32)fixedUpReference;
             }
 #ifdef TARGET_AMD64
             else if (k64Small == refsize)
             {
-                UINT64 TargetAddress = (INT64)pOutBuffer + fixedUpReference + GetSizeOfInstruction(refsize, variationCode);
+                UINT64 TargetAddress = (INT64)pOutBufferRX + fixedUpReference + GetSizeOfInstruction(refsize, variationCode);
                 _ASSERTE(FitsInU4(TargetAddress));
 
                 // mov eax, imm32  ; zero-extended
-                pOutBuffer[0] = 0xB8;
-                *((UINT32*)&pOutBuffer[1]) = (UINT32)TargetAddress;
+                pOutBufferRW[0] = 0xB8;
+                *((UINT32*)&pOutBufferRW[1]) = (UINT32)TargetAddress;
 
                 // jmp rax
-                pOutBuffer[5] = 0xFF;
-                pOutBuffer[6] = 0xE0;
+                pOutBufferRW[5] = 0xFF;
+                pOutBufferRW[6] = 0xE0;
             }
             else if (k64 == refsize)
             {
                 // mov rax, imm64
-                pOutBuffer[0] = REX_PREFIX_BASE | REX_OPERAND_SIZE_64BIT;
-                pOutBuffer[1] = 0xB8;
-                *((UINT64*)&pOutBuffer[2]) = (UINT64)(((INT64)pOutBuffer) + fixedUpReference + GetSizeOfInstruction(refsize, variationCode));
+                pOutBufferRW[0] = REX_PREFIX_BASE | REX_OPERAND_SIZE_64BIT;
+                pOutBufferRW[1] = 0xB8;
+                *((UINT64*)&pOutBufferRW[2]) = (UINT64)(((INT64)pOutBufferRX) + fixedUpReference + GetSizeOfInstruction(refsize, variationCode));
 
                 // jmp rax
-                pOutBuffer[10] = 0xFF;
-                pOutBuffer[11] = 0xE0;
+                pOutBufferRW[10] = 0xFF;
+                pOutBufferRW[11] = 0xE0;
             }
 #endif // TARGET_AMD64
             else
@@ -544,19 +544,19 @@ class X86CondJump : public InstructionFormat
             return (refsize == k8 ? 2 : 6);
         }
 
-        virtual VOID EmitInstruction(UINT refsize, __int64 fixedUpReference, BYTE *pOutBuffer, UINT variationCode, BYTE *pDataBuffer)
+        virtual VOID EmitInstruction(UINT refsize, __int64 fixedUpReference, BYTE *pOutBufferRX, BYTE *pOutBufferRW, UINT variationCode, BYTE *pDataBuffer)
         {
         LIMITED_METHOD_CONTRACT
         if (refsize == k8)
         {
-                pOutBuffer[0] = static_cast<BYTE>(0x70 | variationCode);
-                *((__int8*)(pOutBuffer+1)) = (__int8)fixedUpReference;
+                pOutBufferRW[0] = static_cast<BYTE>(0x70 | variationCode);
+                *((__int8*)(pOutBufferRW+1)) = (__int8)fixedUpReference;
         }
         else
         {
-                pOutBuffer[0] = 0x0f;
-                pOutBuffer[1] = static_cast<BYTE>(0x80 | variationCode);
-                *((__int32*)(pOutBuffer+2)) = (__int32)fixedUpReference;
+                pOutBufferRW[0] = 0x0f;
+                pOutBufferRW[1] = static_cast<BYTE>(0x80 | variationCode);
+                *((__int32*)(pOutBufferRW+2)) = (__int32)fixedUpReference;
             }
         }
 };
@@ -601,42 +601,42 @@ class X86Call : public InstructionFormat
             }
         }
 
-        virtual VOID EmitInstruction(UINT refsize, __int64 fixedUpReference, BYTE *pOutBuffer, UINT variationCode, BYTE *pDataBuffer)
+        virtual VOID EmitInstruction(UINT refsize, __int64 fixedUpReference, BYTE *pOutBufferRX, BYTE *pOutBufferRW, UINT variationCode, BYTE *pDataBuffer)
         {
             LIMITED_METHOD_CONTRACT
 
             switch (refsize)
             {
             case k32:
-                pOutBuffer[0] = 0xE8;
-                *((__int32*)(1+pOutBuffer)) = (__int32)fixedUpReference;
+                pOutBufferRW[0] = 0xE8;
+                *((__int32*)(1+pOutBufferRW)) = (__int32)fixedUpReference;
                 break;
 
 #ifdef TARGET_AMD64
             case k64Small:
                 UINT64 TargetAddress;
 
-                TargetAddress = (INT64)pOutBuffer + fixedUpReference + GetSizeOfInstruction(refsize, variationCode);
+                TargetAddress = (INT64)pOutBufferRX + fixedUpReference + GetSizeOfInstruction(refsize, variationCode);
                 _ASSERTE(FitsInU4(TargetAddress));
 
                 // mov  eax,<fixedUpReference>  ; zero-extends
-                pOutBuffer[0] = 0xB8;
-                *((UINT32*)&pOutBuffer[1]) = (UINT32)TargetAddress;
+                pOutBufferRW[0] = 0xB8;
+                *((UINT32*)&pOutBufferRW[1]) = (UINT32)TargetAddress;
 
                 // call rax
-                pOutBuffer[5] = 0xff;
-                pOutBuffer[6] = 0xd0;
+                pOutBufferRW[5] = 0xff;
+                pOutBufferRW[6] = 0xd0;
                 break;
 
             case k64:
                 // mov  rax,<fixedUpReference>
-                pOutBuffer[0] = REX_PREFIX_BASE | REX_OPERAND_SIZE_64BIT;
-                pOutBuffer[1] = 0xB8;
-                *((UINT64*)&pOutBuffer[2]) = (UINT64)(((INT64)pOutBuffer) + fixedUpReference + GetSizeOfInstruction(refsize, variationCode));
+                pOutBufferRW[0] = REX_PREFIX_BASE | REX_OPERAND_SIZE_64BIT;
+                pOutBufferRW[1] = 0xB8;
+                *((UINT64*)&pOutBufferRW[2]) = (UINT64)(((INT64)pOutBufferRX) + fixedUpReference + GetSizeOfInstruction(refsize, variationCode));
 
                 // call rax
-                pOutBuffer[10] = 0xff;
-                pOutBuffer[11] = 0xd0;
+                pOutBufferRW[10] = 0xff;
+                pOutBufferRW[11] = 0xd0;
                 break;
 #endif // TARGET_AMD64
 
@@ -720,14 +720,14 @@ class X86PushImm32 : public InstructionFormat
             return 5;
         }
 
-        virtual VOID EmitInstruction(UINT refsize, __int64 fixedUpReference, BYTE *pOutBuffer, UINT variationCode, BYTE *pDataBuffer)
+        virtual VOID EmitInstruction(UINT refsize, __int64 fixedUpReference, BYTE *pOutBufferRX, BYTE *pOutBufferRW, UINT variationCode, BYTE *pDataBuffer)
         {
             LIMITED_METHOD_CONTRACT;
 
-            pOutBuffer[0] = 0x68;
+            pOutBufferRW[0] = 0x68;
             // only support absolute pushimm32 of the label address. The fixedUpReference is
             // the offset to the label from the current point, so add to get address
-            *((__int32*)(1+pOutBuffer)) = (__int32)(fixedUpReference);
+            *((__int32*)(1+pOutBufferRW)) = (__int32)(fixedUpReference);
         }
 };
 
@@ -790,7 +790,7 @@ class X64LeaRIP : public InstructionFormat
             }
         }
 
-        virtual VOID EmitInstruction(UINT refsize, __int64 fixedUpReference, BYTE *pOutBuffer, UINT variationCode, BYTE *pDataBuffer)
+        virtual VOID EmitInstruction(UINT refsize, __int64 fixedUpReference, BYTE *pOutBufferRX, BYTE *pOutBufferRW, UINT variationCode, BYTE *pDataBuffer)
         {
             LIMITED_METHOD_CONTRACT;
 
@@ -803,12 +803,12 @@ class X64LeaRIP : public InstructionFormat
                 reg = X86RegFromAMD64Reg(reg);
             }
 
-            pOutBuffer[0] = rex;
-            pOutBuffer[1] = 0x8D;
-            pOutBuffer[2] = 0x05 | (reg << 3);
+            pOutBufferRW[0] = rex;
+            pOutBufferRW[1] = 0x8D;
+            pOutBufferRW[2] = 0x05 | (reg << 3);
             // only support absolute pushimm32 of the label address. The fixedUpReference is
             // the offset to the label from the current point, so add to get address
-            *((__int32*)(3+pOutBuffer)) = (__int32)(fixedUpReference);
+            *((__int32*)(3+pOutBufferRW)) = (__int32)(fixedUpReference);
         }
 };
 
@@ -5193,7 +5193,7 @@ void FixupPrecode::EnumMemoryRegions(CLRDataEnumMemoryFlags flags)
 
 #ifndef DACCESS_COMPILE
 
-void rel32SetInterlocked(/*PINT32*/ PVOID pRel32, TADDR target, MethodDesc* pMD)
+void rel32SetInterlocked(/*PINT32*/ PVOID pRel32, /*PINT32*/ PVOID pRel32RW, TADDR target, MethodDesc* pMD)
 {
     CONTRACTL
     {
@@ -5204,11 +5204,11 @@ void rel32SetInterlocked(/*PINT32*/ PVOID pRel32, TADDR target, MethodDesc* pMD)
 
     INT32 targetRel32 = rel32UsingJumpStub((INT32*)pRel32, target, pMD);
 
-    _ASSERTE(IS_ALIGNED(pRel32, sizeof(INT32)));
-    FastInterlockExchange((LONG*)pRel32, (LONG)targetRel32);
+    _ASSERTE(IS_ALIGNED(pRel32RW, sizeof(INT32)));
+    FastInterlockExchange((LONG*)pRel32RW, (LONG)targetRel32);
 }
 
-BOOL rel32SetInterlocked(/*PINT32*/ PVOID pRel32, TADDR target, TADDR expected, MethodDesc* pMD)
+BOOL rel32SetInterlocked(/*PINT32*/ PVOID pRel32, /*PINT32*/ PVOID pRel32RW, TADDR target, TADDR expected, MethodDesc* pMD)
 {
     CONTRACTL
     {
@@ -5222,11 +5222,11 @@ BOOL rel32SetInterlocked(/*PINT32*/ PVOID pRel32, TADDR target, TADDR expected,
 
     INT32 targetRel32 = rel32UsingJumpStub((INT32*)pRel32, target, pMD);
 
-    _ASSERTE(IS_ALIGNED(pRel32, sizeof(INT32)));
-    return FastInterlockCompareExchange((LONG*)pRel32, (LONG)targetRel32, (LONG)expectedRel32) == (LONG)expectedRel32;
+    _ASSERTE(IS_ALIGNED(pRel32RW, sizeof(INT32)));
+    return FastInterlockCompareExchange((LONG*)pRel32RW, (LONG)targetRel32, (LONG)expectedRel32) == (LONG)expectedRel32;
 }
 
-void StubPrecode::Init(MethodDesc* pMD, LoaderAllocator *pLoaderAllocator /* = NULL */,
+void StubPrecode::Init(StubPrecode* pPrecodeRX, MethodDesc* pMD, LoaderAllocator *pLoaderAllocator /* = NULL */,
     BYTE type /* = StubPrecode::Type */, TADDR target /* = NULL */)
 {
     WRAPPER_NO_CONTRACT;
@@ -5244,23 +5244,23 @@ void StubPrecode::Init(MethodDesc* pMD, LoaderAllocator *pLoaderAllocator /* = N
         // that has the same lifetime like as the precode itself
         if (target == NULL)
             target = GetPreStubEntryPoint();
-        m_rel32 = rel32UsingJumpStub(&m_rel32, target, NULL /* pMD */, pLoaderAllocator);
+        m_rel32 = rel32UsingJumpStub(&pPrecodeRX->m_rel32, target, NULL /* pMD */, pLoaderAllocator);
     }
 }
 
 #ifdef HAS_NDIRECT_IMPORT_PRECODE
 
-void NDirectImportPrecode::Init(MethodDesc* pMD, LoaderAllocator *pLoaderAllocator)
+void NDirectImportPrecode::Init(NDirectImportPrecode* pPrecodeRX, MethodDesc* pMD, LoaderAllocator *pLoaderAllocator)
 {
     WRAPPER_NO_CONTRACT;
-    StubPrecode::Init(pMD, pLoaderAllocator, NDirectImportPrecode::Type, GetEEFuncEntryPoint(NDirectImportThunk));
+    StubPrecode::Init(pPrecodeRX, pMD, pLoaderAllocator, NDirectImportPrecode::Type, GetEEFuncEntryPoint(NDirectImportThunk));
 }
 
 #endif // HAS_NDIRECT_IMPORT_PRECODE
 
 
 #ifdef HAS_FIXUP_PRECODE
-void FixupPrecode::Init(MethodDesc* pMD, LoaderAllocator *pLoaderAllocator, int iMethodDescChunkIndex /*=0*/, int iPrecodeChunkIndex /*=0*/)
+void FixupPrecode::Init(FixupPrecode* pPrecodeRX, MethodDesc* pMD, LoaderAllocator *pLoaderAllocator, int iMethodDescChunkIndex /*=0*/, int iPrecodeChunkIndex /*=0*/)
 {
     WRAPPER_NO_CONTRACT;
 
@@ -5292,13 +5292,13 @@ void FixupPrecode::Init(MethodDesc* pMD, LoaderAllocator *pLoaderAllocator, int
 #ifdef FIXUP_PRECODE_PREALLOCATE_DYNAMIC_METHOD_JUMP_STUBS
     if (pMD->IsLCGMethod())
     {
-        m_rel32 = rel32UsingPreallocatedJumpStub(&m_rel32, target, GetDynamicMethodPrecodeFixupJumpStub(), false /* emitJump */);
+        m_rel32 = rel32UsingPreallocatedJumpStub(&pPrecodeRX->m_rel32, target, pPrecodeRX->GetDynamicMethodPrecodeFixupJumpStub(), GetDynamicMethodPrecodeFixupJumpStub(), false /* emitJump */);
         return;
     }
 #endif // FIXUP_PRECODE_PREALLOCATE_DYNAMIC_METHOD_JUMP_STUBS
     if (pLoaderAllocator != NULL)
     {
-        m_rel32 = rel32UsingJumpStub(&m_rel32, target, NULL /* pMD */, pLoaderAllocator);
+        m_rel32 = rel32UsingJumpStub(&pPrecodeRX->m_rel32, target, NULL /* pMD */, pLoaderAllocator);
     }
 }
 
@@ -5328,7 +5328,9 @@ void FixupPrecode::ResetTargetInterlocked()
     newValue.m_rel32 = rel32UsingJumpStub(&m_rel32, target, pMD);
 
     _ASSERTE(IS_ALIGNED(this, sizeof(INT64)));
-    FastInterlockExchangeLong((INT64*)this, *(INT64*)&newValue);
+
+    ExecutableWriterHolder<FixupPrecode> precodeWriterHolder(this, sizeof(FixupPrecode)); 
+    FastInterlockExchangeLong((INT64*)precodeWriterHolder.GetRW(), *(INT64*)&newValue);
 }
 
 BOOL FixupPrecode::SetTargetInterlocked(TADDR target, TADDR expected)
@@ -5376,15 +5378,24 @@ BOOL FixupPrecode::SetTargetInterlocked(TADDR target, TADDR expected)
         return FALSE;
     }
 
+#ifdef FIXUP_PRECODE_PREALLOCATE_DYNAMIC_METHOD_JUMP_STUBS
+    ExecutableWriterHolder<void> dynamicMethodEntryJumpStubWriterHolder;
+    if (pMD->IsLCGMethod())
+    {
+        dynamicMethodEntryJumpStubWriterHolder = ExecutableWriterHolder<void>((void*)GetDynamicMethodEntryJumpStub(), 12);
+    }
+#endif    
     *(INT32*)(&pNewValue[offsetof(FixupPrecode, m_rel32)]) =
 #ifdef FIXUP_PRECODE_PREALLOCATE_DYNAMIC_METHOD_JUMP_STUBS
         pMD->IsLCGMethod() ?
-            rel32UsingPreallocatedJumpStub(&m_rel32, target, GetDynamicMethodEntryJumpStub(), true /* emitJump */) :
+            rel32UsingPreallocatedJumpStub(&m_rel32, target, GetDynamicMethodEntryJumpStub(), (PCODE)dynamicMethodEntryJumpStubWriterHolder.GetRW(), true /* emitJump */) :
 #endif // FIXUP_PRECODE_PREALLOCATE_DYNAMIC_METHOD_JUMP_STUBS
             rel32UsingJumpStub(&m_rel32, target, pMD);
 
     _ASSERTE(IS_ALIGNED(this, sizeof(INT64)));
-    return FastInterlockCompareExchangeLong((INT64*) this, newValue, oldValue) == oldValue;
+
+    ExecutableWriterHolder<FixupPrecode> precodeWriterHolder(this, sizeof(FixupPrecode));
+    return FastInterlockCompareExchangeLong((INT64*)precodeWriterHolder.GetRW(), newValue, oldValue) == oldValue;
 }
 
 #ifdef FEATURE_NATIVE_IMAGE_GENERATION
@@ -5488,7 +5499,9 @@ BOOL ThisPtrRetBufPrecode::SetTargetInterlocked(TADDR target, TADDR expected)
     INT32 newRel32 = rel32UsingJumpStub(&m_rel32, target, NULL /* pMD */, ((MethodDesc *)GetMethodDesc())->GetLoaderAllocator());
 
     _ASSERTE(IS_ALIGNED(&m_rel32, sizeof(INT32)));
-    FastInterlockExchange((LONG *)&m_rel32, (LONG)newRel32);
+    ExecutableWriterHolder<INT32> rel32WriterHolder(&m_rel32, sizeof(INT32));
+    FastInterlockExchange((LONG*)rel32WriterHolder.GetRW(), (LONG)newRel32);
+
     return TRUE;
 }
 #endif // !DACCESS_COMPILE
diff --git a/src/coreclr/vm/i386/stublinkerx86.h b/src/coreclr/vm/i386/stublinkerx86.h
index e8730c2725bf31..af5244d077193e 100644
--- a/src/coreclr/vm/i386/stublinkerx86.h
+++ b/src/coreclr/vm/i386/stublinkerx86.h
@@ -457,8 +457,8 @@ inline TADDR rel32Decode(/*PTR_INT32*/ TADDR pRel32)
     return pRel32 + 4 + *PTR_INT32(pRel32);
 }
 
-void rel32SetInterlocked(/*PINT32*/ PVOID pRel32, TADDR target, MethodDesc* pMD);
-BOOL rel32SetInterlocked(/*PINT32*/ PVOID pRel32, TADDR target, TADDR expected, MethodDesc* pMD);
+void rel32SetInterlocked(/*PINT32*/ PVOID pRel32, /*PINT32*/ PVOID pRel32RW, TADDR target, MethodDesc* pMD);
+BOOL rel32SetInterlocked(/*PINT32*/ PVOID pRel32, /*PINT32*/ PVOID pRel32RW, TADDR target, TADDR expected, MethodDesc* pMD);
 
 //------------------------------------------------------------------------
 //
@@ -521,7 +521,7 @@ struct StubPrecode {
     BYTE            m_jmp;
     INT32           m_rel32;
 
-    void Init(MethodDesc* pMD, LoaderAllocator *pLoaderAllocator = NULL, BYTE type = StubPrecode::Type, TADDR target = NULL);
+    void Init(StubPrecode* pPrecodeRX, MethodDesc* pMD, LoaderAllocator *pLoaderAllocator = NULL, BYTE type = StubPrecode::Type, TADDR target = NULL);
 
     TADDR GetMethodDesc()
     {
@@ -546,7 +546,8 @@ struct StubPrecode {
         }
         CONTRACTL_END;
 
-        rel32SetInterlocked(&m_rel32, GetPreStubEntryPoint(), (MethodDesc*)GetMethodDesc());
+        ExecutableWriterHolder<INT32> rel32WriterHolder(&m_rel32, sizeof(INT32));
+        rel32SetInterlocked(&m_rel32, rel32WriterHolder.GetRW(), GetPreStubEntryPoint(), (MethodDesc*)GetMethodDesc());
     }
 
     BOOL SetTargetInterlocked(TADDR target, TADDR expected)
@@ -558,7 +559,8 @@ struct StubPrecode {
         }
         CONTRACTL_END;
 
-        return rel32SetInterlocked(&m_rel32, target, expected, (MethodDesc*)GetMethodDesc());
+        ExecutableWriterHolder<void> rel32Holder(&m_rel32, 4);
+        return rel32SetInterlocked(&m_rel32, rel32Holder.GetRW(), target, expected, (MethodDesc*)GetMethodDesc());
     }
 };
 IN_TARGET_64BIT(static_assert_no_msg(offsetof(StubPrecode, m_movR10) == OFFSETOF_PRECODE_TYPE);)
@@ -586,7 +588,7 @@ struct NDirectImportPrecode : StubPrecode {
     // jmp NDirectImportThunk
 #endif // HOST_64BIT
 
-    void Init(MethodDesc* pMD, LoaderAllocator *pLoaderAllocator);
+    void Init(NDirectImportPrecode* pPrecodeRX, MethodDesc* pMD, LoaderAllocator *pLoaderAllocator);
 
     LPVOID GetEntrypoint()
     {
@@ -633,7 +635,7 @@ struct FixupPrecode {
     TADDR           m_pMethodDesc;
 #endif
 
-    void Init(MethodDesc* pMD, LoaderAllocator *pLoaderAllocator, int iMethodDescChunkIndex = 0, int iPrecodeChunkIndex = 0);
+    void Init(FixupPrecode* pPrecodeRX, MethodDesc* pMD, LoaderAllocator *pLoaderAllocator, int iMethodDescChunkIndex = 0, int iPrecodeChunkIndex = 0);
 
 #ifdef HAS_FIXUP_PRECODE_CHUNKS
     TADDR GetBase()
diff --git a/src/coreclr/vm/i386/virtualcallstubcpu.hpp b/src/coreclr/vm/i386/virtualcallstubcpu.hpp
index 38680e402d64d8..c6515abfaed7fd 100644
--- a/src/coreclr/vm/i386/virtualcallstubcpu.hpp
+++ b/src/coreclr/vm/i386/virtualcallstubcpu.hpp
@@ -84,7 +84,7 @@ struct LookupHolder
 {
     static void InitializeStatic();
 
-    void  Initialize(PCODE resolveWorkerTarget, size_t dispatchToken);
+    void  Initialize(LookupHolder* pLookupHolderRX, PCODE resolveWorkerTarget, size_t dispatchToken);
 
     LookupStub*    stub()               { LIMITED_METHOD_CONTRACT;  return &_stub;    }
 
@@ -198,7 +198,7 @@ struct DispatchHolder
 {
     static void InitializeStatic();
 
-    void  Initialize(PCODE implTarget, PCODE failTarget, size_t expectedMT);
+    void  Initialize(DispatchHolder* pDispatchHolderRX, PCODE implTarget, PCODE failTarget, size_t expectedMT);
 
     DispatchStub* stub()      { LIMITED_METHOD_CONTRACT;  return &_stub; }
 
@@ -347,7 +347,8 @@ struct ResolveHolder
 {
     static void  InitializeStatic();
 
-    void  Initialize(PCODE resolveWorkerTarget, PCODE patcherTarget,
+    void  Initialize(ResolveHolder* pResolveHolderRX,
+                     PCODE resolveWorkerTarget, PCODE patcherTarget,
                      size_t dispatchToken, UINT32 hashedToken,
                      void * cacheAddr, INT32 * counterAddr
 #ifndef UNIX_X86_ABI
@@ -741,14 +742,14 @@ void LookupHolder::InitializeStatic()
     lookupInit._resolveWorkerDispl = 0xcccccccc;
 }
 
-void  LookupHolder::Initialize(PCODE resolveWorkerTarget, size_t dispatchToken)
+void  LookupHolder::Initialize(LookupHolder* pLookupHolderRX, PCODE resolveWorkerTarget, size_t dispatchToken)
 {
     _stub = lookupInit;
 
     //fill in the stub specific fields
     //@TODO: Get rid of this duplication of data.
     _stub._token              = dispatchToken;
-    _stub._resolveWorkerDispl = resolveWorkerTarget - ((PCODE) &_stub._resolveWorkerDispl + sizeof(DISPL));
+    _stub._resolveWorkerDispl = resolveWorkerTarget - ((PCODE) &pLookupHolderRX->_stub._resolveWorkerDispl + sizeof(DISPL));
 }
 
 LookupHolder* LookupHolder::FromLookupEntry(PCODE lookupEntry)
@@ -811,14 +812,14 @@ void DispatchHolder::InitializeStatic()
 #endif //STUB_LOGGING
 };
 
-void  DispatchHolder::Initialize(PCODE implTarget, PCODE failTarget, size_t expectedMT)
+void  DispatchHolder::Initialize(DispatchHolder* pDispatchHolderRX, PCODE implTarget, PCODE failTarget, size_t expectedMT)
 {
     _stub = dispatchInit;
 
     //fill in the stub specific fields
     _stub._expectedMT  = (size_t) expectedMT;
-    _stub._failDispl   = failTarget - ((PCODE) &_stub._failDispl + sizeof(DISPL));
-    _stub._implDispl   = implTarget - ((PCODE) &_stub._implDispl + sizeof(DISPL));
+    _stub._failDispl   = failTarget - ((PCODE) &pDispatchHolderRX->_stub._failDispl + sizeof(DISPL));
+    _stub._implDispl   = implTarget - ((PCODE) &pDispatchHolderRX->_stub._implDispl + sizeof(DISPL));
 }
 
 DispatchHolder* DispatchHolder::FromDispatchEntry(PCODE dispatchEntry)
@@ -943,7 +944,8 @@ void ResolveHolder::InitializeStatic()
     resolveInit.toResolveStub          = (offsetof(ResolveStub, _resolveEntryPoint) - (offsetof(ResolveStub, toResolveStub) + 1)) & 0xFF;
 };
 
-void  ResolveHolder::Initialize(PCODE resolveWorkerTarget, PCODE patcherTarget,
+void  ResolveHolder::Initialize(ResolveHolder* pResolveHolderRX, 
+                                PCODE resolveWorkerTarget, PCODE patcherTarget,
                                 size_t dispatchToken, UINT32 hashedToken,
                                 void * cacheAddr, INT32 * counterAddr
 #ifndef UNIX_X86_ABI
@@ -960,8 +962,8 @@ void  ResolveHolder::Initialize(PCODE resolveWorkerTarget, PCODE patcherTarget,
     _stub._token              = dispatchToken;
 //    _stub._hashedTokenMov     = hashedToken;
     _stub._tokenPush          = dispatchToken;
-    _stub._resolveWorkerDispl = resolveWorkerTarget - ((PCODE) &_stub._resolveWorkerDispl + sizeof(DISPL));
-    _stub._backpatcherDispl   = patcherTarget       - ((PCODE) &_stub._backpatcherDispl   + sizeof(DISPL));
+    _stub._resolveWorkerDispl = resolveWorkerTarget - ((PCODE) &pResolveHolderRX->_stub._resolveWorkerDispl + sizeof(DISPL));
+    _stub._backpatcherDispl   = patcherTarget       - ((PCODE) &pResolveHolderRX->_stub._backpatcherDispl   + sizeof(DISPL));
 #ifndef UNIX_X86_ABI
     _stub._stackArgumentsSize = stackArgumentsSize;
 #endif
diff --git a/src/coreclr/vm/ilmarshalers.cpp b/src/coreclr/vm/ilmarshalers.cpp
index 5c7517b28847c1..163222d423d5a8 100644
--- a/src/coreclr/vm/ilmarshalers.cpp
+++ b/src/coreclr/vm/ilmarshalers.cpp
@@ -2496,10 +2496,14 @@ void ILBlittablePtrMarshaler::EmitConvertContentsNativeToCLR(ILCodeStream* pslIL
 
 bool ILBlittablePtrMarshaler::CanMarshalViaPinning()
 {
+    // [COMPAT] For correctness, we can't marshal via pinning if we might need to marshal differently at runtime.
+    // See calls to EmitExactTypeCheck where we check the runtime type of the object being marshalled.
+    // However, we previously supported pinning non-sealed blittable classes, even though that could result
+    // in some data still being unmarshalled if a subclass is provided. This optimization is incorrect,
+    // but libraries like NAudio have taken a hard dependency on this incorrect behavior, so we need to preserve it.
     return IsCLRToNative(m_dwMarshalFlags) &&
         !IsByref(m_dwMarshalFlags) &&
-        !IsFieldMarshal(m_dwMarshalFlags) &&
-        m_pargs->m_pMT->IsSealed(); // We can't marshal via pinning if we might need to marshal differently at runtime. See calls to EmitExactTypeCheck where we check the runtime type of the object being marshalled.
+        !IsFieldMarshal(m_dwMarshalFlags);
 }
 
 void ILBlittablePtrMarshaler::EmitMarshalViaPinning(ILCodeStream* pslILEmit)
diff --git a/src/coreclr/vm/interoputil.cpp b/src/coreclr/vm/interoputil.cpp
index e3797b13d508c2..2b6697887aa97e 100644
--- a/src/coreclr/vm/interoputil.cpp
+++ b/src/coreclr/vm/interoputil.cpp
@@ -820,25 +820,6 @@ BOOL CanCastComObject(OBJECTREF obj, MethodTable * pTargetMT)
     }
 }
 
-// Returns TRUE iff the argument represents the "__ComObject" type or
-// any type derived from it (i.e. typelib-imported RCWs).
-BOOL IsComWrapperClass(TypeHandle type)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    MethodTable* pMT = type.GetMethodTable();
-    if (pMT == NULL)
-        return FALSE;
-
-    return pMT->IsComObjectType();
-}
-
 // Returns TRUE iff the argument represents the "__ComObject" type.
 BOOL IsComObjectClass(TypeHandle type)
 {
diff --git a/src/coreclr/vm/interoputil.h b/src/coreclr/vm/interoputil.h
index c7209467b4a79b..b99764688dd535 100644
--- a/src/coreclr/vm/interoputil.h
+++ b/src/coreclr/vm/interoputil.h
@@ -83,10 +83,6 @@ ULONG SafeReleasePreemp(IUnknown* pUnk, RCW* pRCW = NULL);
 // Determines if a COM object can be cast to the specified type.
 BOOL CanCastComObject(OBJECTREF obj, MethodTable * pTargetMT);
 
-// includes Types which hold a "ComObject" class
-// and types which are imported through typelib
-BOOL IsComWrapperClass(TypeHandle type);
-
 // includes Type which hold a "__ComObject" class
 BOOL IsComObjectClass(TypeHandle type);
 
diff --git a/src/coreclr/vm/jithelpers.cpp b/src/coreclr/vm/jithelpers.cpp
index b7f92254c7083b..ea70bf8e0ac242 100644
--- a/src/coreclr/vm/jithelpers.cpp
+++ b/src/coreclr/vm/jithelpers.cpp
@@ -5471,7 +5471,7 @@ NOINLINE static void JIT_ReversePInvokeEnterRare2(ReversePInvokeFrame* frame, vo
 // As a result, we specially decorate this method to have the correct calling convention
 // and argument ordering for an HCALL, but we don't use the HCALL macros and contracts
 // since this method doesn't follow the contracts.
-void F_CALL_CONV HCCALL3(JIT_ReversePInvokeEnterTrackTransitions, ReversePInvokeFrame* frame, CORINFO_METHOD_HANDLE handle, void* secretArg)
+HCIMPL3_RAW(void, JIT_ReversePInvokeEnterTrackTransitions, ReversePInvokeFrame* frame, CORINFO_METHOD_HANDLE handle, void* secretArg)
 {
     _ASSERTE(frame != NULL && handle != NULL);
 
@@ -5520,8 +5520,9 @@ void F_CALL_CONV HCCALL3(JIT_ReversePInvokeEnterTrackTransitions, ReversePInvoke
     INSTALL_EXCEPTION_HANDLING_RECORD(&frame->record.m_ExReg);
 #endif
 }
+HCIMPLEND_RAW
 
-void F_CALL_CONV HCCALL1(JIT_ReversePInvokeEnter, ReversePInvokeFrame* frame)
+HCIMPL1_RAW(void, JIT_ReversePInvokeEnter, ReversePInvokeFrame* frame)
 {
     _ASSERTE(frame != NULL);
 
@@ -5552,8 +5553,9 @@ void F_CALL_CONV HCCALL1(JIT_ReversePInvokeEnter, ReversePInvokeFrame* frame)
     INSTALL_EXCEPTION_HANDLING_RECORD(&frame->record.m_ExReg);
 #endif
 }
+HCIMPLEND_RAW
 
-void F_CALL_CONV HCCALL1(JIT_ReversePInvokeExitTrackTransitions, ReversePInvokeFrame* frame)
+HCIMPL1_RAW(void, JIT_ReversePInvokeExitTrackTransitions, ReversePInvokeFrame* frame)
 {
     _ASSERTE(frame != NULL);
     _ASSERTE(frame->currentThread == GetThread());
@@ -5574,8 +5576,9 @@ void F_CALL_CONV HCCALL1(JIT_ReversePInvokeExitTrackTransitions, ReversePInvokeF
     }
 #endif
 }
+HCIMPLEND_RAW
 
-void F_CALL_CONV HCCALL1(JIT_ReversePInvokeExit, ReversePInvokeFrame* frame)
+HCIMPL1_RAW(void, JIT_ReversePInvokeExit, ReversePInvokeFrame* frame)
 {
     _ASSERTE(frame != NULL);
     _ASSERTE(frame->currentThread == GetThread());
@@ -5589,6 +5592,7 @@ void F_CALL_CONV HCCALL1(JIT_ReversePInvokeExit, ReversePInvokeFrame* frame)
     UNINSTALL_EXCEPTION_HANDLING_RECORD(&frame->record.m_ExReg);
 #endif
 }
+HCIMPLEND_RAW
 
 //========================================================================
 //
diff --git a/src/coreclr/vm/jitinterface.cpp b/src/coreclr/vm/jitinterface.cpp
index c5363172f79b38..f4b155a500a0ac 100644
--- a/src/coreclr/vm/jitinterface.cpp
+++ b/src/coreclr/vm/jitinterface.cpp
@@ -7738,12 +7738,12 @@ getMethodInfoHelper(
 #if defined(PROFILING_SUPPORTED)
         BOOL fProfilerRequiresGenericsContextForEnterLeave = FALSE;
         {
-            BEGIN_PIN_PROFILER(CORProfilerPresent());
-            if (g_profControlBlock.pProfInterface->RequiresGenericsContextForEnterLeave())
+            BEGIN_PROFILER_CALLBACK(CORProfilerPresent());
+            if ((&g_profControlBlock)->RequiresGenericsContextForEnterLeave())
             {
                 fProfilerRequiresGenericsContextForEnterLeave = TRUE;
             }
-            END_PIN_PROFILER();
+            END_PROFILER_CALLBACK();
         }
         if (fProfilerRequiresGenericsContextForEnterLeave)
         {
@@ -8134,7 +8134,7 @@ CorInfoInline CEEInfo::canInline (CORINFO_METHOD_HANDLE hCaller,
         // profiler that this inlining is going to take place, and give them a
         // chance to prevent it.
         {
-            BEGIN_PIN_PROFILER(CORProfilerTrackJITInfo());
+            BEGIN_PROFILER_CALLBACK(CORProfilerTrackJITInfo());
             if (pCaller->IsILStub() || pCallee->IsILStub())
             {
                 // do nothing
@@ -8142,7 +8142,7 @@ CorInfoInline CEEInfo::canInline (CORINFO_METHOD_HANDLE hCaller,
             else
             {
                 BOOL fShouldInline;
-                HRESULT hr = g_profControlBlock.pProfInterface->JITInlining(
+                HRESULT hr = (&g_profControlBlock)->JITInlining(
                     (FunctionID)pCaller,
                     (FunctionID)pCallee,
                     &fShouldInline);
@@ -8154,7 +8154,7 @@ CorInfoInline CEEInfo::canInline (CORINFO_METHOD_HANDLE hCaller,
                     goto exit;
                 }
             }
-            END_PIN_PROFILER();
+            END_PROFILER_CALLBACK();
         }
     }
 #endif // PROFILING_SUPPORTED
@@ -8904,6 +8904,8 @@ bool CEEInfo::resolveVirtualMethodHelper(CORINFO_DEVIRTUALIZATION_INFO * info)
     info->devirtualizedMethod = NULL;
     info->requiresInstMethodTableArg = false;
     info->exactContext = NULL;
+    memset(&info->resolvedTokenDevirtualizedMethod, 0, sizeof(info->resolvedTokenDevirtualizedMethod));
+    memset(&info->resolvedTokenDevirtualizedUnboxedMethod, 0, sizeof(info->resolvedTokenDevirtualizedUnboxedMethod));
 
     MethodDesc* pBaseMD = GetMethod(info->virtualMethod);
     MethodTable* pBaseMT = pBaseMD->GetMethodTable();
@@ -11182,9 +11184,9 @@ void CEEJitInfo::GetProfilingHandle(bool                      *pbHookFunction,
         void * profilerHandle = m_pMethodBeingCompiled;
 
         {
-            BEGIN_PIN_PROFILER(CORProfilerFunctionIDMapperEnabled());
-            profilerHandle = (void *)g_profControlBlock.pProfInterface->EEFunctionIDMapper((FunctionID) m_pMethodBeingCompiled, &bHookFunction);
-            END_PIN_PROFILER();
+            BEGIN_PROFILER_CALLBACK(CORProfilerFunctionIDMapperEnabled());
+            profilerHandle = (void *)(&g_profControlBlock)->EEFunctionIDMapper((FunctionID) m_pMethodBeingCompiled, &bHookFunction);
+            END_PROFILER_CALLBACK();
         }
 
         m_gphCache.m_pvGphProfilerHandle = profilerHandle;
@@ -11241,7 +11243,8 @@ void CEEJitInfo::WriteCode(EEJitManager * jitMgr)
 
     if (m_CodeHeaderRW != m_CodeHeader)
     {
-        memcpy(m_CodeHeader, m_CodeHeaderRW, m_codeWriteBufferSize);
+        ExecutableWriterHolder<void> codeWriterHolder((void *)m_CodeHeader, m_codeWriteBufferSize);
+        memcpy(codeWriterHolder.GetRW(), m_CodeHeaderRW, m_codeWriteBufferSize);
     }
 
     // Now that the code header was written to the final location, publish the code via the nibble map
@@ -12523,7 +12526,7 @@ void CEEJitInfo::getEHinfo(
 #endif // CROSSGEN_COMPILE
 
 #if defined(CROSSGEN_COMPILE)
-EXTERN_C ICorJitCompiler* __stdcall getJit();
+EXTERN_C ICorJitCompiler* getJit();
 #endif // defined(CROSSGEN_COMPILE)
 
 #ifdef FEATURE_INTERPRETER
@@ -13462,7 +13465,7 @@ void Module::LoadHelperTable()
             *curEntry = X86_INSTR_JMP_REL32;
             *(INT32 *)(curEntry + 1) = rel32UsingJumpStub((INT32 *)(curEntry + 1), pfnHelper, NULL, GetLoaderAllocator());
 #else // all other platforms
-            emitJump(curEntry, (LPVOID)pfnHelper);
+            emitJump(curEntry, curEntry, (LPVOID)pfnHelper);
             _ASSERTE(HELPER_TABLE_ENTRY_LEN >= JUMP_ALLOCATE_SIZE);
 #endif
 
@@ -13958,9 +13961,9 @@ BOOL LoadDynamicInfoEntry(Module *currentModule,
             CORINFO_PROFILING_HANDLE profilerHandle = (CORINFO_PROFILING_HANDLE)funId;
 
             {
-                BEGIN_PIN_PROFILER(CORProfilerFunctionIDMapperEnabled());
-                profilerHandle = (CORINFO_PROFILING_HANDLE) g_profControlBlock.pProfInterface->EEFunctionIDMapper(funId, &bHookFunction);
-                END_PIN_PROFILER();
+                BEGIN_PROFILER_CALLBACK(CORProfilerFunctionIDMapperEnabled());
+                profilerHandle = (CORINFO_PROFILING_HANDLE)(&g_profControlBlock)->EEFunctionIDMapper(funId, &bHookFunction);
+                END_PROFILER_CALLBACK();
             }
 
             // Profiling handle is opaque token. It does not have to be aligned thus we can not store it in the same location as token.
@@ -14256,6 +14259,130 @@ BOOL LoadDynamicInfoEntry(Module *currentModule,
         }
         break;
 
+    case ENCODE_VERIFY_VIRTUAL_FUNCTION_OVERRIDE:
+    case ENCODE_CHECK_VIRTUAL_FUNCTION_OVERRIDE:
+        {
+            PCCOR_SIGNATURE updatedSignature = pBlob;
+
+            ReadyToRunVirtualFunctionOverrideFlags flags = (ReadyToRunVirtualFunctionOverrideFlags)CorSigUncompressData(updatedSignature);
+
+            SigTypeContext typeContext;    // empty context is OK: encoding should not contain type variables.
+            ZapSig::Context zapSigContext(pInfoModule, (void *)currentModule, ZapSig::NormalTokens);
+            MethodDesc *pDeclMethod = ZapSig::DecodeMethod(pInfoModule, updatedSignature, &typeContext, &zapSigContext, NULL, NULL, NULL, &updatedSignature, TRUE);
+            TypeHandle thImpl = ZapSig::DecodeType(currentModule, pInfoModule, updatedSignature, CLASS_LOADED, &updatedSignature);
+
+            MethodDesc *pImplMethodCompiler = NULL;
+            
+            if ((flags & READYTORUN_VIRTUAL_OVERRIDE_VirtualFunctionOverriden) != 0)
+            {
+                pImplMethodCompiler = ZapSig::DecodeMethod(currentModule, pInfoModule, updatedSignature);
+            }
+
+            MethodDesc *pImplMethodRuntime;
+            if (pDeclMethod->IsInterface())
+            {
+                if (!thImpl.CanCastTo(pDeclMethod->GetMethodTable()))
+                {
+                    MethodTable *pInterfaceTypeCanonical = pDeclMethod->GetMethodTable()->GetCanonicalMethodTable();
+
+                    // Its possible for the decl method to need to be found on the only canonically compatible interface on the owning type
+                    MethodTable::InterfaceMapIterator it = thImpl.GetMethodTable()->IterateInterfaceMap();
+                    while (it.Next())
+                    {
+                        if (pInterfaceTypeCanonical == it.GetInterface()->GetCanonicalMethodTable())
+                        {
+                            pDeclMethod = MethodDesc::FindOrCreateAssociatedMethodDesc(pDeclMethod, it.GetInterface(), FALSE, pDeclMethod->GetMethodInstantiation(), FALSE, TRUE);
+                            break;
+                        }
+                    }
+                }
+                DispatchSlot slot = thImpl.GetMethodTable()->FindDispatchSlotForInterfaceMD(pDeclMethod, /*throwOnConflict*/ FALSE);
+                pImplMethodRuntime = slot.GetMethodDesc();
+            }
+            else
+            {
+                MethodTable *pCheckMT = thImpl.GetMethodTable();
+                MethodTable *pBaseMT = pDeclMethod->GetMethodTable();
+                WORD slot = pDeclMethod->GetSlot();
+
+                while (pCheckMT != nullptr)
+                {
+                    if (pCheckMT->HasSameTypeDefAs(pBaseMT))
+                    {
+                        break;
+                    }
+
+                    pCheckMT = pCheckMT->GetParentMethodTable();
+                }
+
+                if (pCheckMT == nullptr)
+                {
+                    pImplMethodRuntime = NULL;
+                }
+                else if (IsMdFinal(pDeclMethod->GetAttrs()))
+                {
+                    pImplMethodRuntime = pDeclMethod;
+                }
+                else
+                {
+                    _ASSERTE(slot < pBaseMT->GetNumVirtuals());
+                    pImplMethodRuntime = thImpl.GetMethodTable()->GetMethodDescForSlot(slot);
+                }
+            }
+
+            if (pImplMethodRuntime != pImplMethodCompiler)
+            {
+                if (kind == ENCODE_CHECK_VIRTUAL_FUNCTION_OVERRIDE)
+                {
+                    return FALSE;
+                }
+                else
+                {
+                    // Verification failures are failfast events
+                    DefineFullyQualifiedNameForClassW();
+                    SString methodNameDecl;
+                    SString methodNameImplRuntime(W("(NULL)"));
+                    SString methodNameImplCompiler(W("(NULL)"));
+
+                    pDeclMethod->GetFullMethodInfo(methodNameDecl);
+
+                    if (pImplMethodRuntime != NULL)
+                    {
+                        methodNameImplRuntime.Clear();
+                        pImplMethodRuntime->GetFullMethodInfo(methodNameImplRuntime);
+                    }
+
+                    if (pImplMethodCompiler != NULL)
+                    {
+                        methodNameImplCompiler.Clear();
+                        pImplMethodCompiler->GetFullMethodInfo(methodNameImplCompiler);
+                    }
+
+                    SString fatalErrorString;
+                    fatalErrorString.Printf(W("Verify_VirtualFunctionOverride Decl Method '%s' on type '%s' is '%s'(actual) instead of expected '%s'(from compiler)"),
+                        methodNameDecl.GetUnicode(),
+                        GetFullyQualifiedNameForClassW(thImpl.GetMethodTable()),
+                        methodNameImplRuntime.GetUnicode(),
+                        methodNameImplCompiler.GetUnicode());
+
+#ifdef _DEBUG
+                    {
+                        StackScratchBuffer buf;
+                        _ASSERTE_MSG(false, fatalErrorString.GetUTF8(buf));
+                    }
+#endif
+                    _ASSERTE(!IsDebuggerPresent() && "Stop on assert here instead of fatal error for ease of live debugging");
+
+                    EEPOLICY_HANDLE_FATAL_ERROR_WITH_MESSAGE(-1, fatalErrorString.GetUnicode());
+                    return FALSE;
+
+                }
+            }
+
+            result = 1;
+        }
+        break;
+
 
     case ENCODE_CHECK_INSTRUCTION_SET_SUPPORT:
         {
diff --git a/src/coreclr/vm/jitinterface.h b/src/coreclr/vm/jitinterface.h
index eda60f61cc65e7..29e566a7342472 100644
--- a/src/coreclr/vm/jitinterface.h
+++ b/src/coreclr/vm/jitinterface.h
@@ -961,8 +961,8 @@ protected :
 
 
     EEJitManager*           m_jitManager;   // responsible for allocating memory
-    CodeHeader*             m_CodeHeader;   // descriptor for JITTED code
-    CodeHeader*             m_CodeHeaderRW;
+    CodeHeader*             m_CodeHeader;   // descriptor for JITTED code - read/execute address
+    CodeHeader*             m_CodeHeaderRW; // descriptor for JITTED code - code write scratch buffer address
     size_t                  m_codeWriteBufferSize;
 #ifdef USE_INDIRECT_CODEHEADER
     BYTE*                   m_pRealCodeHeader;
diff --git a/src/coreclr/vm/marshalnative.cpp b/src/coreclr/vm/marshalnative.cpp
index 6d1c38b9d3353e..b28f34aa266002 100644
--- a/src/coreclr/vm/marshalnative.cpp
+++ b/src/coreclr/vm/marshalnative.cpp
@@ -946,30 +946,6 @@ FCIMPL0(FC_BOOL_RET, MarshalNative::AreComObjectsAvailableForCleanup)
 }
 FCIMPLEND
 
-//====================================================================
-// check if the object is classic COM component
-//====================================================================
-FCIMPL1(FC_BOOL_RET, MarshalNative::IsComObject, Object* objUNSAFE)
-{
-    FCALL_CONTRACT;
-
-    BOOL retVal = FALSE;
-    OBJECTREF obj = (OBJECTREF) objUNSAFE;
-    HELPER_METHOD_FRAME_BEGIN_RET_1(obj);
-
-    if(!obj)
-        COMPlusThrowArgumentNull(W("o"));
-
-    MethodTable* pMT = obj->GetMethodTable();
-    PREFIX_ASSUME(pMT != NULL);
-    retVal = pMT->IsComObjectType();
-
-    HELPER_METHOD_FRAME_END();
-    FC_RETURN_BOOL(retVal);
-}
-FCIMPLEND
-
-
 //====================================================================
 // free the COM component and zombie this object if the ref count hits 0
 // further usage of this Object might throw an exception,
diff --git a/src/coreclr/vm/marshalnative.h b/src/coreclr/vm/marshalnative.h
index 790c7316d32b55..8a3615294ffc6a 100644
--- a/src/coreclr/vm/marshalnative.h
+++ b/src/coreclr/vm/marshalnative.h
@@ -103,11 +103,6 @@ class MarshalNative
     //====================================================================
     static FCDECL2(IUnknown*, CreateAggregatedObjectNative, IUnknown* pOuter, Object* refObjUNSAFE);
 
-    //====================================================================
-    // check if the object is classic COM component
-    //====================================================================
-    static FCDECL1(FC_BOOL_RET, IsComObject, Object* objUNSAFE);
-
     //====================================================================
     // free the COM component and zombie this object
     // further usage of this Object might throw an exception,
diff --git a/src/coreclr/vm/method.cpp b/src/coreclr/vm/method.cpp
index 5f19b8ce3f49eb..bd3984d8697cda 100644
--- a/src/coreclr/vm/method.cpp
+++ b/src/coreclr/vm/method.cpp
@@ -4168,10 +4168,10 @@ static const struct CentralJumpCode {
     BYTE m_jmp[1];
     INT32 m_rel32;
 
-    inline void Setup(MethodDesc* pMD, PCODE target, LoaderAllocator *pLoaderAllocator) {
+    inline void Setup(CentralJumpCode* pCodeRX, MethodDesc* pMD, PCODE target, LoaderAllocator *pLoaderAllocator) {
         WRAPPER_NO_CONTRACT;
         m_pBaseMD = pMD;
-        m_rel32 = rel32UsingJumpStub(&m_rel32, target, pMD, pLoaderAllocator);
+        m_rel32 = rel32UsingJumpStub(&pCodeRX->m_rel32, target, pMD, pLoaderAllocator);
     }
 
     inline BOOL CheckTarget(TADDR target) {
@@ -4200,10 +4200,10 @@ static const struct CentralJumpCode {
     BYTE m_jmp[1];
     INT32 m_rel32;
 
-    inline void Setup(MethodDesc* pMD, PCODE target, LoaderAllocator *pLoaderAllocator) {
+    inline void Setup(CentralJumpCode* pCodeRX, MethodDesc* pMD, PCODE target, LoaderAllocator *pLoaderAllocator) {
         WRAPPER_NO_CONTRACT;
         m_pBaseMD = pMD;
-        m_rel32 = rel32UsingJumpStub(&m_rel32, target, pMD, pLoaderAllocator);
+        m_rel32 = rel32UsingJumpStub(&pCodeRX->m_rel32, target, pMD, pLoaderAllocator);
     }
 
     inline BOOL CheckTarget(TADDR target) {
@@ -4488,15 +4488,17 @@ TADDR MethodDescChunk::AllocateCompactEntryPoints(LoaderAllocator *pLoaderAlloca
     SIZE_T size = SizeOfCompactEntryPoints(count);
 
     TADDR temporaryEntryPoints = (TADDR)pamTracker->Track(pLoaderAllocator->GetPrecodeHeap()->AllocAlignedMem(size, sizeof(TADDR)));
+    ExecutableWriterHolder<void> temporaryEntryPointsWriterHolder((void *)temporaryEntryPoints, size);
+    size_t rxOffset = temporaryEntryPoints - (TADDR)temporaryEntryPointsWriterHolder.GetRW();
 
 #ifdef TARGET_ARM
-    BYTE* p = (BYTE*)temporaryEntryPoints + COMPACT_ENTRY_ARM_CODE;
+    BYTE* p = (BYTE*)temporaryEntryPointsWriterHolder.GetRW() + COMPACT_ENTRY_ARM_CODE;
     int relOffset        = count * TEP_ENTRY_SIZE - TEP_ENTRY_SIZE; // relative offset for the short jump
 
     _ASSERTE (relOffset < MAX_OFFSET_UNCONDITIONAL_BRANCH_THUMB);
 #else // TARGET_ARM
     // make the temporary entrypoints unaligned, so they are easy to identify
-    BYTE* p = (BYTE*)temporaryEntryPoints + 1;
+    BYTE* p = (BYTE*)temporaryEntryPointsWriterHolder.GetRW() + 1;
     int indexInBlock     = TEP_MAX_BLOCK_INDEX;         // recompute relOffset in first iteration
     int relOffset        = 0;                           // relative offset for the short jump
 #endif // TARGET_ARM
@@ -4541,10 +4543,11 @@ TADDR MethodDescChunk::AllocateCompactEntryPoints(LoaderAllocator *pLoaderAlloca
         if (relOffset == 0)
         {
             CentralJumpCode* pCode = (CentralJumpCode*)p;
+            CentralJumpCode* pCodeRX = (CentralJumpCode*)(p + rxOffset);
 
             memcpy(pCode, &c_CentralJumpCode, TEP_CENTRAL_JUMP_SIZE);
 
-            pCode->Setup(pBaseMD, GetPreStubEntryPoint(), pLoaderAllocator);
+            pCode->Setup(pCodeRX, pBaseMD, GetPreStubEntryPoint(), pLoaderAllocator);
 
             p += TEP_CENTRAL_JUMP_SIZE;
 
@@ -4565,11 +4568,11 @@ TADDR MethodDescChunk::AllocateCompactEntryPoints(LoaderAllocator *pLoaderAlloca
     memcpy(pCode, &c_CentralJumpCode, TEP_CENTRAL_JUMP_SIZE);
     pCode->Setup (GetPreStubCompactARMEntryPoint(), this);
 
-    _ASSERTE(p + TEP_CENTRAL_JUMP_SIZE == (BYTE*)temporaryEntryPoints + size);
+    _ASSERTE(p + TEP_CENTRAL_JUMP_SIZE == (BYTE*)temporaryEntryPointsWriterHolder.GetRW() + size);
 
 #else // TARGET_ARM
 
-    _ASSERTE(p == (BYTE*)temporaryEntryPoints + size);
+    _ASSERTE(p == (BYTE*)temporaryEntryPointsWriterHolder.GetRW() + size);
 
 #endif // TARGET_ARM
 
diff --git a/src/coreclr/vm/method.hpp b/src/coreclr/vm/method.hpp
index 491eeb671683f6..c929cbeea4e036 100644
--- a/src/coreclr/vm/method.hpp
+++ b/src/coreclr/vm/method.hpp
@@ -2023,7 +2023,7 @@ class MethodDesc
     PCODE GetPrecompiledCode(PrepareCodeConfig* pConfig, bool shouldTier);
     PCODE GetPrecompiledNgenCode(PrepareCodeConfig* pConfig);
     PCODE GetPrecompiledR2RCode(PrepareCodeConfig* pConfig);
-    PCODE GetMulticoreJitCode(PrepareCodeConfig* pConfig, bool* pWasTier0Jit);
+    PCODE GetMulticoreJitCode(PrepareCodeConfig* pConfig, bool* pWasTier0);
     COR_ILMETHOD_DECODER* GetAndVerifyILHeader(PrepareCodeConfig* pConfig, COR_ILMETHOD_DECODER* pIlDecoderMemory);
     COR_ILMETHOD_DECODER* GetAndVerifyMetadataILHeader(PrepareCodeConfig* pConfig, COR_ILMETHOD_DECODER* pIlDecoderMemory);
     COR_ILMETHOD_DECODER* GetAndVerifyNoMetadataILHeader();
@@ -2208,7 +2208,8 @@ class PrepareCodeConfig
         }
     }
 
-    bool FinalizeOptimizationTierForTier0Jit();
+    bool FinalizeOptimizationTierForTier0Load();
+    bool FinalizeOptimizationTierForTier0LoadOrJit();
 #endif
 
 public:
@@ -2300,21 +2301,21 @@ class PrepareCodeConfigBuffer
 class MulticoreJitPrepareCodeConfig : public PrepareCodeConfig
 {
 private:
-    bool m_wasTier0Jit;
+    bool m_wasTier0;
 
 public:
     MulticoreJitPrepareCodeConfig(MethodDesc* pMethod);
 
-    bool WasTier0Jit() const
+    bool WasTier0() const
     {
         LIMITED_METHOD_CONTRACT;
-        return m_wasTier0Jit;
+        return m_wasTier0;
     }
 
-    void SetWasTier0Jit()
+    void SetWasTier0()
     {
         LIMITED_METHOD_CONTRACT;
-        m_wasTier0Jit = true;
+        m_wasTier0 = true;
     }
 
     virtual BOOL SetNativeCode(PCODE pCode, PCODE * ppAlternateCodeToUse) override;
diff --git a/src/coreclr/vm/methoddescbackpatchinfo.cpp b/src/coreclr/vm/methoddescbackpatchinfo.cpp
index 000b56dbc5bbd8..94b4a1ba112af3 100644
--- a/src/coreclr/vm/methoddescbackpatchinfo.cpp
+++ b/src/coreclr/vm/methoddescbackpatchinfo.cpp
@@ -28,10 +28,6 @@ void EntryPointSlots::Backpatch_Locked(TADDR slot, SlotType slotType, PCODE entr
     _ASSERTE(entryPoint != NULL);
     _ASSERTE(IS_ALIGNED((SIZE_T)slot, GetRequiredSlotAlignment(slotType)));
 
-#if defined(HOST_OSX) && defined(HOST_ARM64)
-    auto jitWriteEnableHolder = PAL_JITWriteEnable(true);
-#endif // defined(HOST_OSX) && defined(HOST_ARM64)
-
     switch (slotType)
     {
         case SlotType_Normal:
@@ -43,15 +39,21 @@ void EntryPointSlots::Backpatch_Locked(TADDR slot, SlotType slotType, PCODE entr
             break;
 
         case SlotType_Executable:
-            *(PCODE *)slot = entryPoint;
+        {
+            ExecutableWriterHolder<void> slotWriterHolder((void*)slot, sizeof(PCODE*));
+            *(PCODE *)slotWriterHolder.GetRW() = entryPoint;
             goto Flush;
+        }
 
         case SlotType_ExecutableRel32:
+        {
             // A rel32 may require a jump stub on some architectures, and is currently not supported
             _ASSERTE(sizeof(void *) <= 4);
 
-            *(PCODE *)slot = entryPoint - ((PCODE)slot + sizeof(PCODE));
+            ExecutableWriterHolder<void> slotWriterHolder((void*)slot, sizeof(PCODE*));
+            *(PCODE *)slotWriterHolder.GetRW() = entryPoint - ((PCODE)slot + sizeof(PCODE));
             // fall through
+        }
 
         Flush:
             ClrFlushInstructionCache((LPCVOID)slot, sizeof(PCODE));
diff --git a/src/coreclr/vm/methodtablebuilder.cpp b/src/coreclr/vm/methodtablebuilder.cpp
index c3b028bf0141a3..ad827323c69bc7 100644
--- a/src/coreclr/vm/methodtablebuilder.cpp
+++ b/src/coreclr/vm/methodtablebuilder.cpp
@@ -1511,7 +1511,7 @@ MethodTableBuilder::BuildMethodTableThrowing(
     if (IsComImport() && !IsEnum() && !IsInterface() && !IsValueClass() && !IsDelegate())
     {
 #ifdef FEATURE_COMINTEROP
-        // ComImport classes must either extend from Object
+        // ComImport classes must extend from Object
         MethodTable* pMTParent = GetParentMethodTable();
         if ((pMTParent == NULL) || (pMTParent != g_pObjectClass))
         {
@@ -1524,19 +1524,14 @@ MethodTableBuilder::BuildMethodTableThrowing(
             BuildMethodTableThrowException(IDS_CLASSLOAD_COMIMPCANNOTHAVELAYOUT);
         }
 
-        if (pMTParent == g_pObjectClass)
+        if (g_pBaseCOMObject != NULL)
         {
-            // ComImport classes ultimately extend from our __ComObject or RuntimeClass class
-            MethodTable *pCOMMT = g_pBaseCOMObject;
-
-            _ASSERTE(pCOMMT);
-
             // We could have had COM interop classes derive from System._ComObject,
             // but instead we have them derive from System.Object, have them set the
             // ComImport bit in the type attributes, and then we swap out the parent
             // type under the covers.
-            bmtInternal->pType->SetParentType(CreateTypeChain(pCOMMT, Substitution()));
-            bmtInternal->pParentMT = pCOMMT;
+            bmtInternal->pType->SetParentType(CreateTypeChain(g_pBaseCOMObject, Substitution()));
+            bmtInternal->pParentMT = g_pBaseCOMObject;
         }
 #endif
         // if the current class is imported
@@ -2911,6 +2906,13 @@ MethodTableBuilder::EnumerateClassMethods()
                 IDS_CLASSLOAD_BADSPECIALMETHOD,
                 tok);
         }
+
+        // Check for the presence of virtual static methods
+        if (IsMdVirtual(dwMemberAttrs) && IsMdStatic(dwMemberAttrs))
+        {
+            bmtProp->fHasVirtualStaticMethods = TRUE;
+        }
+
         //
         // But first - minimal flags validity checks
         //
@@ -2977,11 +2979,7 @@ MethodTableBuilder::EnumerateClassMethods()
                 }
                 if(IsMdStatic(dwMemberAttrs))
                 {
-                    if (fIsClassInterface)
-                    {
-                        bmtProp->fHasVirtualStaticMethods = TRUE;
-                    }
-                    else
+                    if (!fIsClassInterface)
                     {
                         // Static virtual methods are only allowed to exist in interfaces
                         BuildMethodTableThrowException(BFA_VIRTUAL_STATIC_METHOD);
@@ -6315,13 +6313,13 @@ MethodTableBuilder::PlaceMethodImpls()
             {
                 // The declaration is on the type being built
                 bmtMDMethod * pCurDeclMethod = hDeclMethod.AsMDMethod();
-    
+
                 mdToken mdef = pCurDeclMethod->GetMethodSignature().GetToken();
                 if (bmtMethodImpl->IsBody(mdef))
                 {   // A method declared on this class cannot be both a decl and an impl
                     BuildMethodTableThrowException(IDS_CLASSLOAD_MI_MULTIPLEOVERRIDES, mdef);
                 }
-    
+
                 if (IsInterface())
                 {
                     // Throws
@@ -6348,7 +6346,7 @@ MethodTableBuilder::PlaceMethodImpls()
             else
             {
                 bmtRTMethod * pCurDeclMethod = hDeclMethod.AsRTMethod();
-    
+
                 if (IsInterface())
                 {
                     // Throws
diff --git a/src/coreclr/vm/mlinfo.cpp b/src/coreclr/vm/mlinfo.cpp
index 57ee8a4825bcc0..487dd236767f0d 100644
--- a/src/coreclr/vm/mlinfo.cpp
+++ b/src/coreclr/vm/mlinfo.cpp
@@ -1138,8 +1138,6 @@ MarshalInfo::MarshalInfo(Module* pModule,
     CorElementType corElemType      = ELEMENT_TYPE_END;
     m_pMT                           = NULL;
     m_pMD                           = pMD;
-    // [Compat] For backward compatibility reasons, some marshalers imply [In, Out] behavior when marked as [In], [Out], or not marked with either.
-    BOOL byValAlwaysInOut           = FALSE;
 
 #ifdef FEATURE_COMINTEROP
     m_fDispItf                      = FALSE;
@@ -1884,7 +1882,6 @@ MarshalInfo::MarshalInfo(Module* pModule,
                     }
                     m_type = IsFieldScenario() ? MARSHAL_TYPE_BLITTABLE_LAYOUTCLASS : MARSHAL_TYPE_BLITTABLEPTR;
                     m_args.m_pMT = m_pMT;
-                    byValAlwaysInOut = TRUE;
                 }
                 else if (m_pMT->HasLayout())
                 {
@@ -2377,13 +2374,7 @@ MarshalInfo::MarshalInfo(Module* pModule,
             }
         }
 
-        if (!m_byref && byValAlwaysInOut)
-        {
-            // Some marshalers expect [In, Out] behavior with [In], [Out], or no directional attributes.
-            m_in = TRUE;
-            m_out = TRUE;
-        }
-        else if (!m_in && !m_out)
+        if (!m_in && !m_out)
         {
             // If neither IN nor OUT are true, this signals the URT to use the default
             // rules.
diff --git a/src/coreclr/vm/mlinfo.h b/src/coreclr/vm/mlinfo.h
index 68546b167c21f2..81fe67fdc2e1e2 100644
--- a/src/coreclr/vm/mlinfo.h
+++ b/src/coreclr/vm/mlinfo.h
@@ -480,6 +480,12 @@ class MarshalInfo
         return m_ms == MarshalInfo::MARSHAL_SCENARIO_FIELD;
     }
 
+    UINT GetErrorResourceId()
+    {
+        LIMITED_METHOD_CONTRACT;
+        return m_resID;
+    }
+
 private:
 
     UINT16                      GetNativeSize(MarshalType mtype);
diff --git a/src/coreclr/vm/multicorejit.cpp b/src/coreclr/vm/multicorejit.cpp
index 1feb731a68ac0a..ae8582f3cf76f3 100644
--- a/src/coreclr/vm/multicorejit.cpp
+++ b/src/coreclr/vm/multicorejit.cpp
@@ -869,7 +869,7 @@ void MulticoreJitRecorder::PreRecordFirstMethod()
 }
 
 
-void MulticoreJitRecorder::RecordMethodJit(MethodDesc * pMethod, bool application)
+void MulticoreJitRecorder::RecordMethodJitOrLoad(MethodDesc * pMethod, bool application)
 {
     STANDARD_VM_CONTRACT;
 
@@ -1103,7 +1103,7 @@ MulticoreJitCodeInfo MulticoreJitRecorder::RequestMethodCode(MethodDesc * pMetho
 
     if (!codeInfo.IsNull() && pManager->IsRecorderActive()) // recorder may be off when player is on (e.g. for Appx)
     {
-        RecordMethodJit(pMethod, false); // JITTed by background thread, returned to application
+        RecordMethodJitOrLoad(pMethod, false); // JITTed by background thread, returned to application
     }
 
     return codeInfo;
@@ -1426,7 +1426,7 @@ MulticoreJitCodeInfo MulticoreJitManager::RequestMethodCode(MethodDesc * pMethod
 // Call back from MethodDesc::MakeJitWorker for
 // Threading: protected by m_playerLock
 
-void MulticoreJitManager::RecordMethodJit(MethodDesc * pMethod)
+void MulticoreJitManager::RecordMethodJitOrLoad(MethodDesc * pMethod)
 {
     STANDARD_VM_CONTRACT;
 
@@ -1434,7 +1434,7 @@ void MulticoreJitManager::RecordMethodJit(MethodDesc * pMethod)
 
     if (m_pMulticoreJitRecorder != NULL)
     {
-        m_pMulticoreJitRecorder->RecordMethodJit(pMethod, true);
+        m_pMulticoreJitRecorder->RecordMethodJitOrLoad(pMethod, true);
 
         if (m_pMulticoreJitRecorder->IsAtFullCapacity())
         {
diff --git a/src/coreclr/vm/multicorejit.h b/src/coreclr/vm/multicorejit.h
index 4e199a4ae0fb52..3b7bae0a926422 100644
--- a/src/coreclr/vm/multicorejit.h
+++ b/src/coreclr/vm/multicorejit.h
@@ -84,9 +84,9 @@ class MulticoreJitCodeInfo
     enum class TierInfo : TADDR
     {
         None = 0,
-        WasTier0Jit = 1 << 0,
+        WasTier0 = 1 << 0,
         JitSwitchedToOptimized = 1 << 1,
-        Mask = None | WasTier0Jit | JitSwitchedToOptimized
+        Mask = None | WasTier0 | JitSwitchedToOptimized
     };
 
     TADDR m_entryPointAndTierInfo;
@@ -118,12 +118,12 @@ class MulticoreJitCodeInfo
         return IsNull() ? NULL : PINSTRToPCODE(m_entryPointAndTierInfo & ~(TADDR)TierInfo::Mask);
     }
 
-    bool WasTier0Jit() const
+    bool WasTier0() const
     {
         WRAPPER_NO_CONTRACT;
         VerifyIsNotNull();
 
-        return (m_entryPointAndTierInfo & (TADDR)TierInfo::WasTier0Jit) != 0;
+        return (m_entryPointAndTierInfo & (TADDR)TierInfo::WasTier0) != 0;
     }
 
     bool JitSwitchedToOptimized() const
@@ -281,7 +281,7 @@ class MulticoreJitManager
 
     MulticoreJitCodeInfo RequestMethodCode(MethodDesc * pMethod);
 
-    void RecordMethodJit(MethodDesc * pMethod);
+    void RecordMethodJitOrLoad(MethodDesc * pMethod);
 
     MulticoreJitPlayerStat & GetStats()
     {
diff --git a/src/coreclr/vm/multicorejitimpl.h b/src/coreclr/vm/multicorejitimpl.h
index cd00e6f9832f71..234493f0b3e916 100644
--- a/src/coreclr/vm/multicorejitimpl.h
+++ b/src/coreclr/vm/multicorejitimpl.h
@@ -705,7 +705,7 @@ class MulticoreJitRecorder
                (m_ModuleCount  >= MAX_MODULES);
     }
 
-    void RecordMethodJit(MethodDesc * pMethod, bool application);
+    void RecordMethodJitOrLoad(MethodDesc * pMethod, bool application);
 
     MulticoreJitCodeInfo RequestMethodCode(MethodDesc * pMethod, MulticoreJitManager * pManager);
 
diff --git a/src/coreclr/vm/multicorejitplayer.cpp b/src/coreclr/vm/multicorejitplayer.cpp
index ab243cc89a3c5c..da75fe43b39bc3 100644
--- a/src/coreclr/vm/multicorejitplayer.cpp
+++ b/src/coreclr/vm/multicorejitplayer.cpp
@@ -87,7 +87,7 @@ void MulticoreJitCodeStorage::StoreMethodCode(MethodDesc * pMD, MulticoreJitCode
                 "%p %p %d %d StoredMethodCode",
                 pMD,
                 codeInfo.GetEntryPoint(),
-                (int)codeInfo.WasTier0Jit(),
+                (int)codeInfo.WasTier0(),
                 (int)codeInfo.JitSwitchedToOptimized()));
         }
 #endif
@@ -131,7 +131,7 @@ MulticoreJitCodeInfo MulticoreJitCodeStorage::QueryAndRemoveMethodCode(MethodDes
                     "%p %p %d %d QueryAndRemoveMethodCode",
                     pMethod,
                     codeInfo.GetEntryPoint(),
-                    (int)codeInfo.WasTier0Jit(),
+                    (int)codeInfo.WasTier0(),
                     (int)codeInfo.JitSwitchedToOptimized()));
             }
 #endif
@@ -521,7 +521,9 @@ HRESULT MulticoreJitProfilePlayer::HandleModuleRecord(const ModuleRecord * pMod)
 
 #ifndef DACCESS_COMPILE
 MulticoreJitPrepareCodeConfig::MulticoreJitPrepareCodeConfig(MethodDesc* pMethod) :
-    PrepareCodeConfig(NativeCodeVersion(pMethod), FALSE, FALSE), m_wasTier0Jit(false)
+    // Method code that was pregenerated and loaded is recorded in the multi-core JIT profile, so enable multi-core JIT to also
+    // look up pregenerated code to help parallelize the work
+    PrepareCodeConfig(NativeCodeVersion(pMethod), FALSE, TRUE), m_wasTier0(false)
 {
     WRAPPER_NO_CONTRACT;
 
@@ -548,9 +550,9 @@ MulticoreJitCodeInfo::MulticoreJitCodeInfo(PCODE entryPoint, const MulticoreJitP
     _ASSERTE((m_entryPointAndTierInfo & (TADDR)TierInfo::Mask) == 0);
 
 #ifdef FEATURE_TIERED_COMPILATION
-    if (pConfig->WasTier0Jit())
+    if (pConfig->WasTier0())
     {
-        m_entryPointAndTierInfo |= (TADDR)TierInfo::WasTier0Jit;
+        m_entryPointAndTierInfo |= (TADDR)TierInfo::WasTier0;
     }
 
     if (pConfig->JitSwitchedToOptimized())
@@ -890,7 +892,6 @@ HRESULT MulticoreJitProfilePlayer::HandleNonGenericMethodInfoRecord(unsigned mod
             // Similar to Module::FindMethod + Module::FindMethodThrowing,
             // except it calls GetMethodDescFromMemberDefOrRefOrSpec with strictMetadataChecks=FALSE to allow generic instantiation
             MethodDesc * pMethod = MemberLoader::GetMethodDescFromMemberDefOrRefOrSpec(pModule, token, NULL, FALSE, FALSE);
-
             CompileMethodInfoRecord(pModule, pMethod, false);
         }
         else
@@ -1292,7 +1293,6 @@ HRESULT MulticoreJitProfilePlayer::PlayProfile()
                 unsigned curdata1 = * (const unsigned *) pCurBuf;
                 unsigned currcdTyp = curdata1 >> RECORD_TYPE_OFFSET;
                 unsigned curmoduleIndex = curdata1 & MODULE_MASK;
-                unsigned curflags = curdata1 & METHOD_FLAGS_MASK;
 
                 if (currcdTyp == MULTICOREJIT_METHOD_RECORD_ID)
                 {
diff --git a/src/coreclr/vm/nativeimage.cpp b/src/coreclr/vm/nativeimage.cpp
index 5500da1acc8726..8338dbc60960b4 100644
--- a/src/coreclr/vm/nativeimage.cpp
+++ b/src/coreclr/vm/nativeimage.cpp
@@ -143,59 +143,69 @@ NativeImage *NativeImage::Open(
 
     NewHolder<PEImageLayout> peLoadedImage;
 
-    EX_TRY
+    BundleFileLocation bundleFileLocation = Bundle::ProbeAppBundle(fullPath, /*pathIsBundleRelative */ true);
+    if (bundleFileLocation.IsValid())
     {
-        peLoadedImage = PEImageLayout::LoadNative(fullPath);
+        PEImageHolder pImage = PEImage::OpenImage(fullPath, MDInternalImport_NoCache, bundleFileLocation);
+        peLoadedImage = pImage->GetLayout(PEImageLayout::LAYOUT_MAPPED, PEImage::LAYOUT_CREATEIFNEEDED);
     }
-    EX_CATCH
+
+    if (peLoadedImage.IsNull())
     {
-        SString searchPaths(searchPathsConfig);
-        SString::CIterator start = searchPaths.Begin();
-        while (start != searchPaths.End())
+        EX_TRY
         {
-            SString::CIterator end = start;
-            if (!searchPaths.Find(end, PATH_SEPARATOR_CHAR_W))
-            {
-                end = searchPaths.End();
-            }
-            fullPath.Set(searchPaths, start, (COUNT_T)(end - start));
-
-            if (end != searchPaths.End())
-            {
-                // Skip path separator character
-                ++end;
-            }
-            start = end;
-
-            if (fullPath.GetCount() == 0)
-            {
-                continue;
-            }
-
-            fullPath.Append(DIRECTORY_SEPARATOR_CHAR_W);
-            fullPath += compositeImageFileName;
-            
-            EX_TRY
-            {
-                peLoadedImage = PEImageLayout::LoadNative(fullPath);
-                break;
-            }
-            EX_CATCH
+            peLoadedImage = PEImageLayout::LoadNative(fullPath);
+        }
+        EX_CATCH
+        {
+            SString searchPaths(searchPathsConfig);
+            SString::CIterator start = searchPaths.Begin();
+            while (start != searchPaths.End())
             {
+                SString::CIterator end = start;
+                if (!searchPaths.Find(end, PATH_SEPARATOR_CHAR_W))
+                {
+                    end = searchPaths.End();
+                }
+                fullPath.Set(searchPaths, start, (COUNT_T)(end - start));
+
+                if (end != searchPaths.End())
+                {
+                    // Skip path separator character
+                    ++end;
+                }
+                start = end;
+
+                if (fullPath.GetCount() == 0)
+                {
+                    continue;
+                }
+
+                fullPath.Append(DIRECTORY_SEPARATOR_CHAR_W);
+                fullPath += compositeImageFileName;
+                
+                EX_TRY
+                {
+                    peLoadedImage = PEImageLayout::LoadNative(fullPath);
+                    break;
+                }
+                EX_CATCH
+                {
+                }
+                EX_END_CATCH(SwallowAllExceptions)
             }
-            EX_END_CATCH(SwallowAllExceptions)
         }
-    }
-    EX_END_CATCH(SwallowAllExceptions)
+        EX_END_CATCH(SwallowAllExceptions)
 
-    if (peLoadedImage.IsNull())
-    {
-        // Failed to locate the native composite R2R image
-        LOG((LF_LOADER, LL_ALWAYS, "LOADER: failed to load native image '%s' for component assembly '%S' using search paths: '%S'\n",
-            nativeImageFileName,
-            path.GetUnicode(),
-            searchPathsConfig != nullptr ? searchPathsConfig : W("<use COMPlus_NativeImageSearchPaths to set>")));
-        RaiseFailFastException(nullptr, nullptr, 0);
+        if (peLoadedImage.IsNull())
+        {
+            // Failed to locate the native composite R2R image
+            LOG((LF_LOADER, LL_ALWAYS, "LOADER: failed to load native image '%s' for component assembly '%S' using search paths: '%S'\n",
+                nativeImageFileName,
+                path.GetUnicode(),
+                searchPathsConfig != nullptr ? searchPathsConfig : W("<use COMPlus_NativeImageSearchPaths to set>")));
+            RaiseFailFastException(nullptr, nullptr, 0);
+        }
     }
 
     READYTORUN_HEADER *pHeader = (READYTORUN_HEADER *)peLoadedImage->GetExport("RTR_HEADER");
diff --git a/src/coreclr/vm/precode.cpp b/src/coreclr/vm/precode.cpp
index 2ef201d6296546..80731c191e7372 100644
--- a/src/coreclr/vm/precode.cpp
+++ b/src/coreclr/vm/precode.cpp
@@ -360,7 +360,8 @@ Precode* Precode::Allocate(PrecodeType t, MethodDesc* pMD,
     }
 
     Precode* pPrecode = (Precode*)pamTracker->Track(pLoaderAllocator->GetPrecodeHeap()->AllocAlignedMem(size, AlignOf(t)));
-    pPrecode->Init(t, pMD, pLoaderAllocator);
+    ExecutableWriterHolder<Precode> precodeWriterHolder(pPrecode, size);
+    precodeWriterHolder.GetRW()->Init(pPrecode, t, pMD, pLoaderAllocator);
 
 #ifndef CROSSGEN_COMPILE
     ClrFlushInstructionCache(pPrecode, size);
@@ -369,22 +370,22 @@ Precode* Precode::Allocate(PrecodeType t, MethodDesc* pMD,
     return pPrecode;
 }
 
-void Precode::Init(PrecodeType t, MethodDesc* pMD, LoaderAllocator *pLoaderAllocator)
+void Precode::Init(Precode* pPrecodeRX, PrecodeType t, MethodDesc* pMD, LoaderAllocator *pLoaderAllocator)
 {
     LIMITED_METHOD_CONTRACT;
 
     switch (t) {
     case PRECODE_STUB:
-        ((StubPrecode*)this)->Init(pMD, pLoaderAllocator);
+        ((StubPrecode*)this)->Init((StubPrecode*)pPrecodeRX, pMD, pLoaderAllocator);
         break;
 #ifdef HAS_NDIRECT_IMPORT_PRECODE
     case PRECODE_NDIRECT_IMPORT:
-        ((NDirectImportPrecode*)this)->Init(pMD, pLoaderAllocator);
+        ((NDirectImportPrecode*)this)->Init((NDirectImportPrecode*)pPrecodeRX, pMD, pLoaderAllocator);
         break;
 #endif // HAS_NDIRECT_IMPORT_PRECODE
 #ifdef HAS_FIXUP_PRECODE
     case PRECODE_FIXUP:
-        ((FixupPrecode*)this)->Init(pMD, pLoaderAllocator);
+        ((FixupPrecode*)this)->Init((FixupPrecode*)pPrecodeRX, pMD, pLoaderAllocator);
         break;
 #endif // HAS_FIXUP_PRECODE
 #ifdef HAS_THISPTR_RETBUF_PRECODE
@@ -404,10 +405,6 @@ void Precode::ResetTargetInterlocked()
 {
     WRAPPER_NO_CONTRACT;
 
-#if defined(HOST_OSX) && defined(HOST_ARM64)
-    auto jitWriteEnableHolder = PAL_JITWriteEnable(true);
-#endif // defined(HOST_OSX) && defined(HOST_ARM64)
-
     PrecodeType precodeType = GetType();
     switch (precodeType)
     {
@@ -441,10 +438,6 @@ BOOL Precode::SetTargetInterlocked(PCODE target, BOOL fOnlyRedirectFromPrestub)
     if (fOnlyRedirectFromPrestub && !IsPointingToPrestub(expected))
         return FALSE;
 
-#if defined(HOST_OSX) && defined(HOST_ARM64)
-    auto jitWriteEnableHolder = PAL_JITWriteEnable(true);
-#endif // defined(HOST_OSX) && defined(HOST_ARM64)
-
     g_IBCLogger.LogMethodPrecodeWriteAccess(GetMethodDesc());
 
     PrecodeType precodeType = GetType();
@@ -482,7 +475,21 @@ void Precode::Reset()
     WRAPPER_NO_CONTRACT;
 
     MethodDesc* pMD = GetMethodDesc();
-    Init(GetType(), pMD, pMD->GetLoaderAllocator());
+    SIZE_T size;
+    PrecodeType t = GetType();
+#ifdef HAS_FIXUP_PRECODE_CHUNKS
+    if (t == PRECODE_FIXUP)
+    {
+        size = sizeof(FixupPrecode) + sizeof(PTR_MethodDesc);
+    }
+    else
+#endif
+    {
+        size = Precode::SizeOf(t);
+    }
+
+    ExecutableWriterHolder<Precode> precodeWriterHolder(this, size);
+    precodeWriterHolder.GetRW()->Init(this, GetType(), pMD, pMD->GetLoaderAllocator());
     ClrFlushInstructionCache(this, SizeOf());
 }
 
@@ -566,28 +573,34 @@ TADDR Precode::AllocateTemporaryEntryPoints(MethodDescChunk *  pChunk,
 #endif
 
     TADDR temporaryEntryPoints = (TADDR)pamTracker->Track(pLoaderAllocator->GetPrecodeHeap()->AllocAlignedMem(totalSize, AlignOf(t)));
+    ExecutableWriterHolder<void> entryPointsWriterHolder((void*)temporaryEntryPoints, totalSize);
 
 #ifdef HAS_FIXUP_PRECODE_CHUNKS
     if (t == PRECODE_FIXUP)
     {
 #ifdef FIXUP_PRECODE_PREALLOCATE_DYNAMIC_METHOD_JUMP_STUBS
+        PCODE precodeFixupJumpStubRW = NULL;
         PCODE precodeFixupJumpStub = NULL;
         if (preallocateJumpStubs)
         {
             // Emit the jump for the precode fixup jump stub now. This jump stub immediately follows the MethodDesc (see
             // GetDynamicMethodPrecodeFixupJumpStub()).
             precodeFixupJumpStub = temporaryEntryPoints + count * sizeof(FixupPrecode) + sizeof(PTR_MethodDesc);
+            // TODO: how to get the size?
 #ifndef CROSSGEN_COMPILE
-            emitBackToBackJump((LPBYTE)precodeFixupJumpStub, (LPVOID)GetEEFuncEntryPoint(PrecodeFixupThunk));
+            precodeFixupJumpStubRW = (TADDR)entryPointsWriterHolder.GetRW() + count * sizeof(FixupPrecode) + sizeof(PTR_MethodDesc);
+            emitBackToBackJump((BYTE*)precodeFixupJumpStub, (BYTE*)precodeFixupJumpStubRW, (LPVOID)GetEEFuncEntryPoint(PrecodeFixupThunk));
 #endif // !CROSSGEN_COMPILE
         }
 #endif // FIXUP_PRECODE_PREALLOCATE_DYNAMIC_METHOD_JUMP_STUBS
 
         TADDR entryPoint = temporaryEntryPoints;
+        TADDR entryPointRW = (TADDR)entryPointsWriterHolder.GetRW();
+
         MethodDesc * pMD = pChunk->GetFirstMethodDesc();
         for (int i = 0; i < count; i++)
         {
-            ((FixupPrecode *)entryPoint)->Init(pMD, pLoaderAllocator, pMD->GetMethodDescIndex(), (count - 1) - i);
+            ((FixupPrecode *)entryPointRW)->Init((FixupPrecode*)entryPoint, pMD, pLoaderAllocator, pMD->GetMethodDescIndex(), (count - 1) - i);
 
 #ifdef FIXUP_PRECODE_PREALLOCATE_DYNAMIC_METHOD_JUMP_STUBS
             _ASSERTE(
@@ -598,6 +611,7 @@ TADDR Precode::AllocateTemporaryEntryPoints(MethodDescChunk *  pChunk,
 
             _ASSERTE((Precode *)entryPoint == GetPrecodeForTemporaryEntryPoint(temporaryEntryPoints, i));
             entryPoint += sizeof(FixupPrecode);
+            entryPointRW += sizeof(FixupPrecode);
 
             pMD = (MethodDesc *)(dac_cast<TADDR>(pMD) + pMD->SizeOf());
         }
@@ -613,13 +627,15 @@ TADDR Precode::AllocateTemporaryEntryPoints(MethodDescChunk *  pChunk,
 
     SIZE_T oneSize = SizeOfTemporaryEntryPoint(t);
     TADDR entryPoint = temporaryEntryPoints;
+    TADDR entryPointRW = (TADDR)entryPointsWriterHolder.GetRW();
     MethodDesc * pMD = pChunk->GetFirstMethodDesc();
     for (int i = 0; i < count; i++)
     {
-        ((Precode *)entryPoint)->Init(t, pMD, pLoaderAllocator);
+        ((Precode *)entryPointRW)->Init((Precode *)entryPoint, t, pMD, pLoaderAllocator);
 
         _ASSERTE((Precode *)entryPoint == GetPrecodeForTemporaryEntryPoint(temporaryEntryPoints, i));
         entryPoint += oneSize;
+        entryPointRW += oneSize;
 
         pMD = (MethodDesc *)(dac_cast<TADDR>(pMD) + pMD->SizeOf());
     }
@@ -763,7 +779,7 @@ void Precode::SaveChunk::Save(DataImage* image, MethodDesc * pMD)
 
     SIZE_T size = Precode::SizeOf(precodeType);
     Precode* pPrecode = (Precode *)new (image->GetHeap()) BYTE[size];
-    pPrecode->Init(precodeType, pMD, NULL);
+    pPrecode->Init(pPrecode, precodeType, pMD, NULL);
     pPrecode->Save(image);
 
     // Alias the temporary entrypoint
diff --git a/src/coreclr/vm/precode.h b/src/coreclr/vm/precode.h
index 99220f3b966dd8..6ebb02fc8e41cf 100644
--- a/src/coreclr/vm/precode.h
+++ b/src/coreclr/vm/precode.h
@@ -238,7 +238,7 @@ class Precode {
 
     static Precode* Allocate(PrecodeType t, MethodDesc* pMD,
         LoaderAllocator *pLoaderAllocator, AllocMemTracker *pamTracker);
-    void Init(PrecodeType t, MethodDesc* pMD, LoaderAllocator *pLoaderAllocator);
+    void Init(Precode* pPrecodeRX, PrecodeType t, MethodDesc* pMD, LoaderAllocator *pLoaderAllocator);
 
 #ifndef DACCESS_COMPILE
     void ResetTargetInterlocked();
diff --git a/src/coreclr/vm/prestub.cpp b/src/coreclr/vm/prestub.cpp
index 01fa3287d3f702..20f5cbfaf72799 100644
--- a/src/coreclr/vm/prestub.cpp
+++ b/src/coreclr/vm/prestub.cpp
@@ -326,10 +326,6 @@ PCODE MethodDesc::PrepareCode(PrepareCodeConfig* pConfig)
 {
     STANDARD_VM_CONTRACT;
 
-#if defined(HOST_OSX) && defined(HOST_ARM64)
-    auto jitWriteEnableHolder = PAL_JITWriteEnable(true);
-#endif // defined(HOST_OSX) && defined(HOST_ARM64)
-
     // If other kinds of code need multi-versioning we could add more cases here,
     // but for now generation of all other code/stubs occurs in other code paths
     _ASSERTE(IsIL() || IsNoMetadata());
@@ -470,18 +466,43 @@ PCODE MethodDesc::GetPrecompiledCode(PrepareCodeConfig* pConfig, bool shouldTier
         {
             LOG_USING_R2R_CODE(this);
 
+#ifdef FEATURE_TIERED_COMPILATION
+            // Finalize the optimization tier before SetNativeCode() is called
+            bool shouldCountCalls = shouldTier && pConfig->FinalizeOptimizationTierForTier0Load();
+#endif
+
             if (pConfig->SetNativeCode(pCode, &pCode))
             {
 #ifdef FEATURE_CODE_VERSIONING
                 pConfig->SetGeneratedOrLoadedNewCode();
 #endif
 #ifdef FEATURE_TIERED_COMPILATION
-                if (shouldTier)
+                if (shouldCountCalls)
                 {
                     _ASSERTE(pConfig->GetCodeVersion().GetOptimizationTier() == NativeCodeVersion::OptimizationTier0);
                     pConfig->SetShouldCountCalls();
                 }
 #endif
+
+#ifdef FEATURE_MULTICOREJIT
+                // Multi-core JIT is only applicable to the default code version. A method is recorded in the profile only when
+                // SetNativeCode() above succeeds to avoid recording duplicates in the multi-core JIT profile. Successful loads
+                // of R2R code are also recorded.
+                if (pConfig->NeedsMulticoreJitNotification())
+                {
+                    _ASSERTE(pConfig->GetCodeVersion().IsDefaultVersion());
+                    _ASSERTE(!pConfig->IsForMulticoreJit());
+
+                    MulticoreJitManager & mcJitManager = GetAppDomain()->GetMulticoreJitManager();
+                    if (mcJitManager.IsRecorderActive())
+                    {
+                        if (MulticoreJitManager::IsMethodSupported(this))
+                        {
+                            mcJitManager.RecordMethodJitOrLoad(this);
+                        }
+                    }
+                }
+#endif
             }
         }
     }
@@ -516,9 +537,9 @@ PCODE MethodDesc::GetPrecompiledNgenCode(PrepareCodeConfig* pConfig)
     {
         BOOL fShouldSearchCache = TRUE;
         {
-            BEGIN_PIN_PROFILER(CORProfilerTrackCacheSearches());
-            g_profControlBlock.pProfInterface->JITCachedFunctionSearchStarted((FunctionID)this, &fShouldSearchCache);
-            END_PIN_PROFILER();
+            BEGIN_PROFILER_CALLBACK(CORProfilerTrackCacheSearches());
+            (&g_profControlBlock)->JITCachedFunctionSearchStarted((FunctionID)this, &fShouldSearchCache);
+            END_PROFILER_CALLBACK();
         }
 
         if (!fShouldSearchCache)
@@ -564,10 +585,10 @@ PCODE MethodDesc::GetPrecompiledNgenCode(PrepareCodeConfig* pConfig)
         * cached jitted function has been made.
         */
         {
-            BEGIN_PIN_PROFILER(CORProfilerTrackCacheSearches());
-            g_profControlBlock.pProfInterface->
+            BEGIN_PROFILER_CALLBACK(CORProfilerTrackCacheSearches());
+            (&g_profControlBlock)->
                 JITCachedFunctionSearchFinished((FunctionID)this, COR_PRF_CACHED_FUNCTION_FOUND);
-            END_PIN_PROFILER();
+            END_PROFILER_CALLBACK();
         }
 #endif // PROFILING_SUPPORTED
 
@@ -602,16 +623,17 @@ PCODE MethodDesc::GetPrecompiledR2RCode(PrepareCodeConfig* pConfig)
         }
     }
 #endif
+
     return pCode;
 }
 
-PCODE MethodDesc::GetMulticoreJitCode(PrepareCodeConfig* pConfig, bool* pWasTier0Jit)
+PCODE MethodDesc::GetMulticoreJitCode(PrepareCodeConfig* pConfig, bool* pWasTier0)
 {
     STANDARD_VM_CONTRACT;
     _ASSERTE(pConfig != NULL);
     _ASSERTE(pConfig->GetMethodDesc() == this);
-    _ASSERTE(pWasTier0Jit != NULL);
-    _ASSERTE(!*pWasTier0Jit);
+    _ASSERTE(pWasTier0 != NULL);
+    _ASSERTE(!*pWasTier0);
 
     MulticoreJitCodeInfo codeInfo;
 #ifdef FEATURE_MULTICOREJIT
@@ -625,9 +647,9 @@ PCODE MethodDesc::GetMulticoreJitCode(PrepareCodeConfig* pConfig, bool* pWasTier
         #ifdef FEATURE_TIERED_COMPILATION
             if (!codeInfo.IsNull())
             {
-                if (codeInfo.WasTier0Jit())
+                if (codeInfo.WasTier0())
                 {
-                    *pWasTier0Jit = true;
+                    *pWasTier0 = true;
                 }
                 if (codeInfo.JitSwitchedToOptimized())
                 {
@@ -803,13 +825,13 @@ PCODE MethodDesc::JitCompileCode(PrepareCodeConfig* pConfig)
             NativeCodeVersion codeVersion = pConfig->GetCodeVersion();
             if (codeVersion.IsDefaultVersion())
             {
-                bool wasTier0Jit = false;
-                pCode = GetMulticoreJitCode(pConfig, &wasTier0Jit);
+                bool wasTier0 = false;
+                pCode = GetMulticoreJitCode(pConfig, &wasTier0);
                 if (pCode != NULL)
                 {
                 #ifdef FEATURE_TIERED_COMPILATION
                     // Finalize the optimization tier before SetNativeCode() is called
-                    bool shouldCountCalls = wasTier0Jit && pConfig->FinalizeOptimizationTierForTier0Jit();
+                    bool shouldCountCalls = wasTier0 && pConfig->FinalizeOptimizationTierForTier0LoadOrJit();
                 #endif
 
                     if (pConfig->SetNativeCode(pCode, &pCode))
@@ -844,7 +866,7 @@ PCODE MethodDesc::JitCompileCodeLockedEventWrapper(PrepareCodeConfig* pConfig, J
 
 #ifdef PROFILING_SUPPORTED
     {
-        BEGIN_PIN_PROFILER(CORProfilerTrackJITInfo());
+        BEGIN_PROFILER_CALLBACK(CORProfilerTrackJITInfo());
         // For methods with non-zero rejit id we send ReJITCompilationStarted, otherwise
         // JITCompilationStarted. It isn't clear if this is the ideal policy for these
         // notifications yet.
@@ -853,7 +875,7 @@ PCODE MethodDesc::JitCompileCodeLockedEventWrapper(PrepareCodeConfig* pConfig, J
         if (rejitId != 0)
         {
             _ASSERTE(!nativeCodeVersion.IsDefaultVersion());
-            g_profControlBlock.pProfInterface->ReJITCompilationStarted((FunctionID)this,
+            (&g_profControlBlock)->ReJITCompilationStarted((FunctionID)this,
                 rejitId,
                 TRUE);
         }
@@ -864,7 +886,7 @@ PCODE MethodDesc::JitCompileCodeLockedEventWrapper(PrepareCodeConfig* pConfig, J
         {
             if (!IsNoMetadata())
             {
-                g_profControlBlock.pProfInterface->JITCompilationStarted((FunctionID)this, TRUE);
+                (&g_profControlBlock)->JITCompilationStarted((FunctionID)this, TRUE);
 
             }
             else
@@ -873,7 +895,7 @@ PCODE MethodDesc::JitCompileCodeLockedEventWrapper(PrepareCodeConfig* pConfig, J
                 CorInfoOptions corOptions;
                 LPCBYTE ilHeaderPointer = this->AsDynamicMethodDesc()->GetResolver()->GetCodeInfo(&ilSize, &unused, &corOptions, &unused);
 
-                g_profControlBlock.pProfInterface->DynamicMethodJITCompilationStarted((FunctionID)this, TRUE, ilHeaderPointer, ilSize);
+                (&g_profControlBlock)->DynamicMethodJITCompilationStarted((FunctionID)this, TRUE, ilHeaderPointer, ilSize);
             }
 
             if (nativeCodeVersion.IsDefaultVersion())
@@ -881,7 +903,7 @@ PCODE MethodDesc::JitCompileCodeLockedEventWrapper(PrepareCodeConfig* pConfig, J
                 pConfig->SetProfilerMayHaveActivatedNonDefaultCodeVersion();
             }
         }
-        END_PIN_PROFILER();
+        END_PROFILER_CALLBACK();
     }
 #endif // PROFILING_SUPPORTED
 
@@ -933,7 +955,7 @@ PCODE MethodDesc::JitCompileCodeLockedEventWrapper(PrepareCodeConfig* pConfig, J
 
 #ifdef PROFILING_SUPPORTED
     {
-        BEGIN_PIN_PROFILER(CORProfilerTrackJITInfo());
+        BEGIN_PROFILER_CALLBACK(CORProfilerTrackJITInfo());
         // For methods with non-zero rejit id we send ReJITCompilationFinished, otherwise
         // JITCompilationFinished. It isn't clear if this is the ideal policy for these
         // notifications yet.
@@ -942,7 +964,7 @@ PCODE MethodDesc::JitCompileCodeLockedEventWrapper(PrepareCodeConfig* pConfig, J
         if (rejitId != 0)
         {
             _ASSERTE(!nativeCodeVersion.IsDefaultVersion());
-            g_profControlBlock.pProfInterface->ReJITCompilationFinished((FunctionID)this,
+            (&g_profControlBlock)->ReJITCompilationFinished((FunctionID)this,
                 rejitId,
                 S_OK,
                 TRUE);
@@ -954,14 +976,14 @@ PCODE MethodDesc::JitCompileCodeLockedEventWrapper(PrepareCodeConfig* pConfig, J
         {
             if (!IsNoMetadata())
             {
-                g_profControlBlock.pProfInterface->
+                (&g_profControlBlock)->
                     JITCompilationFinished((FunctionID)this,
                         pEntry->m_hrResultCode,
                         TRUE);
             }
             else
             {
-                g_profControlBlock.pProfInterface->DynamicMethodJITCompilationFinished((FunctionID)this, pEntry->m_hrResultCode, TRUE);
+                (&g_profControlBlock)->DynamicMethodJITCompilationFinished((FunctionID)this, pEntry->m_hrResultCode, TRUE);
             }
 
             if (nativeCodeVersion.IsDefaultVersion())
@@ -969,7 +991,7 @@ PCODE MethodDesc::JitCompileCodeLockedEventWrapper(PrepareCodeConfig* pConfig, J
                 pConfig->SetProfilerMayHaveActivatedNonDefaultCodeVersion();
             }
         }
-        END_PIN_PROFILER();
+        END_PROFILER_CALLBACK();
     }
 #endif // PROFILING_SUPPORTED
 
@@ -1079,7 +1101,7 @@ PCODE MethodDesc::JitCompileCodeLocked(PrepareCodeConfig* pConfig, JitListLockEn
 
 #ifdef FEATURE_TIERED_COMPILATION
     // Finalize the optimization tier before SetNativeCode() is called
-    bool shouldCountCalls = pFlags->IsSet(CORJIT_FLAGS::CORJIT_FLAG_TIER0) && pConfig->FinalizeOptimizationTierForTier0Jit();
+    bool shouldCountCalls = pFlags->IsSet(CORJIT_FLAGS::CORJIT_FLAG_TIER0) && pConfig->FinalizeOptimizationTierForTier0LoadOrJit();
 #endif
 
     // Aside from rejit, performing a SetNativeCodeInterlocked at this point
@@ -1126,7 +1148,7 @@ PCODE MethodDesc::JitCompileCodeLocked(PrepareCodeConfig* pConfig, JitListLockEn
         {
             if (MulticoreJitManager::IsMethodSupported(this))
             {
-                mcJitManager.RecordMethodJit(this); // Tell multi-core JIT manager to record method on successful JITting
+                mcJitManager.RecordMethodJitOrLoad(this); // Tell multi-core JIT manager to record method on successful JITting
             }
         }
     }
@@ -1325,10 +1347,27 @@ const char *PrepareCodeConfig::GetJitOptimizationTierStr(PrepareCodeConfig *conf
 }
 
 #ifdef FEATURE_TIERED_COMPILATION
+// This function should be called before SetNativeCode() for consistency with usage of FinalizeOptimizationTierForTier0Jit
+bool PrepareCodeConfig::FinalizeOptimizationTierForTier0Load()
+{
+    _ASSERTE(GetMethodDesc()->IsEligibleForTieredCompilation());
+    _ASSERTE(!JitSwitchedToOptimized());
+
+    if (!IsForMulticoreJit())
+    {
+        return true; // should count calls if SetNativeCode() succeeds
+    }
+
+    // When using multi-core JIT, the loaded code would not be used until the method is called. Record some information that may
+    // be used later when the method is called.
+    ((MulticoreJitPrepareCodeConfig *)this)->SetWasTier0();
+    return false; // don't count calls
+}
+
 // This function should be called before SetNativeCode() to update the optimization tier if necessary before SetNativeCode() is
 // called. As soon as SetNativeCode() is called, another thread may get the native code and the optimization tier for that code
 // version, and it should have already been finalized.
-bool PrepareCodeConfig::FinalizeOptimizationTierForTier0Jit()
+bool PrepareCodeConfig::FinalizeOptimizationTierForTier0LoadOrJit()
 {
     _ASSERTE(GetMethodDesc()->IsEligibleForTieredCompilation());
 
@@ -1336,7 +1375,7 @@ bool PrepareCodeConfig::FinalizeOptimizationTierForTier0Jit()
     {
         // When using multi-core JIT, the jitted code would not be used until the method is called. Don't make changes to the
         // optimization tier yet, just record some information that may be used later when the method is called.
-        ((MulticoreJitPrepareCodeConfig *)this)->SetWasTier0Jit();
+        ((MulticoreJitPrepareCodeConfig *)this)->SetWasTier0();
         return false; // don't count calls
     }
 
@@ -1991,10 +2030,6 @@ extern "C" PCODE STDCALL PreStubWorker(TransitionBlock* pTransitionBlock, Method
 
         GCX_PREEMP_THREAD_EXISTS(CURRENT_THREAD);
         {
-#if defined(HOST_OSX) && defined(HOST_ARM64)
-            auto jitWriteEnableHolder = PAL_JITWriteEnable(true);
-#endif // defined(HOST_OSX) && defined(HOST_ARM64)
-
             pbRetVal = pMD->DoPrestub(pDispatchingMT, CallerGCMode::Coop);
         }
 
@@ -2229,19 +2264,6 @@ PCODE MethodDesc::DoPrestub(MethodTable *pDispatchingMT, CallerGCMode callerGCMo
         if (pCode == NULL)
         {
             pCode = GetStubForInteropMethod(this);
-#ifdef FEATURE_MULTICOREJIT
-            if (pCode)
-            {
-                MulticoreJitManager & mcJitManager = GetAppDomain()->GetMulticoreJitManager();
-                if (mcJitManager.IsRecorderActive())
-                {
-                    if (MulticoreJitManager::IsMethodSupported(this))
-                    {
-                        mcJitManager.RecordMethodJit(this); // Tell multi-core JIT manager to record method on successful JITting
-                    }
-                }
-            }
-#endif // FEATURE_MULTICOREJIT
         }
 
         GetOrCreatePrecode();
@@ -2304,7 +2326,16 @@ PCODE MethodDesc::DoPrestub(MethodTable *pDispatchingMT, CallerGCMode callerGCMo
     {
         if (!GetOrCreatePrecode()->SetTargetInterlocked(pStub->GetEntryPoint()))
         {
-            pStub->DecRef();
+            if (pStub->HasExternalEntryPoint())
+            {
+                // Stubs with external entry point are allocated from regular heap and so they are always writeable
+                pStub->DecRef();
+            }
+            else
+            {
+                ExecutableWriterHolder<Stub> stubWriterHolder(pStub, sizeof(Stub));
+                stubWriterHolder.GetRW()->DecRef();
+            }
         }
         else if (pStub->HasExternalEntryPoint())
         {
@@ -2425,7 +2456,8 @@ static PCODE PatchNonVirtualExternalMethod(MethodDesc * pMD, PCODE pCode, PTR_CO
             *(INT32 *)(pNewValue+1) = rel32UsingJumpStub((INT32*)(&pThunk->callJmp[1]), pCode, pMD, NULL);
 
             _ASSERTE(IS_ALIGNED((size_t)pThunk, sizeof(INT64)));
-            FastInterlockCompareExchangeLong((INT64*)pThunk, newValue, oldValue);
+            ExecutableWriterHolder<INT64> thunkWriterHolder((INT64*)pThunk, sizeof(INT64));
+            FastInterlockCompareExchangeLong(thunkWriterHolder.GetRW(), newValue, oldValue);
 
             FlushInstructionCache(GetCurrentProcess(), pThunk, 8);
         }
diff --git a/src/coreclr/vm/profdetach.cpp b/src/coreclr/vm/profdetach.cpp
index 392fde6c0a1061..0161bef95295b1 100644
--- a/src/coreclr/vm/profdetach.cpp
+++ b/src/coreclr/vm/profdetach.cpp
@@ -19,9 +19,9 @@
 #include "eetoprofinterfaceimpl.inl"
 
 // Class static member variables
-ProfilerDetachInfo ProfilingAPIDetach::s_profilerDetachInfo;
-CLREvent           ProfilingAPIDetach::s_eventDetachWorkAvailable;
-
+CQuickArrayList<ProfilerDetachInfo> ProfilingAPIDetach::s_profilerDetachInfos;
+CLREvent                            ProfilingAPIDetach::s_eventDetachWorkAvailable;
+Volatile<BOOL>                      ProfilingAPIDetach::s_profilerDetachThreadCreated;
 
 // ---------------------------------------------------------------------------------------
 // ProfilerDetachInfo constructor
@@ -49,7 +49,7 @@ void ProfilerDetachInfo::Init()
     // use real contracts, as this requires that utilcode has been initialized.
     STATIC_CONTRACT_LEAF;
 
-    m_pEEToProf = NULL;
+    m_pProfilerInfo = NULL;
     m_ui64DetachStartTime = 0;
     m_dwExpectedCompletionMilliseconds = 0;
 }
@@ -145,7 +145,7 @@ HRESULT ProfilingAPIDetach::Initialize()
 //
 
 // static
-HRESULT ProfilingAPIDetach::RequestProfilerDetach(DWORD dwExpectedCompletionMilliseconds)
+HRESULT ProfilingAPIDetach::RequestProfilerDetach(ProfilerInfo *pProfilerInfo, DWORD dwExpectedCompletionMilliseconds)
 {
     CONTRACTL
     {
@@ -178,14 +178,19 @@ HRESULT ProfilingAPIDetach::RequestProfilerDetach(DWORD dwExpectedCompletionMill
     {
         CRITSEC_Holder csh(ProfilingAPIUtility::GetStatusCrst());
 
-        // return immediately if detach is in progress
+        EEToProfInterfaceImpl *pEEToProf = pProfilerInfo->pProfInterface;
 
-        if (s_profilerDetachInfo.m_pEEToProf != NULL)
+        // return immediately if detach is in progress
+        for (SIZE_T pos = 0; pos < s_profilerDetachInfos.Size(); ++pos)
         {
-            return CORPROF_E_PROFILER_DETACHING;
+            ProfilerDetachInfo &current = s_profilerDetachInfos[pos];
+            if (current.m_pProfilerInfo->pProfInterface == pEEToProf)
+            {
+                return CORPROF_E_PROFILER_DETACHING;
+            }
         }
 
-        ProfilerStatus curProfStatus = g_profControlBlock.curProfStatus.Get();
+        ProfilerStatus curProfStatus = pProfilerInfo->curProfStatus.Get();
 
         if ((curProfStatus == kProfStatusInitializingForStartupLoad) ||
             (curProfStatus == kProfStatusInitializingForAttachLoad))
@@ -201,8 +206,6 @@ HRESULT ProfilingAPIDetach::RequestProfilerDetach(DWORD dwExpectedCompletionMill
             return CORPROF_E_PROFILER_DETACHING;
         }
 
-        EEToProfInterfaceImpl * pEEToProf = g_profControlBlock.pProfInterface;
-
         // Since prof status was active after entering the lock, the profiler must not
         // have unloaded out from under us.
         _ASSERTE(pEEToProf != NULL);
@@ -219,13 +222,25 @@ HRESULT ProfilingAPIDetach::RequestProfilerDetach(DWORD dwExpectedCompletionMill
         {
             return hr;
         }
-        s_profilerDetachInfo.m_pEEToProf = pEEToProf;
-        s_profilerDetachInfo.m_ui64DetachStartTime = CLRGetTickCount64();
-        s_profilerDetachInfo.m_dwExpectedCompletionMilliseconds = dwExpectedCompletionMilliseconds;
+
+        EX_TRY
+        {
+            ProfilerDetachInfo detachInfo;
+            detachInfo.m_pProfilerInfo = pProfilerInfo;
+            detachInfo.m_ui64DetachStartTime = CLRGetTickCount64();
+            detachInfo.m_dwExpectedCompletionMilliseconds = dwExpectedCompletionMilliseconds;
+            s_profilerDetachInfos.Push(detachInfo);
+        }
+        EX_CATCH_HRESULT(hr);
+        
+        if (FAILED(hr))
+        {
+            return hr;
+        }
 
         // Ok, time to seal the profiler from receiving or making calls with the CLR.
         // (This will force a FlushStoreBuffers().)
-        g_profControlBlock.curProfStatus.Set(kProfStatusDetaching);
+        pProfilerInfo->curProfStatus.Set(kProfStatusDetaching);
     }
 
     // Sealing done. Wake up the DetachThread so it can loop until the profiler code is
@@ -274,58 +289,58 @@ void ProfilingAPIDetach::ExecuteEvacuationLoop()
     }
     CONTRACTL_END;
 
-    // Wait until there's a profiler to detach (or until this thread should "wake up"
-    // for some other reason, such as exiting due to an unsuccessful startup-load of a
-    // profiler).
-    DWORD dwRet = s_eventDetachWorkAvailable.Wait(INFINITE, FALSE /* alertable */);
-    if (dwRet != WAIT_OBJECT_0)
+    while (true)
     {
-        // The wait ended due to a failure or a reason other than the event getting
-        // signaled (e.g., WAIT_ABANDONED)
-        DWORD dwErr;
-        if (dwRet == WAIT_FAILED)
+        // Wait until there's a profiler to detach (or until this thread should "wake up"
+        // for some other reason, such as exiting due to an unsuccessful startup-load of a
+        // profiler).
+        DWORD dwRet = s_eventDetachWorkAvailable.Wait(INFINITE, FALSE /* alertable */);
+        if (dwRet != WAIT_OBJECT_0)
         {
-            dwErr = GetLastError();
-            LOG((
-                LF_CORPROF,
-                LL_ERROR,
-                "**PROF: DetachThread wait for s_eventDetachWorkAvailable failed with GetLastError = %d.\n",
-                dwErr));
+            // The wait ended due to a failure or a reason other than the event getting
+            // signaled (e.g., WAIT_ABANDONED)
+            DWORD dwErr;
+            if (dwRet == WAIT_FAILED)
+            {
+                dwErr = GetLastError();
+                LOG((
+                    LF_CORPROF,
+                    LL_ERROR,
+                    "**PROF: DetachThread wait for s_eventDetachWorkAvailable failed with GetLastError = %d.\n",
+                    dwErr));
+            }
+            else
+            {
+                dwErr = dwRet;      // No extra error info available beyond the return code
+                LOG((
+                    LF_CORPROF,
+                    LL_ERROR,
+                    "**PROF: DetachThread wait for s_eventDetachWorkAvailable terminated with %d.\n",
+                    dwErr));
+            }
+
+            ProfilingAPIUtility::LogProfError(IDS_PROF_DETACH_THREAD_ERROR, dwErr);
+            return;
         }
-        else
+
         {
-            dwErr = dwRet;      // No extra error info available beyond the return code
-            LOG((
-                LF_CORPROF,
-                LL_ERROR,
-                "**PROF: DetachThread wait for s_eventDetachWorkAvailable terminated with %d.\n",
-                dwErr));
-        }
+            CRITSEC_Holder csh(ProfilingAPIUtility::GetStatusCrst());
 
-        ProfilingAPIUtility::LogProfError(IDS_PROF_DETACH_THREAD_ERROR, dwErr);
-        return;
-    }
+            for (SIZE_T pos = 0; pos < s_profilerDetachInfos.Size(); ++pos)
+            {
+                ProfilerDetachInfo current = s_profilerDetachInfos.Pop();
 
-    // Peek to make sure there's actually a profiler to detach
-    {
-        CRITSEC_Holder csh(ProfilingAPIUtility::GetStatusCrst());
+                do
+                {
+                    // Give profiler a chance to return from its procs
+                    SleepWhileProfilerEvacuates(&current);
+                }
+                while (!ProfilingAPIUtility::IsProfilerEvacuated(current.m_pProfilerInfo));
 
-        if (s_profilerDetachInfo.m_pEEToProf == NULL)
-        {
-            // Nothing to detach.  This can happen if the DetachThread (i.e., current
-            // thread) was created but then the profiler failed to load.
-            return;
+                UnloadProfiler(&current);
+            }
         }
     }
-
-    do
-    {
-        // Give profiler a chance to return from its procs
-        SleepWhileProfilerEvacuates();
-    }
-    while (!ProfilingAPIUtility::IsProfilerEvacuated());
-
-    UnloadProfiler();
 }
 
 //---------------------------------------------------------------------------------------
@@ -335,7 +350,7 @@ void ProfilingAPIDetach::ExecuteEvacuationLoop()
 //
 
 // static
-void ProfilingAPIDetach::SleepWhileProfilerEvacuates()
+void ProfilingAPIDetach::SleepWhileProfilerEvacuates(ProfilerDetachInfo *pDetachInfo)
 {
     CONTRACTL
     {
@@ -398,9 +413,9 @@ void ProfilingAPIDetach::SleepWhileProfilerEvacuates()
     {
         CRITSEC_Holder csh(ProfilingAPIUtility::GetStatusCrst());
 
-        _ASSERTE(s_profilerDetachInfo.m_pEEToProf != NULL);
-        ui64ExpectedCompletionMilliseconds = s_profilerDetachInfo.m_dwExpectedCompletionMilliseconds;
-        ui64DetachStartTime = s_profilerDetachInfo.m_ui64DetachStartTime;
+        _ASSERTE(pDetachInfo->m_pProfilerInfo != NULL);
+        ui64ExpectedCompletionMilliseconds = pDetachInfo->m_dwExpectedCompletionMilliseconds;
+        ui64DetachStartTime = pDetachInfo->m_ui64DetachStartTime;
     }
 
     // ui64SleepMilliseconds is calculated to ensure that CLR checks evacuation status roughly:
@@ -456,7 +471,7 @@ void ProfilingAPIDetach::SleepWhileProfilerEvacuates()
 //
 
 // static
-void ProfilingAPIDetach::UnloadProfiler()
+void ProfilingAPIDetach::UnloadProfiler(ProfilerDetachInfo *pDetachInfo)
 {
     CONTRACTL
     {
@@ -467,27 +482,39 @@ void ProfilingAPIDetach::UnloadProfiler()
     }
     CONTRACTL_END;
 
-    _ASSERTE(g_profControlBlock.curProfStatus.Get() == kProfStatusDetaching);
+    _ASSERTE(pDetachInfo->m_pProfilerInfo->curProfStatus.Get() == kProfStatusDetaching);
 
     {
         CRITSEC_Holder csh(ProfilingAPIUtility::GetStatusCrst());
 
         // Notify profiler it's about to be unloaded
-        _ASSERTE(s_profilerDetachInfo.m_pEEToProf != NULL);
-        s_profilerDetachInfo.m_pEEToProf->ProfilerDetachSucceeded();
-
-        // Reset detach state.
-        s_profilerDetachInfo.Init();
+        _ASSERTE(pDetachInfo->m_pProfilerInfo != NULL);
+        
+        {
+            // This EvacuationCounterHolder is just to make asserts in EEToProfInterfaceImpl happy.
+            // Using it like this without the dirty read/evac counter increment/clean read pattern
+            // is not safe generally, but in this specific case we can skip all that since we are in
+            // a critical section and are the only ones with access to the ProfilerInfo *
+            EvacuationCounterHolder evacuationCounter(pDetachInfo->m_pProfilerInfo);
+            pDetachInfo->m_pProfilerInfo->pProfInterface->ProfilerDetachSucceeded();
+        }
+        
+        EEToProfInterfaceImpl *pProfInterface = pDetachInfo->m_pProfilerInfo->pProfInterface.Load();
+        pDetachInfo->m_pProfilerInfo->pProfInterface.Store(NULL);
+        delete pProfInterface;
 
         // This deletes the EEToProfInterfaceImpl object managing the detaching profiler,
         // releases the profiler's callback interfaces, unloads the profiler DLL, sets
         // the status to kProfStatusNone, and resets g_profControlBlock for use next time
         // a profiler tries to attach.
         //
-        // Note that s_profilerDetachInfo.Init() has already NULL'd out
-        // s_profilerDetachInfo.m_pEEToProf, so we won't have a dangling pointer to the
+        // Note that we've already NULL'd out
+        // pDetachInfo->m_pProfilerInfo->pProfInterface, so we won't have a dangling pointer to the
         // EEToProfInterfaceImpl that's about to be destroyed.
-        ProfilingAPIUtility::TerminateProfiling();
+        ProfilingAPIUtility::TerminateProfiling(pDetachInfo->m_pProfilerInfo);
+
+        // Reset detach state.
+        pDetachInfo->Init();
     }
 
     ProfilingAPIUtility::LogProfInfo(IDS_PROF_DETACH_COMPLETE);
@@ -570,56 +597,69 @@ HRESULT ProfilingAPIDetach::CreateDetachThread()
         NOTHROW;
         GC_NOTRIGGER;
         MODE_ANY;
-        CANNOT_TAKE_LOCK;
+        CAN_TAKE_LOCK;
     }
     CONTRACTL_END;
 
-    // FUTURE: When reattach with neutered profilers is implemented, this
-    // function should check if a DetachThread already exists (use synchronization
-    // to prevent race), and just return if so.
-
-    HandleHolder hDetachThread;
-
-    // The DetachThread is intentionally not an EE Thread-object thread (it won't
-    // execute managed code).
-    hDetachThread = ::CreateThread(
-        NULL,       // lpThreadAttributes; don't want child processes inheriting this handle
-        0,          // dwStackSize (0 = use default)
-        ProfilingAPIDetachThreadStart,
-        NULL,       // lpParameter (none to pass)
-        0,          // dwCreationFlags (0 = use default flags, start thread immediately)
-        NULL        // lpThreadId (don't need therad ID)
-        );
-    if (hDetachThread == NULL)
+    if (s_profilerDetachThreadCreated)
+    {
+        return S_OK;
+    }
+
     {
-        DWORD dwErr = GetLastError();
+        CRITSEC_Holder csh(ProfilingAPIUtility::GetStatusCrst());
+
+        if (!s_profilerDetachThreadCreated)
+        {
+            HandleHolder hDetachThread;
+
+            // The DetachThread is intentionally not an EE Thread-object thread (it won't
+            // execute managed code).
+            hDetachThread = ::CreateThread(
+                NULL,       // lpThreadAttributes; don't want child processes inheriting this handle
+                0,          // dwStackSize (0 = use default)
+                ProfilingAPIDetachThreadStart,
+                NULL,       // lpParameter (none to pass)
+                0,          // dwCreationFlags (0 = use default flags, start thread immediately)
+                NULL        // lpThreadId (don't need therad ID)
+                );
+            if (hDetachThread == NULL)
+            {
+                DWORD dwErr = GetLastError();
 
-        LOG((
-            LF_CORPROF,
-            LL_ERROR,
-            "**PROF: Failed to create DetachThread.  GetLastError=%d.\n",
-            dwErr));
+                LOG((
+                    LF_CORPROF,
+                    LL_ERROR,
+                    "**PROF: Failed to create DetachThread.  GetLastError=%d.\n",
+                    dwErr));
 
-        return HRESULT_FROM_WIN32(dwErr);
+                return HRESULT_FROM_WIN32(dwErr);
+            }
+
+            s_profilerDetachThreadCreated = TRUE;
+        }
     }
 
     return S_OK;
 }
 
-//---------------------------------------------------------------------------------------
-//
-// Accessor for ProfilingAPIDetach::s_profilerDetachInfo.m_pEEToProf, which is the
-// profiler being detached (or NULL if no profiler is being detached).
-//
-// Return Value:
-//      EEToProfInterfaceImpl * for the profiler being detached.
-//
-
 // static
-EEToProfInterfaceImpl * ProfilingAPIDetach::GetEEToProfPtr()
+BOOL ProfilingAPIDetach::IsEEToProfPtrRegisteredForDetach(EEToProfInterfaceImpl *pEEToProf)
 {
     LIMITED_METHOD_CONTRACT;
-    return s_profilerDetachInfo.m_pEEToProf;
+
+    CRITSEC_Holder csh(ProfilingAPIUtility::GetStatusCrst());
+
+    for (SIZE_T pos = 0; pos < s_profilerDetachInfos.Size(); ++pos)
+    {
+        ProfilerDetachInfo &current = s_profilerDetachInfos[pos];
+        if (current.m_pProfilerInfo->pProfInterface == pEEToProf)
+        {
+            return TRUE;
+        }
+    }
+
+    return FALSE;
 }
 
 #endif // FEATURE_PROFAPI_ATTACH_DETACH
diff --git a/src/coreclr/vm/profdetach.h b/src/coreclr/vm/profdetach.h
index 7b85cb61c9d057..5f97e4e59a91ef 100644
--- a/src/coreclr/vm/profdetach.h
+++ b/src/coreclr/vm/profdetach.h
@@ -24,13 +24,8 @@ struct ProfilerDetachInfo
     ProfilerDetachInfo();
     void Init();
 
-    // NULL if we're not trying to detach a profiler.  Otherwise, this is the
-    // EEToProfInterfaceImpl instance we're detaching.
-    //
-    // FUTURE: Although m_pEEToProf, when non-NULL, is always the same as
-    // g_profControlBlock.pProfInterface, that will no longer be the case once we allow
-    // re-attach with neutered profilers.
-    EEToProfInterfaceImpl * m_pEEToProf;
+    // This is the profiler instance we're detaching.
+    ProfilerInfo           *m_pProfilerInfo;
 
     // Time when profiler originally called RequestProfilerDetach()
     ULONGLONG               m_ui64DetachStartTime;
@@ -48,23 +43,25 @@ class ProfilingAPIDetach
 public:
     static HRESULT Initialize();
 
-    static HRESULT RequestProfilerDetach(DWORD dwExpectedCompletionMilliseconds);
+    static HRESULT RequestProfilerDetach(ProfilerInfo *profilerInfo, DWORD dwExpectedCompletionMilliseconds);
 
     static HRESULT CreateDetachThread();
     static DWORD WINAPI ProfilingAPIDetachThreadStart(LPVOID lpParameter);
     static void ExecuteEvacuationLoop();
 
-    static EEToProfInterfaceImpl * GetEEToProfPtr();
+    static BOOL IsEEToProfPtrRegisteredForDetach(EEToProfInterfaceImpl *pEEToProf);
 
 private:
-    static ProfilerDetachInfo s_profilerDetachInfo;
+    static CQuickArrayList<ProfilerDetachInfo> s_profilerDetachInfos;
 
     // Signaled by RequestProfilerDetach() when there is detach work ready to be
     // done by the DetachThread
     static CLREvent           s_eventDetachWorkAvailable;
 
-    static void SleepWhileProfilerEvacuates();
-    static void UnloadProfiler();
+    static Volatile<BOOL>     s_profilerDetachThreadCreated;
+
+    static void SleepWhileProfilerEvacuates(ProfilerDetachInfo *pDetachInfo);
+    static void UnloadProfiler(ProfilerDetachInfo *pDetachInfo);
 
     // Prevent instantiation of ProfilingAPIDetach objects (should be static-only)
     ProfilingAPIDetach();
diff --git a/src/coreclr/vm/profilinghelper.cpp b/src/coreclr/vm/profilinghelper.cpp
index ea1738f871a684..ac2ea1469a4e3e 100644
--- a/src/coreclr/vm/profilinghelper.cpp
+++ b/src/coreclr/vm/profilinghelper.cpp
@@ -52,9 +52,9 @@
 // issue a profiler callback. Readers are scattered throughout the runtime, and have the
 // following format:
 //    {
-//        BEGIN_PIN_PROFILER(CORProfilerTrackAppDomainLoads());
+//        BEGIN_PROFILER_CALLBACK(CORProfilerTrackAppDomainLoads());
 //        g_profControlBlock.pProfInterface->AppDomainCreationStarted(MyAppDomainID);
-//        END_PIN_PROFILER();
+//        END_PROFILER_CALLBACK();
 //    }
 // The BEGIN / END macros do the following:
 // * Evaluate the expression argument (e.g., CORProfilerTrackAppDomainLoads()). This is a
@@ -95,33 +95,6 @@
 // first, which the writer will be sure to see in (c).  For more details about how the
 // evacuation counters work, see code:ProfilingAPIUtility::IsProfilerEvacuated.
 //
-// WHEN ARE BEGIN/END_PIN_PROFILER REQUIRED?
-//
-// In general, any time you access g_profControlBlock.pProfInterface, you must be inside
-// a BEGIN/END_PIN_PROFILER block. This is pretty much always true throughout the EE, but
-// there are some exceptions inside the profiling API code itself, where the BEGIN / END
-// macros are unnecessary:
-//     * If you are inside a public ICorProfilerInfo function's implementation, the
-//         profiler is already pinned. This is because the profiler called the Info
-//         function from either:
-//         * a callback implemented inside of g_profControlBlock.pProfInterface, in which
-//             case the BEGIN/END macros are already in place around the call to that
-//             callback, OR
-//         * a hijacked thread or a thread of the profiler's own creation. In either
-//             case, it's the profiler's responsibility to end hijacking and end its own
-//             threads before requesting a detach. So the profiler DLL is guaranteed not
-//             to disappear while hijacking or profiler-created threads are in action.
-//    * If you're executing while code:ProfilingAPIUtility::s_csStatus is held, then
-//        you're explicitly serialized against all code that might unload the profiler's
-//        DLL and delete g_profControlBlock.pProfInterface. So the profiler is therefore
-//        still guaranteed not to disappear.
-//    * If slow ELT helpers, fast ELT hooks, or profiler-instrumented code is on the
-//        stack, then the profiler cannot be detached yet anyway. Today, we outright
-//        refuse a detach request from a profiler that instrumented code or enabled ELT.
-//        Once rejit / revert is implemented, the evacuation checks will ensure all
-//        instrumented code (including ELT) are reverted and off all stacks before
-//        attempting to unload the profielr.
-
 
 #include "common.h"
 
@@ -148,44 +121,6 @@
 #include "securitywrapper.h"
 #endif // !TARGET_UNIX
 
-//---------------------------------------------------------------------------------------
-// Normally, this would go in profilepriv.inl, but it's not easily inlineable because of
-// the use of BEGIN/END_PIN_PROFILER
-//
-// Return Value:
-//      TRUE iff security transparency checks in full trust assemblies should be disabled
-//      due to the profiler.
-//
-BOOL CORProfilerBypassSecurityChecks()
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        CANNOT_TAKE_LOCK;
-    }
-    CONTRACTL_END;
-
-    {
-        BEGIN_PIN_PROFILER(CORProfilerPresent());
-
-        // V2 profiler binaries, for compatibility purposes, should bypass transparency
-        // checks in full trust assemblies.
-        if (!(&g_profControlBlock)->pProfInterface->IsCallback3Supported())
-            return TRUE;
-
-        // V4 profiler binaries must opt in to bypassing transparency checks in full trust
-        // assemblies.
-        if (((&g_profControlBlock)->dwEventMask & COR_PRF_DISABLE_TRANSPARENCY_CHECKS_UNDER_FULL_TRUST) != 0)
-            return TRUE;
-
-        END_PIN_PROFILER();
-    }
-
-    // All other cases, including no profiler loaded at all: Don't bypass
-    return FALSE;
-}
-
 // ----------------------------------------------------------------------------
 // CurrentProfilerStatus methods
 
@@ -379,6 +314,9 @@ void ProfilingAPIUtility::LogProfEventVA(
 
     AppendSupplementaryInformation(iStringResourceID, &messageToLog);
 
+    // Write to ETW and EventPipe with the message
+    FireEtwProfilerMessage(GetClrInstanceId(), messageToLog.GetUnicode());
+
     // Ouput debug strings for diagnostic messages.
     WszOutputDebugString(messageToLog);
 }
@@ -498,6 +436,9 @@ HRESULT ProfilingAPIUtility::InitializeProfiling()
     }
 
     AttemptLoadProfilerForStartup();
+    AttemptLoadDelayedStartupProfilers();
+    AttemptLoadProfilerList();
+
     // For now, the return value from AttemptLoadProfilerForStartup is of no use to us.
     // Any event has been logged already by AttemptLoadProfilerForStartup, and
     // regardless of whether a profiler got loaded, we still need to continue.
@@ -687,108 +628,85 @@ HRESULT ProfilingAPIUtility::AttemptLoadProfilerForStartup()
     fProfEnabled = CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_CORECLR_ENABLE_PROFILING);
 
     NewArrayHolder<WCHAR> wszClsid(NULL);
-    NewArrayHolder<const WCHAR> cwszProfilerDLL(NULL);
+    NewArrayHolder<WCHAR> wszProfilerDLL(NULL);
     CLSID *pClsid;
     CLSID clsid;
 
-    if (fProfEnabled != 0)
+    if (fProfEnabled == 0)
     {
-        LOG((LF_CORPROF, LL_INFO10, "**PROF: Initializing Profiling Services.\n"));
+        LOG((LF_CORPROF, LL_INFO10, "**PROF: Profiling not enabled.\n"));
+        return S_FALSE;
+    }
 
-        NewArrayHolder<WCHAR> wszProfilerDLL(NULL);
+    LOG((LF_CORPROF, LL_INFO10, "**PROF: Initializing Profiling Services.\n"));
 
-        IfFailRet(CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_CORECLR_PROFILER, &wszClsid));
+    IfFailRet(CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_CORECLR_PROFILER, &wszClsid));
 
-    #if defined(TARGET_ARM64)
-        IfFailRet(CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_CORECLR_PROFILER_PATH_ARM64, &wszProfilerDLL));
-    #elif defined(TARGET_ARM)
-        IfFailRet(CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_CORECLR_PROFILER_PATH_ARM32, &wszProfilerDLL));
-    #endif
+#if defined(TARGET_ARM64)
+    IfFailRet(CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_CORECLR_PROFILER_PATH_ARM64, &wszProfilerDLL));
+#elif defined(TARGET_ARM)
+    IfFailRet(CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_CORECLR_PROFILER_PATH_ARM32, &wszProfilerDLL));
+#endif
+    if(wszProfilerDLL == NULL)
+    {
+#ifdef TARGET_64BIT
+        IfFailRet(CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_CORECLR_PROFILER_PATH_64, &wszProfilerDLL));
+#else
+        IfFailRet(CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_CORECLR_PROFILER_PATH_32, &wszProfilerDLL));
+#endif
         if(wszProfilerDLL == NULL)
         {
-    #ifdef TARGET_64BIT
-            IfFailRet(CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_CORECLR_PROFILER_PATH_64, &wszProfilerDLL));
-    #else
-            IfFailRet(CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_CORECLR_PROFILER_PATH_32, &wszProfilerDLL));
-    #endif
-            if(wszProfilerDLL == NULL)
-            {
-                IfFailRet(CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_CORECLR_PROFILER_PATH, &wszProfilerDLL));
-            }
+            IfFailRet(CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_CORECLR_PROFILER_PATH, &wszProfilerDLL));
         }
+    }
 
-        // If the environment variable doesn't exist, profiling is not enabled.
-        if (wszClsid == NULL)
-        {
-            LOG((LF_CORPROF, LL_INFO10, "**PROF: Profiling flag set, but required "
-                 "environment variable does not exist.\n"));
-
-            LogProfError(IDS_E_PROF_NO_CLSID);
-
-            return S_FALSE;
-        }
+    // If the environment variable doesn't exist, profiling is not enabled.
+    if (wszClsid == NULL)
+    {
+        LOG((LF_CORPROF, LL_INFO10, "**PROF: Profiling flag set, but required "
+             "environment variable does not exist.\n"));
 
-        if ((wszProfilerDLL != NULL) && (wcslen(wszProfilerDLL) >= MAX_LONGPATH))
-        {
-            LOG((LF_CORPROF, LL_INFO10, "**PROF: Profiling flag set, but COR_PROFILER_PATH was not set properly.\n"));
+        LogProfError(IDS_E_PROF_NO_CLSID);
 
-            LogProfError(IDS_E_PROF_BAD_PATH);
+        return S_FALSE;
+    }
 
-            return S_FALSE;
-        }
+    if ((wszProfilerDLL != NULL) && (wcslen(wszProfilerDLL) >= MAX_LONGPATH))
+    {
+        LOG((LF_CORPROF, LL_INFO10, "**PROF: Profiling flag set, but COR_PROFILER_PATH was not set properly.\n"));
 
-    #ifdef TARGET_UNIX
-        // If the environment variable doesn't exist, profiling is not enabled.
-        if (wszProfilerDLL == NULL)
-        {
-            LOG((LF_CORPROF, LL_INFO10, "**PROF: Profiling flag set, but required "
-                 "environment variable does not exist.\n"));
+        LogProfError(IDS_E_PROF_BAD_PATH);
 
-            LogProfError(IDS_E_PROF_BAD_PATH);
+        return S_FALSE;
+    }
 
-            return S_FALSE;
-        }
-    #endif // TARGET_UNIX
+#ifdef TARGET_UNIX
+    // If the environment variable doesn't exist, profiling is not enabled.
+    if (wszProfilerDLL == NULL)
+    {
+        LOG((LF_CORPROF, LL_INFO10, "**PROF: Profiling flag set, but required "
+             "environment variable does not exist.\n"));
 
-        hr = ProfilingAPIUtility::ProfilerCLSIDFromString(wszClsid, &clsid);
-        if (FAILED(hr))
-        {
-            // ProfilerCLSIDFromString already logged an event if there was a failure
-            return hr;
-        }
+        LogProfError(IDS_E_PROF_BAD_PATH);
 
-        pClsid = &clsid;
-        cwszProfilerDLL.Assign(wszProfilerDLL.GetValue());
-        wszProfilerDLL.SuppressRelease();
-    }
-    else if (g_profControlBlock.fIsStoredProfilerRegistered)
-    {
-        LOG((LF_CORPROF, LL_INFO10, "**PROF: Profiler loading from GUID/Path stored from the IPC channel."));
-        pClsid = &(g_profControlBlock.clsStoredProfilerGuid);
-        
-        // Convert to string for logging
-        constexpr size_t guidStringSize = 128;
-        wszClsid.Assign(new (nothrow) WCHAR[guidStringSize]);
-        if (wszClsid != NULL)
-        {
-            StringFromGUID2(*pClsid, wszClsid, guidStringSize);
-        }
-        
-        // Assign, but don't take ownership of, the stored profiler path. This relies on 
-        // g_profControlBlock.sStoredProfilerPath not mutating, which would invalidate the pointer.
-        cwszProfilerDLL.Assign(g_profControlBlock.sStoredProfilerPath.GetUnicode(), FALSE);
+        return S_FALSE;
     }
-    else
+#endif // TARGET_UNIX
+
+    hr = ProfilingAPIUtility::ProfilerCLSIDFromString(wszClsid, &clsid);
+    if (FAILED(hr))
     {
-        LOG((LF_CORPROF, LL_INFO10, "**PROF: Profiling not enabled.\n"));
-        return S_FALSE;
+        // ProfilerCLSIDFromString already logged an event if there was a failure
+        return hr;
     }
 
+    pClsid = &clsid;
+
     hr = LoadProfiler(
         kStartupLoad,
         pClsid,
         wszClsid,
-        cwszProfilerDLL,
+        wszProfilerDLL,
         NULL,               // No client data for startup load
         0);                 // No client data for startup load
     if (FAILED(hr))
@@ -801,6 +719,121 @@ HRESULT ProfilingAPIUtility::AttemptLoadProfilerForStartup()
     return S_OK;
 }
 
+//static
+HRESULT ProfilingAPIUtility::AttemptLoadDelayedStartupProfilers()
+{
+    if (g_profControlBlock.storedProfilers.IsEmpty())
+    {
+        return S_OK;
+    }
+
+    HRESULT storedHr = S_OK;
+    STOREDPROFILERLIST *profilers = &g_profControlBlock.storedProfilers;
+    for (StoredProfilerNode* item = profilers->GetHead(); item != NULL; item = STOREDPROFILERLIST::GetNext(item))
+    {
+        LOG((LF_CORPROF, LL_INFO10, "**PROF: Profiler loading from GUID/Path stored from the IPC channel."));
+        CLSID *pClsid = &(item->guid);
+
+        // Convert to string for logging
+        constexpr size_t guidStringSize = 39;
+        NewArrayHolder<WCHAR> wszClsid(new (nothrow) WCHAR[guidStringSize]);
+        // GUIDs should always be the same number of characters...
+        _ASSERTE(wszClsid != NULL);
+        if (wszClsid != NULL)
+        {
+            StringFromGUID2(*pClsid, wszClsid, guidStringSize);
+        }
+
+        HRESULT hr = LoadProfiler(
+            kStartupLoad,
+            pClsid,
+            wszClsid,
+            item->path.GetUnicode(),
+            NULL,               // No client data for startup load
+            0);                 // No client data for startup load
+        if (FAILED(hr))
+        {
+            // LoadProfiler logs if there is an error
+            storedHr = hr;
+        }
+    }
+
+    return storedHr;
+}
+
+// static
+HRESULT ProfilingAPIUtility::AttemptLoadProfilerList()
+{
+    HRESULT hr = S_OK;
+    DWORD dwEnabled = CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_CORECLR_ENABLE_NOTIFICATION_PROFILERS);
+    if (dwEnabled == 0)
+    {
+        // Profiler list explicitly disabled, bail
+        LogProfInfo(IDS_E_PROF_NOTIFICATION_DISABLED);
+        return S_OK;
+    }
+
+    NewArrayHolder<WCHAR> wszProfilerList(NULL);
+#ifdef TARGET_64BIT
+    CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_CORECLR_NOTIFICATION_PROFILERS_64, &wszProfilerList);
+#else // TARGET_64BIT
+    CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_CORECLR_NOTIFICATION_PROFILERS_32, &wszProfilerList);
+#endif // TARGET_64BIT
+    if (wszProfilerList == NULL)
+    {
+        CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_CORECLR_NOTIFICATION_PROFILERS, &wszProfilerList);
+        if (wszProfilerList == NULL)
+        {
+            // No profiler list specified, bail
+            return S_OK;
+        }
+    }
+
+    WCHAR *pOuter = NULL;
+    WCHAR *pInner = NULL;
+    WCHAR *currentSection = NULL;
+    WCHAR *currentPath = NULL;
+    WCHAR *currentGuid = NULL;
+
+    HRESULT storedHr = S_OK;
+    // Get each semicolon delimited config
+    currentSection = wcstok_s(wszProfilerList, W(";"), &pOuter);
+    while (currentSection != NULL)
+    {
+        // Parse this config "path={guid}"
+        currentPath = wcstok_s(currentSection, W("="), &pInner);
+        currentGuid = wcstok_s(NULL, W("="), &pInner);
+
+        CLSID clsid;
+        hr = ProfilingAPIUtility::ProfilerCLSIDFromString(currentGuid, &clsid);
+        if (FAILED(hr))
+        {
+            // ProfilerCLSIDFromString already logged an event if there was a failure
+            storedHr = hr;
+            goto NextSection;
+        }
+
+        hr = LoadProfiler(
+            kStartupLoad,
+            &clsid,
+            currentGuid,
+            currentPath,
+            NULL,               // No client data for startup load
+            0);                 // No client data for startup load
+        if (FAILED(hr))
+        {
+            // LoadProfiler already logged if there was an error
+            storedHr = hr;
+            goto NextSection;
+        }
+
+NextSection:
+        // Get next config
+        currentSection = wcstok_s(NULL, W(";"), &pOuter);
+    }
+
+    return storedHr;
+}
 
 //---------------------------------------------------------------------------------------
 //
@@ -1060,6 +1093,12 @@ HRESULT ProfilingAPIUtility::LoadProfiler(
     // Client data is currently only specified on attach
     _ASSERTE((pvClientData == NULL) || (loadType == kAttachLoad));
 
+    ProfilerInfo profilerInfo;
+    // RAII type that will deregister if we bail at any point
+    ProfilerInfoHolder profilerInfoHolder(&profilerInfo);
+    profilerInfo.Init();
+    profilerInfo.inUse = TRUE;
+
     HRESULT hr = PerformDeferredInit();
     if (FAILED(hr))
     {
@@ -1073,19 +1112,10 @@ HRESULT ProfilingAPIUtility::LoadProfiler(
     }
 
     {
-        // To prevent race conditions we need to signal that a load is already happening.
-        // The diagnostics server is single threaded, but it can potentially be
-        // racing with the startup path, or theoretically in the future it could be
-        // racing with another attach request if the diagnostic server becomes
-        // multithreaded.
-        CRITSEC_Holder csh(s_csStatus);
-
-        if (g_profControlBlock.curProfStatus.Get() != kProfStatusNone)
-        {
-            return CORPROF_E_PROFILER_ALREADY_ACTIVE;
-        }
-
-        g_profControlBlock.curProfStatus.Set(kProfStatusPreInitialize);
+        // Usually we need to take the lock when modifying profiler status, but at this
+        // point no one else could have a pointer to this ProfilerInfo so we don't
+        // need to synchronize. Once we store it in g_profControlBlock we need to.
+        profilerInfo.curProfStatus.Set(kProfStatusPreInitialize);
     }
 
     NewHolder<EEToProfInterfaceImpl> pEEProf(new (nothrow) EEToProfInterfaceImpl());
@@ -1100,17 +1130,13 @@ HRESULT ProfilingAPIUtility::LoadProfiler(
     hr = DoPreInitialization(pEEProf, pClsid, wszClsid, wszProfilerDLL, loadType, dwConcurrentGCWaitTimeoutInMs);
     if (FAILED(hr))
     {
-        CRITSEC_Holder csh(s_csStatus);
-        g_profControlBlock.curProfStatus.Set(kProfStatusNone);
         return hr;
     }
 
     {
-        // All modification of the profiler's status and
-        // g_profControlBlock.pProfInterface need to be serialized against each other,
-        // in particular, this code should be serialized against detach and unloading
-        // code.
-        CRITSEC_Holder csh(s_csStatus);
+        // Usually we need to take the lock when modifying profiler status, but at this
+        // point no one else could have a pointer to this ProfilerInfo so we don't
+        // need to synchronize. Once we store it in g_profControlBlock we need to.
 
         // We've successfully allocated and initialized the callback wrapper object and the
         // Info interface implementation objects.  The profiler DLL is therefore also
@@ -1122,18 +1148,64 @@ HRESULT ProfilingAPIUtility::LoadProfiler(
         // callback (which we do immediately below), and have it successfully call
         // back into us via the Info interface (ProfToEEInterfaceImpl) to perform its
         // initialization.
-        g_profControlBlock.pProfInterface = pEEProf.GetValue();
+        profilerInfo.pProfInterface = pEEProf.GetValue();
         pEEProf.SuppressRelease();
         pEEProf = NULL;
 
         // Set global status to reflect the proper type of Init we're doing (attach vs
         // startup)
-        g_profControlBlock.curProfStatus.Set(
+        profilerInfo.curProfStatus.Set(
             (loadType == kStartupLoad) ?
                 kProfStatusInitializingForStartupLoad :
                 kProfStatusInitializingForAttachLoad);
     }
 
+    ProfilerInfo *pProfilerInfo = NULL;
+    {
+        // Now we register the profiler, from this point on we need to worry about
+        // synchronization
+        CRITSEC_Holder csh(s_csStatus);
+
+        // Check if this profiler is notification only and load as appropriate
+        BOOL notificationOnly = FALSE;
+        {
+            EvacuationCounterHolder holder(&profilerInfo);
+            HRESULT callHr = profilerInfo.pProfInterface->LoadAsNotficationOnly(&notificationOnly);
+            if (FAILED(callHr))
+            {
+                notificationOnly = FALSE;
+            }
+        }
+
+        if (notificationOnly)
+        {
+            pProfilerInfo = g_profControlBlock.FindNextFreeProfilerInfoSlot();
+            if (pProfilerInfo == NULL)
+            {
+                LogProfError(IDS_E_PROF_NOTIFICATION_LIMIT_EXCEEDED);
+                return CORPROF_E_PROFILER_ALREADY_ACTIVE;
+            }
+            
+            *pProfilerInfo = profilerInfo;
+        }
+        else
+        {
+            // "main" profiler, there can only be one
+            if (g_profControlBlock.mainProfilerInfo.curProfStatus.Get() != kProfStatusNone)
+            {
+                LogProfError(IDS_PROF_ALREADY_LOADED);
+                return CORPROF_E_PROFILER_ALREADY_ACTIVE;
+            }
+
+            // This profiler cannot be a notification only profiler, copy it over to the 
+            // main slot and the ProfilerInfoHolder above will clear out the notification slot
+            g_profControlBlock.mainProfilerInfo = profilerInfo;
+            pProfilerInfo = &(g_profControlBlock.mainProfilerInfo);
+        }
+
+        pProfilerInfo->pProfInterface->SetProfilerInfo(pProfilerInfo);
+    }
+
     // Now that the profiler is officially loaded and in Init status, call into the
     // profiler's appropriate Initialize() callback. Note that if the profiler fails this
     // call, we should abort the rest of the profiler loading, and reset our state so we
@@ -1141,13 +1213,25 @@ HRESULT ProfilingAPIUtility::LoadProfiler(
 
     if (loadType == kStartupLoad)
     {
-        hr = g_profControlBlock.pProfInterface->Initialize();
+        // This EvacuationCounterHolder is just to make asserts in EEToProfInterfaceImpl happy.
+        // Using it like this without the dirty read/evac counter increment/clean read pattern
+        // is not safe generally, but in this specific case we can skip all that since we haven't
+        // published it yet, so we are the only thread that can access it.
+        EvacuationCounterHolder holder(pProfilerInfo);
+        hr = pProfilerInfo->pProfInterface->Initialize();
     }
     else
     {
+        // This EvacuationCounterHolder is just to make asserts in EEToProfInterfaceImpl happy.
+        // Using it like this without the dirty read/evac counter increment/clean read pattern
+        // is not safe generally, but in this specific case we can skip all that since we haven't
+        // published it yet, so we are the only thread that can access it.
+        EvacuationCounterHolder holder(pProfilerInfo);
+
         _ASSERTE(loadType == kAttachLoad);
-        _ASSERTE(g_profControlBlock.pProfInterface->IsCallback3Supported());
-        hr = g_profControlBlock.pProfInterface->InitializeForAttach(pvClientData, cbClientData);
+        _ASSERTE(pProfilerInfo->pProfInterface->IsCallback3Supported());
+
+        hr = pProfilerInfo->pProfInterface->InitializeForAttach(pvClientData, cbClientData);
     }
 
     if (FAILED(hr))
@@ -1162,7 +1246,7 @@ HRESULT ProfilingAPIUtility::LoadProfiler(
         // the reason InitializeForAttach callback failed even though we cannot be sure and we cannot
         // cannot assume hr is going to be CORPROF_E_TIMEOUT_WAITING_FOR_CONCURRENT_GC.
         // The best we can do in this case is to report this failure anyway.
-        if (g_profControlBlock.pProfInterface->HasTimedOutWaitingForConcurrentGC())
+        if (pProfilerInfo->pProfInterface->HasTimedOutWaitingForConcurrentGC())
         {
             ProfilingAPIUtility::LogProfError(IDS_E_PROF_TIMEOUT_WAITING_FOR_CONCURRENT_GC, dwConcurrentGCWaitTimeoutInMs, wszClsid);
         }
@@ -1171,7 +1255,7 @@ HRESULT ProfilingAPIUtility::LoadProfiler(
         if ((loadType == kAttachLoad) &&
             ((hr == CORPROF_E_PROFILER_NOT_ATTACHABLE) || (hr == E_NOTIMPL)))
         {
-            _ASSERTE(g_profControlBlock.pProfInterface->IsCallback3Supported());
+            _ASSERTE(pProfilerInfo->pProfInterface->IsCallback3Supported());
 
             // Profiler supports ICorProfilerCallback3, but explicitly doesn't support
             // Attach loading.  So log specialized event
@@ -1196,14 +1280,14 @@ HRESULT ProfilingAPIUtility::LoadProfiler(
 
         // Profiler failed; reset everything. This will automatically reset
         // g_profControlBlock and will unload the profiler's DLL.
-        TerminateProfiling();
+        TerminateProfiling(pProfilerInfo);
         return hr;
     }
 
 #ifdef FEATURE_MULTICOREJIT
 
     // Disable multicore JIT when profiling is enabled
-    if (g_profControlBlock.dwEventMask & COR_PRF_MONITOR_JIT_COMPILATION)
+    if (pProfilerInfo->eventMask.IsEventMaskSet(COR_PRF_MONITOR_JIT_COMPILATION))
     {
         MulticoreJitManager::DisableMulticoreJit();
     }
@@ -1213,7 +1297,7 @@ HRESULT ProfilingAPIUtility::LoadProfiler(
     // Indicate that profiling is properly initialized.  On an attach-load, this will
     // force a FlushStoreBuffers(), which is important for catch-up synchronization (see
     // code:#ProfCatchUpSynchronization)
-    g_profControlBlock.curProfStatus.Set(kProfStatusActive);
+    pProfilerInfo->curProfStatus.Set(kProfStatusActive);
 
     LOG((
         LF_CORPROF,
@@ -1229,7 +1313,7 @@ HRESULT ProfilingAPIUtility::LoadProfiler(
         // For startup profilers only: If the profiler is interested in tracking GC
         // events, then we must disable concurrent GC since concurrent GC can allocate
         // and kill objects without relocating and thus not doing a heap walk.
-        if (CORProfilerTrackGC())
+        if (pProfilerInfo->eventMask.IsEventMaskSet(COR_PRF_MONITOR_GC))
         {
             LOG((LF_CORPROF, LL_INFO10, "**PROF: Turning off concurrent GC at startup.\n"));
             // Previously we would use SetGCConcurrent(0) to indicate to the GC that it shouldn't even
@@ -1303,11 +1387,17 @@ HRESULT ProfilingAPIUtility::LoadProfiler(
         // code:ProfilerFunctionEnum::Init#ProfilerEnumGeneral
 
         {
-            BEGIN_PIN_PROFILER(CORProfilerPresent());
-            g_profControlBlock.pProfInterface->ProfilerAttachComplete();
-            END_PIN_PROFILER();
+            // This EvacuationCounterHolder is just to make asserts in EEToProfInterfaceImpl happy.
+            // Using it like this without the dirty read/evac counter increment/clean read pattern
+            // is not safe generally, but in this specific case we can skip all that since we haven't
+            // published it yet, so we are the only thread that can access it.
+            EvacuationCounterHolder holder(pProfilerInfo);
+            pProfilerInfo->pProfInterface->ProfilerAttachComplete();
         }
     }
+
+    // Yay, the profiler is started up. Don't deregister it if we get to this point
+    profilerInfoHolder.SuppressRelease();
     return S_OK;
 }
 
@@ -1323,7 +1413,7 @@ HRESULT ProfilingAPIUtility::LoadProfiler(
 //
 
 // static
-BOOL ProfilingAPIUtility::IsProfilerEvacuated()
+BOOL ProfilingAPIUtility::IsProfilerEvacuated(ProfilerInfo *pProfilerInfo)
 {
     CONTRACTL
     {
@@ -1334,64 +1424,36 @@ BOOL ProfilingAPIUtility::IsProfilerEvacuated()
     }
     CONTRACTL_END;
 
-    _ASSERTE(g_profControlBlock.curProfStatus.Get() == kProfStatusDetaching);
-
-    // Check evacuation counters on all the threads (see
+    _ASSERTE(pProfilerInfo->curProfStatus.Get() == kProfStatusDetaching);
+
+    // Note that threads are still in motion as we check its evacuation counter.
+    // This is ok, because we've already changed the profiler status to
+    // kProfStatusDetaching and flushed CPU buffers. So at this point the counter
+    // will typically only go down to 0 (and not increment anymore), with one
+    // small exception (below). So if we get a read of 0 below, the counter will
+    // typically stay there. Specifically:
+    //     * Profiler is most likely not about to increment its evacuation counter
+    //         from 0 to 1 because pThread sees that the status is
+    //         kProfStatusDetaching.
+    //     * Note that there is a small race where pThread might actually
+    //         increment its evac counter from 0 to 1 (if it dirty-read the
+    //         profiler status a tad too early), but that implies that when
+    //         pThread rechecks the profiler status (clean read) then pThread
+    //         will immediately decrement the evac counter back to 0 and avoid
+    //         calling into the EEToProfInterfaceImpl pointer.
+    //
+    // (see
     // code:ProfilingAPIUtility::InitializeProfiling#LoadUnloadCallbackSynchronization
-    // for details). Doing this under the thread store lock not only ensures we can
-    // iterate through the Thread objects safely, but also forces us to serialize with
-    // the GC. The latter is important, as server GC enters the profiler on non-EE
-    // Threads, and so no evacuation counters might be incremented during server GC even
-    // though control could be entering the profiler.
+    // for details)
+    DWORD dwEvacCounter = pProfilerInfo->dwProfilerEvacuationCounter;
+    if (dwEvacCounter != 0)
     {
-        ThreadStoreLockHolder TSLockHolder;
-
-        Thread * pThread = ThreadStore::GetAllThreadList(
-            NULL,   // cursor thread; always NULL to begin with
-            0,      // mask to AND with Thread::m_State to filter returned threads
-            0);     // bits to match the result of the above AND.  (m_State & 0 == 0,
-                    // so we won't filter out any threads)
-
-        // Note that, by not filtering out any of the threads, we're intentionally including
-        // stuff like TS_Dead or TS_Unstarted.  But that keeps us on the safe
-        // side.  If an EE Thread object exists, we want to check its counters to be
-        // absolutely certain it isn't executing in a profiler.
-
-        while (pThread != NULL)
-        {
-            // Note that pThread is still in motion as we check its evacuation counter.
-            // This is ok, because we've already changed the profiler status to
-            // kProfStatusDetaching and flushed CPU buffers. So at this point the counter
-            // will typically only go down to 0 (and not increment anymore), with one
-            // small exception (below). So if we get a read of 0 below, the counter will
-            // typically stay there. Specifically:
-            //     * pThread is most likely not about to increment its evacuation counter
-            //         from 0 to 1 because pThread sees that the status is
-            //         kProfStatusDetaching.
-            //     * Note that there is a small race where pThread might actually
-            //         increment its evac counter from 0 to 1 (if it dirty-read the
-            //         profiler status a tad too early), but that implies that when
-            //         pThread rechecks the profiler status (clean read) then pThread
-            //         will immediately decrement the evac counter back to 0 and avoid
-            //         calling into the EEToProfInterfaceImpl pointer.
-            //
-            // (see
-            // code:ProfilingAPIUtility::InitializeProfiling#LoadUnloadCallbackSynchronization
-            // for details)
-            DWORD dwEvacCounter = pThread->GetProfilerEvacuationCounter();
-            if (dwEvacCounter != 0)
-            {
-                LOG((
-                    LF_CORPROF,
-                    LL_INFO100,
-                    "**PROF: Profiler not yet evacuated because OS Thread ID 0x%x has evac counter of %d (decimal).\n",
-                    pThread->GetOSThreadId(),
-                    dwEvacCounter));
-                return FALSE;
-            }
-
-            pThread = ThreadStore::GetAllThreadList(pThread, 0, 0);
-        }
+        LOG((
+            LF_CORPROF,
+            LL_INFO100,
+            "**PROF: Profiler not yet evacuated because it has evac counter of %d (decimal).\n",
+            dwEvacCounter));
+        return FALSE;
     }
 
     // FUTURE: When rejit feature crew complete, add code to verify all rejitted
@@ -1412,7 +1474,7 @@ BOOL ProfilingAPIUtility::IsProfilerEvacuated()
 //
 
 // static
-void ProfilingAPIUtility::TerminateProfiling()
+void ProfilingAPIUtility::TerminateProfiling(ProfilerInfo *pProfilerInfo)
 {
     CONTRACTL
     {
@@ -1439,7 +1501,7 @@ void ProfilingAPIUtility::TerminateProfiling()
 
 
 #ifdef FEATURE_PROFAPI_ATTACH_DETACH
-        if (ProfilingAPIDetach::GetEEToProfPtr() != NULL)
+        if (pProfilerInfo->curProfStatus.Get() == kProfStatusDetaching && pProfilerInfo->pProfInterface.Load() != NULL)
         {
             // The profiler is still being referenced by
             // ProfilingAPIDetach::s_profilerDetachInfo, so don't try to release and
@@ -1461,9 +1523,9 @@ void ProfilingAPIUtility::TerminateProfiling()
         }
 #endif // FEATURE_PROFAPI_ATTACH_DETACH
 
-        if (g_profControlBlock.curProfStatus.Get() == kProfStatusActive)
+        if (pProfilerInfo->curProfStatus.Get() == kProfStatusActive)
         {
-            g_profControlBlock.curProfStatus.Set(kProfStatusDetaching);
+            pProfilerInfo->curProfStatus.Set(kProfStatusDetaching);
 
             // Profiler was active when TerminateProfiling() was called, so we're unloading
             // it due to shutdown. But other threads may still be trying to enter profiler
@@ -1471,7 +1533,7 @@ void ProfilingAPIUtility::TerminateProfiling()
             // that the status has been changed to kProfStatusDetaching, no new threads will
             // attempt to enter the profiler. But use the detach evacuation counters to see
             // if other threads already began to enter the profiler.
-            if (!ProfilingAPIUtility::IsProfilerEvacuated())
+            if (!ProfilingAPIUtility::IsProfilerEvacuated(pProfilerInfo))
             {
                 // Other threads might be entering the profiler, so just skip cleanup
                 return;
@@ -1482,34 +1544,40 @@ void ProfilingAPIUtility::TerminateProfiling()
         // If we have a profiler callback wrapper and / or info implementation
         // active, then terminate them.
 
-        if (g_profControlBlock.pProfInterface.Load() != NULL)
+        if (pProfilerInfo->pProfInterface.Load() != NULL)
         {
             // This destructor takes care of releasing the profiler's ICorProfilerCallback*
             // interface, and unloading the DLL when we're not in process teardown.
-            delete g_profControlBlock.pProfInterface;
-            g_profControlBlock.pProfInterface.Store(NULL);
+            delete pProfilerInfo->pProfInterface;
+            pProfilerInfo->pProfInterface.Store(NULL);
         }
 
         // NOTE: Intentionally not destroying / NULLing s_csStatus. If
         // s_csStatus is already initialized, we can reuse it each time we do another
         // attach / detach, so no need to destroy it.
 
+        // Attach/Load/Detach are all synchronized with the Status Crst, don't need to worry about races
         // If we disabled concurrent GC and somehow failed later during the initialization
-        if (g_profControlBlock.fConcurrentGCDisabledForAttach)
+        if (g_profControlBlock.fConcurrentGCDisabledForAttach.Load() && g_profControlBlock.IsMainProfiler(pProfilerInfo->pProfInterface))
         {
+            g_profControlBlock.fConcurrentGCDisabledForAttach = FALSE;
+
             // We know for sure GC has been fully initialized as we've turned off concurrent GC before
             _ASSERTE(IsGarbageCollectorFullyInitialized());
             GCHeapUtilities::GetGCHeap()->TemporaryEnableConcurrentGC();
-            g_profControlBlock.fConcurrentGCDisabledForAttach = FALSE;
         }
 
         // #ProfileResetSessionStatus Reset all the status variables that are for the current
         // profiling attach session.
         // When you are adding new status in g_profControlBlock, you need to think about whether
         // your new status is per-session, or consistent across sessions
-        g_profControlBlock.ResetPerSessionStatus();
+        pProfilerInfo->ResetPerSessionStatus();
 
-        g_profControlBlock.curProfStatus.Set(kProfStatusNone);
+        pProfilerInfo->curProfStatus.Set(kProfStatusNone);
+        
+        g_profControlBlock.DeRegisterProfilerInfo(pProfilerInfo);
+        
+        g_profControlBlock.UpdateGlobalEventMask();
     }
 }
 
diff --git a/src/coreclr/vm/profilinghelper.h b/src/coreclr/vm/profilinghelper.h
index 4c8ed1dc5c264c..1cf7ea4ab50005 100644
--- a/src/coreclr/vm/profilinghelper.h
+++ b/src/coreclr/vm/profilinghelper.h
@@ -64,52 +64,13 @@ class ProfilingAPIUtility
         UINT cbClientData,
         DWORD dwConcurrentGCWaitTimeoutInMs);
 
-    static BOOL IsProfilerEvacuated();
-    static void TerminateProfiling();
+    static BOOL IsProfilerEvacuated(ProfilerInfo *pDetachInfo);
+    static void TerminateProfiling(ProfilerInfo *pProfilerInfo);
     static void LogProfError(int iStringResourceID, ...);
     static void LogProfInfo(int iStringResourceID, ...);
     static void LogNoInterfaceError(REFIID iidRequested, LPCWSTR wszClsid);
     INDEBUG(static BOOL ShouldInjectProfAPIFault(ProfAPIFaultFlags faultFlag);)
 
-#ifdef FEATURE_PROFAPI_ATTACH_DETACH
-    // ----------------------------------------------------------------------------
-    // ProfilingAPIUtility::IncEvacuationCounter
-    //
-    // Description:
-    //    Simple helper to increase the evacuation counter inside an EE thread by one
-    //
-    // Arguments:
-    //    * pThread - pointer to an EE Thread
-    //
-    template<typename ThreadType>
-    static FORCEINLINE void IncEvacuationCounter(ThreadType * pThread)
-    {
-        LIMITED_METHOD_CONTRACT;
-
-        if (pThread)
-            pThread->IncProfilerEvacuationCounter();
-    }
-
-    // ----------------------------------------------------------------------------
-    // ProfilingAPIUtility::DecEvacuationCounter
-    //
-    // Description:
-    //    Simple helper to decrease the evacuation counter inside an EE thread by one
-    //
-    // Arguments:
-    //    * pThread - pointer to an EE Thread
-    //
-    template<typename ThreadType>
-    static FORCEINLINE void DecEvacuationCounter(ThreadType * pThread)
-    {
-        LIMITED_METHOD_CONTRACT;
-
-        if (pThread)
-            pThread->DecProfilerEvacuationCounter();
-    }
-
-#endif // FEATURE_PROFAPI_ATTACH_DETACH
-
     // See code:ProfilingAPIUtility::InitializeProfiling#LoadUnloadCallbackSynchronization
     static CRITSEC_COOKIE GetStatusCrst();
 
@@ -147,6 +108,8 @@ class ProfilingAPIUtility
         DWORD dwConcurrentGCWaitTimeoutInMs = INFINITE);
     static HRESULT ProfilerCLSIDFromString(__inout_z LPWSTR wszClsid, CLSID * pClsid);
     static HRESULT AttemptLoadProfilerForStartup();
+    static HRESULT AttemptLoadDelayedStartupProfilers();
+    static HRESULT AttemptLoadProfilerList();
 
     static void AppendSupplementaryInformation(int iStringResource, SString * pString);
 
@@ -173,4 +136,11 @@ class SetCallbackStateFlagsHolder
     DWORD      m_dwOriginalFullState;
 };
 
+FORCEINLINE void DeregisterProfilerIfNotificationOnly(ProfilerInfo *pProfilerInfo) 
+{
+    g_profControlBlock.DeRegisterProfilerInfo(pProfilerInfo);
+}
+
+typedef Wrapper<ProfilerInfo *, DoNothing, DeregisterProfilerIfNotificationOnly> ProfilerInfoHolder;
+
 #endif //__PROFILING_HELPER_H__
diff --git a/src/coreclr/vm/proftoeeinterfaceimpl.cpp b/src/coreclr/vm/proftoeeinterfaceimpl.cpp
index deaafb66d1b634..c1e983304986ed 100644
--- a/src/coreclr/vm/proftoeeinterfaceimpl.cpp
+++ b/src/coreclr/vm/proftoeeinterfaceimpl.cpp
@@ -177,7 +177,7 @@ enum ProfToClrEntrypointFlags
     do                                                                                     \
     {                                                                                      \
         if ((((p2eeFlags) & kP2EEAllowableAfterAttach) == 0) &&                            \
-            (g_profControlBlock.pProfInterface->IsLoadedViaAttach()))                      \
+            (m_pProfilerInfo->pProfInterface->IsLoadedViaAttach()))                      \
         {                                                                                  \
             LOG((LF_CORPROF,                                                               \
                  LL_ERROR,                                                                 \
@@ -214,10 +214,10 @@ enum ProfToClrEntrypointFlags
     do                                                                                      \
     {                                                                                       \
         INCONTRACT(AssertTriggersContract(((p2eeFlags) & kP2EETriggers)));                  \
-        _ASSERTE(g_profControlBlock.curProfStatus.Get() != kProfStatusNone);                \
+        _ASSERTE(m_pProfilerInfo->curProfStatus.Get() != kProfStatusNone);                \
         LOG(logParams);                                                                     \
         /* If profiler was neutered, disallow call */                                       \
-        if (g_profControlBlock.curProfStatus.Get() == kProfStatusDetaching)                 \
+        if (m_pProfilerInfo->curProfStatus.Get() == kProfStatusDetaching)                 \
         {                                                                                   \
             LOG((LF_CORPROF,                                                                \
                  LL_ERROR,                                                                  \
@@ -256,8 +256,8 @@ enum ProfToClrEntrypointFlags
     do                                                                                          \
     {                                                                                           \
         PROFILER_TO_CLR_ENTRYPOINT_ASYNC(logParams);                                            \
-        if (g_profControlBlock.curProfStatus.Get() != kProfStatusInitializingForStartupLoad &&  \
-            g_profControlBlock.curProfStatus.Get() != kProfStatusInitializingForAttachLoad)     \
+        if (m_pProfilerInfo->curProfStatus.Get() != kProfStatusInitializingForStartupLoad &&  \
+            m_pProfilerInfo->curProfStatus.Get() != kProfStatusInitializingForAttachLoad)     \
         {                                                                                       \
             return CORPROF_E_CALL_ONLY_FROM_INIT;                                               \
         }                                                                                       \
@@ -622,13 +622,13 @@ void __stdcall ProfilerObjectAllocatedCallback(OBJECTREF objref, ClassID classId
     // Notify the profiler of the allocation
 
     {
-        BEGIN_PIN_PROFILER(CORProfilerTrackAllocations() || CORProfilerTrackLargeAllocations());
+        BEGIN_PROFILER_CALLBACK(CORProfilerTrackAllocations() || CORProfilerTrackLargeAllocations());
         // Note that for generic code we always return uninstantiated ClassIDs and FunctionIDs.
         // Thus we strip any instantiations of the ClassID (which is really a type handle) here.
-        g_profControlBlock.pProfInterface->ObjectAllocated(
+        g_profControlBlock.ObjectAllocated(
                 (ObjectID) OBJECTREFToObject(objref),
                 classId);
-        END_PIN_PROFILER();
+        END_PROFILER_CALLBACK();
     }
 #endif // PROFILING_SUPPORTED
 }
@@ -661,18 +661,18 @@ void __stdcall GarbageCollectionStartedCallback(int generation, BOOL induced)
 
     // Notify the profiler of start of the collection
     {
-        BEGIN_PIN_PROFILER(CORProfilerTrackGC() || CORProfilerTrackBasicGC());
+        BEGIN_PROFILER_CALLBACK(CORProfilerTrackGC() || CORProfilerTrackBasicGC());
         BOOL generationCollected[COR_PRF_GC_PINNED_OBJECT_HEAP+1];
         if (generation == COR_PRF_GC_GEN_2)
             generation = COR_PRF_GC_PINNED_OBJECT_HEAP;
         for (int gen = 0; gen <= COR_PRF_GC_PINNED_OBJECT_HEAP; gen++)
             generationCollected[gen] = gen <= generation;
 
-        g_profControlBlock.pProfInterface->GarbageCollectionStarted(
+        g_profControlBlock.GarbageCollectionStarted(
             COR_PRF_GC_PINNED_OBJECT_HEAP+1,
             generationCollected,
             induced ? COR_PRF_GC_INDUCED : COR_PRF_GC_OTHER);
-        END_PIN_PROFILER();
+        END_PROFILER_CALLBACK();
     }
 #endif // PROFILING_SUPPORTED
 }
@@ -695,9 +695,9 @@ void __stdcall GarbageCollectionFinishedCallback()
 #ifdef PROFILING_SUPPORTED
     // Notify the profiler of end of the collection
     {
-        BEGIN_PIN_PROFILER(CORProfilerTrackGC() || CORProfilerTrackBasicGC());
-        g_profControlBlock.pProfInterface->GarbageCollectionFinished();
-        END_PIN_PROFILER();
+        BEGIN_PROFILER_CALLBACK(CORProfilerTrackGC() || CORProfilerTrackBasicGC());
+        g_profControlBlock.GarbageCollectionFinished();
+        END_PROFILER_CALLBACK();
     }
 
     // Mark that GC is finished.
@@ -843,9 +843,9 @@ void __stdcall UpdateGenerationBounds()
             RETURN;
         newGenerationTable->count = 0;
         newGenerationTable->capacity = GenerationTable::defaultCapacity;
-        // if there is already a current table, use its count as a guess for the capacity
+        // if there is already a current table, use its capacity as a guess for the capacity
         if (s_currentGenerationTable != NULL)
-            newGenerationTable->capacity = s_currentGenerationTable->count;
+            newGenerationTable->capacity = s_currentGenerationTable->capacity;
         newGenerationTable->prev = NULL;
         newGenerationTable->genDescTable = new (nothrow) GenerationDesc[newGenerationTable->capacity];
         if (newGenerationTable->genDescTable == NULL)
@@ -1131,7 +1131,7 @@ bool HeapWalkHelper(Object * pBO, void * pvContext)
         // It is not safe and could be overflowed to downcast size_t to ULONG on WIN64.
         // However, we have to do this dangerous downcast here to comply with the existing Profiling COM interface.
         // We are currently evaluating ways to fix this potential overflow issue.
-        hr = g_profControlBlock.pProfInterface->ObjectReference(
+        hr = g_profControlBlock.ObjectReference(
             (ObjectID) pBO,
             SafeGetClassIDFromObject(pBO),
             (ULONG) cNumRefs,
@@ -1210,13 +1210,13 @@ bool AllocByClassHelper(Object * pBO, void * pv)
     _ASSERTE(pv != NULL);
 
     {
-        BEGIN_PIN_PROFILER(CORProfilerPresent());
+        BEGIN_PROFILER_CALLBACK(CORProfilerTrackAllocations());
         // Pass along the call
-        g_profControlBlock.pProfInterface->AllocByClass(
+        g_profControlBlock.AllocByClass(
             (ObjectID) pBO,
             SafeGetClassIDFromObject(pBO),
             pv);
-        END_PIN_PROFILER();
+        END_PROFILER_CALLBACK();
     }
 
     return TRUE;
@@ -1286,8 +1286,7 @@ void ScanRootsHelper(Object* pObj, Object ** ppRoot, ScanContext *pSC, uint32_t
     if (pPSC->fProfilerPinned)
     {
         // Let the profiling code know about this root reference
-        g_profControlBlock.pProfInterface->
-            RootReference2((BYTE *)pObj, pPSC->dwEtwRootKind, (EtwGCRootFlags)dwEtwRootFlags, (BYTE *)rootID, &((pPSC)->pHeapId));
+        g_profControlBlock.RootReference2((BYTE *)pObj, pPSC->dwEtwRootKind, (EtwGCRootFlags)dwEtwRootFlags, (BYTE *)rootID, &((pPSC)->pHeapId));
     }
 #endif
 
@@ -1451,7 +1450,7 @@ HRESULT ProfToEEInterfaceImpl::SetEventMask(DWORD dwEventMask)
 
     _ASSERTE(CORProfilerPresentOrInitializing());
 
-    return g_profControlBlock.pProfInterface->SetEventMask(dwEventMask, 0 /* No high bits */);
+    return m_pProfilerInfo->pProfInterface->SetEventMask(dwEventMask, 0 /* No high bits */);
 }
 
 HRESULT ProfToEEInterfaceImpl::SetEventMask2(DWORD dwEventsLow, DWORD dwEventsHigh)
@@ -1483,7 +1482,7 @@ HRESULT ProfToEEInterfaceImpl::SetEventMask2(DWORD dwEventsLow, DWORD dwEventsHi
 
     _ASSERTE(CORProfilerPresentOrInitializing());
 
-    return g_profControlBlock.pProfInterface->SetEventMask(dwEventsLow, dwEventsHigh);
+    return m_pProfilerInfo->pProfInterface->SetEventMask(dwEventsLow, dwEventsHigh);
 }
 
 
@@ -2571,7 +2570,7 @@ HRESULT ProfToEEInterfaceImpl::GetEventMask(DWORD * pdwEvents)
         return E_INVALIDARG;
     }
 
-    *pdwEvents = g_profControlBlock.dwEventMask;
+    *pdwEvents = m_pProfilerInfo->eventMask.GetEventMask();
     return S_OK;
 }
 
@@ -2608,8 +2607,8 @@ HRESULT ProfToEEInterfaceImpl::GetEventMask2(DWORD *pdwEventsLow, DWORD *pdwEven
         return E_INVALIDARG;
     }
 
-    *pdwEventsLow = g_profControlBlock.dwEventMask;
-    *pdwEventsHigh = g_profControlBlock.dwEventMaskHigh;
+    *pdwEventsLow = m_pProfilerInfo->eventMask.GetEventMask();
+    *pdwEventsHigh = m_pProfilerInfo->eventMask.GetEventMaskHigh();
     return S_OK;
 }
 
@@ -4462,6 +4461,11 @@ HRESULT ProfToEEInterfaceImpl::SetILFunctionBody(ModuleID    moduleId,
         return E_INVALIDARG;
     }
 
+    if (!g_profControlBlock.IsMainProfiler(this))
+    {
+        return E_INVALIDARG;
+    }
+
     Module      *pModule;               // Working pointer for real class.
     HRESULT     hr = S_OK;
 
@@ -4478,7 +4482,7 @@ HRESULT ProfToEEInterfaceImpl::SetILFunctionBody(ModuleID    moduleId,
     }
 
     // Remember the profiler is doing this, as that means we must never detach it!
-    g_profControlBlock.pProfInterface->SetUnrevertiblyModifiedILFlag();
+    g_profControlBlock.mainProfilerInfo.pProfInterface->SetUnrevertiblyModifiedILFlag();
 
     // This action is not temporary!
     // If the profiler want to be able to revert, they need to use
@@ -5751,7 +5755,12 @@ HRESULT ProfToEEInterfaceImpl::SetEnterLeaveFunctionHooks(FunctionEnter * pFuncE
                                         pFuncLeave,
                                         pFuncTailcall));
 
-    return g_profControlBlock.pProfInterface->SetEnterLeaveFunctionHooks(pFuncEnter, pFuncLeave, pFuncTailcall);
+    if (!g_profControlBlock.IsMainProfiler(this))
+    {
+        return E_INVALIDARG;
+    }
+
+    return g_profControlBlock.mainProfilerInfo.pProfInterface->SetEnterLeaveFunctionHooks(pFuncEnter, pFuncLeave, pFuncTailcall);
 }
 
 
@@ -5787,8 +5796,13 @@ HRESULT ProfToEEInterfaceImpl::SetEnterLeaveFunctionHooks2(FunctionEnter2 * pFun
                                         pFuncLeave,
                                         pFuncTailcall));
 
+    if (!g_profControlBlock.IsMainProfiler(this))
+    {
+        return E_INVALIDARG;
+    }
+
     return
-        g_profControlBlock.pProfInterface->SetEnterLeaveFunctionHooks2(pFuncEnter, pFuncLeave, pFuncTailcall);
+        g_profControlBlock.mainProfilerInfo.pProfInterface->SetEnterLeaveFunctionHooks2(pFuncEnter, pFuncLeave, pFuncTailcall);
 }
 
 
@@ -5824,8 +5838,13 @@ HRESULT ProfToEEInterfaceImpl::SetEnterLeaveFunctionHooks3(FunctionEnter3 * pFun
                                         pFuncLeave3,
                                         pFuncTailcall3));
 
+    if (!g_profControlBlock.IsMainProfiler(this))
+    {
+        return E_INVALIDARG;
+    }
+
     return
-        g_profControlBlock.pProfInterface->SetEnterLeaveFunctionHooks3(pFuncEnter3,
+        g_profControlBlock.mainProfilerInfo.pProfInterface->SetEnterLeaveFunctionHooks3(pFuncEnter3,
                                                                        pFuncLeave3,
                                                                        pFuncTailcall3);
 }
@@ -5864,8 +5883,13 @@ HRESULT ProfToEEInterfaceImpl::SetEnterLeaveFunctionHooks3WithInfo(FunctionEnter
                                         pFuncLeave3WithInfo,
                                         pFuncTailcall3WithInfo));
 
+    if (!g_profControlBlock.IsMainProfiler(this))
+    {
+        return E_INVALIDARG;
+    }
+
     return
-        g_profControlBlock.pProfInterface->SetEnterLeaveFunctionHooks3WithInfo(pFuncEnter3WithInfo,
+        g_profControlBlock.mainProfilerInfo.pProfInterface->SetEnterLeaveFunctionHooks3WithInfo(pFuncEnter3WithInfo,
                                                                                pFuncLeave3WithInfo,
                                                                                pFuncTailcall3WithInfo);
 }
@@ -5898,7 +5922,12 @@ HRESULT ProfToEEInterfaceImpl::SetFunctionIDMapper(FunctionIDMapper *pFunc)
                                       "**PROF: SetFunctionIDMapper 0x%p.\n",
                                       pFunc));
 
-    g_profControlBlock.pProfInterface->SetFunctionIDMapper(pFunc);
+    if (!g_profControlBlock.IsMainProfiler(this))
+    {
+        return E_INVALIDARG;
+    }
+
+    g_profControlBlock.mainProfilerInfo.pProfInterface->SetFunctionIDMapper(pFunc);
 
     return (S_OK);
 }
@@ -5931,7 +5960,12 @@ HRESULT ProfToEEInterfaceImpl::SetFunctionIDMapper2(FunctionIDMapper2 *pFunc, vo
                                       pFunc,
                                       clientData));
 
-    g_profControlBlock.pProfInterface->SetFunctionIDMapper2(pFunc, clientData);
+    if (!g_profControlBlock.IsMainProfiler(this))
+    {
+        return E_INVALIDARG;
+    }
+
+    g_profControlBlock.mainProfilerInfo.pProfInterface->SetFunctionIDMapper2(pFunc, clientData);
 
     return (S_OK);
 }
@@ -6709,7 +6743,12 @@ HRESULT ProfToEEInterfaceImpl::RequestReJITWithInliners(
          LL_INFO1000,
          "**PROF: RequestReJITWithInliners.\n"));
 
-    if (!g_profControlBlock.pProfInterface->IsCallback4Supported())
+    if (!g_profControlBlock.IsMainProfiler(this))
+    {
+        return E_INVALIDARG;
+    }
+
+    if (!m_pProfilerInfo->pProfInterface->IsCallback4Supported())
     {
         return CORPROF_E_CALLBACK4_REQUIRED;
     }
@@ -6737,7 +6776,7 @@ HRESULT ProfToEEInterfaceImpl::RequestReJITWithInliners(
     }
 
     // Remember the profiler is doing this, as that means we must never detach it!
-    g_profControlBlock.pProfInterface->SetUnrevertiblyModifiedILFlag();
+    g_profControlBlock.mainProfilerInfo.pProfInterface->SetUnrevertiblyModifiedILFlag();
 
     HRESULT hr = SetupThreadForReJIT();
     if (FAILED(hr))
@@ -7067,7 +7106,8 @@ HRESULT ProfToEEInterfaceImpl::EventPipeStartSession(
                                              EP_SERIALIZATION_FORMAT_NETTRACE_V4,
                                              requestRundown,
                                              NULL,
-                                             reinterpret_cast<EventPipeSessionSynchronousCallback>(&ProfToEEInterfaceImpl::EventPipeCallbackHelper));
+                                             reinterpret_cast<EventPipeSessionSynchronousCallback>(&ProfToEEInterfaceImpl::EventPipeCallbackHelper),
+                                             reinterpret_cast<void *>(m_pProfilerInfo));
         if (sessionID != 0)
         {
             EventPipeAdapter::StartStreaming(sessionID);
@@ -7378,28 +7418,33 @@ void ProfToEEInterfaceImpl::EventPipeCallbackHelper(EventPipeProvider *provider,
                                                     LPCGUID pRelatedActivityId,
                                                     Thread *pEventThread,
                                                     ULONG numStackFrames,
-                                                    UINT_PTR stackFrames[])
-{
-    // If we got here we know a profiler has started an EventPipe session
-    BEGIN_PIN_PROFILER(true);
-    // But, a profiler could always register for a session and then detach without
-    // closing the session. So check if we have an interface before proceeding.
-    if (g_profControlBlock.pProfInterface != nullptr)
-    {
-        g_profControlBlock.pProfInterface->EventPipeEventDelivered(provider,
-                                                                   eventId,
-                                                                   eventVersion,
-                                                                   cbMetadataBlob,
-                                                                   metadataBlob,
-                                                                   cbEventData,
-                                                                   eventData,
-                                                                   pActivityId,
-                                                                   pRelatedActivityId,
-                                                                   pEventThread,
-                                                                   numStackFrames,
-                                                                   stackFrames);
-    }
-    END_PIN_PROFILER();
+                                                    UINT_PTR stackFrames[],
+                                                    void *additionalData)
+{
+    _ASSERTE(additionalData != NULL);
+    ProfilerInfo *pProfilerInfo = reinterpret_cast<ProfilerInfo *>(additionalData);
+
+    _ASSERTE(pProfilerInfo->pProfInterface.Load() != NULL);
+    {
+        EvacuationCounterHolder holder(pProfilerInfo);
+        // But, a profiler could always register for a session and then detach without
+        // closing the session. So check if we have an interface before proceeding.
+        if (pProfilerInfo->pProfInterface.Load() != NULL)
+        {
+            pProfilerInfo->pProfInterface->EventPipeEventDelivered(provider,
+                                                                       eventId,
+                                                                       eventVersion,
+                                                                       cbMetadataBlob,
+                                                                       metadataBlob,
+                                                                       cbEventData,
+                                                                       eventData,
+                                                                       pActivityId,
+                                                                       pRelatedActivityId,
+                                                                       pEventThread,
+                                                                       numStackFrames,
+                                                                       stackFrames);
+        }
+    }
 };
 
 
@@ -9116,7 +9161,12 @@ HRESULT ProfToEEInterfaceImpl::RequestReJIT(ULONG       cFunctions,   // in
          LL_INFO1000,
          "**PROF: RequestReJIT.\n"));
 
-    if (!g_profControlBlock.pProfInterface->IsCallback4Supported())
+    if (!g_profControlBlock.IsMainProfiler(this))
+    {
+        return E_INVALIDARG;
+    }
+
+    if (!m_pProfilerInfo->pProfInterface->IsCallback4Supported())
     {
         return CORPROF_E_CALLBACK4_REQUIRED;
     }
@@ -9133,7 +9183,7 @@ HRESULT ProfToEEInterfaceImpl::RequestReJIT(ULONG       cFunctions,   // in
     }
 
     // Remember the profiler is doing this, as that means we must never detach it!
-    g_profControlBlock.pProfInterface->SetUnrevertiblyModifiedILFlag();
+    g_profControlBlock.mainProfilerInfo.pProfInterface->SetUnrevertiblyModifiedILFlag();
 
     HRESULT hr = SetupThreadForReJIT();
     if (FAILED(hr))
@@ -9178,6 +9228,11 @@ HRESULT ProfToEEInterfaceImpl::RequestRevert(ULONG       cFunctions,  // in
          LL_INFO1000,
          "**PROF: RequestRevert.\n"));
 
+    if (!g_profControlBlock.IsMainProfiler(this))
+    {
+        return E_INVALIDARG;
+    }
+
     if (!CORProfilerEnableRejit())
     {
         return CORPROF_E_REJIT_NOT_ENABLED;
@@ -9190,7 +9245,7 @@ HRESULT ProfToEEInterfaceImpl::RequestRevert(ULONG       cFunctions,  // in
     }
 
     // Remember the profiler is doing this, as that means we must never detach it!
-    g_profControlBlock.pProfInterface->SetUnrevertiblyModifiedILFlag();
+    g_profControlBlock.mainProfilerInfo.pProfInterface->SetUnrevertiblyModifiedILFlag();
 
     // Initialize the status array
     if (rgHrStatuses != NULL)
@@ -9497,7 +9552,7 @@ HRESULT ProfToEEInterfaceImpl::RequestProfilerDetach(DWORD dwExpectedCompletionM
         "**PROF: RequestProfilerDetach.\n"));
 
 #ifdef FEATURE_PROFAPI_ATTACH_DETACH
-    return ProfilingAPIDetach::RequestProfilerDetach(dwExpectedCompletionMilliseconds);
+    return ProfilingAPIDetach::RequestProfilerDetach(g_profControlBlock.GetProfilerInfo(this), dwExpectedCompletionMilliseconds);
 #else // FEATURE_PROFAPI_ATTACH_DETACH
     return E_NOTIMPL;
 #endif // FEATURE_PROFAPI_ATTACH_DETACH
@@ -9710,7 +9765,12 @@ HRESULT ProfToEEInterfaceImpl::GetFunctionEnter3Info(FunctionID functionId,
                                     LL_INFO1000,
                                     "**PROF: GetFunctionEnter3Info.\n"));
 
-    _ASSERTE(g_profControlBlock.pProfInterface->GetEnter3WithInfoHook() != NULL);
+    _ASSERTE(g_profControlBlock.mainProfilerInfo.pProfInterface->GetEnter3WithInfoHook() != NULL);
+
+    if (!g_profControlBlock.IsMainProfiler(this))
+    {
+        return E_INVALIDARG;
+    }
 
     if (!CORProfilerELT3SlowPathEnterEnabled())
     {
@@ -9868,7 +9928,12 @@ HRESULT ProfToEEInterfaceImpl::GetFunctionLeave3Info(FunctionID functionId,
                                     LL_INFO1000,
                                     "**PROF: GetFunctionLeave3Info.\n"));
 
-    _ASSERTE(g_profControlBlock.pProfInterface->GetLeave3WithInfoHook() != NULL);
+    if (!g_profControlBlock.IsMainProfiler(this))
+    {
+        return E_INVALIDARG;
+    }
+
+    _ASSERTE(g_profControlBlock.mainProfilerInfo.pProfInterface->GetLeave3WithInfoHook() != NULL);
 
     if (!CORProfilerELT3SlowPathLeaveEnabled())
     {
@@ -10000,7 +10065,12 @@ HRESULT ProfToEEInterfaceImpl::GetFunctionTailcall3Info(FunctionID functionId,
                                     LL_INFO1000,
                                     "**PROF: GetFunctionTailcall3Info.\n"));
 
-    _ASSERTE(g_profControlBlock.pProfInterface->GetTailcall3WithInfoHook() != NULL);
+    _ASSERTE(g_profControlBlock.mainProfilerInfo.pProfInterface->GetTailcall3WithInfoHook() != NULL);
+
+    if (!g_profControlBlock.IsMainProfiler(this))
+    {
+        return E_INVALIDARG;
+    }
 
     if (!CORProfilerELT3SlowPathTailcallEnabled())
     {
@@ -10409,10 +10479,9 @@ void __stdcall ProfilerManagedToUnmanagedTransitionMD(MethodDesc *pMD,
     // Do not notify the profiler about QCalls
     if (pMD == NULL || !pMD->IsQCall())
     {
-        BEGIN_PIN_PROFILER(CORProfilerPresent());
-        g_profControlBlock.pProfInterface->ManagedToUnmanagedTransition(MethodDescToFunctionID(pMD),
-                                                                        reason);
-        END_PIN_PROFILER();
+        BEGIN_PROFILER_CALLBACK(CORProfilerTrackTransitions());
+        g_profControlBlock.ManagedToUnmanagedTransition(MethodDescToFunctionID(pMD), reason);
+        END_PROFILER_CALLBACK();
     }
 }
 
@@ -10444,10 +10513,9 @@ void __stdcall ProfilerUnmanagedToManagedTransitionMD(MethodDesc *pMD,
     // Do not notify the profiler about QCalls
     if (pMD == NULL || !pMD->IsQCall())
     {
-        BEGIN_PIN_PROFILER(CORProfilerPresent());
-        g_profControlBlock.pProfInterface->UnmanagedToManagedTransition(MethodDescToFunctionID(pMD),
-                                                                        reason);
-        END_PIN_PROFILER();
+        BEGIN_PROFILER_CALLBACK(CORProfilerTrackTransitions());
+        g_profControlBlock.UnmanagedToManagedTransition(MethodDescToFunctionID(pMD), reason);
+        END_PROFILER_CALLBACK();
     }
 }
 
@@ -10472,12 +10540,12 @@ HCIMPL2(EXTERN_C void, ProfileEnter, UINT_PTR clientData, void * platformSpecifi
     // code:ProfControlBlock#TestOnlyELT
     if (g_profControlBlock.fTestOnlyForceEnterLeave)
     {
-        if ((g_profControlBlock.pProfInterface.Load() == NULL) ||
+        if ((g_profControlBlock.mainProfilerInfo.pProfInterface.Load() == NULL) ||
             (
-                (g_profControlBlock.pProfInterface->GetEnterHook()          == NULL) &&
-                (g_profControlBlock.pProfInterface->GetEnter2Hook()         == NULL) &&
-                (g_profControlBlock.pProfInterface->GetEnter3Hook()         == NULL) &&
-                (g_profControlBlock.pProfInterface->GetEnter3WithInfoHook() == NULL)
+                (g_profControlBlock.mainProfilerInfo.pProfInterface->GetEnterHook()          == NULL) &&
+                (g_profControlBlock.mainProfilerInfo.pProfInterface->GetEnter2Hook()         == NULL) &&
+                (g_profControlBlock.mainProfilerInfo.pProfInterface->GetEnter3Hook()         == NULL) &&
+                (g_profControlBlock.mainProfilerInfo.pProfInterface->GetEnter3WithInfoHook() == NULL)
             )
            )
         {
@@ -10487,7 +10555,7 @@ HCIMPL2(EXTERN_C void, ProfileEnter, UINT_PTR clientData, void * platformSpecifi
 #endif // PROF_TEST_ONLY_FORCE_ELT
 
     // ELT3 Fast-Path hooks should be NULL when ELT intermediary is used.
-    _ASSERTE(g_profControlBlock.pProfInterface->GetEnter3Hook() == NULL);
+    _ASSERTE(g_profControlBlock.mainProfilerInfo.pProfInterface->GetEnter3Hook() == NULL);
     _ASSERTE(GetThread()->PreemptiveGCDisabled());
     _ASSERTE(platformSpecificHandle != NULL);
 
@@ -10505,21 +10573,21 @@ HCIMPL2(EXTERN_C void, ProfileEnter, UINT_PTR clientData, void * platformSpecifi
     //
     // CLR v4 Slow-Path ELT
     //
-    if (g_profControlBlock.pProfInterface->GetEnter3WithInfoHook() != NULL)
+    if (g_profControlBlock.mainProfilerInfo.pProfInterface->GetEnter3WithInfoHook() != NULL)
     {
         FunctionIDOrClientID functionIDOrClientID;
         functionIDOrClientID.clientID = clientData;
-        g_profControlBlock.pProfInterface->GetEnter3WithInfoHook()(
+        g_profControlBlock.mainProfilerInfo.pProfInterface->GetEnter3WithInfoHook()(
             functionIDOrClientID,
             (COR_PRF_ELT_INFO)&eltInfo);
         goto LExit;
     }
 
-    if (g_profControlBlock.pProfInterface->GetEnter2Hook() != NULL)
+    if (g_profControlBlock.mainProfilerInfo.pProfInterface->GetEnter2Hook() != NULL)
     {
         // We have run out of heap memory, so the content of the mapping table becomes stale.
         // All Whidbey ETL hooks must be turned off.
-        if (!g_profControlBlock.pProfInterface->IsClientIDToFunctionIDMappingEnabled())
+        if (!g_profControlBlock.mainProfilerInfo.pProfInterface->IsClientIDToFunctionIDMappingEnabled())
         {
             goto LExit;
         }
@@ -10531,14 +10599,14 @@ HCIMPL2(EXTERN_C void, ProfileEnter, UINT_PTR clientData, void * platformSpecifi
         // key to retrieve the corresponding clientID from the internal FunctionID hash table.
         FunctionID functionId = clientData;
         _ASSERTE(functionId != NULL);
-        clientData = g_profControlBlock.pProfInterface->LookupClientIDFromCache(functionId);
+        clientData = g_profControlBlock.mainProfilerInfo.pProfInterface->LookupClientIDFromCache(functionId);
 
         //
         // Whidbey Fast-Path ELT
         //
         if (CORProfilerELT2FastPathEnterEnabled())
         {
-            g_profControlBlock.pProfInterface->GetEnter2Hook()(
+            g_profControlBlock.mainProfilerInfo.pProfInterface->GetEnter2Hook()(
                 functionId,
                 clientData,
                 NULL,
@@ -10594,7 +10662,7 @@ HCIMPL2(EXTERN_C void, ProfileEnter, UINT_PTR clientData, void * platformSpecifi
         HRESULT hr = ProfilingGetFunctionEnter3Info(functionId, (COR_PRF_ELT_INFO)&eltInfo, &frameInfo, &ulArgInfoSize, pArgumentInfo);
 
         _ASSERTE(hr == S_OK);
-        g_profControlBlock.pProfInterface->GetEnter2Hook()(functionId, clientData, frameInfo, pArgumentInfo);
+        g_profControlBlock.mainProfilerInfo.pProfInterface->GetEnter2Hook()(functionId, clientData, frameInfo, pArgumentInfo);
 
         goto LExit;
     }
@@ -10606,7 +10674,7 @@ HCIMPL2(EXTERN_C void, ProfileEnter, UINT_PTR clientData, void * platformSpecifi
     // in the first place.  (Note that SetEnterLeaveFunctionHooks* will return
     // an error unless it's called in the profiler's Initialize(), so a profiler can't change
     // its mind about where the hooks are.)
-    _ASSERTE(g_profControlBlock.pProfInterface->GetEnterHook() != NULL);
+    _ASSERTE(g_profControlBlock.mainProfilerInfo.pProfInterface->GetEnterHook() != NULL);
 
     // Note that we cannot assert CORProfilerTrackEnterLeave() (i.e., profiler flag
     // COR_PRF_MONITOR_ENTERLEAVE), because the profiler may decide whether
@@ -10618,7 +10686,7 @@ HCIMPL2(EXTERN_C void, ProfileEnter, UINT_PTR clientData, void * platformSpecifi
     // Everett ELT
     //
     {
-        g_profControlBlock.pProfInterface->GetEnterHook()((FunctionID)clientData);
+        g_profControlBlock.mainProfilerInfo.pProfInterface->GetEnterHook()((FunctionID)clientData);
     }
 
 LExit:
@@ -10644,12 +10712,12 @@ HCIMPL2(EXTERN_C void, ProfileLeave, UINT_PTR clientData, void * platformSpecifi
     // code:ProfControlBlock#TestOnlyELT
     if (g_profControlBlock.fTestOnlyForceEnterLeave)
     {
-        if ((g_profControlBlock.pProfInterface.Load() == NULL) ||
+        if ((g_profControlBlock.mainProfilerInfo.pProfInterface.Load() == NULL) ||
             (
-                (g_profControlBlock.pProfInterface->GetLeaveHook()          == NULL) &&
-                (g_profControlBlock.pProfInterface->GetLeave2Hook()         == NULL) &&
-                (g_profControlBlock.pProfInterface->GetLeave3Hook()         == NULL) &&
-                (g_profControlBlock.pProfInterface->GetLeave3WithInfoHook() == NULL)
+                (g_profControlBlock.mainProfilerInfo.pProfInterface->GetLeaveHook()          == NULL) &&
+                (g_profControlBlock.mainProfilerInfo.pProfInterface->GetLeave2Hook()         == NULL) &&
+                (g_profControlBlock.mainProfilerInfo.pProfInterface->GetLeave3Hook()         == NULL) &&
+                (g_profControlBlock.mainProfilerInfo.pProfInterface->GetLeave3WithInfoHook() == NULL)
             )
            )
         {
@@ -10659,7 +10727,7 @@ HCIMPL2(EXTERN_C void, ProfileLeave, UINT_PTR clientData, void * platformSpecifi
 #endif // PROF_TEST_ONLY_FORCE_ELT
 
     // ELT3 Fast-Path hooks should be NULL when ELT intermediary is used.
-    _ASSERTE(g_profControlBlock.pProfInterface->GetLeave3Hook() == NULL);
+    _ASSERTE(g_profControlBlock.mainProfilerInfo.pProfInterface->GetLeave3Hook() == NULL);
     _ASSERTE(GetThread()->PreemptiveGCDisabled());
     _ASSERTE(platformSpecificHandle != NULL);
 
@@ -10677,21 +10745,21 @@ HCIMPL2(EXTERN_C void, ProfileLeave, UINT_PTR clientData, void * platformSpecifi
     //
     // CLR v4 Slow-Path ELT
     //
-    if (g_profControlBlock.pProfInterface->GetLeave3WithInfoHook() != NULL)
+    if (g_profControlBlock.mainProfilerInfo.pProfInterface->GetLeave3WithInfoHook() != NULL)
     {
         FunctionIDOrClientID functionIDOrClientID;
         functionIDOrClientID.clientID = clientData;
-        g_profControlBlock.pProfInterface->GetLeave3WithInfoHook()(
+        g_profControlBlock.mainProfilerInfo.pProfInterface->GetLeave3WithInfoHook()(
             functionIDOrClientID,
             (COR_PRF_ELT_INFO)&eltInfo);
         goto LExit;
     }
 
-    if (g_profControlBlock.pProfInterface->GetLeave2Hook() != NULL)
+    if (g_profControlBlock.mainProfilerInfo.pProfInterface->GetLeave2Hook() != NULL)
     {
         // We have run out of heap memory, so the content of the mapping table becomes stale.
         // All Whidbey ETL hooks must be turned off.
-        if (!g_profControlBlock.pProfInterface->IsClientIDToFunctionIDMappingEnabled())
+        if (!g_profControlBlock.mainProfilerInfo.pProfInterface->IsClientIDToFunctionIDMappingEnabled())
         {
             goto LExit;
         }
@@ -10703,14 +10771,14 @@ HCIMPL2(EXTERN_C void, ProfileLeave, UINT_PTR clientData, void * platformSpecifi
         // key to retrieve the corresponding clientID from the internal FunctionID hash table.
         FunctionID functionId = clientData;
         _ASSERTE(functionId != NULL);
-        clientData = g_profControlBlock.pProfInterface->LookupClientIDFromCache(functionId);
+        clientData = g_profControlBlock.mainProfilerInfo.pProfInterface->LookupClientIDFromCache(functionId);
 
         //
         // Whidbey Fast-Path ELT
         //
         if (CORProfilerELT2FastPathLeaveEnabled())
         {
-            g_profControlBlock.pProfInterface->GetLeave2Hook()(
+            g_profControlBlock.mainProfilerInfo.pProfInterface->GetLeave2Hook()(
                 functionId,
                 clientData,
                 NULL,
@@ -10727,7 +10795,7 @@ HCIMPL2(EXTERN_C void, ProfileLeave, UINT_PTR clientData, void * platformSpecifi
         HRESULT hr = ProfilingGetFunctionLeave3Info(functionId, (COR_PRF_ELT_INFO)&eltInfo, &frameInfo, &argumentRange);
         _ASSERTE(hr == S_OK);
 
-        g_profControlBlock.pProfInterface->GetLeave2Hook()(functionId, clientData, frameInfo, &argumentRange);
+        g_profControlBlock.mainProfilerInfo.pProfInterface->GetLeave2Hook()(functionId, clientData, frameInfo, &argumentRange);
         goto LExit;
     }
 
@@ -10737,7 +10805,7 @@ HCIMPL2(EXTERN_C void, ProfileLeave, UINT_PTR clientData, void * platformSpecifi
     // in the first place.  (Note that SetEnterLeaveFunctionHooks* will return
     // an error unless it's called in the profiler's Initialize(), so a profiler can't change
     // its mind about where the hooks are.)
-    _ASSERTE(g_profControlBlock.pProfInterface->GetLeaveHook() != NULL);
+    _ASSERTE(g_profControlBlock.mainProfilerInfo.pProfInterface->GetLeaveHook() != NULL);
 
     // Note that we cannot assert CORProfilerTrackEnterLeave() (i.e., profiler flag
     // COR_PRF_MONITOR_ENTERLEAVE), because the profiler may decide whether
@@ -10749,7 +10817,7 @@ HCIMPL2(EXTERN_C void, ProfileLeave, UINT_PTR clientData, void * platformSpecifi
     // Everett ELT
     //
     {
-        g_profControlBlock.pProfInterface->GetLeaveHook()((FunctionID)clientData);
+        g_profControlBlock.mainProfilerInfo.pProfInterface->GetLeaveHook()((FunctionID)clientData);
     }
 
 LExit:
@@ -10776,12 +10844,12 @@ HCIMPL2(EXTERN_C void, ProfileTailcall, UINT_PTR clientData, void * platformSpec
     // code:ProfControlBlock#TestOnlyELT
     if (g_profControlBlock.fTestOnlyForceEnterLeave)
     {
-        if ((g_profControlBlock.pProfInterface.Load() == NULL) ||
+        if ((g_profControlBlock.mainProfilerInfo.pProfInterface.Load() == NULL) ||
             (
-                (g_profControlBlock.pProfInterface->GetTailcallHook()          == NULL) &&
-                (g_profControlBlock.pProfInterface->GetTailcall2Hook()         == NULL) &&
-                (g_profControlBlock.pProfInterface->GetTailcall3Hook()         == NULL) &&
-                (g_profControlBlock.pProfInterface->GetTailcall3WithInfoHook() == NULL)
+                (g_profControlBlock.mainProfilerInfo.pProfInterface->GetTailcallHook()          == NULL) &&
+                (g_profControlBlock.mainProfilerInfo.pProfInterface->GetTailcall2Hook()         == NULL) &&
+                (g_profControlBlock.mainProfilerInfo.pProfInterface->GetTailcall3Hook()         == NULL) &&
+                (g_profControlBlock.mainProfilerInfo.pProfInterface->GetTailcall3WithInfoHook() == NULL)
             )
            )
         {
@@ -10791,7 +10859,7 @@ HCIMPL2(EXTERN_C void, ProfileTailcall, UINT_PTR clientData, void * platformSpec
 #endif // PROF_TEST_ONLY_FORCE_ELT
 
     // ELT3 fast-path hooks should be NULL when ELT intermediary is used.
-    _ASSERTE(g_profControlBlock.pProfInterface->GetTailcall3Hook() == NULL);
+    _ASSERTE(g_profControlBlock.mainProfilerInfo.pProfInterface->GetTailcall3Hook() == NULL);
     _ASSERTE(GetThread()->PreemptiveGCDisabled());
     _ASSERTE(platformSpecificHandle != NULL);
 
@@ -10809,21 +10877,21 @@ HCIMPL2(EXTERN_C void, ProfileTailcall, UINT_PTR clientData, void * platformSpec
     //
     // CLR v4 Slow-Path ELT
     //
-    if (g_profControlBlock.pProfInterface->GetTailcall3WithInfoHook() != NULL)
+    if (g_profControlBlock.mainProfilerInfo.pProfInterface->GetTailcall3WithInfoHook() != NULL)
     {
         FunctionIDOrClientID functionIDOrClientID;
         functionIDOrClientID.clientID = clientData;
-        g_profControlBlock.pProfInterface->GetTailcall3WithInfoHook()(
+        g_profControlBlock.mainProfilerInfo.pProfInterface->GetTailcall3WithInfoHook()(
             functionIDOrClientID,
             (COR_PRF_ELT_INFO)&eltInfo);
         goto LExit;
     }
 
-    if (g_profControlBlock.pProfInterface->GetTailcall2Hook() != NULL)
+    if (g_profControlBlock.mainProfilerInfo.pProfInterface->GetTailcall2Hook() != NULL)
     {
         // We have run out of heap memory, so the content of the mapping table becomes stale.
         // All Whidbey ETL hooks must be turned off.
-        if (!g_profControlBlock.pProfInterface->IsClientIDToFunctionIDMappingEnabled())
+        if (!g_profControlBlock.mainProfilerInfo.pProfInterface->IsClientIDToFunctionIDMappingEnabled())
         {
             goto LExit;
         }
@@ -10835,14 +10903,14 @@ HCIMPL2(EXTERN_C void, ProfileTailcall, UINT_PTR clientData, void * platformSpec
         // key to retrieve the corresponding clientID from the internal FunctionID hash table.
         FunctionID functionId = clientData;
         _ASSERTE(functionId != NULL);
-        clientData = g_profControlBlock.pProfInterface->LookupClientIDFromCache(functionId);
+        clientData = g_profControlBlock.mainProfilerInfo.pProfInterface->LookupClientIDFromCache(functionId);
 
         //
         // Whidbey Fast-Path ELT
         //
         if (CORProfilerELT2FastPathTailcallEnabled())
         {
-            g_profControlBlock.pProfInterface->GetTailcall2Hook()(
+            g_profControlBlock.mainProfilerInfo.pProfInterface->GetTailcall2Hook()(
                 functionId,
                 clientData,
                 NULL);
@@ -10857,7 +10925,7 @@ HCIMPL2(EXTERN_C void, ProfileTailcall, UINT_PTR clientData, void * platformSpec
         HRESULT hr = ProfilingGetFunctionTailcall3Info(functionId, (COR_PRF_ELT_INFO)&eltInfo, &frameInfo);
         _ASSERTE(hr == S_OK);
 
-        g_profControlBlock.pProfInterface->GetTailcall2Hook()(functionId, clientData, frameInfo);
+        g_profControlBlock.mainProfilerInfo.pProfInterface->GetTailcall2Hook()(functionId, clientData, frameInfo);
         goto LExit;
     }
 
@@ -10867,7 +10935,7 @@ HCIMPL2(EXTERN_C void, ProfileTailcall, UINT_PTR clientData, void * platformSpec
     // in the first place.  (Note that SetEnterLeaveFunctionHooks* will return
     // an error unless it's called in the profiler's Initialize(), so a profiler can't change
     // its mind about where the hooks are.)
-    _ASSERTE(g_profControlBlock.pProfInterface->GetTailcallHook() != NULL);
+    _ASSERTE(g_profControlBlock.mainProfilerInfo.pProfInterface->GetTailcallHook() != NULL);
 
     // Note that we cannot assert CORProfilerTrackEnterLeave() (i.e., profiler flag
     // COR_PRF_MONITOR_ENTERLEAVE), because the profiler may decide whether
@@ -10878,7 +10946,7 @@ HCIMPL2(EXTERN_C void, ProfileTailcall, UINT_PTR clientData, void * platformSpec
     //
     // Everett ELT
     //
-    g_profControlBlock.pProfInterface->GetTailcallHook()((FunctionID)clientData);
+    g_profControlBlock.mainProfilerInfo.pProfInterface->GetTailcallHook()((FunctionID)clientData);
 
 LExit:
 
diff --git a/src/coreclr/vm/proftoeeinterfaceimpl.h b/src/coreclr/vm/proftoeeinterfaceimpl.h
index de5b75a3434d66..1cb340713acea7 100644
--- a/src/coreclr/vm/proftoeeinterfaceimpl.h
+++ b/src/coreclr/vm/proftoeeinterfaceimpl.h
@@ -145,6 +145,9 @@ typedef struct _PROFILER_STACK_WALK_DATA PROFILER_STACK_WALK_DATA;
 
 class ProfToEEInterfaceImpl : public ICorProfilerInfo12
 {
+private:
+    ProfilerInfo *m_pProfilerInfo;
+
 public:
 
     // Internal Housekeeping
@@ -156,6 +159,12 @@ class ProfToEEInterfaceImpl : public ICorProfilerInfo12
     virtual ~ProfToEEInterfaceImpl();
     HRESULT Init();
 
+    void SetProfilerInfo(ProfilerInfo *pProfilerInfo)
+    {
+        LIMITED_METHOD_CONTRACT;
+        m_pProfilerInfo = pProfilerInfo;
+    }
+
     // IUnknown
     ULONG STDMETHODCALLTYPE AddRef();
     ULONG STDMETHODCALLTYPE Release();
@@ -694,7 +703,6 @@ class ProfToEEInterfaceImpl : public ICorProfilerInfo12
 protected:
 
     // Internal Helper Functions
-
     static void EventPipeCallbackHelper(EventPipeProvider *provider,
                                         DWORD eventId,
                                         DWORD eventVersion,
@@ -706,7 +714,8 @@ class ProfToEEInterfaceImpl : public ICorProfilerInfo12
                                         LPCGUID pRelatedActivityId,
                                         Thread *pEventThread,
                                         ULONG numStackFrames,
-                                        UINT_PTR stackFrames[]);
+                                        UINT_PTR stackFrames[],
+                                        void *additionalData);
 
     HRESULT GetCodeInfoHelper(FunctionID functionId,
                                ReJITID  reJitId,
diff --git a/src/coreclr/vm/readytoruninfo.cpp b/src/coreclr/vm/readytoruninfo.cpp
index a7a7e0394a1f4e..cf2803dec9375b 100644
--- a/src/coreclr/vm/readytoruninfo.cpp
+++ b/src/coreclr/vm/readytoruninfo.cpp
@@ -946,10 +946,10 @@ PCODE ReadyToRunInfo::GetEntryPoint(MethodDesc * pMD, PrepareCodeConfig* pConfig
 #ifndef CROSSGEN_COMPILE
 #ifdef PROFILING_SUPPORTED
         {
-            BEGIN_PIN_PROFILER(CORProfilerTrackCacheSearches());
-            g_profControlBlock.pProfInterface->
+            BEGIN_PROFILER_CALLBACK(CORProfilerTrackCacheSearches());
+            (&g_profControlBlock)->
                 JITCachedFunctionSearchStarted((FunctionID)pMD, &fShouldSearchCache);
-            END_PIN_PROFILER();
+            END_PROFILER_CALLBACK();
         }
         if (!fShouldSearchCache)
         {
@@ -1001,10 +1001,10 @@ PCODE ReadyToRunInfo::GetEntryPoint(MethodDesc * pMD, PrepareCodeConfig* pConfig
 #ifndef CROSSGEN_COMPILE
 #ifdef PROFILING_SUPPORTED
         {
-            BEGIN_PIN_PROFILER(CORProfilerTrackCacheSearches());
-            g_profControlBlock.pProfInterface->
+            BEGIN_PROFILER_CALLBACK(CORProfilerTrackCacheSearches());
+            (&g_profControlBlock)->
                 JITCachedFunctionSearchFinished((FunctionID)pMD, COR_PRF_CACHED_FUNCTION_FOUND);
-            END_PIN_PROFILER();
+            END_PROFILER_CALLBACK();
         }
 #endif // PROFILING_SUPPORTED
 #endif // CROSSGEN_COMPILE
diff --git a/src/coreclr/vm/readytoruninfo.h b/src/coreclr/vm/readytoruninfo.h
index fcdfc7667a5644..acc909ab5dda33 100644
--- a/src/coreclr/vm/readytoruninfo.h
+++ b/src/coreclr/vm/readytoruninfo.h
@@ -228,7 +228,7 @@ class ReadyToRunInfo
 class DynamicHelpers
 {
 private:
-    static void EmitHelperWithArg(BYTE*& pCode, LoaderAllocator * pAllocator, TADDR arg, PCODE target);
+    static void EmitHelperWithArg(BYTE*& pCode, size_t rxOffset, LoaderAllocator * pAllocator, TADDR arg, PCODE target);
 public:
     static PCODE CreateHelper(LoaderAllocator * pAllocator, TADDR arg, PCODE target);
     static PCODE CreateHelperWithArg(LoaderAllocator * pAllocator, TADDR arg, PCODE target);
diff --git a/src/coreclr/vm/rejit.cpp b/src/coreclr/vm/rejit.cpp
index ff180ceba33ae2..d66c999c7cebde 100644
--- a/src/coreclr/vm/rejit.cpp
+++ b/src/coreclr/vm/rejit.cpp
@@ -1079,12 +1079,12 @@ HRESULT ReJitManager::ConfigureILCodeVersion(ILCodeVersion ilCodeVersion)
             }
             else
             {
-                BEGIN_PIN_PROFILER(CORProfilerPresent());
-                hr = g_profControlBlock.pProfInterface->GetReJITParameters(
+                BEGIN_PROFILER_CALLBACK(CORProfilerPresent());
+                hr = (&g_profControlBlock)->GetReJITParameters(
                     (ModuleID)pModule,
                     methodDef,
                     pFuncControl);
-                END_PIN_PROFILER();
+                END_PROFILER_CALLBACK();
             }
         }
 
diff --git a/src/coreclr/vm/rejit.inl b/src/coreclr/vm/rejit.inl
index b69b63d9f5599d..f59c536af7893b 100644
--- a/src/coreclr/vm/rejit.inl
+++ b/src/coreclr/vm/rejit.inl
@@ -68,17 +68,17 @@ inline void ReJitManager::ReportReJITError(Module* pModule, mdMethodDef methodDe
     CONTRACTL_END;
 
     {
-        BEGIN_PIN_PROFILER(CORProfilerPresent());
+        BEGIN_PROFILER_CALLBACK(CORProfilerEnableRejit());
         _ASSERTE(CORProfilerEnableRejit());
         {
             GCX_PREEMP();
-            g_profControlBlock.pProfInterface->ReJITError(
+            (&g_profControlBlock)->mainProfilerInfo.pProfInterface->ReJITError(
                 reinterpret_cast< ModuleID > (pModule),
                 methodDef,
                 reinterpret_cast< FunctionID > (pMD),
                 hrStatus);
         }
-        END_PIN_PROFILER();
+        END_PROFILER_CALLBACK();
     }
 #endif // PROFILING_SUPPORTED
 }
diff --git a/src/coreclr/vm/runtimehandles.cpp b/src/coreclr/vm/runtimehandles.cpp
index 401be0abd27487..d3c21535cc4a5d 100644
--- a/src/coreclr/vm/runtimehandles.cpp
+++ b/src/coreclr/vm/runtimehandles.cpp
@@ -1033,34 +1033,6 @@ RuntimeTypeHandle::IsVisible(
     return fIsExternallyVisible;
 } // RuntimeTypeHandle::IsVisible
 
-FCIMPL2(FC_BOOL_RET, RuntimeTypeHandle::IsComObject, ReflectClassBaseObject *pTypeUNSAFE, CLR_BOOL isGenericCOM) {
-    CONTRACTL {
-        FCALL_CHECK;
-    }
-    CONTRACTL_END;
-
-    BOOL ret = FALSE;
-
-    REFLECTCLASSBASEREF refType = (REFLECTCLASSBASEREF)ObjectToOBJECTREF(pTypeUNSAFE);
-
-    if (refType == NULL)
-        FCThrowRes(kArgumentNullException, W("Arg_InvalidHandle"));
-
-    TypeHandle typeHandle = refType->GetType();
-
-    HELPER_METHOD_FRAME_BEGIN_RET_1(refType);
-    {
-        if (isGenericCOM)
-            ret = IsComObjectClass(typeHandle);
-        else
-            ret = IsComWrapperClass(typeHandle);
-    }
-    HELPER_METHOD_FRAME_END();
-
-    FC_RETURN_BOOL(ret);
-}
-FCIMPLEND
-
 FCIMPL1(LPCUTF8, RuntimeTypeHandle::GetUtf8Name, ReflectClassBaseObject* pTypeUNSAFE) {
     CONTRACTL {
         FCALL_CHECK;
@@ -2304,9 +2276,9 @@ void QCALLTYPE RuntimeMethodHandle::Destroy(MethodDesc * pMethod)
     // Fire Unload Dynamic Method Event here
     ETW::MethodLog::DynamicMethodDestroyed(pMethod);
 
-    BEGIN_PIN_PROFILER(CORProfilerIsMonitoringDynamicFunctionUnloads());
-    g_profControlBlock.pProfInterface->DynamicMethodUnloaded((FunctionID)pMethod);
-    END_PIN_PROFILER();
+    BEGIN_PROFILER_CALLBACK(CORProfilerTrackDynamicFunctionUnloads());
+    (&g_profControlBlock)->DynamicMethodUnloaded((FunctionID)pMethod);
+    END_PROFILER_CALLBACK();
 
     pDynamicMethodDesc->Destroy();
 
diff --git a/src/coreclr/vm/runtimehandles.h b/src/coreclr/vm/runtimehandles.h
index d40b45458af1f3..33645adc3eca7d 100644
--- a/src/coreclr/vm/runtimehandles.h
+++ b/src/coreclr/vm/runtimehandles.h
@@ -191,7 +191,6 @@ class RuntimeTypeHandle {
     static
     BOOL QCALLTYPE IsVisible(QCall::TypeHandle pTypeHandle);
 
-    static FCDECL2(FC_BOOL_RET, IsComObject, ReflectClassBaseObject *pType, CLR_BOOL isGenericCOM);
     static FCDECL2(FC_BOOL_RET, CanCastTo, ReflectClassBaseObject *pType, ReflectClassBaseObject *pTarget);
     static FCDECL2(FC_BOOL_RET, IsInstanceOfType, ReflectClassBaseObject *pType, Object *object);
 
diff --git a/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/MockHostTypes/HostBuilder.cs b/src/coreclr/vm/s390x/unixstubs.cpp
similarity index 56%
rename from src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/MockHostTypes/HostBuilder.cs
rename to src/coreclr/vm/s390x/unixstubs.cpp
index 92b7f9b290fbb2..d51902a949f26c 100644
--- a/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/MockHostTypes/HostBuilder.cs
+++ b/src/coreclr/vm/s390x/unixstubs.cpp
@@ -1,10 +1,12 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-namespace MockHostTypes
+#include "common.h"
+
+extern "C"
 {
-    public class HostBuilder : IHostBuilder
+    void RedirectForThrowControl()
     {
-        public IHost Build() => new Host();
+        PORTABILITY_ASSERT("Implement for PAL");
     }
-}
+};
diff --git a/src/coreclr/vm/stubcache.cpp b/src/coreclr/vm/stubcache.cpp
index e70c9ac3f9918c..8a415001ef1a59 100644
--- a/src/coreclr/vm/stubcache.cpp
+++ b/src/coreclr/vm/stubcache.cpp
@@ -59,7 +59,8 @@ StubCacheBase::~StubCacheBase()
     while (phe)
     {
         _ASSERTE(NULL != phe->m_pStub);
-        phe->m_pStub->DecRef();
+        ExecutableWriterHolder<Stub> stubWriterHolder(phe->m_pStub, sizeof(Stub));
+        stubWriterHolder.GetRW()->DecRef();
         phe = (STUBHASHENTRY*)GetNext((BYTE*)phe);
     }
 }
@@ -95,8 +96,9 @@ Stub *StubCacheBase::Canonicalize(const BYTE * pRawStub)
             StubHolder<Stub> pstub;
             pstub = phe->m_pStub;
 
+            ExecutableWriterHolder<Stub> stubWriterHolder(pstub, sizeof(Stub));
             // IncRef as we're returning a reference to our caller.
-            pstub->IncRef();
+            stubWriterHolder.GetRW()->IncRef();
 
             pstub.SuppressRelease();
             RETURN pstub;
@@ -149,7 +151,8 @@ Stub *StubCacheBase::Canonicalize(const BYTE * pRawStub)
                 pstub = phe->m_pStub;
             }
             // IncRef so that caller has firm ownership of stub.
-            pstub->IncRef();
+            ExecutableWriterHolder<Stub> stubWriterHolder(pstub, sizeof(Stub));
+            stubWriterHolder.GetRW()->IncRef();
         }
     }
 
diff --git a/src/coreclr/vm/stublink.cpp b/src/coreclr/vm/stublink.cpp
index b7b3cfdf182e07..04a33e39826133 100644
--- a/src/coreclr/vm/stublink.cpp
+++ b/src/coreclr/vm/stublink.cpp
@@ -308,7 +308,8 @@ class StubUnwindInfoSegmentBoundaryReservationList
         {
             ReservationList *pNext = pList->pNext;
 
-            pList->GetStub()->DecRef();
+            ExecutableWriterHolder<Stub> stubWriterHolder(pList->GetStub(), sizeof(Stub));
+            stubWriterHolder.GetRW()->DecRef();
 
             pList = pNext;
         }
@@ -320,7 +321,8 @@ class StubUnwindInfoSegmentBoundaryReservationList
 
         ReservationList *pList = ReservationList::FromStub(pStub);
 
-        pList->pNext = m_pList;
+        ExecutableWriterHolder<ReservationList> listWriterHolder(pList, sizeof(ReservationList));
+        listWriterHolder.GetRW()->pNext = m_pList;
         m_pList = pList;
     }
 };
@@ -844,7 +846,7 @@ Stub *StubLinker::Link(LoaderHeap *pHeap, DWORD flags)
                 );
         ASSERT(pStub != NULL);
 
-        bool fSuccess; fSuccess = EmitStub(pStub, globalsize, pHeap);
+        bool fSuccess = EmitStub(pStub, globalsize, pHeap);
 
 #ifdef STUBLINKER_GENERATES_UNWIND_INFO
         if (fSuccess)
@@ -1010,7 +1012,12 @@ bool StubLinker::EmitStub(Stub* pStub, int globalsize, LoaderHeap* pHeap)
     STANDARD_VM_CONTRACT;
 
     BYTE *pCode = (BYTE*)(pStub->GetBlob());
-    BYTE *pData = pCode+globalsize; // start of data area
+
+    ExecutableWriterHolder<Stub> stubWriterHolder(pStub, sizeof(Stub));
+    Stub *pStubRW = stubWriterHolder.GetRW();
+
+    BYTE *pCodeRW = (BYTE*)(pStubRW->GetBlob());
+    BYTE *pDataRW = pCodeRW+globalsize; // start of data area
     {
         int lastCodeOffset = 0;
 
@@ -1020,7 +1027,7 @@ bool StubLinker::EmitStub(Stub* pStub, int globalsize, LoaderHeap* pHeap)
 
             switch (pCodeElem->m_type) {
                 case CodeElement::kCodeRun:
-                    CopyMemory(pCode + pCodeElem->m_globaloffset,
+                    CopyMemory(pCodeRW + pCodeElem->m_globaloffset,
                                ((CodeRun*)pCodeElem)->m_codebytes,
                                ((CodeRun*)pCodeElem)->m_numcodebytes);
                     currOffset = pCodeElem->m_globaloffset + ((CodeRun *)pCodeElem)->m_numcodebytes;
@@ -1052,8 +1059,9 @@ bool StubLinker::EmitStub(Stub* pStub, int globalsize, LoaderHeap* pHeap)
                         pLabelRef->m_refsize,
                         fixupval,
                         pCode + pCodeElem->m_globaloffset,
+                        pCodeRW + pCodeElem->m_globaloffset,
                         pLabelRef->m_variationCode,
-                        pData + pCodeElem->m_dataoffset);
+                        pDataRW + pCodeElem->m_dataoffset);
 
                     currOffset =
                         pCodeElem->m_globaloffset +
@@ -1070,7 +1078,7 @@ bool StubLinker::EmitStub(Stub* pStub, int globalsize, LoaderHeap* pHeap)
 
         // Fill in zeros at the end, if necessary
         if (lastCodeOffset < globalsize)
-            ZeroMemory(pCode + lastCodeOffset, globalsize - lastCodeOffset);
+            ZeroMemory(pCodeRW + lastCodeOffset, globalsize - lastCodeOffset);
     }
 
     // Fill in patch offset, if we have one
@@ -1081,7 +1089,7 @@ bool StubLinker::EmitStub(Stub* pStub, int globalsize, LoaderHeap* pHeap)
     {
         UINT32 uLabelOffset = GetLabelOffset(m_pPatchLabel);
         _ASSERTE(FitsIn<USHORT>(uLabelOffset));
-        pStub->SetPatchOffset(static_cast<USHORT>(uLabelOffset));
+        pStubRW->SetPatchOffset(static_cast<USHORT>(uLabelOffset));
 
         LOG((LF_CORDB, LL_INFO100, "SL::ES: patch offset:0x%x\n",
             pStub->GetPatchOffset()));
@@ -1090,7 +1098,7 @@ bool StubLinker::EmitStub(Stub* pStub, int globalsize, LoaderHeap* pHeap)
 #ifdef STUBLINKER_GENERATES_UNWIND_INFO
     if (pStub->HasUnwindInfo())
     {
-        if (!EmitUnwindInfo(pStub, globalsize, pHeap))
+        if (!EmitUnwindInfo(pStub, pStubRW, globalsize, pHeap))
             return false;
     }
 #endif // STUBLINKER_GENERATES_UNWIND_INFO
@@ -1266,11 +1274,11 @@ bool FindBlockCallback (PTR_VOID pvArgs, PTR_VOID pvAllocationBase, SIZE_T cbRes
     return false;
 }
 
-bool StubLinker::EmitUnwindInfo(Stub* pStub, int globalsize, LoaderHeap* pHeap)
+bool StubLinker::EmitUnwindInfo(Stub* pStubRX, Stub* pStubRW, int globalsize, LoaderHeap* pHeap)
 {
     STANDARD_VM_CONTRACT;
 
-    BYTE *pCode = (BYTE*)(pStub->GetEntryPoint());
+    BYTE *pCode = (BYTE*)(pStubRX->GetEntryPoint());
 
     //
     // Determine the lower bound of the address space containing the stub.
@@ -1307,7 +1315,7 @@ bool StubLinker::EmitUnwindInfo(Stub* pStub, int globalsize, LoaderHeap* pHeap)
     // make that INT32_MAX.
     //
 
-    StubUnwindInfoHeader *pHeader = pStub->GetUnwindInfoHeader();
+    StubUnwindInfoHeader *pHeader = pStubRW->GetUnwindInfoHeader();
     _ASSERTE(IS_ALIGNED(pHeader, sizeof(void*)));
 
     BYTE *pbBaseAddress = pbRegionBaseAddress;
@@ -1334,16 +1342,16 @@ bool StubLinker::EmitUnwindInfo(Stub* pStub, int globalsize, LoaderHeap* pHeap)
     // Ensure that the first RUNTIME_FUNCTION struct ends up pointer aligned,
     // so that the StubUnwindInfoHeader struct is aligned.  UNWIND_INFO
     // includes one UNWIND_CODE.
-    _ASSERTE(IS_ALIGNED(pStub, sizeof(void*)));
+    _ASSERTE(IS_ALIGNED(pStubRX, sizeof(void*)));
     _ASSERTE(0 == (FIELD_OFFSET(StubUnwindInfoHeader, FunctionEntry) % sizeof(void*)));
 
-    StubUnwindInfoHeader * pUnwindInfoHeader = pStub->GetUnwindInfoHeader();
+    StubUnwindInfoHeader * pUnwindInfoHeader = pStubRW->GetUnwindInfoHeader();
 
 #ifdef TARGET_AMD64
 
     UNWIND_CODE *pDestUnwindCode = &pUnwindInfoHeader->UnwindInfo.UnwindCode[0];
 #ifdef _DEBUG
-    UNWIND_CODE *pDestUnwindCodeLimit = (UNWIND_CODE*)pStub->GetUnwindInfoHeaderSuffix();
+    UNWIND_CODE *pDestUnwindCodeLimit = (UNWIND_CODE*)pStubRW->GetUnwindInfoHeaderSuffix();
 #endif
 
     UINT FrameRegister = 0;
@@ -2055,8 +2063,6 @@ Stub* Stub::NewStub(PTR_VOID pCode, DWORD flags)
     CONTRACTL_END;
 
     Stub* pStub = NewStub(NULL, 0, flags | NEWSTUB_FL_EXTERNAL);
-    _ASSERTE(pStub->HasExternalEntryPoint());
-
     *(PTR_VOID *)(pStub + 1) = pCode;
 
     return pStub;
@@ -2081,6 +2087,11 @@ Stub* Stub::NewStub(PTR_VOID pCode, DWORD flags)
     }
     CONTRACTL_END;
 
+    if (flags & NEWSTUB_FL_EXTERNAL)
+    {
+        _ASSERTE(pHeap == NULL);
+    }
+
 #ifdef STUBLINKER_GENERATES_UNWIND_INFO
     _ASSERTE(!nUnwindInfoSize || !pHeap || pHeap->m_fPermitStubsWithUnwindInfo);
 #endif // STUBLINKER_GENERATES_UNWIND_INFO
@@ -2121,15 +2132,29 @@ Stub* Stub::NewStub(PTR_VOID pCode, DWORD flags)
     }
     else
     {
-        pBlock = (BYTE*)(void*) pHeap->AllocAlignedMem(totalSize, CODE_SIZE_ALIGN);
+        TaggedMemAllocPtr ptr = pHeap->AllocAlignedMem(totalSize, CODE_SIZE_ALIGN);
+        pBlock = (BYTE*)(void*)ptr;
         flags |= NEWSTUB_FL_LOADERHEAP;
     }
 
+    size_t stubPayloadOffset = totalSize -
+        (sizeof(Stub) + ((flags & NEWSTUB_FL_EXTERNAL) ? sizeof(PTR_PCODE) : numCodeBytes));
+
     // Make sure that the payload of the stub is aligned
-    Stub* pStub = (Stub*)((pBlock + totalSize) -
-        (sizeof(Stub) + ((flags & NEWSTUB_FL_EXTERNAL) ? sizeof(PTR_PCODE) : numCodeBytes)));
+    Stub* pStubRX = (Stub*)(pBlock + stubPayloadOffset);
+    Stub* pStubRW;
+    ExecutableWriterHolder<Stub> stubWriterHolder;
 
-    pStub->SetupStub(
+    if (pHeap == NULL)
+    {
+        pStubRW = pStubRX;
+    }
+    else
+    {
+        stubWriterHolder = ExecutableWriterHolder<Stub>(pStubRX, sizeof(Stub));
+        pStubRW = stubWriterHolder.GetRW();
+    }
+    pStubRW->SetupStub(
             numCodeBytes,
             flags
 #ifdef STUBLINKER_GENERATES_UNWIND_INFO
@@ -2137,9 +2162,9 @@ Stub* Stub::NewStub(PTR_VOID pCode, DWORD flags)
 #endif
             );
 
-    _ASSERTE((BYTE *)pStub->GetAllocationBase() == pBlock);
+    _ASSERTE((BYTE *)pStubRX->GetAllocationBase() == pBlock);
 
-    return pStub;
+    return pStubRX;
 }
 
 void Stub::SetupStub(int numCodeBytes, DWORD flags
@@ -2298,7 +2323,8 @@ Stub *ArgBasedStubCache::GetStub(UINT_PTR key)
         }
     }
     if (pStub) {
-        pStub->IncRef();
+        ExecutableWriterHolder<Stub> stubWriterHolder(pStub, sizeof(Stub));
+        stubWriterHolder.GetRW()->IncRef();
     }
     return pStub;
 }
@@ -2350,12 +2376,14 @@ Stub* ArgBasedStubCache::AttemptToSetStub(UINT_PTR key, Stub *pStub)
 
     CrstHolder ch(&m_crst);
 
+    bool incRefForCache = false;
+
     if (key < m_numFixedSlots) {
         if (m_aStub[key]) {
             pStub = m_aStub[key];
         } else {
             m_aStub[key] = pStub;
-            pStub->IncRef();   // IncRef on cache's behalf
+            incRefForCache = true;
         }
     } else {
         SlotEntry *pSlotEntry;
@@ -2371,14 +2399,19 @@ Stub* ArgBasedStubCache::AttemptToSetStub(UINT_PTR key, Stub *pStub)
         if (!pSlotEntry) {
             pSlotEntry = new SlotEntry;
             pSlotEntry->m_pStub = pStub;
-            pStub->IncRef();   // IncRef on cache's behalf
+            incRefForCache = true;
             pSlotEntry->m_key = key;
             pSlotEntry->m_pNext = m_pSlotEntries;
             m_pSlotEntries = pSlotEntry;
         }
     }
     if (pStub) {
-        pStub->IncRef();  // IncRef because we're returning it to caller
+        ExecutableWriterHolder<Stub> stubWriterHolder(pStub, sizeof(Stub));
+        if (incRefForCache)
+        {
+            stubWriterHolder.GetRW()->IncRef();   // IncRef on cache's behalf
+        }
+        stubWriterHolder.GetRW()->IncRef();  // IncRef because we're returning it to caller
     }
     return pStub;
 }
diff --git a/src/coreclr/vm/stublink.h b/src/coreclr/vm/stublink.h
index 9fdede17d2b035..94326f9962ea73 100644
--- a/src/coreclr/vm/stublink.h
+++ b/src/coreclr/vm/stublink.h
@@ -59,7 +59,6 @@
 //-------------------------------------------------------------------------
 class  InstructionFormat;
 class  Stub;
-class  InterceptStub;
 class  CheckDuplicatedStructLayouts;
 class  CodeBasedStubCache;
 struct  CodeLabel;
@@ -400,7 +399,7 @@ class StubLinker
 
         CodeRun *GetLastCodeRunIfAny();
 
-        bool EmitUnwindInfo(Stub* pStub, int globalsize, LoaderHeap* pHeap);
+        bool EmitUnwindInfo(Stub* pStubRX, Stub* pStubRW, int globalsize, LoaderHeap* pHeap);
 
 #if defined(TARGET_AMD64) && defined(STUBLINKER_GENERATES_UNWIND_INFO)
         UNWIND_CODE *AllocUnwindInfo (UCHAR Op, UCHAR nExtraSlots = 0);
@@ -972,7 +971,7 @@ class InstructionFormat
         }
 
         virtual UINT GetSizeOfInstruction(UINT refsize, UINT variationCode) = 0;
-        virtual VOID EmitInstruction(UINT refsize, __int64 fixedUpReference, BYTE *pCodeBuffer, UINT variationCode, BYTE *pDataBuffer) = 0;
+        virtual VOID EmitInstruction(UINT refsize, __int64 fixedUpReference, BYTE *pCodeBufferRX, BYTE *pCodeBufferRW, UINT variationCode, BYTE *pDataBuffer) = 0;
         virtual UINT GetHotSpotOffset(UINT refsize, UINT variationCode)
         {
             WRAPPER_NO_CONTRACT;
diff --git a/src/coreclr/vm/threads.cpp b/src/coreclr/vm/threads.cpp
index f6b9e89da6be73..4dfa4a22b3fa48 100644
--- a/src/coreclr/vm/threads.cpp
+++ b/src/coreclr/vm/threads.cpp
@@ -659,11 +659,6 @@ Thread* SetupThread()
     }
 #endif
 
-#if defined(HOST_OSX) && defined(HOST_ARM64)
-    // Initialize new threads to JIT Write disabled
-    auto jitWriteEnableHolder = PAL_JITWriteEnable(false);
-#endif // defined(HOST_OSX) && defined(HOST_ARM64)
-
     // Normally, HasStarted is called from the thread's entrypoint to introduce it to
     // the runtime.  But sometimes that thread is used for DLL_THREAD_ATTACH notifications
     // that call into managed code.  In that case, a call to SetupThread here must
@@ -767,17 +762,17 @@ Thread* SetupThread()
     // thread has been created.
     if (!IsGCSpecialThread())
     {
-        BEGIN_PIN_PROFILER(CORProfilerTrackThreads());
+        BEGIN_PROFILER_CALLBACK(CORProfilerTrackThreads());
         {
             GCX_PREEMP();
-            g_profControlBlock.pProfInterface->ThreadCreated(
+            (&g_profControlBlock)->ThreadCreated(
                 (ThreadID)pThread);
         }
 
         DWORD osThreadId = ::GetCurrentThreadId();
-        g_profControlBlock.pProfInterface->ThreadAssignedToOSThread(
+        (&g_profControlBlock)->ThreadAssignedToOSThread(
             (ThreadID)pThread, osThreadId);
-        END_PIN_PROFILER();
+        END_PROFILER_CALLBACK();
     }
 #endif // PROFILING_SUPPORTED
 
@@ -1151,11 +1146,11 @@ void InitThreadManager()
         COMPlusThrowWin32();
     }
 
-#if defined(HOST_OSX) && defined(HOST_ARM64)
-    auto jitWriteEnableHolder = PAL_JITWriteEnable(true);
-#endif // defined(HOST_OSX) && defined(HOST_ARM64)
-
-    memcpy(s_barrierCopy, (BYTE*)JIT_PatchedCodeStart, (BYTE*)JIT_PatchedCodeLast - (BYTE*)JIT_PatchedCodeStart);
+    {
+        size_t writeBarrierSize = (BYTE*)JIT_PatchedCodeLast - (BYTE*)JIT_PatchedCodeStart;
+        ExecutableWriterHolder<void> barrierWriterHolder(s_barrierCopy, writeBarrierSize);
+        memcpy(barrierWriterHolder.GetRW(), (BYTE*)JIT_PatchedCodeStart, writeBarrierSize);
+    }
 
     // Store the JIT_WriteBarrier copy location to a global variable so that helpers
     // can jump to it.
@@ -1434,9 +1429,6 @@ Thread::Thread()
     m_debuggerFilterContext = NULL;
     m_fInteropDebuggingHijacked = FALSE;
     m_profilerCallbackState = 0;
-#if defined(PROFILING_SUPPORTED) || defined(PROFILING_SUPPORTED_DATA)
-    m_dwProfilerEvacuationCounter = 0;
-#endif // defined(PROFILING_SUPPORTED) || defined(PROFILING_SUPPORTED_DATA)
 
     m_pProfilerFilterContext = NULL;
 
@@ -1876,20 +1868,20 @@ BOOL Thread::HasStarted()
     // information
     if (!IsGCSpecial())
     {
-        BEGIN_PIN_PROFILER(CORProfilerTrackThreads());
+        BEGIN_PROFILER_CALLBACK(CORProfilerTrackThreads());
         BOOL gcOnTransition = GC_ON_TRANSITIONS(FALSE);     // disable GCStress 2 to avoid the profiler receiving a RuntimeThreadSuspended notification even before the ThreadCreated notification
-
+        
         {
             GCX_PREEMP();
-            g_profControlBlock.pProfInterface->ThreadCreated((ThreadID) this);
+            (&g_profControlBlock)->ThreadCreated((ThreadID) this);
         }
 
         GC_ON_TRANSITIONS(gcOnTransition);
 
         DWORD osThreadId = ::GetCurrentThreadId();
-        g_profControlBlock.pProfInterface->ThreadAssignedToOSThread(
+        (&g_profControlBlock)->ThreadAssignedToOSThread(
             (ThreadID) this, osThreadId);
-        END_PIN_PROFILER();
+        END_PROFILER_CALLBACK();
     }
 #endif // PROFILING_SUPPORTED
 
@@ -3014,10 +3006,10 @@ void Thread::OnThreadTerminate(BOOL holdingLock)
 #ifdef PROFILING_SUPPORTED
         // If a profiler is present, then notify the profiler of thread destroy
         {
-            BEGIN_PIN_PROFILER(CORProfilerTrackThreads());
+            BEGIN_PROFILER_CALLBACK(CORProfilerTrackThreads());
             GCX_PREEMP();
-            g_profControlBlock.pProfInterface->ThreadDestroyed((ThreadID) this);
-            END_PIN_PROFILER();
+            (&g_profControlBlock)->ThreadDestroyed((ThreadID) this);
+            END_PROFILER_CALLBACK();
         }
 #endif // PROFILING_SUPPORTED
 
diff --git a/src/coreclr/vm/threads.h b/src/coreclr/vm/threads.h
index 5fe312d8e86f4c..0aadbf40260cac 100644
--- a/src/coreclr/vm/threads.h
+++ b/src/coreclr/vm/threads.h
@@ -3623,16 +3623,6 @@ class Thread
     //---------------------------------------------------------------
     DWORD m_profilerCallbackState;
 
-#if defined(PROFILING_SUPPORTED) || defined(PROFILING_SUPPORTED_DATA)
-    //---------------------------------------------------------------
-    // m_dwProfilerEvacuationCounter keeps track of how many profiler
-    // callback calls remain on the stack
-    //---------------------------------------------------------------
-    // Why volatile?
-    // See code:ProfilingAPIUtility::InitializeProfiling#LoadUnloadCallbackSynchronization.
-    Volatile<DWORD> m_dwProfilerEvacuationCounter;
-#endif // defined(PROFILING_SUPPORTED) || defined(PROFILING_SUPPORTED_DATA)
-
 private:
     UINT32 m_workerThreadPoolCompletionCount;
     static UINT64 s_workerThreadPoolCompletionCountOverflow;
@@ -3802,30 +3792,6 @@ class Thread
         return m_pProfilerFilterContext;
     }
 
-#ifdef PROFILING_SUPPORTED
-
-    FORCEINLINE DWORD GetProfilerEvacuationCounter(void)
-    {
-        LIMITED_METHOD_CONTRACT;
-        return m_dwProfilerEvacuationCounter;
-    }
-
-    FORCEINLINE void IncProfilerEvacuationCounter(void)
-    {
-        LIMITED_METHOD_CONTRACT;
-        m_dwProfilerEvacuationCounter++;
-        _ASSERTE(m_dwProfilerEvacuationCounter != 0U);
-    }
-
-    FORCEINLINE void DecProfilerEvacuationCounter(void)
-    {
-        LIMITED_METHOD_CONTRACT;
-        _ASSERTE(m_dwProfilerEvacuationCounter != 0U);
-        m_dwProfilerEvacuationCounter--;
-    }
-
-#endif // PROFILING_SUPPORTED
-
     //-------------------------------------------------------------------------
     // The hijack lock enforces that a thread on which a profiler is currently
     // performing a stack walk cannot be hijacked.
diff --git a/src/coreclr/vm/threadsuspend.cpp b/src/coreclr/vm/threadsuspend.cpp
index 68e4caf6e69e9e..cf09d505b1c469 100644
--- a/src/coreclr/vm/threadsuspend.cpp
+++ b/src/coreclr/vm/threadsuspend.cpp
@@ -401,12 +401,12 @@ Thread::SuspendThreadResult Thread::SuspendThread(BOOL fOneTryOnly, DWORD *pdwSu
 
 #ifdef PROFILING_SUPPORTED
     {
-        BEGIN_PIN_PROFILER(CORProfilerTrackSuspends());
+        BEGIN_PROFILER_CALLBACK(CORProfilerTrackSuspends());
         if (str == STR_Success)
         {
-            g_profControlBlock.pProfInterface->RuntimeThreadSuspended((ThreadID)this);
+            (&g_profControlBlock)->RuntimeThreadSuspended((ThreadID)this);
         }
-        END_PIN_PROFILER();
+        END_PROFILER_CALLBACK();
     }
 #endif // PROFILING_SUPPORTED
 
@@ -456,12 +456,12 @@ DWORD Thread::ResumeThread()
     }
 #ifdef PROFILING_SUPPORTED
     {
-        BEGIN_PIN_PROFILER(CORProfilerTrackSuspends());
+        BEGIN_PROFILER_CALLBACK(CORProfilerTrackSuspends());
         if ((res != 0) && (res != (DWORD)-1))
         {
-            g_profControlBlock.pProfInterface->RuntimeThreadResumed((ThreadID)this);
+            (&g_profControlBlock)->RuntimeThreadResumed((ThreadID)this);
         }
-        END_PIN_PROFILER();
+        END_PROFILER_CALLBACK();
     }
 #endif
     return res;
@@ -2142,12 +2142,12 @@ void Thread::RareDisablePreemptiveGC()
                 // If profiler desires GC events, notify it that this thread is waiting until the GC is over
                 // Do not send suspend notifications for debugger suspensions
                 {
-                    BEGIN_PIN_PROFILER(CORProfilerTrackSuspends());
+                    BEGIN_PROFILER_CALLBACK(CORProfilerTrackSuspends());
                     if (!(m_State & TS_DebugSuspendPending))
                     {
-                        g_profControlBlock.pProfInterface->RuntimeThreadSuspended((ThreadID)this);
+                        (&g_profControlBlock)->RuntimeThreadSuspended((ThreadID)this);
                     }
-                    END_PIN_PROFILER();
+                    END_PROFILER_CALLBACK();
                 }
 #endif // PROFILING_SUPPORTED
 
@@ -2168,9 +2168,9 @@ void Thread::RareDisablePreemptiveGC()
 #ifdef PROFILING_SUPPORTED
                 // Let the profiler know that this thread is resuming
                 {
-                    BEGIN_PIN_PROFILER(CORProfilerTrackSuspends());
-                    g_profControlBlock.pProfInterface->RuntimeThreadResumed((ThreadID)this);
-                    END_PIN_PROFILER();
+                    BEGIN_PROFILER_CALLBACK(CORProfilerTrackSuspends());
+                    (&g_profControlBlock)->RuntimeThreadResumed((ThreadID)this);
+                    END_PROFILER_CALLBACK();
                 }
 #endif // PROFILING_SUPPORTED
             }
@@ -3226,12 +3226,12 @@ void ThreadSuspend::SuspendRuntime(ThreadSuspend::SUSPEND_REASON reason)
     // If the profiler desires information about GCs, then let it know that one
     // is starting.
     {
-        BEGIN_PIN_PROFILER(CORProfilerTrackSuspends());
+        BEGIN_PROFILER_CALLBACK(CORProfilerTrackSuspends());
         _ASSERTE(reason != ThreadSuspend::SUSPEND_FOR_DEBUGGER);
         _ASSERTE(reason != ThreadSuspend::SUSPEND_FOR_DEBUGGER_SWEEP);
 
         {
-            g_profControlBlock.pProfInterface->RuntimeSuspendStarted(
+            (&g_profControlBlock)->RuntimeSuspendStarted(
                 GCSuspendReasonToProfSuspendReason(reason));
         }
         if (pCurThread)
@@ -3239,9 +3239,9 @@ void ThreadSuspend::SuspendRuntime(ThreadSuspend::SUSPEND_REASON reason)
             // Notify the profiler that the thread that is actually doing the GC is 'suspended',
             // meaning that it is doing stuff other than run the managed code it was before the
             // GC started.
-            g_profControlBlock.pProfInterface->RuntimeThreadSuspended((ThreadID)pCurThread);
+            (&g_profControlBlock)->RuntimeThreadSuspended((ThreadID)pCurThread);
         }
-        END_PIN_PROFILER();
+        END_PROFILER_CALLBACK();
     }
 #endif // PROFILING_SUPPORTED
 
@@ -3588,9 +3588,9 @@ void ThreadSuspend::SuspendRuntime(ThreadSuspend::SUSPEND_REASON reason)
 #ifdef PROFILING_SUPPORTED
     // If a profiler is keeping track of GC events, notify it
     {
-    BEGIN_PIN_PROFILER(CORProfilerTrackSuspends());
-    g_profControlBlock.pProfInterface->RuntimeSuspendFinished();
-    END_PIN_PROFILER();
+    BEGIN_PROFILER_CALLBACK(CORProfilerTrackSuspends());
+    (&g_profControlBlock)->RuntimeSuspendFinished();
+    END_PROFILER_CALLBACK();
     }
 #endif // PROFILING_SUPPORTED
 
@@ -3645,28 +3645,26 @@ void Thread::CommitGCStressInstructionUpdate()
         assert(pbDestCode != NULL);
         assert(pbSrcCode != NULL);
 
-#if defined(HOST_OSX) && defined(HOST_ARM64)
-        auto jitWriteEnableHolder = PAL_JITWriteEnable(true);
-#endif // defined(HOST_OSX) && defined(HOST_ARM64)
+        ExecutableWriterHolder<BYTE> destCodeWriterHolder(pbDestCode, sizeof(DWORD));
 
 #if defined(TARGET_X86) || defined(TARGET_AMD64)
 
-        *pbDestCode = *pbSrcCode;
+        *destCodeWriterHolder.GetRW() = *pbSrcCode;
 
 #elif defined(TARGET_ARM)
 
         if (GetARMInstructionLength(pbDestCode) == 2)
-            *(WORD*)pbDestCode  = *(WORD*)pbSrcCode;
+            *(WORD*)destCodeWriterHolder.GetRW()  = *(WORD*)pbSrcCode;
         else
-            *(DWORD*)pbDestCode = *(DWORD*)pbSrcCode;
+            *(DWORD*)destCodeWriterHolder.GetRW() = *(DWORD*)pbSrcCode;
 
 #elif defined(TARGET_ARM64)
 
-        *(DWORD*)pbDestCode = *(DWORD*)pbSrcCode;
+        *(DWORD*)destCodeWriterHolder.GetRW() = *(DWORD*)pbSrcCode;
 
 #else
 
-        *pbDestCode = *pbSrcCode;
+        *destCodeWriterHolder.GetRW() = *pbSrcCode;
 
 #endif
 
@@ -3713,12 +3711,12 @@ void ThreadSuspend::ResumeRuntime(BOOL bFinishedGC, BOOL SuspendSucceded)
 #ifdef PROFILING_SUPPORTED
     // Need to give resume event for the GC thread
     {
-        BEGIN_PIN_PROFILER(CORProfilerTrackSuspends());
+        BEGIN_PROFILER_CALLBACK(CORProfilerTrackSuspends());
         if (pCurThread)
         {
-            g_profControlBlock.pProfInterface->RuntimeThreadResumed((ThreadID)pCurThread);
+            (&g_profControlBlock)->RuntimeThreadResumed((ThreadID)pCurThread);
         }
-        END_PIN_PROFILER();
+        END_PROFILER_CALLBACK();
     }
 #endif // PROFILING_SUPPORTED
 
@@ -3741,10 +3739,10 @@ void ThreadSuspend::ResumeRuntime(BOOL bFinishedGC, BOOL SuspendSucceded)
     // This thread is logically "resuming" from a GC now.  Tell the profiler.
     //
     {
-        BEGIN_PIN_PROFILER(CORProfilerTrackSuspends());
+        BEGIN_PROFILER_CALLBACK(CORProfilerTrackSuspends());
         GCX_PREEMP();
-        g_profControlBlock.pProfInterface->RuntimeResumeFinished();
-        END_PIN_PROFILER();
+        (&g_profControlBlock)->RuntimeResumeFinished();
+        END_PROFILER_CALLBACK();
     }
 #endif // PROFILING_SUPPORTED
 
@@ -5483,9 +5481,9 @@ void ThreadSuspend::RestartEE(BOOL bFinishedGC, BOOL SuspendSucceded)
     // corresponding call to RuntimeSuspendStarted is done at a lower architectural layer,
     // in ThreadSuspend::SuspendRuntime.
     {
-        BEGIN_PIN_PROFILER(CORProfilerTrackSuspends());
-        g_profControlBlock.pProfInterface->RuntimeResumeStarted();
-        END_PIN_PROFILER();
+        BEGIN_PROFILER_CALLBACK(CORProfilerTrackSuspends());
+        (&g_profControlBlock)->RuntimeResumeStarted();
+        END_PROFILER_CALLBACK();
     }
 #endif // PROFILING_SUPPORTED
 
diff --git a/src/coreclr/vm/virtualcallstub.cpp b/src/coreclr/vm/virtualcallstub.cpp
index 878e67285685d6..95d568d641c732 100644
--- a/src/coreclr/vm/virtualcallstub.cpp
+++ b/src/coreclr/vm/virtualcallstub.cpp
@@ -1209,8 +1209,9 @@ VTableCallHolder* VirtualCallStubManager::GenerateVTableCallStub(DWORD slot)
 
     //allocate from the requisite heap and copy the template over it.
     VTableCallHolder * pHolder = (VTableCallHolder*)(void*)vtable_heap->AllocAlignedMem(VTableCallHolder::GetHolderSize(slot), CODE_SIZE_ALIGN);
+    ExecutableWriterHolder<VTableCallHolder> vtableWriterHolder(pHolder, sizeof(VTableCallHolder));
+    vtableWriterHolder.GetRW()->Initialize(slot);
 
-    pHolder->Initialize(slot);
     ClrFlushInstructionCache(pHolder->stub(), pHolder->stub()->size());
 
     AddToCollectibleVSDRangeList(pHolder);
@@ -1724,10 +1725,6 @@ PCODE VirtualCallStubManager::ResolveWorker(StubCallSite* pCallSite,
         PRECONDITION(IsProtectedByGCFrame(protectedObj));
     } CONTRACTL_END;
 
-#if defined(HOST_OSX) && defined(HOST_ARM64)
-    auto jitWriteEnableHolder = PAL_JITWriteEnable(true);
-#endif // defined(HOST_OSX) && defined(HOST_ARM64)
-
     MethodTable* objectType = (*protectedObj)->GetMethodTable();
     CONSISTENCY_CHECK(CheckPointer(objectType));
 
@@ -2769,7 +2766,12 @@ DispatchHolder *VirtualCallStubManager::GenerateDispatchStub(PCODE            ad
     }
 #endif
 
-    holder->Initialize(addrOfCode,
+    ExecutableWriterHolder<DispatchHolder> dispatchWriterHolder(holder, sizeof(DispatchHolder)
+#ifdef TARGET_AMD64
+                                                                        + sizeof(DispatchStubShort)
+#endif
+                                                               );
+    dispatchWriterHolder.GetRW()->Initialize(holder, addrOfCode,
                        addrOfFail,
                        (size_t)pMTExpected
 #ifdef TARGET_AMD64
@@ -2833,8 +2835,9 @@ DispatchHolder *VirtualCallStubManager::GenerateDispatchStubLong(PCODE
     //allocate from the requisite heap and copy the template over it.
     DispatchHolder * holder = (DispatchHolder*) (void*)
         dispatch_heap->AllocAlignedMem(DispatchHolder::GetHolderSize(DispatchStub::e_TYPE_LONG), CODE_SIZE_ALIGN);
+    ExecutableWriterHolder<DispatchHolder> dispatchWriterHolder(holder, sizeof(DispatchHolder) + sizeof(DispatchStubLong));
 
-    holder->Initialize(addrOfCode,
+    dispatchWriterHolder.GetRW()->Initialize(holder, addrOfCode,
                        addrOfFail,
                        (size_t)pMTExpected,
                        DispatchStub::e_TYPE_LONG);
@@ -2942,8 +2945,10 @@ ResolveHolder *VirtualCallStubManager::GenerateResolveStub(PCODE            addr
     //allocate from the requisite heap and copy the templates for each piece over it.
     ResolveHolder * holder = (ResolveHolder*) (void*)
         resolve_heap->AllocAlignedMem(sizeof(ResolveHolder), CODE_SIZE_ALIGN);
+    ExecutableWriterHolder<ResolveHolder> resolveWriterHolder(holder, sizeof(ResolveHolder));
 
-    holder->Initialize(addrOfResolver, addrOfPatcher,
+    resolveWriterHolder.GetRW()->Initialize(holder,
+                       addrOfResolver, addrOfPatcher,
                        dispatchToken, DispatchCache::HashToken(dispatchToken),
                        g_resolveCache->GetCacheBaseAddr(), counterAddr
 #if defined(TARGET_X86) && !defined(UNIX_X86_ABI)
@@ -2980,14 +2985,11 @@ LookupHolder *VirtualCallStubManager::GenerateLookupStub(PCODE addrOfResolver, s
         POSTCONDITION(CheckPointer(RETVAL));
     } CONTRACT_END;
 
-#if defined(HOST_OSX) && defined(HOST_ARM64)
-    auto jitWriteEnableHolder = PAL_JITWriteEnable(true);
-#endif // defined(HOST_OSX) && defined(HOST_ARM64)
-
     //allocate from the requisite heap and copy the template over it.
     LookupHolder * holder     = (LookupHolder*) (void*) lookup_heap->AllocAlignedMem(sizeof(LookupHolder), CODE_SIZE_ALIGN);
+    ExecutableWriterHolder<LookupHolder> lookupWriterHolder(holder, sizeof(LookupHolder));
 
-    holder->Initialize(addrOfResolver, dispatchToken);
+    lookupWriterHolder.GetRW()->Initialize(holder, addrOfResolver, dispatchToken);
     ClrFlushInstructionCache(holder->stub(), holder->stub()->size());
 
     AddToCollectibleVSDRangeList(holder);
diff --git a/src/coreclr/vm/zapsig.cpp b/src/coreclr/vm/zapsig.cpp
index 87fad284f02429..8ef797ea572520 100644
--- a/src/coreclr/vm/zapsig.cpp
+++ b/src/coreclr/vm/zapsig.cpp
@@ -741,7 +741,8 @@ Module *ZapSig::DecodeModuleFromIndexIfLoaded(Module *fromModule,
 TypeHandle ZapSig::DecodeType(Module *pEncodeModuleContext,
                               Module *pInfoModule,
                               PCCOR_SIGNATURE pBuffer,
-                              ClassLoadLevel level)
+                              ClassLoadLevel level,
+                              PCCOR_SIGNATURE *ppAfterSig /*=NULL*/)
 {
     CONTRACTL
     {
@@ -766,6 +767,12 @@ TypeHandle ZapSig::DecodeType(Module *pEncodeModuleContext,
                                             NULL,
                                             pZapSigContext);
 
+    if (ppAfterSig != NULL)
+    {
+        IfFailThrow(p.SkipExactlyOne());
+        *ppAfterSig = p.GetPtr();
+    }
+
     return th;
 }
 
@@ -778,7 +785,7 @@ MethodDesc *ZapSig::DecodeMethod(Module *pReferencingModule,
 
     SigTypeContext typeContext;    // empty context is OK: encoding should not contain type variables.
     ZapSig::Context zapSigContext(pInfoModule, (void *)pReferencingModule, ZapSig::NormalTokens);
-    return DecodeMethod(pInfoModule, pBuffer, &typeContext, &zapSigContext, ppTH);
+    return DecodeMethod(pInfoModule, pBuffer, &typeContext, &zapSigContext, ppTH, NULL, NULL);
 }
 
 MethodDesc *ZapSig::DecodeMethod(Module *pInfoModule,
@@ -787,7 +794,9 @@ MethodDesc *ZapSig::DecodeMethod(Module *pInfoModule,
                                  ZapSig::Context *pZapSigContext,
                                  TypeHandle *ppTH, /*=NULL*/
                                  PCCOR_SIGNATURE *ppOwnerTypeSpecWithVars, /*=NULL*/
-                                 PCCOR_SIGNATURE *ppMethodSpecWithVars /*=NULL*/)
+                                 PCCOR_SIGNATURE *ppMethodSpecWithVars, /*=NULL*/
+                                 PCCOR_SIGNATURE *ppAfterSig /*=NULL*/,
+                                 BOOL actualOwnerRequired /*=FALSE*/)
 {
     STANDARD_VM_CONTRACT;
 
@@ -801,6 +810,22 @@ MethodDesc *ZapSig::DecodeMethod(Module *pInfoModule,
 
     TypeHandle thOwner = NULL;
 
+    if ( methodFlags & ENCODE_METHOD_SIG_UpdateContext)
+    {
+        uint32_t updatedModuleIndex;
+        IfFailThrow(sig.GetData(&updatedModuleIndex));
+#ifdef FEATURE_MULTICOREJIT
+        if (pZapSigContext->externalTokens == ZapSig::MulticoreJitTokens)
+        {
+            pInfoModule = MulticoreJitManager::DecodeModuleFromIndex(pZapSigContext->pModuleContext, updatedModuleIndex);
+        }
+        else
+#endif
+        {
+            pInfoModule = pZapSigContext->GetZapSigModule()->GetModuleFromIndex(updatedModuleIndex);
+        }
+    }
+
     if ( methodFlags & ENCODE_METHOD_SIG_OwnerType )
     {
         if (ppOwnerTypeSpecWithVars != NULL)
@@ -843,7 +868,7 @@ MethodDesc *ZapSig::DecodeMethod(Module *pInfoModule,
                 MethodDesc * pMD = NULL;
                 FieldDesc * pFD = NULL;
 
-                MemberLoader::GetDescFromMemberRef(pInfoModule, TokenFromRid(rid, mdtMemberRef), &pMD, &pFD, NULL, FALSE, &th);
+                MemberLoader::GetDescFromMemberRef(pInfoModule, TokenFromRid(rid, mdtMemberRef), &pMD, &pFD, NULL, actualOwnerRequired, &th);
                 _ASSERTE(pMD != NULL);
 
                 thOwner = th;
@@ -863,7 +888,12 @@ MethodDesc *ZapSig::DecodeMethod(Module *pInfoModule,
     if (thOwner.IsNull())
     {
         if (pZapSigContext->externalTokens == ZapSig::MulticoreJitTokens)
+        {
+            if (ppAfterSig != NULL)
+                *ppAfterSig = sig.GetPtr();
+
             return NULL;
+        }
 
         thOwner = pMethod->GetMethodTable();
     }
@@ -926,7 +956,8 @@ MethodDesc *ZapSig::DecodeMethod(Module *pInfoModule,
     pMethod = MethodDesc::FindOrCreateAssociatedMethodDesc(pMethod, thOwner.GetMethodTable(),
                                                             isUnboxingStub,
                                                             inst,
-                                                            !(isInstantiatingStub || isUnboxingStub));
+                                                            !(isInstantiatingStub || isUnboxingStub) && !actualOwnerRequired,
+                                                            actualOwnerRequired);
 
     g_IBCLogger.LogMethodDescAccess(pMethod);
 
@@ -940,6 +971,9 @@ MethodDesc *ZapSig::DecodeMethod(Module *pInfoModule,
                                                 NULL,
                                                 pZapSigContext);
 
+        if (ppAfterSig != NULL)
+            IfFailThrow(sig.SkipExactlyOne());
+
         MethodDesc * directMethod = constrainedType.GetMethodTable()->TryResolveConstraintMethodApprox(thOwner.GetMethodTable(), pMethod);
         if (directMethod == NULL)
         {
@@ -960,6 +994,9 @@ MethodDesc *ZapSig::DecodeMethod(Module *pInfoModule,
         }
     }
 
+    if (ppAfterSig != NULL)
+        *ppAfterSig = sig.GetPtr();
+
     return pMethod;
 }
 
diff --git a/src/coreclr/vm/zapsig.h b/src/coreclr/vm/zapsig.h
index f8c5d8738171bf..bff06fd1585b26 100644
--- a/src/coreclr/vm/zapsig.h
+++ b/src/coreclr/vm/zapsig.h
@@ -163,7 +163,8 @@ class ZapSig
         Module              *referencingModule,
         Module              *fromModule,
         PCCOR_SIGNATURE     pBuffer,
-        ClassLoadLevel      level = CLASS_LOADED);
+        ClassLoadLevel      level = CLASS_LOADED,
+        PCCOR_SIGNATURE     *ppAfterSig = NULL);
 
     static MethodDesc *DecodeMethod(
         Module              *referencingModule,
@@ -178,7 +179,9 @@ class ZapSig
         ZapSig::Context     *pZapSigContext,
         TypeHandle          *ppTH = NULL,
         PCCOR_SIGNATURE     *ppOwnerTypeSpecWithVars = NULL,
-        PCCOR_SIGNATURE     *ppMethodSpecWithVars = NULL);
+        PCCOR_SIGNATURE     *ppMethodSpecWithVars = NULL,
+        PCCOR_SIGNATURE     *ppAfterSig = NULL,
+        BOOL                actualOwnerRequired = FALSE);
 
     static FieldDesc *DecodeField(
         Module              *referencingModule,
diff --git a/src/coreclr/zap/zapinfo.cpp b/src/coreclr/zap/zapinfo.cpp
index 0b329bea0cd351..b1066dcf807345 100644
--- a/src/coreclr/zap/zapinfo.cpp
+++ b/src/coreclr/zap/zapinfo.cpp
@@ -4072,7 +4072,36 @@ void ZapInfo::getMethodVTableOffset(CORINFO_METHOD_HANDLE method,
 
 bool ZapInfo::resolveVirtualMethod(CORINFO_DEVIRTUALIZATION_INFO * info)
 {
-    return m_pEEJitInfo->resolveVirtualMethod(info);
+    bool result = m_pEEJitInfo->resolveVirtualMethod(info);
+    if (result)
+    {
+        // First, cons up a suitable resolved token.
+        CORINFO_RESOLVED_TOKEN derivedResolvedToken = {};
+        info->resolvedTokenDevirtualizedMethod = derivedResolvedToken;
+
+        info->resolvedTokenDevirtualizedMethod.tokenScope   = getMethodModule(info->devirtualizedMethod);
+        info->resolvedTokenDevirtualizedMethod.tokenContext = MAKE_METHODCONTEXT(info->devirtualizedMethod);
+        info->resolvedTokenDevirtualizedMethod.token        = getMethodDefFromMethod(info->devirtualizedMethod);
+        info->resolvedTokenDevirtualizedMethod.tokenType    = CORINFO_TOKENKIND_DevirtualizedMethod;
+        info->resolvedTokenDevirtualizedMethod.hClass       = (CORINFO_CLASS_HANDLE)((size_t)info->exactContext & ~CORINFO_CONTEXTFLAGS_MASK);;
+        info->resolvedTokenDevirtualizedMethod.hMethod      = info->devirtualizedMethod;
+
+        // Then, if the method is on a valuetype, cons up a unboxed method resolution stub
+        info->resolvedTokenDevirtualizedUnboxedMethod = derivedResolvedToken;
+        bool unused;
+        CORINFO_METHOD_HANDLE unboxedMethod = getUnboxedEntry(info->devirtualizedMethod, &unused);
+        if (unboxedMethod != NULL)
+        {
+            info->resolvedTokenDevirtualizedUnboxedMethod.tokenScope   = getMethodModule(unboxedMethod);
+            info->resolvedTokenDevirtualizedUnboxedMethod.tokenContext = MAKE_METHODCONTEXT(unboxedMethod);
+            info->resolvedTokenDevirtualizedUnboxedMethod.token        = getMethodDefFromMethod(unboxedMethod);
+            info->resolvedTokenDevirtualizedUnboxedMethod.tokenType    = CORINFO_TOKENKIND_DevirtualizedMethod;
+            info->resolvedTokenDevirtualizedUnboxedMethod.hClass       = (CORINFO_CLASS_HANDLE)((size_t)info->exactContext & ~CORINFO_CONTEXTFLAGS_MASK);;
+            info->resolvedTokenDevirtualizedUnboxedMethod.hMethod      = unboxedMethod;
+        }
+    }
+
+    return result;
 }
 
 CORINFO_METHOD_HANDLE ZapInfo::getUnboxedEntry(
diff --git a/src/coreclr/zap/zapreadytorun.cpp b/src/coreclr/zap/zapreadytorun.cpp
index 6b7b09c38b88d3..e5e0a236e44319 100644
--- a/src/coreclr/zap/zapreadytorun.cpp
+++ b/src/coreclr/zap/zapreadytorun.cpp
@@ -787,6 +787,7 @@ static_assert_no_msg((int)READYTORUN_METHOD_SIG_SlotInsteadOfToken   == (int)ENC
 static_assert_no_msg((int)READYTORUN_METHOD_SIG_MemberRefToken       == (int)ENCODE_METHOD_SIG_MemberRefToken);
 static_assert_no_msg((int)READYTORUN_METHOD_SIG_Constrained          == (int)ENCODE_METHOD_SIG_Constrained);
 static_assert_no_msg((int)READYTORUN_METHOD_SIG_OwnerType            == (int)ENCODE_METHOD_SIG_OwnerType);
+static_assert_no_msg((int)READYTORUN_METHOD_SIG_UpdateContext        == (int)ENCODE_METHOD_SIG_UpdateContext);
 
 //
 // READYTORUN_FIELD_SIG
@@ -853,6 +854,9 @@ static_assert_no_msg((int)READYTORUN_FIXUP_Check_InstructionSetSupport== (int)EN
 static_assert_no_msg((int)READYTORUN_FIXUP_Verify_FieldOffset         == (int)ENCODE_VERIFY_FIELD_OFFSET);
 static_assert_no_msg((int)READYTORUN_FIXUP_Verify_TypeLayout          == (int)ENCODE_VERIFY_TYPE_LAYOUT);
 
+static_assert_no_msg((int)READYTORUN_FIXUP_Check_VirtualFunctionOverride  == (int)ENCODE_CHECK_VIRTUAL_FUNCTION_OVERRIDE);
+static_assert_no_msg((int)READYTORUN_FIXUP_Verify_VirtualFunctionOverride == (int)ENCODE_VERIFY_VIRTUAL_FUNCTION_OVERRIDE);
+
 //
 // READYTORUN_EXCEPTION
 //
diff --git a/src/installer/managed/Microsoft.NET.HostModel/AppHost/AppHostCustomizationUnsupportedOSException.cs b/src/installer/managed/Microsoft.NET.HostModel/AppHost/AppHostCustomizationUnsupportedOSException.cs
deleted file mode 100644
index 0b0b055bdc688b..00000000000000
--- a/src/installer/managed/Microsoft.NET.HostModel/AppHost/AppHostCustomizationUnsupportedOSException.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;
-
-namespace Microsoft.NET.HostModel.AppHost
-{
-    /// <summary>
-    /// The application host executable cannot be customized because adding resources requires
-    /// that the build be performed on Windows (excluding Nano Server).
-    /// </summary>
-    public class AppHostCustomizationUnsupportedOSException : AppHostUpdateException
-    {
-    }
-}
diff --git a/src/installer/managed/Microsoft.NET.HostModel/AppHost/AppHostExceptions.cs b/src/installer/managed/Microsoft.NET.HostModel/AppHost/AppHostExceptions.cs
new file mode 100644
index 00000000000000..ceae7c46cdc80f
--- /dev/null
+++ b/src/installer/managed/Microsoft.NET.HostModel/AppHost/AppHostExceptions.cs
@@ -0,0 +1,92 @@
+// 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.NET.HostModel.AppHost
+{
+    /// <summary>
+    /// An instance of this exception is thrown when an AppHost binary update
+    /// fails due to known user errors.
+    /// </summary>
+    public class AppHostUpdateException : Exception
+    {
+        internal AppHostUpdateException(string message = null)
+            : base(message)
+        {
+        }
+    }
+
+    /// <summary>
+    /// The application host executable cannot be customized because adding resources requires
+    /// that the build be performed on Windows (excluding Nano Server).
+    /// </summary>
+    public sealed class AppHostCustomizationUnsupportedOSException : AppHostUpdateException
+    {
+        internal AppHostCustomizationUnsupportedOSException()
+        {
+        }
+    }
+
+    /// <summary>
+    /// The MachO application host executable cannot be customized because
+    /// it was not in the expected format
+    /// </summary>
+    public sealed class AppHostMachOFormatException : AppHostUpdateException
+    {
+        public readonly MachOFormatError Error;
+
+        internal AppHostMachOFormatException(MachOFormatError error)
+        {
+            Error = error;
+        }
+    }
+
+    /// <summary>
+    /// Unable to use the input file as application host executable because it's not a
+    /// Windows executable for the CUI (Console) subsystem.
+    /// </summary>
+    public sealed class AppHostNotCUIException : AppHostUpdateException
+    {
+        internal AppHostNotCUIException()
+        {
+        }
+    }
+
+    /// <summary>
+    ///  Unable to use the input file as an application host executable
+    ///  because it's not a Windows PE file
+    /// </summary>
+    public sealed class AppHostNotPEFileException : AppHostUpdateException
+    {
+        internal AppHostNotPEFileException()
+        {
+        }
+    }
+
+    /// <summary>
+    /// Unable to sign the apphost binary.
+    /// </summary>
+    public sealed class AppHostSigningException : AppHostUpdateException
+    {
+        public readonly int ExitCode;
+
+        internal AppHostSigningException(int exitCode, string signingErrorMessage)
+            : base(signingErrorMessage)
+        {
+        }
+    }
+
+    /// <summary>
+    /// Given app file name is longer than 1024 bytes
+    /// </summary>
+    public sealed class AppNameTooLongException : AppHostUpdateException
+    {
+        public string LongName { get; }
+
+        internal AppNameTooLongException(string name)
+        {
+            LongName = name;
+        }
+    }
+}
diff --git a/src/installer/managed/Microsoft.NET.HostModel/AppHost/AppHostNotCUIException.cs b/src/installer/managed/Microsoft.NET.HostModel/AppHost/AppHostNotCUIException.cs
deleted file mode 100644
index b89a22dced400a..00000000000000
--- a/src/installer/managed/Microsoft.NET.HostModel/AppHost/AppHostNotCUIException.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;
-
-namespace Microsoft.NET.HostModel.AppHost
-{
-    /// <summary>
-    /// Unable to use the input file as application host executable because it's not a
-    /// Windows executable for the CUI (Console) subsystem.
-    /// </summary>
-    public class AppHostNotCUIException : AppHostUpdateException
-    {
-    }
-}
diff --git a/src/installer/managed/Microsoft.NET.HostModel/AppHost/AppHostNotPEFileException.cs b/src/installer/managed/Microsoft.NET.HostModel/AppHost/AppHostNotPEFileException.cs
deleted file mode 100644
index 6712d875f7683f..00000000000000
--- a/src/installer/managed/Microsoft.NET.HostModel/AppHost/AppHostNotPEFileException.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;
-
-namespace Microsoft.NET.HostModel.AppHost
-{
-    /// <summary>
-    ///  Unable to use the input file as an application host executable
-    ///  because it's not a Windows PE file
-    /// </summary>
-    public class AppHostNotPEFileException : AppHostUpdateException
-    {
-    }
-}
diff --git a/src/installer/managed/Microsoft.NET.HostModel/AppHost/AppHostUpdateException.cs b/src/installer/managed/Microsoft.NET.HostModel/AppHost/AppHostUpdateException.cs
deleted file mode 100644
index 4570c7710c2dbf..00000000000000
--- a/src/installer/managed/Microsoft.NET.HostModel/AppHost/AppHostUpdateException.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;
-
-namespace Microsoft.NET.HostModel.AppHost
-{
-    /// <summary>
-    /// An instance of this exception is thrown when an AppHost binary update
-    /// fails due to known user errors.
-    /// </summary>
-    public class AppHostUpdateException : Exception
-    {
-    }
-}
diff --git a/src/installer/managed/Microsoft.NET.HostModel/AppHost/AppNameTooLongException.cs b/src/installer/managed/Microsoft.NET.HostModel/AppHost/AppNameTooLongException.cs
deleted file mode 100644
index 18a984b17c5918..00000000000000
--- a/src/installer/managed/Microsoft.NET.HostModel/AppHost/AppNameTooLongException.cs
+++ /dev/null
@@ -1,20 +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;
-
-namespace Microsoft.NET.HostModel.AppHost
-{
-    /// <summary>
-    /// Given app file name is longer than 1024 bytes
-    /// </summary>
-    public class AppNameTooLongException : AppHostUpdateException
-    {
-        public string LongName { get; }
-        public AppNameTooLongException(string name)
-        {
-            LongName = name;
-        }
-
-    }
-}
diff --git a/src/installer/managed/Microsoft.NET.HostModel/AppHost/HostWriter.cs b/src/installer/managed/Microsoft.NET.HostModel/AppHost/HostWriter.cs
index 69ad0d439bd642..c0e979dd28d276 100644
--- a/src/installer/managed/Microsoft.NET.HostModel/AppHost/HostWriter.cs
+++ b/src/installer/managed/Microsoft.NET.HostModel/AppHost/HostWriter.cs
@@ -3,6 +3,7 @@
 
 using System;
 using System.ComponentModel;
+using System.Diagnostics;
 using System.IO;
 using System.IO.MemoryMappedFiles;
 using System.Runtime.InteropServices;
@@ -30,12 +31,14 @@ public static class HostWriter
         /// <param name="appBinaryFilePath">Full path to app binary or relative path to the result apphost file</param>
         /// <param name="windowsGraphicalUserInterface">Specify whether to set the subsystem to GUI. Only valid for PE apphosts.</param>
         /// <param name="assemblyToCopyResorcesFrom">Path to the intermediate assembly, used for copying resources to PE apphosts.</param>
+        /// <param name="enableMacOSCodeSign">Sign the app binary using codesign with an anonymous certificate.</param>
         public static void CreateAppHost(
             string appHostSourceFilePath,
             string appHostDestinationFilePath,
             string appBinaryFilePath,
             bool windowsGraphicalUserInterface = false,
-            string assemblyToCopyResorcesFrom = null)
+            string assemblyToCopyResorcesFrom = null,
+            bool enableMacOSCodeSign = false)
         {
             var bytesToWrite = Encoding.UTF8.GetBytes(appBinaryFilePath);
             if (bytesToWrite.Length > 1024)
@@ -140,6 +143,9 @@ void UpdateResources()
                     {
                         throw new Win32Exception(Marshal.GetLastWin32Error(), $"Could not set file permission {filePermissionOctal} for {appHostDestinationFilePath}.");
                     }
+
+                    if (enableMacOSCodeSign && RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
+                        CodeSign(appHostDestinationFilePath);
                 }
             }
             catch (Exception ex)
@@ -233,6 +239,28 @@ void FindBundleHeader()
             return headerOffset != 0;
         }
 
+        private static void CodeSign(string appHostPath)
+        {
+            Debug.Assert(RuntimeInformation.IsOSPlatform(OSPlatform.OSX));
+            const string codesign = @"/usr/bin/codesign";
+            if (!File.Exists(codesign))
+                return;
+
+            var psi = new ProcessStartInfo()
+            {
+                Arguments = $"-s - \"{appHostPath}\"",
+                FileName = codesign,
+                RedirectStandardError = true,
+            };
+
+            using (var p = Process.Start(psi))
+            {
+                p.WaitForExit();
+                if (p.ExitCode != 0)
+                    throw new AppHostSigningException(p.ExitCode, p.StandardError.ReadToEnd());
+            }
+        }
+
         [DllImport("libc", SetLastError = true)]
         private static extern int chmod(string pathname, int mode);
     }
diff --git a/src/installer/managed/Microsoft.NET.HostModel/AppHost/AppHostMachOFormatException.cs b/src/installer/managed/Microsoft.NET.HostModel/AppHost/MachOFormatError.cs
similarity index 75%
rename from src/installer/managed/Microsoft.NET.HostModel/AppHost/AppHostMachOFormatException.cs
rename to src/installer/managed/Microsoft.NET.HostModel/AppHost/MachOFormatError.cs
index 60e6d74ec591e9..eae935f13af274 100644
--- a/src/installer/managed/Microsoft.NET.HostModel/AppHost/AppHostMachOFormatException.cs
+++ b/src/installer/managed/Microsoft.NET.HostModel/AppHost/MachOFormatError.cs
@@ -1,8 +1,6 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// 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.NET.HostModel.AppHost
 {
     /// <summary>
@@ -25,18 +23,4 @@ public enum MachOFormatError
         InvalidUTF8,            // UTF8 decoding failed
         SignNotRemoved,         // Signature not removed from the host (while processing a single-file bundle)
     }
-
-    /// <summary>
-    /// The MachO application host executable cannot be customized because
-    /// it was not in the expected format
-    /// </summary>
-    public class AppHostMachOFormatException : AppHostUpdateException
-    {
-        public readonly MachOFormatError Error;
-
-        public AppHostMachOFormatException(MachOFormatError error)
-        {
-            Error = error;
-        }
-    }
 }
diff --git a/src/installer/pkg/sfx/Microsoft.NETCore.App/Directory.Build.props b/src/installer/pkg/sfx/Microsoft.NETCore.App/Directory.Build.props
index 834fa2bac988d6..3efbe093fb75eb 100644
--- a/src/installer/pkg/sfx/Microsoft.NETCore.App/Directory.Build.props
+++ b/src/installer/pkg/sfx/Microsoft.NETCore.App/Directory.Build.props
@@ -68,7 +68,6 @@
   <ItemGroup>
     <!-- Public libraries and shims -->
     <PlatformManifestFileEntry Include="@(NetCoreAppLibrary->'%(Identity).dll')" />
-    <PlatformManifestFileEntry Include="@(NetCoreAppLibraryNoReference->'%(Identity).dll')" />
     <PlatformManifestFileEntry Include="@(NetFxReference->'%(Identity).dll')" />
     <PlatformManifestFileEntry Include="netstandard.dll" />
     <!-- Private libraries -->
@@ -257,4 +256,8 @@
   <PropertyGroup Condition="'$(TargetArchitecture)' == 'arm64' AND '$(BuildArchitecture)' != 'arm64'">
     <_hostArch>amd64</_hostArch>
   </PropertyGroup>
+
+  <PropertyGroup>
+    <WorkloadTasksAssemblyPath>$([MSBuild]::NormalizeDirectory('$(ArtifactsBinDir)', 'WorkloadBuildTasks', 'Debug', '$(NetCoreAppToolCurrent)'))WorkloadBuildTasks.dll</WorkloadTasksAssemblyPath>
+  </PropertyGroup>
 </Project>
diff --git a/src/installer/pkg/sfx/Microsoft.NETCore.App/Directory.Build.targets b/src/installer/pkg/sfx/Microsoft.NETCore.App/Directory.Build.targets
index 671d6f0d040ead..c570a22277456e 100644
--- a/src/installer/pkg/sfx/Microsoft.NETCore.App/Directory.Build.targets
+++ b/src/installer/pkg/sfx/Microsoft.NETCore.App/Directory.Build.targets
@@ -13,5 +13,7 @@
     <PackageReference Include="Microsoft.DotNet.Build.Tasks.Archives" Version="$(MicrosoftDotNetBuildTasksArchivesVersion)" />
   </ItemGroup>
 
+  <UsingTask TaskName="GenerateFileFromTemplate" AssemblyFile="$(WorkloadTasksAssemblyPath)" />
+
   <Import Project="$([MSBuild]::GetPathOfFileAbove(Directory.Build.targets, $(MSBuildThisFileDirectory)..))" />
 </Project>
diff --git a/src/installer/pkg/sfx/Microsoft.NETCore.App/Microsoft.NETCore.App.Crossgen2.sfxproj b/src/installer/pkg/sfx/Microsoft.NETCore.App/Microsoft.NETCore.App.Crossgen2.sfxproj
index e9cd505eea1690..b039715be97a70 100644
--- a/src/installer/pkg/sfx/Microsoft.NETCore.App/Microsoft.NETCore.App.Crossgen2.sfxproj
+++ b/src/installer/pkg/sfx/Microsoft.NETCore.App/Microsoft.NETCore.App.Crossgen2.sfxproj
@@ -10,7 +10,8 @@
     <OverridePackageId>$(SharedFrameworkName)$(PgoSuffix).$(RuntimeIdentifier)</OverridePackageId>
     <ArchiveName>dotnet-crossgen2</ArchiveName>
     <SharedFrameworkHostFileNameOverride>crossgen2</SharedFrameworkHostFileNameOverride>
-    <RuntimeIdentifiers>linux-x64;linux-musl-x64;linux-arm;linux-musl-arm;linux-arm64;linux-musl-arm64;osx-x64;osx-arm64;win-x64;win-x86;win-arm64;win-arm</RuntimeIdentifiers>
+    <!-- Build this pack for any RID if building from source. Otherwise, only build select RIDs. -->
+    <RuntimeIdentifiers Condition="'$(DotNetBuildFromSource)' != 'true'">linux-x64;linux-musl-x64;linux-arm;linux-musl-arm;linux-arm64;linux-musl-arm64;osx-x64;osx-arm64;win-x64;win-x86;win-arm64;win-arm</RuntimeIdentifiers>
     <GenerateInstallers>false</GenerateInstallers>
     <GetSharedFrameworkFilesForReadyToRunDependsOn>
         AddRuntimeFilesToPackage;
diff --git a/src/installer/pkg/sfx/Microsoft.NETCore.App/Microsoft.NETCore.App.MonoCrossAOT.Sdk.props b/src/installer/pkg/sfx/Microsoft.NETCore.App/Microsoft.NETCore.App.MonoCrossAOT.Sdk.props
deleted file mode 100644
index dcdea1f5cc9062..00000000000000
--- a/src/installer/pkg/sfx/Microsoft.NETCore.App/Microsoft.NETCore.App.MonoCrossAOT.Sdk.props
+++ /dev/null
@@ -1,6 +0,0 @@
-<Project>
-  <PropertyGroup>
-    <MonoAotCrossCompilerPath>$(MSBuildThisFileDirectory)..\tools\mono-aot-cross</MonoAotCrossCompilerPath>
-    <MonoAotCrossCompilerPath Condition="$([MSBuild]::IsOsPlatform('Windows'))">$(MonoAotCrossCompilerPath).exe</MonoAotCrossCompilerPath>
-  </PropertyGroup>
-</Project>
diff --git a/src/installer/pkg/sfx/Microsoft.NETCore.App/Microsoft.NETCore.App.MonoCrossAOT.Sdk.props.in b/src/installer/pkg/sfx/Microsoft.NETCore.App/Microsoft.NETCore.App.MonoCrossAOT.Sdk.props.in
new file mode 100644
index 00000000000000..f9a2af9354a70f
--- /dev/null
+++ b/src/installer/pkg/sfx/Microsoft.NETCore.App/Microsoft.NETCore.App.MonoCrossAOT.Sdk.props.in
@@ -0,0 +1,6 @@
+<Project>
+  <ItemGroup>
+    <MonoAotCrossCompiler Include="$(MSBuildThisFileDirectory)..\tools\mono-aot-cross${ExeSuffix}" RuntimeIdentifier="${TargetRid}" />
+  </ItemGroup>
+</Project>
+
diff --git a/src/installer/pkg/sfx/Microsoft.NETCore.App/Microsoft.NETCore.App.MonoCrossAOT.UnixFilePermissions.xml b/src/installer/pkg/sfx/Microsoft.NETCore.App/Microsoft.NETCore.App.MonoCrossAOT.UnixFilePermissions.xml
new file mode 100644
index 00000000000000..9437f7953f315a
--- /dev/null
+++ b/src/installer/pkg/sfx/Microsoft.NETCore.App/Microsoft.NETCore.App.MonoCrossAOT.UnixFilePermissions.xml
@@ -0,0 +1,5 @@
+<FileList>
+    <File Path="tools/mono-aot-cross" Permission="755" />
+    <File Path="tools/opt" Permission="755" />
+    <File Path="tools/llc" Permission="755" />
+</FileList>
diff --git a/src/installer/pkg/sfx/Microsoft.NETCore.App/Microsoft.NETCore.App.MonoCrossAOT.sfxproj b/src/installer/pkg/sfx/Microsoft.NETCore.App/Microsoft.NETCore.App.MonoCrossAOT.sfxproj
index 70b4be718fff4c..3c0e7fac2d86b2 100644
--- a/src/installer/pkg/sfx/Microsoft.NETCore.App/Microsoft.NETCore.App.MonoCrossAOT.sfxproj
+++ b/src/installer/pkg/sfx/Microsoft.NETCore.App/Microsoft.NETCore.App.MonoCrossAOT.sfxproj
@@ -19,9 +19,22 @@
 
   <ItemGroup>
     <NativeRuntimeAsset Include="$(MonoAotCrossDir)$(TargetCrossRid)\**" TargetPath="tools/" />
-    <NativeRuntimeAsset Include="$(MSBuildThisFileDirectory)Microsoft.NETCore.App.MonoCrossAOT.Sdk.props" TargetPath="Sdk/Sdk.props" />
+    <NativeRuntimeAsset Include="$(MonoAotCrossDir)$(TargetCrossRid).Sdk.props" TargetPath="Sdk/Sdk.props" />
+    <NativeRuntimeAsset Condition="!$([MSBuild]::IsOsPlatform('Windows'))" Include="Microsoft.NETCore.App.MonoCrossAOT.UnixFilePermissions.xml" TargetPath="data/UnixFilePermissions.xml" />
   </ItemGroup>
 
+  <Target Name="WriteAotSdkProps" BeforeTargets="ValidateProperties">
+    <ItemGroup>
+      <_SdkPropsProperties Condition="!$([MSBuild]::IsOsPlatform('Windows'))" Include="ExeSuffix" Value="" />
+      <_SdkPropsProperties Condition="$([MSBuild]::IsOsPlatform('Windows'))" Include="ExeSuffix" Value=".exe" />
+      <_SdkPropsProperties Include="TargetRid" Value="$(TargetCrossRid)" />
+    </ItemGroup>
+    <GenerateFileFromTemplate
+      TemplateFile="Microsoft.NETCore.App.MonoCrossAOT.Sdk.props.in"
+      Properties="@(_SdkPropsProperties)"
+      OutputPath="$(MonoAotCrossDir)$(TargetCrossRid).Sdk.props" />
+  </Target>
+
   <Target Name="ValidateProperties" BeforeTargets="GenerateNuspec">
     <Error Condition="'$(TargetCrossRid)' == ''" Text="TargetCrossRid not set" />
     <Error Condition="!Exists('$(MonoAotCrossDir)$(TargetCrossRid)\$(AotCompilerFileName)')" Text="Cross compiler not found in $(MonoAotCrossDir)$(TargetCrossRid)" />
diff --git a/src/installer/pkg/sfx/installers/dotnet-host.proj b/src/installer/pkg/sfx/installers/dotnet-host.proj
index 6f645a73a5281b..0963a7b89d8cca 100644
--- a/src/installer/pkg/sfx/installers/dotnet-host.proj
+++ b/src/installer/pkg/sfx/installers/dotnet-host.proj
@@ -17,6 +17,9 @@
     <IncludeVersionInMacOSComponentName>false</IncludeVersionInMacOSComponentName>
     <MacOSScriptsDirectory>osx_scripts/host</MacOSScriptsDirectory>
     <MacOSPackageDescription>The .NET Shared Host.</MacOSPackageDescription>
+    <RpmScriptsDirectory>$(MSBuildThisFileDirectory)rpm_scripts/host</RpmScriptsDirectory>
+    <RpmAfterInstallScript>$(RpmScriptsDirectory)/after_install.sh</RpmAfterInstallScript>
+    <RpmAfterRemoveScript>$(RpmScriptsDirectory)/after_remove.sh</RpmAfterRemoveScript>
   </PropertyGroup>
 
   <ItemGroup>
@@ -68,6 +71,8 @@
     <ItemGroup>
       <DebJsonProperty Include="symlinks" Object="{ &quot;dotnet&quot;: &quot;/usr/bin/dotnet&quot; }" />
       <RpmJsonProperty Include="directories" Object="[ &quot;/usr/share/dotnet&quot;, &quot;/usr/share/doc/dotnet-host&quot; ]" />
+      <RpmJsonProperty Include="after_install_source" Object="&quot;$(RpmAfterInstallScript)&quot;" />
+      <RpmJsonProperty Include="after_remove_source" Object="&quot;$(RpmAfterRemoveScript)&quot;" />
       <PackageConflictsProperty Include="package_conflicts" Object="[ &quot;dotnet&quot;, &quot;dotnet-nightly&quot; ]" />
       <DebJsonProperty Include="@(PackageConflictsProperty)" />
       <RpmJsonProperty Include="@(PackageConflictsProperty)" />
diff --git a/src/installer/pkg/sfx/installers/rpm_scripts/host/after_install.sh b/src/installer/pkg/sfx/installers/rpm_scripts/host/after_install.sh
new file mode 100644
index 00000000000000..2a588366faa952
--- /dev/null
+++ b/src/installer/pkg/sfx/installers/rpm_scripts/host/after_install.sh
@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+
+if [[ -L /usr/local/bin/dotnet ]]; then
+  rm /usr/local/bin/dotnet
+fi
+ln -s /usr/share/dotnet/dotnet /usr/local/bin/dotnet
+
diff --git a/src/installer/pkg/sfx/installers/rpm_scripts/host/after_remove.sh b/src/installer/pkg/sfx/installers/rpm_scripts/host/after_remove.sh
new file mode 100644
index 00000000000000..35fb8359a54b28
--- /dev/null
+++ b/src/installer/pkg/sfx/installers/rpm_scripts/host/after_remove.sh
@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+
+if [[ -L /usr/local/bin/dotnet ]]; then
+  rm /usr/local/bin/dotnet
+fi
+
diff --git a/src/installer/tests/HostActivation.Tests/CommandExtensions.cs b/src/installer/tests/HostActivation.Tests/CommandExtensions.cs
index 054e6c39d14368..d8460c1368bdb5 100644
--- a/src/installer/tests/HostActivation.Tests/CommandExtensions.cs
+++ b/src/installer/tests/HostActivation.Tests/CommandExtensions.cs
@@ -35,8 +35,11 @@ public static Command EnableTracingAndCaptureOutputs(this Command command)
                 .CaptureStdErr();
         }
 
-        public static Command DotNetRoot(this Command command, string dotNetRoot)
+        public static Command DotNetRoot(this Command command, string dotNetRoot, string architecture = null)
         {
+            if (!string.IsNullOrEmpty(architecture))
+                return command.EnvironmentVariable($"DOTNET_ROOT_{architecture.ToUpper()}", dotNetRoot);
+
             return command
                 .EnvironmentVariable("DOTNET_ROOT", dotNetRoot)
                 .EnvironmentVariable("DOTNET_ROOT(x86)", dotNetRoot);
diff --git a/src/installer/tests/HostActivation.Tests/InstallLocationCommandResultExtensions.cs b/src/installer/tests/HostActivation.Tests/InstallLocationCommandResultExtensions.cs
new file mode 100644
index 00000000000000..c85b7d3e56cc5d
--- /dev/null
+++ b/src/installer/tests/HostActivation.Tests/InstallLocationCommandResultExtensions.cs
@@ -0,0 +1,58 @@
+// 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;
+using FluentAssertions;
+using Microsoft.DotNet.Cli.Build.Framework;
+using Microsoft.DotNet.CoreSetup.Test;
+using Xunit;
+
+namespace HostActivation.Tests
+{
+    internal static class InstallLocationCommandResultExtensions
+    {
+        private static bool IsRunningInWoW64(string rid) => OperatingSystem.IsWindows() && Environment.Is64BitOperatingSystem && rid.Equals("win-x86");
+
+        public static AndConstraint<CommandResultAssertions> HaveUsedDotNetRootInstallLocation(this CommandResultAssertions assertion, string installLocation, string rid)
+        {
+            return assertion.HaveUsedDotNetRootInstallLocation(installLocation, rid, null);
+        }
+
+        public static AndConstraint<CommandResultAssertions> HaveUsedDotNetRootInstallLocation(this CommandResultAssertions assertion,
+            string installLocation,
+            string rid,
+            string arch)
+        {
+            // If no arch is passed and we are on Windows, we need the used RID for determining whether or not we are running on WoW64.
+            if (string.IsNullOrEmpty(arch))
+                Assert.NotNull(rid);
+
+            string expectedEnvironmentVariable = !string.IsNullOrEmpty(arch) ? $"DOTNET_ROOT_{arch.ToUpper()}" :
+                IsRunningInWoW64(rid) ? "DOTNET_ROOT(x86)" : "DOTNET_ROOT";
+
+            return assertion.HaveStdErrContaining($"Using environment variable {expectedEnvironmentVariable}=[{installLocation}] as runtime location.");
+        }
+
+        public static AndConstraint<CommandResultAssertions> HaveUsedConfigFileInstallLocation(this CommandResultAssertions assertion, string installLocation)
+        {
+            return assertion.HaveStdErrContaining($"Using install location '{installLocation}'.");
+        }
+
+        public static AndConstraint<CommandResultAssertions> HaveUsedGlobalInstallLocation(this CommandResultAssertions assertion, string installLocation)
+        {
+            return assertion.HaveStdErrContaining($"Using global installation location [{installLocation}]");
+        }
+
+        public static AndConstraint<CommandResultAssertions> HaveFoundDefaultInstallLocationInConfigFile(this CommandResultAssertions assertion, string installLocation)
+        {
+            return assertion.HaveStdErrContaining($"Found install location path '{installLocation}'.");
+        }
+
+        public static AndConstraint<CommandResultAssertions> HaveFoundArchSpecificInstallLocationInConfigFile(this CommandResultAssertions assertion, string installLocation, string arch)
+        {
+            return assertion.HaveStdErrContaining($"Found architecture-specific install location path: '{installLocation}' ('{arch}').");
+        }
+    }
+}
diff --git a/src/installer/tests/HostActivation.Tests/MultiArchInstallLocation.cs b/src/installer/tests/HostActivation.Tests/MultiArchInstallLocation.cs
new file mode 100644
index 00000000000000..c1b00cafd4e6ae
--- /dev/null
+++ b/src/installer/tests/HostActivation.Tests/MultiArchInstallLocation.cs
@@ -0,0 +1,184 @@
+// 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.Runtime.InteropServices;
+using Microsoft.DotNet.Cli.Build.Framework;
+using Microsoft.DotNet.CoreSetup.Test;
+using Microsoft.DotNet.CoreSetup.Test.HostActivation;
+using Xunit;
+
+namespace HostActivation.Tests
+{
+    public class MultiArchInstallLocation : IClassFixture<MultiArchInstallLocation.SharedTestState>
+    {
+        private SharedTestState sharedTestState;
+
+        public MultiArchInstallLocation(SharedTestState fixture)
+        {
+            sharedTestState = fixture;
+        }
+
+        [Fact]
+        public void EnvironmentVariable_CurrentArchitectureIsUsedIfEnvVarSet()
+        {
+            var fixture = sharedTestState.PortableAppFixture
+                .Copy();
+
+            var appExe = fixture.TestProject.AppExe;
+            var arch = fixture.RepoDirProvider.BuildArchitecture.ToUpper();
+            Command.Create(appExe)
+                .EnableTracingAndCaptureOutputs()
+                .DotNetRoot(fixture.BuiltDotnet.BinPath, arch)
+                .Execute()
+                .Should().Pass()
+                .And.HaveUsedDotNetRootInstallLocation(fixture.BuiltDotnet.BinPath, fixture.CurrentRid, arch);
+        }
+
+        [Fact]
+        public void EnvironmentVariable_IfNoArchSpecificEnvVarIsFoundDotnetRootIsUsed()
+        {
+            var fixture = sharedTestState.PortableAppFixture
+                .Copy();
+
+            var appExe = fixture.TestProject.AppExe;
+            var arch = fixture.RepoDirProvider.BuildArchitecture.ToUpper();
+            Command.Create(appExe)
+                .EnableTracingAndCaptureOutputs()
+                .DotNetRoot(fixture.BuiltDotnet.BinPath)
+                .Execute()
+                .Should().Pass()
+                .And.HaveUsedDotNetRootInstallLocation(fixture.BuiltDotnet.BinPath, fixture.CurrentRid);
+        }
+
+        [Fact]
+        public void EnvironmentVariable_ArchSpecificDotnetRootIsUsedOverDotnetRoot()
+        {
+            var fixture = sharedTestState.PortableAppFixture
+                .Copy();
+
+            var appExe = fixture.TestProject.AppExe;
+            var arch = fixture.RepoDirProvider.BuildArchitecture.ToUpper();
+            var dotnet = fixture.BuiltDotnet.BinPath;
+            Command.Create(appExe)
+                .EnableTracingAndCaptureOutputs()
+                .DotNetRoot("non_existent_path")
+                .DotNetRoot(dotnet, arch)
+                .Execute()
+                .Should().Pass()
+                .And.HaveUsedDotNetRootInstallLocation(dotnet, fixture.CurrentRid, arch)
+                .And.NotHaveStdErrContaining("Using environment variable DOTNET_ROOT=");
+        }
+
+        [Fact]
+        [SkipOnPlatform(TestPlatforms.Windows, "This test targets the install_location config file which is only used on Linux and macOS.")]
+        public void InstallLocationFile_ArchSpecificLocationIsPickedFirst()
+        {
+            var fixture = sharedTestState.PortableAppFixture
+                .Copy();
+
+            var appExe = fixture.TestProject.AppExe;
+            var arch1 = "someArch";
+            var path1 = "x/y/z";
+            var arch2 = fixture.RepoDirProvider.BuildArchitecture;
+            var path2 = "a/b/c";
+
+            using (var registeredInstallLocationOverride = new RegisteredInstallLocationOverride(appExe))
+            {
+                registeredInstallLocationOverride.SetInstallLocation(new (string, string)[] {
+                    (string.Empty, path1),
+                    (arch1, path1),
+                    (arch2, path2)
+                });
+
+                Command.Create(appExe)
+                    .EnableTracingAndCaptureOutputs()
+                    .ApplyRegisteredInstallLocationOverride(registeredInstallLocationOverride)
+                    .DotNetRoot(null)
+                    .Execute()
+                    .Should().HaveFoundDefaultInstallLocationInConfigFile(path1)
+                    .And.HaveFoundArchSpecificInstallLocationInConfigFile(path1, arch1)
+                    .And.HaveFoundArchSpecificInstallLocationInConfigFile(path2, arch2)
+                    .And.HaveUsedGlobalInstallLocation(path2);
+            }
+        }
+
+        [Fact]
+        [SkipOnPlatform(TestPlatforms.Windows, "This test targets the install_location config file which is only used on Linux and macOS.")]
+        public void InstallLocationFile_OnlyFirstLineMayNotSpecifyArchitecture()
+        {
+            var fixture = sharedTestState.PortableAppFixture
+                .Copy();
+
+            var appExe = fixture.TestProject.AppExe;
+            using (var registeredInstallLocationOverride = new RegisteredInstallLocationOverride(appExe))
+            {
+                registeredInstallLocationOverride.SetInstallLocation(new (string, string)[] {
+                    (string.Empty, "a/b/c"),
+                    (string.Empty, "x/y/z"),
+                });
+                Command.Create(appExe)
+                    .EnableTracingAndCaptureOutputs()
+                    .ApplyRegisteredInstallLocationOverride(registeredInstallLocationOverride)
+                    .DotNetRoot(null)
+                    .Execute()
+                    .Should().HaveFoundDefaultInstallLocationInConfigFile("a/b/c")
+                    .And.HaveStdErrContaining($"Only the first line in '{registeredInstallLocationOverride.PathValueOverride}' may not have an architecture prefix.")
+                    .And.HaveUsedConfigFileInstallLocation("a/b/c");
+            }
+        }
+
+        [Fact]
+        [SkipOnPlatform(TestPlatforms.Windows, "This test targets the install_location config file which is only used on Linux and macOS.")]
+        public void InstallLocationFile_ReallyLongInstallPathIsParsedCorrectly()
+        {
+            var fixture = sharedTestState.PortableAppFixture
+                .Copy();
+
+            var appExe = fixture.TestProject.AppExe;
+            using (var registeredInstallLocationOverride = new RegisteredInstallLocationOverride(appExe))
+            {
+                var reallyLongPath =
+                    "reallyreallyreallyreallyreallyreallyreallyreallyreallyreallyreallyreallyreallyreallyreallyreallyreallyreallyreally" +
+                    "reallyreallyreallyreallyreallyreallyreallyreallyreallyreallyreallyreallyreallyreallyreallyreallyreallyreallyreally" +
+                    "reallyreallyreallyreallyreallyreallyreallyreallyreallyreallylongpath";
+                registeredInstallLocationOverride.SetInstallLocation((string.Empty, reallyLongPath));
+
+                Command.Create(appExe)
+                    .EnableTracingAndCaptureOutputs()
+                    .ApplyRegisteredInstallLocationOverride(registeredInstallLocationOverride)
+                    .DotNetRoot(null)
+                    .Execute()
+                    .Should().HaveFoundDefaultInstallLocationInConfigFile(reallyLongPath)
+                    .And.HaveUsedConfigFileInstallLocation(reallyLongPath);
+            }
+        }
+
+        public class SharedTestState : IDisposable
+        {
+            public string BaseDirectory { get; }
+            public TestProjectFixture PortableAppFixture { get; }
+            public RepoDirectoriesProvider RepoDirectories { get; }
+            public string InstallLocation { get; }
+
+            public SharedTestState()
+            {
+                RepoDirectories = new RepoDirectoriesProvider();
+                var fixture = new TestProjectFixture("PortableApp", RepoDirectories);
+                fixture
+                    .EnsureRestored()
+                    // App Host generation is turned off by default on macOS
+                    .PublishProject(extraArgs: "/p:UseAppHost=true");
+
+                PortableAppFixture = fixture;
+                BaseDirectory = Path.GetDirectoryName(PortableAppFixture.SdkDotnet.GreatestVersionHostFxrFilePath);
+            }
+
+            public void Dispose()
+            {
+                PortableAppFixture.Dispose();
+            }
+        }
+    }
+}
diff --git a/src/installer/tests/HostActivation.Tests/MultilevelSDKLookup.cs b/src/installer/tests/HostActivation.Tests/MultilevelSDKLookup.cs
index 97b3387604b623..76d11337c03ab5 100644
--- a/src/installer/tests/HostActivation.Tests/MultilevelSDKLookup.cs
+++ b/src/installer/tests/HostActivation.Tests/MultilevelSDKLookup.cs
@@ -501,7 +501,7 @@ public void SdkMultilevelLookup_RegistryAccess()
 
             using (var registeredInstallLocationOverride = new RegisteredInstallLocationOverride(DotNet.GreatestVersionHostFxrFilePath))
             {
-                registeredInstallLocationOverride.SetInstallLocation(_regDir, RepoDirectories.BuildArchitecture);
+                registeredInstallLocationOverride.SetInstallLocation(new (string, string)[] { (RepoDirectories.BuildArchitecture, _regDir) });
 
                 // Add SDK versions
                 AddAvailableSdkVersions(_regSdkBaseDir, "9999.0.4");
diff --git a/src/installer/tests/HostActivation.Tests/NativeHosting/Nethost.cs b/src/installer/tests/HostActivation.Tests/NativeHosting/Nethost.cs
index 0f18161b026827..0af2ce34774127 100644
--- a/src/installer/tests/HostActivation.Tests/NativeHosting/Nethost.cs
+++ b/src/installer/tests/HostActivation.Tests/NativeHosting/Nethost.cs
@@ -116,7 +116,7 @@ public void GetHostFxrPath_GlobalInstallation(bool explicitLoad, bool useAssembl
             {
                 if (useRegisteredLocation)
                 {
-                    registeredInstallLocationOverride.SetInstallLocation(installLocation, sharedState.RepoDirectories.BuildArchitecture);
+                    registeredInstallLocationOverride.SetInstallLocation((sharedState.RepoDirectories.BuildArchitecture, installLocation));
                 }
 
                 result = Command.Create(sharedState.NativeHostPath, $"{GetHostFxrPath} {explicitLoad} {(useAssemblyPath ? sharedState.TestAssemblyPath : string.Empty)}")
@@ -180,21 +180,32 @@ public void GetHostFxrPath_HostFxrAlreadyLoaded()
 
         [Theory]
         [SkipOnPlatform(TestPlatforms.Windows, "This test targets the install_location config file which is only used on Linux and macOS.")]
-        [InlineData("{0}", true)]
-        [InlineData("{0}\n", true)]
-        [InlineData("{0}\nSome other text", true)]
-        [InlineData("", false)]
-        [InlineData("\n{0}", false)]
-        [InlineData(" {0}", false)]
-        [InlineData("{0} \n", false)]
-        [InlineData("{0} ", false)]
-        public void GetHostFxrPath_InstallLocationFile(string value, bool shouldPass)
+        [InlineData("{0}", false, true)]
+        [InlineData("{0}\n", false, true)]
+        [InlineData("{0}\nSome other text", false, true)]
+        [InlineData("", false, false)]
+        [InlineData("\n{0}", false, false)]
+        [InlineData(" {0}", false, false)]
+        [InlineData("{0} \n", false, false)]
+        [InlineData("{0} ", false, false)]
+        [InlineData("{0}", true, true)]
+        [InlineData("{0}\n", true, true)]
+        [InlineData("{0}\nSome other text", true, true)]
+        [InlineData("", true, false)]
+        [InlineData("\n{0}", true, false)]
+        [InlineData(" {0}", true, false)]
+        [InlineData("{0} \n", true, false)]
+        [InlineData("{0} ", true, false)]
+        public void GetHostFxrPath_InstallLocationFile(string value, bool shouldUseArchSpecificInstallLocation, bool shouldPass)
         {
             string installLocation = Path.Combine(sharedState.ValidInstallRoot, "dotnet");
 
             using (var registeredInstallLocationOverride = new RegisteredInstallLocationOverride(sharedState.NethostPath))
             {
-                File.WriteAllText(registeredInstallLocationOverride.PathValueOverride, string.Format(value, installLocation));
+                if (shouldUseArchSpecificInstallLocation)
+                    registeredInstallLocationOverride.SetInstallLocation((sharedState.RepoDirectories.BuildArchitecture, string.Format(value, installLocation)));
+                else
+                    registeredInstallLocationOverride.SetInstallLocation((string.Empty, string.Format(value, installLocation)));
 
                 CommandResult result = Command.Create(sharedState.NativeHostPath, GetHostFxrPath)
                     .EnableTracingAndCaptureOutputs()
@@ -223,6 +234,94 @@ public void GetHostFxrPath_InstallLocationFile(string value, bool shouldPass)
             }
         }
 
+        [Fact]
+        [SkipOnPlatform(TestPlatforms.Windows, "This test targets the install_location config file which is only used on Linux and macOS.")]
+        public void GetHostFxrPath_GlobalInstallation_HasMoreThanOneDefaultInstallationPath()
+        {
+            string installLocation = Path.Combine(sharedState.ValidInstallRoot, "dotnet");
+            using (var registeredInstallLocationOverride = new RegisteredInstallLocationOverride(sharedState.NethostPath))
+            {
+                registeredInstallLocationOverride.SetInstallLocation(new (string, string)[] {
+                    (string.Empty, installLocation), (string.Empty, installLocation)
+                });
+
+                CommandResult result = Command.Create(sharedState.NativeHostPath, GetHostFxrPath)
+                    .EnableTracingAndCaptureOutputs()
+                    .ApplyRegisteredInstallLocationOverride(registeredInstallLocationOverride)
+                    .EnvironmentVariable( // Redirect the default install location to an invalid location so that it doesn't cause the test to pass 
+                        Constants.TestOnlyEnvironmentVariables.DefaultInstallPath,
+                        sharedState.InvalidInstallRoot)
+                    .DotNetRoot(null)
+                    .Execute();
+
+                result.Should().Pass()
+                    .And.HaveStdErrContaining($"Looking for install_location file in '{registeredInstallLocationOverride.PathValueOverride}'.")
+                    .And.HaveStdErrContaining($"Found install location path '{installLocation}'.")
+                    .And.HaveStdErrContaining($"Only the first line in '{registeredInstallLocationOverride.PathValueOverride}' may not have an architecture prefix.")
+                    .And.HaveStdErrContaining($"Using install location '{installLocation}'.")
+                    .And.HaveStdOutContaining($"hostfxr_path: {sharedState.HostFxrPath}".ToLower());
+            }
+        }
+
+        [Fact]
+        [SkipOnPlatform(TestPlatforms.Windows, "This test targets the install_location config file which is only used on Linux and macOS.")]
+        public void GetHostFxrPath_GlobalInstallation_HasNoDefaultInstallationPath()
+        {
+            string installLocation = Path.Combine(sharedState.ValidInstallRoot, "dotnet");
+            using (var registeredInstallLocationOverride = new RegisteredInstallLocationOverride(sharedState.NethostPath))
+            {
+                registeredInstallLocationOverride.SetInstallLocation(new (string, string)[] {
+                    (sharedState.RepoDirectories.BuildArchitecture, installLocation),
+                    ("someOtherArch", $"{installLocation}/invalid")
+                });
+
+                CommandResult result = Command.Create(sharedState.NativeHostPath, GetHostFxrPath)
+                    .EnableTracingAndCaptureOutputs()
+                    .ApplyRegisteredInstallLocationOverride(registeredInstallLocationOverride)
+                    .EnvironmentVariable( // Redirect the default install location to an invalid location so that it doesn't cause the test to pass 
+                        Constants.TestOnlyEnvironmentVariables.DefaultInstallPath,
+                        sharedState.InvalidInstallRoot)
+                    .DotNetRoot(null)
+                    .Execute();
+
+                result.Should().Pass()
+                    .And.HaveStdErrContaining($"Looking for install_location file in '{registeredInstallLocationOverride.PathValueOverride}'.")
+                    .And.HaveStdErrContaining($"Found architecture-specific install location path: '{installLocation}' ('{sharedState.RepoDirectories.BuildArchitecture.ToLower()}').")
+                    .And.HaveStdErrContaining($"Using install location '{installLocation}'.")
+                    .And.HaveStdOutContaining($"hostfxr_path: {sharedState.HostFxrPath}".ToLower());
+            }
+        }
+
+        [Fact]
+        [SkipOnPlatform(TestPlatforms.Windows, "This test targets the install_location config file which is only used on Linux and macOS.")]
+        public void GetHostFxrPath_GlobalInstallation_ArchitectureSpecificPathIsPickedOverDefaultPath()
+        {
+            string installLocation = Path.Combine(sharedState.ValidInstallRoot, "dotnet");
+            using (var registeredInstallLocationOverride = new RegisteredInstallLocationOverride(sharedState.NethostPath))
+            {
+                registeredInstallLocationOverride.SetInstallLocation(new (string, string)[] {
+                    (string.Empty, $"{installLocation}/a/b/c"),
+                    (sharedState.RepoDirectories.BuildArchitecture, installLocation)
+                });
+
+                CommandResult result = Command.Create(sharedState.NativeHostPath, GetHostFxrPath)
+                    .EnableTracingAndCaptureOutputs()
+                    .ApplyRegisteredInstallLocationOverride(registeredInstallLocationOverride)
+                    .EnvironmentVariable( // Redirect the default install location to an invalid location so that it doesn't cause the test to pass 
+                        Constants.TestOnlyEnvironmentVariables.DefaultInstallPath,
+                        sharedState.InvalidInstallRoot)
+                    .DotNetRoot(null)
+                    .Execute();
+
+                result.Should().Pass()
+                    .And.HaveStdErrContaining($"Looking for install_location file in '{registeredInstallLocationOverride.PathValueOverride}'.")
+                    .And.HaveStdErrContaining($"Found install location path '{installLocation}/a/b/c'.")
+                    .And.HaveStdErrContaining($"Found architecture-specific install location path: '{installLocation}' ('{sharedState.RepoDirectories.BuildArchitecture.ToLower()}').")
+                    .And.HaveStdErrContaining($"Using install location '{installLocation}'.")
+                    .And.HaveStdOutContaining($"hostfxr_path: {sharedState.HostFxrPath}".ToLower());
+            }
+        }
+
         [Fact]
         public void GetHostFxrPath_InvalidParameters()
         {
diff --git a/src/installer/tests/HostActivation.Tests/PortableAppActivation.cs b/src/installer/tests/HostActivation.Tests/PortableAppActivation.cs
index 14060b5e944bfa..a2a0d963e1f094 100644
--- a/src/installer/tests/HostActivation.Tests/PortableAppActivation.cs
+++ b/src/installer/tests/HostActivation.Tests/PortableAppActivation.cs
@@ -257,7 +257,7 @@ public void AppHost_FrameworkDependent_Succeeds()
             Command.Create(appExe)
                 .CaptureStdErr()
                 .CaptureStdOut()
-                .DotNetRoot(builtDotnet)
+                .DotNetRoot(builtDotnet, sharedTestState.RepoDirectories.BuildArchitecture)
                 .MultilevelLookup(false)
                 .Execute()
                 .Should().Pass()
@@ -268,7 +268,7 @@ public void AppHost_FrameworkDependent_Succeeds()
             // Verify running from within the working directory
             Command.Create(appExe)
                 .WorkingDirectory(fixture.TestProject.OutputDirectory)
-                .DotNetRoot(builtDotnet)
+                .DotNetRoot(builtDotnet, sharedTestState.RepoDirectories.BuildArchitecture)
                 .MultilevelLookup(false)
                 .CaptureStdErr()
                 .CaptureStdOut()
@@ -297,10 +297,10 @@ public void AppHost_FrameworkDependent_GlobalLocation_Succeeds(bool useRegistere
 
             using (var registeredInstallLocationOverride = new RegisteredInstallLocationOverride(appExe))
             {
-                string architecture = fixture.CurrentRid.Split('-')[1];
+                string architecture = fixture.RepoDirProvider.BuildArchitecture;
                 if (useRegisteredLocation)
                 {
-                    registeredInstallLocationOverride.SetInstallLocation(builtDotnet, architecture);
+                    registeredInstallLocationOverride.SetInstallLocation(new (string, string)[] { (architecture, builtDotnet) });
                 }
 
                 // Verify running with the default working directory
@@ -357,7 +357,7 @@ public void MissingRuntimeConfig_Fails(bool useAppHost)
             if (useAppHost)
             {
                 command = Command.Create(sharedTestState.MockApp.AppExe)
-                    .DotNetRoot(sharedTestState.BuiltDotNet.BinPath);
+                    .DotNetRoot(sharedTestState.BuiltDotNet.BinPath, sharedTestState.RepoDirectories.BuildArchitecture);
             }
             else
             {
@@ -386,7 +386,7 @@ public void MissingFrameworkInRuntimeConfig_Fails(bool useAppHost)
             if (useAppHost)
             {
                 command = Command.Create(app.AppExe)
-                    .DotNetRoot(sharedTestState.BuiltDotNet.BinPath);
+                    .DotNetRoot(sharedTestState.BuiltDotNet.BinPath, sharedTestState.RepoDirectories.BuildArchitecture);
             }
             else
             {
@@ -540,7 +540,7 @@ public void AppHost_GUI_NoCustomErrorWriter_FrameworkMissing_ErrorReportedInDial
 
                 Command command = Command.Create(appExe)
                     .EnableTracingAndCaptureOutputs()
-                    .DotNetRoot(dotnet.BinPath)
+                    .DotNetRoot(dotnet.BinPath, sharedTestState.RepoDirectories.BuildArchitecture)
                     .MultilevelLookup(false)
                     .Start();
 
diff --git a/src/installer/tests/HostActivation.Tests/RegisteredInstallLocationOverride.cs b/src/installer/tests/HostActivation.Tests/RegisteredInstallLocationOverride.cs
index 7a30c5d6fd08dc..d37cfafe649537 100644
--- a/src/installer/tests/HostActivation.Tests/RegisteredInstallLocationOverride.cs
+++ b/src/installer/tests/HostActivation.Tests/RegisteredInstallLocationOverride.cs
@@ -4,8 +4,10 @@
 using Microsoft.DotNet.Cli.Build.Framework;
 using Microsoft.Win32;
 using System;
+using System.Collections.Generic;
 using System.Diagnostics;
 using System.IO;
+using System.Linq;
 using System.Runtime.InteropServices;
 
 namespace Microsoft.DotNet.CoreSetup.Test.HostActivation
@@ -61,18 +63,24 @@ public RegisteredInstallLocationOverride(string productBinaryPath)
             }
         }
 
-        public void SetInstallLocation(string installLocation, string architecture)
+        public void SetInstallLocation(params (string Architecture, string Path)[] locations)
         {
+            Debug.Assert(locations.Length >= 1);
             if (OperatingSystem.IsWindows())
             {
-                using (RegistryKey dotnetLocationKey = key.CreateSubKey($@"Setup\InstalledVersions\{architecture}"))
+                foreach (var location in locations)
                 {
-                    dotnetLocationKey.SetValue("InstallLocation", installLocation);
+                    using (RegistryKey dotnetLocationKey = key.CreateSubKey($@"Setup\InstalledVersions\{location.Architecture}"))
+                    {
+                        dotnetLocationKey.SetValue("InstallLocation", location.Path);
+                    }
                 }
             }
             else
             {
-                File.WriteAllText(PathValueOverride, installLocation);
+                File.WriteAllText(PathValueOverride, string.Join(Environment.NewLine,
+                    locations.Select(l => string.Format("{0}{1}",
+                        (!string.IsNullOrWhiteSpace(l.Architecture) ? l.Architecture + "=" : ""), l.Path))));
             }
         }
 
diff --git a/src/installer/tests/HostActivation.Tests/StandaloneAppActivation.cs b/src/installer/tests/HostActivation.Tests/StandaloneAppActivation.cs
index b7ec6eb9688916..352abb04f0dc1b 100644
--- a/src/installer/tests/HostActivation.Tests/StandaloneAppActivation.cs
+++ b/src/installer/tests/HostActivation.Tests/StandaloneAppActivation.cs
@@ -204,8 +204,7 @@ public void Running_Publish_Output_Standalone_EXE_With_DOTNET_ROOT_Fails()
             // self-contained layout since a flat layout of the shared framework is not supported.
             Command.Create(appExe)
                 .EnvironmentVariable("COREHOST_TRACE", "1")
-                .EnvironmentVariable("DOTNET_ROOT", newOutDir)
-                .EnvironmentVariable("DOTNET_ROOT(x86)", newOutDir)
+                .DotNetRoot(newOutDir)
                 .CaptureStdErr()
                 .CaptureStdOut()
                 .Execute(fExpectedToFail: true)
diff --git a/src/installer/tests/Microsoft.NET.HostModel.Tests/AppHost.Bundle.Tests/BundledAppWithSubDirs.cs b/src/installer/tests/Microsoft.NET.HostModel.Tests/AppHost.Bundle.Tests/BundledAppWithSubDirs.cs
index 9ede20c516e393..66212592138151 100644
--- a/src/installer/tests/Microsoft.NET.HostModel.Tests/AppHost.Bundle.Tests/BundledAppWithSubDirs.cs
+++ b/src/installer/tests/Microsoft.NET.HostModel.Tests/AppHost.Bundle.Tests/BundledAppWithSubDirs.cs
@@ -126,6 +126,18 @@ public void Bundled_Self_Contained_Targeting50_WithCompression_Throws()
             Assert.Throws<ArgumentException>(()=>BundleHelper.BundleApp(fixture, options, new Version(5, 0)));
         }
 
+        [Fact]
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/54234")]
+        // NOTE: when enabling this test take a look at commented code maked by "ACTIVE ISSUE:" in SharedTestState
+        public void Bundled_Self_Contained_Composite_App_Run_Succeeds()
+        {
+            var fixture = sharedTestState.TestSelfContainedFixtureComposite.Copy();
+            var singleFile = BundleSelfContainedApp(fixture, BundleOptions.None, disableCompression: true);
+
+            // Run the app
+            RunTheApp(singleFile, fixture);
+        }
+
         [InlineData(BundleOptions.None)]
         [InlineData(BundleOptions.BundleNativeBinaries)]
         [InlineData(BundleOptions.BundleAllContent)]
@@ -144,6 +156,7 @@ public class SharedTestState : SharedTestStateBase, IDisposable
             public TestProjectFixture TestFrameworkDependentFixture { get; set; }
             public TestProjectFixture TestSelfContainedFixture { get; set; }
             public TestProjectFixture TestAppWithEmptyFileFixture { get; set; }
+            public TestProjectFixture TestSelfContainedFixtureComposite { get; set; }
 
             public SharedTestState()
             {
@@ -169,6 +182,18 @@ public SharedTestState()
                     .EnsureRestoredForRid(TestAppWithEmptyFileFixture.CurrentRid)
                     .PublishProject(runtime: TestAppWithEmptyFileFixture.CurrentRid,
                                     outputDirectory: BundleHelper.GetPublishPath(TestAppWithEmptyFileFixture));
+
+                TestSelfContainedFixtureComposite = new TestProjectFixture("AppWithSubDirs", RepoDirectories);
+                BundleHelper.AddLongNameContentToAppWithSubDirs(TestSelfContainedFixtureComposite);
+                TestSelfContainedFixtureComposite
+                    .EnsureRestoredForRid(TestSelfContainedFixtureComposite.CurrentRid)
+                    .PublishProject(runtime: TestSelfContainedFixtureComposite.CurrentRid,
+                                    // ACTIVE ISSUE: https://github.com/dotnet/runtime/issues/54234
+                                    //               uncomment extraArgs when fixed.
+                                    outputDirectory: BundleHelper.GetPublishPath(TestSelfContainedFixtureComposite) /*,
+                                    extraArgs: new string[] {
+                                       "/p:PublishReadyToRun=true",
+                                       "/p:PublishReadyToRunComposite=true" } */);
             }
 
             public void Dispose()
@@ -176,6 +201,7 @@ public void Dispose()
                 TestFrameworkDependentFixture.Dispose();
                 TestSelfContainedFixture.Dispose();
                 TestAppWithEmptyFileFixture.Dispose();
+                TestSelfContainedFixtureComposite.Dispose();
             }
         }
     }
diff --git a/src/installer/tests/Microsoft.NET.HostModel.Tests/Microsoft.NET.HostModel.AppHost.Tests/AppHostUpdateTests.cs b/src/installer/tests/Microsoft.NET.HostModel.Tests/Microsoft.NET.HostModel.AppHost.Tests/AppHostUpdateTests.cs
index fc0aedbdfbfd7d..3aa8886babe37d 100644
--- a/src/installer/tests/Microsoft.NET.HostModel.Tests/Microsoft.NET.HostModel.AppHost.Tests/AppHostUpdateTests.cs
+++ b/src/installer/tests/Microsoft.NET.HostModel.Tests/Microsoft.NET.HostModel.AppHost.Tests/AppHostUpdateTests.cs
@@ -12,6 +12,7 @@
 using Xunit;
 using Microsoft.NET.HostModel.AppHost;
 using Microsoft.DotNet.CoreSetup.Test;
+using System.Diagnostics;
 
 namespace Microsoft.NET.HostModel.Tests
 {
@@ -220,6 +221,109 @@ public void CanCreateAppHost()
             }
         }
 
+        [Theory]
+        [PlatformSpecific(TestPlatforms.OSX)]
+        [InlineData("")]
+        [InlineData("dir with spaces")]
+        public void CanCodeSignAppHostOnMacOS(string subdir)
+        {
+            using (TestDirectory testDirectory = TestDirectory.Create(subdir))
+            {
+                string sourceAppHostMock = PrepareAppHostMockFile(testDirectory);
+                File.SetAttributes(sourceAppHostMock, FileAttributes.ReadOnly);
+                string destinationFilePath = Path.Combine(testDirectory.Path, "DestinationAppHost.exe.mock");
+                string appBinaryFilePath = "Test/App/Binary/Path.dll";
+                HostWriter.CreateAppHost(
+                   sourceAppHostMock,
+                   destinationFilePath,
+                   appBinaryFilePath,
+                   windowsGraphicalUserInterface: false,
+                   enableMacOSCodeSign: true);
+
+                const string codesign = @"/usr/bin/codesign";
+                var psi = new ProcessStartInfo()
+                {
+                    Arguments = $"-d \"{destinationFilePath}\"",
+                    FileName = codesign,
+                    RedirectStandardError = true,
+                };
+
+                using (var p = Process.Start(psi))
+                {
+                    p.Start();
+                    p.StandardError.ReadToEnd()
+                        .Should().Contain($"Executable=/private{Path.GetFullPath(destinationFilePath)}");
+                    p.WaitForExit();
+                    // Successfully signed the apphost.
+                    Assert.True(p.ExitCode == 0, $"Expected exit code was '0' but '{codesign}' returned '{p.ExitCode}' instead.");
+                }
+            }
+        }
+
+        [Fact]
+        [PlatformSpecific(TestPlatforms.OSX)]
+        public void ItDoesNotCodeSignAppHostByDefault()
+        {
+            using (TestDirectory testDirectory = TestDirectory.Create())
+            {
+                string sourceAppHostMock = PrepareAppHostMockFile(testDirectory);
+                File.SetAttributes(sourceAppHostMock, FileAttributes.ReadOnly);
+                string destinationFilePath = Path.Combine(testDirectory.Path, "DestinationAppHost.exe.mock");
+                string appBinaryFilePath = "Test/App/Binary/Path.dll";
+                HostWriter.CreateAppHost(
+                   sourceAppHostMock,
+                   destinationFilePath,
+                   appBinaryFilePath,
+                   windowsGraphicalUserInterface: false);
+
+                const string codesign = @"/usr/bin/codesign";
+                var psi = new ProcessStartInfo()
+                {
+                    Arguments = $"-d {destinationFilePath}",
+                    FileName = codesign,
+                    RedirectStandardError = true,
+                };
+
+                using (var p = Process.Start(psi))
+                {
+                    p.Start();
+                    p.StandardError.ReadToEnd()
+                        .Should().Contain($"{Path.GetFullPath(destinationFilePath)}: code object is not signed at all");
+                    p.WaitForExit();
+                }
+            }
+        }
+
+        [Fact]
+        [PlatformSpecific(TestPlatforms.OSX)]
+        public void CodeSigningFailuresThrow()
+        {
+            using (TestDirectory testDirectory = TestDirectory.Create())
+            {
+                string sourceAppHostMock = PrepareAppHostMockFile(testDirectory);
+                File.SetAttributes(sourceAppHostMock, FileAttributes.ReadOnly);
+                string destinationFilePath = Path.Combine(testDirectory.Path, "DestinationAppHost.exe.mock");
+                string appBinaryFilePath = "Test/App/Binary/Path.dll";
+                HostWriter.CreateAppHost(
+                   sourceAppHostMock,
+                   destinationFilePath,
+                   appBinaryFilePath,
+                   windowsGraphicalUserInterface: false,
+                   enableMacOSCodeSign: true);
+
+                // Run CreateAppHost again to sign the apphost a second time,
+                // causing codesign to fail.
+                var exception = Assert.Throws<AppHostSigningException>(() =>
+                    HostWriter.CreateAppHost(
+                    sourceAppHostMock,
+                    destinationFilePath,
+                    appBinaryFilePath,
+                    windowsGraphicalUserInterface: false,
+                    enableMacOSCodeSign: true));
+                Assert.Contains($"{destinationFilePath}: is already signed", exception.Message);
+            }
+        }
+
         private string PrepareAppHostMockFile(TestDirectory testDirectory, Action<byte[]> customize = null)
         {
             // For now we're testing the AppHost on Windows PE files only.
@@ -334,11 +438,12 @@ private TestDirectory(string path)
                 Directory.CreateDirectory(path);
             }
 
-            public static TestDirectory Create([CallerMemberName] string callingMethod = "")
+            public static TestDirectory Create([CallerMemberName] string callingMethod = "", string subDir = "")
             {
                 string path = System.IO.Path.Combine(
                     System.IO.Path.GetTempPath(),
-                    "dotNetSdkUnitTest_" + callingMethod + (Guid.NewGuid().ToString().Substring(0, 8)));
+                    "dotNetSdkUnitTest_" + callingMethod + (Guid.NewGuid().ToString().Substring(0, 8)),
+                    subDir);
                 return new TestDirectory(path);
             }
 
diff --git a/src/installer/tests/TestUtils/TestProjectFixture.cs b/src/installer/tests/TestUtils/TestProjectFixture.cs
index 2ccce4dded1558..7b9da29d1a908e 100644
--- a/src/installer/tests/TestUtils/TestProjectFixture.cs
+++ b/src/installer/tests/TestUtils/TestProjectFixture.cs
@@ -358,7 +358,7 @@ public TestProjectFixture RestoreProject(string[] fallbackSources, string extraM
 
         public TestProjectFixture EnsureRestored(params string[] fallbackSources)
         {
-            if ( ! TestProject.IsRestored())
+            if (!TestProject.IsRestored())
             {
                 RestoreProject(fallbackSources);
             }
@@ -368,7 +368,7 @@ public TestProjectFixture EnsureRestored(params string[] fallbackSources)
 
         public TestProjectFixture EnsureRestoredForRid(string rid, params string[] fallbackSources)
         {
-            if ( ! TestProject.IsRestored())
+            if (!TestProject.IsRestored())
             {
                 string extraMSBuildProperties = $"/p:TestTargetRid={rid}";
                 RestoreProject(fallbackSources, extraMSBuildProperties);
diff --git a/src/libraries/Common/src/Interop/Android/System.Security.Cryptography.Native.Android/Interop.Hmac.cs b/src/libraries/Common/src/Interop/Android/System.Security.Cryptography.Native.Android/Interop.Hmac.cs
index f3329463321360..38ed53453b6760 100644
--- a/src/libraries/Common/src/Interop/Android/System.Security.Cryptography.Native.Android/Interop.Hmac.cs
+++ b/src/libraries/Common/src/Interop/Android/System.Security.Cryptography.Native.Android/Interop.Hmac.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Diagnostics;
 using System.Runtime.InteropServices;
 using Microsoft.Win32.SafeHandles;
 
@@ -29,5 +30,29 @@ internal static int HmacUpdate(SafeHmacCtxHandle ctx, ReadOnlySpan<byte> data, i
 
         [DllImport(Libraries.AndroidCryptoNative, EntryPoint = "CryptoNative_HmacCurrent")]
         internal static extern int HmacCurrent(SafeHmacCtxHandle ctx, ref byte data, ref int len);
+
+        [DllImport(Libraries.AndroidCryptoNative, EntryPoint = "CryptoNative_HmacOneShot")]
+        private static unsafe extern int HmacOneShot(IntPtr type, byte* key, int keySize, byte* source, int sourceSize, byte* md, ref int mdSize);
+
+        internal static unsafe int HmacOneShot(IntPtr type, ReadOnlySpan<byte> key, ReadOnlySpan<byte> source, Span<byte> destination)
+        {
+            int size = destination.Length;
+            const int Success = 1;
+
+            fixed (byte* pKey = key)
+            fixed (byte* pSource = source)
+            fixed (byte* pDestination = destination)
+            {
+                int result = HmacOneShot(type, pKey, key.Length, pSource, source.Length, pDestination, ref size);
+
+                if (result != Success)
+                {
+                    Debug.Assert(result == 0);
+                    throw CreateOpenSslCryptographicException();
+                }
+            }
+
+            return size;
+        }
     }
 }
diff --git a/src/libraries/Common/src/Interop/Android/System.Security.Cryptography.Native.Android/Interop.Ssl.cs b/src/libraries/Common/src/Interop/Android/System.Security.Cryptography.Native.Android/Interop.Ssl.cs
index bf558daead9342..762d352a6f63a3 100644
--- a/src/libraries/Common/src/Interop/Android/System.Security.Cryptography.Native.Android/Interop.Ssl.cs
+++ b/src/libraries/Common/src/Interop/Android/System.Security.Cryptography.Native.Android/Interop.Ssl.cs
@@ -17,6 +17,8 @@ internal static partial class Interop
 {
     internal static partial class AndroidCrypto
     {
+        private const int UNSUPPORTED_API_LEVEL = 2;
+
         internal unsafe delegate PAL_SSLStreamStatus SSLReadCallback(byte* data, int* length);
         internal unsafe delegate void SSLWriteCallback(byte* data, int length);
 
@@ -77,7 +79,9 @@ internal static void SSLStreamSetTargetHost(
             string targetHost)
         {
             int ret = SSLStreamSetTargetHostImpl(sslHandle, targetHost);
-            if (ret != SUCCESS)
+            if (ret == UNSUPPORTED_API_LEVEL)
+                throw new PlatformNotSupportedException(SR.net_android_ssl_api_level_unsupported);
+            else if (ret != SUCCESS)
                 throw new SslException();
         }
 
diff --git a/src/libraries/Common/src/Interop/BSD/System.Native/Interop.Sysctl.cs b/src/libraries/Common/src/Interop/BSD/System.Native/Interop.Sysctl.cs
index f524faae9c38eb..de201f9e546e27 100644
--- a/src/libraries/Common/src/Interop/BSD/System.Native/Interop.Sysctl.cs
+++ b/src/libraries/Common/src/Interop/BSD/System.Native/Interop.Sysctl.cs
@@ -35,8 +35,9 @@ private static unsafe void Sysctl(int* name, int name_len, ref byte* value, ref
         {
             IntPtr bytesLength = (IntPtr)len;
             int ret = -1;
+            bool autoSize = (value == null && len == 0);
 
-            if (value == null && len == 0)
+            if (autoSize)
             {
                 // do one try to see how much data we need
                 ret = Sysctl(name, name_len, value, &bytesLength);
@@ -48,8 +49,33 @@ private static unsafe void Sysctl(int* name, int name_len, ref byte* value, ref
             }
 
             ret = Sysctl(name, name_len, value, &bytesLength);
+            while (autoSize && ret != 0 && GetLastErrorInfo().Error == Error.ENOMEM)
+            {
+                // Do not use ReAllocHGlobal() here: we don't care about
+                // previous contents, and proper checking of value returned
+                // will make code more complex.
+                Marshal.FreeHGlobal((IntPtr)value);
+                if ((int)bytesLength == int.MaxValue)
+                {
+                    throw new OutOfMemoryException();
+                }
+                if ((int)bytesLength >= int.MaxValue / 2)
+                {
+                    bytesLength = (IntPtr)int.MaxValue;
+                }
+                else
+                {
+                    bytesLength = (IntPtr)((int)bytesLength * 2);
+                }
+                value = (byte*)Marshal.AllocHGlobal(bytesLength);
+                ret = Sysctl(name, name_len, value, &bytesLength);
+            }
             if (ret != 0)
             {
+                if (autoSize)
+                {
+                    Marshal.FreeHGlobal((IntPtr)value);
+                }
                 throw new InvalidOperationException(SR.Format(SR.InvalidSysctl, *name, Marshal.GetLastWin32Error()));
             }
 
diff --git a/src/libraries/Common/src/Interop/Interop.Brotli.cs b/src/libraries/Common/src/Interop/Interop.Brotli.cs
index 8052172838a8e5..a817bb971e2630 100644
--- a/src/libraries/Common/src/Interop/Interop.Brotli.cs
+++ b/src/libraries/Common/src/Interop/Interop.Brotli.cs
@@ -19,32 +19,32 @@ internal static extern unsafe int BrotliDecoderDecompressStream(
             ref nuint availableOut, byte** nextOut, out nuint totalOut);
 
         [DllImport(Libraries.CompressionNative)]
-        internal static extern unsafe bool BrotliDecoderDecompress(nuint availableInput, byte* inBytes, ref nuint availableOutput, byte* outBytes);
+        internal static extern unsafe BOOL BrotliDecoderDecompress(nuint availableInput, byte* inBytes, nuint* availableOutput, byte* outBytes);
 
         [DllImport(Libraries.CompressionNative)]
         internal static extern void BrotliDecoderDestroyInstance(IntPtr state);
 
         [DllImport(Libraries.CompressionNative)]
-        internal static extern bool BrotliDecoderIsFinished(SafeBrotliDecoderHandle state);
+        internal static extern BOOL BrotliDecoderIsFinished(SafeBrotliDecoderHandle state);
 
         [DllImport(Libraries.CompressionNative)]
         internal static extern SafeBrotliEncoderHandle BrotliEncoderCreateInstance(IntPtr allocFunc, IntPtr freeFunc, IntPtr opaque);
 
         [DllImport(Libraries.CompressionNative)]
-        internal static extern bool BrotliEncoderSetParameter(SafeBrotliEncoderHandle state, BrotliEncoderParameter parameter, uint value);
+        internal static extern BOOL BrotliEncoderSetParameter(SafeBrotliEncoderHandle state, BrotliEncoderParameter parameter, uint value);
 
         [DllImport(Libraries.CompressionNative)]
-        internal static extern unsafe bool BrotliEncoderCompressStream(
+        internal static extern unsafe BOOL BrotliEncoderCompressStream(
             SafeBrotliEncoderHandle state, BrotliEncoderOperation op, ref nuint availableIn,
             byte** nextIn, ref nuint availableOut, byte** nextOut, out nuint totalOut);
 
         [DllImport(Libraries.CompressionNative)]
-        internal static extern bool BrotliEncoderHasMoreOutput(SafeBrotliEncoderHandle state);
+        internal static extern BOOL BrotliEncoderHasMoreOutput(SafeBrotliEncoderHandle state);
 
         [DllImport(Libraries.CompressionNative)]
         internal static extern void BrotliEncoderDestroyInstance(IntPtr state);
 
         [DllImport(Libraries.CompressionNative)]
-        internal static extern unsafe bool BrotliEncoderCompress(int quality, int window, int v, nuint availableInput, byte* inBytes, ref nuint availableOutput, byte* outBytes);
+        internal static extern unsafe BOOL BrotliEncoderCompress(int quality, int window, int v, nuint availableInput, byte* inBytes, nuint* availableOutput, byte* outBytes);
     }
 }
diff --git a/src/libraries/Common/src/Interop/Interop.zlib.cs b/src/libraries/Common/src/Interop/Interop.zlib.cs
index ad517da4079ca2..55678c46dca151 100644
--- a/src/libraries/Common/src/Interop/Interop.zlib.cs
+++ b/src/libraries/Common/src/Interop/Interop.zlib.cs
@@ -9,8 +9,8 @@ internal static partial class Interop
     internal static partial class zlib
     {
         [DllImport(Libraries.CompressionNative, EntryPoint = "CompressionNative_DeflateInit2_")]
-        internal static extern ZLibNative.ErrorCode DeflateInit2_(
-            ref ZLibNative.ZStream stream,
+        internal static extern unsafe ZLibNative.ErrorCode DeflateInit2_(
+            ZLibNative.ZStream* stream,
             ZLibNative.CompressionLevel level,
             ZLibNative.CompressionMethod method,
             int windowBits,
@@ -18,25 +18,25 @@ internal static extern ZLibNative.ErrorCode DeflateInit2_(
             ZLibNative.CompressionStrategy strategy);
 
         [DllImport(Libraries.CompressionNative, EntryPoint = "CompressionNative_Deflate")]
-        internal static extern ZLibNative.ErrorCode Deflate(ref ZLibNative.ZStream stream, ZLibNative.FlushCode flush);
+        internal static extern unsafe ZLibNative.ErrorCode Deflate(ZLibNative.ZStream* stream, ZLibNative.FlushCode flush);
 
         [DllImport(Libraries.CompressionNative, EntryPoint = "CompressionNative_DeflateReset")]
-        internal static extern ZLibNative.ErrorCode DeflateReset(ref ZLibNative.ZStream stream);
+        internal static extern unsafe ZLibNative.ErrorCode DeflateReset(ZLibNative.ZStream* stream);
 
         [DllImport(Libraries.CompressionNative, EntryPoint = "CompressionNative_DeflateEnd")]
-        internal static extern ZLibNative.ErrorCode DeflateEnd(ref ZLibNative.ZStream stream);
+        internal static extern unsafe ZLibNative.ErrorCode DeflateEnd(ZLibNative.ZStream* stream);
 
         [DllImport(Libraries.CompressionNative, EntryPoint = "CompressionNative_InflateInit2_")]
-        internal static extern ZLibNative.ErrorCode InflateInit2_(ref ZLibNative.ZStream stream, int windowBits);
+        internal static extern unsafe ZLibNative.ErrorCode InflateInit2_(ZLibNative.ZStream* stream, int windowBits);
 
         [DllImport(Libraries.CompressionNative, EntryPoint = "CompressionNative_Inflate")]
-        internal static extern ZLibNative.ErrorCode Inflate(ref ZLibNative.ZStream stream, ZLibNative.FlushCode flush);
+        internal static extern unsafe ZLibNative.ErrorCode Inflate(ZLibNative.ZStream* stream, ZLibNative.FlushCode flush);
 
         [DllImport(Libraries.CompressionNative, EntryPoint = "CompressionNative_InflateReset")]
-        internal static extern ZLibNative.ErrorCode InflateReset(ref ZLibNative.ZStream stream);
+        internal static extern unsafe ZLibNative.ErrorCode InflateReset(ZLibNative.ZStream* stream);
 
         [DllImport(Libraries.CompressionNative, EntryPoint = "CompressionNative_InflateEnd")]
-        internal static extern ZLibNative.ErrorCode InflateEnd(ref ZLibNative.ZStream stream);
+        internal static extern unsafe ZLibNative.ErrorCode InflateEnd(ZLibNative.ZStream* stream);
 
         [DllImport(Libraries.CompressionNative, EntryPoint = "CompressionNative_Crc32")]
         internal static extern unsafe uint crc32(uint crc, byte* buffer, int len);
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 9898f5821289cf..7cedae49e54724 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
@@ -35,6 +35,17 @@ internal static int HmacCurrent(SafeHmacHandle ctx, ReadOnlySpan<byte> output) =
 
         [DllImport(Libraries.AppleCryptoNative, EntryPoint = "AppleCryptoNative_HmacCurrent")]
         private static extern int HmacCurrent(SafeHmacHandle ctx, ref byte pbOutput, int cbOutput);
+
+        [DllImport(Libraries.AppleCryptoNative, EntryPoint = "AppleCryptoNative_HmacOneShot")]
+        internal static unsafe extern int HmacOneShot(
+            PAL_HashAlgorithm algorithm,
+            byte* pKey,
+            int cbKey,
+            byte* pData,
+            int cbData,
+            byte* pOutput,
+            int cbOutput,
+            out int cbDigest);
     }
 }
 
diff --git a/src/libraries/Common/src/Interop/OSX/System.Security.Cryptography.Native.Apple/Interop.X509.cs b/src/libraries/Common/src/Interop/OSX/System.Security.Cryptography.Native.Apple/Interop.X509.cs
index d50ca014c4e3a9..b7a8be1ba8a7c6 100644
--- a/src/libraries/Common/src/Interop/OSX/System.Security.Cryptography.Native.Apple/Interop.X509.cs
+++ b/src/libraries/Common/src/Interop/OSX/System.Security.Cryptography.Native.Apple/Interop.X509.cs
@@ -20,6 +20,11 @@ private static extern int AppleCryptoNative_X509GetRawData(
             out SafeCFDataHandle cfDataOut,
             out int pOSStatus);
 
+        [DllImport(Libraries.AppleCryptoNative)]
+        private static extern int AppleCryptoNative_X509GetSubjectSummary(
+            SafeSecCertificateHandle cert,
+            out SafeCFStringHandle cfSubjectSummaryOut);
+
         [DllImport(Libraries.AppleCryptoNative)]
         private static extern int AppleCryptoNative_X509GetPublicKey(SafeSecCertificateHandle cert, out SafeSecKeyRefHandle publicKey, out int pOSStatus);
 
@@ -55,14 +60,42 @@ internal static byte[] X509GetRawData(SafeSecCertificateHandle cert)
                 out data,
                 out osStatus);
 
-            if (ret == 1)
+            using (data)
             {
-                return CoreFoundation.CFGetData(data);
+                if (ret == 1)
+                {
+                    return CoreFoundation.CFGetData(data);
+                }
+
+                if (ret == 0)
+                {
+                    throw CreateExceptionForOSStatus(osStatus);
+                }
+
+                Debug.Fail($"Unexpected return value {ret}");
+                throw new CryptographicException();
+            }
+        }
+
+        internal static string? X509GetSubjectSummary(SafeSecCertificateHandle cert)
+        {
+            SafeCFStringHandle subjectSummary;
+
+            int ret = AppleCryptoNative_X509GetSubjectSummary(
+                cert,
+                out subjectSummary);
+
+            using (subjectSummary)
+            {
+                if (ret == 1)
+                {
+                    return CoreFoundation.CFStringToString(subjectSummary);
+                }
             }
 
             if (ret == 0)
             {
-                throw CreateExceptionForOSStatus(osStatus);
+                return null;
             }
 
             Debug.Fail($"Unexpected return value {ret}");
diff --git a/src/libraries/Common/src/Interop/Unix/System.Native/Interop.IOVector.cs b/src/libraries/Common/src/Interop/Unix/System.Native/Interop.IOVector.cs
new file mode 100644
index 00000000000000..9cbf1ee2c34785
--- /dev/null
+++ b/src/libraries/Common/src/Interop/Unix/System.Native/Interop.IOVector.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 System;
+
+internal static partial class Interop
+{
+    internal static partial class Sys
+    {
+        internal unsafe struct IOVector
+        {
+            public byte* Base;
+            public UIntPtr Count;
+        }
+    }
+}
diff --git a/src/libraries/Common/src/Interop/Unix/System.Native/Interop.MemAlloc.cs b/src/libraries/Common/src/Interop/Unix/System.Native/Interop.MemAlloc.cs
index c5f6d1baa2adb0..cb4a38ff4ea0fb 100644
--- a/src/libraries/Common/src/Interop/Unix/System.Native/Interop.MemAlloc.cs
+++ b/src/libraries/Common/src/Interop/Unix/System.Native/Interop.MemAlloc.cs
@@ -6,15 +6,27 @@
 
 internal static partial class Interop
 {
-    internal static partial class Sys
+    internal static unsafe partial class Sys
     {
-        [DllImport(Interop.Libraries.SystemNative, EntryPoint = "SystemNative_MemAlloc")]
-        internal static extern IntPtr MemAlloc(nuint sizeInBytes);
+        [DllImport(Interop.Libraries.SystemNative, EntryPoint = "SystemNative_AlignedAlloc")]
+        internal static extern void* AlignedAlloc(nuint alignment, nuint size);
 
-        [DllImport(Interop.Libraries.SystemNative, EntryPoint = "SystemNative_MemReAlloc")]
-        internal static extern IntPtr MemReAlloc(IntPtr ptr, nuint newSize);
+        [DllImport(Interop.Libraries.SystemNative, EntryPoint = "SystemNative_AlignedFree")]
+        internal static extern void AlignedFree(void* ptr);
 
-        [DllImport(Interop.Libraries.SystemNative, EntryPoint = "SystemNative_MemFree")]
-        internal static extern void MemFree(IntPtr ptr);
+        [DllImport(Interop.Libraries.SystemNative, EntryPoint = "SystemNative_AlignedRealloc")]
+        internal static extern void* AlignedRealloc(void* ptr, nuint alignment, nuint new_size);
+
+        [DllImport(Interop.Libraries.SystemNative, EntryPoint = "SystemNative_Calloc")]
+        internal static extern void* Calloc(nuint num, nuint size);
+
+        [DllImport(Interop.Libraries.SystemNative, EntryPoint = "SystemNative_Free")]
+        internal static extern void Free(void* ptr);
+
+        [DllImport(Interop.Libraries.SystemNative, EntryPoint = "SystemNative_Malloc")]
+        internal static extern void* Malloc(nuint size);
+
+        [DllImport(Interop.Libraries.SystemNative, EntryPoint = "SystemNative_Realloc")]
+        internal static extern void* Realloc(void* ptr, nuint new_size);
     }
 }
diff --git a/src/libraries/Common/src/Interop/Unix/System.Native/Interop.MessageHeader.cs b/src/libraries/Common/src/Interop/Unix/System.Native/Interop.MessageHeader.cs
index 5e327a64793624..4b71e0e3d37246 100644
--- a/src/libraries/Common/src/Interop/Unix/System.Native/Interop.MessageHeader.cs
+++ b/src/libraries/Common/src/Interop/Unix/System.Native/Interop.MessageHeader.cs
@@ -8,12 +8,6 @@ internal static partial class Interop
 {
     internal static partial class Sys
     {
-        internal unsafe struct IOVector
-        {
-            public byte* Base;
-            public UIntPtr Count;
-        }
-
         internal unsafe struct MessageHeader
         {
             public byte* SocketAddress;
diff --git a/src/libraries/Common/src/Interop/Unix/System.Native/Interop.PRead.cs b/src/libraries/Common/src/Interop/Unix/System.Native/Interop.PRead.cs
new file mode 100644
index 00000000000000..664da015febb2e
--- /dev/null
+++ b/src/libraries/Common/src/Interop/Unix/System.Native/Interop.PRead.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.
+
+using System.Runtime.InteropServices;
+
+internal static partial class Interop
+{
+    internal static partial class Sys
+    {
+        [DllImport(Libraries.SystemNative, EntryPoint = "SystemNative_PRead", SetLastError = true)]
+        internal static extern unsafe int PRead(SafeHandle fd, byte* buffer, int bufferSize, long fileOffset);
+    }
+}
diff --git a/src/libraries/Common/src/Interop/Unix/System.Native/Interop.PReadV.cs b/src/libraries/Common/src/Interop/Unix/System.Native/Interop.PReadV.cs
new file mode 100644
index 00000000000000..5d93078161f05d
--- /dev/null
+++ b/src/libraries/Common/src/Interop/Unix/System.Native/Interop.PReadV.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.
+
+using System.Runtime.InteropServices;
+
+internal static partial class Interop
+{
+    internal static partial class Sys
+    {
+        [DllImport(Libraries.SystemNative, EntryPoint = "SystemNative_PReadV", SetLastError = true)]
+        internal static extern unsafe long PReadV(SafeHandle fd, IOVector* vectors, int vectorCount, long fileOffset);
+    }
+}
diff --git a/src/libraries/Common/src/Interop/Unix/System.Native/Interop.PWrite.cs b/src/libraries/Common/src/Interop/Unix/System.Native/Interop.PWrite.cs
new file mode 100644
index 00000000000000..721a1c8706fd72
--- /dev/null
+++ b/src/libraries/Common/src/Interop/Unix/System.Native/Interop.PWrite.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.
+
+using System.Runtime.InteropServices;
+
+internal static partial class Interop
+{
+    internal static partial class Sys
+    {
+        [DllImport(Libraries.SystemNative, EntryPoint = "SystemNative_PWrite", SetLastError = true)]
+        internal static extern unsafe int PWrite(SafeHandle fd, byte* buffer, int bufferSize, long fileOffset);
+    }
+}
diff --git a/src/libraries/Common/src/Interop/Unix/System.Native/Interop.PWriteV.cs b/src/libraries/Common/src/Interop/Unix/System.Native/Interop.PWriteV.cs
new file mode 100644
index 00000000000000..c17e9964d8fe9a
--- /dev/null
+++ b/src/libraries/Common/src/Interop/Unix/System.Native/Interop.PWriteV.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.
+
+using System.Runtime.InteropServices;
+
+internal static partial class Interop
+{
+    internal static partial class Sys
+    {
+        [DllImport(Libraries.SystemNative, EntryPoint = "SystemNative_PWriteV", SetLastError = true)]
+        internal static extern unsafe long PWriteV(SafeHandle fd, IOVector* vectors, int vectorCount, long fileOffset);
+    }
+}
diff --git a/src/libraries/Common/src/Interop/Unix/System.Security.Cryptography.Native/Interop.Crypto.cs b/src/libraries/Common/src/Interop/Unix/System.Security.Cryptography.Native/Interop.Crypto.cs
index 9e692c79ee1cf4..c1d0d991a0e52f 100644
--- a/src/libraries/Common/src/Interop/Unix/System.Security.Cryptography.Native/Interop.Crypto.cs
+++ b/src/libraries/Common/src/Interop/Unix/System.Security.Cryptography.Native/Interop.Crypto.cs
@@ -68,23 +68,25 @@ internal static int BioTell(SafeBioHandle bio)
         [return: MarshalAs(UnmanagedType.Bool)]
         internal static extern bool PushX509StackField(SafeSharedX509StackHandle stack, SafeX509Handle x509);
 
-        internal static string? GetX509RootStorePath(out bool defaultPath)
+        internal static unsafe string? GetX509RootStorePath(out bool defaultPath)
         {
-            IntPtr ptr = GetX509RootStorePath_private(out byte usedDefault);
+            byte usedDefault;
+            IntPtr ptr = GetX509RootStorePath_private(&usedDefault);
             defaultPath = (usedDefault != 0);
             return Marshal.PtrToStringAnsi(ptr);
         }
 
-        internal static string? GetX509RootStoreFile()
+        internal static unsafe string? GetX509RootStoreFile()
         {
-            return Marshal.PtrToStringAnsi(GetX509RootStoreFile_private(out _));
+            byte unused;
+            return Marshal.PtrToStringAnsi(GetX509RootStoreFile_private(&unused));
         }
 
         [DllImport(Libraries.CryptoNative, EntryPoint = "CryptoNative_GetX509RootStorePath")]
-        private static extern IntPtr GetX509RootStorePath_private(out byte defaultPath);
+        private static unsafe extern IntPtr GetX509RootStorePath_private(byte* defaultPath);
 
         [DllImport(Libraries.CryptoNative, EntryPoint = "CryptoNative_GetX509RootStoreFile")]
-        private static extern IntPtr GetX509RootStoreFile_private(out byte defaultPath);
+        private static unsafe extern IntPtr GetX509RootStoreFile_private(byte* defaultPath);
 
         [DllImport(Libraries.CryptoNative)]
         private static extern int CryptoNative_X509StoreSetVerifyTime(
diff --git a/src/libraries/Common/src/Interop/Unix/System.Security.Cryptography.Native/Interop.Hmac.cs b/src/libraries/Common/src/Interop/Unix/System.Security.Cryptography.Native/Interop.Hmac.cs
index 5638d20ae9d656..6074351cf383ea 100644
--- a/src/libraries/Common/src/Interop/Unix/System.Security.Cryptography.Native/Interop.Hmac.cs
+++ b/src/libraries/Common/src/Interop/Unix/System.Security.Cryptography.Native/Interop.Hmac.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Diagnostics;
 using System.Runtime.InteropServices;
 using Microsoft.Win32.SafeHandles;
 
@@ -29,5 +30,29 @@ internal static int HmacUpdate(SafeHmacCtxHandle ctx, ReadOnlySpan<byte> data, i
 
         [DllImport(Libraries.CryptoNative, EntryPoint = "CryptoNative_HmacCurrent")]
         internal static extern int HmacCurrent(SafeHmacCtxHandle ctx, ref byte data, ref int len);
+
+        [DllImport(Libraries.CryptoNative, EntryPoint = "CryptoNative_HmacOneShot")]
+        private static unsafe extern int HmacOneShot(IntPtr type, byte* key, int keySize, byte* source, int sourceSize, byte* md, ref int mdSize);
+
+        internal static unsafe int HmacOneShot(IntPtr type, ReadOnlySpan<byte> key, ReadOnlySpan<byte> source, Span<byte> destination)
+        {
+            int size = destination.Length;
+            const int Success = 1;
+
+            fixed (byte* pKey = key)
+            fixed (byte* pSource = source)
+            fixed (byte* pDestination = destination)
+            {
+                int result = HmacOneShot(type, pKey, key.Length, pSource, source.Length, pDestination, ref size);
+
+                if (result != Success)
+                {
+                    Debug.Assert(result == 0);
+                    throw CreateOpenSslCryptographicException();
+                }
+            }
+
+            return size;
+        }
     }
 }
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 71ee76ad2a6d0a..42276ab2b045bf 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
@@ -348,7 +348,7 @@ internal static int Encrypt(SafeSslHandle context, ReadOnlySpan<byte> input, ref
             return retVal;
         }
 
-        internal static int Decrypt(SafeSslHandle context, byte[] outBuffer, int offset, int count, out Ssl.SslErrorCode errorCode)
+        internal static int Decrypt(SafeSslHandle context, Span<byte> buffer, out Ssl.SslErrorCode errorCode)
         {
 #if DEBUG
             ulong assertNoError = Crypto.ErrPeekError();
@@ -356,53 +356,33 @@ internal static int Decrypt(SafeSslHandle context, byte[] outBuffer, int offset,
 #endif
             errorCode = Ssl.SslErrorCode.SSL_ERROR_NONE;
 
-            int retVal = BioWrite(context.InputBio!, outBuffer, offset, count);
-            Exception? innerError = null;
+            BioWrite(context.InputBio!, buffer);
 
-            if (retVal == count)
+            int retVal = Ssl.SslRead(context, ref MemoryMarshal.GetReference(buffer), buffer.Length);
+            if (retVal > 0)
             {
-                unsafe
-                {
-                    fixed (byte* fixedBuffer = outBuffer)
-                    {
-                        retVal = Ssl.SslRead(context, fixedBuffer + offset, outBuffer.Length);
-                    }
-                }
-
-                if (retVal > 0)
-                {
-                        count = retVal;
-                }
+                return retVal;
             }
 
-            if (retVal != count)
+            errorCode = GetSslError(context, retVal, out Exception? innerError);
+            switch (errorCode)
             {
-                errorCode = GetSslError(context, retVal, out innerError);
-            }
-
-            if (retVal != count)
-            {
-                retVal = 0;
-
-                switch (errorCode)
-                {
-                    // indicate end-of-file
-                    case Ssl.SslErrorCode.SSL_ERROR_ZERO_RETURN:
-                        break;
+                // indicate end-of-file
+                case Ssl.SslErrorCode.SSL_ERROR_ZERO_RETURN:
+                    break;
 
-                    case Ssl.SslErrorCode.SSL_ERROR_WANT_READ:
-                        // update error code to renegotiate if renegotiate is pending, otherwise make it SSL_ERROR_WANT_READ
-                        errorCode = Ssl.IsSslRenegotiatePending(context) ?
-                                    Ssl.SslErrorCode.SSL_ERROR_RENEGOTIATE :
-                                    Ssl.SslErrorCode.SSL_ERROR_WANT_READ;
-                        break;
+                case Ssl.SslErrorCode.SSL_ERROR_WANT_READ:
+                    // update error code to renegotiate if renegotiate is pending, otherwise make it SSL_ERROR_WANT_READ
+                    errorCode = Ssl.IsSslRenegotiatePending(context) ?
+                                Ssl.SslErrorCode.SSL_ERROR_RENEGOTIATE :
+                                Ssl.SslErrorCode.SSL_ERROR_WANT_READ;
+                    break;
 
-                    default:
-                        throw new SslException(SR.Format(SR.net_ssl_decrypt_failed, errorCode), innerError);
-                }
+                default:
+                    throw new SslException(SR.Format(SR.net_ssl_decrypt_failed, errorCode), innerError);
             }
 
-            return retVal;
+            return 0;
         }
 
         internal static SafeX509Handle GetPeerCertificate(SafeSslHandle context)
@@ -507,27 +487,13 @@ private static int BioRead(SafeBioHandle bio, byte[] buffer, int count)
             return bytes;
         }
 
-        private static int BioWrite(SafeBioHandle bio, byte[] buffer, int offset, int count)
+        private static void BioWrite(SafeBioHandle bio, ReadOnlySpan<byte> buffer)
         {
-            Debug.Assert(buffer != null);
-            Debug.Assert(offset >= 0);
-            Debug.Assert(count >= 0);
-            Debug.Assert(buffer.Length >= offset + count);
-
-            int bytes;
-            unsafe
-            {
-                fixed (byte* bufPtr = buffer)
-                {
-                    bytes = Ssl.BioWrite(bio, bufPtr + offset, count);
-                }
-            }
-
-            if (bytes != count)
+            int bytes = Ssl.BioWrite(bio, ref MemoryMarshal.GetReference(buffer), buffer.Length);
+            if (bytes != buffer.Length)
             {
                 throw CreateSslException(SR.net_ssl_write_bio_failed_error);
             }
-            return bytes;
         }
 
         private static Ssl.SslErrorCode GetSslError(SafeSslHandle context, int result, out Exception? innerError)
diff --git a/src/libraries/Common/src/Interop/Unix/System.Security.Cryptography.Native/Interop.Ssl.cs b/src/libraries/Common/src/Interop/Unix/System.Security.Cryptography.Native/Interop.Ssl.cs
index 057e4dc8279a42..d080cf2f0d7b41 100644
--- a/src/libraries/Common/src/Interop/Unix/System.Security.Cryptography.Native/Interop.Ssl.cs
+++ b/src/libraries/Common/src/Interop/Unix/System.Security.Cryptography.Native/Interop.Ssl.cs
@@ -72,7 +72,7 @@ internal static partial class Ssl
         internal static extern int SslWrite(SafeSslHandle ssl, ref byte buf, int num);
 
         [DllImport(Libraries.CryptoNative, EntryPoint = "CryptoNative_SslRead", SetLastError = true)]
-        internal static extern unsafe int SslRead(SafeSslHandle ssl, byte* buf, int num);
+        internal static extern int SslRead(SafeSslHandle ssl, ref byte buf, int num);
 
         [DllImport(Libraries.CryptoNative, EntryPoint = "CryptoNative_IsSslRenegotiatePending")]
         [return: MarshalAs(UnmanagedType.Bool)]
diff --git a/src/libraries/Common/src/Interop/Windows/BCrypt/AEADBCryptHandles.cs b/src/libraries/Common/src/Interop/Windows/BCrypt/AEADBCryptHandles.cs
deleted file mode 100644
index a05c5ae962d4a3..00000000000000
--- a/src/libraries/Common/src/Interop/Windows/BCrypt/AEADBCryptHandles.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.
-
-using System;
-using System.Security.Cryptography;
-using System.Threading;
-using Internal.NativeCrypto;
-
-namespace Internal.Cryptography
-{
-    internal static class AeadBCryptHandles
-    {
-        private static SafeAlgorithmHandle? s_aesCcm;
-        private static SafeAlgorithmHandle? s_aesGcm;
-        private static SafeAlgorithmHandle? s_chaCha20Poly1305;
-
-        internal static SafeAlgorithmHandle AesCcm => GetCachedAlgorithmHandle(ref s_aesCcm, Cng.BCRYPT_AES_ALGORITHM, Cng.BCRYPT_CHAIN_MODE_CCM);
-        internal static SafeAlgorithmHandle AesGcm => GetCachedAlgorithmHandle(ref s_aesGcm, Cng.BCRYPT_AES_ALGORITHM, Cng.BCRYPT_CHAIN_MODE_GCM);
-
-        internal static bool IsChaCha20Poly1305Supported { get; } = OperatingSystem.IsWindowsVersionAtLeast(10, 0, 20142);
-        internal static SafeAlgorithmHandle ChaCha20Poly1305 => GetCachedAlgorithmHandle(ref s_chaCha20Poly1305, Cng.BCRYPT_CHACHA20_POLY1305_ALGORITHM);
-
-        private static SafeAlgorithmHandle GetCachedAlgorithmHandle(ref SafeAlgorithmHandle? handle, string algId, string? chainingMode = null)
-        {
-            // Do we already have a handle to this algorithm?
-            SafeAlgorithmHandle? existingHandle = Volatile.Read(ref handle);
-            if (existingHandle != null) { return existingHandle; }
-
-            // No cached handle exists; create a new handle. It's ok if multiple threads call
-            // this concurrently. Only one handle will "win" and the rest will be destroyed.
-            SafeAlgorithmHandle newHandle = Cng.BCryptOpenAlgorithmProvider(algId, null, Cng.OpenAlgorithmProviderFlags.NONE);
-            if (chainingMode != null)
-            {
-                newHandle.SetCipherMode(chainingMode);
-            }
-
-            existingHandle = Interlocked.CompareExchange(ref handle, newHandle, null);
-            if (existingHandle != null)
-            {
-                newHandle.Dispose();
-                return existingHandle;
-            }
-            else
-            {
-                return newHandle;
-            }
-        }
-    }
-}
diff --git a/src/libraries/Common/src/Interop/Windows/BCrypt/Interop.BCryptAlgPseudoHandle.cs b/src/libraries/Common/src/Interop/Windows/BCrypt/Interop.BCryptAlgPseudoHandle.cs
index 9886f2b8f49218..433e6f515dca97 100644
--- a/src/libraries/Common/src/Interop/Windows/BCrypt/Interop.BCryptAlgPseudoHandle.cs
+++ b/src/libraries/Common/src/Interop/Windows/BCrypt/Interop.BCryptAlgPseudoHandle.cs
@@ -17,6 +17,11 @@ public enum BCryptAlgPseudoHandle : uint
             BCRYPT_SHA256_ALG_HANDLE = 0x00000041,
             BCRYPT_SHA384_ALG_HANDLE = 0x00000051,
             BCRYPT_SHA512_ALG_HANDLE = 0x00000061,
+            BCRYPT_HMAC_MD5_ALG_HANDLE = 0x00000091,
+            BCRYPT_HMAC_SHA1_ALG_HANDLE = 0x000000a1,
+            BCRYPT_HMAC_SHA256_ALG_HANDLE = 0x000000b1,
+            BCRYPT_HMAC_SHA384_ALG_HANDLE = 0x000000c1,
+            BCRYPT_HMAC_SHA512_ALG_HANDLE = 0x000000d1,
             BCRYPT_PBKDF2_ALG_HANDLE = 0x00000331,
         }
 
diff --git a/src/libraries/Common/src/Interop/Windows/Crypt32/Interop.CryptProtectData.cs b/src/libraries/Common/src/Interop/Windows/Crypt32/Interop.CryptProtectData.cs
index bf6cc60b985033..6fab3a93fad5f4 100644
--- a/src/libraries/Common/src/Interop/Windows/Crypt32/Interop.CryptProtectData.cs
+++ b/src/libraries/Common/src/Interop/Windows/Crypt32/Interop.CryptProtectData.cs
@@ -13,7 +13,7 @@ internal static partial class Crypt32
         [return: MarshalAs(UnmanagedType.Bool)]
         internal static extern bool CryptProtectData(
                   [In] ref DATA_BLOB pDataIn,
-                  [In] string szDataDescr,
+                  [In] string? szDataDescr,
                   [In] ref DATA_BLOB pOptionalEntropy,
                   [In] IntPtr pvReserved,
                   [In] IntPtr pPromptStruct,
diff --git a/src/libraries/Common/src/Interop/Windows/Interop.Libraries.cs b/src/libraries/Common/src/Interop/Windows/Interop.Libraries.cs
index d3466d74a12edf..93c2bb72a806c4 100644
--- a/src/libraries/Common/src/Interop/Windows/Interop.Libraries.cs
+++ b/src/libraries/Common/src/Interop/Windows/Interop.Libraries.cs
@@ -44,5 +44,6 @@ internal static partial class Libraries
         internal const string GlobalizationNative = "System.Globalization.Native";
         internal const string MsQuic = "msquic.dll";
         internal const string HostPolicy = "hostpolicy.dll";
+        internal const string Ucrtbase = "ucrtbase.dll";
     }
 }
diff --git a/src/libraries/Common/src/Interop/Windows/Kernel32/Interop.FILE_ALLOCATION_INFO.cs b/src/libraries/Common/src/Interop/Windows/Kernel32/Interop.FILE_ALLOCATION_INFO.cs
new file mode 100644
index 00000000000000..0233626ee73c62
--- /dev/null
+++ b/src/libraries/Common/src/Interop/Windows/Kernel32/Interop.FILE_ALLOCATION_INFO.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.
+
+internal static partial class Interop
+{
+    internal static partial class Kernel32
+    {
+        // Value taken from https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-setfileinformationbyhandle#remarks:
+        internal const int FileAllocationInfo = 5;
+
+        internal struct FILE_ALLOCATION_INFO
+        {
+            internal long AllocationSize;
+        }
+    }
+}
diff --git a/src/libraries/Common/src/Interop/Windows/Kernel32/Interop.FileScatterGather.cs b/src/libraries/Common/src/Interop/Windows/Kernel32/Interop.FileScatterGather.cs
new file mode 100644
index 00000000000000..8e61970c3c2424
--- /dev/null
+++ b/src/libraries/Common/src/Interop/Windows/Kernel32/Interop.FileScatterGather.cs
@@ -0,0 +1,28 @@
+// 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;
+using System.Threading;
+
+internal static partial class Interop
+{
+    internal static partial class Kernel32
+    {
+        [DllImport(Libraries.Kernel32, SetLastError = true)]
+        internal static extern unsafe int ReadFileScatter(
+            SafeHandle hFile,
+            long* aSegmentArray,
+            int nNumberOfBytesToRead,
+            IntPtr lpReserved,
+            NativeOverlapped* lpOverlapped);
+
+        [DllImport(Libraries.Kernel32, SetLastError = true)]
+        internal static extern unsafe int WriteFileGather(
+            SafeHandle hFile,
+            long* aSegmentArray,
+            int nNumberOfBytesToWrite,
+            IntPtr lpReserved,
+            NativeOverlapped* lpOverlapped);
+    }
+}
diff --git a/src/libraries/Common/src/Interop/Windows/Kernel32/Interop.GlobalMemoryStatusEx.cs b/src/libraries/Common/src/Interop/Windows/Kernel32/Interop.GlobalMemoryStatusEx.cs
index a5029f5ccb6e81..662cab8383cc76 100644
--- a/src/libraries/Common/src/Interop/Windows/Kernel32/Interop.GlobalMemoryStatusEx.cs
+++ b/src/libraries/Common/src/Interop/Windows/Kernel32/Interop.GlobalMemoryStatusEx.cs
@@ -8,6 +8,6 @@ internal static partial class Interop
     internal static partial class Kernel32
     {
         [DllImport(Libraries.Kernel32)]
-        internal static extern bool GlobalMemoryStatusEx(ref MEMORYSTATUSEX lpBuffer);
+        internal static unsafe extern BOOL GlobalMemoryStatusEx(MEMORYSTATUSEX* lpBuffer);
     }
 }
diff --git a/src/libraries/Common/src/Interop/Windows/NtDll/Interop.NtCreateFile.cs b/src/libraries/Common/src/Interop/Windows/NtDll/Interop.NtCreateFile.cs
index 9ce82c7f4ad453..7d6ab13b6633d3 100644
--- a/src/libraries/Common/src/Interop/Windows/NtDll/Interop.NtCreateFile.cs
+++ b/src/libraries/Common/src/Interop/Windows/NtDll/Interop.NtCreateFile.cs
@@ -10,18 +10,14 @@ internal static partial class Interop
 {
     internal static partial class NtDll
     {
-        internal const uint NT_ERROR_STATUS_DISK_FULL = 0xC000007F;
-        internal const uint NT_ERROR_STATUS_FILE_TOO_LARGE = 0xC0000904;
-        internal const uint NT_STATUS_INVALID_PARAMETER = 0xC000000D;
-
         // https://msdn.microsoft.com/en-us/library/bb432380.aspx
         // https://msdn.microsoft.com/en-us/library/windows/hardware/ff566424.aspx
         [DllImport(Libraries.NtDll, CharSet = CharSet.Unicode, ExactSpelling = true)]
         private static extern unsafe uint NtCreateFile(
-            out IntPtr FileHandle,
+            IntPtr* FileHandle,
             DesiredAccess DesiredAccess,
-            ref OBJECT_ATTRIBUTES ObjectAttributes,
-            out IO_STATUS_BLOCK IoStatusBlock,
+            OBJECT_ATTRIBUTES* ObjectAttributes,
+            IO_STATUS_BLOCK* IoStatusBlock,
             long* AllocationSize,
             FileAttributes FileAttributes,
             FileShare ShareAccess,
@@ -59,11 +55,13 @@ internal static unsafe (uint status, IntPtr handle) CreateFile(
                     rootDirectory,
                     securityQualityOfService);
 
+                IntPtr handle;
+                IO_STATUS_BLOCK statusBlock;
                 uint status = NtCreateFile(
-                    out IntPtr handle,
+                    &handle,
                     desiredAccess,
-                    ref attributes,
-                    out IO_STATUS_BLOCK statusBlock,
+                    &attributes,
+                    &statusBlock,
                     AllocationSize: preallocationSize,
                     fileAttributes,
                     shareAccess,
@@ -76,7 +74,7 @@ internal static unsafe (uint status, IntPtr handle) CreateFile(
             }
         }
 
-        internal static unsafe (uint status, IntPtr handle) CreateFile(ReadOnlySpan<char> path, FileMode mode, FileAccess access, FileShare share, FileOptions options, long preallocationSize)
+        internal static unsafe (uint status, IntPtr handle) NtCreateFile(ReadOnlySpan<char> path, FileMode mode, FileAccess access, FileShare share, FileOptions options, long preallocationSize)
         {
             // For mitigating local elevation of privilege attack through named pipes
             // make sure we always call NtCreateFile with SECURITY_ANONYMOUS so that the
@@ -120,7 +118,7 @@ private static CreateDisposition GetCreateDisposition(FileMode mode)
 
         private static DesiredAccess GetDesiredAccess(FileAccess access, FileMode fileMode, FileOptions options)
         {
-            DesiredAccess result = 0;
+            DesiredAccess result = DesiredAccess.FILE_READ_ATTRIBUTES | DesiredAccess.SYNCHRONIZE; // default values used by CreateFileW
 
             if ((access & FileAccess.Read) != 0)
             {
@@ -134,13 +132,9 @@ private static DesiredAccess GetDesiredAccess(FileAccess access, FileMode fileMo
             {
                 result |= DesiredAccess.FILE_APPEND_DATA;
             }
-            if ((options & FileOptions.Asynchronous) == 0)
-            {
-                result |= DesiredAccess.SYNCHRONIZE; // required by FILE_SYNCHRONOUS_IO_NONALERT
-            }
-            if ((options & FileOptions.DeleteOnClose) != 0 || fileMode == FileMode.Create)
+            if ((options & FileOptions.DeleteOnClose) != 0)
             {
-                result |= DesiredAccess.DELETE; // required by FILE_DELETE_ON_CLOSE and FILE_SUPERSEDE (which deletes a file if it exists)
+                result |= DesiredAccess.DELETE; // required by FILE_DELETE_ON_CLOSE
             }
 
             return result;
@@ -190,7 +184,8 @@ private static CreateOptions GetCreateOptions(FileOptions options)
         }
 
         private static ObjectAttributes GetObjectAttributes(FileShare share)
-            => (share & FileShare.Inheritable) != 0 ? ObjectAttributes.OBJ_INHERIT : 0;
+            => ObjectAttributes.OBJ_CASE_INSENSITIVE | // default value used by CreateFileW
+                ((share & FileShare.Inheritable) != 0 ? ObjectAttributes.OBJ_INHERIT : 0);
 
         /// <summary>
         /// File creation disposition when calling directly to NT APIs.
diff --git a/src/libraries/Common/src/Interop/Windows/NtDll/Interop.NtQueryDirectoryFile.cs b/src/libraries/Common/src/Interop/Windows/NtDll/Interop.NtQueryDirectoryFile.cs
index 517fd4195f360d..63b6bf9767c24d 100644
--- a/src/libraries/Common/src/Interop/Windows/NtDll/Interop.NtQueryDirectoryFile.cs
+++ b/src/libraries/Common/src/Interop/Windows/NtDll/Interop.NtQueryDirectoryFile.cs
@@ -16,7 +16,7 @@ public static extern unsafe int NtQueryDirectoryFile(
             IntPtr Event,
             IntPtr ApcRoutine,
             IntPtr ApcContext,
-            out IO_STATUS_BLOCK IoStatusBlock,
+            IO_STATUS_BLOCK* IoStatusBlock,
             IntPtr FileInformation,
             uint Length,
             FILE_INFORMATION_CLASS FileInformationClass,
diff --git a/src/libraries/Common/src/Interop/Windows/NtDll/Interop.NtQueryInformationFile.cs b/src/libraries/Common/src/Interop/Windows/NtDll/Interop.NtQueryInformationFile.cs
index 644315f2bc2ccf..402443b05e944e 100644
--- a/src/libraries/Common/src/Interop/Windows/NtDll/Interop.NtQueryInformationFile.cs
+++ b/src/libraries/Common/src/Interop/Windows/NtDll/Interop.NtQueryInformationFile.cs
@@ -2,7 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using Microsoft.Win32.SafeHandles;
-using System;
 using System.Runtime.InteropServices;
 
 internal static partial class Interop
diff --git a/src/libraries/Common/src/Interop/Windows/NtDll/Interop.NtStatus.cs b/src/libraries/Common/src/Interop/Windows/NtDll/Interop.NtStatus.cs
index d79653a64105e2..76715c83be916d 100644
--- a/src/libraries/Common/src/Interop/Windows/NtDll/Interop.NtStatus.cs
+++ b/src/libraries/Common/src/Interop/Windows/NtDll/Interop.NtStatus.cs
@@ -17,5 +17,7 @@ internal static class StatusOptions
         internal const uint STATUS_ACCOUNT_RESTRICTION    = 0xC000006E;
         internal const uint STATUS_NONE_MAPPED            = 0xC0000073;
         internal const uint STATUS_INSUFFICIENT_RESOURCES = 0xC000009A;
+        internal const uint STATUS_DISK_FULL = 0xC000007F;
+        internal const uint STATUS_FILE_TOO_LARGE = 0xC0000904;
     }
 }
diff --git a/src/libraries/Common/src/Interop/Windows/Ucrtbase/Interop.MemAlloc.cs b/src/libraries/Common/src/Interop/Windows/Ucrtbase/Interop.MemAlloc.cs
new file mode 100644
index 00000000000000..23fe143abad308
--- /dev/null
+++ b/src/libraries/Common/src/Interop/Windows/Ucrtbase/Interop.MemAlloc.cs
@@ -0,0 +1,32 @@
+// 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 unsafe partial class Ucrtbase
+    {
+        [DllImport(Libraries.Ucrtbase, CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        internal static extern void* _aligned_malloc(nuint size, nuint alignment);
+
+        [DllImport(Libraries.Ucrtbase, CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        internal static extern void _aligned_free(void* ptr);
+
+        [DllImport(Libraries.Ucrtbase, CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        internal static extern void* _aligned_realloc(void* ptr, nuint size, nuint alignment);
+
+        [DllImport(Libraries.Ucrtbase, CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        internal static extern void* calloc(nuint num, nuint size);
+
+        [DllImport(Libraries.Ucrtbase, CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        internal static extern void free(void* ptr);
+
+        [DllImport(Libraries.Ucrtbase, CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        internal static extern void* malloc(nuint size);
+
+        [DllImport(Libraries.Ucrtbase, CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        internal static extern void* realloc(void* ptr, nuint new_size);
+    }
+}
diff --git a/src/libraries/Common/src/Interop/Windows/User32/Interop.GetWindowThreadProcessId.cs b/src/libraries/Common/src/Interop/Windows/User32/Interop.GetWindowThreadProcessId.cs
index 33863ed4259122..3b145fea4cc29c 100644
--- a/src/libraries/Common/src/Interop/Windows/User32/Interop.GetWindowThreadProcessId.cs
+++ b/src/libraries/Common/src/Interop/Windows/User32/Interop.GetWindowThreadProcessId.cs
@@ -9,7 +9,7 @@ internal static partial class Interop
     internal static partial class User32
     {
         [DllImport(Libraries.User32, ExactSpelling = true)]
-        public static extern int GetWindowThreadProcessId(IntPtr handle, out int processId);
+        public static unsafe extern int GetWindowThreadProcessId(IntPtr handle, int* processId);
 
         [DllImport(Libraries.User32, ExactSpelling = true)]
         public static extern int GetWindowThreadProcessId(HandleRef handle, out int processId);
diff --git a/src/libraries/Common/src/Interop/Windows/User32/Interop.IsWindowVisible.cs b/src/libraries/Common/src/Interop/Windows/User32/Interop.IsWindowVisible.cs
index 5e819d26db6305..15a829a9cf5578 100644
--- a/src/libraries/Common/src/Interop/Windows/User32/Interop.IsWindowVisible.cs
+++ b/src/libraries/Common/src/Interop/Windows/User32/Interop.IsWindowVisible.cs
@@ -9,6 +9,6 @@ internal static partial class Interop
     internal static partial class User32
     {
         [DllImport(Libraries.User32)]
-        public static extern bool IsWindowVisible(IntPtr hWnd);
+        public static extern BOOL IsWindowVisible(IntPtr hWnd);
     }
 }
diff --git a/src/libraries/Common/src/System/CodeDom/CodeObject.cs b/src/libraries/Common/src/System/CodeDom/CodeObject.cs
index 1a4898c9610e7d..f780fb625504ff 100644
--- a/src/libraries/Common/src/System/CodeDom/CodeObject.cs
+++ b/src/libraries/Common/src/System/CodeDom/CodeObject.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.
 
+#nullable enable
+
 using System.Collections;
 using System.Collections.Specialized;
 
diff --git a/src/libraries/Common/src/System/CodeDom/CodeTypeReference.cs b/src/libraries/Common/src/System/CodeDom/CodeTypeReference.cs
index ffeb0c92d406ac..281691f7907f6c 100644
--- a/src/libraries/Common/src/System/CodeDom/CodeTypeReference.cs
+++ b/src/libraries/Common/src/System/CodeDom/CodeTypeReference.cs
@@ -5,6 +5,8 @@
 using System.Diagnostics;
 using System.Globalization;
 
+#nullable enable
+
 #if CODEDOM
 namespace System.CodeDom
 #else
@@ -73,7 +75,7 @@ public CodeTypeReference(string typeName, CodeTypeReferenceOptions codeTypeRefer
             Initialize(typeName, codeTypeReferenceOption);
         }
 
-        public CodeTypeReference(string typeName)
+        public CodeTypeReference(string? typeName)
         {
             Initialize(typeName);
         }
diff --git a/src/libraries/Common/src/System/Collections/Concurrent/SingleProducerConsumerQueue.cs b/src/libraries/Common/src/System/Collections/Concurrent/SingleProducerConsumerQueue.cs
index f6e15ae5eb7a85..37ddfdd2811d38 100644
--- a/src/libraries/Common/src/System/Collections/Concurrent/SingleProducerConsumerQueue.cs
+++ b/src/libraries/Common/src/System/Collections/Concurrent/SingleProducerConsumerQueue.cs
@@ -142,16 +142,38 @@ public bool TryDequeue([MaybeNullWhen(false)] out T result)
                 segment._state._first = (first + 1) & (array.Length - 1);
                 return true;
             }
+
             // Slow path: there may not be data available in the current segment
-            else return TryDequeueSlow(ref segment, ref array, out result);
+            return TryDequeueSlow(segment, array, peek: false, out result);
+        }
+
+        /// <summary>Attempts to peek at an item in the queue.</summary>
+        /// <param name="result">The peeked item.</param>
+        /// <returns>true if an item could be peeked; otherwise, false.</returns>
+        public bool TryPeek([MaybeNullWhen(false)] out T result)
+        {
+            Segment segment = _head;
+            T[] array = segment._array;
+            int first = segment._state._first; // local copy to avoid multiple volatile reads
+
+            // Fast path: there's obviously data available in the current segment
+            if (first != segment._state._lastCopy)
+            {
+                result = array[first];
+                return true;
+            }
+
+            // Slow path: there may not be data available in the current segment
+            return TryDequeueSlow(segment, array, peek: true, out result);
         }
 
         /// <summary>Attempts to dequeue an item from the queue.</summary>
-        /// <param name="array">The array from which the item was dequeued.</param>
         /// <param name="segment">The segment from which the item was dequeued.</param>
+        /// <param name="array">The array from <paramref name="segment"/>.</param>
+        /// <param name="peek">true if this is only a peek operation; false if the item should be dequeued.</param>
         /// <param name="result">The dequeued item.</param>
         /// <returns>true if an item could be dequeued; otherwise, false.</returns>
-        private bool TryDequeueSlow(ref Segment segment, ref T[] array, [MaybeNullWhen(false)] out T result)
+        private bool TryDequeueSlow(Segment segment, T[] array, bool peek, [MaybeNullWhen(false)] out T result)
         {
             Debug.Assert(segment != null, "Expected a non-null segment.");
             Debug.Assert(array != null, "Expected a non-null item array.");
@@ -159,7 +181,9 @@ private bool TryDequeueSlow(ref Segment segment, ref T[] array, [MaybeNullWhen(f
             if (segment._state._last != segment._state._lastCopy)
             {
                 segment._state._lastCopy = segment._state._last;
-                return TryDequeue(out result); // will only recur once for this dequeue operation
+                return peek ?
+                    TryPeek(out result) :
+                    TryDequeue(out result); // will only recur once for this operation
             }
 
             if (segment._next != null && segment._state._first == segment._state._last)
@@ -178,9 +202,12 @@ private bool TryDequeueSlow(ref Segment segment, ref T[] array, [MaybeNullWhen(f
             }
 
             result = array[first];
-            array[first] = default!; // Clear the slot to release the element
-            segment._state._first = (first + 1) & (segment._array.Length - 1);
-            segment._state._lastCopy = segment._state._last; // Refresh _lastCopy to ensure that _first has not passed _lastCopy
+            if (!peek)
+            {
+                array[first] = default!; // Clear the slot to release the element
+                segment._state._first = (first + 1) & (segment._array.Length - 1);
+                segment._state._lastCopy = segment._state._last; // Refresh _lastCopy to ensure that _first has not passed _lastCopy
+            }
 
             return true;
         }
diff --git a/src/libraries/Common/src/System/Data/Common/DbConnectionOptions.Common.cs b/src/libraries/Common/src/System/Data/Common/DbConnectionOptions.Common.cs
index fda8cc871d916d..80a092104ae504 100644
--- a/src/libraries/Common/src/System/Data/Common/DbConnectionOptions.Common.cs
+++ b/src/libraries/Common/src/System/Data/Common/DbConnectionOptions.Common.cs
@@ -406,8 +406,7 @@ private static bool IsValueValidInternal(string? keyvalue)
                 bool compValue = s_connectionStringValidValueRegex.IsMatch(keyvalue);
                 Debug.Assert((-1 == keyvalue.IndexOf('\u0000')) == compValue, "IsValueValid mismatch with regex");
 #endif
-                // string.Contains(char) is .NetCore2.1+ specific
-                return (-1 == keyvalue.IndexOf('\u0000'));
+                return (-1 == keyvalue.IndexOf('\u0000')); // string.Contains(char) is .NetCore2.1+ specific
             }
             return true;
         }
diff --git a/src/libraries/Common/src/System/IO/Compression/ZLibNative.cs b/src/libraries/Common/src/System/IO/Compression/ZLibNative.cs
index f0393ebbf35cb5..7457e97ad653db 100644
--- a/src/libraries/Common/src/System/IO/Compression/ZLibNative.cs
+++ b/src/libraries/Common/src/System/IO/Compression/ZLibNative.cs
@@ -262,81 +262,109 @@ private void EnsureState(State requiredState)
             }
 
 
-            public ErrorCode DeflateInit2_(CompressionLevel level, int windowBits, int memLevel, CompressionStrategy strategy)
+            public unsafe ErrorCode DeflateInit2_(CompressionLevel level, int windowBits, int memLevel, CompressionStrategy strategy)
             {
                 EnsureNotDisposed();
                 EnsureState(State.NotInitialized);
 
-                ErrorCode errC = Interop.zlib.DeflateInit2_(ref _zStream, level, CompressionMethod.Deflated, windowBits, memLevel, strategy);
-                _initializationState = State.InitializedForDeflate;
+                fixed (ZStream* stream = &_zStream)
+                {
+                    ErrorCode errC = Interop.zlib.DeflateInit2_(stream, level, CompressionMethod.Deflated, windowBits, memLevel, strategy);
+                    _initializationState = State.InitializedForDeflate;
 
-                return errC;
+                    return errC;
+                }
             }
 
 
-            public ErrorCode Deflate(FlushCode flush)
+            public unsafe ErrorCode Deflate(FlushCode flush)
             {
                 EnsureNotDisposed();
                 EnsureState(State.InitializedForDeflate);
-                return Interop.zlib.Deflate(ref _zStream, flush);
+
+                fixed (ZStream* stream = &_zStream)
+                {
+                    return Interop.zlib.Deflate(stream, flush);
+                }
             }
 
 
-            public ErrorCode DeflateReset()
+            public unsafe ErrorCode DeflateReset()
             {
                 EnsureNotDisposed();
                 EnsureState(State.InitializedForDeflate);
-                return Interop.zlib.DeflateReset(ref _zStream);
+
+                fixed (ZStream* stream = &_zStream)
+                {
+                    return Interop.zlib.DeflateReset(stream);
+                }
             }
 
-            public ErrorCode DeflateEnd()
+            public unsafe ErrorCode DeflateEnd()
             {
                 EnsureNotDisposed();
                 EnsureState(State.InitializedForDeflate);
 
-                ErrorCode errC = Interop.zlib.DeflateEnd(ref _zStream);
-                _initializationState = State.Disposed;
+                fixed (ZStream* stream = &_zStream)
+                {
+                    ErrorCode errC = Interop.zlib.DeflateEnd(stream);
+                    _initializationState = State.Disposed;
 
-                return errC;
+                    return errC;
+                }
             }
 
 
-            public ErrorCode InflateInit2_(int windowBits)
+            public unsafe ErrorCode InflateInit2_(int windowBits)
             {
                 EnsureNotDisposed();
                 EnsureState(State.NotInitialized);
 
-                ErrorCode errC = Interop.zlib.InflateInit2_(ref _zStream, windowBits);
-                _initializationState = State.InitializedForInflate;
+                fixed (ZStream* stream = &_zStream)
+                {
+                    ErrorCode errC = Interop.zlib.InflateInit2_(stream, windowBits);
+                    _initializationState = State.InitializedForInflate;
 
-                return errC;
+                    return errC;
+                }
             }
 
 
-            public ErrorCode Inflate(FlushCode flush)
+            public unsafe ErrorCode Inflate(FlushCode flush)
             {
                 EnsureNotDisposed();
                 EnsureState(State.InitializedForInflate);
-                return Interop.zlib.Inflate(ref _zStream, flush);
+
+                fixed (ZStream* stream = &_zStream)
+                {
+                    return Interop.zlib.Inflate(stream, flush);
+                }
             }
 
 
-            public ErrorCode InflateReset()
+            public unsafe ErrorCode InflateReset()
             {
                 EnsureNotDisposed();
                 EnsureState(State.InitializedForInflate);
-                return Interop.zlib.InflateReset(ref _zStream);
+
+                fixed (ZStream* stream = &_zStream)
+                {
+                    return Interop.zlib.InflateReset(stream);
+                }
             }
 
-            public ErrorCode InflateEnd()
+            public unsafe ErrorCode InflateEnd()
             {
                 EnsureNotDisposed();
                 EnsureState(State.InitializedForInflate);
 
-                ErrorCode errC = Interop.zlib.InflateEnd(ref _zStream);
-                _initializationState = State.Disposed;
+                fixed (ZStream* stream = &_zStream)
+                {
+                    ErrorCode errC = Interop.zlib.InflateEnd(stream);
+                    _initializationState = State.Disposed;
 
-                return errC;
+                    return errC;
+                }
             }
 
             // This can work even after XxflateEnd().
diff --git a/src/libraries/Common/src/System/IO/PathInternal.CaseSensitivity.cs b/src/libraries/Common/src/System/IO/PathInternal.CaseSensitivity.cs
index d66e3aa569d83f..3e3486157e8410 100644
--- a/src/libraries/Common/src/System/IO/PathInternal.CaseSensitivity.cs
+++ b/src/libraries/Common/src/System/IO/PathInternal.CaseSensitivity.cs
@@ -12,48 +12,27 @@ namespace System.IO
     /// <summary>Contains internal path helpers that are shared between many projects.</summary>
     internal static partial class PathInternal
     {
-        private static readonly bool s_isCaseSensitive = GetIsCaseSensitive();
-
         /// <summary>Returns a comparison that can be used to compare file and directory names for equality.</summary>
         internal static StringComparison StringComparison
         {
             get
             {
-                return s_isCaseSensitive ?
+                return IsCaseSensitive ?
                     StringComparison.Ordinal :
                     StringComparison.OrdinalIgnoreCase;
             }
         }
 
         /// <summary>Gets whether the system is case-sensitive.</summary>
-        internal static bool IsCaseSensitive { get { return s_isCaseSensitive; } }
-
-        /// <summary>
-        /// Determines whether the file system is case sensitive.
-        /// </summary>
-        /// <remarks>
-        /// Ideally we'd use something like pathconf with _PC_CASE_SENSITIVE, but that is non-portable,
-        /// not supported on Windows or Linux, etc. For now, this function creates a tmp file with capital letters
-        /// and then tests for its existence with lower-case letters.  This could return invalid results in corner
-        /// cases where, for example, different file systems are mounted with differing sensitivities.
-        /// </remarks>
-        private static bool GetIsCaseSensitive()
+        internal static bool IsCaseSensitive
         {
-            try
-            {
-                string pathWithUpperCase = Path.Combine(Path.GetTempPath(), "CASESENSITIVETEST" + Guid.NewGuid().ToString("N"));
-                using (new FileStream(pathWithUpperCase, FileMode.CreateNew, FileAccess.ReadWrite, FileShare.None, 0x1000, FileOptions.DeleteOnClose))
-                {
-                    string lowerCased = pathWithUpperCase.ToLowerInvariant();
-                    return !File.Exists(lowerCased);
-                }
-            }
-            catch (Exception exc)
+            get
             {
-                // In case something goes terribly wrong, we don't want to fail just because
-                // of a casing test, so we assume case-insensitive-but-preserving.
-                Debug.Fail("Casing test failed: " + exc);
-                return false;
+#if MS_IO_REDIST
+                return false; // Windows is always case-insensitive
+#else
+                return !(OperatingSystem.IsWindows() || OperatingSystem.IsMacOS() || OperatingSystem.IsMacCatalyst() || OperatingSystem.IsIOS() || OperatingSystem.IsTvOS() || OperatingSystem.IsWatchOS());
+#endif
             }
         }
     }
diff --git a/src/libraries/Common/src/System/Net/Http/aspnetcore/Http2/Hpack/H2StaticTable.Http2.cs b/src/libraries/Common/src/System/Net/Http/aspnetcore/Http2/Hpack/H2StaticTable.Http2.cs
index 71ef9019bc0258..fdb619a3ff7abf 100644
--- a/src/libraries/Common/src/System/Net/Http/aspnetcore/Http2/Hpack/H2StaticTable.Http2.cs
+++ b/src/libraries/Common/src/System/Net/Http/aspnetcore/Http2/Hpack/H2StaticTable.Http2.cs
@@ -21,7 +21,7 @@ public static int GetStatusIndex(int status) =>
                 400 => 12,
                 404 => 13,
                 500 => 14,
-                _ => throw new ArgumentOutOfRangeException()
+                _ => throw new ArgumentOutOfRangeException(nameof(status))
             };
 
         private static readonly HeaderField[] s_staticDecoderTable = new HeaderField[]
diff --git a/src/libraries/Common/src/System/Net/Http/aspnetcore/Http2/Hpack/HPackDecoder.cs b/src/libraries/Common/src/System/Net/Http/aspnetcore/Http2/Hpack/HPackDecoder.cs
index 2cce40894f1d0b..22e2f8bd1987aa 100644
--- a/src/libraries/Common/src/System/Net/Http/aspnetcore/Http2/Hpack/HPackDecoder.cs
+++ b/src/libraries/Common/src/System/Net/Http/aspnetcore/Http2/Hpack/HPackDecoder.cs
@@ -83,7 +83,7 @@ private enum State : byte
         private readonly int _maxDynamicTableSize;
         private readonly int _maxHeadersLength;
         private readonly DynamicTable _dynamicTable;
-        private readonly IntegerDecoder _integerDecoder = new IntegerDecoder();
+        private IntegerDecoder _integerDecoder;
         private byte[] _stringOctets;
         private byte[] _headerNameOctets;
         private byte[] _headerValueOctets;
diff --git a/src/libraries/Common/src/System/Net/Http/aspnetcore/Http2/Hpack/IntegerDecoder.cs b/src/libraries/Common/src/System/Net/Http/aspnetcore/Http2/Hpack/IntegerDecoder.cs
index 6faa058ebf997a..34ab1d294ec900 100644
--- a/src/libraries/Common/src/System/Net/Http/aspnetcore/Http2/Hpack/IntegerDecoder.cs
+++ b/src/libraries/Common/src/System/Net/Http/aspnetcore/Http2/Hpack/IntegerDecoder.cs
@@ -6,7 +6,7 @@
 
 namespace System.Net.Http.HPack
 {
-    internal sealed class IntegerDecoder
+    internal struct IntegerDecoder
     {
         private int _i;
         private int _m;
diff --git a/src/libraries/Common/src/System/Net/Http/aspnetcore/Http3/QPack/HeaderField.cs b/src/libraries/Common/src/System/Net/Http/aspnetcore/Http3/QPack/HeaderField.cs
index b4b80c53798f41..9cf185918639ea 100644
--- a/src/libraries/Common/src/System/Net/Http/aspnetcore/Http3/QPack/HeaderField.cs
+++ b/src/libraries/Common/src/System/Net/Http/aspnetcore/Http3/QPack/HeaderField.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.Diagnostics;
+using System.Text;
+
 namespace System.Net.Http.QPack
 {
     internal readonly struct HeaderField
@@ -11,6 +14,8 @@ internal readonly struct HeaderField
 
         public HeaderField(byte[] name, byte[] value)
         {
+            Debug.Assert(name.Length > 0);
+
             Name = name;
             Value = value;
         }
@@ -19,6 +24,20 @@ public HeaderField(byte[] name, byte[] value)
 
         public byte[] Value { get; }
 
-        public int Length => Name.Length + Value.Length;
+        public int Length => GetLength(Name.Length, Value.Length);
+
+        public static int GetLength(int nameLength, int valueLength) => nameLength + valueLength + RfcOverhead;
+
+        public override string ToString()
+        {
+            if (Name != null)
+            {
+                return Encoding.ASCII.GetString(Name) + ": " + Encoding.ASCII.GetString(Value);
+            }
+            else
+            {
+                return "<empty>";
+            }
+        }
     }
 }
diff --git a/src/libraries/Common/src/System/Net/Http/aspnetcore/Http3/QPack/QPackDecoder.cs b/src/libraries/Common/src/System/Net/Http/aspnetcore/Http3/QPack/QPackDecoder.cs
index 96de7c65338098..77a3baa8a3de69 100644
--- a/src/libraries/Common/src/System/Net/Http/aspnetcore/Http3/QPack/QPackDecoder.cs
+++ b/src/libraries/Common/src/System/Net/Http/aspnetcore/Http3/QPack/QPackDecoder.cs
@@ -123,7 +123,7 @@ private enum State
         private int _headerValueLength;
         private int _stringLength;
         private int _stringIndex;
-        private readonly IntegerDecoder _integerDecoder = new IntegerDecoder();
+        private IntegerDecoder _integerDecoder;
 
         private static ArrayPool<byte> Pool => ArrayPool<byte>.Shared;
 
diff --git a/src/libraries/Common/src/System/Net/Http/aspnetcore/Http3/QPack/QPackEncoder.cs b/src/libraries/Common/src/System/Net/Http/aspnetcore/Http3/QPack/QPackEncoder.cs
index 2cc0c4d850a270..1f2275ebb15ff3 100644
--- a/src/libraries/Common/src/System/Net/Http/aspnetcore/Http3/QPack/QPackEncoder.cs
+++ b/src/libraries/Common/src/System/Net/Http/aspnetcore/Http3/QPack/QPackEncoder.cs
@@ -9,10 +9,8 @@
 
 namespace System.Net.Http.QPack
 {
-    internal sealed class QPackEncoder
+    internal static class QPackEncoder
     {
-        private IEnumerator<KeyValuePair<string, string>>? _enumerator;
-
         // https://tools.ietf.org/html/draft-ietf-quic-qpack-11#section-4.5.2
         //   0   1   2   3   4   5   6   7
         // +---+---+---+---+---+---+---+---+
@@ -403,93 +401,5 @@ private static bool EncodeHeaderBlockPrefix(Span<byte> destination, out int byte
 
             return true;
         }
-
-        public bool BeginEncode(IEnumerable<KeyValuePair<string, string>> headers, Span<byte> buffer, out int length)
-        {
-            _enumerator = headers.GetEnumerator();
-
-            bool hasValue = _enumerator.MoveNext();
-            Debug.Assert(hasValue == true);
-
-            buffer[0] = 0;
-            buffer[1] = 0;
-
-            bool doneEncode = Encode(buffer.Slice(2), out length);
-
-            // Add two for the first two bytes.
-            length += 2;
-            return doneEncode;
-        }
-
-        public bool BeginEncode(int statusCode, IEnumerable<KeyValuePair<string, string>> headers, Span<byte> buffer, out int length)
-        {
-            _enumerator = headers.GetEnumerator();
-
-            bool hasValue = _enumerator.MoveNext();
-            Debug.Assert(hasValue == true);
-
-            // https://quicwg.org/base-drafts/draft-ietf-quic-qpack.html#header-prefix
-            buffer[0] = 0;
-            buffer[1] = 0;
-
-            int statusCodeLength = EncodeStatusCode(statusCode, buffer.Slice(2));
-            bool done = Encode(buffer.Slice(statusCodeLength + 2), throwIfNoneEncoded: false, out int headersLength);
-            length = statusCodeLength + headersLength + 2;
-
-            return done;
-        }
-
-        public bool Encode(Span<byte> buffer, out int length)
-        {
-            return Encode(buffer, throwIfNoneEncoded: true, out length);
-        }
-
-        private bool Encode(Span<byte> buffer, bool throwIfNoneEncoded, out int length)
-        {
-            length = 0;
-
-            do
-            {
-                if (!EncodeLiteralHeaderFieldWithoutNameReference(_enumerator!.Current.Key, _enumerator.Current.Value, buffer.Slice(length), out int headerLength))
-                {
-                    if (length == 0 && throwIfNoneEncoded)
-                    {
-                        throw new QPackEncodingException("TODO sync with corefx" /* CoreStrings.HPackErrorNotEnoughBuffer */);
-                    }
-                    return false;
-                }
-
-                length += headerLength;
-            } while (_enumerator.MoveNext());
-
-            return true;
-        }
-
-        private int EncodeStatusCode(int statusCode, Span<byte> buffer)
-        {
-            switch (statusCode)
-            {
-                case 200:
-                case 204:
-                case 206:
-                case 304:
-                case 400:
-                case 404:
-                case 500:
-                    EncodeStaticIndexedHeaderField(H3StaticTable.StatusIndex[statusCode], buffer, out var bytesWritten);
-                    return bytesWritten;
-                default:
-                    // https://tools.ietf.org/html/draft-ietf-quic-qpack-21#section-4.5.4
-                    // Index is 63 - :status
-                    buffer[0] = 0b01011111;
-                    buffer[1] = 0b00110000;
-
-                    ReadOnlySpan<byte> statusBytes = StatusCodes.ToStatusBytes(statusCode);
-                    buffer[2] = (byte)statusBytes.Length;
-                    statusBytes.CopyTo(buffer.Slice(3));
-
-                    return 3 + statusBytes.Length;
-            }
-        }
     }
 }
\ No newline at end of file
diff --git a/src/libraries/Common/src/System/Obsoletions.cs b/src/libraries/Common/src/System/Obsoletions.cs
index 9fb3c94b394fc7..32ec8ebb6edbfc 100644
--- a/src/libraries/Common/src/System/Obsoletions.cs
+++ b/src/libraries/Common/src/System/Obsoletions.cs
@@ -86,5 +86,8 @@ internal static class Obsoletions
 
         internal const string SuppressIldasmAttributeMessage = "SuppressIldasmAttribute has no effect in .NET 6.0+.";
         internal const string SuppressIldasmAttributeDiagId = "SYSLIB0025";
+
+        internal const string X509CertificateImmutableMessage = "X509Certificate and X509Certificate2 are immutable. Use the appropriate constructor to create a new certificate.";
+        internal const string X509CertificateImmutableDiagId = "SYSLIB0026";
     }
 }
diff --git a/src/libraries/Common/src/System/Security/Cryptography/HashOneShotHelpers.cs b/src/libraries/Common/src/System/Security/Cryptography/HashOneShotHelpers.cs
new file mode 100644
index 00000000000000..95c39e02acb0c8
--- /dev/null
+++ b/src/libraries/Common/src/System/Security/Cryptography/HashOneShotHelpers.cs
@@ -0,0 +1,42 @@
+// 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;
+
+namespace System.Security.Cryptography
+{
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Security", "CA5350", Justification = "Weak algorithms are used as instructed by the caller")]
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Security", "CA5351", Justification = "Weak algorithms are used as instructed by the caller")]
+    internal static class HashOneShotHelpers
+    {
+        public static int MacData(
+            HashAlgorithmName hashAlgorithm,
+            ReadOnlySpan<byte> key,
+            ReadOnlySpan<byte> source,
+            Span<byte> destination)
+        {
+            if (hashAlgorithm == HashAlgorithmName.SHA256)
+            {
+                return HMACSHA256.HashData(key, source, destination);
+            }
+            else if (hashAlgorithm == HashAlgorithmName.SHA1)
+            {
+                return HMACSHA1.HashData(key, source, destination);
+            }
+            else if (hashAlgorithm == HashAlgorithmName.SHA512)
+            {
+                return HMACSHA512.HashData(key, source, destination);
+            }
+            else if (hashAlgorithm == HashAlgorithmName.SHA384)
+            {
+                return HMACSHA384.HashData(key, source, destination);
+            }
+            else if (hashAlgorithm == HashAlgorithmName.MD5)
+            {
+                return HMACMD5.HashData(key, source, destination);
+            }
+
+            throw new CryptographicException(SR.Format(SR.Cryptography_UnknownHashAlgorithm, hashAlgorithm.Name));
+        }
+    }
+}
diff --git a/src/libraries/Common/src/System/Security/IdentityHelper.cs b/src/libraries/Common/src/System/Security/IdentityHelper.cs
index 9ce528a47c347f..f7bec51d8deb9f 100644
--- a/src/libraries/Common/src/System/Security/IdentityHelper.cs
+++ b/src/libraries/Common/src/System/Security/IdentityHelper.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.
 
+#nullable enable
+
 using System.Diagnostics;
 using System.IO;
 using System.Reflection;
diff --git a/src/libraries/Common/tests/StreamConformanceTests/System/IO/StreamConformanceTests.cs b/src/libraries/Common/tests/StreamConformanceTests/System/IO/StreamConformanceTests.cs
index d41e07217ee335..43451d45301128 100644
--- a/src/libraries/Common/tests/StreamConformanceTests/System/IO/StreamConformanceTests.cs
+++ b/src/libraries/Common/tests/StreamConformanceTests/System/IO/StreamConformanceTests.cs
@@ -1562,11 +1562,6 @@ public abstract class ConnectedStreamConformanceTests : StreamConformanceTests
         /// Gets whether the stream guarantees that all data written to it will be flushed as part of Flush{Async}.
         /// </summary>
         protected virtual bool FlushGuaranteesAllDataWritten => true;
-        /// <summary>
-        /// Gets whether a stream implements an aggressive read that tries to fill the supplied buffer and only
-        /// stops when it does so or hits EOF.
-        /// </summary>
-        protected virtual bool ReadsMayBlockUntilBufferFullOrEOF => false;
         /// <summary>Gets whether reads for a count of 0 bytes block if no bytes are available to read.</summary>
         protected virtual bool BlocksOnZeroByteReads => false;
         /// <summary>
@@ -1709,6 +1704,10 @@ public virtual async Task ReadWriteByte_Success()
             }
         }
 
+        public static IEnumerable<object[]> ReadWrite_Modes =>
+            from mode in Enum.GetValues<ReadWriteMode>()
+            select new object[] { mode };
+
         public static IEnumerable<object[]> ReadWrite_Success_MemberData() =>
             from mode in Enum.GetValues<ReadWriteMode>()
             from writeSize in new[] { 1, 42, 10 * 1024 }
@@ -1785,6 +1784,54 @@ 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)
+            {
+                return;
+            }
+
+            foreach (CancellationToken nonCanceledToken in new[] { CancellationToken.None, new CancellationTokenSource().Token })
+            {
+                using StreamPair streams = await CreateConnectedStreamsAsync();
+
+                foreach ((Stream writeable, Stream readable) in GetReadWritePairs(streams))
+                {
+                    byte[] writerBytes = RandomNumberGenerator.GetBytes(512);
+                    var readerBytes = new byte[writerBytes.Length * 2];
+
+                    // Repeatedly write then read a message smaller in size than the read buffer
+                    for (int i = 0; i < 5; i++)
+                    {
+                        Task writes = Task.Run(async () =>
+                        {
+                            await WriteAsync(mode, writeable, writerBytes, 0, writerBytes.Length, nonCanceledToken);
+                            if (FlushRequiredToWriteData)
+                            {
+                                await writeable.FlushAsync();
+                            }
+                        });
+
+                        int n = 0;
+                        while (n < writerBytes.Length)
+                        {
+                            int r = await ReadAsync(mode, readable, readerBytes, n, readerBytes.Length - n);
+                            Assert.InRange(r, 1, writerBytes.Length - n);
+                            n += r;
+                        }
+
+                        Assert.Equal(writerBytes.Length, n);
+                        AssertExtensions.SequenceEqual(writerBytes, readerBytes.AsSpan(0, writerBytes.Length));
+
+                        await writes;
+                    }
+                }
+            }
+        }
+
         [Theory]
         [MemberData(nameof(AllReadWriteModesAndValue), false)]
         [MemberData(nameof(AllReadWriteModesAndValue), true)]
@@ -2160,6 +2207,10 @@ public virtual async Task ZeroByteRead_BlocksUntilDataAvailableOrNops(ReadWriteM
                         });
                         Assert.Equal(0, await zeroByteRead);
 
+                        // Perform a second zero-byte read.
+                        await Task.Run(() => ReadAsync(mode, readable, Array.Empty<byte>(), 0, 0));
+
+                        // Now consume all the data.
                         var readBytes = new byte[5];
                         int count = 0;
                         while (count < readBytes.Length)
@@ -2684,7 +2735,7 @@ public virtual async Task Flush_FlushesUnderlyingStream(bool flushAsync)
         [InlineData(true, true)]
         public virtual async Task Dispose_Flushes(bool useAsync, bool leaveOpen)
         {
-            if (leaveOpen && (!SupportsLeaveOpen || ReadsMayBlockUntilBufferFullOrEOF))
+            if (leaveOpen && !SupportsLeaveOpen)
             {
                 return;
             }
diff --git a/src/libraries/Common/tests/System/IO/Compression/CompressionStreamTestBase.cs b/src/libraries/Common/tests/System/IO/Compression/CompressionStreamTestBase.cs
index 366c547d2c600d..24f32fab04b045 100644
--- a/src/libraries/Common/tests/System/IO/Compression/CompressionStreamTestBase.cs
+++ b/src/libraries/Common/tests/System/IO/Compression/CompressionStreamTestBase.cs
@@ -54,6 +54,6 @@ protected override Task<StreamPair> CreateWrappedConnectedStreamsAsync(StreamPai
         protected override Type UnsupportedReadWriteExceptionType => typeof(InvalidOperationException);
         protected override bool WrappedUsableAfterClose => false;
         protected override bool FlushRequiredToWriteData => true;
-        protected override bool FlushGuaranteesAllDataWritten => false;
+        protected override bool BlocksOnZeroByteReads => true;
     }
 }
diff --git a/src/libraries/Common/tests/System/IO/Compression/ZipTestHelper.cs b/src/libraries/Common/tests/System/IO/Compression/ZipTestHelper.cs
index e8a0c08c3df26c..6f319461c35ef4 100644
--- a/src/libraries/Common/tests/System/IO/Compression/ZipTestHelper.cs
+++ b/src/libraries/Common/tests/System/IO/Compression/ZipTestHelper.cs
@@ -65,6 +65,17 @@ public static void ReadBytes(Stream stream, byte[] buffer, long bytesToRead)
             }
         }
 
+        public static int ReadAllBytes(Stream stream, byte[] buffer, int offset, int count)
+        {
+            int bytesRead;
+            int totalRead = 0;
+            while ((bytesRead = stream.Read(buffer, offset + totalRead, count - totalRead)) != 0)
+            {
+                totalRead += bytesRead;
+            }
+            return totalRead;
+        }
+
         public static bool ArraysEqual<T>(T[] a, T[] b) where T : IComparable<T>
         {
             if (a.Length != b.Length) return false;
@@ -111,8 +122,8 @@ public static void StreamsEqual(Stream ast, Stream bst, int blocksToRead)
                 if (blocksToRead != -1 && blocksRead >= blocksToRead)
                     break;
 
-                ac = ast.Read(ad, 0, 4096);
-                bc = bst.Read(bd, 0, 4096);
+                ac = ReadAllBytes(ast, ad, 0, 4096);
+                bc = ReadAllBytes(bst, bd, 0, 4096);
 
                 if (ac != bc)
                 {
@@ -170,7 +181,7 @@ public static void IsZipSameAsDir(Stream archiveFile, string directory, ZipArchi
                         var buffer = new byte[entry.Length];
                         using (Stream entrystream = entry.Open())
                         {
-                            entrystream.Read(buffer, 0, buffer.Length);
+                            ReadAllBytes(entrystream, buffer, 0, buffer.Length);
 #if NETCOREAPP
                             uint zipcrc = entry.Crc32;
                             Assert.Equal(CRC.CalculateCRC(buffer), zipcrc);
diff --git a/src/libraries/Common/tests/System/Net/Configuration.Http.cs b/src/libraries/Common/tests/System/Net/Configuration.Http.cs
index 69e1094128771b..ae1481c56061c7 100644
--- a/src/libraries/Common/tests/System/Net/Configuration.Http.cs
+++ b/src/libraries/Common/tests/System/Net/Configuration.Http.cs
@@ -12,11 +12,12 @@ public static partial class Http
         {
             private static readonly string DefaultHttp2AzureServer = "corefx-net-http2.azurewebsites.net";
 
+            // for the local server hosted in XHarness we are passing also port as part of the environment variables, because it's bound to random port number
             public static string Host => GetValue("DOTNET_TEST_HTTPHOST", DefaultAzureServer);
-
             public static string SecureHost => GetValue("DOTNET_TEST_SECUREHTTPHOST", DefaultAzureServer);
-
             public static string Http2Host => GetValue("DOTNET_TEST_HTTP2HOST", DefaultHttp2AzureServer);
+            public static int Port = GetPortValue("DOTNET_TEST_HTTPHOST", 80);
+            public static int SecurePort = GetPortValue("DOTNET_TEST_SECUREHTTPHOST", 443);
 
             // This server doesn't use HTTP/2 server push (push promise) feature. Some HttpClient implementations
             // don't support servers that use push right now.
@@ -44,12 +45,15 @@ public static partial class Http
             public static string EchoClientCertificateRemoteServer => GetValue("DOTNET_TEST_HTTPHOST_ECHOCLIENTCERT", "https://corefx-net-tls.azurewebsites.net/EchoClientCertificate.ashx");
             public static string Http2ForceUnencryptedLoopback => GetValue("DOTNET_TEST_HTTP2_FORCEUNENCRYPTEDLOOPBACK");
 
+            public static string RemoteLoopHost => GetValue("DOTNET_TEST_REMOTE_LOOP_HOST");
+
             private const string EchoHandler = "Echo.ashx";
             private const string EmptyContentHandler = "EmptyContent.ashx";
             private const string RedirectHandler = "Redirect.ashx";
             private const string VerifyUploadHandler = "VerifyUpload.ashx";
             private const string DeflateHandler = "Deflate.ashx";
             private const string GZipHandler = "GZip.ashx";
+            private const string RemoteLoopHandler = "RemoteLoop";
 
             public static readonly Uri RemoteEchoServer = new Uri("http://" + Host + "/" + EchoHandler);
             public static readonly Uri SecureRemoteEchoServer = new Uri("https://" + SecureHost + "/" + EchoHandler);
@@ -66,6 +70,7 @@ public static partial class Http
             public static readonly Uri RemoteGZipServer = new Uri("http://" + Host + "/" + GZipHandler);
             public static readonly Uri Http2RemoteDeflateServer = new Uri("https://" + Http2Host + "/" + DeflateHandler);
             public static readonly Uri Http2RemoteGZipServer = new Uri("https://" + Http2Host + "/" + GZipHandler);
+            public static Uri RemoteLoopServer => new Uri("ws://" + RemoteLoopHost + "/" + RemoteLoopHandler);
 
             public static readonly object[][] EchoServers = EchoServerList.Select(x => new object[] { x }).ToArray();
             public static readonly object[][] VerifyUploadServers = { new object[] { RemoteVerifyUploadServer }, new object[] { SecureRemoteVerifyUploadServer }, new object[] { Http2RemoteVerifyUploadServer } };
diff --git a/src/libraries/Common/tests/System/Net/Configuration.cs b/src/libraries/Common/tests/System/Net/Configuration.cs
index 62e860b2efecf0..9cb9c75f78acdd 100644
--- a/src/libraries/Common/tests/System/Net/Configuration.cs
+++ b/src/libraries/Common/tests/System/Net/Configuration.cs
@@ -21,6 +21,25 @@ private static string GetValue(string envName, string defaultValue=null)
             return Environment.ExpandEnvironmentVariables(envValue);
         }
 
+        private static int GetPortValue(string envName, int defaultValue)
+        {
+            string envValue = Environment.GetEnvironmentVariable(envName);
+
+            if (string.IsNullOrWhiteSpace(envValue))
+            {
+                return defaultValue;
+            }
+            envValue = Environment.ExpandEnvironmentVariables(envValue);
+
+            var split = envValue.Split(':');
+            if (split.Length<2)
+            {
+                return defaultValue;
+            }
+            
+            return int.Parse(split[1]);
+        }
+
         private static Uri GetUriValue(string envName, Uri defaultValue=null)
         {
             string envValue = GetValue(envName, null);
diff --git a/src/libraries/Common/tests/System/Net/Http/GenericLoopbackServer.cs b/src/libraries/Common/tests/System/Net/Http/GenericLoopbackServer.cs
index d3095bd7a2045a..c145b6aa3d4939 100644
--- a/src/libraries/Common/tests/System/Net/Http/GenericLoopbackServer.cs
+++ b/src/libraries/Common/tests/System/Net/Http/GenericLoopbackServer.cs
@@ -9,6 +9,8 @@
 using System.Security.Cryptography.X509Certificates;
 using System.IO;
 using System.Net.Sockets;
+using System.Net.WebSockets;
+using System.Threading;
 
 namespace System.Net.Test.Common
 {
@@ -20,7 +22,7 @@ public abstract class LoopbackServerFactory
         public abstract GenericLoopbackServer CreateServer(GenericLoopbackOptions options = null);
         public abstract Task CreateServerAsync(Func<GenericLoopbackServer, Uri, Task> funcAsync, int millisecondsTimeout = 60_000, GenericLoopbackOptions options = null);
 
-        public abstract Task<GenericLoopbackConnection> CreateConnectionAsync(Socket socket, Stream stream, GenericLoopbackOptions options = null);
+        public abstract Task<GenericLoopbackConnection> CreateConnectionAsync(SocketWrapper socket, Stream stream, GenericLoopbackOptions options = null);
 
         public abstract Version Version { get; }
 
@@ -59,6 +61,54 @@ public Task<HttpRequestData> AcceptConnectionSendResponseAndCloseAsync(HttpStatu
         }
     }
 
+    public sealed class SocketWrapper : IDisposable
+    {
+        private Socket _socket;
+        private WebSocket _websocket;
+
+        public SocketWrapper(Socket socket)
+        {
+            _socket = socket;
+        }
+        public SocketWrapper(WebSocket websocket)
+        {
+            _websocket = websocket;
+        }
+
+        public void Dispose()
+        {
+            _socket?.Dispose();
+            _websocket?.Dispose();
+        }
+        public void Close()
+        {
+            _socket?.Close();
+            CloseWebSocket();
+        }
+
+        public void Shutdown(SocketShutdown how)
+        {
+            _socket?.Shutdown(how);
+            CloseWebSocket();
+        }
+
+        private void CloseWebSocket()
+        {
+            if (_websocket != null && (_websocket.State == WebSocketState.Open || _websocket.State == WebSocketState.Connecting || _websocket.State == WebSocketState.None))
+            {
+                try
+                {
+                    var task = _websocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "closing remoteLoop", CancellationToken.None);
+                    // Block and wait for the task to complete synchronously
+                    Task.WaitAll(task);
+                }
+                catch (Exception)
+                {
+                }
+            }            
+        }
+    }
+
     public abstract class GenericLoopbackConnection : IDisposable
     {
         public abstract void Dispose();
diff --git a/src/libraries/Common/tests/System/Net/Http/Http2LoopbackConnection.cs b/src/libraries/Common/tests/System/Net/Http/Http2LoopbackConnection.cs
index 01fa9d4e697b5f..5dcbc2d3863e3a 100644
--- a/src/libraries/Common/tests/System/Net/Http/Http2LoopbackConnection.cs
+++ b/src/libraries/Common/tests/System/Net/Http/Http2LoopbackConnection.cs
@@ -20,7 +20,7 @@ public class Http2LoopbackConnection : GenericLoopbackConnection
     {
         public const string Http2Prefix = "PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n";
 
-        private Socket _connectionSocket;
+        private SocketWrapper _connectionSocket;
         private Stream _connectionStream;
         private TaskCompletionSource<bool> _ignoredSettingsAckPromise;
         private bool _ignoreWindowUpdates;
@@ -34,19 +34,19 @@ public class Http2LoopbackConnection : GenericLoopbackConnection
         public Stream Stream => _connectionStream;
         public Task<bool> SettingAckWaiter => _ignoredSettingsAckPromise?.Task;
 
-        private Http2LoopbackConnection(Socket socket, Stream stream, TimeSpan timeout)
+        private Http2LoopbackConnection(SocketWrapper socket, Stream stream, TimeSpan timeout)
         {
             _connectionSocket = socket;
             _connectionStream = stream;
             _timeout = timeout;
         }
 
-        public static Task<Http2LoopbackConnection> CreateAsync(Socket socket, Stream stream, Http2Options httpOptions)
+        public static Task<Http2LoopbackConnection> CreateAsync(SocketWrapper socket, Stream stream, Http2Options httpOptions)
         {
             return CreateAsync(socket, stream, httpOptions, Http2LoopbackServer.Timeout);
         }
 
-        public static async Task<Http2LoopbackConnection> CreateAsync(Socket socket, Stream stream, Http2Options httpOptions, TimeSpan timeout)
+        public static async Task<Http2LoopbackConnection> CreateAsync(SocketWrapper socket, Stream stream, Http2Options httpOptions, TimeSpan timeout)
         {
             if (httpOptions.UseSsl)
             {
@@ -230,9 +230,9 @@ private async Task<Frame> ReadFrameAsync(CancellationToken cancellationToken)
         }
 
         // Reset and return underlying networking objects.
-        public (Socket, Stream) ResetNetwork()
+        public (SocketWrapper, Stream) ResetNetwork()
         {
-            Socket oldSocket = _connectionSocket;
+            SocketWrapper oldSocket = _connectionSocket;
             Stream oldStream = _connectionStream;
             _connectionSocket = null;
             _connectionStream = null;
diff --git a/src/libraries/Common/tests/System/Net/Http/Http2LoopbackServer.cs b/src/libraries/Common/tests/System/Net/Http/Http2LoopbackServer.cs
index 45c2edf3459517..45df14c0380eaf 100644
--- a/src/libraries/Common/tests/System/Net/Http/Http2LoopbackServer.cs
+++ b/src/libraries/Common/tests/System/Net/Http/Http2LoopbackServer.cs
@@ -91,9 +91,10 @@ public async Task<Http2LoopbackConnection> AcceptConnectionAsync(TimeSpan? timeo
             Socket connectionSocket = await _listenSocket.AcceptAsync().ConfigureAwait(false);
 
             var stream = new NetworkStream(connectionSocket, ownsSocket: true);
+            var wrapper = new SocketWrapper(connectionSocket);
             Http2LoopbackConnection connection =
-                timeout != null ? await Http2LoopbackConnection.CreateAsync(connectionSocket, stream, _options, timeout.Value).ConfigureAwait(false) :
-                await Http2LoopbackConnection.CreateAsync(connectionSocket, stream, _options).ConfigureAwait(false);
+                timeout != null ? await Http2LoopbackConnection.CreateAsync(wrapper, stream, _options, timeout.Value).ConfigureAwait(false) :
+                await Http2LoopbackConnection.CreateAsync(wrapper, stream, _options).ConfigureAwait(false);
             _connections.Add(connection);
 
             return connection;
@@ -201,7 +202,7 @@ public override GenericLoopbackServer CreateServer(GenericLoopbackOptions option
             return Http2LoopbackServer.CreateServer(CreateOptions(options));
         }
 
-        public override async Task<GenericLoopbackConnection> CreateConnectionAsync(Socket socket, Stream stream, GenericLoopbackOptions options = null)
+        public override async Task<GenericLoopbackConnection> CreateConnectionAsync(SocketWrapper socket, Stream stream, GenericLoopbackOptions options = null)
         {
             return await Http2LoopbackConnection.CreateAsync(socket, stream, CreateOptions(options)).ConfigureAwait(false);
         }
diff --git a/src/libraries/Common/tests/System/Net/Http/Http3LoopbackServer.cs b/src/libraries/Common/tests/System/Net/Http/Http3LoopbackServer.cs
index 1be1364220a242..b84393a88b1d88 100644
--- a/src/libraries/Common/tests/System/Net/Http/Http3LoopbackServer.cs
+++ b/src/libraries/Common/tests/System/Net/Http/Http3LoopbackServer.cs
@@ -20,26 +20,32 @@ public sealed class Http3LoopbackServer : GenericLoopbackServer
 
         public override Uri Address => new Uri($"https://{_listener.ListenEndPoint}/");
 
-        public Http3LoopbackServer(QuicImplementationProvider quicImplementationProvider = null, GenericLoopbackOptions options = null)
+        public Http3LoopbackServer(QuicImplementationProvider quicImplementationProvider = null, Http3Options options = null)
         {
-            options ??= new GenericLoopbackOptions();
+            options ??= new Http3Options();
 
             _cert = Configuration.Certificates.GetServerCertificate();
 
-            var sslOpts = new SslServerAuthenticationOptions
+            var listenerOptions = new QuicListenerOptions()
             {
-                EnabledSslProtocols = options.SslProtocols,
-                ApplicationProtocols = new List<SslApplicationProtocol>
+                ListenEndPoint = new IPEndPoint(options.Address, 0),
+                ServerAuthenticationOptions = new SslServerAuthenticationOptions
                 {
-                    new SslApplicationProtocol("h3-31"),
-                    new SslApplicationProtocol("h3-30"),
-                    new SslApplicationProtocol("h3-29")
+                    EnabledSslProtocols = options.SslProtocols,
+                    ApplicationProtocols = new List<SslApplicationProtocol>
+                    {
+                        new SslApplicationProtocol("h3-31"),
+                        new SslApplicationProtocol("h3-30"),
+                        new SslApplicationProtocol("h3-29")
+                    },
+                    ServerCertificate = _cert,
+                    ClientCertificateRequired = false
                 },
-                ServerCertificate = _cert,
-                ClientCertificateRequired = false
+                MaxUnidirectionalStreams = options.MaxUnidirectionalStreams,
+                MaxBidirectionalStreams = options.MaxBidirectionalStreams,
             };
 
-            _listener = new QuicListener(quicImplementationProvider ?? QuicImplementationProviders.Default, new IPEndPoint(options.Address, 0), sslOpts);
+            _listener = new QuicListener(quicImplementationProvider ?? QuicImplementationProviders.Default, listenerOptions);
         }
 
         public override void Dispose()
@@ -82,7 +88,7 @@ public Http3LoopbackServerFactory(QuicImplementationProvider quicImplementationP
 
         public override GenericLoopbackServer CreateServer(GenericLoopbackOptions options = null)
         {
-            return new Http3LoopbackServer(_quicImplementationProvider, options);
+            return new Http3LoopbackServer(_quicImplementationProvider, CreateOptions(options));
         }
 
         public override async Task CreateServerAsync(Func<GenericLoopbackServer, Uri, Task> funcAsync, int millisecondsTimeout = 60000, GenericLoopbackOptions options = null)
@@ -91,11 +97,35 @@ public override async Task CreateServerAsync(Func<GenericLoopbackServer, Uri, Ta
             await funcAsync(server, server.Address).WaitAsync(TimeSpan.FromMilliseconds(millisecondsTimeout));
         }
 
-        public override Task<GenericLoopbackConnection> CreateConnectionAsync(Socket socket, Stream stream, GenericLoopbackOptions options = null)
+        public override Task<GenericLoopbackConnection> CreateConnectionAsync(SocketWrapper socket, Stream stream, GenericLoopbackOptions options = null)
         {
             // TODO: make a new overload that takes a MultiplexedConnection.
             // This method is always unacceptable to call for HTTP/3.
             throw new NotImplementedException("HTTP/3 does not operate over a Socket.");
         }
+
+        private static Http3Options CreateOptions(GenericLoopbackOptions options)
+        {
+            Http3Options http3Options = new Http3Options();
+            if (options != null)
+            {
+                http3Options.Address = options.Address;
+                http3Options.UseSsl = options.UseSsl;
+                http3Options.SslProtocols = options.SslProtocols;
+                http3Options.ListenBacklog = options.ListenBacklog;
+            }
+            return http3Options;
+        }
+    }
+    public class Http3Options : GenericLoopbackOptions
+    {
+        public int MaxUnidirectionalStreams {get; set; }
+
+        public int MaxBidirectionalStreams {get; set; }
+        public Http3Options()
+        {
+            MaxUnidirectionalStreams = 100;
+            MaxBidirectionalStreams = 100;
+        }
     }
 }
diff --git a/src/libraries/Common/tests/System/Net/Http/HttpAgnosticLoopbackServer.cs b/src/libraries/Common/tests/System/Net/Http/HttpAgnosticLoopbackServer.cs
index ae436df429a1dc..88a8071153e6c0 100644
--- a/src/libraries/Common/tests/System/Net/Http/HttpAgnosticLoopbackServer.cs
+++ b/src/libraries/Common/tests/System/Net/Http/HttpAgnosticLoopbackServer.cs
@@ -87,13 +87,13 @@ public override async Task<GenericLoopbackConnection> EstablishGenericConnection
                     if (sslStream.NegotiatedApplicationProtocol == SslApplicationProtocol.Http2)
                     {
                         // Do not pass original options so the CreateConnectionAsync won't try to do ALPN again.
-                        return connection = await Http2LoopbackServerFactory.Singleton.CreateConnectionAsync(socket, stream, options).ConfigureAwait(false);
+                        return connection = await Http2LoopbackServerFactory.Singleton.CreateConnectionAsync(new SocketWrapper(socket), stream, options).ConfigureAwait(false);
                     }
                     if (sslStream.NegotiatedApplicationProtocol == SslApplicationProtocol.Http11 ||
                         sslStream.NegotiatedApplicationProtocol == default)
                     {
                         // Do not pass original options so the CreateConnectionAsync won't try to do ALPN again.
-                        return connection = await Http11LoopbackServerFactory.Singleton.CreateConnectionAsync(socket, stream, options).ConfigureAwait(false);
+                        return connection = await Http11LoopbackServerFactory.Singleton.CreateConnectionAsync(new SocketWrapper(socket), stream, options).ConfigureAwait(false);
                     }
                     else
                     {
@@ -103,11 +103,11 @@ public override async Task<GenericLoopbackConnection> EstablishGenericConnection
 
                 if (_options.ClearTextVersion == HttpVersion.Version11)
                 {
-                    return connection = await Http11LoopbackServerFactory.Singleton.CreateConnectionAsync(socket, stream, options).ConfigureAwait(false);
+                    return connection = await Http11LoopbackServerFactory.Singleton.CreateConnectionAsync(new SocketWrapper(socket), stream, options).ConfigureAwait(false);
                 }
                 else if (_options.ClearTextVersion == HttpVersion.Version20)
                 {
-                    return connection = await Http2LoopbackServerFactory.Singleton.CreateConnectionAsync(socket, stream, options).ConfigureAwait(false);
+                    return connection = await Http2LoopbackServerFactory.Singleton.CreateConnectionAsync(new SocketWrapper(socket), stream, options).ConfigureAwait(false);
                 }
                 else 
                 {
@@ -187,7 +187,7 @@ public override GenericLoopbackServer CreateServer(GenericLoopbackOptions option
             return HttpAgnosticLoopbackServer.CreateServer(CreateOptions(options));
         }
 
-        public override Task<GenericLoopbackConnection> CreateConnectionAsync(Socket socket, Stream stream, GenericLoopbackOptions options = null)
+        public override Task<GenericLoopbackConnection> CreateConnectionAsync(SocketWrapper socket, Stream stream, GenericLoopbackOptions options = null)
         {
             // This method is always unacceptable to call for an agnostic server.
             throw new NotImplementedException("HttpAgnosticLoopbackServerFactory cannot create connection.");
diff --git a/src/libraries/Common/tests/System/Net/Http/HttpClientHandlerTest.Authentication.cs b/src/libraries/Common/tests/System/Net/Http/HttpClientHandlerTest.Authentication.cs
index 4df4100a8ed417..f7ccc3127e9abc 100644
--- a/src/libraries/Common/tests/System/Net/Http/HttpClientHandlerTest.Authentication.cs
+++ b/src/libraries/Common/tests/System/Net/Http/HttpClientHandlerTest.Authentication.cs
@@ -104,7 +104,6 @@ public static IEnumerable<object[]> Authentication_SocketsHttpHandler_TestData()
 
         [Theory]
         [MemberData(nameof(Authentication_TestData))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/39187", TestPlatforms.Browser)]
         public async Task HttpClientHandler_Authentication_Succeeds(string authenticateHeader, bool result)
         {
             if (PlatformDetection.IsWindowsNanoServer)
@@ -144,7 +143,6 @@ public async Task HttpClientHandler_MultipleAuthenticateHeaders_WithSameAuth_Suc
         [Theory]
         [InlineData("WWW-Authenticate: Basic realm=\"hello\"\r\nWWW-Authenticate: Digest realm=\"hello\", nonce=\"hello\", algorithm=MD5\r\n")]
         [InlineData("WWW-Authenticate: Digest realm=\"hello\", nonce=\"hello\", algorithm=MD5\r\nWWW-Authenticate: Basic realm=\"hello\"\r\n")]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/39187", TestPlatforms.Browser)]
         public async Task HttpClientHandler_MultipleAuthenticateHeaders_Succeeds(string authenticateHeader)
         {
             if (PlatformDetection.IsWindowsNanoServer)
@@ -164,7 +162,6 @@ await LoopbackServer.CreateServerAsync(async (server, url) =>
         [Theory]
         [InlineData("WWW-Authenticate: Basic realm=\"hello\"\r\nWWW-Authenticate: NTLM\r\n", "Basic", "Negotiate")]
         [InlineData("WWW-Authenticate: Basic realm=\"hello\"\r\nWWW-Authenticate: Digest realm=\"hello\", nonce=\"hello\", algorithm=MD5\r\nWWW-Authenticate: NTLM\r\n", "Digest", "Negotiate")]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/39187", TestPlatforms.Browser)]
         public async Task HttpClientHandler_MultipleAuthenticateHeaders_PicksSupported(string authenticateHeader, string supportedAuth, string unsupportedAuth)
         {
             if (PlatformDetection.IsWindowsNanoServer)
@@ -190,7 +187,6 @@ await LoopbackServer.CreateServerAsync(async (server, url) =>
         [Theory]
         [InlineData("WWW-Authenticate: Basic realm=\"hello\"\r\n")]
         [InlineData("WWW-Authenticate: Digest realm=\"hello\", nonce=\"testnonce\"\r\n")]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/39187", TestPlatforms.Browser)]
         public async Task HttpClientHandler_IncorrectCredentials_Fails(string authenticateHeader)
         {
             var options = new LoopbackServer.Options { Domain = Domain, Username = Username, Password = Password };
@@ -228,7 +224,6 @@ public static IEnumerable<object[]> Authentication_TestData()
         [InlineData("NTLM")]
         [InlineData("Kerberos")]
         [InlineData("Negotiate")]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/39187", TestPlatforms.Browser)]
         public async Task PreAuthenticate_NoPreviousAuthenticatedRequests_NoCredentialsSent(string credCacheScheme)
         {
             const int NumRequests = 3;
@@ -271,7 +266,6 @@ await LoopbackServer.CreateClientAndServerAsync(async uri =>
         [Theory]
         [InlineData(null, "WWW-Authenticate: Basic realm=\"hello\"\r\n")]
         [InlineData("Basic", "WWW-Authenticate: Basic realm=\"hello\"\r\n")]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/39187", TestPlatforms.Browser)]
         public async Task PreAuthenticate_FirstRequestNoHeaderAndAuthenticates_SecondRequestPreauthenticates(string credCacheScheme, string authResponse)
         {
             await LoopbackServer.CreateClientAndServerAsync(async uri =>
@@ -364,7 +358,6 @@ await LoopbackServer.CreateClientAndServerAsync(async uri =>
         [InlineData((HttpStatusCode)508)] // LoopDetected
         [InlineData((HttpStatusCode)510)] // NotExtended
         [InlineData((HttpStatusCode)511)] // NetworkAuthenticationRequired
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/39187", TestPlatforms.Browser)]
         public async Task PreAuthenticate_FirstRequestNoHeader_SecondRequestVariousStatusCodes_ThirdRequestPreauthenticates(HttpStatusCode statusCode)
         {
             const string AuthResponse = "WWW-Authenticate: Basic realm=\"hello\"\r\n";
@@ -408,7 +401,6 @@ await LoopbackServer.CreateClientAndServerAsync(async uri =>
         [InlineData("/something/hello.html", "/world.html", false)]
         [InlineData("/something/hello.html", "/another/", false)]
         [InlineData("/something/hello.html", "/another/hello.html", false)]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/39187", TestPlatforms.Browser)]
         public async Task PreAuthenticate_AuthenticatedUrl_ThenTryDifferentUrl_SendsAuthHeaderOnlyIfPrefixMatches(
             string originalRelativeUri, string secondRelativeUri, bool expectedAuthHeader)
         {
@@ -448,7 +440,6 @@ await LoopbackServer.CreateClientAndServerAsync(async uri =>
         }
 
         [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/39187", TestPlatforms.Browser)]
         public async Task PreAuthenticate_SuccessfulBasicButThenFails_DoesntLoopInfinitely()
         {
             await LoopbackServer.CreateClientAndServerAsync(async uri =>
@@ -487,7 +478,6 @@ await LoopbackServer.CreateClientAndServerAsync(async uri =>
         }
 
         [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/39187", TestPlatforms.Browser)]
         public async Task PreAuthenticate_SuccessfulBasic_ThenDigestChallenged()
         {
             if (IsWinHttpHandler)
diff --git a/src/libraries/Common/tests/System/Net/Http/HttpClientHandlerTest.Cancellation.cs b/src/libraries/Common/tests/System/Net/Http/HttpClientHandlerTest.Cancellation.cs
index d246ca53e9303a..410d2a6987b60c 100644
--- a/src/libraries/Common/tests/System/Net/Http/HttpClientHandlerTest.Cancellation.cs
+++ b/src/libraries/Common/tests/System/Net/Http/HttpClientHandlerTest.Cancellation.cs
@@ -329,6 +329,7 @@ await LoopbackServerFactory.CreateServerAsync(async (server, url) =>
         }
 
         [Fact]
+        [SkipOnPlatform(TestPlatforms.Browser, "MaxConnectionsPerServer is not supported on Browser")]
         public async Task MaxConnectionsPerServer_WaitingConnectionsAreCancelable()
         {
             if (LoopbackServerFactory.Version >= HttpVersion20.Value)
diff --git a/src/libraries/Common/tests/System/Net/Http/HttpClientHandlerTest.Cookies.cs b/src/libraries/Common/tests/System/Net/Http/HttpClientHandlerTest.Cookies.cs
index e722e8bb37c517..dbb1382c9aaf58 100644
--- a/src/libraries/Common/tests/System/Net/Http/HttpClientHandlerTest.Cookies.cs
+++ b/src/libraries/Common/tests/System/Net/Http/HttpClientHandlerTest.Cookies.cs
@@ -63,6 +63,7 @@ await LoopbackServerFactory.CreateClientAndServerAsync(
 
         [Theory]
         [MemberData(nameof(CookieNamesValuesAndUseCookies))]
+        [SkipOnPlatform(TestPlatforms.Browser, "CookieContainer is not supported on Browser")]
         public async Task GetAsync_SetCookieContainer_CookieSent(string cookieName, string cookieValue, bool useCookies)
         {
             await LoopbackServerFactory.CreateClientAndServerAsync(
@@ -92,6 +93,7 @@ await LoopbackServerFactory.CreateClientAndServerAsync(
         }
 
         [Fact]
+        [SkipOnPlatform(TestPlatforms.Browser, "CookieContainer is not supported on Browser")]
         public async Task GetAsync_SetCookieContainerMultipleCookies_CookiesSent()
         {
             var cookies = new Cookie[]
@@ -211,6 +213,7 @@ private string GetCookieValue(HttpRequestData request)
         }
 
         [Fact]
+        [SkipOnPlatform(TestPlatforms.Browser, "CookieContainer is not supported on Browser")]
         public async Task GetAsync_SetCookieContainerAndCookieHeader_BothCookiesSent()
         {
             await LoopbackServerFactory.CreateServerAsync(async (server, url) =>
@@ -238,6 +241,7 @@ await LoopbackServerFactory.CreateServerAsync(async (server, url) =>
         }
 
         [Fact]
+        [SkipOnPlatform(TestPlatforms.Browser, "CookieContainer is not supported on Browser")]
         public async Task GetAsync_SetCookieContainerAndMultipleCookieHeaders_BothCookiesSent()
         {
             await LoopbackServerFactory.CreateServerAsync(async (server, url) =>
@@ -289,6 +293,7 @@ await LoopbackServerFactory.CreateServerAsync(async (server, url) =>
         }
 
         [Fact]
+        [SkipOnPlatform(TestPlatforms.Browser, "CookieContainer is not supported on Browser")]
         public async Task GetAsyncWithRedirect_SetCookieContainer_CorrectCookiesSent()
         {
             const string path1 = "/foo";
@@ -329,6 +334,7 @@ await LoopbackServerFactory.CreateClientAndServerAsync(async url =>
 
         [Theory]
         [MemberData(nameof(CookieNamesValuesAndUseCookies))]
+        [SkipOnPlatform(TestPlatforms.Browser, "CookieContainer is not supported on Browser")]
         public async Task GetAsync_ReceiveSetCookieHeader_CookieAdded(string cookieName, string cookieValue, bool useCookies)
         {
             await LoopbackServerFactory.CreateServerAsync(async (server, url) =>
@@ -360,6 +366,7 @@ await LoopbackServerFactory.CreateServerAsync(async (server, url) =>
         }
 
         [Fact]
+        [SkipOnPlatform(TestPlatforms.Browser, "CookieContainer is not supported on Browser")]
         public async Task GetAsync_ReceiveMultipleSetCookieHeaders_CookieAdded()
         {
             await LoopbackServerFactory.CreateServerAsync(async (server, url) =>
@@ -399,6 +406,7 @@ await LoopbackServerFactory.CreateServerAsync(async (server, url) =>
         // the cookie should be added with Path=/path.
         // ConditionalFact: CookieContainer does not follow RFC6265 on .NET Framework, therefore the (WinHttpHandler) test is expected to fail
         [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNotNetFramework))]
+        [SkipOnPlatform(TestPlatforms.Browser, "CookieContainer is not supported on Browser")]
         public async Task GetAsync_NoPathDefined_CookieAddedWithDefaultPath()
         {
             await LoopbackServerFactory.CreateServerAsync(async (server, serverUrl) =>
@@ -428,6 +436,7 @@ await LoopbackServerFactory.CreateServerAsync(async (server, serverUrl) =>
         // these cookies should be accepted by the client.
         // ConditionalFact: CookieContainer does not follow RFC6265 on .NET Framework, therefore the (WinHttpHandler) test is expected to fail
         [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNotNetFramework))]
+        [SkipOnPlatform(TestPlatforms.Browser, "CookieContainer is not supported on Browser")]
         public async Task GetAsync_CookiePathDoesNotMatchRequestPath_CookieAccepted()
         {
             await LoopbackServerFactory.CreateServerAsync(async (server, serverUrl) =>
@@ -459,6 +468,7 @@ await LoopbackServerFactory.CreateServerAsync(async (server, serverUrl) =>
         // https://github.com/dotnet/runtime/issues/26141#issuecomment-612097147
         // ConditionalFact: CookieContainer does not follow RFC6265 on .NET Framework, therefore the (WinHttpHandler) test is expected to fail
         [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNotNetFramework))]
+        [SkipOnPlatform(TestPlatforms.Browser, "CookieContainer is not supported on Browser")]
         public async Task GetAsync_Redirect_CookiesArePreserved()
         {
             HttpClientHandler handler = CreateHttpClientHandler();
@@ -501,6 +511,7 @@ await LoopbackServerFactory.CreateClientAndServerAsync(async serverUrl =>
         }
 
         [Fact]
+        [SkipOnPlatform(TestPlatforms.Browser, "CookieContainer is not supported on Browser")]
         public async Task GetAsync_ReceiveSetCookieHeader_CookieUpdated()
         {
             const string newCookieValue = "789";
@@ -528,6 +539,7 @@ await LoopbackServerFactory.CreateServerAsync(async (server, url) =>
         }
 
         [Fact]
+        [SkipOnPlatform(TestPlatforms.Browser, "CookieContainer is not supported on Browser")]
         public async Task GetAsync_ReceiveSetCookieHeader_CookieRemoved()
         {
             await LoopbackServerFactory.CreateServerAsync(async (server, url) =>
@@ -551,6 +563,7 @@ await LoopbackServerFactory.CreateServerAsync(async (server, url) =>
         }
 
         [Fact]
+        [SkipOnPlatform(TestPlatforms.Browser, "CookieContainer is not supported on Browser")]
         public async Task GetAsync_ReceiveInvalidSetCookieHeader_ValidCookiesAdded()
         {
             await LoopbackServerFactory.CreateServerAsync(async (server, url) =>
@@ -585,6 +598,7 @@ await LoopbackServerFactory.CreateServerAsync(async (server, url) =>
         }
 
         [Fact]
+        [SkipOnPlatform(TestPlatforms.Browser, "CookieContainer is not supported on Browser")]
         public async Task GetAsyncWithRedirect_ReceiveSetCookie_CookieSent()
         {
             const string path1 = "/foo";
@@ -638,6 +652,7 @@ await LoopbackServerFactory.CreateClientAndServerAsync(async url =>
         }
 
         [Fact]
+        [SkipOnPlatform(TestPlatforms.Browser, "CookieContainer is not supported on Browser")]
         public async Task GetAsyncWithBasicAuth_ReceiveSetCookie_CookieSent()
         {
             if (IsWinHttpHandler)
@@ -757,6 +772,7 @@ public abstract class HttpClientHandlerTest_Cookies_Http11 : HttpClientHandlerTe
         public HttpClientHandlerTest_Cookies_Http11(ITestOutputHelper output) : base(output) { }
 
         [Fact]
+        [SkipOnPlatform(TestPlatforms.Browser, "CookieContainer is not supported on Browser")]
         public async Task GetAsync_ReceiveMultipleSetCookieHeaders_CookieAdded()
         {
             await LoopbackServer.CreateServerAsync(async (server, url) =>
diff --git a/src/libraries/Common/tests/System/Net/Http/HttpClientHandlerTest.Decompression.cs b/src/libraries/Common/tests/System/Net/Http/HttpClientHandlerTest.Decompression.cs
index 6cf46633cc69bb..f53b6fcb910f86 100644
--- a/src/libraries/Common/tests/System/Net/Http/HttpClientHandlerTest.Decompression.cs
+++ b/src/libraries/Common/tests/System/Net/Http/HttpClientHandlerTest.Decompression.cs
@@ -46,7 +46,7 @@ public static IEnumerable<object[]> RemoteServersAndCompressionUris()
         [InlineData("deflate", true)]
         [InlineData("br", false)]
         [InlineData("br", true)]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/39187", TestPlatforms.Browser)]
+        [SkipOnPlatform(TestPlatforms.Browser, "AutomaticDecompression not supported on Browser")]
         public async Task DecompressedResponse_MethodSpecified_DecompressedContentReturned(string encodingName, bool all)
         {
             Func<Stream, Stream> compress;
@@ -136,7 +136,7 @@ public static IEnumerable<object[]> DecompressedResponse_MethodNotSpecified_Orig
 
         [Theory]
         [MemberData(nameof(DecompressedResponse_MethodNotSpecified_OriginalContentReturned_MemberData))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/39187", TestPlatforms.Browser)]
+        [SkipOnPlatform(TestPlatforms.Browser, "AutomaticDecompression not supported on Browser")]
         public async Task DecompressedResponse_MethodNotSpecified_OriginalContentReturned(
             string encodingName, Func<Stream, Stream> compress, DecompressionMethods methods)
         {
@@ -263,7 +263,7 @@ public async Task GetAsync_SetAutomaticDecompression_HeadersRemoved(Configuratio
         [InlineData(DecompressionMethods.Deflate, "deflate", "gzip")]
         [InlineData(DecompressionMethods.Deflate, "deflate", "br")]
         [InlineData(DecompressionMethods.GZip | DecompressionMethods.Deflate, "gzip, deflate", "gzip, deflate")]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/39187", TestPlatforms.Browser)]
+        [SkipOnPlatform(TestPlatforms.Browser, "AutomaticDecompression not supported on Browser")]
         public async Task GetAsync_SetAutomaticDecompression_AcceptEncodingHeaderSentWithNoDuplicates(
             DecompressionMethods methods,
             string encodings,
@@ -316,7 +316,7 @@ await LoopbackServer.CreateServerAsync(async (server, url) =>
 #endif
         [InlineData(DecompressionMethods.GZip | DecompressionMethods.Deflate, "gzip; q=1.0, deflate; q=1.0", "")]
         [InlineData(DecompressionMethods.GZip | DecompressionMethods.Deflate, "gzip; q=1.0", "deflate")]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/39187", TestPlatforms.Browser)]
+        [SkipOnPlatform(TestPlatforms.Browser, "AutomaticDecompression not supported on Browser")]
         public async Task GetAsync_SetAutomaticDecompression_AcceptEncodingHeaderSentWithQualityWeightingsNoDuplicates(
             DecompressionMethods methods,
             string manualAcceptEncodingHeaderValues,
diff --git a/src/libraries/Common/tests/System/Net/Http/HttpClientHandlerTest.RemoteServer.cs b/src/libraries/Common/tests/System/Net/Http/HttpClientHandlerTest.RemoteServer.cs
index fcf578b63cd63d..732384e64ed24e 100644
--- a/src/libraries/Common/tests/System/Net/Http/HttpClientHandlerTest.RemoteServer.cs
+++ b/src/libraries/Common/tests/System/Net/Http/HttpClientHandlerTest.RemoteServer.cs
@@ -77,9 +77,9 @@ public async Task UseDefaultCredentials_SetToFalseAndServerNeedsAuth_StatusCodeU
             }
         }
 
-        [OuterLoop("Uses external servers")]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/37669", TestPlatforms.Browser)]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [Theory, MemberData(nameof(RemoteServersMemberData))]
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/37669", TestPlatforms.Browser)]
         public async Task SendAsync_SimpleGet_Success(Configuration.Http.RemoteServer remoteServer)
         {
             using (HttpClient client = CreateHttpClientForRemoteServer(remoteServer))
@@ -95,9 +95,8 @@ public async Task SendAsync_SimpleGet_Success(Configuration.Http.RemoteServer re
             }
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [Theory, MemberData(nameof(RemoteServersMemberData))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/53018", TestPlatforms.Browser)]
         public async Task SendAsync_MultipleRequestsReusingSameClient_Success(Configuration.Http.RemoteServer remoteServer)
         {
             using (HttpClient client = CreateHttpClientForRemoteServer(remoteServer))
@@ -112,9 +111,8 @@ public async Task SendAsync_MultipleRequestsReusingSameClient_Success(Configurat
             }
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [Theory, MemberData(nameof(RemoteServersMemberData))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/53018", TestPlatforms.Browser)]
         public async Task GetAsync_ResponseContentAfterClientAndHandlerDispose_Success(Configuration.Http.RemoteServer remoteServer)
         {
             using (HttpClient client = CreateHttpClientForRemoteServer(remoteServer))
@@ -162,9 +160,8 @@ public async Task GetAsync_ServerNeedsAuthAndSetCredential_StatusCodeOK(Configur
             }
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [Theory, MemberData(nameof(RemoteServersMemberData))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/53018", TestPlatforms.Browser)]
         public async Task GetAsync_ServerNeedsAuthAndNoCredential_StatusCodeUnauthorized(Configuration.Http.RemoteServer remoteServer)
         {
             using (HttpClient client = CreateHttpClientForRemoteServer(remoteServer))
@@ -177,10 +174,10 @@ public async Task GetAsync_ServerNeedsAuthAndNoCredential_StatusCodeUnauthorized
             }
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [Theory]
         [MemberData(nameof(RemoteServersAndHeaderEchoUrisMemberData))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/53018", TestPlatforms.Browser)]
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/53872", TestPlatforms.Browser)]
         public async Task GetAsync_RequestHeadersAddCustomHeaders_HeaderAndEmptyValueSent(Configuration.Http.RemoteServer remoteServer, Uri uri)
         {
             if (IsWinHttpHandler && !PlatformDetection.IsWindows10Version1709OrGreater)
@@ -204,9 +201,8 @@ public async Task GetAsync_RequestHeadersAddCustomHeaders_HeaderAndEmptyValueSen
             }
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [Theory, MemberData(nameof(RemoteServersHeaderValuesAndUris))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/53018", TestPlatforms.Browser)]
         public async Task GetAsync_RequestHeadersAddCustomHeaders_HeaderAndValueSent(Configuration.Http.RemoteServer remoteServer, string name, string value, Uri uri)
         {
             using (HttpClient client = CreateHttpClientForRemoteServer(remoteServer))
@@ -223,9 +219,8 @@ public async Task GetAsync_RequestHeadersAddCustomHeaders_HeaderAndValueSent(Con
             }
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [Theory, MemberData(nameof(RemoteServersAndHeaderEchoUrisMemberData))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/53018", TestPlatforms.Browser)]
         public async Task GetAsync_LargeRequestHeader_HeadersAndValuesSent(Configuration.Http.RemoteServer remoteServer, Uri uri)
         {
             // Unfortunately, our remote servers seem to have pretty strict limits (around 16K?)
@@ -291,9 +286,8 @@ public static IEnumerable<object[]> RemoteServersHeaderValuesAndUris()
 
         public static IEnumerable<object[]> RemoteServersAndHeaderEchoUrisMemberData() => RemoteServersAndHeaderEchoUris().Select(x => new object[] { x.remoteServer, x.uri });
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [Theory, MemberData(nameof(RemoteServersMemberData))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/53018", TestPlatforms.Browser)]
         public async Task GetAsync_ResponseHeadersRead_ReadFromEachIterativelyDoesntDeadlock(Configuration.Http.RemoteServer remoteServer)
         {
             using (HttpClient client = CreateHttpClientForRemoteServer(remoteServer))
@@ -317,9 +311,8 @@ public async Task GetAsync_ResponseHeadersRead_ReadFromEachIterativelyDoesntDead
             }
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [Theory, MemberData(nameof(RemoteServersMemberData))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/53018", TestPlatforms.Browser)]
         public async Task SendAsync_HttpRequestMsgResponseHeadersRead_StatusCodeOK(Configuration.Http.RemoteServer remoteServer)
         {
             // Sync API supported only up to HTTP/1.1
@@ -344,16 +337,25 @@ public async Task SendAsync_HttpRequestMsgResponseHeadersRead_StatusCodeOK(Confi
             }
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [Theory, MemberData(nameof(RemoteServersMemberData))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/37669", TestPlatforms.Browser)]
         public async Task PostAsync_CallMethodTwice_StringContent(Configuration.Http.RemoteServer remoteServer)
         {
             using (HttpClient client = CreateHttpClientForRemoteServer(remoteServer))
             {
                 string data = "Test String";
                 var content = new StringContent(data, Encoding.UTF8);
-                content.Headers.ContentMD5 = TestHelper.ComputeMD5Hash(data);
+
+                if (PlatformDetection.IsBrowser)
+                {
+                    // [ActiveIssue("https://github.com/dotnet/runtime/issues/37669", TestPlatforms.Browser)]
+                    content.Headers.Add("Content-MD5-Skip", "browser");
+                }
+                else
+                {
+                    content.Headers.ContentMD5 = TestHelper.ComputeMD5Hash(data);
+                }
+
                 HttpResponseMessage response;
                 using (response = await client.PostAsync(remoteServer.VerifyUploadUri, content))
                 {
@@ -362,7 +364,16 @@ public async Task PostAsync_CallMethodTwice_StringContent(Configuration.Http.Rem
 
                 // Repeat call.
                 content = new StringContent(data, Encoding.UTF8);
-                content.Headers.ContentMD5 = TestHelper.ComputeMD5Hash(data);
+                if (PlatformDetection.IsBrowser)
+                {
+                    // [ActiveIssue("https://github.com/dotnet/runtime/issues/37669", TestPlatforms.Browser)]
+                    content.Headers.Add("Content-MD5-Skip", "browser");
+                }
+                else
+                {
+                    content.Headers.ContentMD5 = TestHelper.ComputeMD5Hash(data);
+                }
+
                 using (response = await client.PostAsync(remoteServer.VerifyUploadUri, content))
                 {
                     Assert.Equal(HttpStatusCode.OK, response.StatusCode);
@@ -370,16 +381,23 @@ public async Task PostAsync_CallMethodTwice_StringContent(Configuration.Http.Rem
             }
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [Theory, MemberData(nameof(RemoteServersMemberData))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/37669", TestPlatforms.Browser)]
         public async Task PostAsync_CallMethod_UnicodeStringContent(Configuration.Http.RemoteServer remoteServer)
         {
             using (HttpClient client = CreateHttpClientForRemoteServer(remoteServer))
             {
                 string data = "\ub4f1\uffc7\u4e82\u67ab4\uc6d4\ud1a0\uc694\uc77c\uffda3\u3155\uc218\uffdb";
                 var content = new StringContent(data, Encoding.UTF8);
-                content.Headers.ContentMD5 = TestHelper.ComputeMD5Hash(data);
+                if (PlatformDetection.IsBrowser)
+                {
+                    // [ActiveIssue("https://github.com/dotnet/runtime/issues/37669", TestPlatforms.Browser)]
+                    content.Headers.Add("Content-MD5-Skip", "browser");
+                }
+                else
+                {
+                    content.Headers.ContentMD5 = TestHelper.ComputeMD5Hash(data);
+                }
 
                 using (HttpResponseMessage response = await client.PostAsync(remoteServer.VerifyUploadUri, content))
                 {
@@ -388,14 +406,21 @@ public async Task PostAsync_CallMethod_UnicodeStringContent(Configuration.Http.R
             }
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [Theory, MemberData(nameof(VerifyUploadServersStreamsAndExpectedData))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/37669", TestPlatforms.Browser)] 
         public async Task PostAsync_CallMethod_StreamContent(Configuration.Http.RemoteServer remoteServer, HttpContent content, byte[] expectedData)
         {
             using (HttpClient client = CreateHttpClientForRemoteServer(remoteServer))
             {
-                content.Headers.ContentMD5 = TestHelper.ComputeMD5Hash(expectedData);
+                if (PlatformDetection.IsBrowser)
+                {
+                    // [ActiveIssue("https://github.com/dotnet/runtime/issues/37669", TestPlatforms.Browser)]
+                    content.Headers.Add("Content-MD5-Skip", "browser");
+                }
+                else
+                {
+                    content.Headers.ContentMD5 = TestHelper.ComputeMD5Hash(expectedData);
+                }
 
                 using (HttpResponseMessage response = await client.PostAsync(remoteServer.VerifyUploadUri, content))
                 {
@@ -528,9 +553,8 @@ public static IEnumerable<object[]> VerifyUploadServersStreamsAndExpectedData
             }
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [Theory, MemberData(nameof(RemoteServersMemberData))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/53018", TestPlatforms.Browser)]
         public async Task PostAsync_CallMethod_NullContent(Configuration.Http.RemoteServer remoteServer)
         {
             using (HttpClient client = CreateHttpClientForRemoteServer(remoteServer))
@@ -550,9 +574,8 @@ public async Task PostAsync_CallMethod_NullContent(Configuration.Http.RemoteServ
             }
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [Theory, MemberData(nameof(RemoteServersMemberData))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/53018", TestPlatforms.Browser)]
         public async Task PostAsync_CallMethod_EmptyContent(Configuration.Http.RemoteServer remoteServer)
         {
             using (HttpClient client = CreateHttpClientForRemoteServer(remoteServer))
@@ -581,10 +604,10 @@ public static IEnumerable<object[]> ExpectContinueVersion()
                 select new object[] {expect, version};
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [Theory]
         [MemberData(nameof(ExpectContinueVersion))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/53018", TestPlatforms.Browser)]
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/53876", TestPlatforms.Browser)]
         public async Task PostAsync_ExpectContinue_Success(bool? expectContinue, Version version)
         {
             // Sync API supported only up to HTTP/1.1
@@ -622,9 +645,8 @@ public async Task PostAsync_ExpectContinue_Success(bool? expectContinue, Version
             }
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [Theory, MemberData(nameof(RemoteServersMemberData))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/53018", TestPlatforms.Browser)]
         public async Task PostAsync_Redirect_ResultingGetFormattedCorrectly(Configuration.Http.RemoteServer remoteServer)
         {
             const string ContentString = "This is the content string.";
@@ -644,9 +666,8 @@ public async Task PostAsync_Redirect_ResultingGetFormattedCorrectly(Configuratio
             }
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [Theory, MemberData(nameof(RemoteServersMemberData))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/37669", TestPlatforms.Browser)]
         public async Task PostAsync_RedirectWith307_LargePayload(Configuration.Http.RemoteServer remoteServer)
         {
             if (remoteServer.HttpVersion == new Version(2, 0))
@@ -660,9 +681,8 @@ public async Task PostAsync_RedirectWith307_LargePayload(Configuration.Http.Remo
             await PostAsync_Redirect_LargePayload_Helper(remoteServer, 307, true);
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [Theory, MemberData(nameof(RemoteServersMemberData))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/37669", TestPlatforms.Browser)]
         public async Task PostAsync_RedirectWith302_LargePayload(Configuration.Http.RemoteServer remoteServer)
         {
             await PostAsync_Redirect_LargePayload_Helper(remoteServer, 302, false);
@@ -691,7 +711,15 @@ private async Task PostAsync_Redirect_LargePayload_Helper(Configuration.Http.Rem
                 var content = new StreamContent(fs);
 
                 // Compute MD5 of request body data. This will be verified by the server when it receives the request.
-                content.Headers.ContentMD5 = TestHelper.ComputeMD5Hash(contentBytes);
+                if (PlatformDetection.IsBrowser)
+                {
+                    // [ActiveIssue("https://github.com/dotnet/runtime/issues/37669", TestPlatforms.Browser)]
+                    content.Headers.Add("Content-MD5-Skip", "browser");
+                }
+                else
+                {
+                    content.Headers.ContentMD5 = TestHelper.ComputeMD5Hash(contentBytes);
+                }
 
                 using (HttpClient client = CreateHttpClientForRemoteServer(remoteServer))
                 using (HttpResponseMessage response = await client.PostAsync(redirectUri, content))
@@ -716,9 +744,8 @@ private async Task PostAsync_Redirect_LargePayload_Helper(Configuration.Http.Rem
         }
 
 #if !NETFRAMEWORK
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [Theory, MemberData(nameof(RemoteServersMemberData))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/53018", TestPlatforms.Browser)]
         public async Task PostAsync_ReuseRequestContent_Success(Configuration.Http.RemoteServer remoteServer)
         {
             const string ContentString = "This is the content string.";
@@ -737,14 +764,17 @@ public async Task PostAsync_ReuseRequestContent_Success(Configuration.Http.Remot
         }
 #endif
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [Theory, MemberData(nameof(HttpMethods))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/53018", TestPlatforms.Browser)]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/53592", TestPlatforms.Browser)]
         public async Task SendAsync_SendRequestUsingMethodToEchoServerWithNoContent_MethodCorrectlySent(
             string method,
             Uri serverUri)
         {
+            if (method == "TRACE" && PlatformDetection.IsBrowser)
+            {
+                // [ActiveIssue("https://github.com/dotnet/runtime/issues/53592", TestPlatforms.Browser)]
+                return;
+            }
             using (HttpClient client = CreateHttpClient())
             {
                 var request = new HttpRequestMessage(
@@ -759,13 +789,18 @@ public async Task SendAsync_SendRequestUsingMethodToEchoServerWithNoContent_Meth
             }
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [Theory, MemberData(nameof(HttpMethodsThatAllowContent))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/53591", TestPlatforms.Browser)]
         public async Task SendAsync_SendRequestUsingMethodToEchoServerWithContent_Success(
             string method,
             Uri serverUri)
         {
+            if (method == "GET" && PlatformDetection.IsBrowser)
+            {
+                // [ActiveIssue("https://github.com/dotnet/runtime/issues/53591", TestPlatforms.Browser)]
+                return;
+            }
+
             using (HttpClient client = CreateHttpClient())
             {
                 var request = new HttpRequestMessage(
@@ -789,14 +824,23 @@ public async Task SendAsync_SendRequestUsingMethodToEchoServerWithContent_Succes
             }
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [Theory, MemberData(nameof(HttpMethodsThatDontAllowContent))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/53591", TestPlatforms.Browser)]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/53592", TestPlatforms.Browser)]
         public async Task SendAsync_SendRequestUsingNoBodyMethodToEchoServerWithContent_NoBodySent(
             string method,
             Uri serverUri)
         {
+            if (method == "TRACE" && PlatformDetection.IsBrowser)
+            {
+                // [ActiveIssue("https://github.com/dotnet/runtime/issues/53592", TestPlatforms.Browser)]
+                return;
+            }
+            if (method == "HEAD" && PlatformDetection.IsBrowser)
+            {
+                // [ActiveIssue("https://github.com/dotnet/runtime/issues/53591", TestPlatforms.Browser)]
+                return;
+            }
+
             using (HttpClient client = CreateHttpClient())
             {
                 var request = new HttpRequestMessage(
@@ -836,9 +880,8 @@ public static IEnumerable<object[]> SendAsync_SendSameRequestMultipleTimesDirect
             }
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [Theory, MemberData(nameof(SendAsync_SendSameRequestMultipleTimesDirectlyOnHandler_Success_MemberData))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/53018", TestPlatforms.Browser)]
         public async Task SendAsync_SendSameRequestMultipleTimesDirectlyOnHandler_Success(Configuration.Http.RemoteServer remoteServer, string stringContent, int startingPosition)
         {
             using (var handler = new HttpMessageInvoker(CreateHttpClientHandler()))
@@ -869,10 +912,9 @@ public async Task SendAsync_SendSameRequestMultipleTimesDirectlyOnHandler_Succes
             }
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [Theory]
         [MemberData(nameof(Http2Servers))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/53018", TestPlatforms.Browser)]
         public async Task SendAsync_RequestVersion20_ResponseVersion20IfHttp2Supported(Uri server)
         {
             // Sync API supported only up to HTTP/1.1
diff --git a/src/libraries/Common/tests/System/Net/Http/HttpClientHandlerTest.cs b/src/libraries/Common/tests/System/Net/Http/HttpClientHandlerTest.cs
index 06e80b66b00be5..33392864210a83 100644
--- a/src/libraries/Common/tests/System/Net/Http/HttpClientHandlerTest.cs
+++ b/src/libraries/Common/tests/System/Net/Http/HttpClientHandlerTest.cs
@@ -39,7 +39,7 @@ public void CookieContainer_SetNull_ThrowsArgumentNullException()
             }
         }
 
-        [Fact]
+        [SkipOnPlatform(TestPlatforms.Browser, "Credentials is not supported on Browser")]
         public void Ctor_ExpectedDefaultPropertyValues_CommonPlatform()
         {
             using (HttpClientHandler handler = CreateHttpClientHandler())
@@ -62,6 +62,7 @@ public void Ctor_ExpectedDefaultPropertyValues_CommonPlatform()
         }
 
         [Fact]
+        [SkipOnPlatform(TestPlatforms.Browser, "MaxResponseHeadersLength is not supported on Browser")]
         public void Ctor_ExpectedDefaultPropertyValues()
         {
             using (HttpClientHandler handler = CreateHttpClientHandler())
@@ -79,6 +80,7 @@ public void Ctor_ExpectedDefaultPropertyValues()
         }
 
         [Fact]
+        [SkipOnPlatform(TestPlatforms.Browser, "Credentials is not supported on Browser")]
         public void Credentials_SetGet_Roundtrips()
         {
             using (HttpClientHandler handler = CreateHttpClientHandler())
@@ -99,6 +101,7 @@ public void Credentials_SetGet_Roundtrips()
         [Theory]
         [InlineData(-1)]
         [InlineData(0)]
+        [SkipOnPlatform(TestPlatforms.Browser, "MaxAutomaticRedirections not supported on Browser")]
         public void MaxAutomaticRedirections_InvalidValue_Throws(int redirects)
         {
             using (HttpClientHandler handler = CreateHttpClientHandler())
@@ -148,6 +151,7 @@ public void Properties_AddItemToDictionary_ItemPresent()
         }
 
         [Fact]
+        [SkipOnPlatform(TestPlatforms.Browser, "ServerCertificateCustomValidationCallback not supported on Browser")]
         public async Task GetAsync_IPv6LinkLocalAddressUri_Success()
         {
             if (IsWinHttpHandler && UseVersion >= HttpVersion20.Value)
@@ -195,7 +199,10 @@ public async Task GetAsync_IPBasedUri_Success(IPAddress address)
             }
 
             using HttpClientHandler handler = CreateHttpClientHandler();
-            handler.ServerCertificateCustomValidationCallback = TestHelper.AllowAllCertificates;
+            if (PlatformDetection.IsNotBrowser)
+            {
+                handler.ServerCertificateCustomValidationCallback = TestHelper.AllowAllCertificates;
+            }
 
             using HttpClient client = CreateHttpClient(handler);
 
@@ -224,6 +231,7 @@ public static IEnumerable<object[]> GetAsync_IPBasedUri_Success_MemberData()
         [Theory]
         [InlineData("[::1234]")]
         [InlineData("[::1234]:8080")]
+        [SkipOnPlatform(TestPlatforms.Browser, "Proxy not supported on Browser")]
         public async Task GetAsync_IPv6AddressInHostHeader_CorrectlyFormatted(string host)
         {
             string ipv6Address = "http://" + host;
@@ -254,7 +262,9 @@ await LoopbackServer.CreateClientAndServerAsync(async proxyUri =>
 
         public static IEnumerable<object[]> SecureAndNonSecure_IPBasedUri_MemberData() =>
             from address in new[] { IPAddress.Loopback, IPAddress.IPv6Loopback }
-            from useSsl in BoolValues
+            from useSsl in BoolValues 
+            // we could not create SslStream in browser, [ActiveIssue("https://github.com/dotnet/runtime/issues/37669", TestPlatforms.Browser)]
+            where PlatformDetection.IsNotBrowser || !useSsl 
             select new object[] { address, useSsl };
 
         [Theory]
@@ -267,7 +277,7 @@ public async Task GetAsync_SecureAndNonSecureIPBasedUri_CorrectlyFormatted(IPAdd
                 return;
             }
 
-            var options = new LoopbackServer.Options { Address = address, UseSsl= useSsl };
+            var options = new LoopbackServer.Options { Address = address, UseSsl = useSsl };
             bool connectionAccepted = false;
             string host = "";
 
@@ -277,8 +287,9 @@ await LoopbackServer.CreateClientAndServerAsync(async url =>
                 using (HttpClientHandler handler = CreateHttpClientHandler())
                 using (HttpClient client = CreateHttpClient(handler))
                 {
-                    if (useSsl)
+                    if (useSsl && PlatformDetection.IsNotBrowser)
                     {
+                        // we could not create SslStream in browser, [ActiveIssue("https://github.com/dotnet/runtime/issues/37669", TestPlatforms.Browser)]
                         handler.ServerCertificateCustomValidationCallback = TestHelper.AllowAllCertificates;
                     }
                     try { await client.GetAsync(url); } catch { }
@@ -296,6 +307,7 @@ await LoopbackServer.CreateClientAndServerAsync(async url =>
         [Theory]
         [InlineData("WWW-Authenticate", "CustomAuth")]
         [InlineData("", "")] // RFC7235 requires servers to send this header with 401 but some servers don't.
+        [SkipOnPlatform(TestPlatforms.Browser, "Credentials is not supported on Browser")]
         public async Task GetAsync_ServerNeedsNonStandardAuthAndSetCredential_StatusCodeUnauthorized(string authHeadrName, string authHeaderValue)
         {
             if (IsWinHttpHandler && UseVersion >= HttpVersion20.Value)
@@ -328,6 +340,7 @@ await LoopbackServerFactory.CreateServerAsync(async (server, url) =>
         [InlineData("nocolon")]
         [InlineData("no colon")]
         [InlineData("Content-Length      ")]
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/54160", TestPlatforms.Browser)]
         public async Task GetAsync_InvalidHeaderNameValue_ThrowsHttpRequestException(string invalidHeader)
         {
             if (UseVersion == HttpVersion30)
@@ -341,7 +354,7 @@ await LoopbackServer.CreateClientAndServerAsync(async uri =>
                 {
                     await Assert.ThrowsAsync<HttpRequestException>(() => client.GetStringAsync(uri));
                 }
-            }, server => server.AcceptConnectionSendCustomResponseAndCloseAsync($"HTTP/1.1 200 OK\r\n{invalidHeader}\r\nContent-Length: 11\r\n\r\nhello world"));
+            }, server => server.AcceptConnectionSendCustomResponseAndCloseAsync($"HTTP/1.1 200 OK\r\n{invalidHeader}\r\n{LoopbackServer.CorsHeaders}Content-Length: 11\r\n\r\nhello world"));
         }
 
         [Theory]
@@ -349,6 +362,7 @@ await LoopbackServer.CreateClientAndServerAsync(async uri =>
         [InlineData(true, false)]
         [InlineData(false, true)]
         [InlineData(true, true)]
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/54160", TestPlatforms.Browser)]
         public async Task GetAsync_IncompleteData_ThrowsHttpRequestException(bool failDuringHeaders, bool getString)
         {
             if (IsWinHttpHandler)
@@ -372,8 +386,8 @@ await LoopbackServer.CreateClientAndServerAsync(async uri =>
                 }
             }, server =>
                 failDuringHeaders ?
-                   server.AcceptConnectionSendCustomResponseAndCloseAsync("HTTP/1.1 200 OK\r\nContent-Length: 5\r\n") :
-                   server.AcceptConnectionSendCustomResponseAndCloseAsync("HTTP/1.1 200 OK\r\nContent-Length: 5\r\n\r\nhe"));
+                   server.AcceptConnectionSendCustomResponseAndCloseAsync($"HTTP/1.1 200 OK\r\n{LoopbackServer.CorsHeaders}Content-Length: 5\r\n") :
+                   server.AcceptConnectionSendCustomResponseAndCloseAsync($"HTTP/1.1 200 OK\r\n{LoopbackServer.CorsHeaders}Content-Length: 5\r\n\r\nhe"));
         }
 
         [Fact]
@@ -396,10 +410,13 @@ await LoopbackServerFactory.CreateClientAndServerAsync(async uri =>
                     var request = new HttpRequestMessage(HttpMethod.Post, uri) { Content = new ByteArrayContent(contentArray), Version = UseVersion };
 
                     request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("text/plain"));
-                    request.Headers.AcceptCharset.Add(new StringWithQualityHeaderValue("utf-8"));
-                    request.Headers.AcceptEncoding.Add(new StringWithQualityHeaderValue("gzip"));
-                    request.Headers.AcceptEncoding.Add(new StringWithQualityHeaderValue("deflate"));
-                    request.Headers.AcceptLanguage.Add(new StringWithQualityHeaderValue("en-US"));
+                    if (PlatformDetection.IsNotBrowser)
+                    {
+                        request.Headers.AcceptCharset.Add(new StringWithQualityHeaderValue("utf-8"));
+                        request.Headers.AcceptEncoding.Add(new StringWithQualityHeaderValue("gzip"));
+                        request.Headers.AcceptEncoding.Add(new StringWithQualityHeaderValue("deflate"));
+                        request.Headers.AcceptLanguage.Add(new StringWithQualityHeaderValue("en-US"));
+                    }
                     request.Headers.Add("Accept-Datetime", "Thu, 31 May 2007 20:35:00 GMT");
                     request.Headers.Add("Access-Control-Request-Method", "GET");
                     request.Headers.Add("Access-Control-Request-Headers", "GET");
@@ -409,7 +426,10 @@ await LoopbackServerFactory.CreateClientAndServerAsync(async uri =>
                     request.Headers.Connection.Add("close");
                     request.Headers.Add("Cookie", "$Version=1; Skin=new");
                     request.Content.Headers.ContentLength = contentArray.Length;
-                    request.Content.Headers.ContentMD5 = MD5.Create().ComputeHash(contentArray);
+                    if (PlatformDetection.IsNotBrowser)
+                    {
+                        request.Content.Headers.ContentMD5 = MD5.Create().ComputeHash(contentArray);
+                    }
                     request.Content.Headers.ContentType = new MediaTypeHeaderValue("application/x-www-form-urlencoded");
                     request.Headers.Date = DateTimeOffset.Parse("Tue, 15 Nov 1994 08:12:31 GMT");
                     request.Headers.Expect.Add(new NameValueWithParametersHeaderValue("100-continue"));
@@ -431,11 +451,14 @@ await LoopbackServerFactory.CreateClientAndServerAsync(async uri =>
                     request.Headers.TE.Add(new TransferCodingWithQualityHeaderValue("deflate"));
                     request.Headers.Trailer.Add("MyTrailer");
                     request.Headers.TransferEncoding.Add(new TransferCodingHeaderValue("chunked"));
-                    request.Headers.UserAgent.Add(new ProductInfoHeaderValue(new ProductHeaderValue("Mozilla", "5.0")));
-                    request.Headers.Upgrade.Add(new ProductHeaderValue("HTTPS", "1.3"));
-                    request.Headers.Upgrade.Add(new ProductHeaderValue("IRC", "6.9"));
-                    request.Headers.Upgrade.Add(new ProductHeaderValue("RTA", "x11"));
-                    request.Headers.Upgrade.Add(new ProductHeaderValue("websocket"));
+                    if (PlatformDetection.IsNotBrowser)
+                    {
+                        request.Headers.UserAgent.Add(new ProductInfoHeaderValue(new ProductHeaderValue("Mozilla", "5.0")));
+                        request.Headers.Upgrade.Add(new ProductHeaderValue("HTTPS", "1.3"));
+                        request.Headers.Upgrade.Add(new ProductHeaderValue("IRC", "6.9"));
+                        request.Headers.Upgrade.Add(new ProductHeaderValue("RTA", "x11"));
+                        request.Headers.Upgrade.Add(new ProductHeaderValue("websocket"));
+                    }
                     request.Headers.Via.Add(new ViaHeaderValue("1.0", "fred"));
                     request.Headers.Via.Add(new ViaHeaderValue("1.1", "example.com", null, "(Apache/1.1)"));
                     request.Headers.Warning.Add(new WarningHeaderValue(199, "-", "\"Miscellaneous warning\""));
@@ -471,18 +494,31 @@ await LoopbackServerFactory.CreateClientAndServerAsync(async uri =>
 
                     Assert.Equal(content, Encoding.ASCII.GetString(requestData.Body));
 
-                    Assert.Equal("utf-8", requestData.GetSingleHeaderValue("Accept-Charset"));
-                    Assert.Equal("gzip, deflate", requestData.GetSingleHeaderValue("Accept-Encoding"));
-                    Assert.Equal("en-US", requestData.GetSingleHeaderValue("Accept-Language"));
-                    Assert.Equal("Thu, 31 May 2007 20:35:00 GMT", requestData.GetSingleHeaderValue("Accept-Datetime"));
-                    Assert.Equal("GET", requestData.GetSingleHeaderValue("Access-Control-Request-Method"));
-                    Assert.Equal("GET", requestData.GetSingleHeaderValue("Access-Control-Request-Headers"));
+                    if (PlatformDetection.IsNotBrowser)
+                    {
+                        Assert.Equal("utf-8", requestData.GetSingleHeaderValue("Accept-Charset"));
+                        Assert.Equal("gzip, deflate", requestData.GetSingleHeaderValue("Accept-Encoding"));
+                        Assert.Equal("en-US", requestData.GetSingleHeaderValue("Accept-Language"));
+                        Assert.Equal("Thu, 31 May 2007 20:35:00 GMT", requestData.GetSingleHeaderValue("Accept-Datetime"));
+                        Assert.Equal("GET", requestData.GetSingleHeaderValue("Access-Control-Request-Method"));
+                        Assert.Equal("GET", requestData.GetSingleHeaderValue("Access-Control-Request-Headers"));
+                    }
                     Assert.Equal("12", requestData.GetSingleHeaderValue("Age"));
                     Assert.Equal("Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==", requestData.GetSingleHeaderValue("Authorization"));
                     Assert.Equal("no-cache", requestData.GetSingleHeaderValue("Cache-Control"));
-                    Assert.Equal("$Version=1; Skin=new", requestData.GetSingleHeaderValue("Cookie"));
-                    Assert.Equal("Tue, 15 Nov 1994 08:12:31 GMT", requestData.GetSingleHeaderValue("Date"));
-                    Assert.Equal("100-continue", requestData.GetSingleHeaderValue("Expect"));
+                    if (PlatformDetection.IsNotBrowser)
+                    {
+                        Assert.Equal("$Version=1; Skin=new", requestData.GetSingleHeaderValue("Cookie"));
+                        Assert.Equal("Tue, 15 Nov 1994 08:12:31 GMT", requestData.GetSingleHeaderValue("Date"));
+                        Assert.Equal("100-continue", requestData.GetSingleHeaderValue("Expect"));
+                        Assert.Equal("http://www.example-social-network.com", requestData.GetSingleHeaderValue("Origin"));
+                        Assert.Equal("Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==", requestData.GetSingleHeaderValue("Proxy-Authorization"));
+                        Assert.Equal("Mozilla/5.0", requestData.GetSingleHeaderValue("User-Agent"));
+                        Assert.Equal("http://en.wikipedia.org/wiki/Main_Page", requestData.GetSingleHeaderValue("Referer"));
+                        Assert.Equal("MyTrailer", requestData.GetSingleHeaderValue("Trailer"));
+                        Assert.Equal("1.0 fred, 1.1 example.com (Apache/1.1)", requestData.GetSingleHeaderValue("Via"));
+                        Assert.Equal("1 (Do Not Track Enabled)", requestData.GetSingleHeaderValue("DNT"));
+                    }
                     Assert.Equal("for=192.0.2.60;proto=http;by=203.0.113.43", requestData.GetSingleHeaderValue("Forwarded"));
                     Assert.Equal("User Name <user@example.com>", requestData.GetSingleHeaderValue("From"));
                     Assert.Equal("\"37060cd8c284d8af7ad3082f209582d\"", requestData.GetSingleHeaderValue("If-Match"));
@@ -491,17 +527,10 @@ await LoopbackServerFactory.CreateClientAndServerAsync(async uri =>
                     Assert.Equal("Wed, 21 Oct 2015 07:28:00 GMT", requestData.GetSingleHeaderValue("If-Range"));
                     Assert.Equal("Sat, 29 Oct 1994 19:43:31 GMT", requestData.GetSingleHeaderValue("If-Unmodified-Since"));
                     Assert.Equal("10", requestData.GetSingleHeaderValue("Max-Forwards"));
-                    Assert.Equal("http://www.example-social-network.com", requestData.GetSingleHeaderValue("Origin"));
                     Assert.Equal("no-cache", requestData.GetSingleHeaderValue("Pragma"));
-                    Assert.Equal("Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==", requestData.GetSingleHeaderValue("Proxy-Authorization"));
                     Assert.Equal("bytes=500-999", requestData.GetSingleHeaderValue("Range"));
-                    Assert.Equal("http://en.wikipedia.org/wiki/Main_Page", requestData.GetSingleHeaderValue("Referer"));
-                    Assert.Equal("MyTrailer", requestData.GetSingleHeaderValue("Trailer"));
-                    Assert.Equal("Mozilla/5.0", requestData.GetSingleHeaderValue("User-Agent"));
-                    Assert.Equal("1.0 fred, 1.1 example.com (Apache/1.1)", requestData.GetSingleHeaderValue("Via"));
                     Assert.Equal("199 - \"Miscellaneous warning\"", requestData.GetSingleHeaderValue("Warning"));
                     Assert.Equal("XMLHttpRequest", requestData.GetSingleHeaderValue("X-Requested-With"));
-                    Assert.Equal("1 (Do Not Track Enabled)", requestData.GetSingleHeaderValue("DNT"));
                     Assert.Equal("client1, proxy1, proxy2", requestData.GetSingleHeaderValue("X-Forwarded-For"));
                     Assert.Equal("en.wikipedia.org:8080", requestData.GetSingleHeaderValue("X-Forwarded-Host"));
                     Assert.Equal("https", requestData.GetSingleHeaderValue("X-Forwarded-Proto"));
@@ -527,7 +556,7 @@ await LoopbackServerFactory.CreateClientAndServerAsync(async uri =>
                         Assert.Equal(0, requestData.GetHeaderValueCount("Connection"));
                         Assert.Equal(0, requestData.GetHeaderValueCount("Transfer-Encoding"));
                     }
-                    else
+                    else if (PlatformDetection.IsNotBrowser)
                     {
                         // Verify HTTP/1.x headers
                         Assert.Equal("close", requestData.GetSingleHeaderValue("Connection"), StringComparer.OrdinalIgnoreCase); // NetFxHandler uses "Close" vs "close"
@@ -565,7 +594,10 @@ await LoopbackServer.CreateClientAndServerAsync(async uri =>
                 {
                     Assert.Equal("1.1", resp.Version.ToString());
                     Assert.Equal(HttpStatusCode.OK, resp.StatusCode);
-                    Assert.Contains("*", resp.Headers.GetValues("Access-Control-Allow-Origin"));
+                    if (PlatformDetection.IsNotBrowser)
+                    {
+                        Assert.Contains("*", resp.Headers.GetValues("Access-Control-Allow-Origin"));
+                    }
                     Assert.Contains("text/example;charset=utf-8", resp.Headers.GetValues("Accept-Patch"));
                     Assert.Contains("bytes", resp.Headers.AcceptRanges);
                     Assert.Equal(TimeSpan.FromSeconds(12), resp.Headers.Age.GetValueOrDefault());
@@ -581,7 +613,10 @@ await LoopbackServer.CreateClientAndServerAsync(async uri =>
                     Assert.Contains("gzip", resp.Content.Headers.ContentEncoding);
                     Assert.Contains("da", resp.Content.Headers.ContentLanguage);
                     Assert.Equal(new Uri("/index.htm", UriKind.Relative), resp.Content.Headers.ContentLocation);
-                    Assert.Equal(Convert.FromBase64String("Q2hlY2sgSW50ZWdyaXR5IQ=="), resp.Content.Headers.ContentMD5);
+                    if (PlatformDetection.IsNotBrowser)
+                    {
+                        Assert.Equal(Convert.FromBase64String("Q2hlY2sgSW50ZWdyaXR5IQ=="), resp.Content.Headers.ContentMD5);
+                    }
                     Assert.Equal("bytes", resp.Content.Headers.ContentRange.Unit);
                     Assert.Equal(21010, resp.Content.Headers.ContentRange.From.GetValueOrDefault());
                     Assert.Equal(47021, resp.Content.Headers.ContentRange.To.GetValueOrDefault());
@@ -600,7 +635,11 @@ await LoopbackServer.CreateClientAndServerAsync(async uri =>
                     Assert.Contains("max-age=2592000; pin-sha256=\"E9CZ9INDbd+2eRQozYqqbQ2yXLVKB9+xcprMF+44U1g=\"", resp.Headers.GetValues("Public-Key-Pins"));
                     Assert.Equal(TimeSpan.FromSeconds(120), resp.Headers.RetryAfter.Delta.GetValueOrDefault());
                     Assert.Contains(new ProductInfoHeaderValue("Apache", "2.4.1"), resp.Headers.Server);
-                    Assert.Contains("UserID=JohnDoe; Max-Age=3600; Version=1", resp.Headers.GetValues("Set-Cookie"));
+
+                    if (PlatformDetection.IsNotBrowser)
+                    {
+                        Assert.Contains("UserID=JohnDoe; Max-Age=3600; Version=1", resp.Headers.GetValues("Set-Cookie"));
+                    }
                     Assert.Contains("max-age=16070400; includeSubDomains", resp.Headers.GetValues("Strict-Transport-Security"));
                     Assert.Contains("Max-Forwards", resp.Headers.Trailer);
                     Assert.Contains("?", resp.Headers.GetValues("Tk"));
@@ -627,6 +666,7 @@ await LoopbackServer.CreateClientAndServerAsync(async uri =>
             }, server => server.AcceptConnectionSendCustomResponseAndCloseAsync(
                 $"HTTP/1.1 200 OK{newline}" +
                 $"Access-Control-Allow-Origin:{fold} *{newline}" +
+                $"Access-Control-Expose-Headers:{fold} *{newline}" +
                 $"Accept-Patch:{fold} text/example;charset=utf-8{newline}" +
                 $"Accept-Ranges:{fold} bytes{newline}" +
                 $"Age: {fold}12{newline}" +
@@ -682,6 +722,7 @@ await LoopbackServer.CreateClientAndServerAsync(async uri =>
         }
 
         [Fact]
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/54160", TestPlatforms.Browser)]
         public async Task GetAsync_NonTraditionalChunkSizes_Accepted()
         {
             if (LoopbackServerFactory.Version >= HttpVersion20.Value)
@@ -700,6 +741,7 @@ await TestHelper.WhenAllCompletedOrAnyFailed(
                         server.AcceptConnectionSendCustomResponseAndCloseAsync(
                             "HTTP/1.1 200 OK\r\n" +
                             "Connection: close\r\n" +
+                            LoopbackServer.CorsHeaders +
                             "Transfer-Encoding: chunked\r\n" +
                             "\r\n" +
                             "4    \r\n" + // whitespace after size
@@ -733,6 +775,7 @@ await TestHelper.WhenAllCompletedOrAnyFailed(
         [InlineData("xyz")] // non-hex
         [InlineData("7gibberish")] // valid size then gibberish
         [InlineData("7\v\f")] // unacceptable whitespace
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/54160", TestPlatforms.Browser)]
         public async Task GetAsync_InvalidChunkSize_ThrowsHttpRequestException(string chunkSize)
         {
             if (UseVersion != HttpVersion.Version11)
@@ -745,6 +788,7 @@ await LoopbackServer.CreateServerAsync(async (server, url) =>
                 using (HttpClient client = CreateHttpClient())
                 {
                     string partialResponse = "HTTP/1.1 200 OK\r\n" +
+                        LoopbackServer.CorsHeaders +
                         "Transfer-Encoding: chunked\r\n" +
                         "\r\n" +
                         $"{chunkSize}\r\n";
@@ -764,6 +808,7 @@ await LoopbackServer.CreateServerAsync(async (server, url) =>
         }
 
         [Fact]
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/54160", TestPlatforms.Browser)]
         public async Task GetAsync_InvalidChunkTerminator_ThrowsHttpRequestException()
         {
             if (UseVersion != HttpVersion.Version11)
@@ -780,6 +825,7 @@ await LoopbackServer.CreateClientAndServerAsync(async url =>
             }, server => server.AcceptConnectionSendCustomResponseAndCloseAsync(
                 "HTTP/1.1 200 OK\r\n" +
                 "Connection: close\r\n" +
+                LoopbackServer.CorsHeaders +
                 "Transfer-Encoding: chunked\r\n" +
                 "\r\n" +
                 "5\r\n" +
@@ -791,6 +837,7 @@ await LoopbackServer.CreateClientAndServerAsync(async url =>
         }
 
         [Fact]
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/54160", TestPlatforms.Browser)]
         public async Task GetAsync_InfiniteChunkSize_ThrowsHttpRequestException()
         {
             if (UseVersion != HttpVersion.Version11)
@@ -808,7 +855,7 @@ await LoopbackServer.CreateServerAsync(async (server, url) =>
                     var tcs = new TaskCompletionSource<bool>();
                     Task serverTask = server.AcceptConnectionAsync(async connection =>
                     {
-                        await connection.ReadRequestHeaderAndSendCustomResponseAsync("HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n");
+                        await connection.ReadRequestHeaderAndSendCustomResponseAsync("HTTP/1.1 200 OK\r\n" + LoopbackServer.CorsHeaders + "Transfer-Encoding: chunked\r\n\r\n");
                         try
                         {
                             while (!cts.IsCancellationRequested) // infinite to make sure implementation doesn't OOM
@@ -828,6 +875,7 @@ await LoopbackServer.CreateServerAsync(async (server, url) =>
         }
 
         [Fact]
+        [SkipOnPlatform(TestPlatforms.Browser, "CORS is required on Browser")]
         public async Task SendAsync_TransferEncodingSetButNoRequestContent_Throws()
         {
             var req = new HttpRequestMessage(HttpMethod.Post, "http://bing.com") { Version = UseVersion };
@@ -841,6 +889,7 @@ public async Task SendAsync_TransferEncodingSetButNoRequestContent_Throws()
 
         [OuterLoop("Slow response")]
         [Fact]
+        [SkipOnPlatform(TestPlatforms.Browser, "This is blocking forever on Browser, there is infinite default timeout")]
         public async Task SendAsync_ReadFromSlowStreamingServer_PartialDataReturned()
         {
             if (UseVersion != HttpVersion.Version11)
@@ -856,9 +905,14 @@ await LoopbackServer.CreateServerAsync(async (server, url) =>
 
                     await server.AcceptConnectionAsync(async connection =>
                     {
-                        await connection.ReadRequestHeaderAndSendCustomResponseAsync(
+                        HttpRequestData requestData = await connection.ReadRequestDataAsync();
+#if TARGET_BROWSER
+                        await connection.HandleCORSPreFlight(requestData);
+#endif
+                        await connection.WriteStringAsync(
                             "HTTP/1.1 200 OK\r\n" +
                             $"Date: {DateTimeOffset.UtcNow:R}\r\n" +
+                            LoopbackServer.CorsHeaders +
                             "Content-Length: 16000\r\n" +
                             "\r\n" +
                             "less than 16000 bytes");
@@ -882,6 +936,7 @@ await connection.ReadRequestHeaderAndSendCustomResponseAsync(
         [InlineData(true)]
         [InlineData(false)]
         [InlineData(null)]
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/54159", TestPlatforms.Browser)]
         public async Task ReadAsStreamAsync_HandlerProducesWellBehavedResponseStream(bool? chunked)
         {
             if (IsWinHttpHandler && UseVersion >= HttpVersion20.Value)
@@ -1047,6 +1102,7 @@ await server.AcceptConnectionAsync(async connection =>
         }
 
         [Fact]
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/54159", TestPlatforms.Browser)]
         public async Task ReadAsStreamAsync_EmptyResponseBody_HandlerProducesWellBehavedResponseStream()
         {
             if (IsWinHttpHandler && UseVersion >= HttpVersion20.Value)
@@ -1211,6 +1267,7 @@ await LoopbackServerFactory.CreateServerAsync(async (server3, url3) =>
         [Theory]
         [InlineData(99)]
         [InlineData(1000)]
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/54160", TestPlatforms.Browser)]
         public async Task GetAsync_StatusCodeOutOfRange_ExpectedException(int statusCode)
         {
             if (UseVersion == HttpVersion30)
@@ -1227,6 +1284,7 @@ await LoopbackServer.CreateServerAsync(async (server, url) =>
                     await server.AcceptConnectionSendCustomResponseAndCloseAsync(
                             $"HTTP/1.1 {statusCode}\r\n" +
                             $"Date: {DateTimeOffset.UtcNow:R}\r\n" +
+                            LoopbackServer.CorsHeaders +
                             "Connection: close\r\n" +
                             "\r\n");
 
@@ -1255,6 +1313,7 @@ public async Task GetAsync_UnicodeHostName_SuccessStatusCodeInResponse()
 #region Post Methods Tests
 
         [Fact]
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/53876", TestPlatforms.Browser)]
         public async Task GetAsync_ExpectContinueTrue_NoContent_StillSendsHeader()
         {
             if (IsWinHttpHandler && UseVersion >= HttpVersion20.Value)
@@ -1306,6 +1365,7 @@ public static IEnumerable<object[]> Interim1xxStatusCode()
 
         [Theory]
         [MemberData(nameof(Interim1xxStatusCode))]
+        [SkipOnPlatform(TestPlatforms.Browser, "CookieContainer is not supported on Browser")]
         public async Task SendAsync_1xxResponsesWithHeaders_InterimResponsesHeadersIgnored(HttpStatusCode responseStatusCode)
         {
             if (IsWinHttpHandler && UseVersion >= HttpVersion20.Value)
@@ -1480,6 +1540,7 @@ await server.AcceptConnectionAsync(async connection =>
         }
 
         [Fact]
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/54160", TestPlatforms.Browser)]
         public async Task SendAsync_Expect100Continue_RequestBodyFails_ThrowsContentException()
         {
             if (IsWinHttpHandler)
@@ -1576,6 +1637,7 @@ await server.AcceptConnectionAsync(async connection =>
         }
 
         [Fact]
+        [SkipOnPlatform(TestPlatforms.Browser, "Switching protocol is not supported on Browser")]
         public async Task SendAsync_101SwitchingProtocolsResponse_Success()
         {
             // WinHttpHandler and CurlHandler will hang, waiting for additional response.
@@ -1616,6 +1678,7 @@ await connection.ReadRequestHeaderAndSendCustomResponseAsync(
         [Theory]
         [InlineData(false)]
         [InlineData(true)]
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/54160", TestPlatforms.Browser)]
         public async Task PostAsync_ThrowFromContentCopy_RequestFails(bool syncFailure)
         {
             if (UseVersion == HttpVersion30)
@@ -1629,7 +1692,7 @@ await LoopbackServer.CreateServerAsync(async (server, uri) =>
                 Task responseTask = server.AcceptConnectionAsync(async connection =>
                 {
                     var buffer = new byte[1000];
-                    while (await connection.Socket.ReceiveAsync(new ArraySegment<byte>(buffer, 0, buffer.Length), SocketFlags.None) != 0);
+                    while (await connection.ReadAsync(new Memory<byte>(buffer), 0, buffer.Length) != 0) ;
                 });
 
                 using (HttpClient client = CreateHttpClient())
@@ -1651,6 +1714,7 @@ await LoopbackServer.CreateServerAsync(async (server, uri) =>
         [Theory]
         [InlineData(HttpStatusCode.MethodNotAllowed, "Custom description")]
         [InlineData(HttpStatusCode.MethodNotAllowed, "")]
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/54163", TestPlatforms.Browser)]
         public async Task GetAsync_CallMethod_ExpectedStatusLine(HttpStatusCode statusCode, string reasonPhrase)
         {
             if (LoopbackServerFactory.Version >= HttpVersion20.Value)
@@ -1668,13 +1732,14 @@ await LoopbackServer.CreateClientAndServerAsync(async uri =>
                     Assert.Equal(reasonPhrase, response.ReasonPhrase);
                 }
             }, server => server.AcceptConnectionSendCustomResponseAndCloseAsync(
-                $"HTTP/1.1 {(int)statusCode} {reasonPhrase}\r\nContent-Length: 0\r\n\r\n"));
+                $"HTTP/1.1 {(int)statusCode} {reasonPhrase}\r\n{LoopbackServer.CorsHeaders}Content-Length: 0\r\n\r\n"));
         }
 
         #endregion
 
         #region Version tests
 
+        [SkipOnPlatform(TestPlatforms.Browser, "Version is not supported on Browser")]
         [Fact]
         public async Task SendAsync_RequestVersion10_ServerReceivesVersion10Request()
         {
@@ -1688,6 +1753,7 @@ public async Task SendAsync_RequestVersion10_ServerReceivesVersion10Request()
             Assert.Equal(new Version(1, 0), receivedRequestVersion);
         }
 
+        [SkipOnPlatform(TestPlatforms.Browser, "Version is not supported on Browser")]
         [Fact]
         public async Task SendAsync_RequestVersion11_ServerReceivesVersion11Request()
         {
@@ -1695,6 +1761,7 @@ public async Task SendAsync_RequestVersion11_ServerReceivesVersion11Request()
             Assert.Equal(new Version(1, 1), receivedRequestVersion);
         }
 
+        [SkipOnPlatform(TestPlatforms.Browser, "Version is not supported on Browser")]
         [Fact]
         public async Task SendAsync_RequestVersionNotSpecified_ServerReceivesVersion11Request()
         {
diff --git a/src/libraries/Common/tests/System/Net/Http/LoopbackServer.cs b/src/libraries/Common/tests/System/Net/Http/LoopbackServer.cs
index b44ae2d7f68033..5685e79cdb6021 100644
--- a/src/libraries/Common/tests/System/Net/Http/LoopbackServer.cs
+++ b/src/libraries/Common/tests/System/Net/Http/LoopbackServer.cs
@@ -11,6 +11,7 @@
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
+using System.Net.WebSockets;
 using Xunit;
 
 namespace System.Net.Test.Common
@@ -20,55 +21,83 @@ public sealed partial class LoopbackServer : GenericLoopbackServer, IDisposable
         private static readonly byte[] s_newLineBytes = new byte[] { (byte)'\r', (byte)'\n' };
         private static readonly byte[] s_colonSpaceBytes = new byte[] { (byte)':', (byte)' ' };
 
+        private SocketWrapper _socketWrapper;
+#if TARGET_BROWSER
+        private ClientWebSocket _listenSocket;
+#else
         private Socket _listenSocket;
+#endif
         private Options _options;
         private Uri _uri;
 
         public LoopbackServer(Options options = null)
         {
             _options = options ??= new Options();
+        }
+
+#pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously
+        public async Task ListenAsync()
+#pragma warning restore CS1998 // Async method lacks 'await' operators and will run synchronously
+        {
             try
             {
-                _listenSocket = new Socket(options.Address.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
-                _listenSocket.Bind(new IPEndPoint(options.Address, 0));
-                _listenSocket.Listen(options.ListenBacklog);
+                IPEndPoint localEndPoint;
+#if TARGET_BROWSER
+                _listenSocket = new ClientWebSocket();
 
-                var localEndPoint = (IPEndPoint)_listenSocket.LocalEndPoint;
-                string host = options.Address.AddressFamily == AddressFamily.InterNetworkV6 ?
+                await _listenSocket.ConnectAsync(Configuration.Http.RemoteLoopServer, CancellationToken.None);
+
+                byte[] buffer = new byte[128 * 1024];
+                var message = Encoding.ASCII.GetBytes($"{_options.ListenBacklog},{_options.Address}");
+                await _listenSocket.SendAsync(message, WebSocketMessageType.Binary, true, CancellationToken.None);
+                var first = await _listenSocket.ReceiveAsync(buffer, CancellationToken.None);
+                localEndPoint = IPEndPoint.Parse(Encoding.ASCII.GetString(buffer, 0, first.Count));
+#else
+                _listenSocket = new Socket(_options.Address.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
+                _listenSocket.Bind(new IPEndPoint(_options.Address, 0));
+                _listenSocket.Listen(_options.ListenBacklog);
+                localEndPoint = (IPEndPoint)_listenSocket.LocalEndPoint;
+#endif
+
+                string host = _options.Address.AddressFamily == AddressFamily.InterNetworkV6 ?
                     $"[{localEndPoint.Address}]" :
                     localEndPoint.Address.ToString();
 
-                string scheme = options.UseSsl ? "https" : "http";
-                if (options.WebSocketEndpoint)
+                string scheme = _options.UseSsl ? "https" : "http";
+                if (_options.WebSocketEndpoint)
                 {
-                    scheme = options.UseSsl ? "wss" : "ws";
+                    scheme = _options.UseSsl ? "wss" : "ws";
                 }
 
                 _uri = new Uri($"{scheme}://{host}:{localEndPoint.Port}/");
+                _socketWrapper = new SocketWrapper(_listenSocket);
             }
             catch
             {
                 _listenSocket?.Dispose();
+                _socketWrapper?.Dispose();
                 throw;
             }
         }
 
         public override void Dispose()
         {
-            if (_listenSocket != null)
+            _listenSocket = null;
+            if (_socketWrapper != null)
             {
-                _listenSocket.Dispose();
-                _listenSocket = null;
+                _socketWrapper.Dispose();
+                _socketWrapper = null;
             }
         }
 
-        public Socket ListenSocket => _listenSocket;
+        public SocketWrapper ListenSocket => _socketWrapper;
         public override Uri Address => _uri;
 
         public static async Task CreateServerAsync(Func<LoopbackServer, Task> funcAsync, Options options = null)
         {
             using (var server = new LoopbackServer(options))
             {
+                await server.ListenAsync();
                 await funcAsync(server).ConfigureAwait(false);
             }
         }
@@ -96,23 +125,31 @@ public override async Task<GenericLoopbackConnection> EstablishGenericConnection
 
         public async Task<Connection> EstablishConnectionAsync()
         {
-            Socket s = await _listenSocket.AcceptAsync().ConfigureAwait(false);
+            SocketWrapper closableWrapper = null;
             try
             {
+                Stream stream = null;
+#if TARGET_BROWSER
+                closableWrapper = new SocketWrapper(_listenSocket);
+                stream = new WebSocketStream(_listenSocket, ownsSocket: true);
+#else
+                var socket = await _listenSocket.AcceptAsync().ConfigureAwait(false);
+                closableWrapper = new SocketWrapper(socket);
+
                 try
                 {
-                    s.NoDelay = true;
+                    socket.NoDelay = true;
                 }
                 // OSX can throw if socket is in weird state during close or cancellation
                 catch (SocketException ex) when (ex.SocketErrorCode == SocketError.InvalidArgument && PlatformDetection.IsOSXLike) { }
 
-                Stream stream = new NetworkStream(s, ownsSocket: false);
-
-                return await Connection.CreateAsync(s, stream, _options);
+                stream = new NetworkStream(socket, ownsSocket: false);
+#endif
+                return await Connection.CreateAsync(closableWrapper, stream, _options).ConfigureAwait(false);
             }
             catch (Exception)
             {
-                s.Close();
+                closableWrapper?.Close();
                 throw;
             }
         }
@@ -332,11 +369,19 @@ public static string GetHttpResponse(HttpStatusCode statusCode = HttpStatusCode.
         public static string GetHttpResponseHeaders(HttpStatusCode statusCode = HttpStatusCode.OK, string additionalHeaders = null, string content = null, bool connectionClose = false) =>
             GetHttpResponseHeaders(statusCode, additionalHeaders, content == null ? 0 : content.Length, connectionClose);
 
+        public static string CorsHeaders = PlatformDetection.IsBrowser
+                ? "Access-Control-Allow-Methods: GET, POST, OPTIONS, PUT, DELETE\r\n" +
+                  "Access-Control-Expose-Headers: *\r\n" +
+                  "Access-Control-Allow-Headers: *\r\n" +
+                  "Access-Control-Allow-Origin: *\r\n"
+                : "";
+
         public static string GetHttpResponseHeaders(HttpStatusCode statusCode = HttpStatusCode.OK, string additionalHeaders = null, int contentLength = 0, bool connectionClose = false) =>
             $"HTTP/1.1 {(int)statusCode} {GetStatusDescription(statusCode)}\r\n" +
             (connectionClose ? "Connection: close\r\n" : "") +
             $"Date: {DateTimeOffset.UtcNow:R}\r\n" +
             $"Content-Length: {contentLength}\r\n" +
+            CorsHeaders +
             additionalHeaders +
             "\r\n";
 
@@ -345,6 +390,7 @@ public static string GetSingleChunkHttpResponse(HttpStatusCode statusCode = Http
             (connectionClose ? "Connection: close\r\n" : "") +
             $"Date: {DateTimeOffset.UtcNow:R}\r\n" +
             "Transfer-Encoding: chunked\r\n" +
+            CorsHeaders +
             additionalHeaders +
             "\r\n" +
             (string.IsNullOrEmpty(content) ? "" :
@@ -358,6 +404,7 @@ public static string GetBytePerChunkHttpResponse(HttpStatusCode statusCode = Htt
             (connectionClose ? "Connection: close\r\n" : "") +
             $"Date: {DateTimeOffset.UtcNow:R}\r\n" +
             "Transfer-Encoding: chunked\r\n" +
+            CorsHeaders +
             additionalHeaders +
             "\r\n" +
             (string.IsNullOrEmpty(content) ? "" : string.Concat(content.Select(c => $"1\r\n{c}\r\n"))) +
@@ -368,6 +415,7 @@ public static string GetConnectionCloseResponse(HttpStatusCode statusCode = Http
             $"HTTP/1.1 {(int)statusCode} {GetStatusDescription(statusCode)}\r\n" +
             "Connection: close\r\n" +
             $"Date: {DateTimeOffset.UtcNow:R}\r\n" +
+            CorsHeaders +
             additionalHeaders +
             "\r\n" +
             content;
@@ -395,7 +443,7 @@ public Options()
         public sealed class Connection : GenericLoopbackConnection
         {
             private const int BufferSize = 4000;
-            private Socket _socket;
+            private SocketWrapper _socket;
             private Stream _stream;
             private byte[] _readBuffer;
             private int _readStart;
@@ -403,7 +451,7 @@ public sealed class Connection : GenericLoopbackConnection
             private int _contentLength = 0;
             private bool _bodyRead = false;
 
-            public Connection(Socket socket, Stream stream)
+            public Connection(SocketWrapper socket, Stream stream)
             {
                 _socket = socket;
                 _stream = stream;
@@ -413,10 +461,10 @@ public Connection(Socket socket, Stream stream)
                 _readEnd = 0;
             }
 
-            public Socket Socket => _socket;
+            public SocketWrapper Socket => _socket;
             public Stream Stream => _stream;
 
-            public static async Task<Connection> CreateAsync(Socket socket, Stream stream, Options httpOptions)
+            public static async Task<Connection> CreateAsync(SocketWrapper socket, Stream stream, Options httpOptions)
             {
                 if (httpOptions.UseSsl)
                 {
@@ -706,6 +754,11 @@ public async Task<List<string>> ReadRequestHeaderAndSendCustomResponseAsync(byte
             public async Task<List<string>> ReadRequestHeaderAndSendResponseAsync(HttpStatusCode statusCode = HttpStatusCode.OK, string additionalHeaders = null, string content = null)
             {
                 List<string> lines = await ReadRequestHeaderAsync().ConfigureAwait(false);
+
+#if TARGET_BROWSER
+                lines = await HandleCORSPreFlight(lines);
+#endif
+
                 await SendResponseAsync(statusCode, additionalHeaders, content).ConfigureAwait(false);
                 return lines;
             }
@@ -850,6 +903,12 @@ public override async Task SendResponseAsync(HttpStatusCode? statusCode = HttpSt
                     }
                 }
 
+                if (PlatformDetection.IsBrowser)
+                {
+                    byte[] corsBytes = Encoding.ASCII.GetBytes(CorsHeaders);
+                    headerBytes.Write(corsBytes, 0, corsBytes.Length);
+                }
+
                 bool endHeaders = content != null || isFinal;
                 if (statusCode != null)
                 {
@@ -890,6 +949,7 @@ public override async Task SendResponseHeadersAsync(HttpStatusCode statusCode =
                         headerString = headerString + $"{headerData.Name}: {headerData.Value}\r\n";
                     }
                 }
+                headerString += CorsHeaders;
 
                 headerString = GetHttpResponseHeaders(statusCode, headerString, 0, connectionClose: true);
 
@@ -901,10 +961,52 @@ public override async Task SendResponseBodyAsync(byte[] body, bool isFinal = tru
                 await SendResponseAsync(body).ConfigureAwait(false);
             }
 
+            public async Task<HttpRequestData> HandleCORSPreFlight(HttpRequestData requestData)
+            {
+                if (PlatformDetection.IsBrowser && requestData.Method == "OPTIONS" && requestData.Headers.Any(h => h.Name.StartsWith("Access-Control-Request-Method")))
+                {
+                    // handle CORS pre-flight
+                    await SendResponseAsync(HttpStatusCode.OK).ConfigureAwait(false);
+
+                    // reset state
+                    _bodyRead = false;
+                    _contentLength = 0;
+                    _readStart = 0;
+                    _readEnd = 0;
+
+                    // wait for real request
+                    return await ReadRequestDataAsync().ConfigureAwait(false);
+                }
+                return requestData;
+            }
+
+            public async Task<List<string>> HandleCORSPreFlight(List<string> lines)
+            {
+                if (PlatformDetection.IsBrowser && lines[0].Contains("OPTIONS") && lines.Any(h => h.StartsWith("Access-Control-Request-Method")))
+                {
+                    // handle CORS pre-flight
+                    await SendResponseAsync(HttpStatusCode.OK).ConfigureAwait(false);
+
+                    // reset state
+                    _bodyRead = false;
+                    _contentLength = 0;
+                    _readStart = 0;
+                    _readEnd = 0;
+
+                    // wait for real request
+                    return await ReadRequestHeaderAsync().ConfigureAwait(false);
+                }
+                return lines;
+            }
+
             public override async Task<HttpRequestData> HandleRequestAsync(HttpStatusCode statusCode = HttpStatusCode.OK, IList<HttpHeaderData> headers = null, string content = "")
             {
                 HttpRequestData requestData = await ReadRequestDataAsync().ConfigureAwait(false);
 
+#if TARGET_BROWSER
+                requestData = await HandleCORSPreFlight(requestData);
+#endif
+
                 // For historical reasons, we added Date and "Connection: close" (to improve test reliability)
                 bool hasDate = false;
                 List<HttpHeaderData> newHeaders = new List<HttpHeaderData>();
@@ -970,7 +1072,9 @@ public sealed class Http11LoopbackServerFactory : LoopbackServerFactory
 
         public override GenericLoopbackServer CreateServer(GenericLoopbackOptions options = null)
         {
-            return new LoopbackServer(CreateOptions(options));
+            var loopbackServer = new LoopbackServer(CreateOptions(options));
+            Task.WaitAll(loopbackServer.ListenAsync());
+            return loopbackServer;
         }
 
         public override Task CreateServerAsync(Func<GenericLoopbackServer, Uri, Task> funcAsync, int millisecondsTimeout = 60_000, GenericLoopbackOptions options = null)
@@ -978,7 +1082,7 @@ public override Task CreateServerAsync(Func<GenericLoopbackServer, Uri, Task> fu
             return LoopbackServer.CreateServerAsync((server, uri) => funcAsync(server, uri), options: CreateOptions(options));
         }
 
-        public override async Task<GenericLoopbackConnection> CreateConnectionAsync(Socket socket, Stream stream, GenericLoopbackOptions options = null)
+        public override async Task<GenericLoopbackConnection> CreateConnectionAsync(SocketWrapper socket, Stream stream, GenericLoopbackOptions options = null)
         {
             return await LoopbackServer.Connection.CreateAsync(socket, stream, CreateOptions(options));
         }
diff --git a/src/libraries/Common/tests/System/Net/Http/PostScenarioTest.cs b/src/libraries/Common/tests/System/Net/Http/PostScenarioTest.cs
index 0d75e65aea91a6..d1201244c5aac7 100644
--- a/src/libraries/Common/tests/System/Net/Http/PostScenarioTest.cs
+++ b/src/libraries/Common/tests/System/Net/Http/PostScenarioTest.cs
@@ -28,9 +28,8 @@ public abstract class PostScenarioTest : HttpClientHandlerTestBase
         public PostScenarioTest(ITestOutputHelper output) : base(output) { }
 
 #if !NETFRAMEWORK
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [Theory, MemberData(nameof(RemoteServersMemberData))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/53018", TestPlatforms.Browser)]
         public async Task PostRewindableStreamContentMultipleTimes_StreamContentFullySent(Configuration.Http.RemoteServer remoteServer)
         {
             const string requestBody = "ABC";
@@ -53,91 +52,81 @@ public async Task PostRewindableStreamContentMultipleTimes_StreamContentFullySen
         }
 #endif
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [MemberData(nameof(RemoteServersMemberData))]
         [ConditionalTheory(typeof(PlatformDetection), nameof(PlatformDetection.IsBrowserDomSupportedOrNotBrowser))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/53018", TestPlatforms.Browser)]
         public async Task PostNoContentUsingContentLengthSemantics_Success(Configuration.Http.RemoteServer remoteServer)
         {
             await PostHelper(remoteServer, string.Empty, null,
                 useContentLengthUpload: true, useChunkedEncodingUpload: false);
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [Theory, MemberData(nameof(RemoteServersMemberData))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/37669", TestPlatforms.Browser)]
         public async Task PostEmptyContentUsingContentLengthSemantics_Success(Configuration.Http.RemoteServer remoteServer)
         {
             await PostHelper(remoteServer, string.Empty, new StringContent(string.Empty),
                 useContentLengthUpload: true, useChunkedEncodingUpload: false);
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [Theory, MemberData(nameof(RemoteServersMemberData))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/37669", TestPlatforms.Browser)]
         public async Task PostEmptyContentUsingChunkedEncoding_Success(Configuration.Http.RemoteServer remoteServer)
         {
             await PostHelper(remoteServer, string.Empty, new StringContent(string.Empty),
                 useContentLengthUpload: false, useChunkedEncodingUpload: true);
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [Theory, MemberData(nameof(RemoteServersMemberData))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/37669", TestPlatforms.Browser)]
         public async Task PostEmptyContentUsingConflictingSemantics_Success(Configuration.Http.RemoteServer remoteServer)
         {
             await PostHelper(remoteServer, string.Empty, new StringContent(string.Empty),
                 useContentLengthUpload: true, useChunkedEncodingUpload: true);
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [Theory, MemberData(nameof(RemoteServersMemberData))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/37669", TestPlatforms.Browser)]
         public async Task PostUsingContentLengthSemantics_Success(Configuration.Http.RemoteServer remoteServer)
         {
             await PostHelper(remoteServer, ExpectedContent, new StringContent(ExpectedContent),
                 useContentLengthUpload: true, useChunkedEncodingUpload: false);
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [Theory, MemberData(nameof(RemoteServersMemberData))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/37669", TestPlatforms.Browser)]
         public async Task PostUsingChunkedEncoding_Success(Configuration.Http.RemoteServer remoteServer)
         {
             await PostHelper(remoteServer, ExpectedContent, new StringContent(ExpectedContent),
                 useContentLengthUpload: false, useChunkedEncodingUpload: true);
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [Theory, MemberData(nameof(RemoteServersMemberData))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/37669", TestPlatforms.Browser)]
         public async Task PostSyncBlockingContentUsingChunkedEncoding_Success(Configuration.Http.RemoteServer remoteServer)
         {
             await PostHelper(remoteServer, ExpectedContent, new SyncBlockingContent(ExpectedContent),
                 useContentLengthUpload: false, useChunkedEncodingUpload: true);
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [Theory, MemberData(nameof(RemoteServersMemberData))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/37669", TestPlatforms.Browser)]
         public async Task PostRepeatedFlushContentUsingChunkedEncoding_Success(Configuration.Http.RemoteServer remoteServer)
         {
             await PostHelper(remoteServer, ExpectedContent, new RepeatedFlushContent(ExpectedContent),
                 useContentLengthUpload: false, useChunkedEncodingUpload: true);
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [Theory, MemberData(nameof(RemoteServersMemberData))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/37669", TestPlatforms.Browser)]
         public async Task PostUsingUsingConflictingSemantics_UsesChunkedSemantics(Configuration.Http.RemoteServer remoteServer)
         {
             await PostHelper(remoteServer, ExpectedContent, new StringContent(ExpectedContent),
                 useContentLengthUpload: true, useChunkedEncodingUpload: true);
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [Theory, MemberData(nameof(RemoteServersMemberData))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/37669", TestPlatforms.Browser)]
         public async Task PostUsingNoSpecifiedSemantics_UsesChunkedSemantics(Configuration.Http.RemoteServer remoteServer)
         {
             await PostHelper(remoteServer, ExpectedContent, new StringContent(ExpectedContent),
@@ -154,10 +143,9 @@ public static IEnumerable<object[]> RemoteServersAndLargeContentSizes()
             }
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [Theory]
         [MemberData(nameof(RemoteServersAndLargeContentSizes))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/37669", TestPlatforms.Browser)]
         public async Task PostLargeContentUsingContentLengthSemantics_Success(Configuration.Http.RemoteServer remoteServer, int contentLength)
         {
             var rand = new Random(42);
@@ -223,10 +211,9 @@ public async Task PostNonRewindableContentUsingAuth_PreAuthenticate_Success(Conf
             await PostUsingAuthHelper(remoteServer, ExpectedContent, content, credential, preAuthenticate: true);
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [MemberData(nameof(RemoteServersMemberData))]
         [ConditionalTheory(typeof(PlatformDetection), nameof(PlatformDetection.IsBrowserDomSupportedOrNotBrowser))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/53018", TestPlatforms.Browser)]
         public async Task PostAsync_EmptyContent_ContentTypeHeaderNotSent(Configuration.Http.RemoteServer remoteServer)
         {
             using (HttpClient client = CreateHttpClientForRemoteServer(remoteServer))
@@ -262,7 +249,15 @@ private async Task PostHelper(
 
                     // Compute MD5 of request body data. This will be verified by the server when it
                     // receives the request.
-                    requestContent.Headers.ContentMD5 = TestHelper.ComputeMD5Hash(requestBody);
+                    if (PlatformDetection.IsBrowser)
+                    {
+                        // [ActiveIssue("https://github.com/dotnet/runtime/issues/37669", TestPlatforms.Browser)]
+                        requestContent.Headers.Add("Content-MD5-Skip", "browser");
+                    }
+                    else
+                    {
+                        requestContent.Headers.ContentMD5 = TestHelper.ComputeMD5Hash(requestBody);
+                    }
                 }
 
                 if (useChunkedEncodingUpload)
diff --git a/src/libraries/Common/tests/System/Net/Http/ResponseStreamTest.cs b/src/libraries/Common/tests/System/Net/Http/ResponseStreamTest.cs
index 3b01e68198c649..f6cc44f67e7c90 100644
--- a/src/libraries/Common/tests/System/Net/Http/ResponseStreamTest.cs
+++ b/src/libraries/Common/tests/System/Net/Http/ResponseStreamTest.cs
@@ -30,9 +30,9 @@ public static IEnumerable<object[]> RemoteServersAndReadModes()
             }
 
         }
-        [OuterLoop("Uses external servers")]
+
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [Theory, MemberData(nameof(RemoteServersAndReadModes))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/53018", TestPlatforms.Browser)]
         public async Task GetStreamAsync_ReadToEnd_Success(Configuration.Http.RemoteServer remoteServer, int readMode)
         {
             using (HttpClient client = CreateHttpClientForRemoteServer(remoteServer))
@@ -126,9 +126,8 @@ public async Task GetStreamAsync_ReadToEnd_Success(Configuration.Http.RemoteServ
             }
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [Theory, MemberData(nameof(RemoteServersMemberData))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/53018", TestPlatforms.Browser)]
         public async Task GetAsync_UseResponseHeadersReadAndCallLoadIntoBuffer_Success(Configuration.Http.RemoteServer remoteServer)
         {
             using (HttpClient client = CreateHttpClientForRemoteServer(remoteServer))
@@ -146,9 +145,8 @@ public async Task GetAsync_UseResponseHeadersReadAndCallLoadIntoBuffer_Success(C
             }
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [Theory, MemberData(nameof(RemoteServersMemberData))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/53018", TestPlatforms.Browser)]
         public async Task GetAsync_UseResponseHeadersReadAndCopyToMemoryStream_Success(Configuration.Http.RemoteServer remoteServer)
         {
             using (HttpClient client = CreateHttpClientForRemoteServer(remoteServer))
@@ -171,9 +169,8 @@ public async Task GetAsync_UseResponseHeadersReadAndCopyToMemoryStream_Success(C
             }
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [Theory, MemberData(nameof(RemoteServersMemberData))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/53018", TestPlatforms.Browser)]
         public async Task GetStreamAsync_ReadZeroBytes_Success(Configuration.Http.RemoteServer remoteServer)
         {
             using (HttpClient client = CreateHttpClientForRemoteServer(remoteServer))
@@ -187,9 +184,8 @@ public async Task GetStreamAsync_ReadZeroBytes_Success(Configuration.Http.Remote
             }
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [Theory, MemberData(nameof(RemoteServersMemberData))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/53018", TestPlatforms.Browser)]
         public async Task ReadAsStreamAsync_Cancel_TaskIsCanceled(Configuration.Http.RemoteServer remoteServer)
         {
             var cts = new CancellationTokenSource();
@@ -232,11 +228,11 @@ await client.GetAsync(remoteServer.EchoUri, HttpCompletionOption.ResponseHeaders
             }
         }
 #if NETCOREAPP
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/42852", TestPlatforms.Browser)]
         [Theory]
         [InlineData(TransferType.ContentLength, TransferError.ContentLengthTooLarge)]
         [InlineData(TransferType.Chunked, TransferError.MissingChunkTerminator)]
         [InlineData(TransferType.Chunked, TransferError.ChunkSizeTooLarge)]
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/54160", TestPlatforms.Browser)]
         public async Task ReadAsStreamAsync_InvalidServerResponse_ThrowsIOException(
             TransferType transferType,
             TransferError transferError)
@@ -247,7 +243,6 @@ await StartTransferTypeAndErrorServer(transferType, transferError, async uri =>
             });
         }
 
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/42852", TestPlatforms.Browser)]
         [Theory]
         [InlineData(TransferType.None, TransferError.None)]
         [InlineData(TransferType.ContentLength, TransferError.None)]
@@ -262,7 +257,6 @@ await StartTransferTypeAndErrorServer(transferType, transferError, async uri =>
             });
         }
 
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/42852", TestPlatforms.Browser)]
         [Theory]
         [InlineData(TransferType.None, TransferError.None)]
         [InlineData(TransferType.ContentLength, TransferError.None)]
@@ -331,6 +325,7 @@ public static Task StartTransferTypeAndErrorServer(
                     // Write response header
                     await connection.WriteStringAsync("HTTP/1.1 200 OK\r\n").ConfigureAwait(false);
                     await connection.WriteStringAsync($"Date: {DateTimeOffset.UtcNow:R}\r\n").ConfigureAwait(false);
+                    await connection.WriteStringAsync(LoopbackServer.CorsHeaders).ConfigureAwait(false);
                     await connection.WriteStringAsync("Content-Type: text/plain\r\n").ConfigureAwait(false);
                     if (!string.IsNullOrEmpty(transferHeader))
                     {
diff --git a/src/libraries/Common/tests/System/Net/Http/TestHelper.cs b/src/libraries/Common/tests/System/Net/Http/TestHelper.cs
index 352f4e714782a8..98c19464db941a 100644
--- a/src/libraries/Common/tests/System/Net/Http/TestHelper.cs
+++ b/src/libraries/Common/tests/System/Net/Http/TestHelper.cs
@@ -41,9 +41,13 @@ public static void VerifyResponseBody(
             bool chunkedUpload,
             string requestBody)
         {
-            // Verify that response body from the server was corrected received by comparing MD5 hash.
-            byte[] actualMD5Hash = ComputeMD5Hash(responseContent);
-            Assert.Equal(expectedMD5Hash, actualMD5Hash);
+            // [ActiveIssue("https://github.com/dotnet/runtime/issues/37669", TestPlatforms.Browser)]
+            if (!PlatformDetection.IsBrowser)
+            {
+                // Verify that response body from the server was corrected received by comparing MD5 hash.
+                byte[] actualMD5Hash = ComputeMD5Hash(responseContent);
+                Assert.Equal(expectedMD5Hash, actualMD5Hash);
+            }
 
             // Verify upload semantics: 'Content-Length' vs. 'Transfer-Encoding: chunked'.
             if (requestBody != null)
diff --git a/src/libraries/Common/tests/System/Net/Prerequisites/LocalEchoServer.props b/src/libraries/Common/tests/System/Net/Prerequisites/LocalEchoServer.props
new file mode 100644
index 00000000000000..aeed390ba536b2
--- /dev/null
+++ b/src/libraries/Common/tests/System/Net/Prerequisites/LocalEchoServer.props
@@ -0,0 +1,22 @@
+<Project>
+  <PropertyGroup Condition="'$(TargetOS)' == 'Browser'">
+    <Scenario>WasmTestOnBrowser</Scenario>
+    <TestArchiveTestsRoot>$(TestArchiveRoot)browseronly/</TestArchiveTestsRoot>
+    <TestArchiveTestsDir>$(TestArchiveTestsRoot)$(OSPlatformConfig)/</TestArchiveTestsDir>
+
+    <!-- handle different path to middleware in Helix -->
+    <_TestEchoMiddleware Condition="'$(ContinuousIntegrationBuild)' == 'true' and '$(OS)' == 'Windows_NT'">%HELIX_CORRELATION_PAYLOAD%/xharness/TestEchoMiddleware</_TestEchoMiddleware>
+    <_TestEchoMiddleware Condition="'$(ContinuousIntegrationBuild)' == 'true' and '$(OS)' != 'Windows_NT'">$HELIX_CORRELATION_PAYLOAD/xharness/TestEchoMiddleware</_TestEchoMiddleware>
+    <_TestEchoMiddleware Condition="'$(ContinuousIntegrationBuild)' != 'true'">$(ArtifactsDir)bin/NetCoreServer/$(NetCoreAppCurrent)-$(Configuration)</_TestEchoMiddleware>
+
+    <_RemoteLoopMiddleware Condition="'$(ContinuousIntegrationBuild)' == 'true' and '$(OS)' == 'Windows_NT'">%HELIX_CORRELATION_PAYLOAD%/xharness/RemoteLoopMiddleware</_RemoteLoopMiddleware>
+    <_RemoteLoopMiddleware Condition="'$(ContinuousIntegrationBuild)' == 'true' and '$(OS)' != 'Windows_NT'">$HELIX_CORRELATION_PAYLOAD/xharness/RemoteLoopMiddleware</_RemoteLoopMiddleware>
+    <_RemoteLoopMiddleware Condition="'$(ContinuousIntegrationBuild)' != 'true'">$(ArtifactsDir)bin/RemoteLoopServer/$(NetCoreAppCurrent)-$(Configuration)</_RemoteLoopMiddleware>
+
+    <WasmXHarnessArgs>$(WasmXHarnessArgs) --web-server-use-cors --web-server-use-https</WasmXHarnessArgs>
+    <WasmXHarnessArgs>$(WasmXHarnessArgs) --set-web-server-http-env=DOTNET_TEST_WEBSOCKETHOST,DOTNET_TEST_HTTPHOST,DOTNET_TEST_REMOTE_LOOP_HOST</WasmXHarnessArgs>
+    <WasmXHarnessArgs>$(WasmXHarnessArgs) --set-web-server-https-env=DOTNET_TEST_SECUREWEBSOCKETHOST,DOTNET_TEST_SECUREHTTPHOST,DOTNET_TEST_HTTP2HOST</WasmXHarnessArgs>
+    <WasmXHarnessArgs>$(WasmXHarnessArgs) --web-server-middleware=$(_RemoteLoopMiddleware)/RemoteLoopServer.dll,GenericHandler</WasmXHarnessArgs>
+    <WasmXHarnessArgs>$(WasmXHarnessArgs) --web-server-middleware=$(_TestEchoMiddleware)/NetCoreServer.dll,GenericHandler</WasmXHarnessArgs>
+  </PropertyGroup>
+</Project>
diff --git a/src/libraries/Common/tests/System/Net/Prerequisites/NetCoreServer.sln b/src/libraries/Common/tests/System/Net/Prerequisites/NetCoreServer.sln
deleted file mode 100644
index 8e5d44de5cd87c..00000000000000
--- a/src/libraries/Common/tests/System/Net/Prerequisites/NetCoreServer.sln
+++ /dev/null
@@ -1,25 +0,0 @@
-
-Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 15
-VisualStudioVersion = 15.0.28307.438
-MinimumVisualStudioVersion = 10.0.40219.1
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NetCoreServer", "NetCoreServer\NetCoreServer.csproj", "{86E9A13D-9F4A-45DE-B0BB-CBB6A6533867}"
-EndProject
-Global
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|Any CPU = Debug|Any CPU
-		Release|Any CPU = Release|Any CPU
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{86E9A13D-9F4A-45DE-B0BB-CBB6A6533867}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{86E9A13D-9F4A-45DE-B0BB-CBB6A6533867}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{86E9A13D-9F4A-45DE-B0BB-CBB6A6533867}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{86E9A13D-9F4A-45DE-B0BB-CBB6A6533867}.Release|Any CPU.Build.0 = Release|Any CPU
-	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = FALSE
-	EndGlobalSection
-	GlobalSection(ExtensibilityGlobals) = postSolution
-		SolutionGuid = {2F9A0637-452E-4FB9-9403-CB52944982DA}
-	EndGlobalSection
-EndGlobal
diff --git a/src/libraries/Common/tests/System/Net/Prerequisites/NetCoreServer/GenericHandler.cs b/src/libraries/Common/tests/System/Net/Prerequisites/NetCoreServer/GenericHandler.cs
index 6efc71033a308d..f129157b1d9165 100644
--- a/src/libraries/Common/tests/System/Net/Prerequisites/NetCoreServer/GenericHandler.cs
+++ b/src/libraries/Common/tests/System/Net/Prerequisites/NetCoreServer/GenericHandler.cs
@@ -13,7 +13,7 @@ public class GenericHandler
         // Must have constructor with this signature, otherwise exception at run time.
         public GenericHandler(RequestDelegate next)
         {
-            // This is an HTTP Handler, so no need to store next.
+            // This catch all HTTP Handler, so no need to store next.
         }
 
         public async Task Invoke(HttpContext context)
diff --git a/src/libraries/Common/tests/System/Net/Prerequisites/NetCoreServer/Handlers/VerifyUploadHandler.cs b/src/libraries/Common/tests/System/Net/Prerequisites/NetCoreServer/Handlers/VerifyUploadHandler.cs
index 69d3190d35be0a..3608f6211a3d64 100644
--- a/src/libraries/Common/tests/System/Net/Prerequisites/NetCoreServer/Handlers/VerifyUploadHandler.cs
+++ b/src/libraries/Common/tests/System/Net/Prerequisites/NetCoreServer/Handlers/VerifyUploadHandler.cs
@@ -32,40 +32,41 @@ public static async Task InvokeAsync(HttpContext context)
             // Get request body.
             byte[] requestBodyBytes = await ReadAllRequestBytesAsync(context);
 
-            // Check MD5 checksum for non-empty request body.
-            if (requestBodyBytes.Length > 0)
+            // Skip MD5 checksum for empty request body 
+            // or for requests which opt to skip it due to [ActiveIssue("https://github.com/dotnet/runtime/issues/37669", TestPlatforms.Browser)]
+            if (requestBodyBytes.Length == 0 || !string.IsNullOrEmpty(context.Request.Headers["Content-MD5-Skip"]))
             {
-                // Get expected MD5 hash of request body.
-                string expectedHash = context.Request.Headers["Content-MD5"];
-                if (string.IsNullOrEmpty(expectedHash))
-                {
-                    context.Response.StatusCode = 400;
-                    context.Response.SetStatusDescription("Missing 'Content-MD5' request header");
-                    return;
-                }
+                context.Response.StatusCode = 200;
+                return;
+            }
 
-                // Compute MD5 hash of received request body.
-                string actualHash;
-                using (MD5 md5 = MD5.Create())
-                {
-                    byte[] hash = md5.ComputeHash(requestBodyBytes);
-                    actualHash = Convert.ToBase64String(hash);
-                }
+            // Get expected MD5 hash of request body.
+            string expectedHash = context.Request.Headers["Content-MD5"];
+            if (string.IsNullOrEmpty(expectedHash))
+            {
+                context.Response.StatusCode = 400;
+                context.Response.SetStatusDescription("Missing 'Content-MD5' request header");
+                return;
+            }
 
-                if (expectedHash == actualHash)
-                {
-                    context.Response.StatusCode = 200;
-                }
-                else
-                {
-                    context.Response.StatusCode = 400;
-                    context.Response.SetStatusDescription("Received request body fails MD5 checksum");
-                }
+            // Compute MD5 hash of received request body.
+            string actualHash;
+            using (MD5 md5 = MD5.Create())
+            {
+                byte[] hash = md5.ComputeHash(requestBodyBytes);
+                actualHash = Convert.ToBase64String(hash);
             }
-            else
+
+            if (expectedHash == actualHash)
             {
                 context.Response.StatusCode = 200;
             }
+            else
+            {
+                context.Response.StatusCode = 400;
+                context.Response.SetStatusDescription("Received request body fails MD5 checksum");
+            }
+
         }
 
         private static async Task<byte[]> ReadAllRequestBytesAsync(HttpContext context)
diff --git a/src/libraries/Common/tests/System/Net/Prerequisites/NetCoreServer/NetCoreServer.csproj b/src/libraries/Common/tests/System/Net/Prerequisites/NetCoreServer/NetCoreServer.csproj
index d9b272d4d32414..875277b02d31a4 100644
--- a/src/libraries/Common/tests/System/Net/Prerequisites/NetCoreServer/NetCoreServer.csproj
+++ b/src/libraries/Common/tests/System/Net/Prerequisites/NetCoreServer/NetCoreServer.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk.Web">
 
   <PropertyGroup>
-    <TargetFramework>netcoreapp3.1</TargetFramework>
+    <TargetFramework>$(AspNetCoreAppCurrent)</TargetFramework>
     <AspNetCoreHostingModel>InProcess</AspNetCoreHostingModel>
     <OutputType>Exe</OutputType>
     <EnableDefaultCompileItems>false</EnableDefaultCompileItems>
diff --git a/src/libraries/Common/tests/System/Net/Prerequisites/NetCoreServer/Startup.cs b/src/libraries/Common/tests/System/Net/Prerequisites/NetCoreServer/Startup.cs
index 3ebe39a7d2c510..5819ff9f25ef38 100644
--- a/src/libraries/Common/tests/System/Net/Prerequisites/NetCoreServer/Startup.cs
+++ b/src/libraries/Common/tests/System/Net/Prerequisites/NetCoreServer/Startup.cs
@@ -11,11 +11,20 @@ public class Startup
     {
         public void ConfigureServices(IServiceCollection services)
         {
+            services.AddCors(o => o.AddPolicy("AnyCors", builder =>
+            {
+                builder.AllowAnyOrigin()
+                    .AllowAnyMethod()
+                    .AllowAnyHeader()
+                    .WithExposedHeaders("*")
+                    ;
+            }));
         }
 
         // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
         public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
         {
+            app.UseCors("AnyCors");
             app.UseWebSockets();
             app.UseGenericHandler();
         }
diff --git a/src/libraries/Common/tests/System/Net/Prerequisites/NetTestServers.sln b/src/libraries/Common/tests/System/Net/Prerequisites/NetTestServers.sln
new file mode 100644
index 00000000000000..4075b414bebf7c
--- /dev/null
+++ b/src/libraries/Common/tests/System/Net/Prerequisites/NetTestServers.sln
@@ -0,0 +1,30 @@
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 16
+VisualStudioVersion = 16.0.31229.75
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "RemoteLoopServer", "RemoteLoopServer\RemoteLoopServer.csproj", "{86E9A13D-9F4A-45DE-B0BB-CBB6A6533868}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "NetCoreServer", "NetCoreServer\NetCoreServer.csproj", "{2BB687CC-3F0C-43A9-8F38-140E91892EB0}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{86E9A13D-9F4A-45DE-B0BB-CBB6A6533868}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{86E9A13D-9F4A-45DE-B0BB-CBB6A6533868}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{86E9A13D-9F4A-45DE-B0BB-CBB6A6533868}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{86E9A13D-9F4A-45DE-B0BB-CBB6A6533868}.Release|Any CPU.Build.0 = Release|Any CPU
+		{2BB687CC-3F0C-43A9-8F38-140E91892EB0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{2BB687CC-3F0C-43A9-8F38-140E91892EB0}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{2BB687CC-3F0C-43A9-8F38-140E91892EB0}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{2BB687CC-3F0C-43A9-8F38-140E91892EB0}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {2F9A0637-452E-4FB9-9403-CB52944982DA}
+	EndGlobalSection
+EndGlobal
diff --git a/src/libraries/Common/tests/System/Net/Prerequisites/RemoteLoopServer/GenericHandler.cs b/src/libraries/Common/tests/System/Net/Prerequisites/RemoteLoopServer/GenericHandler.cs
new file mode 100644
index 00000000000000..3f015301038922
--- /dev/null
+++ b/src/libraries/Common/tests/System/Net/Prerequisites/RemoteLoopServer/GenericHandler.cs
@@ -0,0 +1,47 @@
+// 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.Tasks;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Http.Features;
+using Microsoft.Extensions.Logging;
+
+namespace RemoteLoopServer
+{
+    public class GenericHandler
+    {
+        RequestDelegate _next;
+        ILogger _logger;
+        public GenericHandler(RequestDelegate next, ILogger logger)
+        {
+            this._next = next;
+            this._logger = logger;
+        }
+
+        public async Task Invoke(HttpContext context)
+        {
+            PathString path = context.Request.Path;
+            if (path.Equals(new PathString("/RemoteLoop")))
+            {
+                await RemoteLoopHandler.InvokeAsync(context, _logger);
+                return;
+            }
+
+            await _next(context);
+        }
+    }
+
+    public static class GenericHandlerExtensions
+    {
+        public static IApplicationBuilder UseGenericHandler(this IApplicationBuilder builder)
+        {
+            return builder.UseMiddleware<GenericHandler>();
+        }
+
+        public static void SetStatusDescription(this HttpResponse response, string description)
+        {
+            response.HttpContext.Features.Get<IHttpResponseFeature>().ReasonPhrase = description;
+        }
+    }
+}
diff --git a/src/libraries/Common/tests/System/Net/Prerequisites/RemoteLoopServer/Handlers/RemoteLoopHandler.cs b/src/libraries/Common/tests/System/Net/Prerequisites/RemoteLoopServer/Handlers/RemoteLoopHandler.cs
new file mode 100644
index 00000000000000..4f83c67b0b30f4
--- /dev/null
+++ b/src/libraries/Common/tests/System/Net/Prerequisites/RemoteLoopServer/Handlers/RemoteLoopHandler.cs
@@ -0,0 +1,161 @@
+// 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.Net;
+using System.Net.Sockets;
+using System.Net.WebSockets;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.Logging;
+
+namespace RemoteLoopServer
+{
+    public partial class RemoteLoopHandler
+    {
+        public static async Task InvokeAsync(HttpContext context, ILogger logger)
+        {
+            try
+            {
+                if (!context.WebSockets.IsWebSocketRequest)
+                {
+                    context.Response.StatusCode = 400;
+                    context.Response.ContentType = "text/plain";
+                    await context.Response.WriteAsync("Not a websocket request");
+
+                    return;
+                }
+
+                using (WebSocket socket = await context.WebSockets.AcceptWebSocketAsync())
+                {
+                    await ProcessWebSocketRequest(context, socket, logger);
+                }
+
+            }
+            catch (Exception ex)
+            {
+                logger.LogError("RemoteLoopHandler failed", ex);
+            }
+        }
+
+        private static async Task ProcessWebSocketRequest(HttpContext context, WebSocket control, ILogger logger)
+        {
+            byte[] controlBuffer = new byte[128 * 1024];
+            byte[] testedBuffer = new byte[128 * 1024];
+            Socket listenSocket = null;
+            Socket tested = null;
+            CancellationTokenSource cts = new CancellationTokenSource();
+            try
+            {
+                WebSocketReceiveResult first = await control.ReceiveAsync(controlBuffer, cts.Token).ConfigureAwait(false);
+                if (first.Count <= 0 || first.MessageType != WebSocketMessageType.Binary || control.State != WebSocketState.Open)
+                {
+                    throw new Exception("Unexpected close");
+                }
+
+                // parse setup request
+                var message = Encoding.ASCII.GetString(controlBuffer, 0, first.Count);
+                var split = message.Split(',');
+                var listenBacklog = int.Parse(split[0]);
+                var address = IPAddress.Parse(split[1]);
+
+                listenSocket = new Socket(address.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
+                listenSocket.Bind(new IPEndPoint(address, 0));
+                listenSocket.Listen(listenBacklog);
+                EndPoint endPoint = listenSocket.LocalEndPoint;
+
+                // respond with what we have done
+                await control.SendAsync(Encoding.ASCII.GetBytes(endPoint.ToString()), WebSocketMessageType.Binary, true, cts.Token).ConfigureAwait(false);
+
+                // wait for the tested client to connect
+                tested = await listenSocket.AcceptAsync().ConfigureAwait(false);
+
+                // now we are connected, pump messages
+                bool close = false;
+
+                Task<int> testedNext = tested.ReceiveAsync(new Memory<byte>(testedBuffer), SocketFlags.None, cts.Token).AsTask();
+                Task<WebSocketReceiveResult> controlNext = control.ReceiveAsync(controlBuffer, cts.Token);
+                while (!close)
+                {
+                    // wait for either message
+                    await Task.WhenAny(testedNext, controlNext).ConfigureAwait(false);
+
+                    if (testedNext.IsCompleted)
+                    {
+                        if (testedNext.IsCanceled || testedNext.IsFaulted)
+                        {
+                            close = true;
+                        }
+                        else
+                        {
+                            if (!tested.Connected)
+                            {
+                                close = true;
+                            }
+                            if (testedNext.Result > 0)
+                            {
+                                var slice = new ArraySegment<byte>(testedBuffer, 0, testedNext.Result);
+                                await control.SendAsync(slice, WebSocketMessageType.Binary, true, cts.Token).ConfigureAwait(false);
+                            }
+                            if (!close)
+                            {
+                                testedNext = tested.ReceiveAsync(new Memory<byte>(testedBuffer), SocketFlags.None, cts.Token).AsTask();
+                            }
+                        }
+                    }
+                    if (controlNext.IsCompleted)
+                    {
+                        if (controlNext.IsCanceled || controlNext.IsFaulted)
+                        {
+                            close = true;
+                        }
+                        else
+                        {
+                            if (controlNext.Result.MessageType == WebSocketMessageType.Close)
+                            {
+                                close = true;
+                            }
+                            if (controlNext.Result.Count > 0)
+                            {
+                                var slice = new ArraySegment<byte>(controlBuffer, 0, controlNext.Result.Count);
+                                await tested.SendAsync(slice, SocketFlags.None, cts.Token).ConfigureAwait(false);
+                            }
+                            if (!close)
+                            {
+                                controlNext = control.ReceiveAsync(new ArraySegment<byte>(controlBuffer), cts.Token);
+                            }
+                        }
+                    }
+                }
+                if (tested.Connected)
+                {
+                    tested.Disconnect(false);
+                }
+                if (control.State == WebSocketState.Open || control.State == WebSocketState.Connecting || control.State == WebSocketState.None)
+                {
+                    try
+                    {
+                        await control.CloseAsync(WebSocketCloseStatus.NormalClosure, "closing remoteLoop", cts.Token).ConfigureAwait(false);
+                    }
+                    catch (WebSocketException ex)
+                    {
+                        logger.LogWarning("ProcessWebSocketRequest closing failed", ex);
+                    }
+                }
+                cts.Cancel();
+            }
+            catch (Exception ex)
+            {
+                logger.LogError("ProcessWebSocketRequest failed", ex);
+            }
+            finally
+            {
+                tested?.Dispose();
+                control?.Dispose();
+            }
+        }
+    }
+}
diff --git a/src/libraries/Common/tests/System/Net/Prerequisites/RemoteLoopServer/Program.cs b/src/libraries/Common/tests/System/Net/Prerequisites/RemoteLoopServer/Program.cs
new file mode 100644
index 00000000000000..f18d257efb967a
--- /dev/null
+++ b/src/libraries/Common/tests/System/Net/Prerequisites/RemoteLoopServer/Program.cs
@@ -0,0 +1,23 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.Extensions.Hosting;
+
+namespace RemoteLoopServer
+{
+    public class Program
+    {
+        public static void Main(string[] args)
+        {
+            CreateHostBuilder(args).Build().Run();
+        }
+
+        public static IHostBuilder CreateHostBuilder(string[] args) =>
+            Host.CreateDefaultBuilder(args)
+                .ConfigureWebHostDefaults(webBuilder =>
+                {
+                    webBuilder.UseStartup<Startup>();
+                });
+    }
+}
diff --git a/src/libraries/Common/tests/System/Net/Prerequisites/RemoteLoopServer/RemoteLoopServer.csproj b/src/libraries/Common/tests/System/Net/Prerequisites/RemoteLoopServer/RemoteLoopServer.csproj
new file mode 100644
index 00000000000000..ba8a85a059c54d
--- /dev/null
+++ b/src/libraries/Common/tests/System/Net/Prerequisites/RemoteLoopServer/RemoteLoopServer.csproj
@@ -0,0 +1,15 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+
+  <PropertyGroup>
+    <TargetFramework>$(AspNetCoreAppCurrent)</TargetFramework>
+    <AspNetCoreHostingModel>InProcess</AspNetCoreHostingModel>
+    <OutputType>Exe</OutputType>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Include="Handlers\RemoteLoopHandler.cs" />
+    <Compile Include="GenericHandler.cs" />
+    <Compile Include="Program.cs" />
+    <Compile Include="Startup.cs" />
+  </ItemGroup>
+</Project>
diff --git a/src/libraries/Common/tests/System/Net/Prerequisites/RemoteLoopServer/Startup.cs b/src/libraries/Common/tests/System/Net/Prerequisites/RemoteLoopServer/Startup.cs
new file mode 100644
index 00000000000000..bbf7b7bb79e650
--- /dev/null
+++ b/src/libraries/Common/tests/System/Net/Prerequisites/RemoteLoopServer/Startup.cs
@@ -0,0 +1,23 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace RemoteLoopServer
+{
+    public class Startup
+    {
+        public void ConfigureServices(IServiceCollection services)
+        {
+        }
+
+        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
+        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
+        {
+            app.UseWebSockets();
+            app.UseGenericHandler();
+        }
+    }
+}
diff --git a/src/libraries/Common/tests/System/Net/Prerequisites/RemoteLoopServer/appsettings.Development.json b/src/libraries/Common/tests/System/Net/Prerequisites/RemoteLoopServer/appsettings.Development.json
new file mode 100644
index 00000000000000..e203e9407e74a6
--- /dev/null
+++ b/src/libraries/Common/tests/System/Net/Prerequisites/RemoteLoopServer/appsettings.Development.json
@@ -0,0 +1,9 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Debug",
+      "System": "Information",
+      "Microsoft": "Information"
+    }
+  }
+}
diff --git a/src/libraries/Common/tests/System/Net/Prerequisites/RemoteLoopServer/appsettings.json b/src/libraries/Common/tests/System/Net/Prerequisites/RemoteLoopServer/appsettings.json
new file mode 100644
index 00000000000000..def9159a7d9403
--- /dev/null
+++ b/src/libraries/Common/tests/System/Net/Prerequisites/RemoteLoopServer/appsettings.json
@@ -0,0 +1,8 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Warning"
+    }
+  },
+  "AllowedHosts": "*"
+}
diff --git a/src/libraries/Common/tests/System/Net/WebSockets/WebSocketStream.cs b/src/libraries/Common/tests/System/Net/WebSockets/WebSocketStream.cs
new file mode 100644
index 00000000000000..322f5d2a00cb06
--- /dev/null
+++ b/src/libraries/Common/tests/System/Net/WebSockets/WebSocketStream.cs
@@ -0,0 +1,285 @@
+// 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.Tasks;
+using System.IO;
+using System.Threading;
+
+namespace System.Net.WebSockets
+{
+    public class WebSocketStream : Stream
+    {
+        // Used by the class to hold the underlying socket the stream uses.
+        private readonly WebSocket _streamSocket;
+
+        // Whether the stream should dispose of the socket when the stream is disposed
+        private readonly bool _ownsSocket;
+
+        // Used by the class to indicate that the stream is m_Readable.
+        private bool _readable;
+
+        // Used by the class to indicate that the stream is writable.
+        private bool _writeable;
+
+        // Whether Dispose has been called. 0 == false, 1 == true
+        private int _disposed;
+
+        public WebSocketStream(WebSocket socket)
+            : this(socket, FileAccess.ReadWrite, ownsSocket: false)
+        {
+        }
+
+        public WebSocketStream(WebSocket socket, bool ownsSocket)
+            : this(socket, FileAccess.ReadWrite, ownsSocket)
+        {
+        }
+
+        public WebSocketStream(WebSocket socket, FileAccess access)
+            : this(socket, access, ownsSocket: false)
+        {
+        }
+
+        public WebSocketStream(WebSocket socket, FileAccess access, bool ownsSocket)
+        {
+            if (socket == null)
+            {
+                throw new ArgumentNullException(nameof(socket));
+            }
+            if (socket.State != WebSocketState.Open)
+            {
+                throw new IOException("The operation is not allowed on non-connected sockets.");
+            }
+
+            _streamSocket = socket;
+            _ownsSocket = ownsSocket;
+
+            switch (access)
+            {
+                case FileAccess.Read:
+                    _readable = true;
+                    break;
+                case FileAccess.Write:
+                    _writeable = true;
+                    break;
+                case FileAccess.ReadWrite:
+                default: // assume FileAccess.ReadWrite
+                    _readable = true;
+                    _writeable = true;
+                    break;
+            }
+        }
+
+        public WebSocket Socket => _streamSocket;
+
+        protected bool Readable
+        {
+            get { return _readable; }
+            set { _readable = value; }
+        }
+
+        protected bool Writeable
+        {
+            get { return _writeable; }
+            set { _writeable = value; }
+        }
+
+        public override bool CanRead => _readable;
+        public override bool CanSeek => false;
+        public override bool CanWrite => _writeable;
+        public override bool CanTimeout => true;
+        public override long Length => throw new NotSupportedException("This stream does not support seek operations.");
+
+        public override long Position
+        {
+            get
+            {
+                throw new NotSupportedException("This stream does not support seek operations.");
+            }
+            set
+            {
+                throw new NotSupportedException("This stream does not support seek operations.");
+            }
+        }
+
+        public override long Seek(long offset, SeekOrigin origin)
+        {
+            throw new NotSupportedException("This stream does not support seek operations.");
+        }
+
+        public override int Read(byte[] buffer, int offset, int count)
+        {
+            throw new IOException("The operation is not allowed on a non-blocking Socket.");
+        }
+
+        public override int Read(Span<byte> buffer)
+        {
+            throw new IOException("The operation is not allowed on a non-blocking Socket.");
+        }
+
+        public override void Write(byte[] buffer, int offset, int count)
+        {
+            throw new IOException("The operation is not allowed on a non-blocking Socket.");
+        }
+
+        public override void Write(ReadOnlySpan<byte> buffer)
+        {
+            throw new IOException("The operation is not allowed on a non-blocking Socket.");
+        }
+
+        private int _closeTimeout = -1;
+
+        public void Close(int timeout)
+        {
+            if (timeout < -1)
+            {
+                throw new ArgumentOutOfRangeException(nameof(timeout));
+            }
+            _closeTimeout = timeout;
+            Dispose();
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (Interlocked.Exchange(ref _disposed, 1) != 0)
+            {
+                return;
+            }
+
+            if (disposing)
+            {
+                _readable = false;
+                _writeable = false;
+                if (_ownsSocket)
+                {
+                    if (_streamSocket != null && (_streamSocket.State == WebSocketState.Open || _streamSocket.State == WebSocketState.Connecting || _streamSocket.State == WebSocketState.None))
+                    {
+                        try
+                        {
+                            var task = _streamSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "closing remoteLoop", CancellationToken.None);
+                            Task.WaitAll(task);
+                        }
+                        catch (Exception)
+                        {
+                        }
+                        finally
+                        {
+                            _streamSocket.Dispose();
+                        }
+                    }
+                }
+            }
+
+            base.Dispose(disposing);
+        }
+
+        ~WebSocketStream() => Dispose(false);
+
+        public async override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+        {
+            ValidateBufferArguments(buffer, offset, count);
+            ThrowIfDisposed();
+            if (!CanRead)
+            {
+                throw new InvalidOperationException("The stream does not support reading.");
+            }
+
+            try
+            {
+                var res = await _streamSocket.ReceiveAsync(new Memory<byte>(buffer, offset, count), cancellationToken);
+                return res.Count;
+            }
+            catch (Exception exception) when (!(exception is OutOfMemoryException))
+            {
+                throw WrapException("Unable to read data from the transport connection", exception);
+            }
+        }
+
+        public async override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken)
+        {
+            bool canRead = CanRead; // Prevent race with Dispose.
+            ThrowIfDisposed();
+            if (!canRead)
+            {
+                throw new InvalidOperationException("The stream does not support reading.");
+            }
+
+            try
+            {
+                var res = await _streamSocket.ReceiveAsync(buffer,
+                    cancellationToken);
+                return res.Count;
+            }
+            catch (Exception exception) when (!(exception is OutOfMemoryException))
+            {
+                throw WrapException("Unable to read data from the transport connection", exception);
+            }
+        }
+
+        public async override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+        {
+            ValidateBufferArguments(buffer, offset, count);
+            ThrowIfDisposed();
+            if (!CanWrite)
+            {
+                throw new InvalidOperationException("The stream does not support writing.");
+            }
+
+            try
+            {
+                await _streamSocket.SendAsync(new ReadOnlyMemory<byte>(buffer, offset, count), WebSocketMessageType.Binary, true, cancellationToken);
+            }
+            catch (Exception exception) when (!(exception is OutOfMemoryException))
+            {
+                throw WrapException("Unable to write data to the transport connection", exception);
+            }
+        }
+
+        public async override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken)
+        {
+            bool canWrite = CanWrite; // Prevent race with Dispose.
+            ThrowIfDisposed();
+            if (!canWrite)
+            {
+                throw new InvalidOperationException("The stream does not support writing.");
+            }
+
+            try
+            {
+                await _streamSocket.SendAsync(buffer, WebSocketMessageType.Binary, true, cancellationToken);
+            }
+            catch (Exception exception) when (!(exception is OutOfMemoryException))
+            {
+                throw WrapException("Unable to write data to the transport connection", exception);
+            }
+        }
+
+        public override void Flush()
+        {
+        }
+
+        public override Task FlushAsync(CancellationToken cancellationToken)
+        {
+            return Task.CompletedTask;
+        }
+
+        public override void SetLength(long value)
+        {
+            throw new NotSupportedException("This stream does not support seek operations.");
+        }
+
+        private void ThrowIfDisposed()
+        {
+            if (_disposed != 0)
+            {
+                ThrowObjectDisposedException();
+            }
+
+            void ThrowObjectDisposedException() => throw new ObjectDisposedException(GetType().FullName);
+        }
+
+        private static IOException WrapException(string resourceFormatString, Exception innerException)
+        {
+            return new IOException(resourceFormatString, innerException);
+        }
+    }
+}
diff --git a/src/libraries/Common/tests/System/RealParserTestsBase.cs b/src/libraries/Common/tests/System/RealParserTestsBase.cs
index 12ebf61f7cb5c6..a42b9da9bf5165 100644
--- a/src/libraries/Common/tests/System/RealParserTestsBase.cs
+++ b/src/libraries/Common/tests/System/RealParserTestsBase.cs
@@ -410,7 +410,7 @@ public void TestParserDouble_SpecificPowers(int b, int start, int end)
             for (int i = start; i != end; i++)
             {
                 double d = Math.Pow(b, i);
-                ulong bits = (ulong)BitConverter.DoubleToInt64Bits(d);
+                ulong bits = BitConverter.DoubleToUInt64Bits(d);
 
                 TestRoundTripDouble(bits - 1);
                 TestRoundTripDouble(bits);
@@ -594,7 +594,7 @@ public void TestParserSingle_SpecificPowers(int b, int start, int end)
             for (int i = start; i != end; ++i)
             {
                 float f = MathF.Pow(b, i);
-                uint bits = (uint)BitConverter.SingleToInt32Bits(f);
+                uint bits = BitConverter.SingleToUInt32Bits(f);
 
                 TestRoundTripSingle(bits - 1);
                 TestRoundTripSingle(bits);
@@ -604,7 +604,7 @@ public void TestParserSingle_SpecificPowers(int b, int start, int end)
 
         private void CheckOneDouble(string s, ulong expectedBits)
         {
-            CheckOneDouble(s, BitConverter.Int64BitsToDouble((long)(expectedBits)));
+            CheckOneDouble(s, BitConverter.UInt64BitsToDouble(expectedBits));
         }
 
         private void CheckOneDouble(string s, double expected)
@@ -620,7 +620,7 @@ private void CheckOneDouble(string s, double expected)
 
         private void CheckOneSingle(string s, uint expectedBits)
         {
-            CheckOneSingle(s, BitConverter.Int32BitsToSingle((int)(expectedBits)));
+            CheckOneSingle(s, BitConverter.UInt32BitsToSingle(expectedBits));
         }
 
         private void CheckOneSingle(string s, float expected)
@@ -642,7 +642,7 @@ private void TestRoundTripDouble(double d)
 
         private void TestRoundTripDouble(ulong bits)
         {
-            double d = BitConverter.Int64BitsToDouble((long)(bits));
+            double d = BitConverter.UInt64BitsToDouble(bits);
 
             if (double.IsFinite(d))
             {
@@ -659,7 +659,7 @@ private void TestRoundTripSingle(float d)
 
         private void TestRoundTripSingle(uint bits)
         {
-            float d = BitConverter.Int32BitsToSingle((int)(bits));
+            float d = BitConverter.UInt32BitsToSingle(bits);
 
             if (float.IsFinite(d))
             {
diff --git a/src/libraries/Common/tests/TestUtilities/System/AssertExtensions.cs b/src/libraries/Common/tests/TestUtilities/System/AssertExtensions.cs
index 940c4de5822d19..f2fb788960ff6d 100644
--- a/src/libraries/Common/tests/TestUtilities/System/AssertExtensions.cs
+++ b/src/libraries/Common/tests/TestUtilities/System/AssertExtensions.cs
@@ -403,7 +403,7 @@ public static void CollectionEqual<T>(IEnumerable<T> expected, IEnumerable<T> ac
                 {
                     actualItemCountMapping[actualItem] = new ItemCount(1, 1);
                 }
-                
+
                 actualCount++;
             }
 
@@ -431,7 +431,7 @@ public static void CollectionEqual<T>(IEnumerable<T> expected, IEnumerable<T> ac
                 countInfo.Remain--;
             }
         }
-		
+
         /// <summary>
         /// Validates that the actual span is equal to the expected span.
         /// If this fails, determine where the differences are and create an exception with that information.
@@ -475,6 +475,19 @@ public static void SequenceEqual<T>(ReadOnlySpan<T> expected, ReadOnlySpan<T> ac
             }
         }
 
+        public static void FilledWith<T>(T expected, ReadOnlySpan<T> actual)
+        {
+            EqualityComparer<T> comparer = EqualityComparer<T>.Default;
+
+            for (int i = 0; i < actual.Length; i++)
+            {
+                if (!comparer.Equals(expected, actual[i]))
+                {
+                    throw new XunitException($"Expected {expected?.ToString() ?? "null"} at position {i}");
+                }
+            }
+        }
+
         public static void SequenceEqual<T>(Span<T> expected, Span<T> actual) where T : IEquatable<T> => SequenceEqual((ReadOnlySpan<T>)expected, (ReadOnlySpan<T>)actual);
 
         public static void SequenceEqual<T>(T[] expected, T[] actual) where T : IEquatable<T> => SequenceEqual(expected.AsSpan(), actual.AsSpan());
@@ -556,7 +569,7 @@ public static E Throws<E, T>(string expectedParamName, Span<T> span, AssertThrow
             Assert.Equal(expectedParamName, exception.ParamName);
             return exception;
         }
-		
+
         private class ItemCount
         {
             public int Original { get; set; }
diff --git a/src/libraries/Common/tests/TestUtilities/System/PlatformDetection.cs b/src/libraries/Common/tests/TestUtilities/System/PlatformDetection.cs
index e63e0d0d5e946b..aa44cfe53f1b02 100644
--- a/src/libraries/Common/tests/TestUtilities/System/PlatformDetection.cs
+++ b/src/libraries/Common/tests/TestUtilities/System/PlatformDetection.cs
@@ -9,6 +9,7 @@
 using System.Runtime.InteropServices;
 using System.Runtime.CompilerServices;
 using Microsoft.Win32;
+using Xunit;
 
 namespace System
 {
@@ -59,6 +60,8 @@ public static partial class PlatformDetection
         public static bool IsBrowserDomSupported => GetIsBrowserDomSupported();
         public static bool IsBrowserDomSupportedOrNotBrowser => IsNotBrowser || GetIsBrowserDomSupported();
         public static bool IsNotBrowserDomSupported => !IsBrowserDomSupported;
+        public static bool LocalEchoServerIsNotAvailable => !LocalEchoServerIsAvailable;
+        public static bool LocalEchoServerIsAvailable => IsBrowser;
 
         public static bool IsUsingLimitedCultures => !IsNotMobile;
         public static bool IsNotUsingLimitedCultures => IsNotMobile;
diff --git a/src/libraries/Common/tests/Tests/System/Collections/Generic/ArrayBuilderTests.cs b/src/libraries/Common/tests/Tests/System/Collections/Generic/ArrayBuilderTests.cs
index 5a6dbcd32d1ff1..14a80e17d6af8a 100644
--- a/src/libraries/Common/tests/Tests/System/Collections/Generic/ArrayBuilderTests.cs
+++ b/src/libraries/Common/tests/Tests/System/Collections/Generic/ArrayBuilderTests.cs
@@ -3,6 +3,7 @@
 
 using System.Diagnostics;
 using System.Linq;
+using System.Numerics;
 using Xunit;
 
 namespace System.Collections.Generic.Tests
@@ -205,29 +206,7 @@ private static int CalculateExpectedCapacity(int count)
 
             // Then allocate arrays of size 4, 8, 16, etc.
             count = Math.Max(count, 4);
-            return NextPowerOfTwo(count);
-        }
-
-        private static int NextPowerOfTwo(int value)
-        {
-            // Taken from https://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
-
-            Debug.Assert(value >= 0);
-
-            // If the number is already a power of 2, we want to round to itself.
-            value--;
-
-            // Propogate 1-bits right: if the highest bit set is @ position n,
-            // then all of the bits to the right of position n will become set.
-            value |= value >> 1;
-            value |= value >> 2;
-            value |= value >> 4;
-            value |= value >> 8;
-            value |= value >> 16;
-
-            // This yields a number of the form 2^N - 1.
-            // Add 1 to get a power of 2 with the bit set @ position n + 1.
-            return value + 1;
+            return (int)BitOperations.RoundUpToPowerOf2((uint)count);
         }
     }
 
diff --git a/src/libraries/Directory.Build.props b/src/libraries/Directory.Build.props
index cc5a02e38691df..0078c1331d34d8 100644
--- a/src/libraries/Directory.Build.props
+++ b/src/libraries/Directory.Build.props
@@ -28,7 +28,6 @@
   <PropertyGroup>
     <!-- Build all .NET Framework configurations when net48 is passed in. This is for convenience. -->
     <AdditionalBuildTargetFrameworks Condition="'$(BuildTargetFramework)' == 'net48'">net461;net462;net47;net471;net472</AdditionalBuildTargetFrameworks>
-    <AdditionalBuildTargetFrameworks Condition="'$(DotNetBuildFromSource)' == 'true' and '$(BuildAllProjects)' == 'true'">$(AdditionalBuildTargetFrameworks);netstandard2.0</AdditionalBuildTargetFrameworks>
   </PropertyGroup>
 
   <!-- Define test projects and companions -->
@@ -136,15 +135,6 @@
     <ASPNETCoreAppPackageRefPath>$(ArtifactsBinDir)pkg\aspnetcoreapp\ref</ASPNETCoreAppPackageRefPath>
     <ASPNETCoreAppPackageRuntimePath>$(ArtifactsBinDir)pkg\aspnetcoreapp\lib</ASPNETCoreAppPackageRuntimePath>
 
-    <MicrosoftNetCoreAppRefPackDir>$([MSBuild]::NormalizeDirectory('$(ArtifactsBinDir)', 'microsoft.netcore.app.ref'))</MicrosoftNetCoreAppRefPackDir>
-    <MicrosoftNetCoreAppRefPackRefDir>$([MSBuild]::NormalizeDirectory('$(MicrosoftNetCoreAppRefPackDir)', 'ref', '$(NetCoreAppCurrent)'))</MicrosoftNetCoreAppRefPackRefDir>
-    <MicrosoftNetCoreAppRefPackDataDir>$([MSBuild]::NormalizeDirectory('$(MicrosoftNetCoreAppRefPackDir)', 'data'))</MicrosoftNetCoreAppRefPackDataDir>
-
-    <MicrosoftNetCoreAppRuntimePackDir>$([MSBuild]::NormalizeDirectory('$(ArtifactsBinDir)', 'microsoft.netcore.app.runtime.$(PackageRID)', '$(Configuration)'))</MicrosoftNetCoreAppRuntimePackDir>
-    <MicrosoftNetCoreAppRuntimePackRidDir>$([MSBuild]::NormalizeDirectory('$(MicrosoftNetCoreAppRuntimePackDir)', 'runtimes', '$(PackageRID)'))</MicrosoftNetCoreAppRuntimePackRidDir>
-    <MicrosoftNetCoreAppRuntimePackRidLibTfmDir>$([MSBuild]::NormalizeDirectory('$(MicrosoftNetCoreAppRuntimePackRidDir)', 'lib', '$(NetCoreAppCurrent)'))</MicrosoftNetCoreAppRuntimePackRidLibTfmDir>
-    <MicrosoftNetCoreAppRuntimePackNativeDir>$([MSBuild]::NormalizeDirectory('$(MicrosoftNetCoreAppRuntimePackRidDir)', 'native'))</MicrosoftNetCoreAppRuntimePackNativeDir>
-
     <CommonPathRoot>$([MSBuild]::NormalizeDirectory('$(LibrariesProjectRoot)', 'Common'))</CommonPathRoot>
     <CommonPath>$([MSBuild]::NormalizeDirectory('$(CommonPathRoot)', 'src'))</CommonPath>
     <CommonTestPath>$([MSBuild]::NormalizeDirectory('$(CommonPathRoot)', 'tests'))</CommonTestPath>
diff --git a/src/libraries/Directory.Build.targets b/src/libraries/Directory.Build.targets
index 56d428cd34ed57..051d90878db1af 100644
--- a/src/libraries/Directory.Build.targets
+++ b/src/libraries/Directory.Build.targets
@@ -41,8 +41,7 @@
                                 $(NetCoreAppLibrary.Contains('$(AssemblyName);'))">true</IsNETCoreAppSrc>
     <IsNETCoreAppRef Condition="'$(IsNETCoreAppRef)' == '' and
                                 '$(IsReferenceAssembly)' == 'true' and
-                                $(NetCoreAppLibrary.Contains('$(AssemblyName);')) and
-                                !$(NetCoreAppLibraryNoReference.Contains('$(AssemblyName);'))">true</IsNETCoreAppRef>
+                                $(NetCoreAppLibrary.Contains('$(AssemblyName);'))">true</IsNETCoreAppRef>
     <!-- By default, disable implicit framework references for NetCoreAppCurrent libraries. -->
     <DisableImplicitFrameworkReferences Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp' and
                                                    $([MSBuild]::VersionGreaterThanOrEquals($(TargetFrameworkVersion), '$(NETCoreAppCurrentVersion)')) and
@@ -246,10 +245,6 @@
     <Compile Include="$(CoreLibSharedDir)System\Diagnostics\CodeAnalysis\NullableAttributes.cs" Link="System\Diagnostics\CodeAnalysis\NullableAttributes.cs" />
   </ItemGroup>
 
-  <PropertyGroup>
-    <ExcludeFromPackage Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', '$(NetCoreAppCurrent)')) and '$(ExcludeCurrentNetCoreAppFromPackage)' == 'true'">true</ExcludeFromPackage>
-  </PropertyGroup>
-
   <PropertyGroup Condition="'$(IsCrossTargetingBuild)' != 'true' and '$(DotnetBuildFromSource)' == 'true' and '$(IsPackable)' == 'true' and !$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', '$(NetCoreAppCurrent)')) and '$(TargetFrameworkIdentifier)' != '.NETStandard' and '$(TargetFrameworkVersion)' != 'v2.0'">
     <IncludeBuildOutput>false</IncludeBuildOutput>
     <SuppressDependenciesWhenPacking>true</SuppressDependenciesWhenPacking>
diff --git a/src/libraries/Microsoft.CSharp/tests/DefaultParameterTests.cs b/src/libraries/Microsoft.CSharp/tests/DefaultParameterTests.cs
index beae75bc5dea99..e6b7d359bd7e9e 100644
--- a/src/libraries/Microsoft.CSharp/tests/DefaultParameterTests.cs
+++ b/src/libraries/Microsoft.CSharp/tests/DefaultParameterTests.cs
@@ -9,7 +9,6 @@
 
 namespace Microsoft.CSharp.RuntimeBinder.Tests
 {
-    [ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
     public class DefaultParameterTests
     {
 
diff --git a/src/libraries/Microsoft.Extensions.Caching.Memory/src/MemoryCache.cs b/src/libraries/Microsoft.Extensions.Caching.Memory/src/MemoryCache.cs
index d13c7b936a26a9..35121fc86ebc34 100644
--- a/src/libraries/Microsoft.Extensions.Caching.Memory/src/MemoryCache.cs
+++ b/src/libraries/Microsoft.Extensions.Caching.Memory/src/MemoryCache.cs
@@ -316,8 +316,11 @@ void ScheduleTask(DateTimeOffset utcNow)
         private static void ScanForExpiredItems(MemoryCache cache)
         {
             DateTimeOffset now = cache._lastExpirationScan = cache._options.Clock.UtcNow;
-            foreach (CacheEntry entry in cache._entries.Values)
+
+            foreach (KeyValuePair<object, CacheEntry> item in cache._entries)
             {
+                CacheEntry entry = item.Value;
+
                 if (entry.CheckExpired(now))
                 {
                     cache.RemoveEntry(entry);
@@ -399,8 +402,9 @@ private void Compact(long removalSizeTarget, Func<CacheEntry, long> computeEntry
 
             // Sort items by expired & priority status
             DateTimeOffset now = _options.Clock.UtcNow;
-            foreach (CacheEntry entry in _entries.Values)
+            foreach (KeyValuePair<object, CacheEntry> item in _entries)
             {
+                CacheEntry entry = item.Value;
                 if (entry.CheckExpired(now))
                 {
                     entriesToRemove.Add(entry);
diff --git a/src/libraries/Microsoft.Extensions.Caching.Memory/tests/MemoryCacheSetAndRemoveTests.cs b/src/libraries/Microsoft.Extensions.Caching.Memory/tests/MemoryCacheSetAndRemoveTests.cs
index e9e7fb4ebfc552..fb15d9732061e2 100644
--- a/src/libraries/Microsoft.Extensions.Caching.Memory/tests/MemoryCacheSetAndRemoveTests.cs
+++ b/src/libraries/Microsoft.Extensions.Caching.Memory/tests/MemoryCacheSetAndRemoveTests.cs
@@ -594,6 +594,7 @@ public void OvercapacityPurge_AreThreadSafe()
         }
 
         [Fact]
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/33993")]
         public void AddAndReplaceEntries_AreThreadSafe()
         {
             var cache = new MemoryCache(new MemoryCacheOptions
diff --git a/src/libraries/Microsoft.Extensions.Configuration.Binder/ref/Microsoft.Extensions.Configuration.Binder.cs b/src/libraries/Microsoft.Extensions.Configuration.Binder/ref/Microsoft.Extensions.Configuration.Binder.cs
index 3022b1f9c2ff70..30cdeda1b712dd 100644
--- a/src/libraries/Microsoft.Extensions.Configuration.Binder/ref/Microsoft.Extensions.Configuration.Binder.cs
+++ b/src/libraries/Microsoft.Extensions.Configuration.Binder/ref/Microsoft.Extensions.Configuration.Binder.cs
@@ -10,6 +10,7 @@ public partial class BinderOptions
     {
         public BinderOptions() { }
         public bool BindNonPublicProperties { get { throw null; } set { } }
+        public bool ErrorOnUnknownConfiguration { get { throw null; } set { } }
     }
     public static partial class ConfigurationBinder
     {
diff --git a/src/libraries/Microsoft.Extensions.Configuration.Binder/src/BinderOptions.cs b/src/libraries/Microsoft.Extensions.Configuration.Binder/src/BinderOptions.cs
index 56c3ce55e21b57..f5ffd6eb5758f8 100644
--- a/src/libraries/Microsoft.Extensions.Configuration.Binder/src/BinderOptions.cs
+++ b/src/libraries/Microsoft.Extensions.Configuration.Binder/src/BinderOptions.cs
@@ -13,5 +13,13 @@ public class BinderOptions
         /// If true, the binder will attempt to set all non read-only properties.
         /// </summary>
         public bool BindNonPublicProperties { get; set; }
+
+        /// <summary>
+        /// When false (the default), no exceptions are thrown when a configuration key is found for which the
+        /// provided model object does not have an appropriate property which matches the key's name.
+        /// When true, an <see cref="System.InvalidOperationException"/> is thrown with a description
+        /// of the missing properties.
+        /// </summary>
+        public bool ErrorOnUnknownConfiguration { get; set; }
     }
 }
diff --git a/src/libraries/Microsoft.Extensions.Configuration.Binder/src/ConfigurationBinder.cs b/src/libraries/Microsoft.Extensions.Configuration.Binder/src/ConfigurationBinder.cs
index b475fb7554fa13..f13edb1872ebee 100644
--- a/src/libraries/Microsoft.Extensions.Configuration.Binder/src/ConfigurationBinder.cs
+++ b/src/libraries/Microsoft.Extensions.Configuration.Binder/src/ConfigurationBinder.cs
@@ -209,7 +209,28 @@ private static void BindNonScalar(this IConfiguration configuration, object inst
         {
             if (instance != null)
             {
-                foreach (PropertyInfo property in GetAllProperties(instance.GetType()))
+                List<PropertyInfo> modelProperties = GetAllProperties(instance.GetType());
+
+                if (options.ErrorOnUnknownConfiguration)
+                {
+                    HashSet<string> propertyNames = new(modelProperties.Select(mp => mp.Name),
+                        StringComparer.OrdinalIgnoreCase);
+
+                    IEnumerable<IConfigurationSection> configurationSections = configuration.GetChildren();
+                    List<string> missingPropertyNames = configurationSections
+                        .Where(cs => !propertyNames.Contains(cs.Key))
+                        .Select(mp => $"'{mp.Key}'")
+                        .ToList();
+
+                    if (missingPropertyNames.Count > 0)
+                    {
+                        throw new InvalidOperationException(SR.Format(SR.Error_MissingConfig,
+                            nameof(options.ErrorOnUnknownConfiguration), nameof(BinderOptions), instance.GetType(),
+                            string.Join(", ", missingPropertyNames)));
+                    }
+                }
+
+                foreach (PropertyInfo property in modelProperties)
                 {
                     BindProperty(property, instance, configuration, options);
                 }
@@ -622,7 +643,7 @@ private static Type FindOpenGenericInterface(
             return null;
         }
 
-        private static IEnumerable<PropertyInfo> GetAllProperties(
+        private static List<PropertyInfo> GetAllProperties(
             [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)]
             Type type)
         {
diff --git a/src/libraries/Microsoft.Extensions.Configuration.Binder/src/Resources/Strings.resx b/src/libraries/Microsoft.Extensions.Configuration.Binder/src/Resources/Strings.resx
index 54660f24f758d6..dca7cc1bf353b4 100644
--- a/src/libraries/Microsoft.Extensions.Configuration.Binder/src/Resources/Strings.resx
+++ b/src/libraries/Microsoft.Extensions.Configuration.Binder/src/Resources/Strings.resx
@@ -1,17 +1,17 @@
 <?xml version="1.0" encoding="utf-8"?>
 <root>
-  <!--
-    Microsoft ResX Schema
-
+  <!-- 
+    Microsoft ResX Schema 
+    
     Version 2.0
-
-    The primary goals of this format is to allow a simple XML format
-    that is mostly human readable. The generation and parsing of the
-    various data types are done through the TypeConverter classes
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
     associated with the data types.
-
+    
     Example:
-
+    
     ... ado.net/XML headers & schema ...
     <resheader name="resmimetype">text/microsoft-resx</resheader>
     <resheader name="version">2.0</resheader>
@@ -26,36 +26,36 @@
         <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
         <comment>This is a comment</comment>
     </data>
-
-    There are any number of "resheader" rows that contain simple
+                
+    There are any number of "resheader" rows that contain simple 
     name/value pairs.
-
-    Each data row contains a name, and value. The row also contains a
-    type or mimetype. Type corresponds to a .NET class that support
-    text/value conversion through the TypeConverter architecture.
-    Classes that don't support this are serialized and stored with the
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
     mimetype set.
-
-    The mimetype is used for serialized objects, and tells the
-    ResXResourceReader how to depersist the object. This is currently not
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
     extensible. For a given mimetype the value must be set accordingly:
-
-    Note - application/x-microsoft.net.object.binary.base64 is the format
-    that the ResXResourceWriter will generate, however the reader can
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
     read any of the formats listed below.
-
+    
     mimetype: application/x-microsoft.net.object.binary.base64
-    value   : The object must be serialized with
+    value   : The object must be serialized with 
             : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
             : and then encoded with base64 encoding.
-
+    
     mimetype: application/x-microsoft.net.object.soap.base64
-    value   : The object must be serialized with
+    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
+    value   : The object must be serialized into a byte array 
             : using a System.ComponentModel.TypeConverter
             : and then encoded with base64 encoding.
     -->
@@ -126,10 +126,13 @@
   <data name="Error_FailedToActivate" xml:space="preserve">
     <value>Failed to create instance of type '{0}'.</value>
   </data>
+  <data name="Error_MissingConfig" xml:space="preserve">
+    <value>'{0}' was set on the provided {1}, but the following properties were not found on the instance of {2}: {3}</value>
+  </data>
   <data name="Error_MissingParameterlessConstructor" xml:space="preserve">
     <value>Cannot create instance of type '{0}' because it is missing a public parameterless constructor.</value>
   </data>
   <data name="Error_UnsupportedMultidimensionalArray" xml:space="preserve">
     <value>Cannot create instance of type '{0}' because multidimensional arrays are not supported.</value>
   </data>
-</root>
+</root>
\ No newline at end of file
diff --git a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/ConfigurationBinderTests.cs b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/ConfigurationBinderTests.cs
index 734bcf3ed4aca5..d4014ad734fe92 100644
--- a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/ConfigurationBinderTests.cs
+++ b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/ConfigurationBinderTests.cs
@@ -294,6 +294,55 @@ public void GetNullValue()
             Assert.Null(config.GetSection("Object").Get<ComplexOptions>());
         }
 
+        [Fact]
+        public void ThrowsIfPropertyInConfigMissingInModel()
+        {
+            var dic = new Dictionary<string, string>
+            {
+                {"ThisDoesNotExistInTheModel", "42"},
+                {"Integer", "-2"},
+                {"Boolean", "TRUe"},
+                {"Nested:Integer", "11"}
+            };
+            var configurationBuilder = new ConfigurationBuilder();
+            configurationBuilder.AddInMemoryCollection(dic);
+            var config = configurationBuilder.Build();
+
+            var instance = new ComplexOptions();
+
+            var ex = Assert.Throws<InvalidOperationException>(
+                () => config.Bind(instance, o => o.ErrorOnUnknownConfiguration = true));
+
+            string expectedMessage = SR.Format(SR.Error_MissingConfig,
+                nameof(BinderOptions.ErrorOnUnknownConfiguration), nameof(BinderOptions), typeof(ComplexOptions), "'ThisDoesNotExistInTheModel'");
+
+            Assert.Equal(expectedMessage, ex.Message);
+        }
+        [Fact]
+        public void ThrowsIfPropertyInConfigMissingInNestedModel()
+        {
+            var dic = new Dictionary<string, string>
+            {
+                {"Nested:ThisDoesNotExistInTheModel", "42"},
+                {"Integer", "-2"},
+                {"Boolean", "TRUe"},
+                {"Nested:Integer", "11"}
+            };
+            var configurationBuilder = new ConfigurationBuilder();
+            configurationBuilder.AddInMemoryCollection(dic);
+            var config = configurationBuilder.Build();
+
+            var instance = new ComplexOptions();
+
+            string expectedMessage = SR.Format(SR.Error_MissingConfig,
+                nameof(BinderOptions.ErrorOnUnknownConfiguration), nameof(BinderOptions), typeof(NestedOptions), "'ThisDoesNotExistInTheModel'");
+
+            var ex = Assert.Throws<InvalidOperationException>(
+                () => config.Bind(instance, o => o.ErrorOnUnknownConfiguration = true));
+
+            Assert.Equal(expectedMessage, ex.Message);
+        }
+
         [Fact]
         public void GetDefaultsWhenDataDoesNotExist()
         {
diff --git a/src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/ref/Microsoft.Extensions.DependencyInjection.Abstractions.cs b/src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/ref/Microsoft.Extensions.DependencyInjection.Abstractions.cs
index ca0fae35465455..5ba22b99dcbbd7 100644
--- a/src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/ref/Microsoft.Extensions.DependencyInjection.Abstractions.cs
+++ b/src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/ref/Microsoft.Extensions.DependencyInjection.Abstractions.cs
@@ -36,6 +36,10 @@ public partial interface IServiceProviderFactory<TContainerBuilder> where TConta
         TContainerBuilder CreateBuilder(Microsoft.Extensions.DependencyInjection.IServiceCollection services);
         System.IServiceProvider CreateServiceProvider(TContainerBuilder containerBuilder);
     }
+    public partial interface IServiceProviderIsService
+    {
+        bool IsService(System.Type serviceType);
+    }
     public partial interface IServiceScope : System.IDisposable
     {
         System.IServiceProvider ServiceProvider { get; }
diff --git a/src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/src/IServiceProviderIsService.cs b/src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/src/IServiceProviderIsService.cs
new file mode 100644
index 00000000000000..b24ab154d16e93
--- /dev/null
+++ b/src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/src/IServiceProviderIsService.cs
@@ -0,0 +1,20 @@
+// 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.DependencyInjection
+{
+    /// <summary>
+    /// Optional service used to determine if the specified type is available from the <see cref="IServiceProvider"/>.
+    /// </summary>
+    public interface IServiceProviderIsService
+    {
+        /// <summary>
+        /// Determines if the specified service type is available from the <see cref="IServiceProvider"/>.
+        /// </summary>
+        /// <param name="serviceType">An object that specifies the type of service object to test.</param>
+        /// <returns>true if the specified service is a available, false if it is not.</returns>
+        bool IsService(Type serviceType);
+    }
+}
diff --git a/src/libraries/Microsoft.Extensions.DependencyInjection.Specification.Tests/src/Microsoft.Extensions.DependencyInjection.Specification.Tests.csproj b/src/libraries/Microsoft.Extensions.DependencyInjection.Specification.Tests/src/Microsoft.Extensions.DependencyInjection.Specification.Tests.csproj
index 8a2a6e74cc7bab..4c1f40cce828db 100644
--- a/src/libraries/Microsoft.Extensions.DependencyInjection.Specification.Tests/src/Microsoft.Extensions.DependencyInjection.Specification.Tests.csproj
+++ b/src/libraries/Microsoft.Extensions.DependencyInjection.Specification.Tests/src/Microsoft.Extensions.DependencyInjection.Specification.Tests.csproj
@@ -1,10 +1,11 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>netstandard2.0</TargetFrameworks>
+    <TargetFrameworks>netstandard2.0;net461</TargetFrameworks>
     <EnableDefaultItems>true</EnableDefaultItems>
     <CLSCompliant>false</CLSCompliant>
     <IsRuntimeAssembly>false</IsRuntimeAssembly>
+    <!-- TODO: Remove after this package shipped as 6.0.0. -->
     <PackageValidationBaselineVersion>3.1.15</PackageValidationBaselineVersion>
     <PackageDescription>Suite of xUnit.net tests to check for container compatibility with Microsoft.Extensions.DependencyInjection.</PackageDescription>
   </PropertyGroup>
diff --git a/src/libraries/Microsoft.Extensions.DependencyInjection.Specification.Tests/src/ServiceProviderIsServiceSpecificationTests.cs b/src/libraries/Microsoft.Extensions.DependencyInjection.Specification.Tests/src/ServiceProviderIsServiceSpecificationTests.cs
new file mode 100644
index 00000000000000..66ef77a01eb1e5
--- /dev/null
+++ b/src/libraries/Microsoft.Extensions.DependencyInjection.Specification.Tests/src/ServiceProviderIsServiceSpecificationTests.cs
@@ -0,0 +1,127 @@
+// 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.Text;
+using Microsoft.Extensions.DependencyInjection.Specification.Fakes;
+using Xunit;
+
+namespace Microsoft.Extensions.DependencyInjection.Specification
+{
+    public abstract partial class DependencyInjectionSpecificationTests
+    {
+        public virtual bool SupportsIServiceProviderIsService => true;
+
+        [Fact]
+        public void ExplictServiceRegisterationWithIsService()
+        {
+            if (!SupportsIServiceProviderIsService)
+            {
+                return;
+            }
+
+            // Arrange
+            var collection = new TestServiceCollection();
+            collection.AddTransient(typeof(IFakeService), typeof(FakeService));
+            var provider = CreateServiceProvider(collection);
+
+            // Act
+            var serviceProviderIsService = provider.GetService<IServiceProviderIsService>();
+
+            // Assert
+            Assert.NotNull(serviceProviderIsService);
+            Assert.True(serviceProviderIsService.IsService(typeof(IFakeService)));
+            Assert.False(serviceProviderIsService.IsService(typeof(FakeService)));
+        }
+
+        [Fact]
+        public void OpenGenericsWithIsService()
+        {
+            if (!SupportsIServiceProviderIsService)
+            {
+                return;
+            }
+
+            // Arrange
+            var collection = new TestServiceCollection();
+            collection.AddTransient(typeof(IFakeOpenGenericService<>), typeof(FakeOpenGenericService<>));
+            var provider = CreateServiceProvider(collection);
+
+            // Act
+            var serviceProviderIsService = provider.GetService<IServiceProviderIsService>();
+
+            // Assert
+            Assert.NotNull(serviceProviderIsService);
+            Assert.True(serviceProviderIsService.IsService(typeof(IFakeOpenGenericService<IFakeService>)));
+            Assert.False(serviceProviderIsService.IsService(typeof(IFakeOpenGenericService<>)));
+        }
+
+        [Fact]
+        public void ClosedGenericsWithIsService()
+        {
+            if (!SupportsIServiceProviderIsService)
+            {
+                return;
+            }
+
+            // Arrange
+            var collection = new TestServiceCollection();
+            collection.AddTransient(typeof(IFakeOpenGenericService<IFakeService>), typeof(FakeOpenGenericService<IFakeService>));
+            var provider = CreateServiceProvider(collection);
+
+            // Act
+            var serviceProviderIsService = provider.GetService<IServiceProviderIsService>();
+
+            // Assert
+            Assert.NotNull(serviceProviderIsService);
+            Assert.True(serviceProviderIsService.IsService(typeof(IFakeOpenGenericService<IFakeService>)));
+        }
+
+        [Fact]
+        public void IEnumerableWithIsServiceAlwaysReturnsTrue()
+        {
+            if (!SupportsIServiceProviderIsService)
+            {
+                return;
+            }
+
+            // Arrange
+            var collection = new TestServiceCollection();
+            collection.AddTransient(typeof(IFakeService), typeof(FakeService));
+            var provider = CreateServiceProvider(collection);
+
+            // Act
+            var serviceProviderIsService = provider.GetService<IServiceProviderIsService>();
+
+            // Assert
+            Assert.NotNull(serviceProviderIsService);
+            Assert.True(serviceProviderIsService.IsService(typeof(IEnumerable<IFakeService>)));
+            Assert.True(serviceProviderIsService.IsService(typeof(IEnumerable<FakeService>)));
+            Assert.False(serviceProviderIsService.IsService(typeof(IEnumerable<>)));
+        }
+
+        [Fact]
+        public void BuiltInServicesWithIsServiceReturnsTrue()
+        {
+            if (!SupportsIServiceProviderIsService)
+            {
+                return;
+            }
+
+            // Arrange
+            var collection = new TestServiceCollection();
+            collection.AddTransient(typeof(IFakeService), typeof(FakeService));
+            var provider = CreateServiceProvider(collection);
+
+            // Act
+            var serviceProviderIsService = provider.GetService<IServiceProviderIsService>();
+
+            // Assert
+            Assert.NotNull(serviceProviderIsService);
+            Assert.True(serviceProviderIsService.IsService(typeof(IServiceProvider)));
+            Assert.True(serviceProviderIsService.IsService(typeof(IServiceScopeFactory)));
+            Assert.True(serviceProviderIsService.IsService(typeof(IServiceProviderIsService)));
+        }
+    }
+}
diff --git a/src/libraries/Microsoft.Extensions.DependencyInjection/src/ServiceLookup/CallSiteFactory.cs b/src/libraries/Microsoft.Extensions.DependencyInjection/src/ServiceLookup/CallSiteFactory.cs
index 47d7d02f4db4b3..a2e02ce4f50010 100644
--- a/src/libraries/Microsoft.Extensions.DependencyInjection/src/ServiceLookup/CallSiteFactory.cs
+++ b/src/libraries/Microsoft.Extensions.DependencyInjection/src/ServiceLookup/CallSiteFactory.cs
@@ -12,7 +12,7 @@
 
 namespace Microsoft.Extensions.DependencyInjection.ServiceLookup
 {
-    internal sealed class CallSiteFactory
+    internal sealed class CallSiteFactory : IServiceProviderIsService
     {
         private const int DefaultSlot = 0;
         private readonly ServiceDescriptor[] _descriptors;
@@ -77,6 +77,17 @@ private void Populate()
             }
         }
 
+        // For unit testing
+        internal int? GetSlot(ServiceDescriptor serviceDescriptor)
+        {
+            if (_descriptorLookup.TryGetValue(serviceDescriptor.ServiceType, out ServiceDescriptorCacheItem item))
+            {
+                return item.GetSlot(serviceDescriptor);
+            }
+
+            return null;
+        }
+
         internal ServiceCallSite GetCallSite(Type serviceType, CallSiteChain callSiteChain) =>
             _callSiteCache.TryGetValue(new ServiceCacheKey(serviceType, DefaultSlot), out ServiceCallSite site) ? site :
             CreateCallSite(serviceType, callSiteChain);
@@ -441,6 +452,38 @@ public void Add(Type type, ServiceCallSite serviceCallSite)
             _callSiteCache[new ServiceCacheKey(type, DefaultSlot)] = serviceCallSite;
         }
 
+        public bool IsService(Type serviceType)
+        {
+            if (serviceType is null)
+            {
+                throw new ArgumentNullException(nameof(serviceType));
+            }
+
+            // Querying for an open generic should return false (they aren't resolvable)
+            if (serviceType.IsGenericTypeDefinition)
+            {
+                return false;
+            }
+
+            if (_descriptorLookup.ContainsKey(serviceType))
+            {
+                return true;
+            }
+
+            if (serviceType.IsConstructedGenericType && serviceType.GetGenericTypeDefinition() is Type genericDefinition)
+            {
+                // We special case IEnumerable since it isn't explicitly registered in the container
+                // yet we can manifest instances of it when requested.
+                return genericDefinition == typeof(IEnumerable<>) || _descriptorLookup.ContainsKey(genericDefinition);
+            }
+
+            // These are the built in service types that aren't part of the list of service descriptors
+            // If you update these make sure to also update the code in ServiceProvider.ctor
+            return serviceType == typeof(IServiceProvider) ||
+                   serviceType == typeof(IServiceScopeFactory) ||
+                   serviceType == typeof(IServiceProviderIsService);
+        }
+
         private struct ServiceDescriptorCacheItem
         {
             private ServiceDescriptor _item;
@@ -505,7 +548,7 @@ public int GetSlot(ServiceDescriptor descriptor)
                     int index = _items.IndexOf(descriptor);
                     if (index != -1)
                     {
-                        return Count - index + 1;
+                        return _items.Count - (index + 1);
                     }
                 }
 
diff --git a/src/libraries/Microsoft.Extensions.DependencyInjection/src/ServiceLookup/DynamicServiceProviderEngine.cs b/src/libraries/Microsoft.Extensions.DependencyInjection/src/ServiceLookup/DynamicServiceProviderEngine.cs
index 23914ec50c73bf..ee124f31be8eff 100644
--- a/src/libraries/Microsoft.Extensions.DependencyInjection/src/ServiceLookup/DynamicServiceProviderEngine.cs
+++ b/src/libraries/Microsoft.Extensions.DependencyInjection/src/ServiceLookup/DynamicServiceProviderEngine.cs
@@ -20,27 +20,12 @@ public override Func<ServiceProviderEngineScope, object> RealizeService(ServiceC
             int callCount = 0;
             return scope =>
             {
-                // We want to directly use the callsite value if it's set and the scope is the root scope.
-                // We've already called into the RuntimeResolver and pre-computed any singletons or root scope
-                // Avoid the compilation for singletons (or promoted singletons)
-                if (scope.IsRootScope && callSite.Value != null)
-                {
-                    return callSite.Value;
-                }
-
                 // Resolve the result before we increment the call count, this ensures that singletons
                 // won't cause any side effects during the compilation of the resolve function.
                 var result = CallSiteRuntimeResolver.Instance.Resolve(callSite, scope);
 
                 if (Interlocked.Increment(ref callCount) == 2)
                 {
-                    // This second check is to avoid the race where we end up kicking off a background thread
-                    // if multiple calls to GetService race and resolve the values for singletons before the initial check above.
-                    if (scope.IsRootScope && callSite.Value != null)
-                    {
-                        return callSite.Value;
-                    }
-
                     // Don't capture the ExecutionContext when forking to build the compiled version of the
                     // resolve function
                     _ = ThreadPool.UnsafeQueueUserWorkItem(_ =>
diff --git a/src/libraries/Microsoft.Extensions.DependencyInjection/src/ServiceLookup/Expressions/ExpressionResolverBuilder.cs b/src/libraries/Microsoft.Extensions.DependencyInjection/src/ServiceLookup/Expressions/ExpressionResolverBuilder.cs
index 3fd07268b8424a..07ff50a44d6711 100644
--- a/src/libraries/Microsoft.Extensions.DependencyInjection/src/ServiceLookup/Expressions/ExpressionResolverBuilder.cs
+++ b/src/libraries/Microsoft.Extensions.DependencyInjection/src/ServiceLookup/Expressions/ExpressionResolverBuilder.cs
@@ -17,6 +17,7 @@ internal sealed class ExpressionResolverBuilder : CallSiteVisitor<object, Expres
         internal static readonly MethodInfo InvokeFactoryMethodInfo = GetMethodInfo<Action<Func<IServiceProvider, object>, IServiceProvider>>((a, b) => a.Invoke(b));
         internal static readonly MethodInfo CaptureDisposableMethodInfo = GetMethodInfo<Func<ServiceProviderEngineScope, object, object>>((a, b) => a.CaptureDisposable(b));
         internal static readonly MethodInfo TryGetValueMethodInfo = GetMethodInfo<Func<IDictionary<ServiceCacheKey, object>, ServiceCacheKey, object, bool>>((a, b, c) => a.TryGetValue(b, out c));
+        internal static readonly MethodInfo ResolveCallSiteAndScopeMethodInfo = GetMethodInfo<Func<CallSiteRuntimeResolver, ServiceCallSite, ServiceProviderEngineScope, object>>((a, b, c) => a.Resolve(b, c));
         internal static readonly MethodInfo AddMethodInfo = GetMethodInfo<Action<IDictionary<ServiceCacheKey, object>, ServiceCacheKey, object>>((a, b, c) => a.Add(b, c));
         internal static readonly MethodInfo MonitorEnterMethodInfo = GetMethodInfo<Action<object, bool>>((lockObj, lockTaken) => Monitor.Enter(lockObj, ref lockTaken));
         internal static readonly MethodInfo MonitorExitMethodInfo = GetMethodInfo<Action<object>>(lockObj => Monitor.Exit(lockObj));
@@ -44,6 +45,10 @@ internal sealed class ExpressionResolverBuilder : CallSiteVisitor<object, Expres
                     Expression.Call(ScopeParameter, CaptureDisposableMethodInfo, CaptureDisposableParameter),
                     CaptureDisposableParameter);
 
+        private static readonly ConstantExpression CallSiteRuntimeResolverInstanceExpression = Expression.Constant(
+            CallSiteRuntimeResolver.Instance,
+            typeof(CallSiteRuntimeResolver));
+
         private readonly ServiceProviderEngineScope _rootScope;
 
         private readonly ConcurrentDictionary<ServiceCacheKey, Func<ServiceProviderEngineScope, object>> _scopeResolverCache;
@@ -203,6 +208,19 @@ protected override Expression VisitScopeCache(ServiceCallSite callSite, object c
         // Move off the main stack
         private Expression BuildScopedExpression(ServiceCallSite callSite)
         {
+            ConstantExpression callSiteExpression = Expression.Constant(
+                callSite,
+                typeof(ServiceCallSite));
+
+            // We want to directly use the callsite value if it's set and the scope is the root scope.
+            // We've already called into the RuntimeResolver and pre-computed any singletons or root scope
+            // Avoid the compilation for singletons (or promoted singletons)
+            MethodCallExpression resolveRootScopeExpression = Expression.Call(
+                CallSiteRuntimeResolverInstanceExpression,
+                ResolveCallSiteAndScopeMethodInfo,
+                callSiteExpression,
+                ScopeParameter);
+
             ConstantExpression keyExpression = Expression.Constant(
                 callSite.Cache.Key,
                 typeof(ServiceCacheKey));
@@ -254,10 +272,17 @@ private Expression BuildScopedExpression(ServiceCallSite callSite)
             BlockExpression tryBody = Expression.Block(monitorEnter, blockExpression);
             ConditionalExpression finallyBody = Expression.IfThen(lockWasTaken, monitorExit);
 
-            return Expression.Block(
-                typeof(object),
-                new[] { lockWasTaken },
-                Expression.TryFinally(tryBody, finallyBody));
+            return Expression.Condition(
+                    Expression.Property(
+                        ScopeParameter,
+                        typeof(ServiceProviderEngineScope)
+                            .GetProperty(nameof(ServiceProviderEngineScope.IsRootScope), BindingFlags.Instance | BindingFlags.Public)),
+                    resolveRootScopeExpression,
+                    Expression.Block(
+                        typeof(object),
+                        new[] { lockWasTaken },
+                        Expression.TryFinally(tryBody, finallyBody))
+                );
         }
 
         private static MethodInfo GetMethodInfo<T>(Expression<T> expr)
diff --git a/src/libraries/Microsoft.Extensions.DependencyInjection/src/ServiceLookup/ILEmit/ILEmitResolverBuilder.cs b/src/libraries/Microsoft.Extensions.DependencyInjection/src/ServiceLookup/ILEmit/ILEmitResolverBuilder.cs
index 227a2f8c3688fe..a9015e12a99f08 100644
--- a/src/libraries/Microsoft.Extensions.DependencyInjection/src/ServiceLookup/ILEmit/ILEmitResolverBuilder.cs
+++ b/src/libraries/Microsoft.Extensions.DependencyInjection/src/ServiceLookup/ILEmit/ILEmitResolverBuilder.cs
@@ -6,6 +6,7 @@
 using System.Collections.Generic;
 using System.Reflection;
 using System.Reflection.Emit;
+using Microsoft.Extensions.DependencyInjection.ServiceLookup;
 
 namespace Microsoft.Extensions.DependencyInjection.ServiceLookup
 {
@@ -17,6 +18,15 @@ internal sealed class ILEmitResolverBuilder : CallSiteVisitor<ILEmitResolverBuil
         private static readonly MethodInfo ScopeLockGetter = typeof(ServiceProviderEngineScope).GetProperty(
             nameof(ServiceProviderEngineScope.Sync), BindingFlags.Instance | BindingFlags.NonPublic).GetMethod;
 
+        private static readonly MethodInfo ScopeIsRootScope = typeof(ServiceProviderEngineScope).GetProperty(
+            nameof(ServiceProviderEngineScope.IsRootScope), BindingFlags.Instance | BindingFlags.Public).GetMethod;
+
+        private static readonly MethodInfo CallSiteRuntimeResolverResolveMethod = typeof(CallSiteRuntimeResolver).GetMethod(
+            nameof(CallSiteRuntimeResolver.Resolve), BindingFlags.Public | BindingFlags.Instance);
+
+        private static readonly MethodInfo CallSiteRuntimeResolverInstanceField = typeof(CallSiteRuntimeResolver).GetProperty(
+            nameof(CallSiteRuntimeResolver.Instance), BindingFlags.Static | BindingFlags.Public | BindingFlags.Instance).GetMethod;
+
         private static readonly FieldInfo FactoriesField = typeof(ILEmitResolverBuilderRuntimeContext).GetField(nameof(ILEmitResolverBuilderRuntimeContext.Factories));
         private static readonly FieldInfo ConstantsField = typeof(ILEmitResolverBuilderRuntimeContext).GetField(nameof(ILEmitResolverBuilderRuntimeContext.Constants));
         private static readonly MethodInfo GetTypeFromHandleMethod = typeof(Type).GetMethod(nameof(Type.GetTypeFromHandle));
@@ -99,7 +109,7 @@ private GeneratedMethod BuildTypeNoCache(ServiceCallSite callSite)
                 "ResolveService", MethodAttributes.Public | MethodAttributes.Static, CallingConventions.Standard, typeof(object),
                 new[] { typeof(ILEmitResolverBuilderRuntimeContext), typeof(ServiceProviderEngineScope) });
 
-            GenerateMethodBody(callSite, method.GetILGenerator(), info);
+            GenerateMethodBody(callSite, method.GetILGenerator());
             type.CreateTypeInfo();
             assembly.Save(assemblyName + ".dll");
 #endif
@@ -281,6 +291,10 @@ private ILEmitResolverBuilderRuntimeContext GenerateMethodBody(ServiceCallSite c
                 Factories = null
             };
 
+            // if (scope.IsRootScope)
+            // {
+            //     return CallSiteRuntimeResolver.Instance.Resolve(callSite, scope);
+            // }
             //  var cacheKey = scopedCallSite.CacheKey;
             //  try
             //  {
@@ -309,8 +323,21 @@ private ILEmitResolverBuilderRuntimeContext GenerateMethodBody(ServiceCallSite c
 
                 Label skipCreationLabel = context.Generator.DefineLabel();
                 Label returnLabel = context.Generator.DefineLabel();
+                Label defaultLabel = context.Generator.DefineLabel();
+
+                // Check if scope IsRootScope
+                context.Generator.Emit(OpCodes.Ldarg_1);
+                context.Generator.Emit(OpCodes.Callvirt, ScopeIsRootScope);
+                context.Generator.Emit(OpCodes.Brfalse_S, defaultLabel);
+
+                context.Generator.Emit(OpCodes.Call, CallSiteRuntimeResolverInstanceField);
+                AddConstant(context, callSite);
+                context.Generator.Emit(OpCodes.Ldarg_1);
+                context.Generator.Emit(OpCodes.Callvirt, CallSiteRuntimeResolverResolveMethod);
+                context.Generator.Emit(OpCodes.Ret);
 
                 // Generate cache key
+                context.Generator.MarkLabel(defaultLabel);
                 AddCacheKey(context, callSite.Cache.Key);
                 // and store to local
                 Stloc(context.Generator, cacheKeyLocal.LocalIndex);
diff --git a/src/libraries/Microsoft.Extensions.DependencyInjection/src/ServiceLookup/ServiceProviderEngineScope.cs b/src/libraries/Microsoft.Extensions.DependencyInjection/src/ServiceLookup/ServiceProviderEngineScope.cs
index fce0f12152a808..4ad8b1579a0290 100644
--- a/src/libraries/Microsoft.Extensions.DependencyInjection/src/ServiceLookup/ServiceProviderEngineScope.cs
+++ b/src/libraries/Microsoft.Extensions.DependencyInjection/src/ServiceLookup/ServiceProviderEngineScope.cs
@@ -11,15 +11,16 @@ namespace Microsoft.Extensions.DependencyInjection.ServiceLookup
     internal sealed class ServiceProviderEngineScope : IServiceScope, IServiceProvider, IAsyncDisposable, IServiceScopeFactory
     {
         // For testing only
-        internal Action<object> _captureDisposableCallback;
+        internal IList<object> Disposables => _disposables ?? (IList<object>)Array.Empty<object>();
 
         private bool _disposed;
         private List<object> _disposables;
 
-        public ServiceProviderEngineScope(ServiceProvider provider)
+        public ServiceProviderEngineScope(ServiceProvider provider, bool isRootScope)
         {
             ResolvedServices = new Dictionary<ServiceCacheKey, object>();
             RootProvider = provider;
+            IsRootScope = isRootScope;
         }
 
         internal Dictionary<ServiceCacheKey, object> ResolvedServices { get; }
@@ -29,7 +30,7 @@ public ServiceProviderEngineScope(ServiceProvider provider)
         // For other scopes, it protects ResolvedServices and the list of disposables
         internal object Sync => ResolvedServices;
 
-        public bool IsRootScope => this == RootProvider.Root;
+        public bool IsRootScope { get; }
 
         internal ServiceProvider RootProvider { get; }
 
@@ -49,8 +50,6 @@ public object GetService(Type serviceType)
 
         internal object CaptureDisposable(object service)
         {
-            _captureDisposableCallback?.Invoke(service);
-
             if (ReferenceEquals(this, service) || !(service is IDisposable || service is IAsyncDisposable))
             {
                 return service;
diff --git a/src/libraries/Microsoft.Extensions.DependencyInjection/src/ServiceProvider.cs b/src/libraries/Microsoft.Extensions.DependencyInjection/src/ServiceProvider.cs
index 228fb45e3aa22f..fb7052ec8ea669 100644
--- a/src/libraries/Microsoft.Extensions.DependencyInjection/src/ServiceProvider.cs
+++ b/src/libraries/Microsoft.Extensions.DependencyInjection/src/ServiceProvider.cs
@@ -36,10 +36,13 @@ internal ServiceProvider(IEnumerable<ServiceDescriptor> serviceDescriptors, Serv
             _createServiceAccessor = CreateServiceAccessor;
             _realizedServices = new ConcurrentDictionary<Type, Func<ServiceProviderEngineScope, object>>();
 
-            Root = new ServiceProviderEngineScope(this);
+            Root = new ServiceProviderEngineScope(this, isRootScope: true);
             CallSiteFactory = new CallSiteFactory(serviceDescriptors);
+            // The list of built in services that aren't part of the list of service descriptors
+            // keep this in sync with CallSiteFactory.IsService
             CallSiteFactory.Add(typeof(IServiceProvider), new ServiceProviderCallSite());
             CallSiteFactory.Add(typeof(IServiceScopeFactory), new ServiceScopeFactoryCallSite(Root));
+            CallSiteFactory.Add(typeof(IServiceProviderIsService), new ConstantCallSite(typeof(IServiceProviderIsService), CallSiteFactory));
 
             if (options.ValidateScopes)
             {
@@ -111,7 +114,9 @@ internal object GetService(Type serviceType, ServiceProviderEngineScope serviceP
             Func<ServiceProviderEngineScope, object> realizedService = _realizedServices.GetOrAdd(serviceType, _createServiceAccessor);
             OnResolve(serviceType, serviceProviderEngineScope);
             DependencyInjectionEventSource.Log.ServiceResolved(serviceType);
-            return realizedService.Invoke(serviceProviderEngineScope);
+            var result = realizedService.Invoke(serviceProviderEngineScope);
+            System.Diagnostics.Debug.Assert(result is null || CallSiteFactory.IsService(serviceType));
+            return result;
         }
 
         private void ValidateService(ServiceDescriptor descriptor)
@@ -168,7 +173,7 @@ internal IServiceScope CreateScope()
                 ThrowHelper.ThrowObjectDisposedException();
             }
 
-            return new ServiceProviderEngineScope(this);
+            return new ServiceProviderEngineScope(this, isRootScope: false);
         }
 
         private ServiceProviderEngine GetEngine()
diff --git a/src/libraries/Microsoft.Extensions.DependencyInjection/tests/DI.External.Tests/Autofac.cs b/src/libraries/Microsoft.Extensions.DependencyInjection/tests/DI.External.Tests/Autofac.cs
index f80fd06d146aac..a18ea83ae7917f 100644
--- a/src/libraries/Microsoft.Extensions.DependencyInjection/tests/DI.External.Tests/Autofac.cs
+++ b/src/libraries/Microsoft.Extensions.DependencyInjection/tests/DI.External.Tests/Autofac.cs
@@ -9,6 +9,8 @@ namespace Microsoft.Extensions.DependencyInjection.Specification
 {
     public class AutofacDependencyInjectionSpecificationTests : DependencyInjectionSpecificationTests
     {
+        public override bool SupportsIServiceProviderIsService => false;
+
         protected override IServiceProvider CreateServiceProvider(IServiceCollection serviceCollection)
         {
             var builder = new ContainerBuilder();
diff --git a/src/libraries/Microsoft.Extensions.DependencyInjection/tests/DI.External.Tests/DryIoc.cs b/src/libraries/Microsoft.Extensions.DependencyInjection/tests/DI.External.Tests/DryIoc.cs
index 3de5ef16d0b539..2ab31bf5f5fda1 100644
--- a/src/libraries/Microsoft.Extensions.DependencyInjection/tests/DI.External.Tests/DryIoc.cs
+++ b/src/libraries/Microsoft.Extensions.DependencyInjection/tests/DI.External.Tests/DryIoc.cs
@@ -7,8 +7,10 @@
 
 namespace Microsoft.Extensions.DependencyInjection.Specification
 {
-    public class DryIocDependencyInjectionSpecificationTests: DependencyInjectionSpecificationTests
+    public class DryIocDependencyInjectionSpecificationTests : DependencyInjectionSpecificationTests
     {
+        public override bool SupportsIServiceProviderIsService => false;
+
         protected override IServiceProvider CreateServiceProvider(IServiceCollection serviceCollection)
         {
             return new Container()
diff --git a/src/libraries/Microsoft.Extensions.DependencyInjection/tests/DI.External.Tests/Grace.cs b/src/libraries/Microsoft.Extensions.DependencyInjection/tests/DI.External.Tests/Grace.cs
index 165997400bc457..7733aaa16587df 100644
--- a/src/libraries/Microsoft.Extensions.DependencyInjection/tests/DI.External.Tests/Grace.cs
+++ b/src/libraries/Microsoft.Extensions.DependencyInjection/tests/DI.External.Tests/Grace.cs
@@ -9,6 +9,8 @@ namespace Microsoft.Extensions.DependencyInjection.Specification
 {
     public class GraceDependencyInjectionSpecificationTests: SkippableDependencyInjectionSpecificationTests
     {
+        public override bool SupportsIServiceProviderIsService => false;
+
         public override string[] SkippedTests => new[]
         {
             "ResolvesMixedOpenClosedGenericsAsEnumerable",
diff --git a/src/libraries/Microsoft.Extensions.DependencyInjection/tests/DI.External.Tests/Lamar.cs b/src/libraries/Microsoft.Extensions.DependencyInjection/tests/DI.External.Tests/Lamar.cs
index fecf0e4d840346..795bc330c97754 100644
--- a/src/libraries/Microsoft.Extensions.DependencyInjection/tests/DI.External.Tests/Lamar.cs
+++ b/src/libraries/Microsoft.Extensions.DependencyInjection/tests/DI.External.Tests/Lamar.cs
@@ -7,6 +7,8 @@ namespace Microsoft.Extensions.DependencyInjection.Specification
 {
     public class LamarDependencyInjectionSpecificationTests : SkippableDependencyInjectionSpecificationTests
     {
+        public override bool SupportsIServiceProviderIsService => false;
+
         public override string[] SkippedTests => new[]
         {
             "DisposesInReverseOrderOfCreation",
diff --git a/src/libraries/Microsoft.Extensions.DependencyInjection/tests/DI.External.Tests/LightInject.cs b/src/libraries/Microsoft.Extensions.DependencyInjection/tests/DI.External.Tests/LightInject.cs
index d586884b3bb3d3..d9c874958e63b7 100644
--- a/src/libraries/Microsoft.Extensions.DependencyInjection/tests/DI.External.Tests/LightInject.cs
+++ b/src/libraries/Microsoft.Extensions.DependencyInjection/tests/DI.External.Tests/LightInject.cs
@@ -10,6 +10,8 @@ namespace Microsoft.Extensions.DependencyInjection.Specification
 {
     public class LightInjectDependencyInjectionSpecificationTests: DependencyInjectionSpecificationTests
     {
+        public override bool SupportsIServiceProviderIsService => false;
+
         protected override IServiceProvider CreateServiceProvider(IServiceCollection serviceCollection)
         {
             var builder = new ContainerBuilder();
diff --git a/src/libraries/Microsoft.Extensions.DependencyInjection/tests/DI.External.Tests/StashBox.cs b/src/libraries/Microsoft.Extensions.DependencyInjection/tests/DI.External.Tests/StashBox.cs
index 3deffe4767d7e6..6d315d7361f7d9 100644
--- a/src/libraries/Microsoft.Extensions.DependencyInjection/tests/DI.External.Tests/StashBox.cs
+++ b/src/libraries/Microsoft.Extensions.DependencyInjection/tests/DI.External.Tests/StashBox.cs
@@ -7,6 +7,8 @@ namespace Microsoft.Extensions.DependencyInjection.Specification
 {
     public class StashBoxDependencyInjectionSpecificationTests : DependencyInjectionSpecificationTests
     {
+        public override bool SupportsIServiceProviderIsService => false;
+
         protected override IServiceProvider CreateServiceProvider(IServiceCollection serviceCollection)
         {
             return serviceCollection.UseStashbox();
diff --git a/src/libraries/Microsoft.Extensions.DependencyInjection/tests/DI.External.Tests/StructureMap.cs b/src/libraries/Microsoft.Extensions.DependencyInjection/tests/DI.External.Tests/StructureMap.cs
index 74e13fd0a818a2..f73bf039220e8f 100644
--- a/src/libraries/Microsoft.Extensions.DependencyInjection/tests/DI.External.Tests/StructureMap.cs
+++ b/src/libraries/Microsoft.Extensions.DependencyInjection/tests/DI.External.Tests/StructureMap.cs
@@ -8,6 +8,8 @@ namespace Microsoft.Extensions.DependencyInjection.Specification
 {
     public class StructureMapDependencyInjectionSpecificationTests: SkippableDependencyInjectionSpecificationTests
     {
+        public override bool SupportsIServiceProviderIsService => false;
+
         public override string[] SkippedTests => new[]
         {
             "DisposesInReverseOrderOfCreation",
diff --git a/src/libraries/Microsoft.Extensions.DependencyInjection/tests/DI.External.Tests/Unity.cs b/src/libraries/Microsoft.Extensions.DependencyInjection/tests/DI.External.Tests/Unity.cs
index affa7de4551afd..1987206fae02ba 100644
--- a/src/libraries/Microsoft.Extensions.DependencyInjection/tests/DI.External.Tests/Unity.cs
+++ b/src/libraries/Microsoft.Extensions.DependencyInjection/tests/DI.External.Tests/Unity.cs
@@ -7,6 +7,8 @@ namespace Microsoft.Extensions.DependencyInjection.Specification
 {
     public class UnityDependencyInjectionSpecificationTests: SkippableDependencyInjectionSpecificationTests
     {
+        public override bool SupportsIServiceProviderIsService => false;
+
         // See https://github.com/unitycontainer/microsoft-dependency-injection/issues/87
         public override bool ExpectStructWithPublicDefaultConstructorInvoked => true;
 
diff --git a/src/libraries/Microsoft.Extensions.DependencyInjection/tests/DI.Tests/CallSiteTests.cs b/src/libraries/Microsoft.Extensions.DependencyInjection/tests/DI.Tests/CallSiteTests.cs
index c79594a92eb8e3..6c121a5c417ebb 100644
--- a/src/libraries/Microsoft.Extensions.DependencyInjection/tests/DI.Tests/CallSiteTests.cs
+++ b/src/libraries/Microsoft.Extensions.DependencyInjection/tests/DI.Tests/CallSiteTests.cs
@@ -135,16 +135,13 @@ public void BuildExpressionAddsDisposableCaptureForDisposableServices(ServiceLif
 
             var disposables = new List<object>();
             var provider = new ServiceProvider(descriptors, ServiceProviderOptions.Default);
-            provider.Root._captureDisposableCallback = obj =>
-            {
-                disposables.Add(obj);
-            };
+            
             var callSite = provider.CallSiteFactory.GetCallSite(typeof(ServiceC), new CallSiteChain());
             var compiledCallSite = CompileCallSite(callSite, provider);
 
             var serviceC = (DisposableServiceC)compiledCallSite(provider.Root);
 
-            Assert.Equal(3, disposables.Count);
+            Assert.Equal(3, provider.Root.Disposables.Count);
         }
 
         [Theory]
@@ -161,16 +158,13 @@ public void BuildExpressionAddsDisposableCaptureForDisposableFactoryServices(Ser
 
             var disposables = new List<object>();
             var provider = new ServiceProvider(descriptors, ServiceProviderOptions.Default);
-            provider.Root._captureDisposableCallback = obj =>
-            {
-                disposables.Add(obj);
-            };
+
             var callSite = provider.CallSiteFactory.GetCallSite(typeof(ServiceC), new CallSiteChain());
             var compiledCallSite = CompileCallSite(callSite, provider);
 
             var serviceC = (DisposableServiceC)compiledCallSite(provider.Root);
 
-            Assert.Equal(3, disposables.Count);
+            Assert.Equal(3, provider.Root.Disposables.Count);
         }
 
         [Theory]
@@ -190,16 +184,13 @@ public void BuildExpressionElidesDisposableCaptureForNonDisposableServices(Servi
 
             var disposables = new List<object>();
             var provider = new ServiceProvider(descriptors, ServiceProviderOptions.Default);
-            provider.Root._captureDisposableCallback = obj =>
-            {
-                disposables.Add(obj);
-            };
+            
             var callSite = provider.CallSiteFactory.GetCallSite(typeof(ServiceC), new CallSiteChain());
             var compiledCallSite = CompileCallSite(callSite, provider);
 
             var serviceC = (ServiceC)compiledCallSite(provider.Root);
 
-            Assert.Empty(disposables);
+            Assert.Empty(provider.Root.Disposables);
         }
 
         [Theory]
@@ -215,16 +206,13 @@ public void BuildExpressionElidesDisposableCaptureForEnumerableServices(ServiceL
 
             var disposables = new List<object>();
             var provider = new ServiceProvider(descriptors, ServiceProviderOptions.Default);
-            provider.Root._captureDisposableCallback = obj =>
-            {
-                disposables.Add(obj);
-            };
+
             var callSite = provider.CallSiteFactory.GetCallSite(typeof(ServiceD), new CallSiteChain());
             var compiledCallSite = CompileCallSite(callSite, provider);
 
             var serviceD = (ServiceD)compiledCallSite(provider.Root);
 
-            Assert.Empty(disposables);
+            Assert.Empty(provider.Root.Disposables);
         }
 
         [Fact]
diff --git a/src/libraries/Microsoft.Extensions.DependencyInjection/tests/DI.Tests/ServiceLookup/CallSiteFactoryTest.cs b/src/libraries/Microsoft.Extensions.DependencyInjection/tests/DI.Tests/ServiceLookup/CallSiteFactoryTest.cs
index e027508f784f80..8d6a78029fefff 100644
--- a/src/libraries/Microsoft.Extensions.DependencyInjection/tests/DI.Tests/ServiceLookup/CallSiteFactoryTest.cs
+++ b/src/libraries/Microsoft.Extensions.DependencyInjection/tests/DI.Tests/ServiceLookup/CallSiteFactoryTest.cs
@@ -556,6 +556,41 @@ public void CreateCallSite_ThrowsIfTypeHasSingleConstructorWithUnresolvableParam
                 ex.Message);
         }
 
+        [Theory]
+        [InlineData(1)]
+        [InlineData(2)]
+        [InlineData(3)]
+        [InlineData(4)]
+        [InlineData(5)]
+        public void GetSlotTests(int numberOfServices)
+        {
+            var serviceDescriptors = new[] {
+                ServiceDescriptor.Singleton<ICustomService, CustomService1>(),
+                ServiceDescriptor.Singleton<ICustomService, CustomService2>(),
+                ServiceDescriptor.Singleton<ICustomService, CustomService3>(),
+                ServiceDescriptor.Singleton<ICustomService, CustomService4>(),
+                ServiceDescriptor.Singleton<ICustomService, CustomService5>()
+            };
+
+            var callsiteFactory = new CallSiteFactory(serviceDescriptors.Take(numberOfServices));
+
+            for (int i = 0; i < numberOfServices; i++)
+            {
+                Assert.Equal(numberOfServices - i - 1, callsiteFactory.GetSlot(serviceDescriptors[i]));
+            }
+        }
+
+        interface ICustomService
+        {
+
+        }
+
+        class CustomService1 : ICustomService { }
+        class CustomService2 : ICustomService { }
+        class CustomService3 : ICustomService { }
+        class CustomService4 : ICustomService { }
+        class CustomService5 : ICustomService { }
+
         [Theory]
         [InlineData(typeof(TypeWithMultipleParameterizedConstructors))]
         [InlineData(typeof(TypeWithSupersetConstructors))]
diff --git a/src/libraries/Microsoft.Extensions.DependencyInjection/tests/DI.Tests/ServiceProviderContainerTests.cs b/src/libraries/Microsoft.Extensions.DependencyInjection/tests/DI.Tests/ServiceProviderContainerTests.cs
index b0c09d3bd724b2..6da83cf2d3ea79 100644
--- a/src/libraries/Microsoft.Extensions.DependencyInjection/tests/DI.Tests/ServiceProviderContainerTests.cs
+++ b/src/libraries/Microsoft.Extensions.DependencyInjection/tests/DI.Tests/ServiceProviderContainerTests.cs
@@ -7,6 +7,7 @@
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.Extensions.DependencyInjection.Extensions;
 using Microsoft.Extensions.DependencyInjection.Fakes;
 using Microsoft.Extensions.DependencyInjection.Specification;
 using Microsoft.Extensions.DependencyInjection.Specification.Fakes;
@@ -80,6 +81,70 @@ public void AttemptingToIEnumerableResolveNonexistentServiceIndirectlyThrows()
                 $"'{typeof(DependOnNonexistentService)}'.", ex.Message);
         }
 
+        [Theory]
+        [InlineData(1)]
+        [InlineData(2)]
+        [InlineData(3)]
+        [InlineData(4)]
+        [InlineData(5)]
+        [InlineData(6)]
+        public void MultipleServicesAreOrdered(int numberOfServices)
+        {
+            // Arrange
+            var collection = new ServiceCollection();
+
+            var serviceDescriptors = new[] {
+                ServiceDescriptor.Singleton<ICustomService, CustomService1>(),
+                ServiceDescriptor.Singleton<ICustomService, CustomService2>(),
+                ServiceDescriptor.Singleton<ICustomService, CustomService3>(),
+                ServiceDescriptor.Singleton<ICustomService, CustomService4>(),
+                ServiceDescriptor.Singleton<ICustomService, CustomService5>(),
+                ServiceDescriptor.Singleton<ICustomService, CustomService6>()
+            };
+
+            var serviceTypes = new[]
+            {
+                typeof(CustomService1),
+                typeof(CustomService2),
+                typeof(CustomService3),
+                typeof(CustomService4),
+                typeof(CustomService5),
+                typeof(CustomService6),
+            };
+
+            foreach (var sd in serviceDescriptors.Take(numberOfServices))
+            {
+                collection.Add(sd);
+            }
+
+            var provider = collection.BuildServiceProvider(new ServiceProviderOptions
+            {
+                ValidateOnBuild = true
+            });
+
+            // Act and Assert
+            var customServices = provider.GetService<IEnumerable<ICustomService>>().ToArray();
+
+            Assert.Equal(numberOfServices, customServices.Length);
+
+            for (int i = 0; i < numberOfServices; i++)
+            {
+                Assert.IsAssignableFrom(serviceTypes[i], customServices[i]);
+            }
+        }
+
+        interface ICustomService
+        {
+
+        }
+
+        class CustomService1 : ICustomService { }
+        class CustomService2 : ICustomService { }
+        class CustomService3 : ICustomService { }
+        class CustomService4 : ICustomService { }
+        class CustomService5 : ICustomService { }
+        class CustomService6 : ICustomService { }
+
         [Theory]
         // GenericTypeDefintion, Abstract GenericTypeDefintion
         [InlineData(typeof(IFakeOpenGenericService<>), typeof(AbstractFakeOpenGenericService<>))]
@@ -121,11 +186,11 @@ public static IEnumerable<object[]> FailedOpenGenericTypeTestData
         {
             get
             {
-				Type serviceType = typeof(IFakeOpenGenericService<>);
-				// Service type is GenericTypeDefintion, implementation type is ConstructedGenericType
-                yield return new object[] {serviceType, typeof(ClassWithNoConstraints<string>), $"Open generic service type '{serviceType}' requires registering an open generic implementation type."};
-				// Service type is GenericTypeDefintion, implementation type has different generic type definition arity
-                yield return new object[] {serviceType, typeof(FakeOpenGenericServiceWithTwoTypeArguments<,>), $"Arity of open generic service type '{serviceType}' does not equal arity of open generic implementation type '{typeof(FakeOpenGenericServiceWithTwoTypeArguments<,>)}'."};
+                Type serviceType = typeof(IFakeOpenGenericService<>);
+                // Service type is GenericTypeDefintion, implementation type is ConstructedGenericType
+                yield return new object[] { serviceType, typeof(ClassWithNoConstraints<string>), $"Open generic service type '{serviceType}' requires registering an open generic implementation type." };
+                // Service type is GenericTypeDefintion, implementation type has different generic type definition arity
+                yield return new object[] { serviceType, typeof(FakeOpenGenericServiceWithTwoTypeArguments<,>), $"Arity of open generic service type '{serviceType}' does not equal arity of open generic implementation type '{typeof(FakeOpenGenericServiceWithTwoTypeArguments<,>)}'." };
             }
         }
 
@@ -566,8 +631,8 @@ public async Task GetRequiredService_UsesSingletonAndLazyLocks_NoDeadlock()
                         sb.Append("4");
                     }
 
-                // Let Thread 1 over take Thread 2
-                Thing1 value = lazy.Value;
+                    // Let Thread 1 over take Thread 2
+                    Thing1 value = lazy.Value;
                     return value;
                 });
                 services.AddSingleton<Thing2>();
@@ -631,7 +696,7 @@ public async Task GetRequiredService_BiggerObjectGraphWithOpenGenerics_NoDeadloc
                     sb.Append("3");
                     mreForThread2.Set();   // Now that thread 1 holds lazy lock, allow thread 2 to continue
 
-                thing3 = sp.GetRequiredService<Thing3>();
+                    thing3 = sp.GetRequiredService<Thing3>();
                     return new Thing4(thing3);
                 });
 
@@ -1012,7 +1077,7 @@ public void Dispose()
             }
         }
 
-        private class FakeMultipleServiceWithIEnumerableDependency: IFakeMultipleService
+        private class FakeMultipleServiceWithIEnumerableDependency : IFakeMultipleService
         {
             public FakeMultipleServiceWithIEnumerableDependency(IEnumerable<IFakeService> fakeServices)
             {
@@ -1103,6 +1168,54 @@ public void ScopedServiceResolvedFromSingletonAfterCompilation()
             }
         }
 
+        [Theory]
+        [InlineData(ServiceProviderMode.Default)]
+        [InlineData(ServiceProviderMode.Dynamic)]
+        [InlineData(ServiceProviderMode.Runtime)]
+        [InlineData(ServiceProviderMode.Expressions)]
+        [InlineData(ServiceProviderMode.ILEmit)]
+        private void ScopedServiceResolvedFromSingletonAfterCompilation2(ServiceProviderMode mode)
+        {
+            ServiceProvider sp = new ServiceCollection()
+                                .AddScoped<A>()
+                                .AddSingleton<IFakeOpenGenericService<A>, FakeOpenGenericService<A>>()
+                                .BuildServiceProvider(mode);
+
+            var scope = sp.CreateScope();
+            for (int i = 0; i < 50; i++)
+            {
+                scope.ServiceProvider.GetRequiredService<A>();
+                Thread.Sleep(10); // Give the background thread time to compile
+            }
+
+            Assert.Same(sp.GetRequiredService<IFakeOpenGenericService<A>>().Value, sp.GetRequiredService<A>());
+        }
+
+        [Theory]
+        [InlineData(ServiceProviderMode.Default)]
+        [InlineData(ServiceProviderMode.Dynamic)]
+        [InlineData(ServiceProviderMode.Runtime)]
+        [InlineData(ServiceProviderMode.Expressions)]
+        [InlineData(ServiceProviderMode.ILEmit)]
+        private void ScopedServiceResolvedFromSingletonAfterCompilation3(ServiceProviderMode mode)
+        {
+            // Singleton IFakeX<A> -> Scoped A -> Scoped Aa
+            ServiceProvider sp = new ServiceCollection()
+                                .AddScoped<Aa>()
+                                .AddScoped<A>()
+                                .AddSingleton<IFakeOpenGenericService<Aa>, FakeOpenGenericService<Aa>>()
+                                .BuildServiceProvider(mode);
+
+            var scope = sp.CreateScope();
+            for (int i = 0; i < 50; i++)
+            {
+                scope.ServiceProvider.GetRequiredService<A>();
+                Thread.Sleep(10); // Give the background thread time to compile
+            }
+
+            Assert.Same(sp.GetRequiredService<IFakeOpenGenericService<Aa>>().Value.PropertyA, sp.GetRequiredService<A>());
+        }
+
         private async Task<bool> ResolveUniqueServicesConcurrently()
         {
             var types = new Type[]
@@ -1150,5 +1263,13 @@ private class G { }
         private class H { }
         private class I { }
         private class J { }
+        private class Aa
+        {
+            public Aa(A a)
+            {
+                PropertyA = a;
+            }
+            public A PropertyA { get; }
+        }
     }
 }
diff --git a/src/libraries/Microsoft.Extensions.DependencyInjection/tests/DI.Tests/ServiceProviderEngineScopeTests.cs b/src/libraries/Microsoft.Extensions.DependencyInjection/tests/DI.Tests/ServiceProviderEngineScopeTests.cs
index 5c19caa922e761..d43752db21eba7 100644
--- a/src/libraries/Microsoft.Extensions.DependencyInjection/tests/DI.Tests/ServiceProviderEngineScopeTests.cs
+++ b/src/libraries/Microsoft.Extensions.DependencyInjection/tests/DI.Tests/ServiceProviderEngineScopeTests.cs
@@ -12,7 +12,7 @@ public class ServiceProviderEngineScopeTests
         public void DoubleDisposeWorks()
         {
             var provider = new ServiceProvider(new ServiceCollection(), ServiceProviderOptions.Default);
-            var serviceProviderEngineScope = new ServiceProviderEngineScope(provider);
+            var serviceProviderEngineScope = new ServiceProviderEngineScope(provider, isRootScope: true);
             serviceProviderEngineScope.ResolvedServices.Add(new ServiceCacheKey(typeof(IFakeService), 0), null);
             serviceProviderEngineScope.Dispose();
             serviceProviderEngineScope.Dispose();
diff --git a/src/libraries/Microsoft.Extensions.HostFactoryResolver/src/HostFactoryResolver.cs b/src/libraries/Microsoft.Extensions.HostFactoryResolver/src/HostFactoryResolver.cs
index 9b3a30734eb2ab..12516f600b604e 100644
--- a/src/libraries/Microsoft.Extensions.HostFactoryResolver/src/HostFactoryResolver.cs
+++ b/src/libraries/Microsoft.Extensions.HostFactoryResolver/src/HostFactoryResolver.cs
@@ -2,7 +2,11 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Collections.Generic;
+using System.Diagnostics;
 using System.Reflection;
+using System.Threading;
+using System.Threading.Tasks;
 
 #nullable enable
 
@@ -16,6 +20,9 @@ internal sealed class HostFactoryResolver
         public const string CreateWebHostBuilder = nameof(CreateWebHostBuilder);
         public const string CreateHostBuilder = nameof(CreateHostBuilder);
 
+        // The amount of time we wait for the diagnostic source events to fire
+        private static readonly TimeSpan s_defaultWaitTimeout = TimeSpan.FromSeconds(5);
+
         public static Func<string[], TWebHost>? ResolveWebHostFactory<TWebHost>(Assembly assembly)
         {
             return ResolveFactory<TWebHost>(assembly, BuildWebHost);
@@ -31,6 +38,45 @@ internal sealed class HostFactoryResolver
             return ResolveFactory<THostBuilder>(assembly, CreateHostBuilder);
         }
 
+        // This helpers encapsulates all of the complex logic required to:
+        // 1. Execute the entry point of the specified assembly in a different thread.
+        // 2. Wait for the diagnostic source events to fire
+        // 3. Give the caller a chance to execute logic to mutate the IHostBuilder
+        // 4. Resolve the instance of the applications's IHost
+        // 5. Allow the caller to determine if the entry point has completed
+        public static Func<string[], object>? ResolveHostFactory(Assembly assembly, 
+                                                                 TimeSpan? waitTimeout = null, 
+                                                                 bool stopApplication = true, 
+                                                                 Action<object>? configureHostBuilder = null, 
+                                                                 Action<Exception?>? entrypointCompleted = null)
+        {
+            if (assembly.EntryPoint is null)
+            {
+                return null;
+            }
+
+            try
+            {
+                // Attempt to load hosting and check the version to make sure the events
+                // even have a chance of firing (they were added in .NET >= 6)
+                var hostingAssembly = Assembly.Load("Microsoft.Extensions.Hosting");
+                if (hostingAssembly.GetName().Version is Version version && version.Major < 6)
+                {
+                    return null;
+                }
+                
+                // We're using a version >= 6 so the events can fire. If they don't fire
+                // then it's because the application isn't using the hosting APIs
+            }
+            catch
+            {
+                // There was an error loading the extensions assembly, return null.
+                return null;
+            }
+
+            return args => new HostingListener(args, assembly.EntryPoint, waitTimeout ?? s_defaultWaitTimeout, stopApplication, configureHostBuilder, entrypointCompleted).CreateHost();
+        }
+
         private static Func<string[], T>? ResolveFactory<T>(Assembly assembly, string name)
         {
             var programType = assembly?.EntryPoint?.DeclaringType;
@@ -58,7 +104,7 @@ private static bool IsFactory<TReturn>(MethodInfo? factory)
         }
 
         // Used by EF tooling without any Hosting references. Looses some return type safety checks.
-        public static Func<string[], IServiceProvider?>? ResolveServiceProviderFactory(Assembly assembly)
+        public static Func<string[], IServiceProvider?>? ResolveServiceProviderFactory(Assembly assembly, TimeSpan? waitTimeout = null)
         {
             // Prefer the older patterns by default for back compat.
             var webHostFactory = ResolveWebHostFactory<object>(assembly);
@@ -93,6 +139,16 @@ private static bool IsFactory<TReturn>(MethodInfo? factory)
                 };
             }
 
+            var hostFactory = ResolveHostFactory(assembly, waitTimeout: waitTimeout);
+            if (hostFactory != null)
+            {
+                return args =>
+                {
+                    var host = hostFactory(args);
+                    return GetServiceProvider(host);
+                };
+            }
+
             return null;
         }
 
@@ -112,5 +168,163 @@ private static bool IsFactory<TReturn>(MethodInfo? factory)
             var servicesProperty = hostType.GetProperty("Services", DeclaredOnlyLookup);
             return (IServiceProvider?)servicesProperty?.GetValue(host);
         }
+
+        private sealed class HostingListener : IObserver<DiagnosticListener>, IObserver<KeyValuePair<string, object?>>
+        {
+            private readonly string[] _args;
+            private readonly MethodInfo _entryPoint;
+            private readonly TimeSpan _waitTimeout;
+            private readonly bool _stopApplication;
+
+            private readonly TaskCompletionSource<object> _hostTcs = new();
+            private IDisposable? _disposable;
+            private Action<object>? _configure;
+            private Action<Exception?>? _entrypointCompleted;
+            private static readonly AsyncLocal<HostingListener> _currentListener = new();
+
+            public HostingListener(string[] args, MethodInfo entryPoint, TimeSpan waitTimeout, bool stopApplication, Action<object>? configure, Action<Exception?>? entrypointCompleted)
+            {
+                _args = args;
+                _entryPoint = entryPoint;
+                _waitTimeout = waitTimeout;
+                _stopApplication = stopApplication;
+                _configure = configure;
+                _entrypointCompleted = entrypointCompleted;
+            }
+
+            public object CreateHost()
+            {
+                using var subscription = DiagnosticListener.AllListeners.Subscribe(this);
+
+                // Kick off the entry point on a new thread so we don't block the current one
+                // in case we need to timeout the execution
+                var thread = new Thread(() =>
+                {
+                    Exception? exception = null;
+
+                    try
+                    {
+                        // Set the async local to the instance of the HostingListener so we can filter events that
+                        // aren't scoped to this execution of the entry point.
+                        _currentListener.Value = this;
+
+                        var parameters = _entryPoint.GetParameters();
+                        if (parameters.Length == 0)
+                        {
+                            _entryPoint.Invoke(null, Array.Empty<object>());
+                        }
+                        else
+                        {
+                            _entryPoint.Invoke(null, new object[] { _args });
+                        }
+
+                        // Try to set an exception if the entry point returns gracefully, this will force
+                        // build to throw
+                        _hostTcs.TrySetException(new InvalidOperationException("Unable to build IHost"));
+                    }
+                    catch (TargetInvocationException tie) when (tie.InnerException is StopTheHostException)
+                    {
+                        // The host was stopped by our own logic
+                    }
+                    catch (TargetInvocationException tie)
+                    {
+                        exception = tie.InnerException ?? tie;
+
+                        // Another exception happened, propagate that to the caller
+                        _hostTcs.TrySetException(exception);
+                    }
+                    catch (Exception ex)
+                    {
+                        exception = ex;
+
+                        // Another exception happened, propagate that to the caller
+                        _hostTcs.TrySetException(ex);
+                    }
+                    finally
+                    {
+                        // Signal that the entry point is completed
+                        _entrypointCompleted?.Invoke(exception);
+                    }
+                })
+                {
+                    // Make sure this doesn't hang the process
+                    IsBackground = true
+                };
+
+                // Start the thread
+                thread.Start();
+
+                try
+                {
+                    // Wait before throwing an exception
+                    if (!_hostTcs.Task.Wait(_waitTimeout))
+                    {
+                        throw new InvalidOperationException("Unable to build IHost");
+                    }
+                }
+                catch (AggregateException) when (_hostTcs.Task.IsCompleted)
+                {
+                    // Lets this propagate out of the call to GetAwaiter().GetResult()
+                }
+
+                Debug.Assert(_hostTcs.Task.IsCompleted);
+
+                return _hostTcs.Task.GetAwaiter().GetResult();
+            }
+
+            public void OnCompleted()
+            {
+                _disposable?.Dispose();
+            }
+
+            public void OnError(Exception error)
+            {
+
+            }
+
+            public void OnNext(DiagnosticListener value)
+            {
+                if (_currentListener.Value != this)
+                {
+                    // Ignore events that aren't for this listener
+                    return;
+                }
+
+                if (value.Name == "Microsoft.Extensions.Hosting")
+                {
+                    _disposable = value.Subscribe(this);
+                }
+            }
+
+            public void OnNext(KeyValuePair<string, object?> value)
+            {
+                if (_currentListener.Value != this)
+                {
+                    // Ignore events that aren't for this listener
+                    return;
+                }
+
+                if (value.Key == "HostBuilding")
+                {
+                    _configure?.Invoke(value.Value!);
+                }
+
+                if (value.Key == "HostBuilt")
+                {
+                    _hostTcs.TrySetResult(value.Value!);
+
+                    if (_stopApplication)
+                    {
+                        // Stop the host from running further
+                        throw new StopTheHostException();
+                    }
+                }
+            }
+
+            private sealed class StopTheHostException : Exception
+            {
+
+            }
+        }
     }
 }
diff --git a/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/CreateHostBuilderInvalidSignature/Program.cs b/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/CreateHostBuilderInvalidSignature/Program.cs
index b1b233eb95d519..f82816eed4537b 100644
--- a/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/CreateHostBuilderInvalidSignature/Program.cs
+++ b/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/CreateHostBuilderInvalidSignature/Program.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using MockHostTypes;
+using Microsoft.Extensions.Hosting;
 
 namespace CreateHostBuilderInvalidSignature
 {
@@ -9,7 +10,7 @@ public class Program
     {
         public static void Main(string[] args)
         {
-            var webHost = CreateHostBuilder(null, args).Build();
+            var webHost = CreateHostBuilder(null, args)?.Build();
         }
 
         // Extra parameter
diff --git a/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/CreateHostBuilderPatternTestSite/Program.cs b/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/CreateHostBuilderPatternTestSite/Program.cs
index 515615731fa09c..55e872f8f34127 100644
--- a/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/CreateHostBuilderPatternTestSite/Program.cs
+++ b/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/CreateHostBuilderPatternTestSite/Program.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using MockHostTypes;
+using Microsoft.Extensions.Hosting;
 
 namespace CreateHostBuilderPatternTestSite
 {
diff --git a/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/HostFactoryResolverTests.cs b/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/HostFactoryResolverTests.cs
index 55d53fa668e355..8f6cf79de0bf3e 100644
--- a/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/HostFactoryResolverTests.cs
+++ b/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/HostFactoryResolverTests.cs
@@ -4,12 +4,17 @@
 using MockHostTypes;
 using System;
 using System.Diagnostics.CodeAnalysis;
+using System.Reflection;
+using System.Threading;
+using System.Threading.Tasks;
 using Xunit;
 
 namespace Microsoft.Extensions.Hosting.Tests
 {
     public class HostFactoryResolverTests
     {
+        private static readonly TimeSpan s_WaitTimeout = TimeSpan.FromSeconds(20);
+
         [Fact]
         [DynamicDependency(DynamicallyAccessedMemberTypes.All, typeof(BuildWebHostPatternTestSite.Program))]
         public void BuildWebHostPattern_CanFindWebHost()
@@ -46,7 +51,7 @@ public void BuildWebHostPattern__Invalid_CantFindServiceProvider()
         {
             var factory = HostFactoryResolver.ResolveServiceProviderFactory(typeof(BuildWebHostInvalidSignature.Program).Assembly);
 
-            Assert.Null(factory);
+            Assert.NotNull(factory);
         }
 
         [Fact]
@@ -119,13 +124,154 @@ public void CreateHostBuilderPattern__Invalid_CantFindHostBuilder()
             Assert.Null(factory);
         }
 
-        [Fact]
+        [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsThreadingSupported))]
         [DynamicDependency(DynamicallyAccessedMemberTypes.All, typeof(CreateHostBuilderInvalidSignature.Program))]
         public void CreateHostBuilderPattern__Invalid_CantFindServiceProvider()
         {
-            var factory = HostFactoryResolver.ResolveServiceProviderFactory(typeof(CreateHostBuilderInvalidSignature.Program).Assembly);
+            var factory = HostFactoryResolver.ResolveServiceProviderFactory(typeof(CreateHostBuilderInvalidSignature.Program).Assembly, s_WaitTimeout);
 
-            Assert.Null(factory);
+            Assert.NotNull(factory);
+            Assert.Throws<InvalidOperationException>(() => factory(Array.Empty<string>()));
+        }
+
+        [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsThreadingSupported))]
+        [DynamicDependency(DynamicallyAccessedMemberTypes.All, typeof(NoSpecialEntryPointPattern.Program))]
+        public void NoSpecialEntryPointPattern()
+        {
+            var factory = HostFactoryResolver.ResolveServiceProviderFactory(typeof(NoSpecialEntryPointPattern.Program).Assembly, s_WaitTimeout);
+
+            Assert.NotNull(factory);
+            Assert.IsAssignableFrom<IServiceProvider>(factory(Array.Empty<string>()));
+        }
+
+        [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsThreadingSupported))]
+        [DynamicDependency(DynamicallyAccessedMemberTypes.All, typeof(NoSpecialEntryPointPattern.Program))]
+        public void NoSpecialEntryPointPatternHostBuilderConfigureHostBuilderCallbackIsCalled()
+        {
+            bool called = false;
+            void ConfigureHostBuilder(object hostBuilder)
+            {
+                Assert.IsAssignableFrom<IHostBuilder>(hostBuilder);
+                called = true;
+            }
+
+            var factory = HostFactoryResolver.ResolveHostFactory(typeof(NoSpecialEntryPointPattern.Program).Assembly, waitTimeout: s_WaitTimeout, configureHostBuilder: ConfigureHostBuilder);
+
+            Assert.NotNull(factory);
+            Assert.IsAssignableFrom<IHost>(factory(Array.Empty<string>()));
+            Assert.True(called);
+        }
+
+        [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsThreadingSupported))]
+        [DynamicDependency(DynamicallyAccessedMemberTypes.All, typeof(NoSpecialEntryPointPattern.Program))]
+        public void NoSpecialEntryPointPatternBuildsThenThrowsCallsEntryPointCompletedCallback()
+        {
+            var wait = new ManualResetEventSlim(false);
+            Exception? entryPointException = null;
+            void EntryPointCompleted(Exception? exception)
+            {
+                entryPointException = exception;
+                wait.Set();
+            }
+
+            var factory = HostFactoryResolver.ResolveHostFactory(typeof(NoSpecialEntryPointPattern.Program).Assembly, waitTimeout: s_WaitTimeout, stopApplication: false, entrypointCompleted: EntryPointCompleted);
+
+            Assert.NotNull(factory);
+            Assert.IsAssignableFrom<IHost>(factory(Array.Empty<string>()));
+            Assert.True(wait.Wait(s_WaitTimeout));
+            Assert.Null(entryPointException);
+        }
+
+        [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsThreadingSupported))]
+        [DynamicDependency(DynamicallyAccessedMemberTypes.All, typeof(NoSpecialEntryPointPatternBuildsThenThrows.Program))]
+        public void NoSpecialEntryPointPatternBuildsThenThrowsCallsEntryPointCompletedCallbackWithException()
+        {
+            var wait = new ManualResetEventSlim(false);
+            Exception? entryPointException = null;
+            void EntryPointCompleted(Exception? exception)
+            {
+                entryPointException = exception;
+                wait.Set();
+            }
+
+            var factory = HostFactoryResolver.ResolveHostFactory(typeof(NoSpecialEntryPointPatternBuildsThenThrows.Program).Assembly, waitTimeout: s_WaitTimeout, stopApplication: false, entrypointCompleted: EntryPointCompleted);
+
+            Assert.NotNull(factory);
+            Assert.IsAssignableFrom<IHost>(factory(Array.Empty<string>()));
+            Assert.True(wait.Wait(s_WaitTimeout));
+            Assert.NotNull(entryPointException);
+        }
+
+        [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsThreadingSupported))]
+        [DynamicDependency(DynamicallyAccessedMemberTypes.All, typeof(NoSpecialEntryPointPatternThrows.Program))]
+        public void NoSpecialEntryPointPatternThrows()
+        {
+            var factory = HostFactoryResolver.ResolveServiceProviderFactory(typeof(NoSpecialEntryPointPatternThrows.Program).Assembly, s_WaitTimeout);
+
+            Assert.NotNull(factory);
+            Assert.Throws<Exception>(() => factory(Array.Empty<string>()));
+        }
+
+        [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsThreadingSupported))]
+        [DynamicDependency(DynamicallyAccessedMemberTypes.All, typeof(NoSpecialEntryPointPatternExits.Program))]
+        public void NoSpecialEntryPointPatternExits()
+        {
+            var factory = HostFactoryResolver.ResolveServiceProviderFactory(typeof(NoSpecialEntryPointPatternExits.Program).Assembly, s_WaitTimeout);
+
+            Assert.NotNull(factory);
+            Assert.Throws<InvalidOperationException>(() => factory(Array.Empty<string>()));
+        }
+
+        [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsThreadingSupported))]
+        [DynamicDependency(DynamicallyAccessedMemberTypes.All, typeof(NoSpecialEntryPointPatternHangs.Program))]
+        public void NoSpecialEntryPointPatternHangs()
+        {
+            var factory = HostFactoryResolver.ResolveServiceProviderFactory(typeof(NoSpecialEntryPointPatternHangs.Program).Assembly, s_WaitTimeout);
+
+            Assert.NotNull(factory);
+            Assert.Throws<InvalidOperationException>(() => factory(Array.Empty<string>()));
+        }
+
+        [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsThreadingSupported))]
+        [DynamicDependency(DynamicallyAccessedMemberTypes.All, typeof(NoSpecialEntryPointPatternMainNoArgs.Program))]
+        public void NoSpecialEntryPointPatternMainNoArgs()
+        {
+            var factory = HostFactoryResolver.ResolveServiceProviderFactory(typeof(NoSpecialEntryPointPatternMainNoArgs.Program).Assembly, s_WaitTimeout);
+
+            Assert.NotNull(factory);
+            Assert.IsAssignableFrom<IServiceProvider>(factory(Array.Empty<string>()));
+        }
+
+        [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsThreadingSupported))]
+        public void TopLevelStatements()
+        {
+            var assembly = Assembly.Load("TopLevelStatements");
+            var factory = HostFactoryResolver.ResolveServiceProviderFactory(assembly, s_WaitTimeout);
+
+            Assert.NotNull(factory);
+            Assert.IsAssignableFrom<IServiceProvider>(factory(Array.Empty<string>()));
+        }
+
+        [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsThreadingSupported))]
+        [DynamicDependency(DynamicallyAccessedMemberTypes.All, typeof(NoSpecialEntryPointPattern.Program))]
+        public void NoSpecialEntryPointPatternCanRunInParallel()
+        {
+            var factory = HostFactoryResolver.ResolveServiceProviderFactory(typeof(NoSpecialEntryPointPattern.Program).Assembly, s_WaitTimeout);
+            Assert.NotNull(factory);
+
+            var tasks = new Task<IServiceProvider>[30];
+            int index = 0;
+            for (int i = 0; i < tasks.Length; i++)
+            {
+                tasks[index++] = Task.Run(() => factory(Array.Empty<string>()));
+            }
+
+            Task.WaitAll(tasks);
+
+            foreach (var t in tasks)
+            {
+                Assert.IsAssignableFrom<IServiceProvider>(t.Result);
+            }
         }
     }
 }
diff --git a/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/Microsoft.Extensions.HostFactoryResolver.Tests.csproj b/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/Microsoft.Extensions.HostFactoryResolver.Tests.csproj
index 8f5acc14b7f9e7..dc808c40b7cc99 100644
--- a/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/Microsoft.Extensions.HostFactoryResolver.Tests.csproj
+++ b/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/Microsoft.Extensions.HostFactoryResolver.Tests.csproj
@@ -20,5 +20,16 @@
     <ProjectReference Include="CreateHostBuilderPatternTestSite\CreateHostBuilderPatternTestSite.csproj" />
     <ProjectReference Include="CreateWebHostBuilderInvalidSignature\CreateWebHostBuilderInvalidSignature.csproj" />
     <ProjectReference Include="CreateWebHostBuilderPatternTestSite\CreateWebHostBuilderPatternTestSite.csproj" />
+    <ProjectReference Include="NoSpecialEntryPointPattern\NoSpecialEntryPointPattern.csproj" />
+    <ProjectReference Include="NoSpecialEntryPointPatternBuildsThenThrows\NoSpecialEntryPointPatternBuildsThenThrows.csproj" />
+    <ProjectReference Include="NoSpecialEntryPointPatternThrows\NoSpecialEntryPointPatternThrows.csproj" />
+    <ProjectReference Include="NoSpecialEntryPointPatternExits\NoSpecialEntryPointPatternExits.csproj" />
+    <ProjectReference Include="NoSpecialEntryPointPatternHangs\NoSpecialEntryPointPatternHangs.csproj" />
+    <ProjectReference Include="NoSpecialEntryPointPatternMainNoArgs\NoSpecialEntryPointPatternMainNoArgs.csproj" />
+    <ProjectReference Include="TopLevelStatements\TopLevelStatements.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="$(LibrariesProjectRoot)Microsoft.Extensions.Hosting.Abstractions\src\Microsoft.Extensions.Hosting.Abstractions.csproj" />
   </ItemGroup>
 </Project>
diff --git a/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/MockHostTypes/MockHostTypes.csproj b/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/MockHostTypes/MockHostTypes.csproj
index 88e03293e6ce4c..ed642b4209adba 100644
--- a/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/MockHostTypes/MockHostTypes.csproj
+++ b/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/MockHostTypes/MockHostTypes.csproj
@@ -5,4 +5,8 @@
     <EnableDefaultItems>true</EnableDefaultItems>
   </PropertyGroup>
 
+  <ItemGroup>
+    <ProjectReference Include="$(LibrariesProjectRoot)Microsoft.Extensions.Hosting\src\Microsoft.Extensions.Hosting.csproj" />
+  </ItemGroup>
+
 </Project>
diff --git a/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/NoSpecialEntryPointPattern/NoSpecialEntryPointPattern.csproj b/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/NoSpecialEntryPointPattern/NoSpecialEntryPointPattern.csproj
new file mode 100644
index 00000000000000..716b25a87281da
--- /dev/null
+++ b/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/NoSpecialEntryPointPattern/NoSpecialEntryPointPattern.csproj
@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFrameworks>$(NetCoreAppCurrent);net461</TargetFrameworks>
+    <EnableDefaultItems>true</EnableDefaultItems>
+    <OutputType>Exe</OutputType>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\MockHostTypes\MockHostTypes.csproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/NoSpecialEntryPointPattern/Program.cs b/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/NoSpecialEntryPointPattern/Program.cs
new file mode 100644
index 00000000000000..4dafef644a8c2e
--- /dev/null
+++ b/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/NoSpecialEntryPointPattern/Program.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 Microsoft.Extensions.Hosting;
+
+namespace NoSpecialEntryPointPattern
+{
+    public class Program
+    {
+        public static void Main(string[] args)
+        {
+            var host = new HostBuilder().Build();
+        }
+    }
+}
diff --git a/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/NoSpecialEntryPointPatternBuildsThenThrows/NoSpecialEntryPointPatternBuildsThenThrows.csproj b/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/NoSpecialEntryPointPatternBuildsThenThrows/NoSpecialEntryPointPatternBuildsThenThrows.csproj
new file mode 100644
index 00000000000000..716b25a87281da
--- /dev/null
+++ b/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/NoSpecialEntryPointPatternBuildsThenThrows/NoSpecialEntryPointPatternBuildsThenThrows.csproj
@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFrameworks>$(NetCoreAppCurrent);net461</TargetFrameworks>
+    <EnableDefaultItems>true</EnableDefaultItems>
+    <OutputType>Exe</OutputType>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\MockHostTypes\MockHostTypes.csproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/NoSpecialEntryPointPatternBuildsThenThrows/Program.cs b/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/NoSpecialEntryPointPatternBuildsThenThrows/Program.cs
new file mode 100644
index 00000000000000..9e889d85b2f731
--- /dev/null
+++ b/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/NoSpecialEntryPointPatternBuildsThenThrows/Program.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.
+
+using System;
+using Microsoft.Extensions.Hosting;
+
+namespace NoSpecialEntryPointPatternBuildsThenThrows
+{
+    public class Program
+    {
+        public static void Main(string[] args)
+        {
+            var host = new HostBuilder().Build();
+
+            throw new Exception("Main just throws");
+        }
+    }
+}
diff --git a/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/NoSpecialEntryPointPatternExits/NoSpecialEntryPointPatternExits.csproj b/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/NoSpecialEntryPointPatternExits/NoSpecialEntryPointPatternExits.csproj
new file mode 100644
index 00000000000000..716b25a87281da
--- /dev/null
+++ b/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/NoSpecialEntryPointPatternExits/NoSpecialEntryPointPatternExits.csproj
@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFrameworks>$(NetCoreAppCurrent);net461</TargetFrameworks>
+    <EnableDefaultItems>true</EnableDefaultItems>
+    <OutputType>Exe</OutputType>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\MockHostTypes\MockHostTypes.csproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/NoSpecialEntryPointPatternExits/Program.cs b/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/NoSpecialEntryPointPatternExits/Program.cs
new file mode 100644
index 00000000000000..9176dae239533f
--- /dev/null
+++ b/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/NoSpecialEntryPointPatternExits/Program.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 NoSpecialEntryPointPatternExits
+{
+    public class Program
+    {
+        public static void Main(string[] args)
+        {
+            
+        }
+    }
+}
diff --git a/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/NoSpecialEntryPointPatternHangs/NoSpecialEntryPointPatternHangs.csproj b/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/NoSpecialEntryPointPatternHangs/NoSpecialEntryPointPatternHangs.csproj
new file mode 100644
index 00000000000000..716b25a87281da
--- /dev/null
+++ b/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/NoSpecialEntryPointPatternHangs/NoSpecialEntryPointPatternHangs.csproj
@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFrameworks>$(NetCoreAppCurrent);net461</TargetFrameworks>
+    <EnableDefaultItems>true</EnableDefaultItems>
+    <OutputType>Exe</OutputType>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\MockHostTypes\MockHostTypes.csproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/NoSpecialEntryPointPatternHangs/Program.cs b/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/NoSpecialEntryPointPatternHangs/Program.cs
new file mode 100644
index 00000000000000..52ac9d43ccabf3
--- /dev/null
+++ b/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/NoSpecialEntryPointPatternHangs/Program.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 NoSpecialEntryPointPatternHangs
+{
+    public class Program
+    {
+        public static void Main(string[] args)
+        {
+            System.Threading.Thread.Sleep(-1);
+        }
+    }
+}
diff --git a/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/NoSpecialEntryPointPatternMainNoArgs/NoSpecialEntryPointPatternMainNoArgs.csproj b/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/NoSpecialEntryPointPatternMainNoArgs/NoSpecialEntryPointPatternMainNoArgs.csproj
new file mode 100644
index 00000000000000..716b25a87281da
--- /dev/null
+++ b/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/NoSpecialEntryPointPatternMainNoArgs/NoSpecialEntryPointPatternMainNoArgs.csproj
@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFrameworks>$(NetCoreAppCurrent);net461</TargetFrameworks>
+    <EnableDefaultItems>true</EnableDefaultItems>
+    <OutputType>Exe</OutputType>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\MockHostTypes\MockHostTypes.csproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/NoSpecialEntryPointPatternMainNoArgs/Program.cs b/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/NoSpecialEntryPointPatternMainNoArgs/Program.cs
new file mode 100644
index 00000000000000..e304864cd82476
--- /dev/null
+++ b/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/NoSpecialEntryPointPatternMainNoArgs/Program.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 System;
+using Microsoft.Extensions.Hosting;
+
+namespace NoSpecialEntryPointPatternMainNoArgs
+{
+    public class Program
+    {
+        public static void Main()
+        {
+            var host = new HostBuilder().Build();
+        }
+    }
+}
diff --git a/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/NoSpecialEntryPointPatternThrows/NoSpecialEntryPointPatternThrows.csproj b/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/NoSpecialEntryPointPatternThrows/NoSpecialEntryPointPatternThrows.csproj
new file mode 100644
index 00000000000000..716b25a87281da
--- /dev/null
+++ b/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/NoSpecialEntryPointPatternThrows/NoSpecialEntryPointPatternThrows.csproj
@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFrameworks>$(NetCoreAppCurrent);net461</TargetFrameworks>
+    <EnableDefaultItems>true</EnableDefaultItems>
+    <OutputType>Exe</OutputType>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\MockHostTypes\MockHostTypes.csproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/NoSpecialEntryPointPatternThrows/Program.cs b/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/NoSpecialEntryPointPatternThrows/Program.cs
new file mode 100644
index 00000000000000..f01cc36661a471
--- /dev/null
+++ b/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/NoSpecialEntryPointPatternThrows/Program.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 NoSpecialEntryPointPatternThrows
+{
+    public class Program
+    {
+        public static void Main(string[] args)
+        {
+            throw new Exception("Main just throws");
+        }
+    }
+}
diff --git a/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/MockHostTypes/IHost.cs b/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/TopLevelStatements/Program.cs
similarity index 58%
rename from src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/MockHostTypes/IHost.cs
rename to src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/TopLevelStatements/Program.cs
index 410e44c2dc283a..92f51e33ef543c 100644
--- a/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/MockHostTypes/IHost.cs
+++ b/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/TopLevelStatements/Program.cs
@@ -2,11 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using Microsoft.Extensions.Hosting;
 
-namespace MockHostTypes
-{
-    public interface IHost
-    {
-        IServiceProvider Services { get; }
-    }
-}
+var host = new HostBuilder().Build();
\ No newline at end of file
diff --git a/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/TopLevelStatements/TopLevelStatements.csproj b/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/TopLevelStatements/TopLevelStatements.csproj
new file mode 100644
index 00000000000000..716b25a87281da
--- /dev/null
+++ b/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/TopLevelStatements/TopLevelStatements.csproj
@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFrameworks>$(NetCoreAppCurrent);net461</TargetFrameworks>
+    <EnableDefaultItems>true</EnableDefaultItems>
+    <OutputType>Exe</OutputType>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\MockHostTypes\MockHostTypes.csproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/src/libraries/Microsoft.Extensions.Hosting.WindowsServices/Directory.Build.props b/src/libraries/Microsoft.Extensions.Hosting.WindowsServices/Directory.Build.props
index 3d31843054e721..899ad9d38a52d6 100644
--- a/src/libraries/Microsoft.Extensions.Hosting.WindowsServices/Directory.Build.props
+++ b/src/libraries/Microsoft.Extensions.Hosting.WindowsServices/Directory.Build.props
@@ -2,5 +2,6 @@
   <Import Project="..\Directory.Build.props" />
   <PropertyGroup>
     <PackageTags>hosting</PackageTags>
+    <SupportedOSPlatforms>windows</SupportedOSPlatforms> 
   </PropertyGroup>
 </Project>
diff --git a/src/libraries/Microsoft.Extensions.Hosting/src/ConsoleLifetimeOptions.cs b/src/libraries/Microsoft.Extensions.Hosting/src/ConsoleLifetimeOptions.cs
index 0475bb8c93b75e..eebb5d7fae165c 100644
--- a/src/libraries/Microsoft.Extensions.Hosting/src/ConsoleLifetimeOptions.cs
+++ b/src/libraries/Microsoft.Extensions.Hosting/src/ConsoleLifetimeOptions.cs
@@ -6,7 +6,7 @@ namespace Microsoft.Extensions.Hosting
     public class ConsoleLifetimeOptions
     {
         /// <summary>
-        /// Indicates if host lifetime status messages should be supressed such as on startup.
+        /// Indicates if host lifetime status messages should be suppressed such as on startup.
         /// The default is false.
         /// </summary>
         public bool SuppressStatusMessages { get; set; }
diff --git a/src/libraries/Microsoft.Extensions.Hosting/src/HostBuilder.cs b/src/libraries/Microsoft.Extensions.Hosting/src/HostBuilder.cs
index 1cc812f6f8f199..7ed38f701f6ae6 100644
--- a/src/libraries/Microsoft.Extensions.Hosting/src/HostBuilder.cs
+++ b/src/libraries/Microsoft.Extensions.Hosting/src/HostBuilder.cs
@@ -3,6 +3,8 @@
 
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using System.Reflection;
 using Microsoft.Extensions.Configuration;
@@ -127,13 +129,40 @@ public IHost Build()
             }
             _hostBuilt = true;
 
+            // REVIEW: If we want to raise more events outside of these calls then we will need to
+            // stash this in a field.
+            using var diagnosticListener = new DiagnosticListener("Microsoft.Extensions.Hosting");
+            const string hostBuildingEventName = "HostBuilding";
+            const string hostBuiltEventName = "HostBuilt";
+
+            if (diagnosticListener.IsEnabled() && diagnosticListener.IsEnabled(hostBuildingEventName))
+            {
+                Write(diagnosticListener, hostBuildingEventName, this);
+            }
+
             BuildHostConfiguration();
             CreateHostingEnvironment();
             CreateHostBuilderContext();
             BuildAppConfiguration();
             CreateServiceProvider();
 
-            return _appServices.GetRequiredService<IHost>();
+            var host = _appServices.GetRequiredService<IHost>();
+            if (diagnosticListener.IsEnabled() && diagnosticListener.IsEnabled(hostBuiltEventName))
+            {
+                Write(diagnosticListener, hostBuiltEventName, host);
+            }
+
+            return host;
+        }
+
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:UnrecognizedReflectionPattern",
+            Justification = "The values being passed into Write are being consumed by the application already.")]
+        private static void Write<T>(
+            DiagnosticSource diagnosticSource,
+            string name,
+            T value)
+        {
+            diagnosticSource.Write(name, value);
         }
 
         private void BuildHostConfiguration()
diff --git a/src/libraries/Microsoft.Extensions.Hosting/tests/UnitTests/HostBuilderTests.cs b/src/libraries/Microsoft.Extensions.Hosting/tests/UnitTests/HostBuilderTests.cs
index a07be287a3b95d..1f35e1c15f4802 100644
--- a/src/libraries/Microsoft.Extensions.Hosting/tests/UnitTests/HostBuilderTests.cs
+++ b/src/libraries/Microsoft.Extensions.Hosting/tests/UnitTests/HostBuilderTests.cs
@@ -3,8 +3,10 @@
 
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.IO;
 using System.Reflection;
+using Microsoft.DotNet.RemoteExecutor;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.FileProviders;
@@ -32,6 +34,37 @@ public void DefaultConfigIsMutable()
             }
         }
 
+        [ConditionalFact(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))]
+        public void BuildFiresEvents()
+        {
+            using var _ = RemoteExecutor.Invoke(() =>
+            {
+                IHostBuilder hostBuilderFromEvent = null;
+                IHost hostFromEvent = null;
+
+                var listener = new HostingListener((pair) =>
+                {
+                    if (pair.Key == "HostBuilding")
+                    {
+                        hostBuilderFromEvent = (IHostBuilder)pair.Value;
+                    }
+
+                    if (pair.Key == "HostBuilt")
+                    {
+                        hostFromEvent = (IHost)pair.Value;
+                    }
+                });
+
+                using var sub = DiagnosticListener.AllListeners.Subscribe(listener);
+
+                var hostBuilder = new HostBuilder();
+                var host = hostBuilder.Build();
+
+                Assert.Same(hostBuilder, hostBuilderFromEvent);
+                Assert.Same(host, hostFromEvent);
+            });
+        }
+
         [Fact]
         public void ConfigureHostConfigurationPropagated()
         {
@@ -657,6 +690,32 @@ public void HostBuilderCanConfigureBackgroundServiceExceptionBehavior(
                 options.Value.BackgroundServiceExceptionBehavior);
         }
 
+        private class HostingListener : IObserver<DiagnosticListener>, IObserver<KeyValuePair<string, object?>>
+        {
+            private IDisposable? _disposable;
+            private readonly Action<KeyValuePair<string, object?>> _callback;
+
+            public HostingListener(Action<KeyValuePair<string, object?>> callback)
+            {
+                _callback = callback;
+            }
+
+            public void OnCompleted() { _disposable?.Dispose(); }
+            public void OnError(Exception error) { }
+            public void OnNext(DiagnosticListener value)
+            {
+                if (value.Name == "Microsoft.Extensions.Hosting")
+                {
+                    _disposable = value.Subscribe(this);
+                }
+            }
+
+            public void OnNext(KeyValuePair<string, object?> value)
+            {
+                _callback(value);
+            }
+        }
+
         private class FakeFileProvider : IFileProvider, IDisposable
         {
             public bool Disposed { get; private set; }
diff --git a/src/libraries/Microsoft.Extensions.Hosting/tests/UnitTests/Microsoft.Extensions.Hosting.Unit.Tests.csproj b/src/libraries/Microsoft.Extensions.Hosting/tests/UnitTests/Microsoft.Extensions.Hosting.Unit.Tests.csproj
index 8038a16a4d5afd..c5049661e96a16 100644
--- a/src/libraries/Microsoft.Extensions.Hosting/tests/UnitTests/Microsoft.Extensions.Hosting.Unit.Tests.csproj
+++ b/src/libraries/Microsoft.Extensions.Hosting/tests/UnitTests/Microsoft.Extensions.Hosting.Unit.Tests.csproj
@@ -3,6 +3,7 @@
   <PropertyGroup>
     <TargetFrameworks>$(NetCoreAppCurrent)-windows;$(NetCoreAppCurrent);net461</TargetFrameworks>
     <EnableDefaultItems>true</EnableDefaultItems>
+    <IncludeRemoteExecutor>true</IncludeRemoteExecutor>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/src/libraries/Microsoft.Extensions.Http/tests/Microsoft.Extensions.Http.Tests/Logging/RedactedLogValueIntegrationTest.cs b/src/libraries/Microsoft.Extensions.Http/tests/Microsoft.Extensions.Http.Tests/Logging/RedactedLogValueIntegrationTest.cs
index 7128daa5045994..4a4c1327401c1f 100644
--- a/src/libraries/Microsoft.Extensions.Http/tests/Microsoft.Extensions.Http.Tests/Logging/RedactedLogValueIntegrationTest.cs
+++ b/src/libraries/Microsoft.Extensions.Http/tests/Microsoft.Extensions.Http.Tests/Logging/RedactedLogValueIntegrationTest.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.Linq;
 using System.Net.Http;
 using System.Net.Http.Headers;
@@ -50,11 +51,11 @@ public async Task RedactHeaderValueWithHeaderList_ValueIsRedactedBeforeLogging()
                     m.EventId == LoggingScopeHttpMessageHandler.Log.EventIds.RequestHeader &&
                     m.LoggerName == "System.Net.Http.HttpClient.test.LogicalHandler";
             }));
-            Assert.StartsWith(
+            Assert.StartsWith(LineEndingsHelper.Normalize(
 @"Request Headers:
 Authorization: *
 Cache-Control: no-cache
-", message.Message);
+"), message.Message);
 
             message = Assert.Single(messages.Where(m =>
             {
@@ -62,11 +63,11 @@ public async Task RedactHeaderValueWithHeaderList_ValueIsRedactedBeforeLogging()
                     m.EventId == LoggingHttpMessageHandler.Log.EventIds.RequestHeader &&
                     m.LoggerName == "System.Net.Http.HttpClient.test.ClientHandler";
             }));
-            Assert.StartsWith(
+            Assert.StartsWith(LineEndingsHelper.Normalize(
 @"Request Headers:
 Authorization: *
 Cache-Control: no-cache
-", message.Message);
+"), message.Message);
 
             message = Assert.Single(messages.Where(m =>
             {
@@ -74,11 +75,11 @@ public async Task RedactHeaderValueWithHeaderList_ValueIsRedactedBeforeLogging()
                     m.EventId == LoggingHttpMessageHandler.Log.EventIds.ResponseHeader &&
                     m.LoggerName == "System.Net.Http.HttpClient.test.ClientHandler";
             }));
-            Assert.StartsWith(
+            Assert.StartsWith(LineEndingsHelper.Normalize(
 @"Response Headers:
 X-Sensitive: *
 Y-Non-Sensitive: innocuous value
-", message.Message);
+"), message.Message);
 
             message = Assert.Single(messages.Where(m =>
             {
@@ -86,11 +87,11 @@ public async Task RedactHeaderValueWithHeaderList_ValueIsRedactedBeforeLogging()
                     m.EventId == LoggingScopeHttpMessageHandler.Log.EventIds.ResponseHeader &&
                     m.LoggerName == "System.Net.Http.HttpClient.test.LogicalHandler";
             }));
-            Assert.StartsWith(
+            Assert.StartsWith(LineEndingsHelper.Normalize(
 @"Response Headers:
 X-Sensitive: *
 Y-Non-Sensitive: innocuous value
-", message.Message);
+"), message.Message);
         }
 
         [Fact]
@@ -131,11 +132,11 @@ public async Task RedactHeaderValueWithPredicate_ValueIsRedactedBeforeLogging()
                     m.EventId == LoggingScopeHttpMessageHandler.Log.EventIds.RequestHeader &&
                     m.LoggerName == "System.Net.Http.HttpClient.test.LogicalHandler";
             }));
-            Assert.StartsWith(
+            Assert.StartsWith(LineEndingsHelper.Normalize(
 @"Request Headers:
 Authorization: *
 Cache-Control: no-cache
-", message.Message);
+"), message.Message);
 
             message = Assert.Single(messages.Where(m =>
             {
@@ -143,11 +144,11 @@ public async Task RedactHeaderValueWithPredicate_ValueIsRedactedBeforeLogging()
                     m.EventId == LoggingHttpMessageHandler.Log.EventIds.RequestHeader &&
                     m.LoggerName == "System.Net.Http.HttpClient.test.ClientHandler";
             }));
-            Assert.StartsWith(
+            Assert.StartsWith(LineEndingsHelper.Normalize(
 @"Request Headers:
 Authorization: *
 Cache-Control: no-cache
-", message.Message);
+"), message.Message);
 
             message = Assert.Single(messages.Where(m =>
             {
@@ -155,11 +156,11 @@ public async Task RedactHeaderValueWithPredicate_ValueIsRedactedBeforeLogging()
                     m.EventId == LoggingHttpMessageHandler.Log.EventIds.ResponseHeader &&
                     m.LoggerName == "System.Net.Http.HttpClient.test.ClientHandler";
             }));
-            Assert.StartsWith(
+            Assert.StartsWith(LineEndingsHelper.Normalize(
 @"Response Headers:
 X-Sensitive: *
 Y-Non-Sensitive: innocuous value
-", message.Message);
+"), message.Message);
 
             message = Assert.Single(messages.Where(m =>
             {
@@ -167,11 +168,11 @@ public async Task RedactHeaderValueWithPredicate_ValueIsRedactedBeforeLogging()
                     m.EventId == LoggingScopeHttpMessageHandler.Log.EventIds.ResponseHeader &&
                     m.LoggerName == "System.Net.Http.HttpClient.test.LogicalHandler";
             }));
-            Assert.StartsWith(
+            Assert.StartsWith(LineEndingsHelper.Normalize(
 @"Response Headers:
 X-Sensitive: *
 Y-Non-Sensitive: innocuous value
-", message.Message);
+"), message.Message);
         }
 
         private class TestMessageHandler : HttpClientHandler
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/DiagnosticDescriptors.cs b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/DiagnosticDescriptors.cs
index 2e7e0ac340180d..2e3f31a508702f 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/DiagnosticDescriptors.cs
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/DiagnosticDescriptors.cs
@@ -32,14 +32,6 @@ public static class DiagnosticDescriptors
             DiagnosticSeverity.Error,
             isEnabledByDefault: true);
 
-        public static DiagnosticDescriptor LoggingMethodInNestedType { get; } = new DiagnosticDescriptor(
-            id: "SYSLIB1004",
-            title: new LocalizableResourceString(nameof(SR.LoggingMethodInNestedTypeMessage), SR.ResourceManager, typeof(FxResources.Microsoft.Extensions.Logging.Generators.SR)),
-            messageFormat: new LocalizableResourceString(nameof(SR.LoggingMethodInNestedTypeMessage), SR.ResourceManager, typeof(FxResources.Microsoft.Extensions.Logging.Generators.SR)),
-            category: "LoggingGenerator",
-            DiagnosticSeverity.Error,
-            isEnabledByDefault: true);
-
         public static DiagnosticDescriptor MissingRequiredType { get; } = new DiagnosticDescriptor(
             id: "SYSLIB1005",
             title: new LocalizableResourceString(nameof(SR.MissingRequiredTypeTitle), SR.ResourceManager, typeof(FxResources.Microsoft.Extensions.Logging.Generators.SR)),
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/LoggerMessageGenerator.Emitter.cs b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/LoggerMessageGenerator.Emitter.cs
index 748bfd375bbe34..908efaf6afe325 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/LoggerMessageGenerator.Emitter.cs
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/LoggerMessageGenerator.Emitter.cs
@@ -65,6 +65,7 @@ private static bool UseLoggerMessageDefine(LoggerMethod lm)
 
             private void GenType(LoggerClass lc)
             {
+                string nestedIndentation = "";
                 if (!string.IsNullOrWhiteSpace(lc.Namespace))
                 {
                     _builder.Append($@"
@@ -72,22 +73,49 @@ namespace {lc.Namespace}
 {{");
                 }
 
+                LoggerClass parent = lc.ParentClass;
+                var parentClasses = new List<string>();
+                // loop until you find top level nested class
+                while (parent != null)
+                {
+                    parentClasses.Add($"partial {parent.Keyword} {parent.Name} {parent.Constraints}");
+                    parent = parent.ParentClass;
+                }
+
+                // write down top level nested class first
+                for (int i = parentClasses.Count - 1; i >= 0; i--)
+                {
+                    _builder.Append($@"
+    {nestedIndentation}{parentClasses[i]}
+    {nestedIndentation}{{");
+                    nestedIndentation += "    ";
+                }
+
                 _builder.Append($@"
-    partial class {lc.Name} {lc.Constraints}
-    {{");
+    {nestedIndentation}partial {lc.Keyword} {lc.Name} {lc.Constraints}
+    {nestedIndentation}{{");
 
                 foreach (LoggerMethod lm in lc.Methods)
                 {
                     if (!UseLoggerMessageDefine(lm))
                     {
-                        GenStruct(lm);
+                        GenStruct(lm, nestedIndentation);
                     }
 
-                    GenLogMethod(lm);
+                    GenLogMethod(lm, nestedIndentation);
                 }
 
                 _builder.Append($@"
-    }}");
+    {nestedIndentation}}}");
+
+                parent = lc.ParentClass;
+                while (parent != null)
+                {
+                    nestedIndentation = new String(' ', nestedIndentation.Length - 4);
+                    _builder.Append($@"
+    {nestedIndentation}}}");
+                    parent = parent.ParentClass;
+                }
 
                 if (!string.IsNullOrWhiteSpace(lc.Namespace))
                 {
@@ -96,83 +124,83 @@ partial class {lc.Name} {lc.Constraints}
                 }
             }
 
-            private void GenStruct(LoggerMethod lm)
+            private void GenStruct(LoggerMethod lm, string nestedIndentation)
             {
                 _builder.AppendLine($@"
-        [{s_generatedCodeAttribute}]
-        private readonly struct __{lm.Name}Struct : global::System.Collections.Generic.IReadOnlyList<global::System.Collections.Generic.KeyValuePair<string, object?>>
-        {{");
-                GenFields(lm);
+        {nestedIndentation}[{s_generatedCodeAttribute}]
+        {nestedIndentation}private readonly struct __{lm.Name}Struct : global::System.Collections.Generic.IReadOnlyList<global::System.Collections.Generic.KeyValuePair<string, object?>>
+        {nestedIndentation}{{");
+                GenFields(lm, nestedIndentation);
 
                 if (lm.TemplateParameters.Count > 0)
                 {
                     _builder.Append($@"
-            public __{lm.Name}Struct(");
+            {nestedIndentation}public __{lm.Name}Struct(");
                     GenArguments(lm);
                     _builder.Append($@")
-            {{");
+            {nestedIndentation}{{");
                     _builder.AppendLine();
-                    GenFieldAssignments(lm);
+                    GenFieldAssignments(lm, nestedIndentation);
                     _builder.Append($@"
-            }}
+            {nestedIndentation}}}
 ");
                 }
 
                 _builder.Append($@"
-            public override string ToString()
-            {{
+            {nestedIndentation}public override string ToString()
+            {nestedIndentation}{{
 ");
-                GenVariableAssignments(lm);
+                GenVariableAssignments(lm, nestedIndentation);
                 _builder.Append($@"
-                return $""{lm.Message}"";
-            }}
+                {nestedIndentation}return $""{lm.Message}"";
+            {nestedIndentation}}}
 ");
                 _builder.Append($@"
-            public static string Format(__{lm.Name}Struct state, global::System.Exception? ex) => state.ToString();
+            {nestedIndentation}public static string Format(__{lm.Name}Struct state, global::System.Exception? ex) => state.ToString();
 
-            public int Count => {lm.TemplateParameters.Count + 1};
+            {nestedIndentation}public int Count => {lm.TemplateParameters.Count + 1};
 
-            public global::System.Collections.Generic.KeyValuePair<string, object?> this[int index]
-            {{
-                get => index switch
-                {{
+            {nestedIndentation}public global::System.Collections.Generic.KeyValuePair<string, object?> this[int index]
+            {nestedIndentation}{{
+                {nestedIndentation}get => index switch
+                {nestedIndentation}{{
 ");
-                GenCases(lm);
+                GenCases(lm, nestedIndentation);
                 _builder.Append($@"
-                    _ => throw new global::System.IndexOutOfRangeException(nameof(index)),  // return the same exception LoggerMessage.Define returns in this case
-                }};
+                    {nestedIndentation}_ => throw new global::System.IndexOutOfRangeException(nameof(index)),  // return the same exception LoggerMessage.Define returns in this case
+                {nestedIndentation}}};
             }}
 
-            public global::System.Collections.Generic.IEnumerator<global::System.Collections.Generic.KeyValuePair<string, object?>> GetEnumerator()
-            {{
-                for (int i = 0; i < {lm.TemplateParameters.Count + 1}; i++)
-                {{
-                    yield return this[i];
-                }}
-            }}
+            {nestedIndentation}public global::System.Collections.Generic.IEnumerator<global::System.Collections.Generic.KeyValuePair<string, object?>> GetEnumerator()
+            {nestedIndentation}{{
+                {nestedIndentation}for (int i = 0; i < {lm.TemplateParameters.Count + 1}; i++)
+                {nestedIndentation}{{
+                    {nestedIndentation}yield return this[i];
+                {nestedIndentation}}}
+            {nestedIndentation}}}
 
-            global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator() => GetEnumerator();
-        }}
+            {nestedIndentation}global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator() => GetEnumerator();
+        {nestedIndentation}}}
 ");
             }
 
-            private void GenFields(LoggerMethod lm)
+            private void GenFields(LoggerMethod lm, string nestedIndentation)
             {
                 foreach (LoggerParameter p in lm.TemplateParameters)
                 {
-                    _builder.AppendLine($"            private readonly {p.Type} _{p.Name};");
+                    _builder.AppendLine($"            {nestedIndentation}private readonly {p.Type} _{p.Name};");
                 }
             }
 
-            private void GenFieldAssignments(LoggerMethod lm)
+            private void GenFieldAssignments(LoggerMethod lm, string nestedIndentation)
             {
                 foreach (LoggerParameter p in lm.TemplateParameters)
                 {
-                    _builder.AppendLine($"                this._{p.Name} = {p.Name};");
+                    _builder.AppendLine($"                {nestedIndentation}this._{p.Name} = {p.Name};");
                 }
             }
 
-            private void GenVariableAssignments(LoggerMethod lm)
+            private void GenVariableAssignments(LoggerMethod lm, string nestedIndentation)
             {
                 foreach (KeyValuePair<string, string> t in lm.TemplateMap)
                 {
@@ -192,20 +220,20 @@ private void GenVariableAssignments(LoggerMethod lm)
                     {
                         if (lm.TemplateParameters[index].IsEnumerable)
                         {
-                            _builder.AppendLine($"                var {t.Key} = "
+                            _builder.AppendLine($"                {nestedIndentation}var {t.Key} = "
                                 + $"global::__LoggerMessageGenerator.Enumerate((global::System.Collections.IEnumerable ?)this._{lm.TemplateParameters[index].Name});");
 
                             _needEnumerationHelper = true;
                         }
                         else
                         {
-                            _builder.AppendLine($"                var {t.Key} = this._{lm.TemplateParameters[index].Name};");
+                            _builder.AppendLine($"                {nestedIndentation}var {t.Key} = this._{lm.TemplateParameters[index].Name};");
                         }
                     }
                 }
             }
 
-            private void GenCases(LoggerMethod lm)
+            private void GenCases(LoggerMethod lm, string nestedIndentation)
             {
                 int index = 0;
                 foreach (LoggerParameter p in lm.TemplateParameters)
@@ -217,10 +245,10 @@ private void GenCases(LoggerMethod lm)
                         name = lm.TemplateMap[name];
                     }
 
-                    _builder.AppendLine($"                    {index++} => new global::System.Collections.Generic.KeyValuePair<string, object?>(\"{name}\", this._{p.Name}),");
+                    _builder.AppendLine($"                    {nestedIndentation}{index++} => new global::System.Collections.Generic.KeyValuePair<string, object?>(\"{name}\", this._{p.Name}),");
                 }
 
-                _builder.AppendLine($"                    {index++} => new global::System.Collections.Generic.KeyValuePair<string, object?>(\"{{OriginalFormat}}\", \"{ConvertEndOfLineAndQuotationCharactersToEscapeForm(lm.Message)}\"),");
+                _builder.AppendLine($"                    {nestedIndentation}{index++} => new global::System.Collections.Generic.KeyValuePair<string, object?>(\"{{OriginalFormat}}\", \"{ConvertEndOfLineAndQuotationCharactersToEscapeForm(lm.Message)}\"),");
             }
 
             private void GenCallbackArguments(LoggerMethod lm)
@@ -321,7 +349,7 @@ private void GenHolder(LoggerMethod lm)
                 _builder.Append(')');
             }
 
-            private void GenLogMethod(LoggerMethod lm)
+            private void GenLogMethod(LoggerMethod lm, string nestedIndentation)
             {
                 string level = GetLogLevel(lm);
                 string extension = lm.IsExtensionMethod ? "this " : string.Empty;
@@ -332,13 +360,13 @@ private void GenLogMethod(LoggerMethod lm)
                 if (UseLoggerMessageDefine(lm))
                 {
                     _builder.Append($@"
-        [{s_generatedCodeAttribute}]
-        private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, ");
+        {nestedIndentation}[{s_generatedCodeAttribute}]
+        {nestedIndentation}private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, ");
 
                     GenDefineTypes(lm, brackets: false);
 
-                    _builder.Append(@$"global::System.Exception?> __{lm.Name}Callback =
-            global::Microsoft.Extensions.Logging.LoggerMessage.Define");
+                    _builder.Append($@"global::System.Exception?> __{lm.Name}Callback =
+            {nestedIndentation}global::Microsoft.Extensions.Logging.LoggerMessage.Define");
 
                     GenDefineTypes(lm, brackets: true);
 
@@ -347,41 +375,52 @@ private void GenLogMethod(LoggerMethod lm)
                 }
 
                 _builder.Append($@"
-        [{s_generatedCodeAttribute}]
-        {lm.Modifiers} void {lm.Name}({extension}");
+        {nestedIndentation}[{s_generatedCodeAttribute}]
+        {nestedIndentation}{lm.Modifiers} void {lm.Name}({extension}");
 
                 GenParameters(lm);
 
                 _builder.Append($@")
-        {{
-            if ({logger}.IsEnabled({level}))
-            {{");
+        {nestedIndentation}{{");
+
+                string enabledCheckIndentation = lm.SkipEnabledCheck ? "" : "    ";
+                if (!lm.SkipEnabledCheck)
+                {
+                    _builder.Append($@"
+            {nestedIndentation}if ({logger}.IsEnabled({level}))
+            {nestedIndentation}{{");
+                }
 
                 if (UseLoggerMessageDefine(lm))
                 {
                     _builder.Append($@"
-                __{lm.Name}Callback({logger}, ");
+            {nestedIndentation}{enabledCheckIndentation}__{lm.Name}Callback({logger}, ");
 
                     GenCallbackArguments(lm);
 
-                    _builder.Append(@$"{exceptionArg});");
+                    _builder.Append($"{exceptionArg});");
                 }
                 else
                 {
                     _builder.Append($@"
-                {logger}.Log(
-                    {level},
-                    new global::Microsoft.Extensions.Logging.EventId({lm.EventId}, {eventName}),
-                    ");
-                    GenHolder(lm);
-                    _builder.Append($@",
-                    {exceptionArg},
-                    __{lm.Name}Struct.Format);");
+            {nestedIndentation}{enabledCheckIndentation}{logger}.Log(
+                {nestedIndentation}{enabledCheckIndentation}{level},
+                {nestedIndentation}{enabledCheckIndentation}new global::Microsoft.Extensions.Logging.EventId({lm.EventId}, {eventName}),
+                {nestedIndentation}{enabledCheckIndentation}");
+                GenHolder(lm);
+                _builder.Append($@",
+                {nestedIndentation}{enabledCheckIndentation}{exceptionArg},
+                {nestedIndentation}{enabledCheckIndentation}__{lm.Name}Struct.Format);");
+                }
+
+                if (!lm.SkipEnabledCheck)
+                {
+                    _builder.Append($@"
+            {nestedIndentation}}}");
                 }
 
                 _builder.Append($@"
-            }}
-        }}");
+        {nestedIndentation}}}");
 
                 static string GetException(LoggerMethod lm)
                 {
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 03c5ad2cf57624..4a995039104b9d 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/LoggerMessageGenerator.Parser.cs
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/LoggerMessageGenerator.Parser.cs
@@ -9,6 +9,7 @@
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
+using System.Collections.Immutable;
 
 namespace Microsoft.Extensions.Logging.Generators
 {
@@ -83,7 +84,7 @@ public IReadOnlyList<LoggerClass> GetLogClasses(IEnumerable<ClassDeclarationSynt
                         bool multipleLoggerFields = false;
 
                         ids.Clear();
-                        foreach (var member in classDec.Members)
+                        foreach (MemberDeclarationSyntax member in classDec.Members)
                         {
                             var method = member as MethodDeclarationSyntax;
                             if (method == null)
@@ -93,6 +94,9 @@ public IReadOnlyList<LoggerClass> GetLogClasses(IEnumerable<ClassDeclarationSynt
                             }
 
                             sm ??= _compilation.GetSemanticModel(classDec.SyntaxTree);
+                            IMethodSymbol logMethodSymbol = sm.GetDeclaredSymbol(method, _cancellationToken) as IMethodSymbol;
+                            Debug.Assert(logMethodSymbol != null, "log method is present.");
+                            (int eventId, int? level, string message, string? eventName, bool skipEnabledCheck) = (-1, null, string.Empty, null, false);
 
                             foreach (AttributeListSyntax mal in method.AttributeLists)
                             {
@@ -105,7 +109,78 @@ public IReadOnlyList<LoggerClass> GetLogClasses(IEnumerable<ClassDeclarationSynt
                                         continue;
                                     }
 
-                                    (int eventId, int? level, string message, string? eventName) = ExtractAttributeValues(ma.ArgumentList!, sm);
+                                    bool hasMisconfiguredInput = false;
+                                    ImmutableArray<AttributeData>? boundAttrbutes = logMethodSymbol?.GetAttributes();
+
+                                    if (boundAttrbutes == null)
+                                    {
+                                        continue;
+                                    }
+
+                                    foreach (AttributeData attributeData in boundAttrbutes)
+                                    {
+                                        // supports: [LoggerMessage(0, LogLevel.Warning, "custom message")]
+                                        // supports: [LoggerMessage(eventId: 0, level: LogLevel.Warning, message: "custom message")]
+                                        if (attributeData.ConstructorArguments.Any())
+                                        {
+                                            foreach (TypedConstant typedConstant in attributeData.ConstructorArguments)
+                                            {
+                                                if (typedConstant.Kind == TypedConstantKind.Error)
+                                                {
+                                                    hasMisconfiguredInput = true;
+                                                }
+                                            }
+
+                                            ImmutableArray<TypedConstant> items = attributeData.ConstructorArguments;
+                                            Debug.Assert(items.Length == 3);
+
+                                            eventId = items[0].IsNull ? -1 : (int)GetItem(items[0]);
+                                            level = items[1].IsNull ? null : (int?)GetItem(items[1]);
+                                            message = items[2].IsNull ? "" : (string)GetItem(items[2]);
+                                        }
+
+                                        // argument syntax takes parameters. e.g. EventId = 0
+                                        // supports: e.g. [LoggerMessage(EventId = 0, Level = LogLevel.Warning, Message = "custom message")]
+                                        if (attributeData.NamedArguments.Any())
+                                        {
+                                            foreach (KeyValuePair<string, TypedConstant> namedArgument in attributeData.NamedArguments)
+                                            {
+                                                TypedConstant typedConstant = namedArgument.Value;
+                                                if (typedConstant.Kind == TypedConstantKind.Error)
+                                                {
+                                                    hasMisconfiguredInput = true;
+                                                }
+                                                else
+                                                {
+                                                    TypedConstant value = namedArgument.Value;
+                                                    switch (namedArgument.Key)
+                                                    {
+                                                        case "EventId":
+                                                            eventId = (int)GetItem(value);
+                                                            break;
+                                                        case "Level":
+                                                            level = value.IsNull ? null : (int?)GetItem(value);
+                                                            break;
+                                                        case "SkipEnabledCheck":
+                                                            skipEnabledCheck = (bool)GetItem(value);
+                                                            break;
+                                                        case "EventName":
+                                                            eventName = (string?)GetItem(value);
+                                                            break;
+                                                        case "Message":
+                                                            message = value.IsNull ? "" : (string)GetItem(value);
+                                                            break;
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+
+                                    if (hasMisconfiguredInput)
+                                    {
+                                        // skip further generator execution and let compiler generate the errors
+                                        break;
+                                    }
 
                                     IMethodSymbol? methodSymbol = sm.GetDeclaredSymbol(method, _cancellationToken);
                                     if (methodSymbol != null)
@@ -119,6 +194,7 @@ public IReadOnlyList<LoggerClass> GetLogClasses(IEnumerable<ClassDeclarationSynt
                                             EventName = eventName,
                                             IsExtensionMethod = methodSymbol.IsExtensionMethod,
                                             Modifiers = method.Modifiers.ToString(),
+                                            SkipEnabledCheck = skipEnabledCheck
                                         };
 
                                         ExtractTemplates(message, lm.TemplateMap, lm.TemplateList);
@@ -323,7 +399,7 @@ public IReadOnlyList<LoggerClass> GetLogClasses(IEnumerable<ClassDeclarationSynt
 
                                                 if (!found)
                                                 {
-                                                    Diag(DiagnosticDescriptors.TemplateHasNoCorrespondingArgument, ma.GetLocation(), t);
+                                                    Diag(DiagnosticDescriptors.TemplateHasNoCorrespondingArgument, ma.GetLocation(), t.Key);
                                                 }
                                             }
                                         }
@@ -331,28 +407,23 @@ public IReadOnlyList<LoggerClass> GetLogClasses(IEnumerable<ClassDeclarationSynt
                                         if (lc == null)
                                         {
                                             // determine the namespace the class is declared in, if any
-                                            var ns = classDec.Parent as NamespaceDeclarationSyntax;
-                                            if (ns == null)
+                                            SyntaxNode? potentialNamespaceParent = classDec.Parent;
+                                            while (potentialNamespaceParent != null && potentialNamespaceParent is not NamespaceDeclarationSyntax)
                                             {
-                                                if (classDec.Parent is not CompilationUnitSyntax)
-                                                {
-                                                    // since this generator doesn't know how to generate a nested type...
-                                                    Diag(DiagnosticDescriptors.LoggingMethodInNestedType, classDec.Identifier.GetLocation());
-                                                    keepMethod = false;
-                                                }
+                                                potentialNamespaceParent = potentialNamespaceParent.Parent;
                                             }
-                                            else
+                                            if (potentialNamespaceParent is NamespaceDeclarationSyntax namespaceParent)
                                             {
-                                                nspace = ns.Name.ToString();
+                                                nspace = namespaceParent.Name.ToString();
                                                 while (true)
                                                 {
-                                                    ns = ns.Parent as NamespaceDeclarationSyntax;
-                                                    if (ns == null)
+                                                    namespaceParent = namespaceParent.Parent as NamespaceDeclarationSyntax;
+                                                    if (namespaceParent == null)
                                                     {
                                                         break;
                                                     }
 
-                                                    nspace = $"{ns.Name}.{nspace}";
+                                                    nspace = $"{namespaceParent.Name}.{nspace}";
                                                 }
                                             }
                                         }
@@ -361,11 +432,36 @@ public IReadOnlyList<LoggerClass> GetLogClasses(IEnumerable<ClassDeclarationSynt
                                         {
                                             lc ??= new LoggerClass
                                             {
+                                                Keyword = classDec.Keyword.ValueText,
                                                 Namespace = nspace,
                                                 Name = classDec.Identifier.ToString() + classDec.TypeParameterList,
                                                 Constraints = classDec.ConstraintClauses.ToString(),
+                                                ParentClass = null,
                                             };
 
+                                            LoggerClass currentLoggerClass = lc;
+                                            var parentLoggerClass = (classDec.Parent as TypeDeclarationSyntax);
+
+                                            bool IsAllowedKind(SyntaxKind kind) => 
+                                                kind == SyntaxKind.ClassDeclaration ||
+                                                kind == SyntaxKind.StructDeclaration ||
+                                                kind == SyntaxKind.RecordDeclaration;
+                                            
+                                            while (parentLoggerClass != null && IsAllowedKind(parentLoggerClass.Kind()))
+                                            {
+                                                currentLoggerClass.ParentClass = new LoggerClass
+                                                {
+                                                    Keyword = parentLoggerClass.Keyword.ValueText,
+                                                    Namespace = nspace,
+                                                    Name = parentLoggerClass.Identifier.ToString() + parentLoggerClass.TypeParameterList,
+                                                    Constraints = parentLoggerClass.ConstraintClauses.ToString(),
+                                                    ParentClass = null,
+                                                };
+
+                                                currentLoggerClass = currentLoggerClass.ParentClass;
+                                                parentLoggerClass = (parentLoggerClass.Parent as TypeDeclarationSyntax);
+                                            }
+
                                             lc.Methods.Add(lm);
                                         }
                                     }
@@ -415,35 +511,6 @@ public IReadOnlyList<LoggerClass> GetLogClasses(IEnumerable<ClassDeclarationSynt
                 return (loggerField, false);
             }
 
-            private (int eventId, int? level, string message, string? eventName) ExtractAttributeValues(AttributeArgumentListSyntax args, SemanticModel sm)
-            {
-                int eventId = 0;
-                int? level = null;
-                string? eventName = null;
-                string message = string.Empty;
-                foreach (AttributeArgumentSyntax a in args.Arguments)
-                {
-                    // argument syntax takes parameters. e.g. EventId = 0
-                    Debug.Assert(a.NameEquals != null);
-                    switch (a.NameEquals.Name.ToString())
-                    {
-                        case "EventId":
-                            eventId = (int)sm.GetConstantValue(a.Expression, _cancellationToken).Value!;
-                            break;
-                        case "EventName":
-                            eventName = sm.GetConstantValue(a.Expression, _cancellationToken).ToString();
-                            break;
-                        case "Level":
-                            level = (int)sm.GetConstantValue(a.Expression, _cancellationToken).Value!;
-                            break;
-                        case "Message":
-                            message = sm.GetConstantValue(a.Expression, _cancellationToken).ToString();
-                            break;
-                    }
-                }
-                return (eventId, level, message, eventName);
-            }
-
             private void Diag(DiagnosticDescriptor desc, Location? location, params object?[]? messageArgs)
             {
                 _reportDiagnostic(Diagnostic.Create(desc, location, messageArgs));
@@ -560,6 +627,8 @@ private string GetStringExpression(SemanticModel sm, SyntaxNode expr)
 
                 return string.Empty;
             }
+
+            private static object GetItem(TypedConstant arg) => arg.Kind == TypedConstantKind.Array ? arg.Values : arg.Value;
         }
 
         /// <summary>
@@ -568,9 +637,11 @@ private string GetStringExpression(SemanticModel sm, SyntaxNode expr)
         internal class LoggerClass
         {
             public readonly List<LoggerMethod> Methods = new ();
+            public string Keyword = string.Empty;
             public string Namespace = string.Empty;
             public string Name = string.Empty;
             public string Constraints = string.Empty;
+            public LoggerClass? ParentClass;
         }
 
         /// <summary>
@@ -590,6 +661,7 @@ internal class LoggerMethod
             public bool IsExtensionMethod;
             public string Modifiers = string.Empty;
             public string LoggerField = string.Empty;
+            public bool SkipEnabledCheck;
         }
 
         /// <summary>
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/LoggerMessageGenerator.cs b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/LoggerMessageGenerator.cs
index 73ca6a738aa860..92105d515e328c 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/LoggerMessageGenerator.cs
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/LoggerMessageGenerator.cs
@@ -39,7 +39,7 @@ public void Execute(GeneratorExecutionContext context)
                 var e = new Emitter();
                 string result = e.Emit(logClasses, context.CancellationToken);
     
-                context.AddSource("LoggerMessage", SourceText.From(result, Encoding.UTF8));
+                context.AddSource("LoggerMessage.g.cs", SourceText.From(result, Encoding.UTF8));
             }
         }
 
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/Strings.resx b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/Strings.resx
index 13a23bcd2118b8..66a9a1e6a297f2 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/Strings.resx
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/Strings.resx
@@ -123,9 +123,6 @@
   <data name="InvalidLoggingMethodParameterNameMessage" xml:space="preserve">
     <value>Logging method parameter names cannot start with _</value>
   </data>
-  <data name="LoggingMethodInNestedTypeMessage" xml:space="preserve">
-    <value>Logging class cannot be in nested types</value>
-  </data>
   <data name="MissingRequiredTypeTitle" xml:space="preserve">
     <value>Could not find a required type definition</value>
   </data>
@@ -177,7 +174,7 @@
     <value>Argument is not referenced from the logging message</value>
   </data>
   <data name="TemplateHasNoCorrespondingArgumentMessage" xml:space="preserve">
-    <value>Template {0} is not provided as argument to the logging method</value>
+    <value>Template '{0}' is not provided as argument to the logging method</value>
   </data>
   <data name="TemplateHasNoCorrespondingArgumentTitle" xml:space="preserve">
     <value>Logging template has no corresponding method argument</value>
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.cs.xlf b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.cs.xlf
index 8a6e5be5b381c6..7e5140bd64feb3 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.cs.xlf
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.cs.xlf
@@ -37,11 +37,6 @@
         <target state="new">Logging methods cannot have a body</target>
         <note />
       </trans-unit>
-      <trans-unit id="LoggingMethodInNestedTypeMessage">
-        <source>Logging class cannot be in nested types</source>
-        <target state="new">Logging class cannot be in nested types</target>
-        <note />
-      </trans-unit>
       <trans-unit id="LoggingMethodIsGenericMessage">
         <source>Logging methods cannot be generic</source>
         <target state="new">Logging methods cannot be generic</target>
@@ -153,8 +148,8 @@
         <note />
       </trans-unit>
       <trans-unit id="TemplateHasNoCorrespondingArgumentMessage">
-        <source>Template {0} is not provided as argument to the logging method</source>
-        <target state="new">Template {0} is not provided as argument to the logging method</target>
+        <source>Template '{0}' is not provided as argument to the logging method</source>
+        <target state="new">Template '{0}' is not provided as argument to the logging method</target>
         <note />
       </trans-unit>
       <trans-unit id="TemplateHasNoCorrespondingArgumentTitle">
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.de.xlf b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.de.xlf
index 835dfbbc7fbf1a..c0b1d1b81655fc 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.de.xlf
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.de.xlf
@@ -37,11 +37,6 @@
         <target state="new">Logging methods cannot have a body</target>
         <note />
       </trans-unit>
-      <trans-unit id="LoggingMethodInNestedTypeMessage">
-        <source>Logging class cannot be in nested types</source>
-        <target state="new">Logging class cannot be in nested types</target>
-        <note />
-      </trans-unit>
       <trans-unit id="LoggingMethodIsGenericMessage">
         <source>Logging methods cannot be generic</source>
         <target state="new">Logging methods cannot be generic</target>
@@ -153,8 +148,8 @@
         <note />
       </trans-unit>
       <trans-unit id="TemplateHasNoCorrespondingArgumentMessage">
-        <source>Template {0} is not provided as argument to the logging method</source>
-        <target state="new">Template {0} is not provided as argument to the logging method</target>
+        <source>Template '{0}' is not provided as argument to the logging method</source>
+        <target state="new">Template '{0}' is not provided as argument to the logging method</target>
         <note />
       </trans-unit>
       <trans-unit id="TemplateHasNoCorrespondingArgumentTitle">
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.es.xlf b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.es.xlf
index 0db7b4e17b3667..f18fd61da78409 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.es.xlf
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.es.xlf
@@ -37,11 +37,6 @@
         <target state="new">Logging methods cannot have a body</target>
         <note />
       </trans-unit>
-      <trans-unit id="LoggingMethodInNestedTypeMessage">
-        <source>Logging class cannot be in nested types</source>
-        <target state="new">Logging class cannot be in nested types</target>
-        <note />
-      </trans-unit>
       <trans-unit id="LoggingMethodIsGenericMessage">
         <source>Logging methods cannot be generic</source>
         <target state="new">Logging methods cannot be generic</target>
@@ -153,8 +148,8 @@
         <note />
       </trans-unit>
       <trans-unit id="TemplateHasNoCorrespondingArgumentMessage">
-        <source>Template {0} is not provided as argument to the logging method</source>
-        <target state="new">Template {0} is not provided as argument to the logging method</target>
+        <source>Template '{0}' is not provided as argument to the logging method</source>
+        <target state="new">Template '{0}' is not provided as argument to the logging method</target>
         <note />
       </trans-unit>
       <trans-unit id="TemplateHasNoCorrespondingArgumentTitle">
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.fr.xlf b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.fr.xlf
index 757ff655a6b142..ae9e608c8c241e 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.fr.xlf
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.fr.xlf
@@ -37,11 +37,6 @@
         <target state="new">Logging methods cannot have a body</target>
         <note />
       </trans-unit>
-      <trans-unit id="LoggingMethodInNestedTypeMessage">
-        <source>Logging class cannot be in nested types</source>
-        <target state="new">Logging class cannot be in nested types</target>
-        <note />
-      </trans-unit>
       <trans-unit id="LoggingMethodIsGenericMessage">
         <source>Logging methods cannot be generic</source>
         <target state="new">Logging methods cannot be generic</target>
@@ -153,8 +148,8 @@
         <note />
       </trans-unit>
       <trans-unit id="TemplateHasNoCorrespondingArgumentMessage">
-        <source>Template {0} is not provided as argument to the logging method</source>
-        <target state="new">Template {0} is not provided as argument to the logging method</target>
+        <source>Template '{0}' is not provided as argument to the logging method</source>
+        <target state="new">Template '{0}' is not provided as argument to the logging method</target>
         <note />
       </trans-unit>
       <trans-unit id="TemplateHasNoCorrespondingArgumentTitle">
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.it.xlf b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.it.xlf
index 8717aa30c3c287..241484f6356476 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.it.xlf
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.it.xlf
@@ -37,11 +37,6 @@
         <target state="new">Logging methods cannot have a body</target>
         <note />
       </trans-unit>
-      <trans-unit id="LoggingMethodInNestedTypeMessage">
-        <source>Logging class cannot be in nested types</source>
-        <target state="new">Logging class cannot be in nested types</target>
-        <note />
-      </trans-unit>
       <trans-unit id="LoggingMethodIsGenericMessage">
         <source>Logging methods cannot be generic</source>
         <target state="new">Logging methods cannot be generic</target>
@@ -153,8 +148,8 @@
         <note />
       </trans-unit>
       <trans-unit id="TemplateHasNoCorrespondingArgumentMessage">
-        <source>Template {0} is not provided as argument to the logging method</source>
-        <target state="new">Template {0} is not provided as argument to the logging method</target>
+        <source>Template '{0}' is not provided as argument to the logging method</source>
+        <target state="new">Template '{0}' is not provided as argument to the logging method</target>
         <note />
       </trans-unit>
       <trans-unit id="TemplateHasNoCorrespondingArgumentTitle">
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.ja.xlf b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.ja.xlf
index 9ed2e744c66a4c..3854417a403faf 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.ja.xlf
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.ja.xlf
@@ -37,11 +37,6 @@
         <target state="new">Logging methods cannot have a body</target>
         <note />
       </trans-unit>
-      <trans-unit id="LoggingMethodInNestedTypeMessage">
-        <source>Logging class cannot be in nested types</source>
-        <target state="new">Logging class cannot be in nested types</target>
-        <note />
-      </trans-unit>
       <trans-unit id="LoggingMethodIsGenericMessage">
         <source>Logging methods cannot be generic</source>
         <target state="new">Logging methods cannot be generic</target>
@@ -153,8 +148,8 @@
         <note />
       </trans-unit>
       <trans-unit id="TemplateHasNoCorrespondingArgumentMessage">
-        <source>Template {0} is not provided as argument to the logging method</source>
-        <target state="new">Template {0} is not provided as argument to the logging method</target>
+        <source>Template '{0}' is not provided as argument to the logging method</source>
+        <target state="new">Template '{0}' is not provided as argument to the logging method</target>
         <note />
       </trans-unit>
       <trans-unit id="TemplateHasNoCorrespondingArgumentTitle">
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.ko.xlf b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.ko.xlf
index 5b7bbb9010784c..1fec30a63fa0e8 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.ko.xlf
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.ko.xlf
@@ -37,11 +37,6 @@
         <target state="new">Logging methods cannot have a body</target>
         <note />
       </trans-unit>
-      <trans-unit id="LoggingMethodInNestedTypeMessage">
-        <source>Logging class cannot be in nested types</source>
-        <target state="new">Logging class cannot be in nested types</target>
-        <note />
-      </trans-unit>
       <trans-unit id="LoggingMethodIsGenericMessage">
         <source>Logging methods cannot be generic</source>
         <target state="new">Logging methods cannot be generic</target>
@@ -153,8 +148,8 @@
         <note />
       </trans-unit>
       <trans-unit id="TemplateHasNoCorrespondingArgumentMessage">
-        <source>Template {0} is not provided as argument to the logging method</source>
-        <target state="new">Template {0} is not provided as argument to the logging method</target>
+        <source>Template '{0}' is not provided as argument to the logging method</source>
+        <target state="new">Template '{0}' is not provided as argument to the logging method</target>
         <note />
       </trans-unit>
       <trans-unit id="TemplateHasNoCorrespondingArgumentTitle">
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.pl.xlf b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.pl.xlf
index eed366ed41893d..3bfdf3eeeafd35 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.pl.xlf
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.pl.xlf
@@ -37,11 +37,6 @@
         <target state="new">Logging methods cannot have a body</target>
         <note />
       </trans-unit>
-      <trans-unit id="LoggingMethodInNestedTypeMessage">
-        <source>Logging class cannot be in nested types</source>
-        <target state="new">Logging class cannot be in nested types</target>
-        <note />
-      </trans-unit>
       <trans-unit id="LoggingMethodIsGenericMessage">
         <source>Logging methods cannot be generic</source>
         <target state="new">Logging methods cannot be generic</target>
@@ -153,8 +148,8 @@
         <note />
       </trans-unit>
       <trans-unit id="TemplateHasNoCorrespondingArgumentMessage">
-        <source>Template {0} is not provided as argument to the logging method</source>
-        <target state="new">Template {0} is not provided as argument to the logging method</target>
+        <source>Template '{0}' is not provided as argument to the logging method</source>
+        <target state="new">Template '{0}' is not provided as argument to the logging method</target>
         <note />
       </trans-unit>
       <trans-unit id="TemplateHasNoCorrespondingArgumentTitle">
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.pt-BR.xlf b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.pt-BR.xlf
index c33ad19bb8cd91..4417c68f9699a9 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.pt-BR.xlf
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.pt-BR.xlf
@@ -37,11 +37,6 @@
         <target state="new">Logging methods cannot have a body</target>
         <note />
       </trans-unit>
-      <trans-unit id="LoggingMethodInNestedTypeMessage">
-        <source>Logging class cannot be in nested types</source>
-        <target state="new">Logging class cannot be in nested types</target>
-        <note />
-      </trans-unit>
       <trans-unit id="LoggingMethodIsGenericMessage">
         <source>Logging methods cannot be generic</source>
         <target state="new">Logging methods cannot be generic</target>
@@ -153,8 +148,8 @@
         <note />
       </trans-unit>
       <trans-unit id="TemplateHasNoCorrespondingArgumentMessage">
-        <source>Template {0} is not provided as argument to the logging method</source>
-        <target state="new">Template {0} is not provided as argument to the logging method</target>
+        <source>Template '{0}' is not provided as argument to the logging method</source>
+        <target state="new">Template '{0}' is not provided as argument to the logging method</target>
         <note />
       </trans-unit>
       <trans-unit id="TemplateHasNoCorrespondingArgumentTitle">
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.ru.xlf b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.ru.xlf
index 37548b1750a5cc..5263092fc61907 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.ru.xlf
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.ru.xlf
@@ -37,11 +37,6 @@
         <target state="new">Logging methods cannot have a body</target>
         <note />
       </trans-unit>
-      <trans-unit id="LoggingMethodInNestedTypeMessage">
-        <source>Logging class cannot be in nested types</source>
-        <target state="new">Logging class cannot be in nested types</target>
-        <note />
-      </trans-unit>
       <trans-unit id="LoggingMethodIsGenericMessage">
         <source>Logging methods cannot be generic</source>
         <target state="new">Logging methods cannot be generic</target>
@@ -153,8 +148,8 @@
         <note />
       </trans-unit>
       <trans-unit id="TemplateHasNoCorrespondingArgumentMessage">
-        <source>Template {0} is not provided as argument to the logging method</source>
-        <target state="new">Template {0} is not provided as argument to the logging method</target>
+        <source>Template '{0}' is not provided as argument to the logging method</source>
+        <target state="new">Template '{0}' is not provided as argument to the logging method</target>
         <note />
       </trans-unit>
       <trans-unit id="TemplateHasNoCorrespondingArgumentTitle">
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.tr.xlf b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.tr.xlf
index dccdbd55e57aa9..539f7ecf9c131b 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.tr.xlf
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.tr.xlf
@@ -37,11 +37,6 @@
         <target state="new">Logging methods cannot have a body</target>
         <note />
       </trans-unit>
-      <trans-unit id="LoggingMethodInNestedTypeMessage">
-        <source>Logging class cannot be in nested types</source>
-        <target state="new">Logging class cannot be in nested types</target>
-        <note />
-      </trans-unit>
       <trans-unit id="LoggingMethodIsGenericMessage">
         <source>Logging methods cannot be generic</source>
         <target state="new">Logging methods cannot be generic</target>
@@ -153,8 +148,8 @@
         <note />
       </trans-unit>
       <trans-unit id="TemplateHasNoCorrespondingArgumentMessage">
-        <source>Template {0} is not provided as argument to the logging method</source>
-        <target state="new">Template {0} is not provided as argument to the logging method</target>
+        <source>Template '{0}' is not provided as argument to the logging method</source>
+        <target state="new">Template '{0}' is not provided as argument to the logging method</target>
         <note />
       </trans-unit>
       <trans-unit id="TemplateHasNoCorrespondingArgumentTitle">
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.zh-Hans.xlf b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.zh-Hans.xlf
index 98b2d4b7185e9b..cbc17ee3d19fda 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.zh-Hans.xlf
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.zh-Hans.xlf
@@ -37,11 +37,6 @@
         <target state="new">Logging methods cannot have a body</target>
         <note />
       </trans-unit>
-      <trans-unit id="LoggingMethodInNestedTypeMessage">
-        <source>Logging class cannot be in nested types</source>
-        <target state="new">Logging class cannot be in nested types</target>
-        <note />
-      </trans-unit>
       <trans-unit id="LoggingMethodIsGenericMessage">
         <source>Logging methods cannot be generic</source>
         <target state="new">Logging methods cannot be generic</target>
@@ -153,8 +148,8 @@
         <note />
       </trans-unit>
       <trans-unit id="TemplateHasNoCorrespondingArgumentMessage">
-        <source>Template {0} is not provided as argument to the logging method</source>
-        <target state="new">Template {0} is not provided as argument to the logging method</target>
+        <source>Template '{0}' is not provided as argument to the logging method</source>
+        <target state="new">Template '{0}' is not provided as argument to the logging method</target>
         <note />
       </trans-unit>
       <trans-unit id="TemplateHasNoCorrespondingArgumentTitle">
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.zh-Hant.xlf b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.zh-Hant.xlf
index 0a54ae2ca73273..297a39f23dbdd5 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.zh-Hant.xlf
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.zh-Hant.xlf
@@ -37,11 +37,6 @@
         <target state="new">Logging methods cannot have a body</target>
         <note />
       </trans-unit>
-      <trans-unit id="LoggingMethodInNestedTypeMessage">
-        <source>Logging class cannot be in nested types</source>
-        <target state="new">Logging class cannot be in nested types</target>
-        <note />
-      </trans-unit>
       <trans-unit id="LoggingMethodIsGenericMessage">
         <source>Logging methods cannot be generic</source>
         <target state="new">Logging methods cannot be generic</target>
@@ -153,8 +148,8 @@
         <note />
       </trans-unit>
       <trans-unit id="TemplateHasNoCorrespondingArgumentMessage">
-        <source>Template {0} is not provided as argument to the logging method</source>
-        <target state="new">Template {0} is not provided as argument to the logging method</target>
+        <source>Template '{0}' is not provided as argument to the logging method</source>
+        <target state="new">Template '{0}' is not provided as argument to the logging method</target>
         <note />
       </trans-unit>
       <trans-unit id="TemplateHasNoCorrespondingArgumentTitle">
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 57deb72a24a56d..ef9d46564ec61c 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
@@ -119,17 +119,19 @@ public static partial class LoggerMessage
     public sealed partial class LoggerMessageAttribute : System.Attribute
     {
         public LoggerMessageAttribute() { }
+        public LoggerMessageAttribute(int eventId, Microsoft.Extensions.Logging.LogLevel level, string message) { }
         public int EventId { get { throw null; } set { } }
         public string? EventName { get { throw null; } set { } }
         public Microsoft.Extensions.Logging.LogLevel Level { get { throw null; } set { } }
         public string Message { get { throw null; } set { } }
+        public bool SkipEnabledCheck { get { throw null; } set { } }
     }
     public partial class Logger<T> : Microsoft.Extensions.Logging.ILogger, Microsoft.Extensions.Logging.ILogger<T>
     {
         public Logger(Microsoft.Extensions.Logging.ILoggerFactory factory) { }
         System.IDisposable Microsoft.Extensions.Logging.ILogger.BeginScope<TState>(TState state) { throw null; }
         bool Microsoft.Extensions.Logging.ILogger.IsEnabled(Microsoft.Extensions.Logging.LogLevel logLevel) { throw null; }
-        void Microsoft.Extensions.Logging.ILogger.Log<TState>(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, TState state, System.Exception exception, System.Func<TState, System.Exception, string> formatter) { }
+        void Microsoft.Extensions.Logging.ILogger.Log<TState>(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, TState state, System.Exception? exception, System.Func<TState, System.Exception?, string> formatter) { }
     }
     public enum LogLevel
     {
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/ref/Microsoft.Extensions.Logging.Abstractions.csproj b/src/libraries/Microsoft.Extensions.Logging.Abstractions/ref/Microsoft.Extensions.Logging.Abstractions.csproj
index 0086184386da10..8a736a657507a6 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/ref/Microsoft.Extensions.Logging.Abstractions.csproj
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/ref/Microsoft.Extensions.Logging.Abstractions.csproj
@@ -1,9 +1,12 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFrameworks>netstandard2.0;net461</TargetFrameworks>
+    <TargetFrameworks>$(NetCoreAppCurrent);netstandard2.0;net461</TargetFrameworks>
     <Nullable>enable</Nullable>
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="Microsoft.Extensions.Logging.Abstractions.cs" />
   </ItemGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == '$(NetCoreAppCurrent)'">
+    <ProjectReference Include="$(LibrariesProjectRoot)System.Runtime\ref\System.Runtime.csproj" />
+  </ItemGroup>
 </Project>
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/LogValuesFormatter.cs b/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/LogValuesFormatter.cs
index aed4014fdc6ba5..24dfb06b014928 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/LogValuesFormatter.cs
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/LogValuesFormatter.cs
@@ -233,7 +233,7 @@ private object FormatArgument(object? value)
             {
                 var vsb = new ValueStringBuilder(stackalloc char[256]);
                 bool first = true;
-                foreach (object e in enumerable)
+                foreach (object? e in enumerable)
                 {
                     if (!first)
                     {
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/LoggerMessageAttribute.cs b/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/LoggerMessageAttribute.cs
index b103ef31a4e162..acb9af3d8601fe 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/LoggerMessageAttribute.cs
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/LoggerMessageAttribute.cs
@@ -37,6 +37,20 @@ public sealed class LoggerMessageAttribute : Attribute
         /// </summary>
         public LoggerMessageAttribute() { }
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="LoggerMessageAttribute"/> class
+        /// which is used to guide the production of a strongly-typed logging method.
+        /// </summary>
+        /// <param name="eventId">The log event Id.</param>
+        /// <param name="level">The log level.</param>
+        /// <param name="message">Format string of the log message.</param>
+        public LoggerMessageAttribute(int eventId, LogLevel level, string message)
+        {
+            EventId = eventId;
+            Level = level;
+            Message = message;
+        }
+
         /// <summary>
         /// Gets the logging event id for the logging method.
         /// </summary>
@@ -59,5 +73,10 @@ public LoggerMessageAttribute() { }
         /// Gets the message text for the logging method.
         /// </summary>
         public string Message { get; set; } = "";
+
+        /// <summary>
+        /// Gets the flag to skip IsEnabled check for the logging method.
+        /// </summary>
+        public bool SkipEnabledCheck { get; set; }
     }
 }
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 d63b42d63f3a67..71e35b67179fa7 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
@@ -2,7 +2,6 @@
 
   <PropertyGroup>
     <TargetFrameworks>$(NetCoreAppCurrent);netstandard2.0;net461</TargetFrameworks>
-    <ExcludeCurrentNetCoreAppFromPackage>true</ExcludeCurrentNetCoreAppFromPackage>
     <EnableDefaultItems>true</EnableDefaultItems>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <!-- Use targeting pack references instead of granular ones in the project file. -->
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/Baselines/TestWithDefaultValues.generated.txt b/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/Baselines/TestWithDefaultValues.generated.txt
new file mode 100644
index 00000000000000..c61da37d27bba4
--- /dev/null
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/Baselines/TestWithDefaultValues.generated.txt
@@ -0,0 +1,57 @@
+// <auto-generated/>
+#nullable enable
+
+namespace Microsoft.Extensions.Logging.Generators.Tests.TestClasses
+{
+    partial class TestWithDefaultValues 
+    {
+        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "6.0.0.0")]
+        private readonly struct __M0Struct : global::System.Collections.Generic.IReadOnlyList<global::System.Collections.Generic.KeyValuePair<string, object?>>
+        {
+
+            public override string ToString()
+            {
+
+                return $"";
+            }
+
+            public static string Format(__M0Struct state, global::System.Exception? ex) => state.ToString();
+
+            public int Count => 1;
+
+            public global::System.Collections.Generic.KeyValuePair<string, object?> this[int index]
+            {
+                get => index switch
+                {
+                    0 => new global::System.Collections.Generic.KeyValuePair<string, object?>("{OriginalFormat}", ""),
+
+                    _ => throw new global::System.IndexOutOfRangeException(nameof(index)),  // return the same exception LoggerMessage.Define returns in this case
+                };
+            }
+
+            public global::System.Collections.Generic.IEnumerator<global::System.Collections.Generic.KeyValuePair<string, object?>> GetEnumerator()
+            {
+                for (int i = 0; i < 1; i++)
+                {
+                    yield return this[i];
+                }
+            }
+
+            global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator() => GetEnumerator();
+        }
+
+        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "6.0.0.0")]
+        public static partial void M0(global::Microsoft.Extensions.Logging.ILogger logger, global::Microsoft.Extensions.Logging.LogLevel level)
+        {
+            if (logger.IsEnabled(level))
+            {
+                logger.Log(
+                    level,
+                    new global::Microsoft.Extensions.Logging.EventId(-1, nameof(M0)),
+                    new __M0Struct(),
+                    null,
+                    __M0Struct.Format);
+            }
+        }
+    }
+}
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/Baselines/TestWithNestedClass.generated.txt b/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/Baselines/TestWithNestedClass.generated.txt
new file mode 100644
index 00000000000000..024e0464c715f8
--- /dev/null
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/Baselines/TestWithNestedClass.generated.txt
@@ -0,0 +1,36 @@
+// <auto-generated/>
+#nullable enable
+
+namespace Microsoft.Extensions.Logging.Generators.Tests.TestClasses.NestedNamespace
+{
+    partial class MultiLevelNestedClass 
+    {
+        partial struct NestedStruct 
+        {
+            partial record NestedRecord 
+            {
+                partial class NestedClassTestsExtensions<T1> where T1 : Class1
+                {
+                    partial class NestedMiddleParentClass 
+                    {
+                        partial class Nested<T2> where T2 : Class2
+                        {
+                            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "6.0.0.0")]
+                            private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Exception?> __M9Callback =
+                                global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Debug, new global::Microsoft.Extensions.Logging.EventId(9, nameof(M9)), "M9", true); 
+
+                            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "6.0.0.0")]
+                            public static partial void M9(global::Microsoft.Extensions.Logging.ILogger logger)
+                            {
+                                if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
+                                {
+                                    __M9Callback(logger, null);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/Baselines/TestWithSkipEnabledCheck.generated.txt b/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/Baselines/TestWithSkipEnabledCheck.generated.txt
new file mode 100644
index 00000000000000..c4b242a0a9e17d
--- /dev/null
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/Baselines/TestWithSkipEnabledCheck.generated.txt
@@ -0,0 +1,18 @@
+// <auto-generated/>
+#nullable enable
+
+namespace Microsoft.Extensions.Logging.Generators.Tests.TestClasses
+{
+    partial class TestWithSkipEnabledCheck 
+    {
+        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "6.0.0.0")]
+        private static readonly global::System.Action<global::Microsoft.Extensions.Logging.ILogger, global::System.Exception?> __M0Callback =
+            global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Information, new global::Microsoft.Extensions.Logging.EventId(0, nameof(M0)), "Message: When using SkipEnabledCheck, the generated code skips logger.IsEnabled(logLevel) check before calling log. To be used when consumer has already guarded logger method in an IsEnabled check.", true); 
+
+        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Logging.Generators", "6.0.0.0")]
+        public static partial void M0(global::Microsoft.Extensions.Logging.ILogger logger)
+        {
+            __M0Callback(logger, null);
+        }
+    }
+}
\ No newline at end of file
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 7e0661d77a6993..33d1ab7c901712 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
@@ -178,6 +178,22 @@ public void MessageTests()
             Assert.Equal(string.Empty, logger.LastFormattedString);
             Assert.Equal(LogLevel.Debug, logger.LastLogLevel);
             Assert.Equal(1, logger.CallCount);
+
+            logger.Reset();
+            MessageTestExtensions.M5(logger, LogLevel.Trace);
+            Assert.Null(logger.LastException);
+            Assert.Equal(string.Empty, logger.LastFormattedString);
+            Assert.Equal(LogLevel.Trace, logger.LastLogLevel);
+            Assert.Equal(-1, logger.LastEventId.Id);
+            Assert.Equal(1, logger.CallCount);
+
+            logger.Reset();
+            MessageTestExtensions.M6(logger, LogLevel.Trace);
+            Assert.Null(logger.LastException);
+            Assert.Equal(string.Empty, logger.LastFormattedString);
+            Assert.Equal(LogLevel.Trace, logger.LastLogLevel);
+            Assert.Equal(6, logger.LastEventId.Id);
+            Assert.Equal(1, logger.CallCount);
         }
 
         [Fact]
@@ -309,6 +325,14 @@ public void LevelTests()
             Assert.Equal("M9", logger.LastFormattedString);
             Assert.Equal(LogLevel.Trace, logger.LastLogLevel);
             Assert.Equal(1, logger.CallCount);
+
+            logger.Reset();
+            LevelTestExtensions.M10vs11(logger);
+            Assert.Null(logger.LastException);
+            Assert.Equal("event ID 10 vs. 11", logger.LastFormattedString);
+            Assert.Equal(LogLevel.Warning, logger.LastLogLevel);
+            Assert.Equal(1, logger.CallCount);
+            Assert.Equal(11, logger.LastEventId.Id);
         }
 
         [Fact]
@@ -343,6 +367,81 @@ public void EventNameTests()
             Assert.Equal(LogLevel.Trace, logger.LastLogLevel);
             Assert.Equal(1, logger.CallCount);
             Assert.Equal("CustomEventName", logger.LastEventId.Name);
+
+            logger.Reset();
+            EventNameTestExtensions.CustomEventName(logger);
+            Assert.Null(logger.LastException);
+            Assert.Equal("CustomEventName", logger.LastFormattedString);
+            Assert.Equal(LogLevel.Trace, logger.LastLogLevel);
+            Assert.Equal(1, logger.CallCount);
+            Assert.Equal("CustomEventName", logger.LastEventId.Name);
+        }
+
+        [Fact]
+        public void SkipEnabledCheckTests()
+        {
+            var logger = new MockLogger();
+
+            logger.Reset();
+            logger.Enabled = false;
+            Assert.False(logger.IsEnabled(LogLevel.Information));
+            SkipEnabledCheckExtensions.LoggerMethodWithFalseSkipEnabledCheck(logger);
+            Assert.Null(logger.LastException);
+            Assert.Null(logger.LastFormattedString);
+            Assert.Equal((LogLevel)(-1), logger.LastLogLevel);
+            Assert.Equal(0, logger.CallCount);
+            Assert.Equal(default, logger.LastEventId);
+
+            logger.Reset();
+            logger.Enabled = false;
+            Assert.False(logger.IsEnabled(LogLevel.Debug));
+            SkipEnabledCheckExtensions.LoggerMethodWithTrueSkipEnabledCheck(logger);
+            Assert.Null(logger.LastException);
+            Assert.Equal("Message: When using SkipEnabledCheck, the generated code skips logger.IsEnabled(logLevel) check before calling log. To be used when consumer has already guarded logger method in an IsEnabled check.", logger.LastFormattedString);
+            Assert.Equal(LogLevel.Debug, logger.LastLogLevel);
+            Assert.Equal(1, logger.CallCount);
+            Assert.Equal("LoggerMethodWithTrueSkipEnabledCheck", logger.LastEventId.Name);
+        }
+
+        [Fact]
+        public void NestedClassTests()
+        {
+            var logger = new MockLogger();
+
+            logger.Reset();
+            NestedClassTestsExtensions<ABC>.NestedMiddleParentClass.NestedClass.M8(logger);
+            Assert.Null(logger.LastException);
+            Assert.Equal("M8", logger.LastFormattedString);
+            Assert.Equal(LogLevel.Debug, logger.LastLogLevel);
+            Assert.Equal(1, logger.CallCount);
+
+            logger.Reset();
+            NonStaticNestedClassTestsExtensions<ABC>.NonStaticNestedMiddleParentClass.NestedClass.M9(logger);
+            Assert.Null(logger.LastException);
+            Assert.Equal("M9", logger.LastFormattedString);
+            Assert.Equal(LogLevel.Debug, logger.LastLogLevel);
+            Assert.Equal(1, logger.CallCount);
+
+            logger.Reset();
+            NestedStruct.Logger.M10(logger);
+            Assert.Null(logger.LastException);
+            Assert.Equal("M10", logger.LastFormattedString);
+            Assert.Equal(LogLevel.Debug, logger.LastLogLevel);
+            Assert.Equal(1, logger.CallCount);
+
+            logger.Reset();
+            NestedRecord.Logger.M11(logger);
+            Assert.Null(logger.LastException);
+            Assert.Equal("M11", logger.LastFormattedString);
+            Assert.Equal(LogLevel.Debug, logger.LastLogLevel);
+            Assert.Equal(1, logger.CallCount);
+
+            logger.Reset();
+            MultiLevelNestedClass.NestedStruct.NestedRecord.Logger.M12(logger);
+            Assert.Null(logger.LastException);
+            Assert.Equal("M12", 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 d727420f52a291..917d87cd127f1e 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
@@ -35,17 +35,51 @@ public async Task TestEmitter()
         }
 
         [Fact]
-        public async Task TestBaseline_TestWithTwoParams_Success()
+        public async Task TestBaseline_TestWithSkipEnabledCheck_Success()
         {
             string testSourceCode = @"
 namespace Microsoft.Extensions.Logging.Generators.Tests.TestClasses
 {
-    internal static partial class TestWithTwoParams
+    internal static partial class TestWithSkipEnabledCheck
     {
-        [LoggerMessage(EventId = 0, Level = LogLevel.Error, Message = ""M0 {a1} {a2}"")]
-        public static partial void M0(ILogger logger, int a1, System.Collections.Generic.IEnumerable<int> a2);
+        [LoggerMessage(EventId = 0, Level = LogLevel.Information, Message = ""Message: When using SkipEnabledCheck, the generated code skips logger.IsEnabled(logLevel) check before calling log. To be used when consumer has already guarded logger method in an IsEnabled check."", SkipEnabledCheck = true)]
+        public static partial void M0(ILogger logger);
     }
 }";
+            await VerifyAgainstBaselineUsingFile("TestWithSkipEnabledCheck.generated.txt", testSourceCode);
+        }
+
+        [Fact]
+        public async Task TestBaseline_TestWithDefaultValues_Success()
+        {
+            string testSourceCode = @"
+namespace Microsoft.Extensions.Logging.Generators.Tests.TestClasses
+{
+    internal static partial class TestWithDefaultValues
+    {
+        [LoggerMessage]
+        public static partial void M0(ILogger logger, LogLevel level);
+    }
+}";
+            await VerifyAgainstBaselineUsingFile("TestWithDefaultValues.generated.txt", testSourceCode);
+        }
+
+        [Theory]
+        [InlineData("EventId = 0, Level = LogLevel.Error, Message = \"M0 {a1} {a2}\"")]
+        [InlineData("eventId: 0, level: LogLevel.Error, message: \"M0 {a1} {a2}\"")]
+        [InlineData("0, LogLevel.Error, \"M0 {a1} {a2}\"")]
+        [InlineData("0, LogLevel.Error, \"M0 {a1} {a2}\", SkipEnabledCheck = false")]
+        public async Task TestBaseline_TestWithTwoParams_Success(string argumentList)
+        {
+            string testSourceCode = $@"
+namespace Microsoft.Extensions.Logging.Generators.Tests.TestClasses
+{{
+    internal static partial class TestWithTwoParams
+    {{
+        [LoggerMessage({argumentList})]
+        public static partial void M0(ILogger logger, int a1, System.Collections.Generic.IEnumerable<int> a2);
+    }}
+}}";
             await VerifyAgainstBaselineUsingFile("TestWithTwoParams.generated.txt", testSourceCode);
         }
 
@@ -80,6 +114,41 @@ internal static partial class TestWithDynamicLogLevel
             await VerifyAgainstBaselineUsingFile("TestWithDynamicLogLevel.generated.txt", testSourceCode);
         }
 
+        [Fact]
+        public async Task TestBaseline_TestWithNestedClass_Success()
+        {
+            string testSourceCode = @"
+namespace Microsoft.Extensions.Logging.Generators.Tests.TestClasses
+{
+    namespace NestedNamespace
+    {
+        public static partial class MultiLevelNestedClass
+        {
+            public partial struct NestedStruct
+            {
+                internal partial record NestedRecord(string Name, string Address)
+                { 
+                    internal static partial class NestedClassTestsExtensions<T1> where T1 : Class1
+                    {
+                        internal static partial class NestedMiddleParentClass
+                        {
+                            internal static partial class Nested<T2> where T2 : Class2
+                            {
+                                [LoggerMessage(EventId = 9, Level = LogLevel.Debug, Message = ""M9"")]
+                                public static partial void M9(ILogger logger);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        internal class Class1 { }
+        internal class Class2 { }
+    }
+}";
+            await VerifyAgainstBaselineUsingFile("TestWithNestedClass.generated.txt", testSourceCode);
+        }
+
         private async Task VerifyAgainstBaselineUsingFile(string filename, string testSourceCode)
         {
             string[] expectedLines = await File.ReadAllLinesAsync(Path.Combine("Baselines", filename)).ConfigureAwait(false);
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 e3e62f72b10cf7..8e5df4972cf9a1 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
@@ -64,6 +64,90 @@ static partial void M1(ILogger logger)
             Assert.Equal(DiagnosticDescriptors.LoggingMethodHasBody.Id, diagnostics[0].Id);
         }
 
+        [Theory]
+        [InlineData("EventId = 0, Level = null, Message = \"This is a message with {foo}\"")]
+        [InlineData("eventId: 0, level: null, message: \"This is a message with {foo}\"")]
+        [InlineData("0, null, \"This is a message with {foo}\"")]
+        public async Task WithNullLevel_GeneratorWontFail(string argumentList)
+        {
+            IReadOnlyList<Diagnostic> diagnostics = await RunGenerator($@"
+                partial class C
+                {{
+                    [LoggerMessage({argumentList})]
+                    static partial void M1(ILogger logger, string foo);
+                    
+                    [LoggerMessage({argumentList})]
+                    static partial void M2(ILogger logger, LogLevel level, string foo);
+                }}
+            ");
+
+            Assert.Empty(diagnostics);
+        }
+
+        [Theory]
+        [InlineData("EventId = null, Level = LogLevel.Debug, Message = \"This is a message with {foo}\"")]
+        [InlineData("eventId: null, level: LogLevel.Debug, message: \"This is a message with {foo}\"")]
+        [InlineData("null, LogLevel.Debug, \"This is a message with {foo}\"")]
+        public async Task WithNullEventId_GeneratorWontFail(string argumentList)
+        {
+            IReadOnlyList<Diagnostic> diagnostics = await RunGenerator($@"
+                partial class C
+                {{
+                    [LoggerMessage({argumentList})]
+                    static partial void M1(ILogger logger, string foo);
+                }}
+            ");
+
+            Assert.Empty(diagnostics);
+        }
+
+        [Fact]
+        public async Task WithNullMessage_GeneratorWontFail()
+        {
+            IReadOnlyList<Diagnostic> diagnostics = await RunGenerator(@"
+                partial class C
+                {
+                    [LoggerMessage(EventId = 0, Level = LogLevel.Debug, Message = null)]
+                    static partial void M1(ILogger logger, string foo);
+                }
+            ");
+
+            Assert.Single(diagnostics);
+            Assert.Equal(DiagnosticDescriptors.ArgumentHasNoCorrespondingTemplate.Id, diagnostics[0].Id);
+            Assert.Contains("Argument 'foo' is not referenced from the logging message", diagnostics[0].GetMessage(), StringComparison.InvariantCulture);
+        }
+
+        [Fact]
+        public async Task WithNullSkipEnabledCheck_GeneratorWontFail()
+        {
+            IReadOnlyList<Diagnostic> diagnostics = await RunGenerator(@"
+                partial class C
+                {
+                    [LoggerMessage(EventId = 0, Level = LogLevel.Debug, Message = ""This is a message with {foo}"", SkipEnabledCheck = null)]
+                    static partial void M1(ILogger logger, string foo);
+                }
+            ");
+
+            Assert.Empty(diagnostics);
+        }
+
+        [Fact]
+        public async Task WithBadMisconfiguredInput_GeneratorWontFail()
+        {
+            IReadOnlyList<Diagnostic> diagnostics = await RunGenerator(@"
+                public static partial class C
+                {
+                    [LoggerMessage(SkipEnabledCheck = 6)]
+                    public static partial void M0(ILogger logger, LogLevel level);
+
+                    [LoggerMessage(eventId: true, level: LogLevel.Debug, message: ""misconfigured eventId as bool"")]
+                    public static partial void M1(ILogger logger);
+                }
+            ");
+
+            Assert.Empty(diagnostics);
+        }
+
         [Fact]
         public async Task MissingTemplate()
         {
@@ -93,6 +177,7 @@ partial class C
 
             Assert.Single(diagnostics);
             Assert.Equal(DiagnosticDescriptors.TemplateHasNoCorrespondingArgument.Id, diagnostics[0].Id);
+            Assert.Contains("Template 'foo' is not provided as argument to the logging method", diagnostics[0].GetMessage(), StringComparison.InvariantCulture);
         }
 
         [Fact]
@@ -249,7 +334,7 @@ partial class C
         }
 
         [Fact]
-        public async Task NestedType()
+        public async Task NestedTypeOK()
         {
             IReadOnlyList<Diagnostic> diagnostics = await RunGenerator(@"
                 partial class C
@@ -262,8 +347,27 @@ public partial class Nested
                 }
             ");
 
-            Assert.Single(diagnostics);
-            Assert.Equal(DiagnosticDescriptors.LoggingMethodInNestedType.Id, diagnostics[0].Id);
+            Assert.Empty(diagnostics);
+        }
+
+        [Theory]
+        [InlineData("false")]
+        [InlineData("true")]
+        [InlineData("null")]
+        public async Task UsingSkipEnabledCheck(string skipEnabledCheckValue)
+        {
+            IReadOnlyList<Diagnostic> diagnostics = await RunGenerator($@"
+                partial class C
+                {{
+                    public partial class WithLoggerMethodUsingSkipEnabledCheck
+                    {{
+                        [LoggerMessage(EventId = 0, Level = LogLevel.Debug, Message = ""M1"", SkipEnabledCheck = {skipEnabledCheckValue})]
+                        static partial void M1(ILogger logger);
+                    }}
+                }}
+            ");
+
+            Assert.Empty(diagnostics);
         }
 
         [Fact]
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/TestClasses/EventNameTestExtensions.cs b/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/TestClasses/EventNameTestExtensions.cs
index 4c0ddf320aabf4..f41d615d04314a 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/TestClasses/EventNameTestExtensions.cs
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/TestClasses/EventNameTestExtensions.cs
@@ -7,5 +7,8 @@ internal static partial class EventNameTestExtensions
     {
         [LoggerMessage(EventId = 0, Level = LogLevel.Trace, Message = "M0", EventName = "CustomEventName")]
         public static partial void M0(ILogger logger);
+
+        [LoggerMessage(EventId = 2, Level = LogLevel.Trace, Message = "CustomEventName")] // EventName inferred from method name
+        public static partial void CustomEventName(ILogger logger);
     }
 }
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/TestClasses/LevelTestExtensions.cs b/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/TestClasses/LevelTestExtensions.cs
index 5726aa02a4c3fe..2251d198a2af29 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/TestClasses/LevelTestExtensions.cs
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/TestClasses/LevelTestExtensions.cs
@@ -34,5 +34,8 @@ internal static partial class LevelTestExtensions
 
         [LoggerMessage(EventId = 9, Message = "M9")]
         public static partial void M9(LogLevel level, ILogger logger);
+
+        [LoggerMessage(eventId: 10, level: LogLevel.Warning, message: "event ID 10 vs. 11", EventId = 11)]
+        public static partial void M10vs11(ILogger logger);
     }
 }
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/TestClasses/MessageTestExtensions.cs b/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/TestClasses/MessageTestExtensions.cs
index a30849288b53b4..8cad8db64cd9de 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/TestClasses/MessageTestExtensions.cs
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/TestClasses/MessageTestExtensions.cs
@@ -29,5 +29,11 @@ internal static partial class MessageTestExtensions
         [LoggerMessage(EventId = 4, Level = LogLevel.Debug, Message = "{p1}")]
         public static partial void M4(ILogger logger, string p1, int p2, int p3);
 #endif
+
+        [LoggerMessage]
+        public static partial void M5(ILogger logger, LogLevel level);
+
+        [LoggerMessage(EventId = 6, Message = "")]
+        public static partial void M6(ILogger logger, LogLevel level);
     }
 }
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/TestClasses/NestedClassTestsExtensions.cs b/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/TestClasses/NestedClassTestsExtensions.cs
new file mode 100644
index 00000000000000..4b5b6cdbf90a26
--- /dev/null
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/TestClasses/NestedClassTestsExtensions.cs
@@ -0,0 +1,63 @@
+// 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 NestedClassTestsExtensions<T> where T : ABC
+    {
+        internal static partial class NestedMiddleParentClass
+        {
+            internal static partial class NestedClass
+            {
+                [LoggerMessage(EventId = 8, Level = LogLevel.Debug, Message = "M8")]
+                public static partial void M8(ILogger logger);
+            }
+        }
+    }
+    
+    internal partial class NonStaticNestedClassTestsExtensions<T> where T : ABC
+    {
+        internal partial class NonStaticNestedMiddleParentClass
+        {
+            internal static partial class NestedClass
+            {
+                [LoggerMessage(EventId = 9, Level = LogLevel.Debug, Message = "M9")]
+                public static partial void M9(ILogger logger);
+            }
+        }
+    }
+    public class ABC {}
+
+    public partial struct NestedStruct
+    {
+        internal static partial class Logger
+        {
+            [LoggerMessage(EventId = 10, Level = LogLevel.Debug, Message = "M10")]
+            public static partial void M10(ILogger logger);
+        }
+    }
+
+    public partial record NestedRecord(string Name, string Address)
+    {
+        internal static partial class Logger
+        {
+            [LoggerMessage(EventId = 11, Level = LogLevel.Debug, Message = "M11")]
+            public static partial void M11(ILogger logger);
+        }
+    }
+
+    public static partial class MultiLevelNestedClass
+    {
+        public partial struct NestedStruct
+        {
+            internal partial record NestedRecord(string Name, string Address)
+            {
+                internal static partial class Logger
+                {
+                    [LoggerMessage(EventId = 12, Level = LogLevel.Debug, Message = "M12")]
+                    public static partial void M12(ILogger logger);
+                }
+            }
+        }
+    }
+}
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/TestClasses/SkipEnabledCheckExtensions.cs b/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/TestClasses/SkipEnabledCheckExtensions.cs
new file mode 100644
index 00000000000000..397acdf080ca4e
--- /dev/null
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/TestClasses/SkipEnabledCheckExtensions.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 Microsoft.Extensions.Logging.Generators.Tests.TestClasses
+{
+    internal static partial class SkipEnabledCheckExtensions
+    {
+        [LoggerMessage(EventId = 0, Level = LogLevel.Debug, Message = "Message: When using SkipEnabledCheck, the generated code skips logger.IsEnabled(logLevel) check before calling log. To be used when consumer has already guarded logger method in an IsEnabled check.", SkipEnabledCheck = true)]
+        internal static partial void LoggerMethodWithTrueSkipEnabledCheck(ILogger logger);
+
+        [LoggerMessage(EventId = 1, Level = LogLevel.Information, Message = "M1", SkipEnabledCheck = false)]
+        internal static partial void LoggerMethodWithFalseSkipEnabledCheck(ILogger logger);
+    }
+}
\ No newline at end of file
diff --git a/src/libraries/Microsoft.Extensions.Logging.Configuration/ref/Microsoft.Extensions.Logging.Configuration.cs b/src/libraries/Microsoft.Extensions.Logging.Configuration/ref/Microsoft.Extensions.Logging.Configuration.cs
index a152a0a71c8e5e..224bf6d42372c1 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Configuration/ref/Microsoft.Extensions.Logging.Configuration.cs
+++ b/src/libraries/Microsoft.Extensions.Logging.Configuration/ref/Microsoft.Extensions.Logging.Configuration.cs
@@ -23,7 +23,8 @@ public partial interface ILoggerProviderConfiguration<T>
     }
     public static partial class LoggerProviderOptions
     {
-        public static void RegisterProviderOptions<TOptions, TProvider>(Microsoft.Extensions.DependencyInjection.IServiceCollection services) where TOptions : class { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("TOptions's dependent types may have their members trimmed. Ensure all required members are preserved.")]
+        public static void RegisterProviderOptions<[System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.All)] TOptions, TProvider>(Microsoft.Extensions.DependencyInjection.IServiceCollection services) where TOptions : class { }
     }
     public partial class LoggerProviderOptionsChangeTokenSource<TOptions, TProvider> : Microsoft.Extensions.Options.ConfigurationChangeTokenSource<TOptions>
     {
diff --git a/src/libraries/Microsoft.Extensions.Logging.Configuration/ref/Microsoft.Extensions.Logging.Configuration.csproj b/src/libraries/Microsoft.Extensions.Logging.Configuration/ref/Microsoft.Extensions.Logging.Configuration.csproj
index 880386c22985d2..96453d7f665eda 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Configuration/ref/Microsoft.Extensions.Logging.Configuration.csproj
+++ b/src/libraries/Microsoft.Extensions.Logging.Configuration/ref/Microsoft.Extensions.Logging.Configuration.csproj
@@ -4,6 +4,9 @@
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="Microsoft.Extensions.Logging.Configuration.cs" />
+    <Compile Include="$(CoreLibSharedDir)System\Diagnostics\CodeAnalysis\DynamicallyAccessedMembersAttribute.cs" />
+    <Compile Include="$(CoreLibSharedDir)System\Diagnostics\CodeAnalysis\DynamicallyAccessedMemberTypes.cs" />
+    <Compile Include="$(CoreLibSharedDir)System\Diagnostics\CodeAnalysis\RequiresUnreferencedCodeAttribute.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="$(LibrariesProjectRoot)Microsoft.Extensions.Configuration.Abstractions\ref\Microsoft.Extensions.Configuration.Abstractions.csproj" />
diff --git a/src/libraries/Microsoft.Extensions.Logging.Configuration/src/LoggerProviderConfigurationExtensions.cs b/src/libraries/Microsoft.Extensions.Logging.Configuration/src/LoggerProviderConfigurationExtensions.cs
index f8673b8615917a..3cbbbd60667263 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Configuration/src/LoggerProviderConfigurationExtensions.cs
+++ b/src/libraries/Microsoft.Extensions.Logging.Configuration/src/LoggerProviderConfigurationExtensions.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.CodeAnalysis;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.DependencyInjection.Extensions;
 using Microsoft.Extensions.Options;
@@ -12,13 +13,16 @@ namespace Microsoft.Extensions.Logging.Configuration
     /// </summary>
     public static class LoggerProviderOptions
     {
+        internal const string TrimmingRequiresUnreferencedCodeMessage = "TOptions's dependent types may have their members trimmed. Ensure all required members are preserved.";
+
         /// <summary>
         /// Indicates that settings for <typeparamref name="TProvider"/> should be loaded into <typeparamref name="TOptions"/> type.
         /// </summary>
         /// <param name="services">The <see cref="IServiceCollection"/> to register on.</param>
         /// <typeparam name="TOptions">The options class </typeparam>
         /// <typeparam name="TProvider">The provider class</typeparam>
-        public static void RegisterProviderOptions<TOptions, TProvider>(IServiceCollection services) where TOptions : class
+        [RequiresUnreferencedCode(TrimmingRequiresUnreferencedCodeMessage)]
+        public static void RegisterProviderOptions<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] TOptions, TProvider>(IServiceCollection services) where TOptions : class
         {
             services.TryAddEnumerable(ServiceDescriptor.Singleton<IConfigureOptions<TOptions>, LoggerProviderConfigureOptions<TOptions, TProvider>>());
             services.TryAddEnumerable(ServiceDescriptor.Singleton<IOptionsChangeTokenSource<TOptions>, LoggerProviderOptionsChangeTokenSource<TOptions, TProvider>>());
diff --git a/src/libraries/Microsoft.Extensions.Logging.Configuration/src/LoggerProviderConfigureOptions.cs b/src/libraries/Microsoft.Extensions.Logging.Configuration/src/LoggerProviderConfigureOptions.cs
index 1510cc53770e02..c7e83445baaef6 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Configuration/src/LoggerProviderConfigureOptions.cs
+++ b/src/libraries/Microsoft.Extensions.Logging.Configuration/src/LoggerProviderConfigureOptions.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.CodeAnalysis;
 using Microsoft.Extensions.Options;
 
 namespace Microsoft.Extensions.Logging.Configuration
@@ -8,8 +9,9 @@ namespace Microsoft.Extensions.Logging.Configuration
     /// <summary>
     /// Loads settings for <typeparamref name="TProvider"/> into <typeparamref name="TOptions"/> type.
     /// </summary>
-    internal sealed class LoggerProviderConfigureOptions<TOptions, TProvider> : ConfigureFromConfigurationOptions<TOptions> where TOptions : class
+    internal sealed class LoggerProviderConfigureOptions<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] TOptions, TProvider> : ConfigureFromConfigurationOptions<TOptions> where TOptions : class
     {
+        [RequiresUnreferencedCode(LoggerProviderOptions.TrimmingRequiresUnreferencedCodeMessage)]
         public LoggerProviderConfigureOptions(ILoggerProviderConfiguration<TProvider> providerConfiguration)
             : base(providerConfiguration.Configuration)
         {
diff --git a/src/libraries/Microsoft.Extensions.Logging.Configuration/src/Microsoft.Extensions.Logging.Configuration.csproj b/src/libraries/Microsoft.Extensions.Logging.Configuration/src/Microsoft.Extensions.Logging.Configuration.csproj
index 387ecfe46af42c..976be509012be6 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Configuration/src/Microsoft.Extensions.Logging.Configuration.csproj
+++ b/src/libraries/Microsoft.Extensions.Logging.Configuration/src/Microsoft.Extensions.Logging.Configuration.csproj
@@ -10,6 +10,9 @@
     <Compile Include="$(CommonPath)\Extensions\ProviderAliasUtilities\ProviderAliasUtilities.cs"
              Link="Common\Extensions\ProviderAliasUtilities\ProviderAliasUtilities.cs" />
     <Compile Include="$(CoreLibSharedDir)System\Diagnostics\CodeAnalysis\UnconditionalSuppressMessageAttribute.cs" />
+    <Compile Include="$(CoreLibSharedDir)System\Diagnostics\CodeAnalysis\DynamicallyAccessedMembersAttribute.cs" />
+    <Compile Include="$(CoreLibSharedDir)System\Diagnostics\CodeAnalysis\DynamicallyAccessedMemberTypes.cs" />
+    <Compile Include="$(CoreLibSharedDir)System\Diagnostics\CodeAnalysis\RequiresUnreferencedCodeAttribute.cs" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/src/libraries/Microsoft.Extensions.Logging.Console/ref/Microsoft.Extensions.Logging.Console.cs b/src/libraries/Microsoft.Extensions.Logging.Console/ref/Microsoft.Extensions.Logging.Console.cs
index 4cca93a0012af4..d9ffb2dc19c536 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Console/ref/Microsoft.Extensions.Logging.Console.cs
+++ b/src/libraries/Microsoft.Extensions.Logging.Console/ref/Microsoft.Extensions.Logging.Console.cs
@@ -11,8 +11,10 @@ public static partial class ConsoleLoggerExtensions
     {
         public static Microsoft.Extensions.Logging.ILoggingBuilder AddConsole(this Microsoft.Extensions.Logging.ILoggingBuilder builder) { throw null; }
         public static Microsoft.Extensions.Logging.ILoggingBuilder AddConsole(this Microsoft.Extensions.Logging.ILoggingBuilder builder, System.Action<Microsoft.Extensions.Logging.Console.ConsoleLoggerOptions> configure) { throw null; }
-        public static Microsoft.Extensions.Logging.ILoggingBuilder AddConsoleFormatter<[System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembersAttribute(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicConstructors)] TFormatter, TOptions>(this Microsoft.Extensions.Logging.ILoggingBuilder builder) where TFormatter : Microsoft.Extensions.Logging.Console.ConsoleFormatter where TOptions : Microsoft.Extensions.Logging.Console.ConsoleFormatterOptions { throw null; }
-        public static Microsoft.Extensions.Logging.ILoggingBuilder AddConsoleFormatter<[System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembersAttribute(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicConstructors)] TFormatter, TOptions>(this Microsoft.Extensions.Logging.ILoggingBuilder builder, System.Action<TOptions> configure) where TFormatter : Microsoft.Extensions.Logging.Console.ConsoleFormatter where TOptions : Microsoft.Extensions.Logging.Console.ConsoleFormatterOptions { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("TOptions's dependent types may have their members trimmed. Ensure all required members are preserved.")]
+        public static Microsoft.Extensions.Logging.ILoggingBuilder AddConsoleFormatter<[System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembersAttribute(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicConstructors)] TFormatter, [System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.All)] TOptions>(this Microsoft.Extensions.Logging.ILoggingBuilder builder) where TFormatter : Microsoft.Extensions.Logging.Console.ConsoleFormatter where TOptions : Microsoft.Extensions.Logging.Console.ConsoleFormatterOptions { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("TOptions's dependent types may have their members trimmed. Ensure all required members are preserved.")]
+        public static Microsoft.Extensions.Logging.ILoggingBuilder AddConsoleFormatter<[System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembersAttribute(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicConstructors)] TFormatter, [System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.All)] TOptions>(this Microsoft.Extensions.Logging.ILoggingBuilder builder, System.Action<TOptions> configure) where TFormatter : Microsoft.Extensions.Logging.Console.ConsoleFormatter where TOptions : Microsoft.Extensions.Logging.Console.ConsoleFormatterOptions { throw null; }
         public static Microsoft.Extensions.Logging.ILoggingBuilder AddJsonConsole(this Microsoft.Extensions.Logging.ILoggingBuilder builder) { throw null; }
         public static Microsoft.Extensions.Logging.ILoggingBuilder AddJsonConsole(this Microsoft.Extensions.Logging.ILoggingBuilder builder, System.Action<Microsoft.Extensions.Logging.Console.JsonConsoleFormatterOptions> configure) { throw null; }
         public static Microsoft.Extensions.Logging.ILoggingBuilder AddSimpleConsole(this Microsoft.Extensions.Logging.ILoggingBuilder builder) { throw null; }
diff --git a/src/libraries/Microsoft.Extensions.Logging.Console/ref/Microsoft.Extensions.Logging.Console.csproj b/src/libraries/Microsoft.Extensions.Logging.Console/ref/Microsoft.Extensions.Logging.Console.csproj
index 41c181ec7a7d01..765b78729358e5 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Console/ref/Microsoft.Extensions.Logging.Console.csproj
+++ b/src/libraries/Microsoft.Extensions.Logging.Console/ref/Microsoft.Extensions.Logging.Console.csproj
@@ -1,13 +1,17 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFrameworks>netstandard2.0;net461</TargetFrameworks>
+    <TargetFrameworks>$(NetCoreAppCurrent);netcoreapp3.1;netstandard2.0;net461</TargetFrameworks>
     <IncludePlatformAttributes>true</IncludePlatformAttributes>
   </PropertyGroup>
 
   <ItemGroup>
     <Compile Include="Microsoft.Extensions.Logging.Console.cs" />
+  </ItemGroup>
+  
+  <ItemGroup Condition="!$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net5.0'))">
     <Compile Include="$(CoreLibSharedDir)System\Diagnostics\CodeAnalysis\DynamicallyAccessedMembersAttribute.cs" />
     <Compile Include="$(CoreLibSharedDir)System\Diagnostics\CodeAnalysis\DynamicallyAccessedMemberTypes.cs" />
+    <Compile Include="$(CoreLibSharedDir)System\Diagnostics\CodeAnalysis\RequiresUnreferencedCodeAttribute.cs" />
   </ItemGroup>
 
   <ItemGroup>
@@ -16,4 +20,16 @@
     <ProjectReference Include="$(LibrariesProjectRoot)Microsoft.Extensions.Logging\ref\Microsoft.Extensions.Logging.csproj" />
     <ProjectReference Include="$(LibrariesProjectRoot)Microsoft.Extensions.Options\ref\Microsoft.Extensions.Options.csproj" />
   </ItemGroup>
+
+  <ItemGroup Condition="'$(TargetFramework)' == '$(NetCoreAppCurrent)'">
+    <Reference Include="netstandard" />
+    <ProjectReference Include="$(LibrariesProjectRoot)System.Diagnostics.Tracing\ref\System.Diagnostics.Tracing.csproj" />
+  </ItemGroup>
+
+  <ItemGroup Condition="'$(TargetFramework)' == 'netcoreapp3.1'">
+    <Reference Include="netstandard" />
+    <Reference Include="System.Diagnostics.Tracing" />
+    <Reference Include="System.Runtime" />
+    <Reference Include="System.Runtime.Extensions" />
+  </ItemGroup>
 </Project>
diff --git a/src/libraries/Microsoft.Extensions.Logging.Console/src/ConsoleLoggerExtensions.cs b/src/libraries/Microsoft.Extensions.Logging.Console/src/ConsoleLoggerExtensions.cs
index 372933b97e3d02..8a91327d95c32c 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Console/src/ConsoleLoggerExtensions.cs
+++ b/src/libraries/Microsoft.Extensions.Logging.Console/src/ConsoleLoggerExtensions.cs
@@ -16,10 +16,15 @@ namespace Microsoft.Extensions.Logging
     [UnsupportedOSPlatform("browser")]
     public static class ConsoleLoggerExtensions
     {
+        internal const string TrimmingRequiresUnreferencedCodeMessage = "TOptions's dependent types may have their members trimmed. Ensure all required members are preserved.";
+
         /// <summary>
         /// Adds a console logger named 'Console' to the factory.
         /// </summary>
         /// <param name="builder">The <see cref="ILoggingBuilder"/> to use.</param>
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
+            Justification = "AddConsoleFormatter and RegisterProviderOptions are only dangerous when the Options type cannot be statically analyzed, but that is not the case here. " +
+            "The DynamicallyAccessedMembers annotations on them will make sure to preserve the right members from the different options objects.")]
         public static ILoggingBuilder AddConsole(this ILoggingBuilder builder)
         {
             builder.AddConfiguration();
@@ -123,7 +128,8 @@ private static ILoggingBuilder AddFormatterWithName(this ILoggingBuilder builder
         /// Adds a custom console logger formatter 'TFormatter' to be configured with options 'TOptions'.
         /// </summary>
         /// <param name="builder">The <see cref="ILoggingBuilder"/> to use.</param>
-        public static ILoggingBuilder AddConsoleFormatter<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] TFormatter, TOptions>(this ILoggingBuilder builder)
+        [RequiresUnreferencedCode(TrimmingRequiresUnreferencedCodeMessage)]
+        public static ILoggingBuilder AddConsoleFormatter<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] TFormatter, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] TOptions>(this ILoggingBuilder builder)
             where TOptions : ConsoleFormatterOptions
             where TFormatter : ConsoleFormatter
         {
@@ -141,7 +147,8 @@ private static ILoggingBuilder AddFormatterWithName(this ILoggingBuilder builder
         /// </summary>
         /// <param name="builder">The <see cref="ILoggingBuilder"/> to use.</param>
         /// <param name="configure">A delegate to configure options 'TOptions' for custom formatter 'TFormatter'.</param>
-        public static ILoggingBuilder AddConsoleFormatter<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] TFormatter, TOptions>(this ILoggingBuilder builder, Action<TOptions> configure)
+        [RequiresUnreferencedCode(TrimmingRequiresUnreferencedCodeMessage)]
+        public static ILoggingBuilder AddConsoleFormatter<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] TFormatter, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] TOptions>(this ILoggingBuilder builder, Action<TOptions> configure)
             where TOptions : ConsoleFormatterOptions
             where TFormatter : ConsoleFormatter
         {
@@ -157,10 +164,11 @@ private static ILoggingBuilder AddFormatterWithName(this ILoggingBuilder builder
     }
 
     [UnsupportedOSPlatform("browser")]
-    internal sealed class ConsoleLoggerFormatterConfigureOptions<TFormatter, TOptions> : ConfigureFromConfigurationOptions<TOptions>
+    internal sealed class ConsoleLoggerFormatterConfigureOptions<TFormatter, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] TOptions> : ConfigureFromConfigurationOptions<TOptions>
         where TOptions : ConsoleFormatterOptions
         where TFormatter : ConsoleFormatter
     {
+        [RequiresUnreferencedCode(ConsoleLoggerExtensions.TrimmingRequiresUnreferencedCodeMessage)]
         public ConsoleLoggerFormatterConfigureOptions(ILoggerProviderConfiguration<ConsoleLoggerProvider> providerConfiguration) :
             base(providerConfiguration.Configuration.GetSection("FormatterOptions"))
         {
diff --git a/src/libraries/Microsoft.Extensions.Logging.Console/src/Microsoft.Extensions.Logging.Console.csproj b/src/libraries/Microsoft.Extensions.Logging.Console/src/Microsoft.Extensions.Logging.Console.csproj
index c9f3ee93875a41..271f495a8dc211 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Console/src/Microsoft.Extensions.Logging.Console.csproj
+++ b/src/libraries/Microsoft.Extensions.Logging.Console/src/Microsoft.Extensions.Logging.Console.csproj
@@ -2,7 +2,6 @@
 
   <PropertyGroup>
     <TargetFrameworks>$(NetCoreAppCurrent);netcoreapp3.1;netstandard2.0;net461</TargetFrameworks>
-    <ExcludeCurrentNetCoreAppFromPackage>true</ExcludeCurrentNetCoreAppFromPackage>
     <EnableDefaultItems>true</EnableDefaultItems>
     <Nullable>annotations</Nullable>
     <DefineConstants>$(DefineConstants);NO_SUPPRESS_GC_TRANSITION</DefineConstants>
@@ -30,9 +29,11 @@
              Link="Common\Interop\Windows\Interop.GetStdHandle.cs" />
   </ItemGroup>
 
-  <ItemGroup Condition="'$(TargetFramework)' != '$(NetCoreAppCurrent)'">
+  <ItemGroup Condition="!$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net5.0'))">
     <Compile Include="$(CoreLibSharedDir)System\Diagnostics\CodeAnalysis\DynamicallyAccessedMembersAttribute.cs" />
     <Compile Include="$(CoreLibSharedDir)System\Diagnostics\CodeAnalysis\DynamicallyAccessedMemberTypes.cs" />
+    <Compile Include="$(CoreLibSharedDir)System\Diagnostics\CodeAnalysis\RequiresUnreferencedCodeAttribute.cs" />
+    <Compile Include="$(CoreLibSharedDir)System\Diagnostics\CodeAnalysis\UnconditionalSuppressMessageAttribute.cs" />
   </ItemGroup>
   
   <ItemGroup Condition="'$(TargetFrameworkIdentifier)' != '.NETCoreApp'">
@@ -59,4 +60,4 @@
     <NETStandardCompatError Include="netcoreapp2.0" Supported="netcoreapp3.1" />
   </ItemGroup>
 
-</Project>
+</Project>
\ No newline at end of file
diff --git a/src/libraries/Microsoft.Extensions.Logging.Console/tests/Microsoft.Extensions.Logging.Console.Tests/ConsoleLoggerExtensionsTests.cs b/src/libraries/Microsoft.Extensions.Logging.Console/tests/Microsoft.Extensions.Logging.Console.Tests/ConsoleLoggerExtensionsTests.cs
index 15fcbf7220d47a..739978be7d069e 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Console/tests/Microsoft.Extensions.Logging.Console.Tests/ConsoleLoggerExtensionsTests.cs
+++ b/src/libraries/Microsoft.Extensions.Logging.Console/tests/Microsoft.Extensions.Logging.Console.Tests/ConsoleLoggerExtensionsTests.cs
@@ -17,7 +17,6 @@
 
 namespace Microsoft.Extensions.Logging.Test
 {
-    [ActiveIssue("https://github.com/dotnet/runtime/issues/49110 ", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
     public class ConsoleLoggerExtensionsTests
     {
         [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsThreadingSupported))]
diff --git a/src/libraries/Microsoft.Extensions.Logging.Console/tests/Microsoft.Extensions.Logging.Console.Tests/ConsoleLoggerTest.cs b/src/libraries/Microsoft.Extensions.Logging.Console/tests/Microsoft.Extensions.Logging.Console.Tests/ConsoleLoggerTest.cs
index 94b3781ca4d49c..ebe9985a245d27 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Console/tests/Microsoft.Extensions.Logging.Console.Tests/ConsoleLoggerTest.cs
+++ b/src/libraries/Microsoft.Extensions.Logging.Console/tests/Microsoft.Extensions.Logging.Console.Tests/ConsoleLoggerTest.cs
@@ -1167,7 +1167,6 @@ public void ConsoleLoggerOptions_InvalidFormat_Throws()
         }
 
         [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsThreadingSupported))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/49110 ", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
         public void ConsoleLoggerOptions_DisableColors_IsReadFromLoggingConfiguration()
         {
             var configuration = new ConfigurationBuilder().AddInMemoryCollection(new[] { new KeyValuePair<string, string>("Console:DisableColors", "true") }).Build();
@@ -1199,7 +1198,6 @@ public void ConsoleLoggerOptions_TimeStampFormat_IsReloaded()
         }
 
         [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsThreadingSupported))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/49110 ", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
         public void ConsoleLoggerOptions_TimeStampFormat_IsReadFromLoggingConfiguration()
         {
             var configuration = new ConfigurationBuilder().AddInMemoryCollection(new[] { new KeyValuePair<string, string>("Console:TimeStampFormat", "yyyyMMddHHmmss") }).Build();
@@ -1245,7 +1243,6 @@ public void ConsoleLoggerOptions_IncludeScopes_IsAppliedToLoggers()
         }
 
         [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsThreadingSupported))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/49110 ", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
         public void ConsoleLoggerOptions_LogAsErrorLevel_IsReadFromLoggingConfiguration()
         {
             var configuration = new ConfigurationBuilder().AddInMemoryCollection(new[] { new KeyValuePair<string, string>("Console:LogToStandardErrorThreshold", "Warning") }).Build();
@@ -1291,7 +1288,6 @@ public void ConsoleLoggerOptions_UseUtcTimestamp_IsAppliedToLoggers()
         }
 
         [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsThreadingSupported))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/49110 ", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
         public void ConsoleLoggerOptions_IncludeScopes_IsReadFromLoggingConfiguration()
         {
             var configuration = new ConfigurationBuilder().AddInMemoryCollection(new[] { new KeyValuePair<string, string>("Console:IncludeScopes", "true") }).Build();
diff --git a/src/libraries/Microsoft.Extensions.Logging.EventSource/ref/Microsoft.Extensions.Logging.EventSource.csproj b/src/libraries/Microsoft.Extensions.Logging.EventSource/ref/Microsoft.Extensions.Logging.EventSource.csproj
index fe5b5ee697d378..99dea9fad13d12 100644
--- a/src/libraries/Microsoft.Extensions.Logging.EventSource/ref/Microsoft.Extensions.Logging.EventSource.csproj
+++ b/src/libraries/Microsoft.Extensions.Logging.EventSource/ref/Microsoft.Extensions.Logging.EventSource.csproj
@@ -1,12 +1,26 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFrameworks>netstandard2.0;net461</TargetFrameworks>
+    <TargetFrameworks>$(NetCoreAppCurrent);netcoreapp3.1;netstandard2.0;net461</TargetFrameworks>
   </PropertyGroup>
+
   <ItemGroup>
     <Compile Include="Microsoft.Extensions.Logging.EventSource.cs" />
   </ItemGroup>
+
   <ItemGroup>
     <ProjectReference Include="$(LibrariesProjectRoot)Microsoft.Extensions.Logging\ref\Microsoft.Extensions.Logging.csproj" />
     <ProjectReference Include="$(LibrariesProjectRoot)Microsoft.Extensions.Logging.Abstractions\ref\Microsoft.Extensions.Logging.Abstractions.csproj" />
   </ItemGroup>
+
+  <ItemGroup Condition="'$(TargetFramework)' == '$(NetCoreAppCurrent)'">
+    <Reference Include="netstandard" />
+    <ProjectReference Include="$(LibrariesProjectRoot)System.Diagnostics.Tracing\ref\System.Diagnostics.Tracing.csproj" />
+  </ItemGroup>
+
+  <ItemGroup Condition="'$(TargetFramework)' == 'netcoreapp3.1'">
+    <Reference Include="netstandard" />
+    <Reference Include="System.Diagnostics.Tracing" />
+    <Reference Include="System.Runtime" />
+  </ItemGroup>
+
 </Project>
diff --git a/src/libraries/Microsoft.Extensions.Logging.EventSource/src/Microsoft.Extensions.Logging.EventSource.csproj b/src/libraries/Microsoft.Extensions.Logging.EventSource/src/Microsoft.Extensions.Logging.EventSource.csproj
index bf3aab8453c9fb..3823f1cfac81d3 100644
--- a/src/libraries/Microsoft.Extensions.Logging.EventSource/src/Microsoft.Extensions.Logging.EventSource.csproj
+++ b/src/libraries/Microsoft.Extensions.Logging.EventSource/src/Microsoft.Extensions.Logging.EventSource.csproj
@@ -2,7 +2,6 @@
 
   <PropertyGroup>
     <TargetFrameworks>$(NetCoreAppCurrent);netcoreapp3.1;netstandard2.0;net461</TargetFrameworks>
-    <ExcludeCurrentNetCoreAppFromPackage>true</ExcludeCurrentNetCoreAppFromPackage>
     <EnableDefaultItems>true</EnableDefaultItems>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <!-- Use targeting pack references instead of granular ones in the project file. -->
diff --git a/src/libraries/Microsoft.Extensions.Options.ConfigurationExtensions/ref/Microsoft.Extensions.Options.ConfigurationExtensions.cs b/src/libraries/Microsoft.Extensions.Options.ConfigurationExtensions/ref/Microsoft.Extensions.Options.ConfigurationExtensions.cs
index 43e04c4327d585..42a11a68afc0d2 100644
--- a/src/libraries/Microsoft.Extensions.Options.ConfigurationExtensions/ref/Microsoft.Extensions.Options.ConfigurationExtensions.cs
+++ b/src/libraries/Microsoft.Extensions.Options.ConfigurationExtensions/ref/Microsoft.Extensions.Options.ConfigurationExtensions.cs
@@ -8,16 +8,23 @@ namespace Microsoft.Extensions.DependencyInjection
 {
     public static partial class OptionsBuilderConfigurationExtensions
     {
-        public static Microsoft.Extensions.Options.OptionsBuilder<TOptions> BindConfiguration<TOptions>(this Microsoft.Extensions.Options.OptionsBuilder<TOptions> optionsBuilder, string configSectionPath, System.Action<Microsoft.Extensions.Configuration.BinderOptions> configureBinder = null) where TOptions : class { throw null; }
-        public static Microsoft.Extensions.Options.OptionsBuilder<TOptions> Bind<TOptions>(this Microsoft.Extensions.Options.OptionsBuilder<TOptions> optionsBuilder, Microsoft.Extensions.Configuration.IConfiguration config) where TOptions : class { throw null; }
-        public static Microsoft.Extensions.Options.OptionsBuilder<TOptions> Bind<TOptions>(this Microsoft.Extensions.Options.OptionsBuilder<TOptions> optionsBuilder, Microsoft.Extensions.Configuration.IConfiguration config, System.Action<Microsoft.Extensions.Configuration.BinderOptions> configureBinder) where TOptions : class { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("TOptions's dependent types may have their members trimmed. Ensure all required members are preserved.")]
+        public static Microsoft.Extensions.Options.OptionsBuilder<TOptions> BindConfiguration<[System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.All)] TOptions>(this Microsoft.Extensions.Options.OptionsBuilder<TOptions> optionsBuilder, string configSectionPath, System.Action<Microsoft.Extensions.Configuration.BinderOptions> configureBinder = null) where TOptions : class { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("TOptions's dependent types may have their members trimmed. Ensure all required members are preserved.")]
+        public static Microsoft.Extensions.Options.OptionsBuilder<TOptions> Bind<[System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.All)] TOptions>(this Microsoft.Extensions.Options.OptionsBuilder<TOptions> optionsBuilder, Microsoft.Extensions.Configuration.IConfiguration config) where TOptions : class { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("TOptions's dependent types may have their members trimmed. Ensure all required members are preserved.")]
+        public static Microsoft.Extensions.Options.OptionsBuilder<TOptions> Bind<[System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.All)] TOptions>(this Microsoft.Extensions.Options.OptionsBuilder<TOptions> optionsBuilder, Microsoft.Extensions.Configuration.IConfiguration config, System.Action<Microsoft.Extensions.Configuration.BinderOptions> configureBinder) where TOptions : class { throw null; }
     }
     public static partial class OptionsConfigurationServiceCollectionExtensions
     {
-        public static Microsoft.Extensions.DependencyInjection.IServiceCollection Configure<TOptions>(this Microsoft.Extensions.DependencyInjection.IServiceCollection services, Microsoft.Extensions.Configuration.IConfiguration config) where TOptions : class { throw null; }
-        public static Microsoft.Extensions.DependencyInjection.IServiceCollection Configure<TOptions>(this Microsoft.Extensions.DependencyInjection.IServiceCollection services, Microsoft.Extensions.Configuration.IConfiguration config, System.Action<Microsoft.Extensions.Configuration.BinderOptions> configureBinder) where TOptions : class { throw null; }
-        public static Microsoft.Extensions.DependencyInjection.IServiceCollection Configure<TOptions>(this Microsoft.Extensions.DependencyInjection.IServiceCollection services, string name, Microsoft.Extensions.Configuration.IConfiguration config) where TOptions : class { throw null; }
-        public static Microsoft.Extensions.DependencyInjection.IServiceCollection Configure<TOptions>(this Microsoft.Extensions.DependencyInjection.IServiceCollection services, string name, Microsoft.Extensions.Configuration.IConfiguration config, System.Action<Microsoft.Extensions.Configuration.BinderOptions> configureBinder) where TOptions : class { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("TOptions's dependent types may have their members trimmed. Ensure all required members are preserved.")]
+        public static Microsoft.Extensions.DependencyInjection.IServiceCollection Configure<[System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.All)] TOptions>(this Microsoft.Extensions.DependencyInjection.IServiceCollection services, Microsoft.Extensions.Configuration.IConfiguration config) where TOptions : class { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("TOptions's dependent types may have their members trimmed. Ensure all required members are preserved.")]
+        public static Microsoft.Extensions.DependencyInjection.IServiceCollection Configure<[System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.All)] TOptions>(this Microsoft.Extensions.DependencyInjection.IServiceCollection services, Microsoft.Extensions.Configuration.IConfiguration config, System.Action<Microsoft.Extensions.Configuration.BinderOptions> configureBinder) where TOptions : class { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("TOptions's dependent types may have their members trimmed. Ensure all required members are preserved.")]
+        public static Microsoft.Extensions.DependencyInjection.IServiceCollection Configure<[System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.All)] TOptions>(this Microsoft.Extensions.DependencyInjection.IServiceCollection services, string name, Microsoft.Extensions.Configuration.IConfiguration config) where TOptions : class { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("TOptions's dependent types may have their members trimmed. Ensure all required members are preserved.")]
+        public static Microsoft.Extensions.DependencyInjection.IServiceCollection Configure<[System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.All)] TOptions>(this Microsoft.Extensions.DependencyInjection.IServiceCollection services, string name, Microsoft.Extensions.Configuration.IConfiguration config, System.Action<Microsoft.Extensions.Configuration.BinderOptions> configureBinder) where TOptions : class { throw null; }
     }
 }
 namespace Microsoft.Extensions.Options
@@ -29,13 +36,16 @@ public ConfigurationChangeTokenSource(string name, Microsoft.Extensions.Configur
         public string Name { get { throw null; } }
         public Microsoft.Extensions.Primitives.IChangeToken GetChangeToken() { throw null; }
     }
-    public partial class ConfigureFromConfigurationOptions<TOptions> : Microsoft.Extensions.Options.ConfigureOptions<TOptions> where TOptions : class
+    public partial class ConfigureFromConfigurationOptions<[System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.All)] TOptions> : Microsoft.Extensions.Options.ConfigureOptions<TOptions> where TOptions : class
     {
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("TOptions's dependent types may have their members trimmed. Ensure all required members are preserved.")]
         public ConfigureFromConfigurationOptions(Microsoft.Extensions.Configuration.IConfiguration config) : base (default(System.Action<TOptions>)) { }
     }
-    public partial class NamedConfigureFromConfigurationOptions<TOptions> : Microsoft.Extensions.Options.ConfigureNamedOptions<TOptions> where TOptions : class
+    public partial class NamedConfigureFromConfigurationOptions<[System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.All)] TOptions> : Microsoft.Extensions.Options.ConfigureNamedOptions<TOptions> where TOptions : class
     {
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("TOptions's dependent types may have their members trimmed. Ensure all required members are preserved.")]
         public NamedConfigureFromConfigurationOptions(string name, Microsoft.Extensions.Configuration.IConfiguration config) : base (default(string), default(System.Action<TOptions>)) { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("TOptions's dependent types may have their members trimmed. Ensure all required members are preserved.")]
         public NamedConfigureFromConfigurationOptions(string name, Microsoft.Extensions.Configuration.IConfiguration config, System.Action<Microsoft.Extensions.Configuration.BinderOptions> configureBinder) : base (default(string), default(System.Action<TOptions>)) { }
     }
 }
diff --git a/src/libraries/Microsoft.Extensions.Options.ConfigurationExtensions/ref/Microsoft.Extensions.Options.ConfigurationExtensions.csproj b/src/libraries/Microsoft.Extensions.Options.ConfigurationExtensions/ref/Microsoft.Extensions.Options.ConfigurationExtensions.csproj
index b28dde039c486c..85bfa45c2696e6 100644
--- a/src/libraries/Microsoft.Extensions.Options.ConfigurationExtensions/ref/Microsoft.Extensions.Options.ConfigurationExtensions.csproj
+++ b/src/libraries/Microsoft.Extensions.Options.ConfigurationExtensions/ref/Microsoft.Extensions.Options.ConfigurationExtensions.csproj
@@ -4,6 +4,9 @@
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="Microsoft.Extensions.Options.ConfigurationExtensions.cs" />
+    <Compile Include="$(CoreLibSharedDir)System\Diagnostics\CodeAnalysis\DynamicallyAccessedMembersAttribute.cs" />
+    <Compile Include="$(CoreLibSharedDir)System\Diagnostics\CodeAnalysis\DynamicallyAccessedMemberTypes.cs" />
+    <Compile Include="$(CoreLibSharedDir)System\Diagnostics\CodeAnalysis\RequiresUnreferencedCodeAttribute.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="$(LibrariesProjectRoot)Microsoft.Extensions.Configuration.Abstractions\ref\Microsoft.Extensions.Configuration.Abstractions.csproj" />
diff --git a/src/libraries/Microsoft.Extensions.Options.ConfigurationExtensions/src/ConfigureFromConfigurationOptions.cs b/src/libraries/Microsoft.Extensions.Options.ConfigurationExtensions/src/ConfigureFromConfigurationOptions.cs
index ac0e09814c6d0b..b9b3d00ee1fba2 100644
--- a/src/libraries/Microsoft.Extensions.Options.ConfigurationExtensions/src/ConfigureFromConfigurationOptions.cs
+++ b/src/libraries/Microsoft.Extensions.Options.ConfigurationExtensions/src/ConfigureFromConfigurationOptions.cs
@@ -2,7 +2,9 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Diagnostics.CodeAnalysis;
 using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
 
 namespace Microsoft.Extensions.Options
 {
@@ -12,20 +14,26 @@ namespace Microsoft.Extensions.Options
     /// Configures an option instance by using <see cref="ConfigurationBinder.Bind(IConfiguration, object)"/> against an <see cref="IConfiguration"/>.
     /// </summary>
     /// <typeparam name="TOptions">The type of options to bind.</typeparam>
-    public class ConfigureFromConfigurationOptions<TOptions> : ConfigureOptions<TOptions>
+    public class ConfigureFromConfigurationOptions<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] TOptions> : ConfigureOptions<TOptions>
         where TOptions : class
     {
         /// <summary>
         /// Constructor that takes the <see cref="IConfiguration"/> instance to bind against.
         /// </summary>
         /// <param name="config">The <see cref="IConfiguration"/> instance.</param>
+        //Even though TOptions is annotated, we need to annotate as RUC as we can't guarantee properties on referenced types are preserved.
+        [RequiresUnreferencedCode(OptionsBuilderConfigurationExtensions.TrimmingRequiredUnreferencedCodeMessage)]
         public ConfigureFromConfigurationOptions(IConfiguration config)
-            : base(options => ConfigurationBinder.Bind(config, options))
+            : base(options => BindFromOptions(options, config))
         {
             if (config == null)
             {
                 throw new ArgumentNullException(nameof(config));
             }
         }
+
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
+            Justification = "The only call to this method is the constructor which is already annotated as RequiresUnreferencedCode.")]
+        private static void BindFromOptions(TOptions options, IConfiguration config) => ConfigurationBinder.Bind(config, options);
     }
 }
diff --git a/src/libraries/Microsoft.Extensions.Options.ConfigurationExtensions/src/ILLink/ILLink.Suppressions.xml b/src/libraries/Microsoft.Extensions.Options.ConfigurationExtensions/src/ILLink/ILLink.Suppressions.xml
deleted file mode 100644
index f9ff691945bc56..00000000000000
--- a/src/libraries/Microsoft.Extensions.Options.ConfigurationExtensions/src/ILLink/ILLink.Suppressions.xml
+++ /dev/null
@@ -1,23 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<linker>
-  <assembly fullname="Microsoft.Extensions.Options.ConfigurationExtensions, Version=6.0.0.0, Culture=neutral, PublicKeyToken=adb9793829ddae60">
-    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
-      <argument>ILLink</argument>
-      <argument>IL2026</argument>
-      <property name="Scope">member</property>
-      <property name="Target">M:Microsoft.Extensions.DependencyInjection.OptionsBuilderConfigurationExtensions.&lt;&gt;c__DisplayClass2_0`1.&lt;BindConfiguration&gt;b__0(`0,Microsoft.Extensions.Configuration.IConfiguration)</property>
-    </attribute>
-    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
-      <argument>ILLink</argument>
-      <argument>IL2026</argument>
-      <property name="Scope">member</property>
-      <property name="Target">M:Microsoft.Extensions.Options.ConfigureFromConfigurationOptions`1.&lt;&gt;c__DisplayClass0_0.&lt;#ctor&gt;b__0(`0)</property>
-    </attribute>
-    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
-      <argument>ILLink</argument>
-      <argument>IL2026</argument>
-      <property name="Scope">member</property>
-      <property name="Target">M:Microsoft.Extensions.Options.NamedConfigureFromConfigurationOptions`1.&lt;&gt;c__DisplayClass1_0.&lt;#ctor&gt;b__0(`0)</property>
-    </attribute>
-  </assembly>
-</linker>
\ No newline at end of file
diff --git a/src/libraries/Microsoft.Extensions.Options.ConfigurationExtensions/src/Microsoft.Extensions.Options.ConfigurationExtensions.csproj b/src/libraries/Microsoft.Extensions.Options.ConfigurationExtensions/src/Microsoft.Extensions.Options.ConfigurationExtensions.csproj
index 822d4706702e25..5d30bfa93e2bc4 100644
--- a/src/libraries/Microsoft.Extensions.Options.ConfigurationExtensions/src/Microsoft.Extensions.Options.ConfigurationExtensions.csproj
+++ b/src/libraries/Microsoft.Extensions.Options.ConfigurationExtensions/src/Microsoft.Extensions.Options.ConfigurationExtensions.csproj
@@ -7,6 +7,11 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <Compile Include="$(CoreLibSharedDir)System\Diagnostics\CodeAnalysis\DynamicallyAccessedMembersAttribute.cs" />
+    <Compile Include="$(CoreLibSharedDir)System\Diagnostics\CodeAnalysis\DynamicallyAccessedMemberTypes.cs" />
+    <Compile Include="$(CoreLibSharedDir)System\Diagnostics\CodeAnalysis\RequiresUnreferencedCodeAttribute.cs" />
+    <Compile Include="$(CoreLibSharedDir)System\Diagnostics\CodeAnalysis\UnconditionalSuppressMessageAttribute.cs" />
+
     <ProjectReference Include="$(LibrariesProjectRoot)Microsoft.Extensions.Configuration.Abstractions\src\Microsoft.Extensions.Configuration.Abstractions.csproj" />
     <ProjectReference Include="$(LibrariesProjectRoot)Microsoft.Extensions.Configuration.Binder\src\Microsoft.Extensions.Configuration.Binder.csproj" />
     <ProjectReference Include="$(LibrariesProjectRoot)Microsoft.Extensions.DependencyInjection.Abstractions\src\Microsoft.Extensions.DependencyInjection.Abstractions.csproj" />
diff --git a/src/libraries/Microsoft.Extensions.Options.ConfigurationExtensions/src/NamedConfigureFromConfigurationOptions.cs b/src/libraries/Microsoft.Extensions.Options.ConfigurationExtensions/src/NamedConfigureFromConfigurationOptions.cs
index c86e799ccfe915..df5b7e4cb92a3f 100644
--- a/src/libraries/Microsoft.Extensions.Options.ConfigurationExtensions/src/NamedConfigureFromConfigurationOptions.cs
+++ b/src/libraries/Microsoft.Extensions.Options.ConfigurationExtensions/src/NamedConfigureFromConfigurationOptions.cs
@@ -2,7 +2,9 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Diagnostics.CodeAnalysis;
 using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
 
 namespace Microsoft.Extensions.Options
 {
@@ -10,7 +12,7 @@ namespace Microsoft.Extensions.Options
     /// Configures an option instance by using <see cref="ConfigurationBinder.Bind(IConfiguration, object)"/> against an <see cref="IConfiguration"/>.
     /// </summary>
     /// <typeparam name="TOptions">The type of options to bind.</typeparam>
-    public class NamedConfigureFromConfigurationOptions<TOptions> : ConfigureNamedOptions<TOptions>
+    public class NamedConfigureFromConfigurationOptions<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] TOptions> : ConfigureNamedOptions<TOptions>
         where TOptions : class
     {
         /// <summary>
@@ -18,6 +20,7 @@ public class NamedConfigureFromConfigurationOptions<TOptions> : ConfigureNamedOp
         /// </summary>
         /// <param name="name">The name of the options instance.</param>
         /// <param name="config">The <see cref="IConfiguration"/> instance.</param>
+        [RequiresUnreferencedCode(OptionsBuilderConfigurationExtensions.TrimmingRequiredUnreferencedCodeMessage)]
         public NamedConfigureFromConfigurationOptions(string name, IConfiguration config)
             : this(name, config, _ => { })
         { }
@@ -28,13 +31,18 @@ public NamedConfigureFromConfigurationOptions(string name, IConfiguration config
         /// <param name="name">The name of the options instance.</param>
         /// <param name="config">The <see cref="IConfiguration"/> instance.</param>
         /// <param name="configureBinder">Used to configure the <see cref="BinderOptions"/>.</param>
+        [RequiresUnreferencedCode(OptionsBuilderConfigurationExtensions.TrimmingRequiredUnreferencedCodeMessage)]
         public NamedConfigureFromConfigurationOptions(string name, IConfiguration config, Action<BinderOptions> configureBinder)
-            : base(name, options => config.Bind(options, configureBinder))
+            : base(name, options => BindFromOptions(options, config, configureBinder))
         {
             if (config == null)
             {
                 throw new ArgumentNullException(nameof(config));
             }
         }
+
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
+            Justification = "The only call to this method is the constructor which is already annotated as RequiresUnreferencedCode.")]
+        private static void BindFromOptions(TOptions options, IConfiguration config, Action<BinderOptions> configureBinder) => config.Bind(options, configureBinder);
     }
 }
diff --git a/src/libraries/Microsoft.Extensions.Options.ConfigurationExtensions/src/OptionsBuilderConfigurationExtensions.cs b/src/libraries/Microsoft.Extensions.Options.ConfigurationExtensions/src/OptionsBuilderConfigurationExtensions.cs
index a102c2b49da4e2..128f0eda38aa4a 100644
--- a/src/libraries/Microsoft.Extensions.Options.ConfigurationExtensions/src/OptionsBuilderConfigurationExtensions.cs
+++ b/src/libraries/Microsoft.Extensions.Options.ConfigurationExtensions/src/OptionsBuilderConfigurationExtensions.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Diagnostics.CodeAnalysis;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Options;
 
@@ -12,6 +13,8 @@ namespace Microsoft.Extensions.DependencyInjection
     /// </summary>
     public static class OptionsBuilderConfigurationExtensions
     {
+        internal const string TrimmingRequiredUnreferencedCodeMessage = "TOptions's dependent types may have their members trimmed. Ensure all required members are preserved.";
+
         /// <summary>
         /// Registers a configuration instance which <typeparamref name="TOptions"/> will bind against.
         /// </summary>
@@ -19,7 +22,8 @@ public static class OptionsBuilderConfigurationExtensions
         /// <param name="optionsBuilder">The options builder to add the services to.</param>
         /// <param name="config">The configuration being bound.</param>
         /// <returns>The <see cref="OptionsBuilder{TOptions}"/> so that additional calls can be chained.</returns>
-        public static OptionsBuilder<TOptions> Bind<TOptions>(this OptionsBuilder<TOptions> optionsBuilder, IConfiguration config) where TOptions : class
+        [RequiresUnreferencedCode(TrimmingRequiredUnreferencedCodeMessage)]
+        public static OptionsBuilder<TOptions> Bind<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] TOptions>(this OptionsBuilder<TOptions> optionsBuilder, IConfiguration config) where TOptions : class
             => optionsBuilder.Bind(config, _ => { });
 
         /// <summary>
@@ -30,7 +34,8 @@ public static OptionsBuilder<TOptions> Bind<TOptions>(this OptionsBuilder<TOptio
         /// <param name="config">The configuration being bound.</param>
         /// <param name="configureBinder">Used to configure the <see cref="BinderOptions"/>.</param>
         /// <returns>The <see cref="OptionsBuilder{TOptions}"/> so that additional calls can be chained.</returns>
-        public static OptionsBuilder<TOptions> Bind<TOptions>(this OptionsBuilder<TOptions> optionsBuilder, IConfiguration config, Action<BinderOptions> configureBinder) where TOptions : class
+        [RequiresUnreferencedCode(TrimmingRequiredUnreferencedCodeMessage)]
+        public static OptionsBuilder<TOptions> Bind<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] TOptions>(this OptionsBuilder<TOptions> optionsBuilder, IConfiguration config, Action<BinderOptions> configureBinder) where TOptions : class
         {
             if (optionsBuilder == null)
             {
@@ -54,7 +59,8 @@ public static OptionsBuilder<TOptions> Bind<TOptions>(this OptionsBuilder<TOptio
         /// <paramref name="optionsBuilder"/> or <paramref name="configSectionPath" /> is <see langword="null"/>.
         /// </exception>
         /// <seealso cref="Bind{TOptions}(OptionsBuilder{TOptions}, IConfiguration, Action{BinderOptions})"/>
-        public static OptionsBuilder<TOptions> BindConfiguration<TOptions>(
+        [RequiresUnreferencedCode(TrimmingRequiredUnreferencedCodeMessage)]
+        public static OptionsBuilder<TOptions> BindConfiguration<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] TOptions>(
             this OptionsBuilder<TOptions> optionsBuilder,
             string configSectionPath,
             Action<BinderOptions> configureBinder = null)
@@ -63,14 +69,19 @@ public static OptionsBuilder<TOptions> BindConfiguration<TOptions>(
             _ = optionsBuilder ?? throw new ArgumentNullException(nameof(optionsBuilder));
             _ = configSectionPath ?? throw new ArgumentNullException(nameof(configSectionPath));
 
-            optionsBuilder.Configure<IConfiguration>((opts, config) =>
-            {
-                IConfiguration section = string.Equals("", configSectionPath, StringComparison.OrdinalIgnoreCase)
-                    ? config
-                    : config.GetSection(configSectionPath);
-                section.Bind(opts, configureBinder);
-            });
+            optionsBuilder.Configure<IConfiguration>((opts, config) => BindFromOptions<TOptions>(opts, config, configSectionPath, configureBinder));
+            optionsBuilder.Services.AddSingleton<IOptionsChangeTokenSource<TOptions>, ConfigurationChangeTokenSource<TOptions>>();
             return optionsBuilder;
         }
+
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
+            Justification = "The only call to this method is in BindConfiguration method which is already annotated as RequiresUnreferencedCode.")]
+        private static void BindFromOptions<TOptions>(TOptions opts, IConfiguration config, string configSectionPath, Action<BinderOptions> configureBinder) where TOptions : class
+        {
+            IConfiguration section = string.Equals("", configSectionPath, StringComparison.OrdinalIgnoreCase)
+                ? config
+                : config.GetSection(configSectionPath);
+            section.Bind(opts, configureBinder);
+        }
     }
 }
diff --git a/src/libraries/Microsoft.Extensions.Options.ConfigurationExtensions/src/OptionsConfigurationServiceCollectionExtensions.cs b/src/libraries/Microsoft.Extensions.Options.ConfigurationExtensions/src/OptionsConfigurationServiceCollectionExtensions.cs
index 9d843cb3a52a02..3606ae73f9a274 100644
--- a/src/libraries/Microsoft.Extensions.Options.ConfigurationExtensions/src/OptionsConfigurationServiceCollectionExtensions.cs
+++ b/src/libraries/Microsoft.Extensions.Options.ConfigurationExtensions/src/OptionsConfigurationServiceCollectionExtensions.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Diagnostics.CodeAnalysis;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Options;
 
@@ -19,7 +20,8 @@ public static class OptionsConfigurationServiceCollectionExtensions
         /// <param name="services">The <see cref="IServiceCollection"/> to add the services to.</param>
         /// <param name="config">The configuration being bound.</param>
         /// <returns>The <see cref="IServiceCollection"/> so that additional calls can be chained.</returns>
-        public static IServiceCollection Configure<TOptions>(this IServiceCollection services, IConfiguration config) where TOptions : class
+        [RequiresUnreferencedCode(OptionsBuilderConfigurationExtensions.TrimmingRequiredUnreferencedCodeMessage)]
+        public static IServiceCollection Configure<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] TOptions>(this IServiceCollection services, IConfiguration config) where TOptions : class
             => services.Configure<TOptions>(Options.Options.DefaultName, config);
 
         /// <summary>
@@ -30,7 +32,8 @@ public static IServiceCollection Configure<TOptions>(this IServiceCollection ser
         /// <param name="name">The name of the options instance.</param>
         /// <param name="config">The configuration being bound.</param>
         /// <returns>The <see cref="IServiceCollection"/> so that additional calls can be chained.</returns>
-        public static IServiceCollection Configure<TOptions>(this IServiceCollection services, string name, IConfiguration config) where TOptions : class
+        [RequiresUnreferencedCode(OptionsBuilderConfigurationExtensions.TrimmingRequiredUnreferencedCodeMessage)]
+        public static IServiceCollection Configure<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] TOptions>(this IServiceCollection services, string name, IConfiguration config) where TOptions : class
             => services.Configure<TOptions>(name, config, _ => { });
 
         /// <summary>
@@ -41,7 +44,8 @@ public static IServiceCollection Configure<TOptions>(this IServiceCollection ser
         /// <param name="config">The configuration being bound.</param>
         /// <param name="configureBinder">Used to configure the <see cref="BinderOptions"/>.</param>
         /// <returns>The <see cref="IServiceCollection"/> so that additional calls can be chained.</returns>
-        public static IServiceCollection Configure<TOptions>(this IServiceCollection services, IConfiguration config, Action<BinderOptions> configureBinder)
+        [RequiresUnreferencedCode(OptionsBuilderConfigurationExtensions.TrimmingRequiredUnreferencedCodeMessage)]
+        public static IServiceCollection Configure<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] TOptions>(this IServiceCollection services, IConfiguration config, Action<BinderOptions> configureBinder)
             where TOptions : class
             => services.Configure<TOptions>(Options.Options.DefaultName, config, configureBinder);
 
@@ -54,7 +58,8 @@ public static IServiceCollection Configure<TOptions>(this IServiceCollection ser
         /// <param name="config">The configuration being bound.</param>
         /// <param name="configureBinder">Used to configure the <see cref="BinderOptions"/>.</param>
         /// <returns>The <see cref="IServiceCollection"/> so that additional calls can be chained.</returns>
-        public static IServiceCollection Configure<TOptions>(this IServiceCollection services, string name, IConfiguration config, Action<BinderOptions> configureBinder)
+        [RequiresUnreferencedCode(OptionsBuilderConfigurationExtensions.TrimmingRequiredUnreferencedCodeMessage)]
+        public static IServiceCollection Configure<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] TOptions>(this IServiceCollection services, string name, IConfiguration config, Action<BinderOptions> configureBinder)
             where TOptions : class
         {
             if (services == null)
diff --git a/src/libraries/Microsoft.Extensions.Options.ConfigurationExtensions/tests/FakeConfigurationProvider.cs b/src/libraries/Microsoft.Extensions.Options.ConfigurationExtensions/tests/FakeConfigurationProvider.cs
new file mode 100644
index 00000000000000..62f25a8d5862ae
--- /dev/null
+++ b/src/libraries/Microsoft.Extensions.Options.ConfigurationExtensions/tests/FakeConfigurationProvider.cs
@@ -0,0 +1,20 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Configuration.Memory;
+
+namespace Microsoft.Extensions.Options.ConfigurationExtensions.Tests
+{
+    internal class FakeConfigurationProvider : MemoryConfigurationProvider, IConfigurationProvider
+    {
+        public FakeConfigurationProvider(MemoryConfigurationSource source)
+            : base(source) { }
+
+        public new void Set(string key, string value)
+        {
+            base.Set(key, value);
+            OnReload();
+        }
+    }
+}
diff --git a/src/libraries/Microsoft.Extensions.Options.ConfigurationExtensions/tests/FakeConfigurationSource.cs b/src/libraries/Microsoft.Extensions.Options.ConfigurationExtensions/tests/FakeConfigurationSource.cs
new file mode 100644
index 00000000000000..512061a3ea75e5
--- /dev/null
+++ b/src/libraries/Microsoft.Extensions.Options.ConfigurationExtensions/tests/FakeConfigurationSource.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 Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Configuration.Memory;
+
+namespace Microsoft.Extensions.Options.ConfigurationExtensions.Tests
+{
+    internal class FakeConfigurationSource : MemoryConfigurationSource, IConfigurationSource
+    {
+        internal IConfigurationProvider Provider { get; private set; } = null!;
+
+        public new IConfigurationProvider Build(IConfigurationBuilder builder)
+        {
+            Provider = new FakeConfigurationProvider(this);
+            return Provider;
+        }
+    }
+}
diff --git a/src/libraries/Microsoft.Extensions.Options.ConfigurationExtensions/tests/OptionsBuidlerConfigurationExtensionsTests.cs b/src/libraries/Microsoft.Extensions.Options.ConfigurationExtensions/tests/OptionsBuidlerConfigurationExtensionsTests.cs
index 0aa34a9650f4a1..9d4764c19c0b40 100644
--- a/src/libraries/Microsoft.Extensions.Options.ConfigurationExtensions/tests/OptionsBuidlerConfigurationExtensionsTests.cs
+++ b/src/libraries/Microsoft.Extensions.Options.ConfigurationExtensions/tests/OptionsBuidlerConfigurationExtensionsTests.cs
@@ -26,7 +26,7 @@ public static void BindConfiguration_ThrowsForNullBuilder()
         public static void BindConfiguration_ThrowsForNullConfigurationSectionPath()
         {
             var services = new ServiceCollection();
-            var optionsBuilder = new OptionsBuilder<FakeOptions>(services, Options.DefaultName);
+            OptionsBuilder<FakeOptions> optionsBuilder = new(services, Options.DefaultName);
             string configSectionPath = null!;
 
             Assert.Throws<ArgumentNullException>("configSectionPath", () =>
@@ -39,9 +39,9 @@ public static void BindConfiguration_ThrowsForNullConfigurationSectionPath()
         public static void BindConfiguration_ReturnsSameBuilderInstance()
         {
             var services = new ServiceCollection();
-            var optionsBuilder = new OptionsBuilder<FakeOptions>(services, Options.DefaultName);
+            OptionsBuilder<FakeOptions> optionsBuilder = new(services, Options.DefaultName);
 
-            var returnedBuilder = optionsBuilder.BindConfiguration("Test");
+            OptionsBuilder<FakeOptions> returnedBuilder = optionsBuilder.BindConfiguration("Test");
 
             Assert.Same(optionsBuilder, returnedBuilder);
         }
@@ -50,7 +50,7 @@ public static void BindConfiguration_ReturnsSameBuilderInstance()
         public static void BindConfiguration_OptionsMaterializationThrowsIfNoConfigurationInDI()
         {
             var services = new ServiceCollection();
-            var optionsBuilder = services.AddOptions<FakeOptions>();
+            OptionsBuilder<FakeOptions> optionsBuilder = services.AddOptions<FakeOptions>();
 
             _ = optionsBuilder.BindConfiguration("Test");
             using ServiceProvider serviceProvider = services.BuildServiceProvider();
@@ -74,12 +74,12 @@ public static void BindConfiguration_UsesConfigurationSectionPath()
             services.AddSingleton<IConfiguration>(new ConfigurationBuilder()
                 .AddInMemoryCollection(configEntries)
                 .Build());
-            var optionsBuilder = services.AddOptions<FakeOptions>();
+            OptionsBuilder<FakeOptions> optionsBuilder = services.AddOptions<FakeOptions>();
 
             _ = optionsBuilder.BindConfiguration(configSectionName);
 
             using ServiceProvider serviceProvider = services.BuildServiceProvider();
-            var options = serviceProvider.GetRequiredService<IOptions<FakeOptions>>().Value;
+            FakeOptions options = serviceProvider.GetRequiredService<IOptions<FakeOptions>>().Value;
 
             Assert.Equal(messageValue, options.Message);
         }
@@ -96,14 +96,86 @@ public static void BindConfiguration_UsesConfigurationRootIfSectionNameIsEmptySt
             services.AddSingleton<IConfiguration>(new ConfigurationBuilder()
                 .AddInMemoryCollection(configEntries)
                 .Build());
-            var optionsBuilder = services.AddOptions<FakeOptions>();
+            OptionsBuilder<FakeOptions> optionsBuilder = services.AddOptions<FakeOptions>();
 
             _ = optionsBuilder.BindConfiguration(configSectionPath: "");
 
             using ServiceProvider serviceProvider = services.BuildServiceProvider();
-            var options = serviceProvider.GetRequiredService<IOptions<FakeOptions>>().Value;
+            FakeOptions options = serviceProvider.GetRequiredService<IOptions<FakeOptions>>().Value;
 
             Assert.Equal(messageValue, options.Message);
         }
+
+        [Fact]
+        public static void BindConfiguration_UpdatesOptionOnConfigurationUpdateWithEmptySectionName()
+        {
+            const string messageValue1 = "This is a test";
+            const string messageValue2 = "This is the message after update";
+
+            FakeConfigurationSource configSource = new()
+            {
+                InitialData = new Dictionary<string, string>
+                {
+                    [nameof(FakeOptions.Message)] = messageValue1,
+                }
+            };
+
+            var services = new ServiceCollection();
+            services.AddSingleton<IConfiguration>(new ConfigurationBuilder()
+                    .Add(configSource)
+                    .Build());
+            OptionsBuilder<FakeOptions> optionsBuilder = services.AddOptions<FakeOptions>();
+            _ = optionsBuilder.BindConfiguration(configSectionPath: "");
+            using ServiceProvider serviceProvider = services.BuildServiceProvider();
+            var optionsMonitor = serviceProvider.GetRequiredService<IOptionsMonitor<FakeOptions>>();
+            bool updateHasRun = false;
+            optionsMonitor.OnChange((opts, name) =>
+            {
+                updateHasRun = true;
+            });
+            FakeOptions optionsValue1 = optionsMonitor.CurrentValue;
+            Assert.Equal(messageValue1, optionsValue1.Message);
+            configSource.Provider.Set(nameof(FakeOptions.Message), messageValue2);
+            FakeOptions optionsValue2 = optionsMonitor.CurrentValue;
+            Assert.True(updateHasRun);
+            Assert.Equal(messageValue2, optionsValue2.Message);
+        }
+
+        [Fact]
+        public static void BindConfiguration_UpdatesOptionOnConfigurationUpdate()
+        {
+            const string configSectionName = "Test";
+            string messageConfigKey = ConfigurationPath.Combine(configSectionName, nameof(FakeOptions.Message));
+            const string messageValue1 = "This is a test";
+            const string messageValue2 = "This is the message after update";
+
+            FakeConfigurationSource configSource = new()
+            {
+                InitialData = new Dictionary<string, string>
+                {
+                    [messageConfigKey] = messageValue1
+                }
+            };
+
+            var services = new ServiceCollection();
+            services.AddSingleton<IConfiguration>(new ConfigurationBuilder()
+                    .Add(configSource)
+                    .Build());
+            OptionsBuilder<FakeOptions> optionsBuilder = services.AddOptions<FakeOptions>();
+            _ = optionsBuilder.BindConfiguration(configSectionName);
+            using ServiceProvider serviceProvider = services.BuildServiceProvider();
+            var optionsMonitor = serviceProvider.GetRequiredService<IOptionsMonitor<FakeOptions>>();
+            bool updateHasRun = false;
+            optionsMonitor.OnChange((opts, name) =>
+            {
+                updateHasRun = true;
+            });
+            FakeOptions optionsValue1 = optionsMonitor.CurrentValue;
+            Assert.Equal(messageValue1, optionsValue1.Message);
+            configSource.Provider.Set(messageConfigKey, messageValue2);
+            FakeOptions optionsValue2 = optionsMonitor.CurrentValue;
+            Assert.True(updateHasRun);
+            Assert.Equal(messageValue2, optionsValue2.Message);
+        }
     }
 }
diff --git a/src/libraries/Microsoft.Extensions.Options/tests/Microsoft.Extensions.Options.Tests/OptionsBuilderTest.cs b/src/libraries/Microsoft.Extensions.Options/tests/Microsoft.Extensions.Options.Tests/OptionsBuilderTest.cs
index 819d80dbf78878..7e00f530ed10a9 100644
--- a/src/libraries/Microsoft.Extensions.Options/tests/Microsoft.Extensions.Options.Tests/OptionsBuilderTest.cs
+++ b/src/libraries/Microsoft.Extensions.Options/tests/Microsoft.Extensions.Options.Tests/OptionsBuilderTest.cs
@@ -12,7 +12,6 @@
 
 namespace Microsoft.Extensions.Options.Tests
 {
-    [ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
     public class OptionsBuilderTest
     {
         [Fact]
diff --git a/src/libraries/Microsoft.Extensions.Options/tests/Microsoft.Extensions.Options.Tests/OptionsFactoryTests.cs b/src/libraries/Microsoft.Extensions.Options/tests/Microsoft.Extensions.Options.Tests/OptionsFactoryTests.cs
index 0c8748dd5c7d77..fb06ea00d52456 100644
--- a/src/libraries/Microsoft.Extensions.Options/tests/Microsoft.Extensions.Options.Tests/OptionsFactoryTests.cs
+++ b/src/libraries/Microsoft.Extensions.Options/tests/Microsoft.Extensions.Options.Tests/OptionsFactoryTests.cs
@@ -7,7 +7,6 @@
 
 namespace Microsoft.Extensions.Options.Tests
 {
-    [ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
     public class OptionsFactoryTest
     {
         [Fact]
diff --git a/src/libraries/Microsoft.Extensions.Options/tests/Microsoft.Extensions.Options.Tests/OptionsMonitorTest.cs b/src/libraries/Microsoft.Extensions.Options/tests/Microsoft.Extensions.Options.Tests/OptionsMonitorTest.cs
index f253d1efd251ad..858b90dccd7ee9 100644
--- a/src/libraries/Microsoft.Extensions.Options/tests/Microsoft.Extensions.Options.Tests/OptionsMonitorTest.cs
+++ b/src/libraries/Microsoft.Extensions.Options/tests/Microsoft.Extensions.Options.Tests/OptionsMonitorTest.cs
@@ -11,7 +11,6 @@
 
 namespace Microsoft.Extensions.Options.Tests
 {
-    [ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
     public class OptionsMonitorTest
     {
         [Fact]
diff --git a/src/libraries/Microsoft.Extensions.Options/tests/Microsoft.Extensions.Options.Tests/OptionsSnapshotTest.cs b/src/libraries/Microsoft.Extensions.Options/tests/Microsoft.Extensions.Options.Tests/OptionsSnapshotTest.cs
index 0dfa2c2095c02f..adb63a5c6913c9 100644
--- a/src/libraries/Microsoft.Extensions.Options/tests/Microsoft.Extensions.Options.Tests/OptionsSnapshotTest.cs
+++ b/src/libraries/Microsoft.Extensions.Options/tests/Microsoft.Extensions.Options.Tests/OptionsSnapshotTest.cs
@@ -10,7 +10,6 @@
 
 namespace Microsoft.Extensions.Options.Tests
 {
-    [ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
     public class OptionsSnapshotTest
     {
         [Fact]
diff --git a/src/libraries/Microsoft.Extensions.Options/tests/Microsoft.Extensions.Options.Tests/OptionsTest.cs b/src/libraries/Microsoft.Extensions.Options/tests/Microsoft.Extensions.Options.Tests/OptionsTest.cs
index 7f5ed8fc052a76..bb76bb9d7fc211 100644
--- a/src/libraries/Microsoft.Extensions.Options/tests/Microsoft.Extensions.Options.Tests/OptionsTest.cs
+++ b/src/libraries/Microsoft.Extensions.Options/tests/Microsoft.Extensions.Options.Tests/OptionsTest.cs
@@ -12,7 +12,6 @@
 
 namespace Microsoft.Extensions.Options.Tests
 {
-    [ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
     public class OptionsTest
     {
         [Fact]
diff --git a/src/libraries/Microsoft.Extensions.Primitives/ref/Microsoft.Extensions.Primitives.csproj b/src/libraries/Microsoft.Extensions.Primitives/ref/Microsoft.Extensions.Primitives.csproj
index 10861efa679855..e6f45298de118f 100644
--- a/src/libraries/Microsoft.Extensions.Primitives/ref/Microsoft.Extensions.Primitives.csproj
+++ b/src/libraries/Microsoft.Extensions.Primitives/ref/Microsoft.Extensions.Primitives.csproj
@@ -1,13 +1,18 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFrameworks>netstandard2.0;netstandard2.1;net461</TargetFrameworks>
+    <TargetFrameworks>$(NetCoreAppCurrent);netcoreapp3.1;netstandard2.0;net461</TargetFrameworks>
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="Microsoft.Extensions.Primitives.cs" />
   </ItemGroup>
-  <ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0' or
-                        '$(TargetFramework)' == 'net461'">
-    <!-- PrivateAssets=all is a workaround to issue: https://github.com/NuGet/Home/issues/10617 -->
+  <ItemGroup Condition="'$(TargetFramework)' == '$(NetCoreAppCurrent)'">
+    <ProjectReference Include="$(LibrariesProjectRoot)System.Runtime\ref\System.Runtime.csproj" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == 'netcoreapp3.1'">
+    <Reference Include="System.Runtime" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(TargetFrameworkIdentifier)' != '.NETCoreApp'">
+    <!-- PrivateAssets=all is a workaround to issue: https://github.com/NuGet/Home/issues/10368. -->
     <PackageReference Include="System.Memory" Version="$(SystemMemoryVersion)" PrivateAssets="all" />
   </ItemGroup>
 </Project>
diff --git a/src/libraries/Microsoft.Extensions.Primitives/src/Microsoft.Extensions.Primitives.csproj b/src/libraries/Microsoft.Extensions.Primitives/src/Microsoft.Extensions.Primitives.csproj
index 3843dc8c292d43..25f981a38034e0 100644
--- a/src/libraries/Microsoft.Extensions.Primitives/src/Microsoft.Extensions.Primitives.csproj
+++ b/src/libraries/Microsoft.Extensions.Primitives/src/Microsoft.Extensions.Primitives.csproj
@@ -3,7 +3,6 @@
     <TargetFrameworks>$(NetCoreAppCurrent);netcoreapp3.1;netstandard2.0;net461</TargetFrameworks>
     <EnableDefaultItems>true</EnableDefaultItems>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ExcludeCurrentNetCoreAppFromPackage>true</ExcludeCurrentNetCoreAppFromPackage>
     <!-- Use targeting pack references instead of granular ones in the project file. -->
     <DisableImplicitAssemblyReferences>false</DisableImplicitAssemblyReferences>
     <PackageDescription>Primitives shared by framework extensions. Commonly used types include:
diff --git a/src/libraries/Microsoft.Extensions.Primitives/tests/CompositeChangeTokenTest.cs b/src/libraries/Microsoft.Extensions.Primitives/tests/CompositeChangeTokenTest.cs
index 549cfcc6138e35..07bb99b3ffc3f8 100644
--- a/src/libraries/Microsoft.Extensions.Primitives/tests/CompositeChangeTokenTest.cs
+++ b/src/libraries/Microsoft.Extensions.Primitives/tests/CompositeChangeTokenTest.cs
@@ -103,7 +103,6 @@ public void ActiveChangeCallbacks_IsFalse_IfNoTokenHasActiveChangeCallbacks()
         }
 
         [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsThreadingSupported))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
         public async Task RegisteredCallbackGetsInvokedExactlyOnce_WhenMultipleConcurrentChangeEventsOccur()
         {
             // Arrange
diff --git a/src/libraries/Microsoft.VisualBasic.Core/tests/FileSystemTests.cs b/src/libraries/Microsoft.VisualBasic.Core/tests/FileSystemTests.cs
index b3428a838ace4d..d9f981b2425982 100644
--- a/src/libraries/Microsoft.VisualBasic.Core/tests/FileSystemTests.cs
+++ b/src/libraries/Microsoft.VisualBasic.Core/tests/FileSystemTests.cs
@@ -43,7 +43,6 @@ public void ChDir()
         //   public static void ChDrive(string Drive){ throw null; }
 
         [ConditionalFact(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
         public void CloseAllFiles()
         {
             var fileName1 = GetTestFilePath();
@@ -182,6 +181,7 @@ public void EOF()
         //   public static OpenMode FileAttr(int FileNumber){ throw null; }
 
         [Fact]
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/53815", typeof(PlatformDetection), nameof(PlatformDetection.IsBrowser), nameof(PlatformDetection.IsMonoAOT))]
         public void FileClose()
         {
             int fileNumber = FileSystem.FreeFile();
@@ -376,6 +376,7 @@ public void FileLen()
         }
 
         [Fact]
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/53815", typeof(PlatformDetection), nameof(PlatformDetection.IsBrowser), nameof(PlatformDetection.IsMonoAOT))]
         public void FileOpen()
         {
             // OpenMode.Append:
@@ -706,6 +707,7 @@ public void Rename()
         //   public static void WriteLine(int FileNumber, params object[] Output) { }
 
         [Fact]
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/53815", typeof(PlatformDetection), nameof(PlatformDetection.IsBrowser), nameof(PlatformDetection.IsMonoAOT))]
         public void Write_ArgumentException()
         {
             int fileNumber = FileSystem.FreeFile();
diff --git a/src/libraries/Microsoft.Win32.Registry.AccessControl/ref/Microsoft.Win32.Registry.AccessControl.csproj b/src/libraries/Microsoft.Win32.Registry.AccessControl/ref/Microsoft.Win32.Registry.AccessControl.csproj
index ac6eb1b1d3397e..c6e8d3fbf20a55 100644
--- a/src/libraries/Microsoft.Win32.Registry.AccessControl/ref/Microsoft.Win32.Registry.AccessControl.csproj
+++ b/src/libraries/Microsoft.Win32.Registry.AccessControl/ref/Microsoft.Win32.Registry.AccessControl.csproj
@@ -7,8 +7,8 @@
     <Compile Include="Microsoft.Win32.Registry.AccessControl.cs" />
     <Compile Include="Microsoft.Win32.Registry.AccessControl.Forwards.cs" />
   </ItemGroup>
-  <ItemGroup Condition="!$(TargetFramework.StartsWith('net4'))">
-    <ProjectReference Include="..\..\Microsoft.Win32.Registry\ref\Microsoft.Win32.Registry.csproj" />
-    <ProjectReference Include="..\..\System.Security.AccessControl\ref\System.Security.AccessControl.csproj" />
+  <ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">
+    <PackageReference Include="Microsoft.Win32.Registry" Version="$(MicrosoftWin32RegistryVersion)" />
+    <PackageReference Include="System.Security.AccessControl" Version="$(SystemSecurityAccessControlVersion)" />
   </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/src/libraries/Microsoft.Win32.Registry.AccessControl/src/Microsoft.Win32.Registry.AccessControl.csproj b/src/libraries/Microsoft.Win32.Registry.AccessControl/src/Microsoft.Win32.Registry.AccessControl.csproj
index 6ce1218ec14c4c..f66a53a084091d 100644
--- a/src/libraries/Microsoft.Win32.Registry.AccessControl/src/Microsoft.Win32.Registry.AccessControl.csproj
+++ b/src/libraries/Microsoft.Win32.Registry.AccessControl/src/Microsoft.Win32.Registry.AccessControl.csproj
@@ -12,8 +12,8 @@
   <ItemGroup Condition="'$(TargetsWindows)' == 'true'">
     <Compile Include="Microsoft\Win32\RegistryAclExtensions.cs" />
   </ItemGroup>
-  <ItemGroup Condition="$(TargetFramework.StartsWith('netstandard'))">
-    <ProjectReference Include="$(LibrariesProjectRoot)Microsoft.Win32.Registry\src\Microsoft.Win32.Registry.csproj" />
-    <ProjectReference Include="$(LibrariesProjectRoot)System.Security.AccessControl\src\System.Security.AccessControl.csproj" />
+  <ItemGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETStandard'">
+    <PackageReference Include="Microsoft.Win32.Registry" Version="$(MicrosoftWin32RegistryVersion)" />
+    <PackageReference Include="System.Security.AccessControl" Version="$(SystemSecurityAccessControlVersion)" />
   </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/src/libraries/Microsoft.Win32.Registry/Directory.Build.props b/src/libraries/Microsoft.Win32.Registry/Directory.Build.props
index e02d0c28b4c563..709a22a7537088 100644
--- a/src/libraries/Microsoft.Win32.Registry/Directory.Build.props
+++ b/src/libraries/Microsoft.Win32.Registry/Directory.Build.props
@@ -2,15 +2,6 @@
   <Import Project="..\Directory.Build.props" />
   <PropertyGroup>
     <StrongNameKeyId>Microsoft</StrongNameKeyId>
-    <IsAspNetCoreApp>true</IsAspNetCoreApp>
     <SupportedOSPlatforms>windows</SupportedOSPlatforms>
-    <PackageDescription>Provides support for accessing and modifying the Windows Registry.
-
-Commonly Used Types:
-Microsoft.Win32.RegistryKey
-Microsoft.Win32.Registry
-Microsoft.Win32.RegistryValueKind
-Microsoft.Win32.RegistryHive
-Microsoft.Win32.RegistryView</PackageDescription>
   </PropertyGroup>
 </Project>
\ No newline at end of file
diff --git a/src/libraries/Microsoft.Win32.Registry/NuGet.config b/src/libraries/Microsoft.Win32.Registry/NuGet.config
deleted file mode 100644
index a66b7f9b013241..00000000000000
--- a/src/libraries/Microsoft.Win32.Registry/NuGet.config
+++ /dev/null
@@ -1,12 +0,0 @@
-<configuration>
-  <!-- This disables restore in VS for projects that target platform specific target frameworks older than net5.0. -->
-  <packageRestore>
-    <!-- The 'automatic' key is set to True when the "Automatically check for missing packages during
-         build in Visual Studio" checkbox is set. Clearing the box sets this to False and disables
-         automatic restore. -->
-    <add key="automatic" value="False" />
-    <!-- The 'enabled' key is True when the "Allow NuGet to download missing packages" checkbox is set.
-         Clearing the box sets this to False, disabling command-line, automatic, and MSBuild-integrated restore. -->
-    <add key="enabled" value="False" />
-  </packageRestore>
-</configuration>
\ No newline at end of file
diff --git a/src/libraries/Microsoft.Win32.Registry/pkg/Microsoft.Win32.Registry.pkgproj b/src/libraries/Microsoft.Win32.Registry/pkg/Microsoft.Win32.Registry.pkgproj
deleted file mode 100644
index 0c82f94c890533..00000000000000
--- a/src/libraries/Microsoft.Win32.Registry/pkg/Microsoft.Win32.Registry.pkgproj
+++ /dev/null
@@ -1,12 +0,0 @@
-<Project DefaultTargets="Build">
-  <Import Project="$([MSBuild]::GetPathOfFileAbove(Directory.Build.props))" />
-  <ItemGroup>
-    <ProjectReference Include="..\ref\Microsoft.Win32.Registry.csproj">
-      <SupportedFramework>net461;uap10.0.16299;netcoreapp2.0;$(AllXamarinFrameworks)</SupportedFramework>
-    </ProjectReference>
-    <ProjectReference Include="..\src\Microsoft.Win32.Registry.csproj" />
-    <!-- Exclude TFMs that aren't supported by the package anymore from validation. -->
-    <ExcludeHarvestedSupportedFramework Include="netcoreapp1.0;netcoreapp1.1;netcore50;uap10.0;net46" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetPathOfFileAbove(Directory.Build.targets))" />
-</Project>
\ No newline at end of file
diff --git a/src/libraries/Microsoft.Win32.Registry/ref/Microsoft.Win32.Registry.csproj b/src/libraries/Microsoft.Win32.Registry/ref/Microsoft.Win32.Registry.csproj
index da35db4f3001fa..8d2c8aaa1e1b13 100644
--- a/src/libraries/Microsoft.Win32.Registry/ref/Microsoft.Win32.Registry.csproj
+++ b/src/libraries/Microsoft.Win32.Registry/ref/Microsoft.Win32.Registry.csproj
@@ -1,14 +1,12 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFrameworks>netstandard2.0;net461</TargetFrameworks>
+    <TargetFrameworks>$(NetCoreAppCurrent)</TargetFrameworks>
     <Nullable>enable</Nullable>
   </PropertyGroup>
   <ItemGroup>
-    <Compile Condition="'$(TargetFramework)' != 'net461'" Include="Microsoft.Win32.Registry.cs" />
-    <Compile Condition="'$(TargetFramework)' == 'net461'" Include="Microsoft.Win32.Registry.net461.cs" />
+    <Compile Include="Microsoft.Win32.Registry.cs" />
   </ItemGroup>
-  <ItemGroup Condition="'$(TargetFramework)' != 'net461'">
-    <ProjectReference Include="..\..\System.Security.AccessControl\ref\System.Security.AccessControl.csproj" />
-    <ProjectReference Include="..\..\System.Security.Principal.Windows\ref\System.Security.Principal.Windows.csproj" />
+  <ItemGroup>
+    <ProjectReference Include="$(LibrariesProjectRoot)System.IO.Pipes.AccessControl\ref\System.IO.Pipes.AccessControl.csproj" />
   </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/src/libraries/Microsoft.Win32.Registry/ref/Microsoft.Win32.Registry.net461.cs b/src/libraries/Microsoft.Win32.Registry/ref/Microsoft.Win32.Registry.net461.cs
deleted file mode 100644
index 1fb81f88a9a284..00000000000000
--- a/src/libraries/Microsoft.Win32.Registry/ref/Microsoft.Win32.Registry.net461.cs
+++ /dev/null
@@ -1,21 +0,0 @@
-// 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.
-// ------------------------------------------------------------------------------
-
-using System.Runtime.CompilerServices;
-
-[assembly: TypeForwardedTo(typeof(System.Security.AccessControl.RegistryAccessRule))]
-[assembly: TypeForwardedTo(typeof(System.Security.AccessControl.RegistryAuditRule))]
-[assembly: TypeForwardedTo(typeof(System.Security.AccessControl.RegistryRights))]
-[assembly: TypeForwardedTo(typeof(System.Security.AccessControl.RegistrySecurity))]
-[assembly: TypeForwardedTo(typeof(Microsoft.Win32.Registry))]
-[assembly: TypeForwardedTo(typeof(Microsoft.Win32.RegistryHive))]
-[assembly: TypeForwardedTo(typeof(Microsoft.Win32.RegistryKey))]
-[assembly: TypeForwardedTo(typeof(Microsoft.Win32.RegistryKeyPermissionCheck))]
-[assembly: TypeForwardedTo(typeof(Microsoft.Win32.RegistryOptions))]
-[assembly: TypeForwardedTo(typeof(Microsoft.Win32.RegistryValueKind))]
-[assembly: TypeForwardedTo(typeof(Microsoft.Win32.RegistryValueOptions))]
-[assembly: TypeForwardedTo(typeof(Microsoft.Win32.RegistryView))]
-[assembly: TypeForwardedTo(typeof(Microsoft.Win32.SafeHandles.SafeRegistryHandle))]
diff --git a/src/libraries/Microsoft.Win32.Registry/src/Microsoft.Win32.Registry.csproj b/src/libraries/Microsoft.Win32.Registry/src/Microsoft.Win32.Registry.csproj
index 845a6e4ab2f5e0..2c5fa34fc434db 100644
--- a/src/libraries/Microsoft.Win32.Registry/src/Microsoft.Win32.Registry.csproj
+++ b/src/libraries/Microsoft.Win32.Registry/src/Microsoft.Win32.Registry.csproj
@@ -2,17 +2,15 @@
   <PropertyGroup>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <DefineConstants>$(DefineConstants);REGISTRY_ASSEMBLY</DefineConstants>
-    <TargetFrameworks>$(NetCoreAppCurrent)-windows;$(NetCoreAppCurrent);netstandard2.0-windows;netstandard2.0;net461-windows</TargetFrameworks>
-    <ExcludeCurrentNetCoreAppFromPackage>true</ExcludeCurrentNetCoreAppFromPackage>
+    <TargetFrameworks>$(NetCoreAppCurrent)-windows;$(NetCoreAppCurrent)</TargetFrameworks>
     <NoWarn>$(NoWarn);CA2249</NoWarn>
     <Nullable>enable</Nullable>
   </PropertyGroup>
   <!-- DesignTimeBuild requires all the TargetFramework Derived Properties to not be present in the first property group. -->
   <PropertyGroup>
-    <IsPartialFacadeAssembly Condition="$(TargetFramework.StartsWith('net4'))">true</IsPartialFacadeAssembly>
     <NoWarn Condition="'$(TargetsWindows)' != 'true'">$(NoWarn);CA1823</NoWarn> <!-- Avoid unused fields warnings in Unix build -->
   </PropertyGroup>
-  <ItemGroup Condition="!$(TargetFramework.StartsWith('net4'))">
+  <ItemGroup>
     <Compile Include="$(CommonPath)Interop\Windows\Advapi32\Interop.RegistryConstants.cs"
              Link="Common\Interop\Windows\Advapi32\Interop.RegistryConstants.cs" />
     <Compile Include="$(CoreLibSharedDir)Microsoft\Win32\SafeHandles\SafeRegistryHandle.cs"
@@ -28,7 +26,7 @@
     <Compile Include="System\Security\AccessControl\RegistryRights.cs" />
     <Compile Include="System\Security\AccessControl\RegistrySecurity.cs" />
   </ItemGroup>
-  <ItemGroup Condition="!$(TargetFramework.StartsWith('net4')) and '$(TargetsWindows)' == 'true'">
+  <ItemGroup Condition="'$(TargetsWindows)' == 'true'">
     <Compile Include="$(CommonPath)Interop\Windows\Interop.Libraries.cs"
              Link="Common\Interop\Windows\Interop.Libraries.cs" />
     <Compile Include="$(CommonPath)Interop\Windows\Interop.Errors.cs"
@@ -73,11 +71,9 @@
     <Compile Include="Microsoft\Win32\SafeHandles\SafeRegistryHandle.FileSystem.cs" />
     <Compile Include="System\Security\AccessControl\RegistrySecurity.FileSystem.cs" />
   </ItemGroup>
-  <ItemGroup Condition="'$(IsPartialFacadeAssembly)' != 'true'">
+  <ItemGroup>
     <ProjectReference Include="$(LibrariesProjectRoot)System.Security.AccessControl\src\System.Security.AccessControl.csproj" />
     <ProjectReference Include="$(LibrariesProjectRoot)System.Security.Principal.Windows\src\System.Security.Principal.Windows.csproj" />
-  </ItemGroup>
-  <ItemGroup Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', '$(NetCoreAppCurrent)'))">
     <Reference Include="System.Buffers" />
     <Reference Include="System.Collections" />
     <Reference Include="System.Diagnostics.Debug" />
@@ -88,11 +84,4 @@
     <Reference Include="System.Runtime.Extensions" />
     <Reference Include="System.Runtime.InteropServices" />
   </ItemGroup>
-  <ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">
-    <PackageReference Include="System.Buffers" Version="$(SystemBuffersVersion)" />
-    <PackageReference Include="System.Memory" Version="$(SystemMemoryVersion)" />
-    <ProjectReference Include="$(LibrariesProjectRoot)System.Runtime.CompilerServices.Unsafe\src\System.Runtime.CompilerServices.Unsafe.ilproj" />
-    <ProjectReference Include="$(LibrariesProjectRoot)System.IO.FileSystem.AccessControl\src\System.IO.FileSystem.AccessControl.csproj" />
-    <ProjectReference Include="$(LibrariesProjectRoot)System.Security.Permissions\src\System.Security.Permissions.csproj" />
-  </ItemGroup>
 </Project>
diff --git a/src/libraries/Microsoft.Win32.Registry/src/Microsoft/Win32/RegistryKey.cs b/src/libraries/Microsoft.Win32.Registry/src/Microsoft/Win32/RegistryKey.cs
index 54054d809c2847..ea5a83315216de 100644
--- a/src/libraries/Microsoft.Win32.Registry/src/Microsoft/Win32/RegistryKey.cs
+++ b/src/libraries/Microsoft.Win32.Registry/src/Microsoft/Win32/RegistryKey.cs
@@ -628,8 +628,7 @@ private static string FixupName(string name)
         {
             Debug.Assert(name != null, "[FixupName]name!=null");
 
-            // string.Contains(char) is .NetCore2.1+ specific
-            if (name.IndexOf('\\') == -1)
+            if (!name.Contains('\\'))
             {
                 return name;
             }
diff --git a/src/libraries/Microsoft.Win32.Registry/tests/Microsoft.Win32.Registry.Tests.csproj b/src/libraries/Microsoft.Win32.Registry/tests/Microsoft.Win32.Registry.Tests.csproj
index bfe24efad01533..e88f97d0cb43cc 100644
--- a/src/libraries/Microsoft.Win32.Registry/tests/Microsoft.Win32.Registry.Tests.csproj
+++ b/src/libraries/Microsoft.Win32.Registry/tests/Microsoft.Win32.Registry.Tests.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <DefineConstants>$(DefineConstants);REGISTRY_ASSEMBLY</DefineConstants>
-    <TargetFrameworks>$(NetCoreAppCurrent)-windows;net461-windows</TargetFrameworks>
+    <TargetFrameworks>$(NetCoreAppCurrent)-windows</TargetFrameworks>
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="$(CommonPath)Interop\Windows\Interop.Libraries.cs"
@@ -56,7 +56,4 @@
     <Compile Include="TestData.cs" />
     <Compile Include="XunitAssemblyAttributes.cs" />
   </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="..\src\Microsoft.Win32.Registry.csproj" />
-  </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/src/libraries/Microsoft.Win32.SystemEvents/ref/Microsoft.Win32.SystemEvents.csproj b/src/libraries/Microsoft.Win32.SystemEvents/ref/Microsoft.Win32.SystemEvents.csproj
index 32515389382276..60b298c4b14d57 100644
--- a/src/libraries/Microsoft.Win32.SystemEvents/ref/Microsoft.Win32.SystemEvents.csproj
+++ b/src/libraries/Microsoft.Win32.SystemEvents/ref/Microsoft.Win32.SystemEvents.csproj
@@ -1,10 +1,17 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFrameworks>netstandard2.0;net461</TargetFrameworks>
+    <TargetFrameworks>$(NetCoreAppCurrent);netcoreapp3.1;netstandard2.0;net461</TargetFrameworks>
     <Nullable>enable</Nullable>
   </PropertyGroup>
   <ItemGroup>
     <Compile Condition="'$(TargetFramework)' != 'net461'" Include="Microsoft.Win32.SystemEvents.cs" />
     <Compile Condition="'$(TargetFramework)' == 'net461'" Include="Microsoft.Win32.SystemEvents.net461.cs" />
   </ItemGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == '$(NetCoreAppCurrent)'">
+    <ProjectReference Include="$(LibrariesProjectRoot)System.ComponentModel.Primitives\ref\System.ComponentModel.Primitives.csproj" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == 'netcoreapp3.1'">
+    <Reference Include="System.ComponentModel.Primitives" />
+    <Reference Include="System.Runtime" />
+  </ItemGroup>
 </Project>
\ No newline at end of file
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 2b9dada8b1ecc3..2929b90c61a3a8 100644
--- a/src/libraries/Microsoft.Win32.SystemEvents/src/Microsoft.Win32.SystemEvents.csproj
+++ b/src/libraries/Microsoft.Win32.SystemEvents/src/Microsoft.Win32.SystemEvents.csproj
@@ -2,8 +2,7 @@
   <PropertyGroup>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <Nullable>enable</Nullable>
-    <TargetFrameworks>$(NetCoreAppCurrent)-windows;netcoreapp3.1-windows;netstandard2.0;net461</TargetFrameworks>
-    <ExcludeCurrentNetCoreAppFromPackage>true</ExcludeCurrentNetCoreAppFromPackage>
+    <TargetFrameworks>$(NetCoreAppCurrent)-windows;$(NetCoreAppCurrent);netcoreapp3.1-windows;netcoreapp3.1;netstandard2.0;net461</TargetFrameworks>
   </PropertyGroup>
   <!-- DesignTimeBuild requires all the TargetFramework Derived Properties to not be present in the first property group. -->
   <PropertyGroup>
diff --git a/src/libraries/Microsoft.Win32.SystemEvents/tests/SystemEvents.InvokeOnEventsThread.cs b/src/libraries/Microsoft.Win32.SystemEvents/tests/SystemEvents.InvokeOnEventsThread.cs
index d3c058bf91182e..a0a571e7b7624b 100644
--- a/src/libraries/Microsoft.Win32.SystemEvents/tests/SystemEvents.InvokeOnEventsThread.cs
+++ b/src/libraries/Microsoft.Win32.SystemEvents/tests/SystemEvents.InvokeOnEventsThread.cs
@@ -54,6 +54,7 @@ public void InvokeOnEventsThreadRunsOnSameThreadAsOtherEvents()
 
         [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNotWindowsNanoNorServerCore))]
         [SkipOnTargetFramework(TargetFrameworkMonikers.NetFramework)]
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/34360", TestPlatforms.Windows, TargetFrameworkMonikers.Netcoreapp, TestRuntimes.Mono)]
         public void RegisterFromSTAThreadThatGoesAway_MessageStillDelivered()
         {
             RemoteExecutor.Invoke(() => // to ensure no one has registered for any events before
diff --git a/src/libraries/Native/Unix/Common/pal_config.h.in b/src/libraries/Native/Unix/Common/pal_config.h.in
index b7bd484e629ffa..2b86ed15d4cae7 100644
--- a/src/libraries/Native/Unix/Common/pal_config.h.in
+++ b/src/libraries/Native/Unix/Common/pal_config.h.in
@@ -36,6 +36,8 @@
 #cmakedefine01 HAVE_POSIX_ADVISE
 #cmakedefine01 HAVE_POSIX_FALLOCATE
 #cmakedefine01 HAVE_POSIX_FALLOCATE64
+#cmakedefine01 HAVE_PREADV
+#cmakedefine01 HAVE_PWRITEV
 #cmakedefine01 PRIORITY_REQUIRES_INT_WHO
 #cmakedefine01 KEVENT_REQUIRES_INT_PARAMS
 #cmakedefine01 HAVE_IOCTL
@@ -120,6 +122,11 @@
 #cmakedefine01 HAVE_GETGROUPLIST
 #cmakedefine01 HAVE_SYS_PROCINFO_H
 #cmakedefine01 HAVE_IOSS_H
+#cmakedefine01 HAVE_ALIGNED_ALLOC
+#cmakedefine01 HAVE_MALLOC_SIZE
+#cmakedefine01 HAVE_MALLOC_USABLE_SIZE
+#cmakedefine01 HAVE_MALLOC_USABLE_SIZE_NP
+#cmakedefine01 HAVE_POSIX_MEMALIGN
 
 // Mac OS X has stat64, but it is deprecated since plain stat now
 // provides the same 64-bit aware struct when targeting OS X > 10.5
diff --git a/src/libraries/Native/Unix/System.Native/entrypoints.c b/src/libraries/Native/Unix/System.Native/entrypoints.c
index 0f7b1a12fa5076..cf6485ecf8430a 100644
--- a/src/libraries/Native/Unix/System.Native/entrypoints.c
+++ b/src/libraries/Native/Unix/System.Native/entrypoints.c
@@ -108,10 +108,15 @@ static const Entry s_sysNative[] =
     DllImportEntry(SystemNative_LChflagsCanSetHiddenFlag)
     DllImportEntry(SystemNative_ReadProcessStatusInfo)
     DllImportEntry(SystemNative_Log)
-    DllImportEntry(SystemNative_MemAlloc)
-    DllImportEntry(SystemNative_MemReAlloc)
-    DllImportEntry(SystemNative_MemFree)
+    DllImportEntry(SystemNative_AlignedAlloc)
+    DllImportEntry(SystemNative_AlignedFree)
+    DllImportEntry(SystemNative_AlignedRealloc)
+    DllImportEntry(SystemNative_Calloc)
+    DllImportEntry(SystemNative_Free)
+    DllImportEntry(SystemNative_GetUsableSize)
+    DllImportEntry(SystemNative_Malloc)
     DllImportEntry(SystemNative_MemSet)
+    DllImportEntry(SystemNative_Realloc)
     DllImportEntry(SystemNative_GetSpaceInfoForMountPoint)
     DllImportEntry(SystemNative_GetFormatInfoForMountPoint)
     DllImportEntry(SystemNative_GetAllMountPoints)
@@ -242,6 +247,10 @@ static const Entry s_sysNative[] =
     DllImportEntry(SystemNative_iOSSupportVersion)
     DllImportEntry(SystemNative_GetErrNo)
     DllImportEntry(SystemNative_SetErrNo)
+    DllImportEntry(SystemNative_PRead)
+    DllImportEntry(SystemNative_PWrite)
+    DllImportEntry(SystemNative_PReadV)
+    DllImportEntry(SystemNative_PWriteV)
 };
 
 EXTERN_C const void* SystemResolveDllImport(const char* name);
diff --git a/src/libraries/Native/Unix/System.Native/pal_io.c b/src/libraries/Native/Unix/System.Native/pal_io.c
index c63eb8898cace9..d7eb6c4ab23aca 100644
--- a/src/libraries/Native/Unix/System.Native/pal_io.c
+++ b/src/libraries/Native/Unix/System.Native/pal_io.c
@@ -22,6 +22,7 @@
 #include <sys/file.h>
 #include <sys/ioctl.h>
 #include <sys/socket.h>
+#include <sys/uio.h>
 #include <syslog.h>
 #include <termios.h>
 #include <unistd.h>
@@ -1454,3 +1455,107 @@ int32_t SystemNative_ReadProcessStatusInfo(pid_t pid, ProcessStatus* processStat
     return -1;
 #endif // __sun
 }
+
+int32_t SystemNative_PRead(intptr_t fd, void* buffer, int32_t bufferSize, int64_t fileOffset)
+{
+    assert(buffer != NULL);
+    assert(bufferSize >= 0);
+
+    ssize_t count;
+    while ((count = pread(ToFileDescriptor(fd), buffer, (uint32_t)bufferSize, (off_t)fileOffset)) < 0 && errno == EINTR);
+
+    assert(count >= -1 && count <= bufferSize);
+    return (int32_t)count;
+}
+
+int32_t SystemNative_PWrite(intptr_t fd, void* buffer, int32_t bufferSize, int64_t fileOffset)
+{
+    assert(buffer != NULL);
+    assert(bufferSize >= 0);
+
+    ssize_t count;
+    while ((count = pwrite(ToFileDescriptor(fd), buffer, (uint32_t)bufferSize, (off_t)fileOffset)) < 0 && errno == EINTR);
+
+    assert(count >= -1 && count <= bufferSize);
+    return (int32_t)count;
+}
+
+int64_t SystemNative_PReadV(intptr_t fd, IOVector* vectors, int32_t vectorCount, int64_t fileOffset)
+{
+    assert(vectors != NULL);
+    assert(vectorCount >= 0);
+
+    int64_t count = 0;
+    int fileDescriptor = ToFileDescriptor(fd);
+#if HAVE_PREADV && !defined(TARGET_WASM) // preadv is buggy on WASM
+    while ((count = preadv(fileDescriptor, (struct iovec*)vectors, (int)vectorCount, (off_t)fileOffset)) < 0 && errno == EINTR);
+#else
+    int64_t current;
+    for (int i = 0; i < vectorCount; i++)
+    {
+        IOVector vector = vectors[i];
+        while ((current = pread(fileDescriptor, vector.Base, vector.Count, (off_t)(fileOffset + count))) < 0 && errno == EINTR);
+
+        if (current < 0)
+        {
+            // if previous calls were succesfull, we return what we got so far
+            // otherwise, we return the error code
+            return count > 0 ? count : current;
+        }
+
+        count += current;
+
+        // Incomplete pread operation may happen for two reasons:
+        // a) We have reached EOF.
+        // b) The operation was interrupted by a signal handler.
+        // To mimic preadv, we stop on the first incomplete operation.
+        if (current != (int64_t)vector.Count)
+        {
+            return count;
+        }
+    }
+#endif
+
+    assert(count >= -1);
+    return count;
+}
+
+int64_t SystemNative_PWriteV(intptr_t fd, IOVector* vectors, int32_t vectorCount, int64_t fileOffset)
+{
+    assert(vectors != NULL);
+    assert(vectorCount >= 0);
+
+    int64_t count = 0;
+    int fileDescriptor = ToFileDescriptor(fd);
+#if HAVE_PWRITEV && !defined(TARGET_WASM) // pwritev is buggy on WASM
+    while ((count = pwritev(fileDescriptor, (struct iovec*)vectors, (int)vectorCount, (off_t)fileOffset)) < 0 && errno == EINTR);
+#else
+    int64_t current;
+    for (int i = 0; i < vectorCount; i++)
+    {
+        IOVector vector = vectors[i];
+        while ((current = pwrite(fileDescriptor, vector.Base, vector.Count, (off_t)(fileOffset + count))) < 0 && errno == EINTR);
+
+        if (current < 0)
+        {
+            // if previous calls were succesfull, we return what we got so far
+            // otherwise, we return the error code
+            return count > 0 ? count : current;
+        }
+
+        count += current;
+
+        // Incomplete pwrite operation may happen for few reasons:
+        // a) There was not enough space available or the file is too large for given file system.
+        // b) The operation was interrupted by a signal handler.
+        // To mimic pwritev, we stop on the first incomplete operation.
+        if (current != (int64_t)vector.Count)
+        {
+            return count;
+        }
+    }
+#endif
+
+    assert(count >= -1);
+    return count;
+}
diff --git a/src/libraries/Native/Unix/System.Native/pal_io.h b/src/libraries/Native/Unix/System.Native/pal_io.h
index e3d402d9be5f66..1dc70387ad5eac 100644
--- a/src/libraries/Native/Unix/System.Native/pal_io.h
+++ b/src/libraries/Native/Unix/System.Native/pal_io.h
@@ -41,6 +41,14 @@ typedef struct
     // add more fields when needed.
 } ProcessStatus;
 
+// NOTE: the layout of this type is intended to exactly  match the layout of a `struct iovec`. There are
+//       assertions in pal_networking.c that validate this.
+typedef struct
+{
+    uint8_t* Base;
+    uintptr_t Count;
+} IOVector;
+
 /* Provide consistent access to nanosecond fields, if they exist. */
 /* Seconds are always available through st_atime, st_mtime, st_ctime. */
 
@@ -730,3 +738,31 @@ PALEXPORT int32_t SystemNative_LChflagsCanSetHiddenFlag(void);
  * Returns 1 if the process status was read; otherwise, 0.
  */
 PALEXPORT int32_t SystemNative_ReadProcessStatusInfo(pid_t pid, ProcessStatus* processStatus);
+
+/**
+ * Reads the number of bytes specified into the provided buffer from the specified, opened file descriptor at specified offset.
+ *
+ * Returns the number of bytes read on success; otherwise, -1 is returned an errno is set.
+ */
+PALEXPORT int32_t SystemNative_PRead(intptr_t fd, void* buffer, int32_t bufferSize, int64_t fileOffset);
+
+/**
+ * Writes the number of bytes specified in the buffer into the specified, opened file descriptor at specified offset.
+ *
+ * Returns the number of bytes written on success; otherwise, -1 is returned an errno is set.
+ */
+PALEXPORT int32_t SystemNative_PWrite(intptr_t fd, void* buffer, int32_t bufferSize, int64_t fileOffset);
+
+/**
+ * Reads the number of bytes specified into the provided buffers from the specified, opened file descriptor at specified offset.
+ *
+ * Returns the number of bytes read on success; otherwise, -1 is returned an errno is set.
+ */
+PALEXPORT int64_t SystemNative_PReadV(intptr_t fd, IOVector* vectors, int32_t vectorCount, int64_t fileOffset);
+
+/**
+ * Writes the number of bytes specified in the buffers into the specified, opened file descriptor at specified offset.
+ *
+ * Returns the number of bytes written on success; otherwise, -1 is returned an errno is set.
+ */
+PALEXPORT int64_t SystemNative_PWriteV(intptr_t fd, IOVector* vectors, int32_t vectorCount, int64_t fileOffset);
diff --git a/src/libraries/Native/Unix/System.Native/pal_memory.c b/src/libraries/Native/Unix/System.Native/pal_memory.c
index 35757dff03b9dd..fd6a34de2c39a8 100644
--- a/src/libraries/Native/Unix/System.Native/pal_memory.c
+++ b/src/libraries/Native/Unix/System.Native/pal_memory.c
@@ -1,27 +1,92 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+#include "pal_config.h"
 #include "pal_memory.h"
 
+#include <assert.h>
 #include <stdlib.h>
 #include <string.h>
 
-void* SystemNative_MemAlloc(uintptr_t size)
+#if HAVE_MALLOC_SIZE
+    #include <malloc/malloc.h>
+#elif HAVE_MALLOC_USABLE_SIZE
+    #include <malloc.h>
+#elif HAVE_MALLOC_USABLE_SIZE_NP
+    #include <malloc_np.h>
+#else
+    #error "Platform doesn't support malloc_usable_size or malloc_size"
+#endif
+
+void* SystemNative_AlignedAlloc(uintptr_t alignment, uintptr_t size)
 {
-    return malloc(size);
+#if HAVE_ALIGNED_ALLOC
+    // We want to prefer the standardized aligned_alloc function. However
+    // it cannot be used on __APPLE__ since we target 10.13 and it was
+    // only added in 10.15, but we might be compiling on a 10.15 box.
+    return aligned_alloc(alignment, size);
+#elif HAVE_POSIX_MEMALIGN
+    void* result = NULL;
+    posix_memalign(&result, alignment, size);
+    return result;
+#else
+    #error "Platform doesn't support aligned_alloc or posix_memalign"
+#endif
+}
+
+void SystemNative_AlignedFree(void* ptr)
+{
+    free(ptr);
+}
+
+void* SystemNative_AlignedRealloc(void* ptr, uintptr_t alignment, uintptr_t new_size)
+{
+    void* result = SystemNative_AlignedAlloc(alignment, new_size);
+
+    if (result != NULL)
+    {
+        uintptr_t old_size = SystemNative_GetUsableSize(ptr);
+        assert((ptr != NULL) || (old_size == 0));
+
+        memcpy(result, ptr, (new_size < old_size) ? new_size : old_size);
+        SystemNative_AlignedFree(ptr);
+    }
+
+    return result;
 }
 
-void* SystemNative_MemReAlloc(void* ptr, uintptr_t size)
+void* SystemNative_Calloc(uintptr_t num, uintptr_t size)
 {
-    return realloc(ptr, size);
+    return calloc(num, size);
 }
 
-void SystemNative_MemFree(void* ptr)
+void SystemNative_Free(void* ptr)
 {
     free(ptr);
 }
 
+uintptr_t SystemNative_GetUsableSize(void* ptr)
+{
+#if HAVE_MALLOC_SIZE
+    return malloc_size(ptr);
+#elif HAVE_MALLOC_USABLE_SIZE || HAVE_MALLOC_USABLE_SIZE_NP
+    return malloc_usable_size(ptr);
+#else
+    #error "Platform doesn't support malloc_usable_size or malloc_size"
+#endif
+}
+
+void* SystemNative_Malloc(uintptr_t size)
+{
+    return malloc(size);
+}
+
 void* SystemNative_MemSet(void* s, int c, uintptr_t n)
 {
     return memset(s, c, n);
 }
+
+void* SystemNative_Realloc(void* ptr, uintptr_t new_size)
+{
+    return realloc(ptr, new_size);
+}
diff --git a/src/libraries/Native/Unix/System.Native/pal_memory.h b/src/libraries/Native/Unix/System.Native/pal_memory.h
index 83fc2f2f9f48a0..2cc4c1d8635be9 100644
--- a/src/libraries/Native/Unix/System.Native/pal_memory.h
+++ b/src/libraries/Native/Unix/System.Native/pal_memory.h
@@ -7,21 +7,46 @@
 #include "pal_types.h"
 
 /**
- * C runtime malloc
+ * C runtime aligned_alloc
  */
-PALEXPORT void* SystemNative_MemAlloc(uintptr_t size);
+PALEXPORT void* SystemNative_AlignedAlloc(uintptr_t alignment, uintptr_t size);
 
 /**
- * C runtime realloc
+ * Free for C runtime aligned_alloc
+ */
+PALEXPORT void SystemNative_AlignedFree(void* ptr);
+
+/**
+ * Realloc for C runtime aligned_alloc
  */
-PALEXPORT void* SystemNative_MemReAlloc(void* ptr, uintptr_t size);
+PALEXPORT void* SystemNative_AlignedRealloc(void* ptr, uintptr_t alignment, uintptr_t size);
+
+/**
+ * C runtime calloc
+ */
+PALEXPORT void* SystemNative_Calloc(uintptr_t num, uintptr_t size);
 
 /**
  * C runtime free
  */
-PALEXPORT void SystemNative_MemFree(void* ptr);
+PALEXPORT void SystemNative_Free(void* ptr);
+
+/**
+ * Get usable size of C runtime malloc
+ */
+PALEXPORT uintptr_t SystemNative_GetUsableSize(void* ptr);
+
+/**
+ * C runtime malloc
+ */
+PALEXPORT void* SystemNative_Malloc(uintptr_t size);
 
 /**
  * C runtime memset
  */
 PALEXPORT void* SystemNative_MemSet(void* s, int c, uintptr_t n);
+
+/**
+ * C runtime realloc
+ */
+PALEXPORT void* SystemNative_Realloc(void* ptr, uintptr_t new_size);
diff --git a/src/libraries/Native/Unix/System.Native/pal_networking.c b/src/libraries/Native/Unix/System.Native/pal_networking.c
index 11124f34c29bb3..3236fe26acfeba 100644
--- a/src/libraries/Native/Unix/System.Native/pal_networking.c
+++ b/src/libraries/Native/Unix/System.Native/pal_networking.c
@@ -3,7 +3,6 @@
 
 #include "pal_config.h"
 #include "pal_networking.h"
-#include "pal_io.h"
 #include "pal_safecrt.h"
 #include "pal_utilities.h"
 #include <pal_networking_common.h>
@@ -3104,11 +3103,11 @@ int32_t SystemNative_Disconnect(intptr_t socket)
     addr.sa_family = AF_UNSPEC;
 
     err = connect(fd, &addr, sizeof(addr));
-    if (err != 0) 
+    if (err != 0)
     {
         // On some older kernels connect(AF_UNSPEC) may fail. Fall back to shutdown in these cases:
         err = shutdown(fd, SHUT_RDWR);
-    } 
+    }
 #elif HAVE_DISCONNECTX
     // disconnectx causes a FIN close on OSX. It's the best we can do.
     err = disconnectx(fd, SAE_ASSOCID_ANY, SAE_CONNID_ANY);
diff --git a/src/libraries/Native/Unix/System.Native/pal_networking.h b/src/libraries/Native/Unix/System.Native/pal_networking.h
index bbb0bc0785ccec..4bf9de658e26f8 100644
--- a/src/libraries/Native/Unix/System.Native/pal_networking.h
+++ b/src/libraries/Native/Unix/System.Native/pal_networking.h
@@ -4,6 +4,7 @@
 #pragma once
 
 #include "pal_compiler.h"
+#include "pal_io.h"
 #include "pal_types.h"
 #include "pal_errno.h"
 #include <pal_networking_common.h>
@@ -275,14 +276,6 @@ typedef struct
     int32_t Seconds; // Number of seconds to linger for
 } LingerOption;
 
-// NOTE: the layout of this type is intended to exactly  match the layout of a `struct iovec`. There are
-//       assertions in pal_networking.cpp that validate this.
-typedef struct
-{
-    uint8_t* Base;
-    uintptr_t Count;
-} IOVector;
-
 typedef struct
 {
     uint8_t* SocketAddress;
diff --git a/src/libraries/Native/Unix/System.Security.Cryptography.Native.Android/pal_hmac.c b/src/libraries/Native/Unix/System.Security.Cryptography.Native.Android/pal_hmac.c
index 4fd381dbc82a73..7632eed59050fd 100644
--- a/src/libraries/Native/Unix/System.Security.Cryptography.Native.Android/pal_hmac.c
+++ b/src/libraries/Native/Unix/System.Security.Cryptography.Native.Android/pal_hmac.c
@@ -136,3 +136,29 @@ void CryptoNative_HmacDestroy(jobject ctx)
 {
     ReleaseGRef(GetJNIEnv(), ctx);
 }
+
+int32_t CryptoNative_HmacOneShot(intptr_t type,
+                                 uint8_t* key,
+                                 int32_t keyLen,
+                                 uint8_t* source,
+                                 int32_t sourceLen,
+                                 uint8_t* md,
+                                 int32_t* mdSize)
+{
+    jobject hmacCtx = CryptoNative_HmacCreate(key, keyLen, type);
+
+    if (hmacCtx == FAIL)
+        return FAIL;
+
+    int32_t ret = sourceLen == 0 ? SUCCESS : CryptoNative_HmacUpdate(hmacCtx, source, sourceLen);
+
+    if (ret != SUCCESS)
+    {
+        CryptoNative_HmacDestroy(hmacCtx);
+        return ret;
+    }
+
+    ret = CryptoNative_HmacFinal(hmacCtx, md, mdSize);
+    CryptoNative_HmacDestroy(hmacCtx);
+    return ret;
+}
diff --git a/src/libraries/Native/Unix/System.Security.Cryptography.Native.Android/pal_hmac.h b/src/libraries/Native/Unix/System.Security.Cryptography.Native.Android/pal_hmac.h
index e44aa5d2570f2d..671fc6fe5179e1 100644
--- a/src/libraries/Native/Unix/System.Security.Cryptography.Native.Android/pal_hmac.h
+++ b/src/libraries/Native/Unix/System.Security.Cryptography.Native.Android/pal_hmac.h
@@ -11,3 +11,10 @@ PALEXPORT int32_t CryptoNative_HmacUpdate(jobject ctx, uint8_t* data, int32_t le
 PALEXPORT int32_t CryptoNative_HmacFinal(jobject ctx, uint8_t* md, int32_t* len);
 PALEXPORT int32_t CryptoNative_HmacCurrent(jobject ctx, uint8_t* md, int32_t* len);
 PALEXPORT void CryptoNative_HmacDestroy(jobject ctx);
+PALEXPORT int32_t CryptoNative_HmacOneShot(intptr_t type,
+                                           uint8_t* key,
+                                           int32_t keyLen,
+                                           uint8_t* source,
+                                           int32_t sourceLen,
+                                           uint8_t* md,
+                                           int32_t* mdSize);
diff --git a/src/libraries/Native/Unix/System.Security.Cryptography.Native.Android/pal_jni.c b/src/libraries/Native/Unix/System.Security.Cryptography.Native.Android/pal_jni.c
index d847680d421141..fe92ce9ebe3ebe 100644
--- a/src/libraries/Native/Unix/System.Security.Cryptography.Native.Android/pal_jni.c
+++ b/src/libraries/Native/Unix/System.Security.Cryptography.Native.Android/pal_jni.c
@@ -484,7 +484,6 @@ void ReleaseLRef(JNIEnv *env, jobject lref)
 ARGS_NON_NULL_ALL static bool TryGetClassGRef(JNIEnv *env, const char* name, jclass* out)
 {
     *out = NULL;
-    LOG_DEBUG("Finding %s class", name);
     jclass klass = (*env)->FindClass (env, name);
     if (klass == NULL)
         return false;
@@ -568,7 +567,6 @@ void SaveTo(uint8_t* src, uint8_t** dst, size_t len, bool overwrite)
 
 jmethodID GetMethod(JNIEnv *env, bool isStatic, jclass klass, const char* name, const char* sig)
 {
-    LOG_DEBUG("Finding %s method", name);
     jmethodID mid = isStatic ? (*env)->GetStaticMethodID(env, klass, name, sig) : (*env)->GetMethodID(env, klass, name, sig);
     abort_unless(mid != NULL, "method %s %s was not found", name, sig);
     return mid;
@@ -576,7 +574,6 @@ jmethodID GetMethod(JNIEnv *env, bool isStatic, jclass klass, const char* name,
 
 jmethodID GetOptionalMethod(JNIEnv *env, bool isStatic, jclass klass, const char* name, const char* sig)
 {
-    LOG_DEBUG("Finding %s method", name);
     jmethodID mid = isStatic ? (*env)->GetStaticMethodID(env, klass, name, sig) : (*env)->GetMethodID(env, klass, name, sig);
     if (!mid) {
         LOG_INFO("optional method %s %s was not found", name, sig);
@@ -588,7 +585,6 @@ jmethodID GetOptionalMethod(JNIEnv *env, bool isStatic, jclass klass, const char
 
 jfieldID GetField(JNIEnv *env, bool isStatic, jclass klass, const char* name, const char* sig)
 {
-    LOG_DEBUG("Finding %s field", name);
     jfieldID fid = isStatic ? (*env)->GetStaticFieldID(env, klass, name, sig) : (*env)->GetFieldID(env, klass, name, sig);
     abort_unless(fid != NULL, "field %s %s was not found", name, sig);
     return fid;
@@ -709,7 +705,6 @@ JNI_OnLoad(JavaVM *vm, void *reserved)
     g_SSLParametersClass =                      GetClassGRef(env, "javax/net/ssl/SSLParameters");
     g_SSLParametersGetProtocols =               GetMethod(env, false,  g_SSLParametersClass, "getProtocols", "()[Ljava/lang/String;");
     g_SSLParametersSetApplicationProtocols =    GetOptionalMethod(env, false,  g_SSLParametersClass, "setApplicationProtocols", "([Ljava/lang/String;)V");
-    g_SSLParametersSetServerNames =             GetMethod(env, false,  g_SSLParametersClass, "setServerNames", "(Ljava/util/List;)V");
 
     g_sslCtxClass =                     GetClassGRef(env, "javax/net/ssl/SSLContext");
     g_sslCtxGetDefaultMethod =          GetMethod(env, true,  g_sslCtxClass, "getDefault", "()Ljavax/net/ssl/SSLContext;");
@@ -961,8 +956,13 @@ JNI_OnLoad(JavaVM *vm, void *reserved)
     g_KeyManagerFactoryInit =           GetMethod(env, false, g_KeyManagerFactory, "init", "(Ljava/security/KeyStore;[C)V");
     g_KeyManagerFactoryGetKeyManagers = GetMethod(env, false, g_KeyManagerFactory, "getKeyManagers", "()[Ljavax/net/ssl/KeyManager;");
 
-    g_SNIHostName =     GetClassGRef(env, "javax/net/ssl/SNIHostName");
-    g_SNIHostNameCtor = GetMethod(env, false, g_SNIHostName, "<init>", "(Ljava/lang/String;)V");
+    // Supported on API Level 24 and above
+    g_SNIHostName = GetOptionalClassGRef(env, "javax/net/ssl/SNIHostName");
+    if (g_SNIHostName != NULL)
+    {
+        g_SNIHostNameCtor =                 GetMethod(env, false, g_SNIHostName, "<init>", "(Ljava/lang/String;)V");
+        g_SSLParametersSetServerNames =     GetOptionalMethod(env, false,  g_SSLParametersClass, "setServerNames", "(Ljava/util/List;)V");
+    }
 
     g_SSLEngine =                       GetClassGRef(env, "javax/net/ssl/SSLEngine");
     g_SSLEngineBeginHandshake =         GetMethod(env, false, g_SSLEngine, "beginHandshake", "()V");
diff --git a/src/libraries/Native/Unix/System.Security.Cryptography.Native.Android/pal_jni.h b/src/libraries/Native/Unix/System.Security.Cryptography.Native.Android/pal_jni.h
index 4b33497aa4424a..f9e9bc7acf5863 100644
--- a/src/libraries/Native/Unix/System.Security.Cryptography.Native.Android/pal_jni.h
+++ b/src/libraries/Native/Unix/System.Security.Cryptography.Native.Android/pal_jni.h
@@ -10,6 +10,7 @@
 
 #define FAIL 0
 #define SUCCESS 1
+#define UNSUPPORTED_API_LEVEL  2
 #define INSUFFICIENT_BUFFER -1
 
 extern JavaVM* gJvm;
diff --git a/src/libraries/Native/Unix/System.Security.Cryptography.Native.Android/pal_sslstream.c b/src/libraries/Native/Unix/System.Security.Cryptography.Native.Android/pal_sslstream.c
index 0a458eab355483..4b95faf7a191bd 100644
--- a/src/libraries/Native/Unix/System.Security.Cryptography.Native.Android/pal_sslstream.c
+++ b/src/libraries/Native/Unix/System.Security.Cryptography.Native.Android/pal_sslstream.c
@@ -479,6 +479,12 @@ int32_t AndroidCryptoNative_SSLStreamSetTargetHost(SSLStream* sslStream, char* t
     abort_if_invalid_pointer_argument (sslStream);
     abort_if_invalid_pointer_argument (targetHost);
 
+    if (g_SNIHostName == NULL || g_SSLParametersSetServerNames == NULL)
+    {
+        // SSL not supported below API Level 24
+        return UNSUPPORTED_API_LEVEL;
+    }
+
     JNIEnv* env = GetJNIEnv();
 
     int32_t ret = FAIL;
diff --git a/src/libraries/Native/Unix/System.Security.Cryptography.Native.Apple/entrypoints.c b/src/libraries/Native/Unix/System.Security.Cryptography.Native.Apple/entrypoints.c
index 90dd2abe91d104..1833d4a2161ac1 100644
--- a/src/libraries/Native/Unix/System.Security.Cryptography.Native.Apple/entrypoints.c
+++ b/src/libraries/Native/Unix/System.Security.Cryptography.Native.Apple/entrypoints.c
@@ -38,6 +38,7 @@ static const Entry s_cryptoAppleNative[] =
     DllImportEntry(AppleCryptoNative_HmacUpdate)
     DllImportEntry(AppleCryptoNative_HmacFinal)
     DllImportEntry(AppleCryptoNative_HmacCurrent)
+    DllImportEntry(AppleCryptoNative_HmacOneShot)
     DllImportEntry(AppleCryptoNative_SecKeychainItemCopyKeychain)
     DllImportEntry(AppleCryptoNative_SecKeychainCreate)
     DllImportEntry(AppleCryptoNative_SecKeychainDelete)
@@ -105,6 +106,7 @@ static const Entry s_cryptoAppleNative[] =
     DllImportEntry(AppleCryptoNative_GetOSStatusForChainStatus)
     DllImportEntry(AppleCryptoNative_X509ChainSetTrustAnchorCertificates)
     DllImportEntry(AppleCryptoNative_Pbkdf2)
+    DllImportEntry(AppleCryptoNative_X509GetSubjectSummary)
 };
 
 EXTERN_C const void* CryptoAppleResolveDllImport(const char* name);
diff --git a/src/libraries/Native/Unix/System.Security.Cryptography.Native.Apple/pal_hmac.c b/src/libraries/Native/Unix/System.Security.Cryptography.Native.Apple/pal_hmac.c
index 25632ea9a01b0e..4ffbc2f094d9ba 100644
--- a/src/libraries/Native/Unix/System.Security.Cryptography.Native.Apple/pal_hmac.c
+++ b/src/libraries/Native/Unix/System.Security.Cryptography.Native.Apple/pal_hmac.c
@@ -116,7 +116,32 @@ int32_t AppleCryptoNative_HmacCurrent(const HmacCtx* ctx, uint8_t* pbOutput)
 {
     if (ctx == NULL || pbOutput == NULL)
         return 0;
-    
+
     HmacCtx dup = *ctx;
     return AppleCryptoNative_HmacFinal(&dup, pbOutput);
 }
+
+int32_t AppleCryptoNative_HmacOneShot(PAL_HashAlgorithm algorithm,
+                                      const uint8_t* pKey,
+                                      int32_t cbKey,
+                                      const uint8_t* pBuf,
+                                      int32_t cbBuf,
+                                      uint8_t* pOutput,
+                                      int32_t cbOutput,
+                                      int32_t* pcbDigest)
+{
+    if (pOutput == NULL || cbOutput <= 0 || pcbDigest == NULL)
+        return -1;
+
+    CCHmacAlgorithm ccAlgorithm = PalAlgorithmToAppleAlgorithm(algorithm);
+    *pcbDigest = GetHmacOutputSize(algorithm);
+
+    if (ccAlgorithm == UINT_MAX)
+        return -1;
+
+    if (cbOutput < *pcbDigest)
+        return -1;
+
+    CCHmac(ccAlgorithm, pKey, cbKey, pBuf, cbBuf, pOutput);
+    return 1;
+}
diff --git a/src/libraries/Native/Unix/System.Security.Cryptography.Native.Apple/pal_hmac.h b/src/libraries/Native/Unix/System.Security.Cryptography.Native.Apple/pal_hmac.h
index 86d05cc718d67b..28891659241890 100644
--- a/src/libraries/Native/Unix/System.Security.Cryptography.Native.Apple/pal_hmac.h
+++ b/src/libraries/Native/Unix/System.Security.Cryptography.Native.Apple/pal_hmac.h
@@ -51,3 +51,17 @@ Computes the HMAC of the accumulated data in ctx without resetting the state.
 Returns 1 on success, 0 on error.
 */
 PALEXPORT int32_t AppleCryptoNative_HmacCurrent(const HmacCtx* ctx, uint8_t* pbOutput);
+
+/*
+Computes the HMAC of data with a key in to the pOutput buffer in one step.
+
+Return 1 on success, 0 on error, and negative values for invalid input.
+*/
+PALEXPORT int32_t AppleCryptoNative_HmacOneShot(PAL_HashAlgorithm algorithm,
+                                                const uint8_t* pKey,
+                                                int32_t cbKey,
+                                                const uint8_t* pBuf,
+                                                int32_t cbBuf,
+                                                uint8_t* pOutput,
+                                                int32_t cbOutput,
+                                                int32_t* pcbDigest);
diff --git a/src/libraries/Native/Unix/System.Security.Cryptography.Native.Apple/pal_x509.c b/src/libraries/Native/Unix/System.Security.Cryptography.Native.Apple/pal_x509.c
index 7d3e61f4b5d576..0b6d1f889bc691 100644
--- a/src/libraries/Native/Unix/System.Security.Cryptography.Native.Apple/pal_x509.c
+++ b/src/libraries/Native/Unix/System.Security.Cryptography.Native.Apple/pal_x509.c
@@ -230,3 +230,15 @@ int32_t AppleCryptoNative_X509GetRawData(SecCertificateRef cert, CFDataRef* ppDa
     *pOSStatus = *ppDataOut == NULL ? errSecParam : noErr;
     return (*pOSStatus == noErr);
 }
+
+int32_t AppleCryptoNative_X509GetSubjectSummary(SecCertificateRef cert, CFStringRef* ppSummaryOut)
+{
+    if (ppSummaryOut != NULL)
+        *ppSummaryOut = NULL;
+
+    if (cert == NULL || ppSummaryOut == NULL)
+        return kErrorBadInput;
+
+    *ppSummaryOut = SecCertificateCopySubjectSummary(cert);
+    return (*ppSummaryOut != NULL);
+}
diff --git a/src/libraries/Native/Unix/System.Security.Cryptography.Native.Apple/pal_x509.h b/src/libraries/Native/Unix/System.Security.Cryptography.Native.Apple/pal_x509.h
index 28124de10c98d1..a0bc58044c3eb4 100644
--- a/src/libraries/Native/Unix/System.Security.Cryptography.Native.Apple/pal_x509.h
+++ b/src/libraries/Native/Unix/System.Security.Cryptography.Native.Apple/pal_x509.h
@@ -72,3 +72,13 @@ ppDataOut: Receives a CFDataRef with the exported blob
 pOSStatus: Receives the result of SecItemExport
 */
 PALEXPORT int32_t AppleCryptoNative_X509GetRawData(SecCertificateRef cert, CFDataRef* ppDataOut, int32_t* pOSStatus);
+
+/*
+Extract a string that contains a human-readable summary of the contents of the certificate
+
+Returns 1 on success, 0 on failure, any other value indicates invalid state.
+
+Output:
+ppSummaryOut: Receives a CFDataRef with the exported blob
+*/
+PALEXPORT int32_t AppleCryptoNative_X509GetSubjectSummary(SecCertificateRef cert, CFStringRef* ppSummaryOut);
diff --git a/src/libraries/Native/Unix/System.Security.Cryptography.Native/entrypoints.c b/src/libraries/Native/Unix/System.Security.Cryptography.Native/entrypoints.c
index 3ab9ccfffebab1..996921777f6f40 100644
--- a/src/libraries/Native/Unix/System.Security.Cryptography.Native/entrypoints.c
+++ b/src/libraries/Native/Unix/System.Security.Cryptography.Native/entrypoints.c
@@ -202,6 +202,7 @@ static const Entry s_cryptoNative[] =
     DllImportEntry(CryptoNative_HmacCurrent)
     DllImportEntry(CryptoNative_HmacDestroy)
     DllImportEntry(CryptoNative_HmacFinal)
+    DllImportEntry(CryptoNative_HmacOneShot)
     DllImportEntry(CryptoNative_HmacReset)
     DllImportEntry(CryptoNative_HmacUpdate)
     DllImportEntry(CryptoNative_LookupFriendlyNameByOid)
diff --git a/src/libraries/Native/Unix/System.Security.Cryptography.Native/opensslshim.h b/src/libraries/Native/Unix/System.Security.Cryptography.Native/opensslshim.h
index 8bf1befbb0f5b9..09d8351288c6e0 100644
--- a/src/libraries/Native/Unix/System.Security.Cryptography.Native/opensslshim.h
+++ b/src/libraries/Native/Unix/System.Security.Cryptography.Native/opensslshim.h
@@ -362,6 +362,7 @@ const EVP_CIPHER* EVP_chacha20_poly1305(void);
     REQUIRED_FUNCTION(EVP_sha512) \
     REQUIRED_FUNCTION(EXTENDED_KEY_USAGE_free) \
     REQUIRED_FUNCTION(GENERAL_NAMES_free) \
+    REQUIRED_FUNCTION(HMAC) \
     LEGACY_FUNCTION(HMAC_CTX_cleanup) \
     REQUIRED_FUNCTION(HMAC_CTX_copy) \
     FALLBACK_FUNCTION(HMAC_CTX_free) \
@@ -797,6 +798,7 @@ FOR_ALL_OPENSSL_FUNCTIONS
 #define EVP_sha512 EVP_sha512_ptr
 #define EXTENDED_KEY_USAGE_free EXTENDED_KEY_USAGE_free_ptr
 #define GENERAL_NAMES_free GENERAL_NAMES_free_ptr
+#define HMAC HMAC_ptr
 #define HMAC_CTX_cleanup HMAC_CTX_cleanup_ptr
 #define HMAC_CTX_copy HMAC_CTX_copy_ptr
 #define HMAC_CTX_free HMAC_CTX_free_ptr
diff --git a/src/libraries/Native/Unix/System.Security.Cryptography.Native/pal_hmac.c b/src/libraries/Native/Unix/System.Security.Cryptography.Native/pal_hmac.c
index 8871eac848fcee..96b008534c0e2c 100644
--- a/src/libraries/Native/Unix/System.Security.Cryptography.Native/pal_hmac.c
+++ b/src/libraries/Native/Unix/System.Security.Cryptography.Native/pal_hmac.c
@@ -130,3 +130,36 @@ int32_t CryptoNative_HmacCurrent(const HMAC_CTX* ctx, uint8_t* md, int32_t* len)
 
     return 0;
 }
+
+int32_t CryptoNative_HmacOneShot(const EVP_MD* type,
+                                 const uint8_t* key,
+                                 int32_t keySize,
+                                 const uint8_t* source,
+                                 int32_t sourceSize,
+                                 uint8_t* md,
+                                 int32_t* mdSize)
+{
+    assert(mdSize != NULL && type != NULL && md != NULL && mdSize != NULL);
+    assert(keySize >= 0 && *mdSize >= 0);
+    assert(key != NULL || keySize == 0);
+    assert(source != NULL || sourceSize == 0);
+
+    uint8_t empty = 0;
+
+    if (key == NULL)
+    {
+        if (keySize != 0)
+        {
+            return -1;
+        }
+
+        key = &empty;
+    }
+
+    unsigned int unsignedSource = Int32ToUint32(sourceSize);
+    unsigned int unsignedSize = Int32ToUint32(*mdSize);
+    unsigned char* result = HMAC(type, key, keySize, source, unsignedSource, md, &unsignedSize);
+    *mdSize = Uint32ToInt32(unsignedSize);
+
+    return result == NULL ? 0 : 1;
+}
diff --git a/src/libraries/Native/Unix/System.Security.Cryptography.Native/pal_hmac.h b/src/libraries/Native/Unix/System.Security.Cryptography.Native/pal_hmac.h
index e310c054353698..9f8989569da971 100644
--- a/src/libraries/Native/Unix/System.Security.Cryptography.Native/pal_hmac.h
+++ b/src/libraries/Native/Unix/System.Security.Cryptography.Native/pal_hmac.h
@@ -69,3 +69,15 @@ PALEXPORT int32_t CryptoNative_HmacFinal(HMAC_CTX* ctx, uint8_t* md, int32_t* le
  * Returns 1 for success or 0 for failure.
  */
 PALEXPORT int32_t CryptoNative_HmacCurrent(const HMAC_CTX* ctx, uint8_t* md, int32_t* len);
+
+/**
+ * Computes the HMAC of data using a key in a single operation.
+ * Returns -1 on invalid input, 0 on failure, and 1 on success.
+ */
+PALEXPORT int32_t CryptoNative_HmacOneShot(const EVP_MD* type,
+                                           const uint8_t* key,
+                                           int32_t keySize,
+                                           const uint8_t* source,
+                                           int32_t sourceSize,
+                                           uint8_t* md,
+                                           int32_t* mdSize);
diff --git a/src/libraries/Native/Unix/configure.cmake b/src/libraries/Native/Unix/configure.cmake
index 7c0ed7a2af90fa..b2cfdb3bc40c2a 100644
--- a/src/libraries/Native/Unix/configure.cmake
+++ b/src/libraries/Native/Unix/configure.cmake
@@ -219,6 +219,16 @@ check_symbol_exists(
     fcntl.h
     HAVE_POSIX_FALLOCATE64)
 
+check_symbol_exists(
+    preadv
+    sys/uio.h
+    HAVE_PREADV)
+
+check_symbol_exists(
+    pwritev
+    sys/uio.h
+    HAVE_PWRITEV)
+
 check_symbol_exists(
     ioctl
     sys/ioctl.h
@@ -519,9 +529,27 @@ if (CLR_CMAKE_TARGET_LINUX)
     set(HAVE_SUPPORT_FOR_DUAL_MODE_IPV4_PACKET_INFO 1)
 endif ()
 
+check_symbol_exists(
+    malloc_size
+    malloc/malloc.h
+    HAVE_MALLOC_SIZE)
+check_symbol_exists(
+    malloc_usable_size
+    malloc.h
+    HAVE_MALLOC_USABLE_SIZE)
+check_symbol_exists(
+    malloc_usable_size
+    malloc_np.h
+    HAVE_MALLOC_USABLE_SIZE_NP)
+check_symbol_exists(
+    posix_memalign
+    stdlib.h
+    HAVE_POSIX_MEMALIGN)
+
 if(CLR_CMAKE_TARGET_IOS)
     # Manually set results from check_c_source_runs() since it's not possible to actually run it during CMake configure checking
     unset(HAVE_SHM_OPEN_THAT_WORKS_WELL_ENOUGH_WITH_MMAP)
+    unset(HAVE_ALIGNED_ALLOC)   # only exists on iOS 13+
     unset(HAVE_CLOCK_MONOTONIC) # only exists on iOS 10+
     unset(HAVE_CLOCK_REALTIME)  # only exists on iOS 10+
     unset(HAVE_FORK) # exists but blocked by kernel
@@ -529,23 +557,35 @@ elseif(CLR_CMAKE_TARGET_MACCATALYST)
     # Manually set results from check_c_source_runs() since it's not possible to actually run it during CMake configure checking
     # TODO: test to see if these all actually hold true on Mac Catalyst
     unset(HAVE_SHM_OPEN_THAT_WORKS_WELL_ENOUGH_WITH_MMAP)
+    unset(HAVE_ALIGNED_ALLOC)   # only exists on iOS 13+
     unset(HAVE_CLOCK_MONOTONIC) # only exists on iOS 10+
     unset(HAVE_CLOCK_REALTIME)  # only exists on iOS 10+
     unset(HAVE_FORK) # exists but blocked by kernel
 elseif(CLR_CMAKE_TARGET_TVOS)
     # Manually set results from check_c_source_runs() since it's not possible to actually run it during CMake configure checking
     unset(HAVE_SHM_OPEN_THAT_WORKS_WELL_ENOUGH_WITH_MMAP)
+    unset(HAVE_ALIGNED_ALLOC)   # only exists on iOS 13+
     unset(HAVE_CLOCK_MONOTONIC) # only exists on iOS 10+
     unset(HAVE_CLOCK_REALTIME)  # only exists on iOS 10+
     unset(HAVE_FORK) # exists but blocked by kernel
 elseif(CLR_CMAKE_TARGET_ANDROID)
     # Manually set results from check_c_source_runs() since it's not possible to actually run it during CMake configure checking
     unset(HAVE_SHM_OPEN_THAT_WORKS_WELL_ENOUGH_WITH_MMAP)
+    unset(HAVE_ALIGNED_ALLOC) # only exists on newer Android
     set(HAVE_CLOCK_MONOTONIC 1)
     set(HAVE_CLOCK_REALTIME 1)
-elseif (CLR_CMAKE_TARGET_BROWSER)
+elseif(CLR_CMAKE_TARGET_BROWSER)
     set(HAVE_FORK 0)
 else()
+    if(CLR_CMAKE_TARGET_OSX)
+        unset(HAVE_ALIGNED_ALLOC) # only exists on OSX 10.15+
+    else()
+        check_symbol_exists(
+            aligned_alloc
+            stdlib.h
+            HAVE_ALIGNED_ALLOC)
+    endif()
+
     check_c_source_runs(
         "
         #include <sys/mman.h>
diff --git a/src/libraries/NetCoreAppLibrary.props b/src/libraries/NetCoreAppLibrary.props
index c488a78a056559..cd44cc99317ab9 100644
--- a/src/libraries/NetCoreAppLibrary.props
+++ b/src/libraries/NetCoreAppLibrary.props
@@ -145,17 +145,9 @@
       System.Xml.XPath;
       System.Xml.XPath.XDocument;
     </NetCoreAppLibrary>
-    <NetCoreAppLibraryNoReference>
-      Microsoft.Win32.Registry;
-      System.IO.FileSystem.AccessControl;
-      System.IO.Pipes.AccessControl;
-      System.Security.AccessControl;
-      System.Security.Principal.Windows;
-    </NetCoreAppLibraryNoReference>
   </PropertyGroup>
   <!-- Make NetCoreAppLibrary available as an item. -->
   <ItemGroup>
     <NetCoreAppLibrary Include="$(NetCoreAppLibrary)" />
-    <NetCoreAppLibraryNoReference Include="$(NetCoreAppLibraryNoReference)" />
   </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/src/libraries/System.Buffers/tests/ArrayPool/UnitTests.cs b/src/libraries/System.Buffers/tests/ArrayPool/UnitTests.cs
index a917fd3af41c7a..7456e1b46fe68e 100644
--- a/src/libraries/System.Buffers/tests/ArrayPool/UnitTests.cs
+++ b/src/libraries/System.Buffers/tests/ArrayPool/UnitTests.cs
@@ -5,6 +5,7 @@
 using System.Collections.Generic;
 using System.Diagnostics.Tracing;
 using System.Linq;
+using System.Numerics;
 using System.Threading.Tasks;
 using Microsoft.DotNet.RemoteExecutor;
 using Xunit;
@@ -278,23 +279,11 @@ public static void CanRentManySizedBuffers(ArrayPool<byte> pool)
             for (int i = 1; i < 10000; i++)
             {
                 byte[] buffer = pool.Rent(i);
-                Assert.Equal(i <= 16 ? 16 : RoundUpToPowerOf2(i), buffer.Length);
+                Assert.Equal(i <= 16 ? 16 : (int)BitOperations.RoundUpToPowerOf2((uint)i), buffer.Length);
                 pool.Return(buffer);
             }
         }
 
-        private static int RoundUpToPowerOf2(int i)
-        {
-            // http://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
-            --i;
-            i |= i >> 1;
-            i |= i >> 2;
-            i |= i >> 4;
-            i |= i >> 8;
-            i |= i >> 16;
-            return i + 1;
-        }
-
         [Theory]
         [InlineData(1, 16)]
         [InlineData(15, 16)]
diff --git a/src/libraries/System.CodeDom/Directory.Build.props b/src/libraries/System.CodeDom/Directory.Build.props
index e14d822dacdf69..6821d51759dd1c 100644
--- a/src/libraries/System.CodeDom/Directory.Build.props
+++ b/src/libraries/System.CodeDom/Directory.Build.props
@@ -9,5 +9,7 @@ System.CodeDom.CodeObject
 System.CodeDom.Compiler.CodeDomProvider
 Microsoft.CSharp.CSharpCodeProvider
 Microsoft.VisualBasic.VBCodeProvider</PackageDescription>
+    <IncludePlatformAttributes>true</IncludePlatformAttributes>
+    <UnsupportedOSPlatforms>browser;ios;tvos;maccatalyst</UnsupportedOSPlatforms>
   </PropertyGroup>
 </Project>
\ No newline at end of file
diff --git a/src/libraries/System.CodeDom/ref/System.CodeDom.csproj b/src/libraries/System.CodeDom/ref/System.CodeDom.csproj
index a32fa0a3e062bb..3267a92c1d628a 100644
--- a/src/libraries/System.CodeDom/ref/System.CodeDom.csproj
+++ b/src/libraries/System.CodeDom/ref/System.CodeDom.csproj
@@ -1,12 +1,12 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFrameworks>netstandard2.0;net461</TargetFrameworks>
+    <TargetFrameworks>$(NetCoreAppCurrent);netstandard2.0;net461</TargetFrameworks>
   </PropertyGroup>
   <ItemGroup>
     <Compile Condition="'$(TargetFramework)' != 'net461'" Include="System.CodeDom.cs" />
     <Compile Condition="'$(TargetFramework)' == 'net461'" Include="System.CodeDom.net461.cs" />
   </ItemGroup>
   <ItemGroup Condition="'$(TargetFramework)' != 'net461'">
-    <ProjectReference Include="..\..\System.Security.Permissions\ref\System.Security.Permissions.csproj" />
+    <ProjectReference Include="$(LibrariesProjectRoot)System.Security.Permissions\ref\System.Security.Permissions.csproj" />
   </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/src/libraries/System.CodeDom/src/Microsoft/VisualBasic/VBCodeGenerator.cs b/src/libraries/System.CodeDom/src/Microsoft/VisualBasic/VBCodeGenerator.cs
index 028476723aedbe..a25eb3ed7f4fa3 100644
--- a/src/libraries/System.CodeDom/src/Microsoft/VisualBasic/VBCodeGenerator.cs
+++ b/src/libraries/System.CodeDom/src/Microsoft/VisualBasic/VBCodeGenerator.cs
@@ -865,7 +865,11 @@ protected override void GenerateArrayCreateExpression(CodeArrayCreateExpression
                 string typeName = GetTypeOutput(e.CreateType);
                 Output.Write(typeName);
 
-                if (typeName.IndexOf('(') == -1) // string.Contains(char) is .NetCore2.1+ specific
+#if NETCOREAPP
+                if (!typeName.Contains('('))
+#else
+                if (typeName.IndexOf('(') == -1)
+#endif
                 {
                     Output.Write("()");
                 }
diff --git a/src/libraries/System.CodeDom/src/System.CodeDom.csproj b/src/libraries/System.CodeDom/src/System.CodeDom.csproj
index 84dd24091ba613..7977a719807fb3 100644
--- a/src/libraries/System.CodeDom/src/System.CodeDom.csproj
+++ b/src/libraries/System.CodeDom/src/System.CodeDom.csproj
@@ -2,7 +2,7 @@
   <PropertyGroup>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <DefineConstants>$(DefineConstants);CODEDOM</DefineConstants>
-    <TargetFrameworks>netstandard2.0;net461</TargetFrameworks>
+    <TargetFrameworks>$(NetCoreAppCurrent);netstandard2.0;net461</TargetFrameworks>
     <SetIsTrimmable>false</SetIsTrimmable>
   </PropertyGroup>
   <!-- DesignTimeBuild requires all the TargetFramework Derived Properties to not be present in the first property group. -->
@@ -129,4 +129,18 @@
     <Compile Include="System\Collections\Specialized\FixedStringLookup.cs" />
     <Compile Include="$(CommonPath)System\CSharpHelpers.cs" />
   </ItemGroup>
+  <ItemGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp'">
+    <Reference Include="System.Collections" />
+    <Reference Include="System.Collections.NonGeneric" />
+    <Reference Include="System.Collections.Specialized" />
+    <Reference Include="System.ComponentModel.Primitives" />
+    <Reference Include="System.ComponentModel.TypeConverter" />
+    <Reference Include="System.Diagnostics.Debug" />
+    <Reference Include="System.Diagnostics.Process" />
+    <Reference Include="System.IO.FileSystem" />
+    <Reference Include="System.Resources.ResourceManager" />
+    <Reference Include="System.Runtime" />
+    <Reference Include="System.Runtime.Extensions" />
+    <Reference Include="System.Threading" />
+  </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/src/libraries/System.Collections.Immutable/ref/System.Collections.Immutable.cs b/src/libraries/System.Collections.Immutable/ref/System.Collections.Immutable.cs
index 7e060514da2bfb..b70fcca6b235c6 100644
--- a/src/libraries/System.Collections.Immutable/ref/System.Collections.Immutable.cs
+++ b/src/libraries/System.Collections.Immutable/ref/System.Collections.Immutable.cs
@@ -417,7 +417,7 @@ public static partial class ImmutableHashSet
         public static System.Collections.Immutable.ImmutableHashSet<TSource> ToImmutableHashSet<TSource>(this System.Collections.Immutable.ImmutableHashSet<TSource>.Builder builder) { throw null; }
     }
 
-    #if !NETSTANDARD2_0 && !NETFRAMEWORK
+#if NET5_0_OR_GREATER
     public sealed partial class ImmutableHashSet<T> : System.Collections.Generic.ICollection<T>, System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IReadOnlyCollection<T>, System.Collections.Generic.ISet<T>, System.Collections.Generic.IReadOnlySet<T>, System.Collections.ICollection, System.Collections.IEnumerable, System.Collections.Immutable.IImmutableSet<T>
 #else
     public sealed partial class ImmutableHashSet<T> : System.Collections.Generic.ICollection<T>, System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IReadOnlyCollection<T>, System.Collections.Generic.ISet<T>, System.Collections.ICollection, System.Collections.IEnumerable, System.Collections.Immutable.IImmutableSet<T>
@@ -905,7 +905,7 @@ public static partial class ImmutableSortedSet
         public static System.Collections.Immutable.ImmutableSortedSet<TSource> ToImmutableSortedSet<TSource>(this System.Collections.Immutable.ImmutableSortedSet<TSource>.Builder builder) { throw null; }
     }
 
-#if !NETSTANDARD2_0 && !NETFRAMEWORK
+#if NET5_0_OR_GREATER
     public sealed partial class ImmutableSortedSet<T> : System.Collections.Generic.ICollection<T>, System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IList<T>, System.Collections.Generic.IReadOnlyCollection<T>, System.Collections.Generic.IReadOnlyList<T>, System.Collections.Generic.ISet<T>, System.Collections.Generic.IReadOnlySet<T>, System.Collections.ICollection, System.Collections.IEnumerable, System.Collections.IList, System.Collections.Immutable.IImmutableSet<T>
 #else
     public sealed partial class ImmutableSortedSet<T> : System.Collections.Generic.ICollection<T>, System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IList<T>, System.Collections.Generic.IReadOnlyCollection<T>, System.Collections.Generic.IReadOnlyList<T>, System.Collections.Generic.ISet<T>, System.Collections.ICollection, System.Collections.IEnumerable, System.Collections.IList, System.Collections.Immutable.IImmutableSet<T>
diff --git a/src/libraries/System.Collections.Immutable/ref/System.Collections.Immutable.csproj b/src/libraries/System.Collections.Immutable/ref/System.Collections.Immutable.csproj
index 3d1674e34b356b..01c989df4fef66 100644
--- a/src/libraries/System.Collections.Immutable/ref/System.Collections.Immutable.csproj
+++ b/src/libraries/System.Collections.Immutable/ref/System.Collections.Immutable.csproj
@@ -1,7 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <TargetFrameworks>$(NetCoreAppCurrent);netstandard2.0;net461</TargetFrameworks>
-    <ExcludeCurrentNetCoreAppFromPackage>true</ExcludeCurrentNetCoreAppFromPackage>
     <Nullable>enable</Nullable>
   </PropertyGroup>
   <ItemGroup>
diff --git a/src/libraries/System.Collections.Immutable/src/System.Collections.Immutable.csproj b/src/libraries/System.Collections.Immutable/src/System.Collections.Immutable.csproj
index b9993c0d4afcc1..c9d746fd13b6b7 100644
--- a/src/libraries/System.Collections.Immutable/src/System.Collections.Immutable.csproj
+++ b/src/libraries/System.Collections.Immutable/src/System.Collections.Immutable.csproj
@@ -1,7 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <TargetFrameworks>$(NetCoreAppCurrent);netstandard2.0;net461</TargetFrameworks>
-    <ExcludeCurrentNetCoreAppFromPackage>true</ExcludeCurrentNetCoreAppFromPackage>
     <Nullable>enable</Nullable>
   </PropertyGroup>
   <ItemGroup>
@@ -85,7 +84,10 @@
              Link="Common\System\Runtime\Versioning\NonVersionableAttribute.cs" />
     <None Include="Interfaces.cd" />
   </ItemGroup>
-  <ItemGroup Condition="'$(TargetFramework)' == '$(NetCoreAppCurrent)'">
+  <ItemGroup>
+    <ProjectReference Include="$(LibrariesProjectRoot)System.Runtime.CompilerServices.Unsafe\src\System.Runtime.CompilerServices.Unsafe.ilproj" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp'">
     <Reference Include="System.Collections" />
     <Reference Include="System.Diagnostics.Contracts" />
     <Reference Include="System.Diagnostics.Debug" />
@@ -94,7 +96,6 @@
     <Reference Include="System.Linq" />
     <Reference Include="System.Resources.ResourceManager" />
     <Reference Include="System.Runtime" />
-    <Reference Include="System.Runtime.CompilerServices.Unsafe" />
     <Reference Include="System.Runtime.Extensions" />
     <Reference Include="System.Runtime.InteropServices" />
     <Reference Include="System.Threading" />
@@ -102,7 +103,4 @@
   <ItemGroup Condition="'$(TargetFrameworkIdentifier)' != '.NETCoreApp'">
     <PackageReference Include="System.Memory"  Version="$(SystemMemoryVersion)" />
   </ItemGroup>
-  <ItemGroup Condition="'$(TargetFramework)' != '$(NetCoreAppCurrent)'">
-    <ProjectReference Include="$(LibrariesProjectRoot)System.Runtime.CompilerServices.Unsafe\src\System.Runtime.CompilerServices.Unsafe.ilproj" />
-  </ItemGroup>
 </Project>
diff --git a/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableHashSet_1.cs b/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableHashSet_1.cs
index 3f67d39ef067ab..bfcae53cf8083c 100644
--- a/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableHashSet_1.cs
+++ b/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableHashSet_1.cs
@@ -14,7 +14,7 @@ namespace System.Collections.Immutable
     /// <typeparam name="T">The type of elements in the set.</typeparam>
     [DebuggerDisplay("Count = {Count}")]
     [DebuggerTypeProxy(typeof(ImmutableEnumerableDebuggerProxy<>))]
-#if !NETSTANDARD2_0 && !NETFRAMEWORK
+#if NET5_0_OR_GREATER
     public sealed partial class ImmutableHashSet<T> : IImmutableSet<T>, IHashKeyCollection<T>, IReadOnlyCollection<T>, ICollection<T>, ISet<T>, IReadOnlySet<T>, ICollection, IStrongEnumerable<T, ImmutableHashSet<T>.Enumerator>
 #else
     public sealed partial class ImmutableHashSet<T> : IImmutableSet<T>, IHashKeyCollection<T>, IReadOnlyCollection<T>, ICollection<T>, ISet<T>, ICollection, IStrongEnumerable<T, ImmutableHashSet<T>.Enumerator>
diff --git a/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableSortedSet_1.cs b/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableSortedSet_1.cs
index 1beb3df403dbd2..c0e69a79ec782d 100644
--- a/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableSortedSet_1.cs
+++ b/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableSortedSet_1.cs
@@ -19,7 +19,7 @@ namespace System.Collections.Immutable
     /// </devremarks>
     [DebuggerDisplay("Count = {Count}")]
     [DebuggerTypeProxy(typeof(ImmutableEnumerableDebuggerProxy<>))]
-#if !NETSTANDARD2_0 && !NETFRAMEWORK
+#if NET5_0_OR_GREATER
     public sealed partial class ImmutableSortedSet<T> : IImmutableSet<T>, ISortKeyCollection<T>, IReadOnlySet<T>, IReadOnlyList<T>, IList<T>, ISet<T>, IList, IStrongEnumerable<T, ImmutableSortedSet<T>.Enumerator>
 #else
     public sealed partial class ImmutableSortedSet<T> : IImmutableSet<T>, ISortKeyCollection<T>, IReadOnlyList<T>, IList<T>, ISet<T>, IList, IStrongEnumerable<T, ImmutableSortedSet<T>.Enumerator>
diff --git a/src/libraries/System.Collections.Immutable/tests/ImmutableDictionaryTestBase.nonnetstandard.cs b/src/libraries/System.Collections.Immutable/tests/ImmutableDictionaryTestBase.nonnetstandard.cs
index 36615bb91963e9..3ea83edeba4f6e 100644
--- a/src/libraries/System.Collections.Immutable/tests/ImmutableDictionaryTestBase.nonnetstandard.cs
+++ b/src/libraries/System.Collections.Immutable/tests/ImmutableDictionaryTestBase.nonnetstandard.cs
@@ -75,7 +75,6 @@ public void EqualsTest()
         }
 
         [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
         public void AddRangeTest()
         {
             var map = Empty<int, GenericParameterHelper>();
diff --git a/src/libraries/System.Collections.Immutable/tests/ImmutableSortedDictionaryTest.cs b/src/libraries/System.Collections.Immutable/tests/ImmutableSortedDictionaryTest.cs
index eba271b2f418af..c0ba89103cd096 100644
--- a/src/libraries/System.Collections.Immutable/tests/ImmutableSortedDictionaryTest.cs
+++ b/src/libraries/System.Collections.Immutable/tests/ImmutableSortedDictionaryTest.cs
@@ -102,7 +102,6 @@ public void AddExistingKeyDifferentValueTest()
         }
 
         [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
         public void ToUnorderedTest()
         {
             var sortedMap = Empty<int, GenericParameterHelper>().AddRange(Enumerable.Range(1, 100).Select(n => new KeyValuePair<int, GenericParameterHelper>(n, new GenericParameterHelper(n))));
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 12853ebe3622d4..ce4ba761ab7aff 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
@@ -1,9 +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.Diagnostics;
-using System.Text;
 using System.Diagnostics.CodeAnalysis;
+using System.Numerics;
 
 namespace System.Collections.Specialized
 {
@@ -93,18 +92,6 @@ public int Data
             }
         }
 
-        private static short CountBitsSet(short mask)
-        {
-            // We assume that the bits are always right aligned, with no holes (i.e. always 00000111, never 00100011)
-            short value = 0;
-            while ((mask & 0x1) != 0)
-            {
-                value++;
-                mask >>= 1;
-            }
-            return value;
-        }
-
         /// <devdoc>
         ///    <para> Creates the first mask in a series.</para>
         /// </devdoc>
@@ -131,29 +118,6 @@ public static int CreateMask(int previous)
             return previous << 1;
         }
 
-        /// <devdoc>
-        ///     Given a highValue, creates the mask
-        /// </devdoc>
-        private static short CreateMaskFromHighValue(short highValue)
-        {
-            short required = 16;
-            while ((highValue & 0x8000) == 0)
-            {
-                required--;
-                highValue <<= 1;
-            }
-
-            ushort value = 0;
-            while (required > 0)
-            {
-                required--;
-                value <<= 1;
-                value |= 0x1;
-            }
-
-            return unchecked((short)value);
-        }
-
         /// <devdoc>
         ///    <para>Creates the first section in a series, with the specified maximum value.</para>
         /// </devdoc>
@@ -177,28 +141,19 @@ private static Section CreateSectionHelper(short maxValue, short priorMask, shor
                 throw new ArgumentException(SR.Format(SR.Argument_InvalidValue_TooSmall, nameof(maxValue), 1), nameof(maxValue));
             }
 
-            short offset = (short)(priorOffset + CountBitsSet(priorMask));
+            short offset = (short)(priorOffset + BitOperations.PopCount((uint)(ushort)priorMask));
             if (offset >= 32)
             {
                 throw new InvalidOperationException(SR.BitVectorFull);
             }
-            return new Section(CreateMaskFromHighValue(maxValue), offset);
-        }
-
-        public override bool Equals([NotNullWhen(true)] object? o)
-        {
-            if (!(o is BitVector32))
-            {
-                return false;
-            }
 
-            return _data == ((BitVector32)o)._data;
+            short mask = (short)(BitOperations.RoundUpToPowerOf2((uint)(ushort)maxValue + 1) - 1);
+            return new Section(mask, offset);
         }
 
-        public override int GetHashCode()
-        {
-            return base.GetHashCode();
-        }
+        public override bool Equals([NotNullWhen(true)] object? o) => o is BitVector32 other && _data == other._data;
+
+        public override int GetHashCode() => _data.GetHashCode();
 
         public static string ToString(BitVector32 value)
         {
@@ -238,29 +193,11 @@ internal Section(short mask, short offset)
                 _offset = offset;
             }
 
-            public short Mask
-            {
-                get
-                {
-                    return _mask;
-                }
-            }
+            public short Mask => _mask;
 
-            public short Offset
-            {
-                get
-                {
-                    return _offset;
-                }
-            }
+            public short Offset => _offset;
 
-            public override bool Equals([NotNullWhen(true)] object? o)
-            {
-                if (o is Section)
-                    return Equals((Section)o);
-                else
-                    return false;
-            }
+            public override bool Equals([NotNullWhen(true)] object? o) => o is Section other && Equals(other);
 
             public bool Equals(Section obj)
             {
@@ -277,14 +214,11 @@ public bool Equals(Section obj)
                 return !(a == b);
             }
 
-            public override int GetHashCode()
-            {
-                return base.GetHashCode();
-            }
+            public override int GetHashCode() => HashCode.Combine(_mask, _offset);
 
             public static string ToString(Section value)
             {
-                return "Section{0x" + Convert.ToString(value.Mask, 16) + ", 0x" + Convert.ToString(value.Offset, 16) + "}";
+                return $"Section{{0x{value.Mask:x}, 0x{value.Offset:x}}}";
             }
 
             public override string ToString()
diff --git a/src/libraries/System.ComponentModel.Composition/ref/System.ComponentModel.Composition.csproj b/src/libraries/System.ComponentModel.Composition/ref/System.ComponentModel.Composition.csproj
index 543c5c85ca1d35..5b6fcbd2306e23 100644
--- a/src/libraries/System.ComponentModel.Composition/ref/System.ComponentModel.Composition.csproj
+++ b/src/libraries/System.ComponentModel.Composition/ref/System.ComponentModel.Composition.csproj
@@ -1,10 +1,17 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFrameworks>netstandard2.0</TargetFrameworks>
+    <TargetFrameworks>$(NetCoreAppCurrent);netcoreapp3.1;netstandard2.0</TargetFrameworks>
     <Nullable>enable</Nullable>
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="System.ComponentModel.Composition.cs" />
     <Compile Include="System.ComponentModel.Composition.Forwards.cs" />
   </ItemGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == '$(NetCoreAppCurrent)'">
+    <ProjectReference Include="$(LibrariesProjectRoot)System.Linq.Expressions\ref\System.Linq.Expressions.csproj" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == 'netcoreapp3.1'">
+    <Reference Include="System.Linq.Expressions" />
+    <Reference Include="System.Runtime" />
+  </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/src/libraries/System.ComponentModel.Composition/src/System.ComponentModel.Composition.csproj b/src/libraries/System.ComponentModel.Composition/src/System.ComponentModel.Composition.csproj
index cf8fe4f6249a0b..e35314716013a2 100644
--- a/src/libraries/System.ComponentModel.Composition/src/System.ComponentModel.Composition.csproj
+++ b/src/libraries/System.ComponentModel.Composition/src/System.ComponentModel.Composition.csproj
@@ -1,7 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <TargetFrameworks>$(NetCoreAppCurrent);netcoreapp3.1;netstandard2.0</TargetFrameworks>
-    <ExcludeCurrentNetCoreAppFromPackage>true</ExcludeCurrentNetCoreAppFromPackage>
     <Nullable>enable</Nullable>
     <SetIsTrimmable>false</SetIsTrimmable>
   </PropertyGroup>
diff --git a/src/libraries/System.ComponentModel.Composition/tests/System/ComponentModel/Composition/CompositionContainerTests.cs b/src/libraries/System.ComponentModel.Composition/tests/System/ComponentModel/Composition/CompositionContainerTests.cs
index 9fa75345a1534c..93432aa8789fe3 100644
--- a/src/libraries/System.ComponentModel.Composition/tests/System/ComponentModel/Composition/CompositionContainerTests.cs
+++ b/src/libraries/System.ComponentModel.Composition/tests/System/ComponentModel/Composition/CompositionContainerTests.cs
@@ -1699,7 +1699,6 @@ public void GetExports1_TypeAsMetadataViewTypeArgument_IsUsedAsMetadataConstrain
         }
 
         [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
         public void GetExports2_TypeAsMetadataViewTypeArgument_IsUsedAsMetadataConstraint()
         {
             var metadata = new Dictionary<string, object>();
diff --git a/src/libraries/System.ComponentModel.Composition/tests/System/ComponentModel/Composition/ExportCollectionTests.cs b/src/libraries/System.ComponentModel.Composition/tests/System/ComponentModel/Composition/ExportCollectionTests.cs
index 6a6cad837a877f..2bdbd73252c301 100644
--- a/src/libraries/System.ComponentModel.Composition/tests/System/ComponentModel/Composition/ExportCollectionTests.cs
+++ b/src/libraries/System.ComponentModel.Composition/tests/System/ComponentModel/Composition/ExportCollectionTests.cs
@@ -142,7 +142,6 @@ public class ExporterDefault42
 
         [Fact]
         [ActiveIssue("https://github.com/dotnet/runtime/issues/31792", TestRuntimes.Mono)]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/49365", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
         [Trait("Type", "Integration")]
         public void ImportCollectionsFromContainerOnly()
         {
diff --git a/src/libraries/System.ComponentModel.TypeConverter/src/System/ComponentModel/NullableConverter.cs b/src/libraries/System.ComponentModel.TypeConverter/src/System/ComponentModel/NullableConverter.cs
index 9bcfdc0b03300f..08a077b037d733 100644
--- a/src/libraries/System.ComponentModel.TypeConverter/src/System/ComponentModel/NullableConverter.cs
+++ b/src/libraries/System.ComponentModel.TypeConverter/src/System/ComponentModel/NullableConverter.cs
@@ -15,6 +15,8 @@ namespace System.ComponentModel
     /// </summary>
     public class NullableConverter : TypeConverter
     {
+        private static readonly ConstructorInfo s_nullableConstructor = typeof(Nullable<>).GetConstructor(typeof(Nullable<>).GetGenericArguments())!;
+
         /// <summary>
         /// Nullable converter is initialized with the underlying simple type.
         /// </summary>
@@ -108,7 +110,7 @@ public override object ConvertTo(ITypeDescriptorContext context, CultureInfo cul
             }
             else if (destinationType == typeof(InstanceDescriptor))
             {
-                ConstructorInfo ci = GetNullableConstructor();
+                ConstructorInfo ci = (ConstructorInfo)NullableType.GetMemberWithSameMetadataDefinitionAs(s_nullableConstructor);
                 Debug.Assert(ci != null, "Couldn't find constructor");
                 return new InstanceDescriptor(ci, new object[] { value }, true);
             }
@@ -128,14 +130,6 @@ public override object ConvertTo(ITypeDescriptorContext context, CultureInfo cul
             return base.ConvertTo(context, culture, value, destinationType);
         }
 
-        [DynamicDependency(DynamicallyAccessedMemberTypes.PublicConstructors, typeof(Nullable<>))]
-        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2075:UnrecognizedReflectionPattern",
-            Justification = "The Nullable<T> ctor will be preserved by the DynamicDependency.")]
-        private ConstructorInfo GetNullableConstructor()
-        {
-            return NullableType.GetConstructor(new Type[] { UnderlyingType })!;
-        }
-
         /// <summary>
         /// </summary>
         public override object CreateInstance(ITypeDescriptorContext context, IDictionary propertyValues)
diff --git a/src/libraries/System.Composition.Hosting/tests/System/Composition/Hosting/Core/CompositionHostTests.cs b/src/libraries/System.Composition.Hosting/tests/System/Composition/Hosting/Core/CompositionHostTests.cs
index 3024c07ae20721..f703345120442f 100644
--- a/src/libraries/System.Composition.Hosting/tests/System/Composition/Hosting/Core/CompositionHostTests.cs
+++ b/src/libraries/System.Composition.Hosting/tests/System/Composition/Hosting/Core/CompositionHostTests.cs
@@ -133,7 +133,6 @@ public override IEnumerable<ExportDescriptorPromise> GetExportDescriptors(Compos
         [InlineData(typeof(Lazy<int, IDictionary<string, string>>))]
         [InlineData(typeof(Lazy<int, PrivateConstructor>))]
         [InlineData(typeof(Lazy<int, NoParameterlessConstructor>))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
         public void GetExport_InvalidMetadata_ThrowsComposititionFailedException(Type type)
         {
             using (CompositionHost host = CompositionHost.CreateCompositionHost(new ExportDescriptorProvider[0]))
diff --git a/src/libraries/System.Configuration.ConfigurationManager/Directory.Build.props b/src/libraries/System.Configuration.ConfigurationManager/Directory.Build.props
index 24e9eeb056f084..844af4fbfc939c 100644
--- a/src/libraries/System.Configuration.ConfigurationManager/Directory.Build.props
+++ b/src/libraries/System.Configuration.ConfigurationManager/Directory.Build.props
@@ -3,6 +3,7 @@
   <PropertyGroup>
     <StrongNameKeyId>Open</StrongNameKeyId>
     <IncludePlatformAttributes>true</IncludePlatformAttributes>
+    <UnsupportedOSPlatforms>browser</UnsupportedOSPlatforms>
     <PackageDescription>Provides types that support using configuration files.
 
 Commonly Used Types:
diff --git a/src/libraries/System.Configuration.ConfigurationManager/ref/System.Configuration.ConfigurationManager.cs b/src/libraries/System.Configuration.ConfigurationManager/ref/System.Configuration.ConfigurationManager.cs
index b418b345716161..f4171af9de41d2 100644
--- a/src/libraries/System.Configuration.ConfigurationManager/ref/System.Configuration.ConfigurationManager.cs
+++ b/src/libraries/System.Configuration.ConfigurationManager/ref/System.Configuration.ConfigurationManager.cs
@@ -1052,6 +1052,7 @@ public partial class SettingsAttributeDictionary : System.Collections.Hashtable
     {
         public SettingsAttributeDictionary() { }
         public SettingsAttributeDictionary(System.Configuration.SettingsAttributeDictionary attributes) { }
+        protected SettingsAttributeDictionary(System.Runtime.Serialization.SerializationInfo serializationInfo, System.Runtime.Serialization.StreamingContext streamingContext) { }
     }
     public abstract partial class SettingsBase
     {
@@ -1070,6 +1071,7 @@ public virtual void Save() { }
     public partial class SettingsContext : System.Collections.Hashtable
     {
         public SettingsContext() { }
+        protected SettingsContext(System.Runtime.Serialization.SerializationInfo serializationInfo, System.Runtime.Serialization.StreamingContext streamingContext) { }
     }
     [System.AttributeUsageAttribute(System.AttributeTargets.Property)]
     public sealed partial class SettingsDescriptionAttribute : System.Attribute
@@ -1381,7 +1383,9 @@ public virtual void DeleteStream(string streamName) { }
         public virtual string GetConfigPathFromLocationSubPath(string configPath, string locationSubPath) { throw null; }
         public virtual System.Type GetConfigType(string typeName, bool throwOnError) { throw null; }
         public virtual string GetConfigTypeName(System.Type t) { throw null; }
+#pragma warning disable SYSLIB0003
         public virtual void GetRestrictedPermissions(System.Configuration.Internal.IInternalConfigRecord configRecord, out System.Security.PermissionSet permissionSet, out bool isHostReady) { throw null; }
+#pragma warning restore SYSLIB0003
         public virtual string GetStreamName(string configPath) { throw null; }
         public virtual string GetStreamNameForConfigSource(string streamName, string configSource) { throw null; }
         public virtual object GetStreamVersion(string streamName) { throw null; }
@@ -1469,7 +1473,9 @@ public partial interface IInternalConfigHost
         string GetConfigPathFromLocationSubPath(string configPath, string locationSubPath);
         System.Type GetConfigType(string typeName, bool throwOnError);
         string GetConfigTypeName(System.Type t);
+#pragma warning disable SYSLIB0003
         void GetRestrictedPermissions(System.Configuration.Internal.IInternalConfigRecord configRecord, out System.Security.PermissionSet permissionSet, out bool isHostReady);
+#pragma warning restore SYSLIB0003
         string GetStreamName(string configPath);
         string GetStreamNameForConfigSource(string streamName, string configSource);
         object GetStreamVersion(string streamName);
diff --git a/src/libraries/System.Configuration.ConfigurationManager/ref/System.Configuration.ConfigurationManager.csproj b/src/libraries/System.Configuration.ConfigurationManager/ref/System.Configuration.ConfigurationManager.csproj
index f1892d24df1750..fa1f81b9e19873 100644
--- a/src/libraries/System.Configuration.ConfigurationManager/ref/System.Configuration.ConfigurationManager.csproj
+++ b/src/libraries/System.Configuration.ConfigurationManager/ref/System.Configuration.ConfigurationManager.csproj
@@ -1,17 +1,20 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFrameworks>netstandard2.0;net461</TargetFrameworks>
+    <TargetFrameworks>$(NetCoreAppCurrent);netstandard2.0;net461</TargetFrameworks>
     <NoWarn>$(NoWarn);CS0618</NoWarn>
   </PropertyGroup>
-  <ItemGroup Condition="'$(TargetFramework)' != 'net461'">
-    <Compile Include="System.Configuration.ConfigurationManager.cs" />
-    <Compile Include="$(CommonPath)System\Obsoletions.cs" Link="Common\System\Obsoletions.cs" />
+  <ItemGroup >
+    <Compile Include="System.Configuration.ConfigurationManager.cs" Condition="'$(TargetFramework)' != 'net461'" />
+    <Compile Include="$(CommonPath)System\Obsoletions.cs" Link="Common\System\Obsoletions.cs" Condition="'$(TargetFramework)' != 'net461'" />
+    <Compile Include="System.Configuration.ConfigurationManager.net461.cs" Condition="'$(TargetFramework)' == 'net461'" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="$(LibrariesProjectRoot)System.Security.Permissions\ref\System.Security.Permissions.csproj" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == '$(NetCoreAppCurrent)'">
+    <ProjectReference Include="$(LibrariesProjectRoot)System.Xml.ReaderWriter\ref\System.Xml.ReaderWriter.csproj" />
   </ItemGroup>
   <ItemGroup Condition="'$(TargetFramework)' == 'net461'">
-    <Compile Include="System.Configuration.ConfigurationManager.net461.cs" />
     <Reference Include="System.Configuration" />
   </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="..\..\System.Security.Permissions\ref\System.Security.Permissions.csproj" />
-  </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/src/libraries/System.Configuration.ConfigurationManager/src/System.Configuration.ConfigurationManager.csproj b/src/libraries/System.Configuration.ConfigurationManager/src/System.Configuration.ConfigurationManager.csproj
index a7fcc9e7abaeb5..209d36e49c51b5 100644
--- a/src/libraries/System.Configuration.ConfigurationManager/src/System.Configuration.ConfigurationManager.csproj
+++ b/src/libraries/System.Configuration.ConfigurationManager/src/System.Configuration.ConfigurationManager.csproj
@@ -1,12 +1,13 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFrameworks>netstandard2.0;net461</TargetFrameworks>
+    <TargetFrameworks>$(NetCoreAppCurrent);netstandard2.0;net461</TargetFrameworks>
     <!-- opt-out of trimming until it works https://github.com/dotnet/runtime/issues/49062 -->
     <SetIsTrimmable>false</SetIsTrimmable>
+    <NoWarn>$(NoWarn);CA1847</NoWarn>
   </PropertyGroup>
   <!-- DesignTimeBuild requires all the TargetFramework Derived Properties to not be present in the first property group. -->
   <PropertyGroup>
-    <IsPartialFacadeAssembly Condition="$(TargetFramework.StartsWith('net4'))">true</IsPartialFacadeAssembly>
+    <IsPartialFacadeAssembly Condition="'$(TargetFramework)' == 'net461'">true</IsPartialFacadeAssembly>
   </PropertyGroup>
   <ItemGroup Condition="'$(IsPartialFacadeAssembly)' != 'true'">
     <Compile Include="System\Configuration\DictionarySectionHandler.cs" />
@@ -251,13 +252,42 @@
     <Compile Include="$(CommonPath)System\IO\TempFileCollection.cs"
              Link="Common\System\IO\TempFileCollection.cs" />
     <Compile Include="$(CommonPath)System\Obsoletions.cs" Link="Common\System\Obsoletions.cs" />
-    <Compile Include="$(CoreLibSharedDir)System\Diagnostics\CodeAnalysis\UnconditionalSuppressMessageAttribute.cs" />
+    <Compile Include="$(CoreLibSharedDir)System\Diagnostics\CodeAnalysis\UnconditionalSuppressMessageAttribute.cs"
+             Condition="!$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net5.0'))" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp'">
+    <Reference Include="System.Collections" />
+    <Reference Include="System.Collections.NonGeneric" />
+    <Reference Include="System.Collections.Specialized" />
+    <Reference Include="System.ComponentModel" />
+    <Reference Include="System.ComponentModel.Primitives" />
+    <Reference Include="System.ComponentModel.TypeConverter" />
+    <Reference Include="System.Diagnostics.Debug" />
+    <Reference Include="System.Diagnostics.Process" />
+    <Reference Include="System.Diagnostics.Tools" />
+    <Reference Include="System.IO.FileSystem" />
+    <Reference Include="System.Net.Primitives" />
+    <Reference Include="System.ObjectModel" />
+    <Reference Include="System.Resources.ResourceManager" />
+    <Reference Include="System.Runtime" />
+    <Reference Include="System.Runtime.Extensions" />
+    <Reference Include="System.Runtime.InteropServices.RuntimeInformation" />
+    <Reference Include="System.Runtime.Serialization.Formatters" />
+    <Reference Include="System.Security.Cryptography.Algorithms" />
+    <Reference Include="System.Security.Cryptography.Primitives" />
+    <Reference Include="System.Text.RegularExpressions" />
+    <Reference Include="System.Text.Encoding.Extensions" />
+    <Reference Include="System.Threading" />
+    <Reference Include="System.Threading.Thread" />
+    <Reference Include="System.Net.WebClient" />
+    <Reference Include="System.Xml.ReaderWriter" />
+    <Reference Include="System.Xml.XmlSerializer" />
   </ItemGroup>
   <ItemGroup Condition="'$(IsPartialFacadeAssembly)' != 'true'">
     <ProjectReference Include="$(LibrariesProjectRoot)System.Security.Cryptography.ProtectedData\src\System.Security.Cryptography.ProtectedData.csproj" />
     <ProjectReference Include="$(LibrariesProjectRoot)System.Security.Permissions\src\System.Security.Permissions.csproj" />
   </ItemGroup>
-  <ItemGroup Condition="'$(IsPartialFacadeAssembly)' == 'true'">
+  <ItemGroup Condition="'$(TargetFramework)' == 'net461'">
     <Reference Include="System.Configuration" />
   </ItemGroup>
 </Project>
diff --git a/src/libraries/System.Configuration.ConfigurationManager/src/System/Configuration/ClientConfigurationHost.cs b/src/libraries/System.Configuration.ConfigurationManager/src/System/Configuration/ClientConfigurationHost.cs
index c906306c539276..190ec71abaf03d 100644
--- a/src/libraries/System.Configuration.ConfigurationManager/src/System/Configuration/ClientConfigurationHost.cs
+++ b/src/libraries/System.Configuration.ConfigurationManager/src/System/Configuration/ClientConfigurationHost.cs
@@ -282,6 +282,7 @@ public override Stream OpenStreamForRead(string streamName)
 
             if (streamName == null) return null;
 
+#pragma warning disable SYSLIB0014 // WebClient is obsolete.
             // scheme is http
             WebClient client = new WebClient();
 
@@ -298,6 +299,7 @@ public override Stream OpenStreamForRead(string streamName)
                 fileData = client.DownloadData(streamName);
             }
             catch { }
+#pragma warning restore SYSLIB0014
 
             if (fileData == null) return null;
 
diff --git a/src/libraries/System.Configuration.ConfigurationManager/src/System/Configuration/ConfigurationLockCollection.cs b/src/libraries/System.Configuration.ConfigurationManager/src/System/Configuration/ConfigurationLockCollection.cs
index f2f9b647546a00..60867e30f4190d 100644
--- a/src/libraries/System.Configuration.ConfigurationManager/src/System/Configuration/ConfigurationLockCollection.cs
+++ b/src/libraries/System.Configuration.ConfigurationManager/src/System/Configuration/ConfigurationLockCollection.cs
@@ -220,7 +220,11 @@ internal bool DefinedInParent(string name)
 
             string parentListEnclosed = "," + _seedList + ",";
             if (name.Equals(_ignoreName) ||
-                (parentListEnclosed.IndexOf("," + name + ",", StringComparison.Ordinal) >= 0))
+#if NETCOREAPP
+                parentListEnclosed.Contains("," + name + ",", StringComparison.Ordinal))
+#else
+                parentListEnclosed.IndexOf("," + name + ",", StringComparison.Ordinal) >= 0)
+#endif
                 return true;
             return _internalDictionary.Contains(name) &&
                 (((ConfigurationValueFlags)_internalDictionary[name] & ConfigurationValueFlags.Inherited) != 0);
diff --git a/src/libraries/System.Configuration.ConfigurationManager/src/System/Configuration/ConfigurationProperty.cs b/src/libraries/System.Configuration.ConfigurationManager/src/System/Configuration/ConfigurationProperty.cs
index 7602d12216380b..7f4299b69f76c6 100644
--- a/src/libraries/System.Configuration.ConfigurationManager/src/System/Configuration/ConfigurationProperty.cs
+++ b/src/libraries/System.Configuration.ConfigurationManager/src/System/Configuration/ConfigurationProperty.cs
@@ -133,7 +133,14 @@ internal ConfigurationProperty(PropertyInfo info)
 
                 if (collectionAttribute != null)
                 {
-                    if (collectionAttribute.AddItemName.IndexOf(',') == -1) AddElementName = collectionAttribute.AddItemName; // string.Contains(char) is .NetCore2.1+ specific
+#if NETCOREAPP
+                    if (!collectionAttribute.AddItemName.Contains(','))
+#else
+                    if (collectionAttribute.AddItemName.IndexOf(',') == -1)
+#endif
+                    {
+                      AddElementName = collectionAttribute.AddItemName;
+                    }
                     RemoveElementName = collectionAttribute.RemoveItemName;
                     ClearElementName = collectionAttribute.ClearItemsName;
                 }
diff --git a/src/libraries/System.Configuration.ConfigurationManager/src/System/Configuration/ConfigurationSectionCollection.cs b/src/libraries/System.Configuration.ConfigurationManager/src/System/Configuration/ConfigurationSectionCollection.cs
index d00befe43ef2c4..e322ba08097d0f 100644
--- a/src/libraries/System.Configuration.ConfigurationManager/src/System/Configuration/ConfigurationSectionCollection.cs
+++ b/src/libraries/System.Configuration.ConfigurationManager/src/System/Configuration/ConfigurationSectionCollection.cs
@@ -92,7 +92,11 @@ public ConfigurationSection Get(string name)
                 throw ExceptionUtil.ParameterNullOrEmpty(nameof(name));
 
             // prevent GetConfig from returning config not in this collection
-            if (name.IndexOf('/') >= 0) // string.Contains(char) is .NetCore2.1+ specific
+#if NETCOREAPP
+            if (name.Contains('/'))
+#else
+            if (name.IndexOf('/') >= 0)
+#endif
                 return null;
 
             // get the section from the config record
diff --git a/src/libraries/System.Configuration.ConfigurationManager/src/System/Configuration/ConfigurationSectionGroupCollection.cs b/src/libraries/System.Configuration.ConfigurationManager/src/System/Configuration/ConfigurationSectionGroupCollection.cs
index 408ca76170bbe4..7b696a06fb703e 100644
--- a/src/libraries/System.Configuration.ConfigurationManager/src/System/Configuration/ConfigurationSectionGroupCollection.cs
+++ b/src/libraries/System.Configuration.ConfigurationManager/src/System/Configuration/ConfigurationSectionGroupCollection.cs
@@ -89,7 +89,11 @@ public ConfigurationSectionGroup Get(string name)
                 throw ExceptionUtil.ParameterNullOrEmpty(nameof(name));
 
             // prevent GetConfig from returning config not in this collection
-            if (name.IndexOf('/') >= 0) // string.Contains(char) is .NetCore2.1+ specific
+#if NETCOREAPP
+            if (name.Contains('/'))
+#else
+            if (name.IndexOf('/') >= 0)
+#endif
                 return null;
 
             // get the section group
diff --git a/src/libraries/System.Configuration.ConfigurationManager/src/System/Configuration/Internal/DelegatingConfigHost.cs b/src/libraries/System.Configuration.ConfigurationManager/src/System/Configuration/Internal/DelegatingConfigHost.cs
index f1b958b78d6a20..46e588ce644c2e 100644
--- a/src/libraries/System.Configuration.ConfigurationManager/src/System/Configuration/Internal/DelegatingConfigHost.cs
+++ b/src/libraries/System.Configuration.ConfigurationManager/src/System/Configuration/Internal/DelegatingConfigHost.cs
@@ -231,10 +231,12 @@ public virtual void RefreshConfigPaths()
 
         public virtual IDisposable Impersonate() => new DummyDisposable();
 
+#pragma warning disable SYSLIB0003 // Obsolete: CAS
         public virtual void GetRestrictedPermissions(IInternalConfigRecord configRecord, out PermissionSet permissionSet, out bool isHostReady)
         {
             permissionSet = new PermissionSet(null);
             isHostReady = true;
         }
+#pragma warning restore SYSLIB0003 // Obsolete: CAS
     }
 }
diff --git a/src/libraries/System.Configuration.ConfigurationManager/src/System/Configuration/Internal/IInternalConfigHost.cs b/src/libraries/System.Configuration.ConfigurationManager/src/System/Configuration/Internal/IInternalConfigHost.cs
index f3d0e54cbdd546..b03989bfb87097 100644
--- a/src/libraries/System.Configuration.ConfigurationManager/src/System/Configuration/Internal/IInternalConfigHost.cs
+++ b/src/libraries/System.Configuration.ConfigurationManager/src/System/Configuration/Internal/IInternalConfigHost.cs
@@ -103,6 +103,8 @@ string EncryptSection(string clearTextXml, ProtectedConfigurationProvider protec
 
         IDisposable Impersonate();
 
+#pragma warning disable SYSLIB0003 // Obsolete: CAS
         void GetRestrictedPermissions(IInternalConfigRecord configRecord, out PermissionSet permissionSet, out bool isHostReady);
+#pragma warning restore SYSLIB0003 // Obsolete: CAS
     }
 }
diff --git a/src/libraries/System.Configuration.ConfigurationManager/src/System/Configuration/Internal/InternalConfigHost.cs b/src/libraries/System.Configuration.ConfigurationManager/src/System/Configuration/Internal/InternalConfigHost.cs
index 8f2f2d4154e188..52a7360c506a5a 100644
--- a/src/libraries/System.Configuration.ConfigurationManager/src/System/Configuration/Internal/InternalConfigHost.cs
+++ b/src/libraries/System.Configuration.ConfigurationManager/src/System/Configuration/Internal/InternalConfigHost.cs
@@ -304,10 +304,12 @@ internal static bool StaticIsFile(string streamName)
 
         public IDisposable Impersonate() => new DummyDisposable();
 
+#pragma warning disable SYSLIB0003
         public void GetRestrictedPermissions(IInternalConfigRecord configRecord, out PermissionSet permissionSet, out bool isHostReady)
         {
             permissionSet = new PermissionSet(null);
             isHostReady = true;
         }
+#pragma warning restore SYSLIB0003
     }
 }
diff --git a/src/libraries/System.Configuration.ConfigurationManager/src/System/Configuration/SettingsPropertyValue.cs b/src/libraries/System.Configuration.ConfigurationManager/src/System/Configuration/SettingsPropertyValue.cs
index 481ca485d460a1..769c736f72c78b 100644
--- a/src/libraries/System.Configuration.ConfigurationManager/src/System/Configuration/SettingsPropertyValue.cs
+++ b/src/libraries/System.Configuration.ConfigurationManager/src/System/Configuration/SettingsPropertyValue.cs
@@ -101,7 +101,9 @@ private object Deserialize()
                         {
                             using (MemoryStream ms = new MemoryStream((byte[])SerializedValue))
                             {
+#pragma warning disable SYSLIB0011 // BinaryFormatter serialization is obsolete and should not be used.
                                 value = (new BinaryFormatter()).Deserialize(ms);
+#pragma warning restore SYSLIB0011
                             }
                         }
                         else
@@ -212,7 +214,9 @@ private static object GetObjectFromString(Type type, SettingsSerializeAs seriali
                         byte[] buffer = Convert.FromBase64String(serializedValue);
                         using (MemoryStream ms = new MemoryStream(buffer))
                         {
+#pragma warning disable SYSLIB0011 // BinaryFormatter serialization is obsolete and should not be used.
                             return (new BinaryFormatter()).Deserialize(ms);
+#pragma warning restore SYSLIB0011
                         }
                     }
                     else
@@ -249,8 +253,10 @@ private object SerializePropertyValue()
             {
                 using (MemoryStream ms = new MemoryStream())
                 {
+#pragma warning disable SYSLIB0011 // BinaryFormatter serialization is obsolete and should not be used.
                     BinaryFormatter bf = new BinaryFormatter();
                     bf.Serialize(ms, _value);
+#pragma warning restore SYSLIB0011
                     return ms.ToArray();
                 }
             }
diff --git a/src/libraries/System.Console/tests/NonStandardConfiguration.Unix.cs b/src/libraries/System.Console/tests/NonStandardConfiguration.Unix.cs
index c9d2b09fe5e1ce..35067d2067b09c 100644
--- a/src/libraries/System.Console/tests/NonStandardConfiguration.Unix.cs
+++ b/src/libraries/System.Console/tests/NonStandardConfiguration.Unix.cs
@@ -12,7 +12,6 @@ public partial class NonStandardConfigurationTests
     {
         [PlatformSpecific(TestPlatforms.AnyUnix)] // Uses P/Invokes
         [ConditionalFact(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
         public void NonBlockingStdout_AllDataReceived()
         {
             RemoteInvokeHandle remote = RemoteExecutor.Invoke(() =>
diff --git a/src/libraries/System.Console/tests/ReadKey.cs b/src/libraries/System.Console/tests/ReadKey.cs
index e0429983e7a701..42481f367a6a33 100644
--- a/src/libraries/System.Console/tests/ReadKey.cs
+++ b/src/libraries/System.Console/tests/ReadKey.cs
@@ -23,7 +23,6 @@ public static void KeyAvailable()
     }
 
     [ConditionalFact(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))]
-    [ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
     public static void RedirectedConsole_ReadKey()
     {
         RunRemote(() => { Assert.Throws<InvalidOperationException>(() => Console.ReadKey()); return 42; }, new ProcessStartInfo() { RedirectStandardInput = true });
diff --git a/src/libraries/System.Console/tests/RedirectedStream.cs b/src/libraries/System.Console/tests/RedirectedStream.cs
index ee2afb9bbd6e65..578824c8cce018 100644
--- a/src/libraries/System.Console/tests/RedirectedStream.cs
+++ b/src/libraries/System.Console/tests/RedirectedStream.cs
@@ -11,7 +11,6 @@
 using Microsoft.DotNet.XUnitExtensions;
 using Xunit;
 
-[ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
 public class RedirectedStream
 {
     [ConditionalFact(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))] // the CI system redirects stdout, so we can only really test the redirected behavior.
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 eadaf5c0501fa8..ce7de38a7aefd2 100644
--- a/src/libraries/System.Data.Common/ref/System.Data.Common.cs
+++ b/src/libraries/System.Data.Common/ref/System.Data.Common.cs
@@ -96,13 +96,16 @@ public ConstraintException(string? message, System.Exception? innerException) {
     [System.ComponentModel.DesignTimeVisibleAttribute(false)]
     [System.ComponentModel.EditorAttribute("Microsoft.VSDesigner.Data.Design.DataColumnEditor, Microsoft.VSDesigner, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", "System.Drawing.Design.UITypeEditor, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a")]
     [System.ComponentModel.ToolboxItemAttribute(false)]
+    [System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembersAttribute(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)]
     public partial class DataColumn : System.ComponentModel.MarshalByValueComponent
     {
         public DataColumn() { }
         public DataColumn(string? columnName) { }
-        public DataColumn(string? columnName, System.Type dataType) { }
-        public DataColumn(string? columnName, System.Type dataType, string? expr) { }
-        public DataColumn(string? columnName, System.Type dataType, string? expr, System.Data.MappingType type) { }
+        public DataColumn(string? columnName, [System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembersAttribute(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicProperties | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicFields)] System.Type dataType) { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types or types used in expressions may be trimmed if not referenced directly.")]
+        public DataColumn(string? columnName, [System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembersAttribute(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicProperties | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicFields)] System.Type dataType, string? expr) { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types or types used in expressions may be trimmed if not referenced directly.")]
+        public DataColumn(string? columnName, [System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembersAttribute(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicProperties | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicFields)] System.Type dataType, string? expr, System.Data.MappingType type) { }
         [System.ComponentModel.DefaultValueAttribute(true)]
         public bool AllowDBNull { get { throw null; } set { } }
         [System.ComponentModel.DefaultValueAttribute(false)]
@@ -126,7 +129,7 @@ public DataColumn(string? columnName, System.Type dataType, string? expr, System
         [System.ComponentModel.DefaultValueAttribute("")]
         [System.ComponentModel.RefreshPropertiesAttribute(System.ComponentModel.RefreshProperties.All)]
         [System.Diagnostics.CodeAnalysis.AllowNullAttribute]
-        public string Expression { get { throw null; } set { } }
+        public string Expression { get { throw null; } [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from types used in the expressions may be trimmed if not referenced directly.")] set { } }
         [System.ComponentModel.BrowsableAttribute(false)]
         public System.Data.PropertyCollection ExtendedProperties { get { throw null; } }
         [System.ComponentModel.DefaultValueAttribute(-1)]
@@ -174,8 +177,9 @@ public event System.ComponentModel.CollectionChangeEventHandler? CollectionChang
         public System.Data.DataColumn Add() { throw null; }
         public void Add(System.Data.DataColumn column) { }
         public System.Data.DataColumn Add(string? columnName) { throw null; }
-        public System.Data.DataColumn Add(string? columnName, System.Type type) { throw null; }
-        public System.Data.DataColumn Add(string? columnName, System.Type type, string expression) { throw null; }
+        public System.Data.DataColumn Add(string? columnName, [System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembersAttribute(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicProperties | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicFields)] System.Type type) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members might be trimmed for some data types or expressions.")]
+        public System.Data.DataColumn Add(string? columnName, [System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembersAttribute(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicProperties | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicFields)] System.Type type, string expression) { throw null; }
         public void AddRange(System.Data.DataColumn[] columns) { }
         public bool CanRemove(System.Data.DataColumn? column) { throw null; }
         public void Clear() { }
@@ -465,20 +469,20 @@ public void EndEdit() { }
         System.ComponentModel.AttributeCollection System.ComponentModel.ICustomTypeDescriptor.GetAttributes() { throw null; }
         string System.ComponentModel.ICustomTypeDescriptor.GetClassName() { throw null; }
         string System.ComponentModel.ICustomTypeDescriptor.GetComponentName() { throw null; }
-        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("Generic TypeConverters may require the generic types to be annotated. For example, NullableConverter requires the underlying type to be DynamicallyAccessedMembers All.")]
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Generic TypeConverters may require the generic types to be annotated. For example, NullableConverter requires the underlying type to be DynamicallyAccessedMembers All.")]
         System.ComponentModel.TypeConverter System.ComponentModel.ICustomTypeDescriptor.GetConverter() { throw null; }
-        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("The built-in EventDescriptor implementation uses Reflection which requires unreferenced code.")]
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("The built-in EventDescriptor implementation uses Reflection which requires unreferenced code.")]
         System.ComponentModel.EventDescriptor System.ComponentModel.ICustomTypeDescriptor.GetDefaultEvent() { throw null; }
-        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("PropertyDescriptor's PropertyType cannot be statically discovered.")]
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("PropertyDescriptor's PropertyType cannot be statically discovered.")]
         System.ComponentModel.PropertyDescriptor System.ComponentModel.ICustomTypeDescriptor.GetDefaultProperty() { throw null; }
-        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("Editors registered in TypeDescriptor.AddEditorTable may be trimmed.")]
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Editors registered in TypeDescriptor.AddEditorTable may be trimmed.")]
         object System.ComponentModel.ICustomTypeDescriptor.GetEditor(System.Type editorBaseType) { throw null; }
         System.ComponentModel.EventDescriptorCollection System.ComponentModel.ICustomTypeDescriptor.GetEvents() { throw null; }
-        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("The public parameterless constructor or the 'Default' static field may be trimmed from the Attribute's Type.")]
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("The public parameterless constructor or the 'Default' static field may be trimmed from the Attribute's Type.")]
         System.ComponentModel.EventDescriptorCollection System.ComponentModel.ICustomTypeDescriptor.GetEvents(System.Attribute[] attributes) { throw null; }
-        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("PropertyDescriptor's PropertyType cannot be statically discovered.")]
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("PropertyDescriptor's PropertyType cannot be statically discovered.")]
         System.ComponentModel.PropertyDescriptorCollection System.ComponentModel.ICustomTypeDescriptor.GetProperties() { throw null; }
-        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("PropertyDescriptor's PropertyType cannot be statically discovered. The public parameterless constructor or the 'Default' static field may be trimmed from the Attribute's Type.")]
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("PropertyDescriptor's PropertyType cannot be statically discovered. The public parameterless constructor or the 'Default' static field may be trimmed from the Attribute's Type.")]
         System.ComponentModel.PropertyDescriptorCollection System.ComponentModel.ICustomTypeDescriptor.GetProperties(System.Attribute[] attributes) { throw null; }
         object System.ComponentModel.ICustomTypeDescriptor.GetPropertyOwner(System.ComponentModel.PropertyDescriptor pd) { throw null; }
 #nullable enable
@@ -488,10 +492,13 @@ public void EndEdit() { }
     [System.ComponentModel.ToolboxItemAttribute("Microsoft.VSDesigner.Data.VS.DataSetToolboxItem, Microsoft.VSDesigner, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a")]
     [System.Xml.Serialization.XmlRootAttribute("DataSet")]
     [System.Xml.Serialization.XmlSchemaProviderAttribute("GetDataSetSchema")]
+    [System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembersAttribute(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicParameterlessConstructor | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicConstructors)]
     public partial class DataSet : System.ComponentModel.MarshalByValueComponent, System.ComponentModel.IListSource, System.ComponentModel.ISupportInitialize, System.ComponentModel.ISupportInitializeNotification, System.Runtime.Serialization.ISerializable, System.Xml.Serialization.IXmlSerializable
     {
         public DataSet() { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         protected DataSet(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         protected DataSet(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context, bool ConstructSchema) { }
         public DataSet(string dataSetName) { }
         [System.ComponentModel.DefaultValueAttribute(false)]
@@ -547,14 +554,21 @@ public void EndInit() { }
         public static System.Xml.Schema.XmlSchemaComplexType GetDataSetSchema(System.Xml.Schema.XmlSchemaSet? schemaSet) { throw null; }
         public virtual void GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
         protected virtual System.Xml.Schema.XmlSchema? GetSchemaSerializable() { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         protected void GetSerializationData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public string GetXml() { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public string GetXmlSchema() { throw null; }
         public bool HasChanges() { throw null; }
         public bool HasChanges(System.Data.DataRowState rowStates) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public void InferXmlSchema(System.IO.Stream? stream, string[]? nsArray) { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public void InferXmlSchema(System.IO.TextReader? reader, string[]? nsArray) { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public void InferXmlSchema(string fileName, string[]? nsArray) { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public void InferXmlSchema(System.Xml.XmlReader? reader, string[]? nsArray) { }
         protected virtual void InitializeDerivedDataSet() { }
         protected bool IsBinarySerialized(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { throw null; }
@@ -572,18 +586,31 @@ protected virtual void OnPropertyChanging(System.ComponentModel.PropertyChangedE
         protected virtual void OnRemoveRelation(System.Data.DataRelation relation) { }
         protected internal virtual void OnRemoveTable(System.Data.DataTable table) { }
         protected internal void RaisePropertyChanging(string name) { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public System.Data.XmlReadMode ReadXml(System.IO.Stream? stream) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public System.Data.XmlReadMode ReadXml(System.IO.Stream? stream, System.Data.XmlReadMode mode) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public System.Data.XmlReadMode ReadXml(System.IO.TextReader? reader) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public System.Data.XmlReadMode ReadXml(System.IO.TextReader? reader, System.Data.XmlReadMode mode) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public System.Data.XmlReadMode ReadXml(string fileName) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public System.Data.XmlReadMode ReadXml(string fileName, System.Data.XmlReadMode mode) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public System.Data.XmlReadMode ReadXml(System.Xml.XmlReader? reader) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public System.Data.XmlReadMode ReadXml(System.Xml.XmlReader? reader, System.Data.XmlReadMode mode) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public void ReadXmlSchema(System.IO.Stream? stream) { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public void ReadXmlSchema(System.IO.TextReader? reader) { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public void ReadXmlSchema(string fileName) { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public void ReadXmlSchema(System.Xml.XmlReader? reader) { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         protected virtual void ReadXmlSerializable(System.Xml.XmlReader reader) { }
         public virtual void RejectChanges() { }
         public virtual void Reset() { }
@@ -595,21 +622,37 @@ public virtual void Reset() { }
         void System.Xml.Serialization.IXmlSerializable.ReadXml(System.Xml.XmlReader reader) { }
         void System.Xml.Serialization.IXmlSerializable.WriteXml(System.Xml.XmlWriter writer) { }
 #nullable enable
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public void WriteXml(System.IO.Stream? stream) { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public void WriteXml(System.IO.Stream? stream, System.Data.XmlWriteMode mode) { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public void WriteXml(System.IO.TextWriter? writer) { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public void WriteXml(System.IO.TextWriter? writer, System.Data.XmlWriteMode mode) { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public void WriteXml(string fileName) { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public void WriteXml(string fileName, System.Data.XmlWriteMode mode) { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public void WriteXml(System.Xml.XmlWriter? writer) { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public void WriteXml(System.Xml.XmlWriter? writer, System.Data.XmlWriteMode mode) { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public void WriteXmlSchema(System.IO.Stream? stream) { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public void WriteXmlSchema(System.IO.Stream? stream, System.Converter<System.Type, string> multipleTargetConverter) { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public void WriteXmlSchema(System.IO.TextWriter? writer) { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public void WriteXmlSchema(System.IO.TextWriter? writer, System.Converter<System.Type, string> multipleTargetConverter) { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public void WriteXmlSchema(string fileName) { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public void WriteXmlSchema(string fileName, System.Converter<System.Type, string> multipleTargetConverter) { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public void WriteXmlSchema(System.Xml.XmlWriter? writer) { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public void WriteXmlSchema(System.Xml.XmlWriter? writer, System.Converter<System.Type, string> multipleTargetConverter) { }
     }
     public enum DataSetDateTime
@@ -637,6 +680,7 @@ public partial class DataTable : System.ComponentModel.MarshalByValueComponent,
     {
         protected internal bool fInitInProgress;
         public DataTable() { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         protected DataTable(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
         public DataTable(string? tableName) { }
         public DataTable(string? tableName, string? tableNamespace) { }
@@ -655,7 +699,7 @@ public DataTable(string? tableName, string? tableNamespace) { }
         public System.Data.DataView DefaultView { get { throw null; } }
         [System.ComponentModel.DefaultValueAttribute("")]
         [System.Diagnostics.CodeAnalysis.AllowNullAttribute]
-        public string DisplayExpression { get { throw null; } set { } }
+        public string DisplayExpression { get { throw null; } [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from types used in the expressions may be trimmed if not referenced directly.")] set { } }
         [System.ComponentModel.BrowsableAttribute(false)]
         public System.Data.PropertyCollection ExtendedProperties { get { throw null; } }
         [System.ComponentModel.BrowsableAttribute(false)]
@@ -702,6 +746,7 @@ public virtual void BeginInit() { }
         public void BeginLoadData() { }
         public void Clear() { }
         public virtual System.Data.DataTable Clone() { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members of types used in the filter or expression might be trimmed.")]
         public object Compute(string? expression, string? filter) { throw null; }
         public System.Data.DataTable Copy() { throw null; }
         public System.Data.DataTableReader CreateDataReader() { throw null; }
@@ -738,20 +783,31 @@ protected virtual void OnRowDeleting(System.Data.DataRowChangeEventArgs e) { }
         protected virtual void OnTableCleared(System.Data.DataTableClearEventArgs e) { }
         protected virtual void OnTableClearing(System.Data.DataTableClearEventArgs e) { }
         protected virtual void OnTableNewRow(System.Data.DataTableNewRowEventArgs e) { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public System.Data.XmlReadMode ReadXml(System.IO.Stream? stream) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public System.Data.XmlReadMode ReadXml(System.IO.TextReader? reader) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public System.Data.XmlReadMode ReadXml(string fileName) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public System.Data.XmlReadMode ReadXml(System.Xml.XmlReader? reader) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public void ReadXmlSchema(System.IO.Stream? stream) { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public void ReadXmlSchema(System.IO.TextReader? reader) { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public void ReadXmlSchema(string fileName) { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public void ReadXmlSchema(System.Xml.XmlReader? reader) { }
         protected virtual void ReadXmlSerializable(System.Xml.XmlReader? reader) { }
         public void RejectChanges() { }
         public virtual void Reset() { }
         public System.Data.DataRow[] Select() { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members of types used in the filter expression might be trimmed.")]
         public System.Data.DataRow[] Select(string? filterExpression) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members of types used in the filter expression might be trimmed.")]
         public System.Data.DataRow[] Select(string? filterExpression, string? sort) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members of types used in the filter expression might be trimmed.")]
         public System.Data.DataRow[] Select(string? filterExpression, string? sort, System.Data.DataViewRowState recordStates) { throw null; }
         System.Collections.IList System.ComponentModel.IListSource.GetList() { throw null; }
         System.Xml.Schema.XmlSchema? System.Xml.Serialization.IXmlSerializable.GetSchema() { throw null; }
@@ -760,29 +816,53 @@ void System.Xml.Serialization.IXmlSerializable.ReadXml(System.Xml.XmlReader read
         void System.Xml.Serialization.IXmlSerializable.WriteXml(System.Xml.XmlWriter writer) { }
 #nullable enable
         public override string ToString() { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public void WriteXml(System.IO.Stream? stream) { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public void WriteXml(System.IO.Stream? stream, bool writeHierarchy) { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public void WriteXml(System.IO.Stream? stream, System.Data.XmlWriteMode mode) { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public void WriteXml(System.IO.Stream? stream, System.Data.XmlWriteMode mode, bool writeHierarchy) { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public void WriteXml(System.IO.TextWriter? writer) { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public void WriteXml(System.IO.TextWriter? writer, bool writeHierarchy) { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public void WriteXml(System.IO.TextWriter? writer, System.Data.XmlWriteMode mode) { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public void WriteXml(System.IO.TextWriter? writer, System.Data.XmlWriteMode mode, bool writeHierarchy) { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public void WriteXml(string fileName) { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public void WriteXml(string fileName, bool writeHierarchy) { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public void WriteXml(string fileName, System.Data.XmlWriteMode mode) { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public void WriteXml(string fileName, System.Data.XmlWriteMode mode, bool writeHierarchy) { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public void WriteXml(System.Xml.XmlWriter? writer) { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public void WriteXml(System.Xml.XmlWriter? writer, bool writeHierarchy) { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public void WriteXml(System.Xml.XmlWriter? writer, System.Data.XmlWriteMode mode) { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public void WriteXml(System.Xml.XmlWriter? writer, System.Data.XmlWriteMode mode, bool writeHierarchy) { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public void WriteXmlSchema(System.IO.Stream? stream) { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public void WriteXmlSchema(System.IO.Stream? stream, bool writeHierarchy) { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public void WriteXmlSchema(System.IO.TextWriter? writer) { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public void WriteXmlSchema(System.IO.TextWriter? writer, bool writeHierarchy) { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public void WriteXmlSchema(string fileName) { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public void WriteXmlSchema(string fileName, bool writeHierarchy) { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public void WriteXmlSchema(System.Xml.XmlWriter? writer) { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         public void WriteXmlSchema(System.Xml.XmlWriter? writer, bool writeHierarchy) { }
     }
     public sealed partial class DataTableClearEventArgs : System.EventArgs
@@ -887,6 +967,7 @@ public partial class DataView : System.ComponentModel.MarshalByValueComponent, S
     {
         public DataView() { }
         public DataView(System.Data.DataTable? table) { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members of types used in the filter expression might be trimmed.")]
         public DataView(System.Data.DataTable table, string? RowFilter, string? Sort, System.Data.DataViewRowState RowState) { }
         [System.ComponentModel.DefaultValueAttribute(true)]
         public bool AllowDelete { get { throw null; } set { } }
@@ -907,7 +988,7 @@ public DataView(System.Data.DataTable table, string? RowFilter, string? Sort, Sy
         protected bool IsOpen { get { throw null; } }
         public System.Data.DataRowView this[int recordIndex] { get { throw null; } }
         [System.ComponentModel.DefaultValueAttribute("")]
-        public virtual string? RowFilter { get { throw null; } set { } }
+        public virtual string? RowFilter { get { throw null; } [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members of types used in the filter expression might be trimmed.")] set { } }
         [System.ComponentModel.DefaultValueAttribute(System.Data.DataViewRowState.CurrentRows)]
         public System.Data.DataViewRowState RowStateFilter { get { throw null; } set { } }
         [System.ComponentModel.DefaultValueAttribute("")]
@@ -987,7 +1068,7 @@ public DataViewManager(System.Data.DataSet? dataSet) { }
         [System.ComponentModel.DefaultValueAttribute(null)]
         [System.Diagnostics.CodeAnalysis.DisallowNullAttribute]
         public System.Data.DataSet? DataSet { get { throw null; } set { } }
-        public string DataViewSettingCollectionString { get { throw null; } set { } }
+        public string DataViewSettingCollectionString { get { throw null; } [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("Members of types used in the RowFilter expression might be trimmed.")] set { } }
         [System.ComponentModel.DesignerSerializationVisibilityAttribute(System.ComponentModel.DesignerSerializationVisibility.Content)]
         public System.Data.DataViewSettingCollection DataViewSettings { get { throw null; } }
         int System.Collections.ICollection.Count { get { throw null; } }
@@ -1053,7 +1134,7 @@ internal DataViewSetting() { }
         [System.ComponentModel.BrowsableAttribute(false)]
         public System.Data.DataViewManager? DataViewManager { get { throw null; } }
         [System.Diagnostics.CodeAnalysis.AllowNullAttribute]
-        public string RowFilter { get { throw null; } set { } }
+        public string RowFilter { get { throw null; } [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members of types used in the filter expression might be trimmed.")] set { } }
         public System.Data.DataViewRowState RowStateFilter { get { throw null; } set { } }
         [System.Diagnostics.CodeAnalysis.AllowNullAttribute]
         public string Sort { get { throw null; } set { } }
@@ -1589,6 +1670,7 @@ public static partial class TypedTableBaseExtensions
     public abstract partial class TypedTableBase<T> : System.Data.DataTable, System.Collections.Generic.IEnumerable<T>, System.Collections.IEnumerable where T : System.Data.DataRow
     {
         protected TypedTableBase() { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Members from serialized types may be trimmed if not referenced directly.")]
         protected TypedTableBase(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
         public System.Data.EnumerableRowCollection<TResult> Cast<TResult>() { throw null; }
         public System.Collections.Generic.IEnumerator<T> GetEnumerator() { throw null; }
@@ -1718,9 +1800,9 @@ public DataColumnMapping(string? sourceColumn, string? dataSetColumn) { }
         [System.Diagnostics.CodeAnalysis.AllowNullAttribute]
         public string SourceColumn { get { throw null; } set { } }
         [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Advanced)]
-        public System.Data.DataColumn? GetDataColumnBySchemaAction(System.Data.DataTable dataTable, System.Type? dataType, System.Data.MissingSchemaAction schemaAction) { throw null; }
+        public System.Data.DataColumn? GetDataColumnBySchemaAction(System.Data.DataTable dataTable, [System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembersAttribute(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicProperties | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicFields)] System.Type? dataType, System.Data.MissingSchemaAction schemaAction) { throw null; }
         [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Advanced)]
-        public static System.Data.DataColumn? GetDataColumnBySchemaAction(string? sourceColumn, string? dataSetColumn, System.Data.DataTable dataTable, System.Type? dataType, System.Data.MissingSchemaAction schemaAction) { throw null; }
+        public static System.Data.DataColumn? GetDataColumnBySchemaAction(string? sourceColumn, string? dataSetColumn, System.Data.DataTable dataTable, [System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembersAttribute(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicProperties | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicFields)] System.Type? dataType, System.Data.MissingSchemaAction schemaAction) { throw null; }
         object System.ICloneable.Clone() { throw null; }
         public override string ToString() { throw null; }
     }
@@ -1755,7 +1837,7 @@ public void CopyTo(System.Data.Common.DataColumnMapping[] array, int index) { }
         [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Advanced)]
         public static System.Data.Common.DataColumnMapping? GetColumnMappingBySchemaAction(System.Data.Common.DataColumnMappingCollection? columnMappings, string sourceColumn, System.Data.MissingMappingAction mappingAction) { throw null; }
         [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Advanced)]
-        public static System.Data.DataColumn? GetDataColumn(System.Data.Common.DataColumnMappingCollection? columnMappings, string sourceColumn, System.Type? dataType, System.Data.DataTable dataTable, System.Data.MissingMappingAction mappingAction, System.Data.MissingSchemaAction schemaAction) { throw null; }
+        public static System.Data.DataColumn? GetDataColumn(System.Data.Common.DataColumnMappingCollection? columnMappings, string sourceColumn, [System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembersAttribute(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicProperties | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicFields)] System.Type? dataType, System.Data.DataTable dataTable, System.Data.MissingMappingAction mappingAction, System.Data.MissingSchemaAction schemaAction) { throw null; }
         public System.Collections.IEnumerator GetEnumerator() { throw null; }
         public int IndexOf(object? value) { throw null; }
         public int IndexOf(string? sourceColumn) { throw null; }
@@ -1786,7 +1868,7 @@ public DataTableMapping(string? sourceTable, string? dataSetTable, System.Data.C
         [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Advanced)]
         public System.Data.Common.DataColumnMapping? GetColumnMappingBySchemaAction(string sourceColumn, System.Data.MissingMappingAction mappingAction) { throw null; }
         [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Advanced)]
-        public System.Data.DataColumn? GetDataColumn(string sourceColumn, System.Type? dataType, System.Data.DataTable dataTable, System.Data.MissingMappingAction mappingAction, System.Data.MissingSchemaAction schemaAction) { throw null; }
+        public System.Data.DataColumn? GetDataColumn(string sourceColumn, [System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembersAttribute(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicProperties | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicFields)] System.Type? dataType, System.Data.DataTable dataTable, System.Data.MissingMappingAction mappingAction, System.Data.MissingSchemaAction schemaAction) { throw null; }
         [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Advanced)]
         public System.Data.DataTable? GetDataTableBySchemaAction(System.Data.DataSet dataSet, System.Data.MissingSchemaAction schemaAction) { throw null; }
         object System.ICloneable.Clone() { throw null; }
@@ -2013,6 +2095,7 @@ protected virtual void OnStateChange(System.Data.StateChangeEventArgs stateChang
         System.Data.IDbTransaction System.Data.IDbConnection.BeginTransaction(System.Data.IsolationLevel isolationLevel) { throw null; }
         System.Data.IDbCommand System.Data.IDbConnection.CreateCommand() { throw null; }
     }
+    [System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.All)]
     public partial class DbConnectionStringBuilder : System.Collections.ICollection, System.Collections.IDictionary, System.Collections.IEnumerable, System.ComponentModel.ICustomTypeDescriptor
     {
         public DbConnectionStringBuilder() { }
@@ -2048,6 +2131,7 @@ public virtual void Clear() { }
         protected internal void ClearPropertyDescriptors() { }
         public virtual bool ContainsKey(string keyword) { throw null; }
         public virtual bool EquivalentTo(System.Data.Common.DbConnectionStringBuilder connectionStringBuilder) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("PropertyDescriptor's PropertyType cannot be statically discovered.")]
         protected virtual void GetProperties(System.Collections.Hashtable propertyDescriptors) { }
         public virtual bool Remove(string keyword) { throw null; }
         public virtual bool ShouldSerialize(string keyword) { throw null; }
@@ -2060,20 +2144,20 @@ void System.Collections.IDictionary.Remove(object keyword) { }
         System.ComponentModel.AttributeCollection System.ComponentModel.ICustomTypeDescriptor.GetAttributes() { throw null; }
         string System.ComponentModel.ICustomTypeDescriptor.GetClassName() { throw null; }
         string System.ComponentModel.ICustomTypeDescriptor.GetComponentName() { throw null; }
-        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("Generic TypeConverters may require the generic types to be annotated. For example, NullableConverter requires the underlying type to be DynamicallyAccessedMembers All.")]
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Generic TypeConverters may require the generic types to be annotated. For example, NullableConverter requires the underlying type to be DynamicallyAccessedMembers All.")]
         System.ComponentModel.TypeConverter System.ComponentModel.ICustomTypeDescriptor.GetConverter() { throw null; }
-        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("The built-in EventDescriptor implementation uses Reflection which requires unreferenced code.")]
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("The built-in EventDescriptor implementation uses Reflection which requires unreferenced code.")]
         System.ComponentModel.EventDescriptor System.ComponentModel.ICustomTypeDescriptor.GetDefaultEvent() { throw null; }
-        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("PropertyDescriptor's PropertyType cannot be statically discovered.")]
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("PropertyDescriptor's PropertyType cannot be statically discovered.")]
         System.ComponentModel.PropertyDescriptor System.ComponentModel.ICustomTypeDescriptor.GetDefaultProperty() { throw null; }
-        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("Editors registered in TypeDescriptor.AddEditorTable may be trimmed.")]
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Editors registered in TypeDescriptor.AddEditorTable may be trimmed.")]
         object System.ComponentModel.ICustomTypeDescriptor.GetEditor(System.Type editorBaseType) { throw null; }
         System.ComponentModel.EventDescriptorCollection System.ComponentModel.ICustomTypeDescriptor.GetEvents() { throw null; }
-        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("The public parameterless constructor or the 'Default' static field may be trimmed from the Attribute's Type.")]
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("The public parameterless constructor or the 'Default' static field may be trimmed from the Attribute's Type.")]
         System.ComponentModel.EventDescriptorCollection System.ComponentModel.ICustomTypeDescriptor.GetEvents(System.Attribute[] attributes) { throw null; }
-        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("PropertyDescriptor's PropertyType cannot be statically discovered.")]
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("PropertyDescriptor's PropertyType cannot be statically discovered.")]
         System.ComponentModel.PropertyDescriptorCollection System.ComponentModel.ICustomTypeDescriptor.GetProperties() { throw null; }
-        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("PropertyDescriptor's PropertyType cannot be statically discovered. The public parameterless constructor or the 'Default' static field may be trimmed from the Attribute's Type.")]
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("PropertyDescriptor's PropertyType cannot be statically discovered. The public parameterless constructor or the 'Default' static field may be trimmed from the Attribute's Type.")]
         System.ComponentModel.PropertyDescriptorCollection System.ComponentModel.ICustomTypeDescriptor.GetProperties(System.Attribute[] attributes) { throw null; }
         object System.ComponentModel.ICustomTypeDescriptor.GetPropertyOwner(System.ComponentModel.PropertyDescriptor pd) { throw null; }
         public override string ToString() { throw null; }
@@ -2242,20 +2326,20 @@ protected DbDataRecord() { }
         System.ComponentModel.AttributeCollection System.ComponentModel.ICustomTypeDescriptor.GetAttributes() { throw null; }
         string System.ComponentModel.ICustomTypeDescriptor.GetClassName() { throw null; }
         string System.ComponentModel.ICustomTypeDescriptor.GetComponentName() { throw null; }
-        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("Generic TypeConverters may require the generic types to be annotated. For example, NullableConverter requires the underlying type to be DynamicallyAccessedMembers All.")]
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Generic TypeConverters may require the generic types to be annotated. For example, NullableConverter requires the underlying type to be DynamicallyAccessedMembers All.")]
         System.ComponentModel.TypeConverter System.ComponentModel.ICustomTypeDescriptor.GetConverter() { throw null; }
-        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("The built-in EventDescriptor implementation uses Reflection which requires unreferenced code.")]
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("The built-in EventDescriptor implementation uses Reflection which requires unreferenced code.")]
         System.ComponentModel.EventDescriptor System.ComponentModel.ICustomTypeDescriptor.GetDefaultEvent() { throw null; }
-        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("PropertyDescriptor's PropertyType cannot be statically discovered.")]
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("PropertyDescriptor's PropertyType cannot be statically discovered.")]
         System.ComponentModel.PropertyDescriptor System.ComponentModel.ICustomTypeDescriptor.GetDefaultProperty() { throw null; }
-        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("Editors registered in TypeDescriptor.AddEditorTable may be trimmed.")]
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Editors registered in TypeDescriptor.AddEditorTable may be trimmed.")]
         object System.ComponentModel.ICustomTypeDescriptor.GetEditor(System.Type editorBaseType) { throw null; }
         System.ComponentModel.EventDescriptorCollection System.ComponentModel.ICustomTypeDescriptor.GetEvents() { throw null; }
-        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("The public parameterless constructor or the 'Default' static field may be trimmed from the Attribute's Type.")]
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("The public parameterless constructor or the 'Default' static field may be trimmed from the Attribute's Type.")]
         System.ComponentModel.EventDescriptorCollection System.ComponentModel.ICustomTypeDescriptor.GetEvents(System.Attribute[] attributes) { throw null; }
-        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("PropertyDescriptor's PropertyType cannot be statically discovered.")]
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("PropertyDescriptor's PropertyType cannot be statically discovered.")]
         System.ComponentModel.PropertyDescriptorCollection System.ComponentModel.ICustomTypeDescriptor.GetProperties() { throw null; }
-        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("PropertyDescriptor's PropertyType cannot be statically discovered. The public parameterless constructor or the 'Default' static field may be trimmed from the Attribute's Type.")]
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("PropertyDescriptor's PropertyType cannot be statically discovered. The public parameterless constructor or the 'Default' static field may be trimmed from the Attribute's Type.")]
         System.ComponentModel.PropertyDescriptorCollection System.ComponentModel.ICustomTypeDescriptor.GetProperties(System.Attribute[] attributes) { throw null; }
         object System.ComponentModel.ICustomTypeDescriptor.GetPropertyOwner(System.ComponentModel.PropertyDescriptor pd) { throw null; }
 #nullable enable
@@ -2430,16 +2514,19 @@ protected DbParameterCollection() { }
     public static partial class DbProviderFactories
     {
         public static System.Data.Common.DbProviderFactory? GetFactory(System.Data.Common.DbConnection connection) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Provider type and its members might be trimmed if not referenced directly.")]
         public static System.Data.Common.DbProviderFactory GetFactory(System.Data.DataRow providerRow) { throw null; }
         public static System.Data.Common.DbProviderFactory GetFactory(string providerInvariantName) { throw null; }
         public static System.Data.DataTable GetFactoryClasses() { throw null; }
         public static System.Collections.Generic.IEnumerable<string> GetProviderInvariantNames() { throw null; }
         public static void RegisterFactory(string providerInvariantName, System.Data.Common.DbProviderFactory factory) { }
-        public static void RegisterFactory(string providerInvariantName, string factoryTypeAssemblyQualifiedName) { }
-        public static void RegisterFactory(string providerInvariantName, System.Type providerFactoryClass) { }
+        public static void RegisterFactory(string providerInvariantName, [System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembersAttribute(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicFields)] string factoryTypeAssemblyQualifiedName) { }
+        public static void RegisterFactory(string providerInvariantName, [System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembersAttribute(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicFields)] System.Type providerFactoryClass) { }
         public static bool TryGetFactory(string providerInvariantName, [System.Diagnostics.CodeAnalysis.NotNullWhenAttribute(true)] out System.Data.Common.DbProviderFactory? factory) { throw null; }
         public static bool UnregisterFactory(string providerInvariantName) { throw null; }
     }
+
+    [System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembersAttribute(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicFields)]
     public abstract partial class DbProviderFactory
     {
         protected DbProviderFactory() { }
@@ -2454,7 +2541,7 @@ protected DbProviderFactory() { }
         public virtual System.Data.Common.DbDataSourceEnumerator? CreateDataSourceEnumerator() { throw null; }
         public virtual System.Data.Common.DbParameter? CreateParameter() { throw null; }
     }
-    [System.AttributeUsageAttribute(System.AttributeTargets.Property, AllowMultiple=false, Inherited=true)]
+    [System.AttributeUsageAttribute(System.AttributeTargets.Property, AllowMultiple = false, Inherited = true)]
     public sealed partial class DbProviderSpecificTypePropertyAttribute : System.Attribute
     {
         public DbProviderSpecificTypePropertyAttribute(bool isProviderSpecificTypeProperty) { }
@@ -2610,11 +2697,11 @@ public partial struct SqlBinary : System.Data.SqlTypes.INullable, System.ICompar
         public static System.Data.SqlTypes.SqlBoolean NotEquals(System.Data.SqlTypes.SqlBinary x, System.Data.SqlTypes.SqlBinary y) { throw null; }
         public static System.Data.SqlTypes.SqlBinary operator +(System.Data.SqlTypes.SqlBinary x, System.Data.SqlTypes.SqlBinary y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator ==(System.Data.SqlTypes.SqlBinary x, System.Data.SqlTypes.SqlBinary y) { throw null; }
-        public static explicit operator byte[]? (System.Data.SqlTypes.SqlBinary x) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlBinary (System.Data.SqlTypes.SqlGuid x) { throw null; }
+        public static explicit operator byte[]?(System.Data.SqlTypes.SqlBinary x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlBinary(System.Data.SqlTypes.SqlGuid x) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator >(System.Data.SqlTypes.SqlBinary x, System.Data.SqlTypes.SqlBinary y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator >=(System.Data.SqlTypes.SqlBinary x, System.Data.SqlTypes.SqlBinary y) { throw null; }
-        public static implicit operator System.Data.SqlTypes.SqlBinary (byte[] x) { throw null; }
+        public static implicit operator System.Data.SqlTypes.SqlBinary(byte[] x) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator !=(System.Data.SqlTypes.SqlBinary x, System.Data.SqlTypes.SqlBinary y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator <(System.Data.SqlTypes.SqlBinary x, System.Data.SqlTypes.SqlBinary y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator <=(System.Data.SqlTypes.SqlBinary x, System.Data.SqlTypes.SqlBinary y) { throw null; }
@@ -2657,20 +2744,20 @@ public partial struct SqlBoolean : System.Data.SqlTypes.INullable, System.ICompa
         public static System.Data.SqlTypes.SqlBoolean operator |(System.Data.SqlTypes.SqlBoolean x, System.Data.SqlTypes.SqlBoolean y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator ==(System.Data.SqlTypes.SqlBoolean x, System.Data.SqlTypes.SqlBoolean y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator ^(System.Data.SqlTypes.SqlBoolean x, System.Data.SqlTypes.SqlBoolean y) { throw null; }
-        public static explicit operator bool (System.Data.SqlTypes.SqlBoolean x) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlBoolean (System.Data.SqlTypes.SqlByte x) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlBoolean (System.Data.SqlTypes.SqlDecimal x) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlBoolean (System.Data.SqlTypes.SqlDouble x) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlBoolean (System.Data.SqlTypes.SqlInt16 x) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlBoolean (System.Data.SqlTypes.SqlInt32 x) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlBoolean (System.Data.SqlTypes.SqlInt64 x) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlBoolean (System.Data.SqlTypes.SqlMoney x) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlBoolean (System.Data.SqlTypes.SqlSingle x) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlBoolean (System.Data.SqlTypes.SqlString x) { throw null; }
+        public static explicit operator bool(System.Data.SqlTypes.SqlBoolean x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlBoolean(System.Data.SqlTypes.SqlByte x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlBoolean(System.Data.SqlTypes.SqlDecimal x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlBoolean(System.Data.SqlTypes.SqlDouble x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlBoolean(System.Data.SqlTypes.SqlInt16 x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlBoolean(System.Data.SqlTypes.SqlInt32 x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlBoolean(System.Data.SqlTypes.SqlInt64 x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlBoolean(System.Data.SqlTypes.SqlMoney x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlBoolean(System.Data.SqlTypes.SqlSingle x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlBoolean(System.Data.SqlTypes.SqlString x) { throw null; }
         public static bool operator false(System.Data.SqlTypes.SqlBoolean x) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator >(System.Data.SqlTypes.SqlBoolean x, System.Data.SqlTypes.SqlBoolean y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator >=(System.Data.SqlTypes.SqlBoolean x, System.Data.SqlTypes.SqlBoolean y) { throw null; }
-        public static implicit operator System.Data.SqlTypes.SqlBoolean (bool x) { throw null; }
+        public static implicit operator System.Data.SqlTypes.SqlBoolean(bool x) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator !=(System.Data.SqlTypes.SqlBoolean x, System.Data.SqlTypes.SqlBoolean y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator <(System.Data.SqlTypes.SqlBoolean x, System.Data.SqlTypes.SqlBoolean y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator <=(System.Data.SqlTypes.SqlBoolean x, System.Data.SqlTypes.SqlBoolean y) { throw null; }
@@ -2730,19 +2817,19 @@ public partial struct SqlByte : System.Data.SqlTypes.INullable, System.IComparab
         public static System.Data.SqlTypes.SqlByte operator /(System.Data.SqlTypes.SqlByte x, System.Data.SqlTypes.SqlByte y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator ==(System.Data.SqlTypes.SqlByte x, System.Data.SqlTypes.SqlByte y) { throw null; }
         public static System.Data.SqlTypes.SqlByte operator ^(System.Data.SqlTypes.SqlByte x, System.Data.SqlTypes.SqlByte y) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlByte (System.Data.SqlTypes.SqlBoolean x) { throw null; }
-        public static explicit operator byte (System.Data.SqlTypes.SqlByte x) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlByte (System.Data.SqlTypes.SqlDecimal x) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlByte (System.Data.SqlTypes.SqlDouble x) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlByte (System.Data.SqlTypes.SqlInt16 x) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlByte (System.Data.SqlTypes.SqlInt32 x) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlByte (System.Data.SqlTypes.SqlInt64 x) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlByte (System.Data.SqlTypes.SqlMoney x) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlByte (System.Data.SqlTypes.SqlSingle x) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlByte (System.Data.SqlTypes.SqlString x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlByte(System.Data.SqlTypes.SqlBoolean x) { throw null; }
+        public static explicit operator byte(System.Data.SqlTypes.SqlByte x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlByte(System.Data.SqlTypes.SqlDecimal x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlByte(System.Data.SqlTypes.SqlDouble x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlByte(System.Data.SqlTypes.SqlInt16 x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlByte(System.Data.SqlTypes.SqlInt32 x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlByte(System.Data.SqlTypes.SqlInt64 x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlByte(System.Data.SqlTypes.SqlMoney x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlByte(System.Data.SqlTypes.SqlSingle x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlByte(System.Data.SqlTypes.SqlString x) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator >(System.Data.SqlTypes.SqlByte x, System.Data.SqlTypes.SqlByte y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator >=(System.Data.SqlTypes.SqlByte x, System.Data.SqlTypes.SqlByte y) { throw null; }
-        public static implicit operator System.Data.SqlTypes.SqlByte (byte x) { throw null; }
+        public static implicit operator System.Data.SqlTypes.SqlByte(byte x) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator !=(System.Data.SqlTypes.SqlByte x, System.Data.SqlTypes.SqlByte y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator <(System.Data.SqlTypes.SqlByte x, System.Data.SqlTypes.SqlByte y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator <=(System.Data.SqlTypes.SqlByte x, System.Data.SqlTypes.SqlByte y) { throw null; }
@@ -2784,8 +2871,8 @@ public SqlBytes(System.IO.Stream? s) { }
         public System.IO.Stream Stream { get { throw null; } set { } }
         public byte[] Value { get { throw null; } }
         public static System.Xml.XmlQualifiedName GetXsdType(System.Xml.Schema.XmlSchemaSet schemaSet) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlBytes (System.Data.SqlTypes.SqlBinary value) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlBinary (System.Data.SqlTypes.SqlBytes value) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlBytes(System.Data.SqlTypes.SqlBinary value) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlBinary(System.Data.SqlTypes.SqlBytes value) { throw null; }
         public long Read(long offset, byte[] buffer, int offsetInBuffer, int count) { throw null; }
         public void SetLength(long value) { }
         public void SetNull() { }
@@ -2811,8 +2898,8 @@ public SqlChars(System.Data.SqlTypes.SqlString value) { }
         public System.Data.SqlTypes.StorageState Storage { get { throw null; } }
         public char[] Value { get { throw null; } }
         public static System.Xml.XmlQualifiedName GetXsdType(System.Xml.Schema.XmlSchemaSet schemaSet) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlString (System.Data.SqlTypes.SqlChars value) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlChars (System.Data.SqlTypes.SqlString value) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlString(System.Data.SqlTypes.SqlChars value) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlChars(System.Data.SqlTypes.SqlString value) { throw null; }
         public long Read(long offset, char[] buffer, int offsetInBuffer, int count) { throw null; }
         public void SetLength(long value) { }
         public void SetNull() { }
@@ -2868,11 +2955,11 @@ public partial struct SqlDateTime : System.Data.SqlTypes.INullable, System.IComp
         public static System.Data.SqlTypes.SqlBoolean NotEquals(System.Data.SqlTypes.SqlDateTime x, System.Data.SqlTypes.SqlDateTime y) { throw null; }
         public static System.Data.SqlTypes.SqlDateTime operator +(System.Data.SqlTypes.SqlDateTime x, System.TimeSpan t) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator ==(System.Data.SqlTypes.SqlDateTime x, System.Data.SqlTypes.SqlDateTime y) { throw null; }
-        public static explicit operator System.DateTime (System.Data.SqlTypes.SqlDateTime x) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlDateTime (System.Data.SqlTypes.SqlString x) { throw null; }
+        public static explicit operator System.DateTime(System.Data.SqlTypes.SqlDateTime x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlDateTime(System.Data.SqlTypes.SqlString x) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator >(System.Data.SqlTypes.SqlDateTime x, System.Data.SqlTypes.SqlDateTime y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator >=(System.Data.SqlTypes.SqlDateTime x, System.Data.SqlTypes.SqlDateTime y) { throw null; }
-        public static implicit operator System.Data.SqlTypes.SqlDateTime (System.DateTime value) { throw null; }
+        public static implicit operator System.Data.SqlTypes.SqlDateTime(System.DateTime value) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator !=(System.Data.SqlTypes.SqlDateTime x, System.Data.SqlTypes.SqlDateTime y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator <(System.Data.SqlTypes.SqlDateTime x, System.Data.SqlTypes.SqlDateTime y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator <=(System.Data.SqlTypes.SqlDateTime x, System.Data.SqlTypes.SqlDateTime y) { throw null; }
@@ -2929,21 +3016,21 @@ public partial struct SqlDecimal : System.Data.SqlTypes.INullable, System.ICompa
         public static System.Data.SqlTypes.SqlDecimal operator +(System.Data.SqlTypes.SqlDecimal x, System.Data.SqlTypes.SqlDecimal y) { throw null; }
         public static System.Data.SqlTypes.SqlDecimal operator /(System.Data.SqlTypes.SqlDecimal x, System.Data.SqlTypes.SqlDecimal y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator ==(System.Data.SqlTypes.SqlDecimal x, System.Data.SqlTypes.SqlDecimal y) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlDecimal (System.Data.SqlTypes.SqlBoolean x) { throw null; }
-        public static explicit operator decimal (System.Data.SqlTypes.SqlDecimal x) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlDecimal (System.Data.SqlTypes.SqlDouble x) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlDecimal (System.Data.SqlTypes.SqlSingle x) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlDecimal (System.Data.SqlTypes.SqlString x) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlDecimal (double x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlDecimal(System.Data.SqlTypes.SqlBoolean x) { throw null; }
+        public static explicit operator decimal(System.Data.SqlTypes.SqlDecimal x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlDecimal(System.Data.SqlTypes.SqlDouble x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlDecimal(System.Data.SqlTypes.SqlSingle x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlDecimal(System.Data.SqlTypes.SqlString x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlDecimal(double x) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator >(System.Data.SqlTypes.SqlDecimal x, System.Data.SqlTypes.SqlDecimal y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator >=(System.Data.SqlTypes.SqlDecimal x, System.Data.SqlTypes.SqlDecimal y) { throw null; }
-        public static implicit operator System.Data.SqlTypes.SqlDecimal (System.Data.SqlTypes.SqlByte x) { throw null; }
-        public static implicit operator System.Data.SqlTypes.SqlDecimal (System.Data.SqlTypes.SqlInt16 x) { throw null; }
-        public static implicit operator System.Data.SqlTypes.SqlDecimal (System.Data.SqlTypes.SqlInt32 x) { throw null; }
-        public static implicit operator System.Data.SqlTypes.SqlDecimal (System.Data.SqlTypes.SqlInt64 x) { throw null; }
-        public static implicit operator System.Data.SqlTypes.SqlDecimal (System.Data.SqlTypes.SqlMoney x) { throw null; }
-        public static implicit operator System.Data.SqlTypes.SqlDecimal (decimal x) { throw null; }
-        public static implicit operator System.Data.SqlTypes.SqlDecimal (long x) { throw null; }
+        public static implicit operator System.Data.SqlTypes.SqlDecimal(System.Data.SqlTypes.SqlByte x) { throw null; }
+        public static implicit operator System.Data.SqlTypes.SqlDecimal(System.Data.SqlTypes.SqlInt16 x) { throw null; }
+        public static implicit operator System.Data.SqlTypes.SqlDecimal(System.Data.SqlTypes.SqlInt32 x) { throw null; }
+        public static implicit operator System.Data.SqlTypes.SqlDecimal(System.Data.SqlTypes.SqlInt64 x) { throw null; }
+        public static implicit operator System.Data.SqlTypes.SqlDecimal(System.Data.SqlTypes.SqlMoney x) { throw null; }
+        public static implicit operator System.Data.SqlTypes.SqlDecimal(decimal x) { throw null; }
+        public static implicit operator System.Data.SqlTypes.SqlDecimal(long x) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator !=(System.Data.SqlTypes.SqlDecimal x, System.Data.SqlTypes.SqlDecimal y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator <(System.Data.SqlTypes.SqlDecimal x, System.Data.SqlTypes.SqlDecimal y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator <=(System.Data.SqlTypes.SqlDecimal x, System.Data.SqlTypes.SqlDecimal y) { throw null; }
@@ -2999,19 +3086,19 @@ public partial struct SqlDouble : System.Data.SqlTypes.INullable, System.ICompar
         public static System.Data.SqlTypes.SqlDouble operator +(System.Data.SqlTypes.SqlDouble x, System.Data.SqlTypes.SqlDouble y) { throw null; }
         public static System.Data.SqlTypes.SqlDouble operator /(System.Data.SqlTypes.SqlDouble x, System.Data.SqlTypes.SqlDouble y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator ==(System.Data.SqlTypes.SqlDouble x, System.Data.SqlTypes.SqlDouble y) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlDouble (System.Data.SqlTypes.SqlBoolean x) { throw null; }
-        public static explicit operator double (System.Data.SqlTypes.SqlDouble x) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlDouble (System.Data.SqlTypes.SqlString x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlDouble(System.Data.SqlTypes.SqlBoolean x) { throw null; }
+        public static explicit operator double(System.Data.SqlTypes.SqlDouble x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlDouble(System.Data.SqlTypes.SqlString x) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator >(System.Data.SqlTypes.SqlDouble x, System.Data.SqlTypes.SqlDouble y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator >=(System.Data.SqlTypes.SqlDouble x, System.Data.SqlTypes.SqlDouble y) { throw null; }
-        public static implicit operator System.Data.SqlTypes.SqlDouble (System.Data.SqlTypes.SqlByte x) { throw null; }
-        public static implicit operator System.Data.SqlTypes.SqlDouble (System.Data.SqlTypes.SqlDecimal x) { throw null; }
-        public static implicit operator System.Data.SqlTypes.SqlDouble (System.Data.SqlTypes.SqlInt16 x) { throw null; }
-        public static implicit operator System.Data.SqlTypes.SqlDouble (System.Data.SqlTypes.SqlInt32 x) { throw null; }
-        public static implicit operator System.Data.SqlTypes.SqlDouble (System.Data.SqlTypes.SqlInt64 x) { throw null; }
-        public static implicit operator System.Data.SqlTypes.SqlDouble (System.Data.SqlTypes.SqlMoney x) { throw null; }
-        public static implicit operator System.Data.SqlTypes.SqlDouble (System.Data.SqlTypes.SqlSingle x) { throw null; }
-        public static implicit operator System.Data.SqlTypes.SqlDouble (double x) { throw null; }
+        public static implicit operator System.Data.SqlTypes.SqlDouble(System.Data.SqlTypes.SqlByte x) { throw null; }
+        public static implicit operator System.Data.SqlTypes.SqlDouble(System.Data.SqlTypes.SqlDecimal x) { throw null; }
+        public static implicit operator System.Data.SqlTypes.SqlDouble(System.Data.SqlTypes.SqlInt16 x) { throw null; }
+        public static implicit operator System.Data.SqlTypes.SqlDouble(System.Data.SqlTypes.SqlInt32 x) { throw null; }
+        public static implicit operator System.Data.SqlTypes.SqlDouble(System.Data.SqlTypes.SqlInt64 x) { throw null; }
+        public static implicit operator System.Data.SqlTypes.SqlDouble(System.Data.SqlTypes.SqlMoney x) { throw null; }
+        public static implicit operator System.Data.SqlTypes.SqlDouble(System.Data.SqlTypes.SqlSingle x) { throw null; }
+        public static implicit operator System.Data.SqlTypes.SqlDouble(double x) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator !=(System.Data.SqlTypes.SqlDouble x, System.Data.SqlTypes.SqlDouble y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator <(System.Data.SqlTypes.SqlDouble x, System.Data.SqlTypes.SqlDouble y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator <=(System.Data.SqlTypes.SqlDouble x, System.Data.SqlTypes.SqlDouble y) { throw null; }
@@ -3058,12 +3145,12 @@ public partial struct SqlGuid : System.Data.SqlTypes.INullable, System.IComparab
         public static System.Data.SqlTypes.SqlBoolean LessThanOrEqual(System.Data.SqlTypes.SqlGuid x, System.Data.SqlTypes.SqlGuid y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean NotEquals(System.Data.SqlTypes.SqlGuid x, System.Data.SqlTypes.SqlGuid y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator ==(System.Data.SqlTypes.SqlGuid x, System.Data.SqlTypes.SqlGuid y) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlGuid (System.Data.SqlTypes.SqlBinary x) { throw null; }
-        public static explicit operator System.Guid (System.Data.SqlTypes.SqlGuid x) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlGuid (System.Data.SqlTypes.SqlString x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlGuid(System.Data.SqlTypes.SqlBinary x) { throw null; }
+        public static explicit operator System.Guid(System.Data.SqlTypes.SqlGuid x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlGuid(System.Data.SqlTypes.SqlString x) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator >(System.Data.SqlTypes.SqlGuid x, System.Data.SqlTypes.SqlGuid y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator >=(System.Data.SqlTypes.SqlGuid x, System.Data.SqlTypes.SqlGuid y) { throw null; }
-        public static implicit operator System.Data.SqlTypes.SqlGuid (System.Guid x) { throw null; }
+        public static implicit operator System.Data.SqlTypes.SqlGuid(System.Guid x) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator !=(System.Data.SqlTypes.SqlGuid x, System.Data.SqlTypes.SqlGuid y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator <(System.Data.SqlTypes.SqlGuid x, System.Data.SqlTypes.SqlGuid y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator <=(System.Data.SqlTypes.SqlGuid x, System.Data.SqlTypes.SqlGuid y) { throw null; }
@@ -3112,19 +3199,19 @@ public partial struct SqlInt16 : System.Data.SqlTypes.INullable, System.ICompara
         public static System.Data.SqlTypes.SqlInt16 operator /(System.Data.SqlTypes.SqlInt16 x, System.Data.SqlTypes.SqlInt16 y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator ==(System.Data.SqlTypes.SqlInt16 x, System.Data.SqlTypes.SqlInt16 y) { throw null; }
         public static System.Data.SqlTypes.SqlInt16 operator ^(System.Data.SqlTypes.SqlInt16 x, System.Data.SqlTypes.SqlInt16 y) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlInt16 (System.Data.SqlTypes.SqlBoolean x) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlInt16 (System.Data.SqlTypes.SqlDecimal x) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlInt16 (System.Data.SqlTypes.SqlDouble x) { throw null; }
-        public static explicit operator short (System.Data.SqlTypes.SqlInt16 x) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlInt16 (System.Data.SqlTypes.SqlInt32 x) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlInt16 (System.Data.SqlTypes.SqlInt64 x) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlInt16 (System.Data.SqlTypes.SqlMoney x) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlInt16 (System.Data.SqlTypes.SqlSingle x) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlInt16 (System.Data.SqlTypes.SqlString x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlInt16(System.Data.SqlTypes.SqlBoolean x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlInt16(System.Data.SqlTypes.SqlDecimal x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlInt16(System.Data.SqlTypes.SqlDouble x) { throw null; }
+        public static explicit operator short(System.Data.SqlTypes.SqlInt16 x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlInt16(System.Data.SqlTypes.SqlInt32 x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlInt16(System.Data.SqlTypes.SqlInt64 x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlInt16(System.Data.SqlTypes.SqlMoney x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlInt16(System.Data.SqlTypes.SqlSingle x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlInt16(System.Data.SqlTypes.SqlString x) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator >(System.Data.SqlTypes.SqlInt16 x, System.Data.SqlTypes.SqlInt16 y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator >=(System.Data.SqlTypes.SqlInt16 x, System.Data.SqlTypes.SqlInt16 y) { throw null; }
-        public static implicit operator System.Data.SqlTypes.SqlInt16 (System.Data.SqlTypes.SqlByte x) { throw null; }
-        public static implicit operator System.Data.SqlTypes.SqlInt16 (short x) { throw null; }
+        public static implicit operator System.Data.SqlTypes.SqlInt16(System.Data.SqlTypes.SqlByte x) { throw null; }
+        public static implicit operator System.Data.SqlTypes.SqlInt16(short x) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator !=(System.Data.SqlTypes.SqlInt16 x, System.Data.SqlTypes.SqlInt16 y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator <(System.Data.SqlTypes.SqlInt16 x, System.Data.SqlTypes.SqlInt16 y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator <=(System.Data.SqlTypes.SqlInt16 x, System.Data.SqlTypes.SqlInt16 y) { throw null; }
@@ -3186,19 +3273,19 @@ public partial struct SqlInt32 : System.Data.SqlTypes.INullable, System.ICompara
         public static System.Data.SqlTypes.SqlInt32 operator /(System.Data.SqlTypes.SqlInt32 x, System.Data.SqlTypes.SqlInt32 y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator ==(System.Data.SqlTypes.SqlInt32 x, System.Data.SqlTypes.SqlInt32 y) { throw null; }
         public static System.Data.SqlTypes.SqlInt32 operator ^(System.Data.SqlTypes.SqlInt32 x, System.Data.SqlTypes.SqlInt32 y) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlInt32 (System.Data.SqlTypes.SqlBoolean x) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlInt32 (System.Data.SqlTypes.SqlDecimal x) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlInt32 (System.Data.SqlTypes.SqlDouble x) { throw null; }
-        public static explicit operator int (System.Data.SqlTypes.SqlInt32 x) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlInt32 (System.Data.SqlTypes.SqlInt64 x) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlInt32 (System.Data.SqlTypes.SqlMoney x) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlInt32 (System.Data.SqlTypes.SqlSingle x) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlInt32 (System.Data.SqlTypes.SqlString x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlInt32(System.Data.SqlTypes.SqlBoolean x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlInt32(System.Data.SqlTypes.SqlDecimal x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlInt32(System.Data.SqlTypes.SqlDouble x) { throw null; }
+        public static explicit operator int(System.Data.SqlTypes.SqlInt32 x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlInt32(System.Data.SqlTypes.SqlInt64 x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlInt32(System.Data.SqlTypes.SqlMoney x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlInt32(System.Data.SqlTypes.SqlSingle x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlInt32(System.Data.SqlTypes.SqlString x) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator >(System.Data.SqlTypes.SqlInt32 x, System.Data.SqlTypes.SqlInt32 y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator >=(System.Data.SqlTypes.SqlInt32 x, System.Data.SqlTypes.SqlInt32 y) { throw null; }
-        public static implicit operator System.Data.SqlTypes.SqlInt32 (System.Data.SqlTypes.SqlByte x) { throw null; }
-        public static implicit operator System.Data.SqlTypes.SqlInt32 (System.Data.SqlTypes.SqlInt16 x) { throw null; }
-        public static implicit operator System.Data.SqlTypes.SqlInt32 (int x) { throw null; }
+        public static implicit operator System.Data.SqlTypes.SqlInt32(System.Data.SqlTypes.SqlByte x) { throw null; }
+        public static implicit operator System.Data.SqlTypes.SqlInt32(System.Data.SqlTypes.SqlInt16 x) { throw null; }
+        public static implicit operator System.Data.SqlTypes.SqlInt32(int x) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator !=(System.Data.SqlTypes.SqlInt32 x, System.Data.SqlTypes.SqlInt32 y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator <(System.Data.SqlTypes.SqlInt32 x, System.Data.SqlTypes.SqlInt32 y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator <=(System.Data.SqlTypes.SqlInt32 x, System.Data.SqlTypes.SqlInt32 y) { throw null; }
@@ -3260,19 +3347,19 @@ public partial struct SqlInt64 : System.Data.SqlTypes.INullable, System.ICompara
         public static System.Data.SqlTypes.SqlInt64 operator /(System.Data.SqlTypes.SqlInt64 x, System.Data.SqlTypes.SqlInt64 y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator ==(System.Data.SqlTypes.SqlInt64 x, System.Data.SqlTypes.SqlInt64 y) { throw null; }
         public static System.Data.SqlTypes.SqlInt64 operator ^(System.Data.SqlTypes.SqlInt64 x, System.Data.SqlTypes.SqlInt64 y) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlInt64 (System.Data.SqlTypes.SqlBoolean x) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlInt64 (System.Data.SqlTypes.SqlDecimal x) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlInt64 (System.Data.SqlTypes.SqlDouble x) { throw null; }
-        public static explicit operator long (System.Data.SqlTypes.SqlInt64 x) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlInt64 (System.Data.SqlTypes.SqlMoney x) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlInt64 (System.Data.SqlTypes.SqlSingle x) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlInt64 (System.Data.SqlTypes.SqlString x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlInt64(System.Data.SqlTypes.SqlBoolean x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlInt64(System.Data.SqlTypes.SqlDecimal x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlInt64(System.Data.SqlTypes.SqlDouble x) { throw null; }
+        public static explicit operator long(System.Data.SqlTypes.SqlInt64 x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlInt64(System.Data.SqlTypes.SqlMoney x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlInt64(System.Data.SqlTypes.SqlSingle x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlInt64(System.Data.SqlTypes.SqlString x) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator >(System.Data.SqlTypes.SqlInt64 x, System.Data.SqlTypes.SqlInt64 y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator >=(System.Data.SqlTypes.SqlInt64 x, System.Data.SqlTypes.SqlInt64 y) { throw null; }
-        public static implicit operator System.Data.SqlTypes.SqlInt64 (System.Data.SqlTypes.SqlByte x) { throw null; }
-        public static implicit operator System.Data.SqlTypes.SqlInt64 (System.Data.SqlTypes.SqlInt16 x) { throw null; }
-        public static implicit operator System.Data.SqlTypes.SqlInt64 (System.Data.SqlTypes.SqlInt32 x) { throw null; }
-        public static implicit operator System.Data.SqlTypes.SqlInt64 (long x) { throw null; }
+        public static implicit operator System.Data.SqlTypes.SqlInt64(System.Data.SqlTypes.SqlByte x) { throw null; }
+        public static implicit operator System.Data.SqlTypes.SqlInt64(System.Data.SqlTypes.SqlInt16 x) { throw null; }
+        public static implicit operator System.Data.SqlTypes.SqlInt64(System.Data.SqlTypes.SqlInt32 x) { throw null; }
+        public static implicit operator System.Data.SqlTypes.SqlInt64(long x) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator !=(System.Data.SqlTypes.SqlInt64 x, System.Data.SqlTypes.SqlInt64 y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator <(System.Data.SqlTypes.SqlInt64 x, System.Data.SqlTypes.SqlInt64 y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator <=(System.Data.SqlTypes.SqlInt64 x, System.Data.SqlTypes.SqlInt64 y) { throw null; }
@@ -3329,21 +3416,21 @@ public partial struct SqlMoney : System.Data.SqlTypes.INullable, System.ICompara
         public static System.Data.SqlTypes.SqlMoney operator +(System.Data.SqlTypes.SqlMoney x, System.Data.SqlTypes.SqlMoney y) { throw null; }
         public static System.Data.SqlTypes.SqlMoney operator /(System.Data.SqlTypes.SqlMoney x, System.Data.SqlTypes.SqlMoney y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator ==(System.Data.SqlTypes.SqlMoney x, System.Data.SqlTypes.SqlMoney y) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlMoney (System.Data.SqlTypes.SqlBoolean x) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlMoney (System.Data.SqlTypes.SqlDecimal x) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlMoney (System.Data.SqlTypes.SqlDouble x) { throw null; }
-        public static explicit operator decimal (System.Data.SqlTypes.SqlMoney x) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlMoney (System.Data.SqlTypes.SqlSingle x) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlMoney (System.Data.SqlTypes.SqlString x) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlMoney (double x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlMoney(System.Data.SqlTypes.SqlBoolean x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlMoney(System.Data.SqlTypes.SqlDecimal x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlMoney(System.Data.SqlTypes.SqlDouble x) { throw null; }
+        public static explicit operator decimal(System.Data.SqlTypes.SqlMoney x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlMoney(System.Data.SqlTypes.SqlSingle x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlMoney(System.Data.SqlTypes.SqlString x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlMoney(double x) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator >(System.Data.SqlTypes.SqlMoney x, System.Data.SqlTypes.SqlMoney y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator >=(System.Data.SqlTypes.SqlMoney x, System.Data.SqlTypes.SqlMoney y) { throw null; }
-        public static implicit operator System.Data.SqlTypes.SqlMoney (System.Data.SqlTypes.SqlByte x) { throw null; }
-        public static implicit operator System.Data.SqlTypes.SqlMoney (System.Data.SqlTypes.SqlInt16 x) { throw null; }
-        public static implicit operator System.Data.SqlTypes.SqlMoney (System.Data.SqlTypes.SqlInt32 x) { throw null; }
-        public static implicit operator System.Data.SqlTypes.SqlMoney (System.Data.SqlTypes.SqlInt64 x) { throw null; }
-        public static implicit operator System.Data.SqlTypes.SqlMoney (decimal x) { throw null; }
-        public static implicit operator System.Data.SqlTypes.SqlMoney (long x) { throw null; }
+        public static implicit operator System.Data.SqlTypes.SqlMoney(System.Data.SqlTypes.SqlByte x) { throw null; }
+        public static implicit operator System.Data.SqlTypes.SqlMoney(System.Data.SqlTypes.SqlInt16 x) { throw null; }
+        public static implicit operator System.Data.SqlTypes.SqlMoney(System.Data.SqlTypes.SqlInt32 x) { throw null; }
+        public static implicit operator System.Data.SqlTypes.SqlMoney(System.Data.SqlTypes.SqlInt64 x) { throw null; }
+        public static implicit operator System.Data.SqlTypes.SqlMoney(decimal x) { throw null; }
+        public static implicit operator System.Data.SqlTypes.SqlMoney(long x) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator !=(System.Data.SqlTypes.SqlMoney x, System.Data.SqlTypes.SqlMoney y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator <(System.Data.SqlTypes.SqlMoney x, System.Data.SqlTypes.SqlMoney y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator <=(System.Data.SqlTypes.SqlMoney x, System.Data.SqlTypes.SqlMoney y) { throw null; }
@@ -3411,19 +3498,19 @@ public partial struct SqlSingle : System.Data.SqlTypes.INullable, System.ICompar
         public static System.Data.SqlTypes.SqlSingle operator +(System.Data.SqlTypes.SqlSingle x, System.Data.SqlTypes.SqlSingle y) { throw null; }
         public static System.Data.SqlTypes.SqlSingle operator /(System.Data.SqlTypes.SqlSingle x, System.Data.SqlTypes.SqlSingle y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator ==(System.Data.SqlTypes.SqlSingle x, System.Data.SqlTypes.SqlSingle y) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlSingle (System.Data.SqlTypes.SqlBoolean x) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlSingle (System.Data.SqlTypes.SqlDouble x) { throw null; }
-        public static explicit operator float (System.Data.SqlTypes.SqlSingle x) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlSingle (System.Data.SqlTypes.SqlString x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlSingle(System.Data.SqlTypes.SqlBoolean x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlSingle(System.Data.SqlTypes.SqlDouble x) { throw null; }
+        public static explicit operator float(System.Data.SqlTypes.SqlSingle x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlSingle(System.Data.SqlTypes.SqlString x) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator >(System.Data.SqlTypes.SqlSingle x, System.Data.SqlTypes.SqlSingle y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator >=(System.Data.SqlTypes.SqlSingle x, System.Data.SqlTypes.SqlSingle y) { throw null; }
-        public static implicit operator System.Data.SqlTypes.SqlSingle (System.Data.SqlTypes.SqlByte x) { throw null; }
-        public static implicit operator System.Data.SqlTypes.SqlSingle (System.Data.SqlTypes.SqlDecimal x) { throw null; }
-        public static implicit operator System.Data.SqlTypes.SqlSingle (System.Data.SqlTypes.SqlInt16 x) { throw null; }
-        public static implicit operator System.Data.SqlTypes.SqlSingle (System.Data.SqlTypes.SqlInt32 x) { throw null; }
-        public static implicit operator System.Data.SqlTypes.SqlSingle (System.Data.SqlTypes.SqlInt64 x) { throw null; }
-        public static implicit operator System.Data.SqlTypes.SqlSingle (System.Data.SqlTypes.SqlMoney x) { throw null; }
-        public static implicit operator System.Data.SqlTypes.SqlSingle (float x) { throw null; }
+        public static implicit operator System.Data.SqlTypes.SqlSingle(System.Data.SqlTypes.SqlByte x) { throw null; }
+        public static implicit operator System.Data.SqlTypes.SqlSingle(System.Data.SqlTypes.SqlDecimal x) { throw null; }
+        public static implicit operator System.Data.SqlTypes.SqlSingle(System.Data.SqlTypes.SqlInt16 x) { throw null; }
+        public static implicit operator System.Data.SqlTypes.SqlSingle(System.Data.SqlTypes.SqlInt32 x) { throw null; }
+        public static implicit operator System.Data.SqlTypes.SqlSingle(System.Data.SqlTypes.SqlInt64 x) { throw null; }
+        public static implicit operator System.Data.SqlTypes.SqlSingle(System.Data.SqlTypes.SqlMoney x) { throw null; }
+        public static implicit operator System.Data.SqlTypes.SqlSingle(float x) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator !=(System.Data.SqlTypes.SqlSingle x, System.Data.SqlTypes.SqlSingle y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator <(System.Data.SqlTypes.SqlSingle x, System.Data.SqlTypes.SqlSingle y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator <=(System.Data.SqlTypes.SqlSingle x, System.Data.SqlTypes.SqlSingle y) { throw null; }
@@ -3490,21 +3577,21 @@ public partial struct SqlString : System.Data.SqlTypes.INullable, System.ICompar
         public static System.Data.SqlTypes.SqlBoolean NotEquals(System.Data.SqlTypes.SqlString x, System.Data.SqlTypes.SqlString y) { throw null; }
         public static System.Data.SqlTypes.SqlString operator +(System.Data.SqlTypes.SqlString x, System.Data.SqlTypes.SqlString y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator ==(System.Data.SqlTypes.SqlString x, System.Data.SqlTypes.SqlString y) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlString (System.Data.SqlTypes.SqlBoolean x) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlString (System.Data.SqlTypes.SqlByte x) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlString (System.Data.SqlTypes.SqlDateTime x) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlString (System.Data.SqlTypes.SqlDecimal x) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlString (System.Data.SqlTypes.SqlDouble x) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlString (System.Data.SqlTypes.SqlGuid x) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlString (System.Data.SqlTypes.SqlInt16 x) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlString (System.Data.SqlTypes.SqlInt32 x) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlString (System.Data.SqlTypes.SqlInt64 x) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlString (System.Data.SqlTypes.SqlMoney x) { throw null; }
-        public static explicit operator System.Data.SqlTypes.SqlString (System.Data.SqlTypes.SqlSingle x) { throw null; }
-        public static explicit operator string (System.Data.SqlTypes.SqlString x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlString(System.Data.SqlTypes.SqlBoolean x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlString(System.Data.SqlTypes.SqlByte x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlString(System.Data.SqlTypes.SqlDateTime x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlString(System.Data.SqlTypes.SqlDecimal x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlString(System.Data.SqlTypes.SqlDouble x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlString(System.Data.SqlTypes.SqlGuid x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlString(System.Data.SqlTypes.SqlInt16 x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlString(System.Data.SqlTypes.SqlInt32 x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlString(System.Data.SqlTypes.SqlInt64 x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlString(System.Data.SqlTypes.SqlMoney x) { throw null; }
+        public static explicit operator System.Data.SqlTypes.SqlString(System.Data.SqlTypes.SqlSingle x) { throw null; }
+        public static explicit operator string(System.Data.SqlTypes.SqlString x) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator >(System.Data.SqlTypes.SqlString x, System.Data.SqlTypes.SqlString y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator >=(System.Data.SqlTypes.SqlString x, System.Data.SqlTypes.SqlString y) { throw null; }
-        public static implicit operator System.Data.SqlTypes.SqlString (string x) { throw null; }
+        public static implicit operator System.Data.SqlTypes.SqlString(string x) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator !=(System.Data.SqlTypes.SqlString x, System.Data.SqlTypes.SqlString y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator <(System.Data.SqlTypes.SqlString x, System.Data.SqlTypes.SqlString y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean operator <=(System.Data.SqlTypes.SqlString x, System.Data.SqlTypes.SqlString y) { throw null; }
@@ -3564,7 +3651,9 @@ namespace System.Xml
     [System.ObsoleteAttribute("XmlDataDocument class will be removed in a future release.")]
     public partial class XmlDataDocument : System.Xml.XmlDocument
     {
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("XmlDataDocument is used for serialization and deserialization. Members from serialized types may be trimmed if not referenced directly.")]
         public XmlDataDocument() { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("XmlDataDocument is used for serialization and deserialization. Members from serialized types may be trimmed if not referenced directly.")]
         public XmlDataDocument(System.Data.DataSet dataset) { }
         public System.Data.DataSet DataSet { get { throw null; } }
         public override System.Xml.XmlNode CloneNode(bool deep) { throw null; }
diff --git a/src/libraries/System.Data.Common/src/ILLink/ILLink.Suppressions.xml b/src/libraries/System.Data.Common/src/ILLink/ILLink.Suppressions.xml
index a0aae1367cb5f4..3e47be79791de4 100644
--- a/src/libraries/System.Data.Common/src/ILLink/ILLink.Suppressions.xml
+++ b/src/libraries/System.Data.Common/src/ILLink/ILLink.Suppressions.xml
@@ -7,317 +7,101 @@
       <property name="Scope">member</property>
       <property name="Target">M:System.Data.ColumnTypeConverter.ConvertTo(System.ComponentModel.ITypeDescriptorContext,System.Globalization.CultureInfo,System.Object,System.Type)</property>
     </attribute>
-    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
-      <argument>ILLink</argument>
-      <argument>IL2057</argument>
-      <property name="Scope">member</property>
-      <property name="Target">M:System.Data.Common.DataStorage.GetType(System.String)</property>
-    </attribute>
-    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
-      <argument>ILLink</argument>
-      <argument>IL2057</argument>
-      <property name="Scope">member</property>
-      <property name="Target">M:System.Data.Common.DbProviderFactories.GetProviderTypeFromTypeName(System.String)</property>
-    </attribute>
-    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
-      <argument>ILLink</argument>
-      <argument>IL2057</argument>
-      <property name="Scope">member</property>
-      <property name="Target">M:System.Data.Common.ObjectStorage.ConvertXmlToObject(System.String)</property>
-    </attribute>
-    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
-      <argument>ILLink</argument>
-      <argument>IL2057</argument>
-      <property name="Scope">member</property>
-      <property name="Target">M:System.Data.Common.ObjectStorage.ConvertXmlToObject(System.Xml.XmlReader,System.Xml.Serialization.XmlRootAttribute)</property>
-    </attribute>
-    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
-      <argument>ILLink</argument>
-      <argument>IL2057</argument>
-      <property name="Scope">member</property>
-      <property name="Target">M:System.Data.Common.SqlUdtStorage.ConvertXmlToObject(System.Xml.XmlReader,System.Xml.Serialization.XmlRootAttribute)</property>
-    </attribute>
-    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
-      <argument>ILLink</argument>
-      <argument>IL2057</argument>
-      <property name="Scope">member</property>
-      <property name="Target">M:System.Data.DataTable.DeserializeTableSchema(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext,System.Boolean)</property>
-    </attribute>
-    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
-      <argument>ILLink</argument>
-      <argument>IL2057</argument>
-      <property name="Scope">member</property>
-      <property name="Target">M:System.Data.FunctionNode.GetDataType(System.Data.ExpressionNode)</property>
-    </attribute>
-    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
-      <argument>ILLink</argument>
-      <argument>IL2057</argument>
-      <property name="Scope">member</property>
-      <property name="Target">M:System.Data.XSDSchema.SetProperties(System.Object,System.Xml.XmlAttribute[])</property>
-    </attribute>
     <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
       <argument>ILLink</argument>
       <argument>IL2060</argument>
       <property name="Scope">member</property>
       <property name="Target">M:System.Data.DataRowExtensions.UnboxT`1.Create</property>
     </attribute>
-    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
-      <argument>ILLink</argument>
-      <argument>IL2070</argument>
-      <property name="Scope">member</property>
-      <property name="Target">M:System.Data.Common.DbProviderFactories.GetFactoryInstance(System.Type)</property>
-    </attribute>
     <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
       <argument>ILLink</argument>
       <argument>IL2072</argument>
       <property name="Scope">member</property>
       <property name="Target">M:System.Data.Common.DataAdapter.CloneInternals</property>
     </attribute>
-    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
-      <argument>ILLink</argument>
-      <argument>IL2072</argument>
-      <property name="Scope">member</property>
-      <property name="Target">M:System.Data.Common.ObjectStorage.ConvertXmlToObject(System.Xml.XmlReader,System.Xml.Serialization.XmlRootAttribute)</property>
-    </attribute>
-    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
-      <argument>ILLink</argument>
-      <argument>IL2072</argument>
-      <property name="Scope">member</property>
-      <property name="Target">M:System.Data.Common.SqlUdtStorage.ConvertXmlToObject(System.Xml.XmlReader,System.Xml.Serialization.XmlRootAttribute)</property>
-    </attribute>
-    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
-      <argument>ILLink</argument>
-      <argument>IL2072</argument>
-      <property name="Scope">member</property>
-      <property name="Target">M:System.Data.DataColumn.Clone</property>
-    </attribute>
-    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
-      <argument>ILLink</argument>
-      <argument>IL2072</argument>
-      <property name="Scope">member</property>
-      <property name="Target">M:System.Data.DataSet.Clone</property>
-    </attribute>
-    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
-      <argument>ILLink</argument>
-      <argument>IL2072</argument>
-      <property name="Scope">member</property>
-      <property name="Target">M:System.Data.DataTable.CreateInstance</property>
-    </attribute>
-    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
-      <argument>ILLink</argument>
-      <argument>IL2077</argument>
-      <property name="Scope">member</property>
-      <property name="Target">M:System.Data.Common.ObjectStorage.ConvertXmlToObject(System.String)</property>
-    </attribute>
-    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
-      <argument>ILLink</argument>
-      <argument>IL2077</argument>
-      <property name="Scope">member</property>
-      <property name="Target">M:System.Data.Common.ObjectStorage.ConvertXmlToObject(System.Xml.XmlReader,System.Xml.Serialization.XmlRootAttribute)</property>
-    </attribute>
-    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
-      <argument>ILLink</argument>
-      <argument>IL2077</argument>
-      <property name="Scope">member</property>
-      <property name="Target">M:System.Data.Common.SqlUdtStorage.ConvertXmlToObject(System.String)</property>
-    </attribute>
-    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
-      <argument>ILLink</argument>
-      <argument>IL2077</argument>
-      <property name="Scope">member</property>
-      <property name="Target">M:System.Data.Common.SqlUdtStorage.ConvertXmlToObject(System.Xml.XmlReader,System.Xml.Serialization.XmlRootAttribute)</property>
-    </attribute>
-    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
-      <argument>ILLink</argument>
-      <argument>IL2080</argument>
-      <property name="Scope">member</property>
-      <property name="Target">T:System.Data.Common.SqlUdtStorage</property>
-    </attribute>
-    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
-      <argument>ILLink</argument>
-      <argument>IL2080</argument>
-      <property name="Scope">member</property>
-      <property name="Target">M:System.Data.DataColumn.get_DefaultValue</property>
-    </attribute>
     <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
       <argument>ILLink</argument>
       <argument>IL2026</argument>
       <property name="Scope">member</property>
-      <property name="Target">M:System.Data.DataSet.DeserializeDataSetSchema(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext,System.Data.SerializationFormat,System.Data.SchemaSerializationMode)</property>
+      <property name="Target">M:System.Data.DataSet.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)</property>
     </attribute>
     <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
       <argument>ILLink</argument>
       <argument>IL2026</argument>
       <property name="Scope">member</property>
-      <property name="Target">M:System.Data.DataSet.SerializeDataSet(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext,System.Data.SerializationFormat)</property>
+      <property name="Target">M:System.Data.DataSet.System.Xml.Serialization.IXmlSerializable.GetSchema()</property>
     </attribute>
     <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
       <argument>ILLink</argument>
       <argument>IL2026</argument>
       <property name="Scope">member</property>
-      <property name="Target">M:System.Data.Common.DbConnectionStringBuilder.GetProperties(System.Collections.Hashtable)</property>
+      <property name="Target">M:System.Data.DataSet.System.Xml.Serialization.IXmlSerializable.ReadXml(System.Xml.XmlReader)</property>
     </attribute>
     <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
       <argument>ILLink</argument>
       <argument>IL2026</argument>
       <property name="Scope">member</property>
-      <property name="Target">M:System.Data.Common.DbConnectionStringBuilder.System#ComponentModel#ICustomTypeDescriptor#GetAttributes</property>
+      <property name="Target">M:System.Data.DataSet.System.Xml.Serialization.IXmlSerializable.WriteXml(System.Xml.XmlWriter)</property>
     </attribute>
     <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
       <argument>ILLink</argument>
       <argument>IL2026</argument>
       <property name="Scope">member</property>
-      <property name="Target">M:System.Data.Common.DbConnectionStringBuilder.System#ComponentModel#ICustomTypeDescriptor#GetClassName</property>
+      <property name="Target">M:System.Data.DataTable.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)</property>
     </attribute>
     <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
       <argument>ILLink</argument>
-      <argument>IL2026</argument>
-      <property name="Scope">member</property>
-      <property name="Target">M:System.Data.Common.DbConnectionStringBuilder.System#ComponentModel#ICustomTypeDescriptor#GetComponentName</property>
-    </attribute>
-    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
-      <argument>ILLink</argument>
-      <argument>IL2026</argument>
-      <property name="Scope">member</property>
-      <property name="Target">M:System.Data.Common.DbConnectionStringBuilder.System#ComponentModel#ICustomTypeDescriptor#GetConverter</property>
-    </attribute>
-    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
-      <argument>ILLink</argument>
-      <argument>IL2026</argument>
-      <property name="Scope">member</property>
-      <property name="Target">M:System.Data.Common.DbConnectionStringBuilder.System#ComponentModel#ICustomTypeDescriptor#GetDefaultEvent</property>
-    </attribute>
-    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
-      <argument>ILLink</argument>
-      <argument>IL2026</argument>
-      <property name="Scope">member</property>
-      <property name="Target">M:System.Data.Common.DbConnectionStringBuilder.System#ComponentModel#ICustomTypeDescriptor#GetDefaultProperty</property>
-    </attribute>
-    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
-      <argument>ILLink</argument>
-      <argument>IL2026</argument>
-      <property name="Scope">member</property>
-      <property name="Target">M:System.Data.Common.DbConnectionStringBuilder.System#ComponentModel#ICustomTypeDescriptor#GetEditor(System.Type)</property>
-    </attribute>
-    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
-      <argument>ILLink</argument>
-      <argument>IL2026</argument>
-      <property name="Scope">member</property>
-      <property name="Target">M:System.Data.Common.DbConnectionStringBuilder.System#ComponentModel#ICustomTypeDescriptor#GetEvents</property>
-    </attribute>
-    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
-      <argument>ILLink</argument>
-      <argument>IL2026</argument>
-      <property name="Scope">member</property>
-      <property name="Target">M:System.Data.XMLSchema.SetProperties(System.Object,System.Xml.XmlAttributeCollection)</property>
-    </attribute>
-    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
-      <argument>ILLink</argument>
-      <argument>IL2026</argument>
-      <property name="Scope">member</property>
-      <property name="Target">M:System.Data.XmlTreeGen.AddXdoProperties(System.Object,System.Xml.XmlElement,System.Xml.XmlDocument)</property>
-    </attribute>
-    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
-      <argument>ILLink</argument>
-      <argument>IL2026</argument>
-      <property name="Scope">member</property>
-      <property name="Target">M:System.Data.XmlTreeGen.AddXdoProperty(System.ComponentModel.PropertyDescriptor,System.Object,System.Xml.XmlElement,System.Xml.XmlDocument)</property>
-    </attribute>
-    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
-      <argument>ILLink</argument>
-      <argument>IL2026</argument>
-      <property name="Scope">member</property>
-      <property name="Target">M:System.Data.XSDSchema.SetExtProperties(System.Object,System.Xml.XmlAttribute[])</property>
-    </attribute>
-    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
-      <argument>ILLink</argument>
-      <argument>IL2026</argument>
-      <property name="Scope">member</property>
-      <property name="Target">M:System.Data.XSDSchema.SetExtProperties(System.Object,System.Xml.XmlAttributeCollection)</property>
-    </attribute>
-    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
-      <argument>ILLink</argument>
-      <argument>IL2026</argument>
-      <property name="Scope">member</property>
-      <property name="Target">M:System.Data.XSDSchema.SetProperties(System.Object,System.Xml.XmlAttribute[])</property>
-    </attribute>
-    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
-      <argument>ILLink</argument>
-      <argument>IL2067</argument>
-      <property name="Scope">member</property>
-      <property name="Target">M:System.Data.XMLSchema.GetConverter(System.Type)</property>
-    </attribute>
-    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
-      <argument>ILLink</argument>
-      <argument>IL2026</argument>
-      <property name="Scope">member</property>
-      <property name="Target">M:System.Data.Common.ObjectStorage.ConvertObjectToXml(System.Object)</property>
-    </attribute>
-    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
-      <argument>ILLink</argument>
-      <argument>IL2026</argument>
-      <property name="Scope">member</property>
-      <property name="Target">M:System.Data.Common.ObjectStorage.ConvertObjectToXml(System.Object,System.Xml.XmlWriter,System.Xml.Serialization.XmlRootAttribute)</property>
-    </attribute>
-    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
-      <argument>ILLink</argument>
-      <argument>IL2026</argument>
-      <property name="Scope">member</property>
-      <property name="Target">M:System.Data.Common.ObjectStorage.ConvertObjectToXml(System.Object,System.Xml.XmlReader,System.Xml.Serialization.XmlRootAttribute)</property>
-    </attribute>
-    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
-      <argument>ILLink</argument>
-      <argument>IL2026</argument>
+      <argument>IL2072</argument>
       <property name="Scope">member</property>
-      <property name="Target">M:System.Data.Common.ObjectStorage.ConvertXmlToObject(System.Xml.XmlReader,System.Xml.Serialization.XmlRootAttribute)</property>
+      <property name="Target">M:System.Data.DataTable.CreateInstance()</property>
     </attribute>
     <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
       <argument>ILLink</argument>
       <argument>IL2026</argument>
       <property name="Scope">member</property>
-      <property name="Target">M:System.Data.Common.SqlUdtStorage.ConvertObjectToXml(System.Object)</property>
+      <property name="Target">M:System.Data.DataTable.GetSchema()</property>
     </attribute>
     <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
       <argument>ILLink</argument>
       <argument>IL2026</argument>
       <property name="Scope">member</property>
-      <property name="Target">M:System.Data.Common.ObjectStorage.ConvertXmlToObject(System.Object)</property>
+      <property name="Target">M:System.Data.DataTable.ReadXml(System.Xml.XmlReader,System.Data.XmlReadMode,System.Boolean)</property>
     </attribute>
     <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
       <argument>ILLink</argument>
       <argument>IL2026</argument>
       <property name="Scope">member</property>
-      <property name="Target">M:System.Data.Common.ObjectStorage.ConvertXmlToObject(System.String)</property>
+      <property name="Target">M:System.Data.DataTable.WriteXmlCore(System.Xml.XmlWriter)</property>
     </attribute>
     <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
       <argument>ILLink</argument>
       <argument>IL2026</argument>
       <property name="Scope">member</property>
-      <property name="Target">M:System.Data.Common.SqlUdtStorage.ConvertObjectToXml(System.Object,System.Xml.XmlWriter,System.Xml.Serialization.XmlRootAttribute)</property>
+      <property name="Target">M:System.Data.DataView.SetRowFilter(System.String)</property>
     </attribute>
     <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
       <argument>ILLink</argument>
       <argument>IL2026</argument>
       <property name="Scope">member</property>
-      <property name="Target">M:System.Data.Common.SqlUdtStorage.ConvertXmlToObject(System.String)</property>
+      <property name="Target">M:System.Data.DataView.System.ComponentModel.IBindingListView.set_Filter(System.String)</property>
     </attribute>
     <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
       <argument>ILLink</argument>
-      <argument>IL2026</argument>
+      <argument>IL2072</argument>
       <property name="Scope">member</property>
-      <property name="Target">M:System.Data.Common.SqlUdtStorage.ConvertXmlToObject(System.Xml.XmlReader,System.Xml.Serialization.XmlRootAttribute)</property>
+      <property name="Target">M:System.Data.ProviderBase.SchemaMapping.SetupSchemaWithKeyInfo(System.Data.MissingMappingAction,System.Data.MissingSchemaAction,System.Boolean,System.Data.DataColumn,System.Object)</property>
     </attribute>
     <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
       <argument>ILLink</argument>
       <argument>IL2026</argument>
       <property name="Scope">member</property>
-      <property name="Target">M:System.Data.Common.ObjectStorage.GetXmlSerializer(System.Type)</property>
+      <property name="Target">M:System.Data.ProviderBase.SchemaMapping.SetupSchemaWithKeyInfo(System.Data.MissingMappingAction,System.Data.MissingSchemaAction,System.Boolean,System.Data.DataColumn,System.Object)</property>
     </attribute>
     <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
       <argument>ILLink</argument>
-      <argument>IL2026</argument>
+      <argument>IL2072</argument>
       <property name="Scope">member</property>
-      <property name="Target">M:System.Data.Common.ObjectStorage.GetXmlSerializer(System.Type,System.Xml.Serialization.XmlRootAttribute)</property>
+      <property name="Target">M:System.Data.ProviderBase.SchemaMapping.SetupSchemaWithoutKeyInfo(System.Data.MissingMappingAction,System.Data.MissingSchemaAction,System.Boolean,System.Data.DataColumn,System.Object)</property>
     </attribute>
   </assembly>
 </linker>
diff --git a/src/libraries/System.Data.Common/src/System/Data/Common/BigIntegerStorage.cs b/src/libraries/System.Data.Common/src/System/Data/Common/BigIntegerStorage.cs
index fdff3ed6ab990c..2aa92e10445830 100644
--- a/src/libraries/System.Data.Common/src/System/Data/Common/BigIntegerStorage.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/Common/BigIntegerStorage.cs
@@ -4,6 +4,7 @@
 using System.Numerics;
 using System.Collections;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 
 namespace System.Data.Common
 {
@@ -149,11 +150,13 @@ public override void SetCapacity(int capacity)
             base.SetCapacity(capacity);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override object ConvertXmlToObject(string s)
         {
             return BigInteger.Parse(s, System.Globalization.CultureInfo.InvariantCulture);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override string ConvertObjectToXml(object value)
         {
             return ((BigInteger)value).ToString("D", System.Globalization.CultureInfo.InvariantCulture);
diff --git a/src/libraries/System.Data.Common/src/System/Data/Common/BooleanStorage.cs b/src/libraries/System.Data.Common/src/System/Data/Common/BooleanStorage.cs
index 99e6ce414dab34..3ccb79e49d6fc7 100644
--- a/src/libraries/System.Data.Common/src/System/Data/Common/BooleanStorage.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/Common/BooleanStorage.cs
@@ -4,6 +4,7 @@
 using System.Xml;
 using System.Collections;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 
 namespace System.Data.Common
 {
@@ -169,11 +170,13 @@ public override void SetCapacity(int capacity)
             base.SetCapacity(capacity);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override object ConvertXmlToObject(string s)
         {
             return XmlConvert.ToBoolean(s);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override string ConvertObjectToXml(object value)
         {
             return XmlConvert.ToString((bool)value);
diff --git a/src/libraries/System.Data.Common/src/System/Data/Common/ByteStorage.cs b/src/libraries/System.Data.Common/src/System/Data/Common/ByteStorage.cs
index 1fd8b9dbc76677..c8a777db67b6ba 100644
--- a/src/libraries/System.Data.Common/src/System/Data/Common/ByteStorage.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/Common/ByteStorage.cs
@@ -4,6 +4,7 @@
 using System.Xml;
 using System.Collections;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 
 namespace System.Data.Common
 {
@@ -241,11 +242,13 @@ public override void SetCapacity(int capacity)
             base.SetCapacity(capacity);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override object ConvertXmlToObject(string s)
         {
             return XmlConvert.ToByte(s);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override string ConvertObjectToXml(object value)
         {
             return XmlConvert.ToString((byte)value);
diff --git a/src/libraries/System.Data.Common/src/System/Data/Common/CharStorage.cs b/src/libraries/System.Data.Common/src/System/Data/Common/CharStorage.cs
index 72027fea73c3ae..a8d9a78d87b0de 100644
--- a/src/libraries/System.Data.Common/src/System/Data/Common/CharStorage.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/Common/CharStorage.cs
@@ -4,6 +4,7 @@
 using System.Xml;
 using System.Collections;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 
 namespace System.Data.Common
 {
@@ -173,11 +174,13 @@ public override void SetCapacity(int capacity)
             base.SetCapacity(capacity);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override object ConvertXmlToObject(string s)
         {
             return XmlConvert.ToChar(s);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override string ConvertObjectToXml(object value)
         {
             return XmlConvert.ToString((char)value);
diff --git a/src/libraries/System.Data.Common/src/System/Data/Common/DBCommandBuilder.cs b/src/libraries/System.Data.Common/src/System/Data/Common/DBCommandBuilder.cs
index 7472c15a749fdb..827f442ab2c1e5 100644
--- a/src/libraries/System.Data.Common/src/System/Data/Common/DBCommandBuilder.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/Common/DBCommandBuilder.cs
@@ -1318,6 +1318,7 @@ public DbCommand GetInsertCommand(bool useColumnsForParameterNames)
         {
             return GetInsertCommand(null, useColumnsForParameterNames);
         }
+
         internal DbCommand GetInsertCommand(DataRow? dataRow, bool useColumnsForParameterNames)
         {
             BuildCache(true, dataRow, useColumnsForParameterNames);
@@ -1329,10 +1330,12 @@ public DbCommand GetUpdateCommand()
         {
             return GetUpdateCommand(null, false);
         }
+
         public DbCommand GetUpdateCommand(bool useColumnsForParameterNames)
         {
             return GetUpdateCommand(null, useColumnsForParameterNames);
         }
+
         internal DbCommand GetUpdateCommand(DataRow? dataRow, bool useColumnsForParameterNames)
         {
             BuildCache(true, dataRow, useColumnsForParameterNames);
@@ -1344,10 +1347,12 @@ public DbCommand GetDeleteCommand()
         {
             return GetDeleteCommand(null, false);
         }
+
         public DbCommand GetDeleteCommand(bool useColumnsForParameterNames)
         {
             return GetDeleteCommand(null, useColumnsForParameterNames);
         }
+
         internal DbCommand GetDeleteCommand(DataRow? dataRow, bool useColumnsForParameterNames)
         {
             BuildCache(true, dataRow, useColumnsForParameterNames);
diff --git a/src/libraries/System.Data.Common/src/System/Data/Common/DBSchemaRow.cs b/src/libraries/System.Data.Common/src/System/Data/Common/DBSchemaRow.cs
index 438433e3b4a9ee..544ef90481dde5 100644
--- a/src/libraries/System.Data.Common/src/System/Data/Common/DBSchemaRow.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/Common/DBSchemaRow.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
 
 namespace System.Data.Common
@@ -27,8 +28,8 @@ internal static DbSchemaRow[] GetSortedSchemaRows(DataTable dataTable, bool retu
             };
             DbSchemaTable schemaTable = new DbSchemaTable(dataTable, returnProviderSpecificTypes);
 
-            const DataViewRowState rowStates = DataViewRowState.Unchanged | DataViewRowState.Added | DataViewRowState.ModifiedCurrent;
-            DataRow[] dataRows = dataTable.Select(null, "ColumnOrdinal ASC", rowStates);
+
+            DataRow[] dataRows = SelectRows(dataTable, returnProviderSpecificTypes);
             Debug.Assert(null != dataRows, "GetSchemaRows: unexpected null dataRows");
 
             DbSchemaRow[] schemaRows = new DbSchemaRow[dataRows.Length];
@@ -40,6 +41,14 @@ internal static DbSchemaRow[] GetSortedSchemaRows(DataTable dataTable, bool retu
             return schemaRows;
         }
 
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
+            Justification = "Filter expression is null.")]
+        private static DataRow[] SelectRows(DataTable dataTable, bool returnProviderSpecificTypes)
+        {
+            const DataViewRowState rowStates = DataViewRowState.Unchanged | DataViewRowState.Added | DataViewRowState.ModifiedCurrent;
+            return dataTable.Select(null, "ColumnOrdinal ASC", rowStates);
+        }
+
         internal DbSchemaRow(DbSchemaTable schemaTable, DataRow dataRow)
         {
             _schemaTable = schemaTable;
diff --git a/src/libraries/System.Data.Common/src/System/Data/Common/DataColumnMapping.cs b/src/libraries/System.Data.Common/src/System/Data/Common/DataColumnMapping.cs
index 7f53c995836c4f..6c896aae0c564e 100644
--- a/src/libraries/System.Data.Common/src/System/Data/Common/DataColumnMapping.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/Common/DataColumnMapping.cs
@@ -71,13 +71,13 @@ object ICloneable.Clone()
         }
 
         [EditorBrowsable(EditorBrowsableState.Advanced)]
-        public DataColumn? GetDataColumnBySchemaAction(DataTable dataTable, Type? dataType, MissingSchemaAction schemaAction)
+        public DataColumn? GetDataColumnBySchemaAction(DataTable dataTable, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicFields)] Type? dataType, MissingSchemaAction schemaAction)
         {
             return GetDataColumnBySchemaAction(SourceColumn, DataSetColumn, dataTable, dataType, schemaAction);
         }
 
         [EditorBrowsable(EditorBrowsableState.Advanced)]
-        public static DataColumn? GetDataColumnBySchemaAction(string? sourceColumn, string? dataSetColumn, DataTable dataTable, Type? dataType, MissingSchemaAction schemaAction)
+        public static DataColumn? GetDataColumnBySchemaAction(string? sourceColumn, string? dataSetColumn, DataTable dataTable, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicFields)] Type? dataType, MissingSchemaAction schemaAction)
         {
             if (null == dataTable)
             {
@@ -112,7 +112,7 @@ object ICloneable.Clone()
             return CreateDataColumnBySchemaAction(sourceColumn, dataSetColumn, dataTable, dataType, schemaAction);
         }
 
-        internal static DataColumn? CreateDataColumnBySchemaAction(string? sourceColumn, string? dataSetColumn, DataTable dataTable, Type? dataType, MissingSchemaAction schemaAction)
+        internal static DataColumn? CreateDataColumnBySchemaAction(string? sourceColumn, string? dataSetColumn, DataTable dataTable, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicFields)] Type? dataType, MissingSchemaAction schemaAction)
         {
             Debug.Assert(dataTable != null, "Should not call with a null DataTable");
             if (string.IsNullOrEmpty(dataSetColumn))
diff --git a/src/libraries/System.Data.Common/src/System/Data/Common/DataColumnMappingCollection.cs b/src/libraries/System.Data.Common/src/System/Data/Common/DataColumnMappingCollection.cs
index 7c6776d35db686..a929eb679faf66 100644
--- a/src/libraries/System.Data.Common/src/System/Data/Common/DataColumnMappingCollection.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/Common/DataColumnMappingCollection.cs
@@ -442,7 +442,7 @@ internal void ValidateSourceColumn(int index, string? value)
         }
 
         [EditorBrowsable(EditorBrowsableState.Advanced)]
-        public static DataColumn? GetDataColumn(DataColumnMappingCollection? columnMappings, string sourceColumn, Type? dataType, DataTable dataTable, MissingMappingAction mappingAction, MissingSchemaAction schemaAction)
+        public static DataColumn? GetDataColumn(DataColumnMappingCollection? columnMappings, string sourceColumn, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicFields)] Type? dataType, DataTable dataTable, MissingMappingAction mappingAction, MissingSchemaAction schemaAction)
         {
             if (null != columnMappings)
             {
diff --git a/src/libraries/System.Data.Common/src/System/Data/Common/DataStorage.cs b/src/libraries/System.Data.Common/src/System/Data/Common/DataStorage.cs
index 55cec5acc9737a..1a8b361c17f7d4 100644
--- a/src/libraries/System.Data.Common/src/System/Data/Common/DataStorage.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/Common/DataStorage.cs
@@ -5,6 +5,7 @@
 using System.Collections.Concurrent;
 using System.Data.SqlTypes;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.Xml;
 using System.Xml.Serialization;
 
@@ -269,19 +270,25 @@ public virtual void SetCapacity(int capacity)
             }
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public abstract object ConvertXmlToObject(string s);
+
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public virtual object ConvertXmlToObject(XmlReader xmlReader, XmlRootAttribute xmlAttrib)
         {
             return ConvertXmlToObject(xmlReader.Value);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public abstract string ConvertObjectToXml(object value);
+
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public virtual void ConvertObjectToXml(object value, XmlWriter xmlWriter, XmlRootAttribute? xmlAttrib)
         {
             xmlWriter.WriteString(ConvertObjectToXml(value)); // should it be NO OP?
         }
 
-        public static DataStorage CreateStorage(DataColumn column, Type dataType, StorageType typeCode)
+        public static DataStorage CreateStorage(DataColumn column, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicFields)] Type dataType, StorageType typeCode)
         {
             Debug.Assert(typeCode == GetStorageType(dataType), "Incorrect storage type specified");
             if ((StorageType.Empty == typeCode) && (null != dataType))
@@ -557,6 +564,7 @@ protected void SetNullStorage(BitArray nullbits)
         /// Types like "System.Data.SqlTypes.SqlString" will load because they are in the same assembly as this code
         /// Types like "System.Numerics.BigInteger" won't load because they are not special and not same assembly as this code
         /// </remarks>
+        [RequiresUnreferencedCode("Calls Type.GetType")]
         internal static Type GetType(string value)
         {
             Type? dataType = Type.GetType(value); // throwOnError=false, ignoreCase=fase
diff --git a/src/libraries/System.Data.Common/src/System/Data/Common/DataTableMapping.cs b/src/libraries/System.Data.Common/src/System/Data/Common/DataTableMapping.cs
index cbf3743a207f5f..5d89922c19a9a6 100644
--- a/src/libraries/System.Data.Common/src/System/Data/Common/DataTableMapping.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/Common/DataTableMapping.cs
@@ -112,7 +112,7 @@ object ICloneable.Clone()
         }
 
         [EditorBrowsable(EditorBrowsableState.Advanced)]
-        public DataColumn? GetDataColumn(string sourceColumn, Type? dataType, DataTable dataTable, MissingMappingAction mappingAction, MissingSchemaAction schemaAction)
+        public DataColumn? GetDataColumn(string sourceColumn, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicFields)] Type? dataType, DataTable dataTable, MissingMappingAction mappingAction, MissingSchemaAction schemaAction)
         {
             return DataColumnMappingCollection.GetDataColumn(_columnMappings, sourceColumn, dataType, dataTable, mappingAction, schemaAction);
         }
diff --git a/src/libraries/System.Data.Common/src/System/Data/Common/DateTimeOffsetStorage.cs b/src/libraries/System.Data.Common/src/System/Data/Common/DateTimeOffsetStorage.cs
index aca975ea779e82..72b9db7e9e6e62 100644
--- a/src/libraries/System.Data.Common/src/System/Data/Common/DateTimeOffsetStorage.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/Common/DateTimeOffsetStorage.cs
@@ -3,6 +3,7 @@
 
 using System.Xml;
 using System.Collections;
+using System.Diagnostics.CodeAnalysis;
 
 namespace System.Data.Common
 {
@@ -176,11 +177,13 @@ public override void SetCapacity(int capacity)
             base.SetCapacity(capacity);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override object ConvertXmlToObject(string s)
         {
             return XmlConvert.ToDateTimeOffset(s);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override string ConvertObjectToXml(object value)
         {
             return XmlConvert.ToString((DateTimeOffset)value);
diff --git a/src/libraries/System.Data.Common/src/System/Data/Common/DateTimeStorage.cs b/src/libraries/System.Data.Common/src/System/Data/Common/DateTimeStorage.cs
index 30337abccad753..47feb27cf0010b 100644
--- a/src/libraries/System.Data.Common/src/System/Data/Common/DateTimeStorage.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/Common/DateTimeStorage.cs
@@ -3,6 +3,7 @@
 
 using System.Xml;
 using System.Collections;
+using System.Diagnostics.CodeAnalysis;
 
 namespace System.Data.Common
 {
@@ -215,6 +216,7 @@ public override void SetCapacity(int capacity)
             base.SetCapacity(capacity);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override object ConvertXmlToObject(string s)
         {
             object retValue;
@@ -229,6 +231,7 @@ public override object ConvertXmlToObject(string s)
             return retValue;
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override string ConvertObjectToXml(object value)
         {
             string retValue;
diff --git a/src/libraries/System.Data.Common/src/System/Data/Common/DbConnectionStringBuilder.cs b/src/libraries/System.Data.Common/src/System/Data/Common/DbConnectionStringBuilder.cs
index 3c3ac63548ef8a..027fe42f0b08ef 100644
--- a/src/libraries/System.Data.Common/src/System/Data/Common/DbConnectionStringBuilder.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/Common/DbConnectionStringBuilder.cs
@@ -12,6 +12,7 @@
 
 namespace System.Data.Common
 {
+    [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)]
     public class DbConnectionStringBuilder : IDictionary, ICustomTypeDescriptor
     {
         // keyword->value currently listed in the connection string
@@ -387,6 +388,7 @@ internal Attribute[] GetAttributesFromCollection(AttributeCollection collection)
             return attributes;
         }
 
+        [RequiresUnreferencedCode("PropertyDescriptor's PropertyType cannot be statically discovered.")]
         private PropertyDescriptorCollection GetProperties()
         {
             PropertyDescriptorCollection? propertyDescriptors = _propertyDescriptors;
@@ -412,11 +414,16 @@ private PropertyDescriptorCollection GetProperties()
             return propertyDescriptors;
         }
 
+        [RequiresUnreferencedCode("PropertyDescriptor's PropertyType cannot be statically discovered.")]
         protected virtual void GetProperties(Hashtable propertyDescriptors)
         {
             long logScopeId = DataCommonEventSource.Log.EnterScope("<comm.DbConnectionStringBuilder.GetProperties|API> {0}", ObjectID);
             try
             {
+                // Below call is necessary to tell the trimmer that it should mark derived types appropriately.
+                // We cannot use overload which takes type because the result might differ if derived class implements ICustomTypeDescriptor.
+                Type thisType = GetType();
+
                 // show all strongly typed properties (not already added)
                 // except ConnectionString iff BrowsableConnectionString
                 Attribute[]? attributes;
@@ -562,16 +569,28 @@ private PropertyDescriptorCollection GetProperties(Attribute[]? attributes)
             return new PropertyDescriptorCollection(filteredPropertiesArray);
         }
 
-// TODO: Enable after System.ComponentModel.TypeConverter is annotated
+        // TODO-NULLABLE: Enable after System.ComponentModel.TypeConverter is annotated
 #nullable disable
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
+            Justification = "The type of component is statically known. This class is marked with [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)]")]
         string ICustomTypeDescriptor.GetClassName()
         {
+            // Below call is necessary to tell the trimmer that it should mark derived types appropriately.
+            // We cannot use overload which takes type because the result might differ if derived class implements ICustomTypeDescriptor.
+            Type thisType = GetType();
             return TypeDescriptor.GetClassName(this, true);
         }
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
+            Justification = "The type of component is statically known. This class is marked with [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)]")]
         string ICustomTypeDescriptor.GetComponentName()
         {
+            // Below call is necessary to tell the trimmer that it should mark derived types appropriately.
+            // We cannot use overload which takes type because the result might differ if derived class implements ICustomTypeDescriptor.
+            Type thisType = GetType();
             return TypeDescriptor.GetComponentName(this, true);
         }
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
+            Justification = "The type of component is statically known. This class is marked with [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)]")]
         AttributeCollection ICustomTypeDescriptor.GetAttributes()
         {
             return TypeDescriptor.GetAttributes(this, true);
@@ -606,8 +625,13 @@ EventDescriptor ICustomTypeDescriptor.GetDefaultEvent()
         {
             return TypeDescriptor.GetDefaultEvent(this, true);
         }
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
+            Justification = "The type of component is statically known. This class is marked with [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)]")]
         EventDescriptorCollection ICustomTypeDescriptor.GetEvents()
         {
+            // Below call is necessary to tell the trimmer that it should mark derived types appropriately.
+            // We cannot use overload which takes type because the result might differ if derived class implements ICustomTypeDescriptor.
+            Type thisType = GetType();
             return TypeDescriptor.GetEvents(this, true);
         }
         [RequiresUnreferencedCode("The public parameterless constructor or the 'Default' static field may be trimmed from the Attribute's Type.")]
diff --git a/src/libraries/System.Data.Common/src/System/Data/Common/DbDataAdapter.cs b/src/libraries/System.Data.Common/src/System/Data/Common/DbDataAdapter.cs
index b1e417ec7d14c2..1579d01e143e33 100644
--- a/src/libraries/System.Data.Common/src/System/Data/Common/DbDataAdapter.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/Common/DbDataAdapter.cs
@@ -5,7 +5,6 @@
 using System.Collections.Generic;
 using System.Data.ProviderBase;
 using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
 
 namespace System.Data.Common
 {
diff --git a/src/libraries/System.Data.Common/src/System/Data/Common/DbProviderFactories.cs b/src/libraries/System.Data.Common/src/System/Data/Common/DbProviderFactories.cs
index 2ad35f787cdeee..39ae170ad537f3 100644
--- a/src/libraries/System.Data.Common/src/System/Data/Common/DbProviderFactories.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/Common/DbProviderFactories.cs
@@ -17,12 +17,13 @@ public static partial class DbProviderFactories
     {
         private struct ProviderRegistration
         {
-            internal ProviderRegistration(string factoryTypeAssemblyQualifiedName, DbProviderFactory? factoryInstance)
+            internal ProviderRegistration([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields)] string factoryTypeAssemblyQualifiedName, DbProviderFactory? factoryInstance)
             {
                 this.FactoryTypeAssemblyQualifiedName = factoryTypeAssemblyQualifiedName;
                 this.FactoryInstance = factoryInstance;
             }
 
+            [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields)]
             internal string FactoryTypeAssemblyQualifiedName { get; }
 
             /// <summary>
@@ -51,6 +52,7 @@ public static DbProviderFactory GetFactory(string providerInvariantName)
             return GetFactory(providerInvariantName, throwOnError: true)!;
         }
 
+        [RequiresUnreferencedCode("Provider type and its members might be trimmed if not referenced directly.")]
         public static DbProviderFactory GetFactory(DataRow providerRow)
         {
             ADP.CheckArgumentNull(providerRow, nameof(providerRow));
@@ -105,7 +107,7 @@ public static IEnumerable<string> GetProviderInvariantNames()
             return _registeredFactories.Keys.ToList();
         }
 
-        public static void RegisterFactory(string providerInvariantName, string factoryTypeAssemblyQualifiedName)
+        public static void RegisterFactory(string providerInvariantName, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields)] string factoryTypeAssemblyQualifiedName)
         {
             ADP.CheckArgumentLength(providerInvariantName, nameof(providerInvariantName));
             ADP.CheckArgumentLength(factoryTypeAssemblyQualifiedName, nameof(factoryTypeAssemblyQualifiedName));
@@ -114,7 +116,7 @@ public static void RegisterFactory(string providerInvariantName, string factoryT
             _registeredFactories[providerInvariantName] = new ProviderRegistration(factoryTypeAssemblyQualifiedName, null);
         }
 
-        public static void RegisterFactory(string providerInvariantName, Type providerFactoryClass)
+        public static void RegisterFactory(string providerInvariantName, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields)] Type providerFactoryClass)
         {
             RegisterFactory(providerInvariantName, GetFactoryInstance(providerFactoryClass));
         }
@@ -163,7 +165,7 @@ public static bool UnregisterFactory(string providerInvariantName)
             return toReturn;
         }
 
-        private static DbProviderFactory GetFactoryInstance(Type providerFactoryClass)
+        private static DbProviderFactory GetFactoryInstance([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields)] Type providerFactoryClass)
         {
             ADP.CheckArgumentNull(providerFactoryClass, nameof(providerFactoryClass));
             if (!providerFactoryClass.IsSubclassOf(typeof(DbProviderFactory)))
@@ -188,8 +190,8 @@ private static DbProviderFactory GetFactoryInstance(Type providerFactoryClass)
             return (DbProviderFactory)factory;
         }
 
-
-        private static Type GetProviderTypeFromTypeName(string assemblyQualifiedName)
+        [return: DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields)]
+        private static Type GetProviderTypeFromTypeName([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields)] string assemblyQualifiedName)
         {
             Type? providerType = Type.GetType(assemblyQualifiedName);
             if (null == providerType)
diff --git a/src/libraries/System.Data.Common/src/System/Data/Common/DbProviderFactory.cs b/src/libraries/System.Data.Common/src/System/Data/Common/DbProviderFactory.cs
index 70ad0e96c6b92f..6065bc6acd8e22 100644
--- a/src/libraries/System.Data.Common/src/System/Data/Common/DbProviderFactory.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/Common/DbProviderFactory.cs
@@ -1,8 +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.Data.Common
 {
+    [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields)]
     public abstract partial class DbProviderFactory
     {
         private bool? _canCreateDataAdapter;
diff --git a/src/libraries/System.Data.Common/src/System/Data/Common/DecimalStorage.cs b/src/libraries/System.Data.Common/src/System/Data/Common/DecimalStorage.cs
index a102ae412be95b..5c145272abb937 100644
--- a/src/libraries/System.Data.Common/src/System/Data/Common/DecimalStorage.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/Common/DecimalStorage.cs
@@ -3,6 +3,7 @@
 
 using System.Xml;
 using System.Collections;
+using System.Diagnostics.CodeAnalysis;
 
 namespace System.Data.Common
 {
@@ -237,11 +238,13 @@ public override void SetCapacity(int capacity)
             base.SetCapacity(capacity);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override object ConvertXmlToObject(string s)
         {
             return XmlConvert.ToDecimal(s);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override string ConvertObjectToXml(object value)
         {
             return XmlConvert.ToString((decimal)value);
diff --git a/src/libraries/System.Data.Common/src/System/Data/Common/DoubleStorage.cs b/src/libraries/System.Data.Common/src/System/Data/Common/DoubleStorage.cs
index e27658bfbf9d10..73f17e241e96f5 100644
--- a/src/libraries/System.Data.Common/src/System/Data/Common/DoubleStorage.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/Common/DoubleStorage.cs
@@ -3,6 +3,7 @@
 
 using System.Xml;
 using System.Collections;
+using System.Diagnostics.CodeAnalysis;
 
 namespace System.Data.Common
 {
@@ -241,11 +242,13 @@ public override void SetCapacity(int capacity)
             base.SetCapacity(capacity);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override object ConvertXmlToObject(string s)
         {
             return XmlConvert.ToDouble(s);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override string ConvertObjectToXml(object value)
         {
             return XmlConvert.ToString((double)value);
diff --git a/src/libraries/System.Data.Common/src/System/Data/Common/Int16Storage.cs b/src/libraries/System.Data.Common/src/System/Data/Common/Int16Storage.cs
index ba44cf199a8293..ceac9585cb3831 100644
--- a/src/libraries/System.Data.Common/src/System/Data/Common/Int16Storage.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/Common/Int16Storage.cs
@@ -3,6 +3,7 @@
 
 using System.Xml;
 using System.Collections;
+using System.Diagnostics.CodeAnalysis;
 
 namespace System.Data.Common
 {
@@ -255,11 +256,13 @@ public override void SetCapacity(int capacity)
             base.SetCapacity(capacity);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override object ConvertXmlToObject(string s)
         {
             return XmlConvert.ToInt16(s);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override string ConvertObjectToXml(object value)
         {
             return XmlConvert.ToString((short)value);
diff --git a/src/libraries/System.Data.Common/src/System/Data/Common/Int32Storage.cs b/src/libraries/System.Data.Common/src/System/Data/Common/Int32Storage.cs
index 015d46bf7bc249..11da865400b636 100644
--- a/src/libraries/System.Data.Common/src/System/Data/Common/Int32Storage.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/Common/Int32Storage.cs
@@ -3,6 +3,7 @@
 
 using System.Xml;
 using System.Collections;
+using System.Diagnostics.CodeAnalysis;
 
 namespace System.Data.Common
 {
@@ -254,11 +255,13 @@ public override void SetCapacity(int capacity)
             base.SetCapacity(capacity);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override object ConvertXmlToObject(string s)
         {
             return XmlConvert.ToInt32(s);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override string ConvertObjectToXml(object value)
         {
             return XmlConvert.ToString((int)value);
diff --git a/src/libraries/System.Data.Common/src/System/Data/Common/Int64Storage.cs b/src/libraries/System.Data.Common/src/System/Data/Common/Int64Storage.cs
index 2a6dbc03caf36d..bb0f519ada080a 100644
--- a/src/libraries/System.Data.Common/src/System/Data/Common/Int64Storage.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/Common/Int64Storage.cs
@@ -3,6 +3,7 @@
 
 using System.Xml;
 using System.Collections;
+using System.Diagnostics.CodeAnalysis;
 
 namespace System.Data.Common
 {
@@ -246,11 +247,13 @@ public override void SetCapacity(int capacity)
             base.SetCapacity(capacity);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override object ConvertXmlToObject(string s)
         {
             return XmlConvert.ToInt64(s);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override string ConvertObjectToXml(object value)
         {
             return XmlConvert.ToString((long)value);
diff --git a/src/libraries/System.Data.Common/src/System/Data/Common/ObjectStorage.cs b/src/libraries/System.Data.Common/src/System/Data/Common/ObjectStorage.cs
index a59749d46aa163..aa06791989d6e5 100644
--- a/src/libraries/System.Data.Common/src/System/Data/Common/ObjectStorage.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/Common/ObjectStorage.cs
@@ -9,6 +9,7 @@
 using System.Diagnostics;
 using System.Runtime.CompilerServices;
 using System.Dynamic;
+using System.Diagnostics.CodeAnalysis;
 
 namespace System.Data.Common
 {
@@ -306,6 +307,7 @@ public override void SetCapacity(int capacity)
 
         // Prevent inlining so that reflection calls are not moved to caller that may be in a different assembly that may have a different grant set.
         [MethodImpl(MethodImplOptions.NoInlining)]
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override object ConvertXmlToObject(string s)
         {
             Type type = _dataType; // real type of objects in this column
@@ -346,6 +348,7 @@ public override object ConvertXmlToObject(string s)
 
         // Prevent inlining so that reflection calls are not moved to caller that may be in a different assembly that may have a different grant set.
         [MethodImpl(MethodImplOptions.NoInlining)]
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override object ConvertXmlToObject(XmlReader xmlReader, XmlRootAttribute xmlAttrib)
         {
             object? retValue = null;
@@ -441,9 +444,11 @@ public override object ConvertXmlToObject(XmlReader xmlReader, XmlRootAttribute
                 XmlSerializer deserializerWithRootAttribute = ObjectStorage.GetXmlSerializer(_dataType, xmlAttrib);
                 retValue = deserializerWithRootAttribute.Deserialize(xmlReader);
             }
+
             return retValue!;
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override string ConvertObjectToXml(object value)
         {
             if ((value == null) || (value == _nullValue))// this case won't happen,  this is added in case if code in xml saver changes
@@ -484,6 +489,7 @@ public override string ConvertObjectToXml(object value)
             return strwriter.ToString();
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override void ConvertObjectToXml(object value, XmlWriter xmlWriter, XmlRootAttribute? xmlAttrib)
         {
             if (null == xmlAttrib)
@@ -551,6 +557,7 @@ internal static void VerifyIDynamicMetaObjectProvider(Type type)
             }
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal static XmlSerializer GetXmlSerializer(Type type)
         {
             // prevent writing an instance which implements IDynamicMetaObjectProvider and not IXmlSerializable
@@ -562,6 +569,7 @@ internal static XmlSerializer GetXmlSerializer(Type type)
             return serializer;
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal static XmlSerializer GetXmlSerializer(Type type, XmlRootAttribute attribute)
         {
             XmlSerializer? serializer = null;
diff --git a/src/libraries/System.Data.Common/src/System/Data/Common/SByteStorage.cs b/src/libraries/System.Data.Common/src/System/Data/Common/SByteStorage.cs
index b6ddd9fad0be56..dc58d20033c06b 100644
--- a/src/libraries/System.Data.Common/src/System/Data/Common/SByteStorage.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/Common/SByteStorage.cs
@@ -3,6 +3,7 @@
 
 using System.Xml;
 using System.Collections;
+using System.Diagnostics.CodeAnalysis;
 
 namespace System.Data.Common
 {
@@ -243,11 +244,13 @@ public override void SetCapacity(int capacity)
             base.SetCapacity(capacity);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override object ConvertXmlToObject(string s)
         {
             return XmlConvert.ToSByte(s);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override string ConvertObjectToXml(object value)
         {
             return XmlConvert.ToString((sbyte)value);
diff --git a/src/libraries/System.Data.Common/src/System/Data/Common/SQLTypes/SQLBinaryStorage.cs b/src/libraries/System.Data.Common/src/System/Data/Common/SQLTypes/SQLBinaryStorage.cs
index ce27245f79a9ac..ca43ad5b673794 100644
--- a/src/libraries/System.Data.Common/src/System/Data/Common/SQLTypes/SQLBinaryStorage.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/Common/SQLTypes/SQLBinaryStorage.cs
@@ -7,6 +7,7 @@
 using System.IO;
 using System.Xml.Serialization;
 using System.Collections;
+using System.Diagnostics.CodeAnalysis;
 
 namespace System.Data.Common
 {
@@ -98,6 +99,7 @@ public override void SetCapacity(int capacity)
             _values = newValues;
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override object ConvertXmlToObject(string s)
         {
             SqlBinary newValue = default;
@@ -113,6 +115,7 @@ public override object ConvertXmlToObject(string s)
             return ((SqlBinary)tmp);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override string ConvertObjectToXml(object value)
         {
             Debug.Assert(!DataStorage.IsObjectNull(value), "we should have null here");
diff --git a/src/libraries/System.Data.Common/src/System/Data/Common/SQLTypes/SQLByteStorage.cs b/src/libraries/System.Data.Common/src/System/Data/Common/SQLTypes/SQLByteStorage.cs
index 8b15f077390323..85b4ea53891fa5 100644
--- a/src/libraries/System.Data.Common/src/System/Data/Common/SQLTypes/SQLByteStorage.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/Common/SQLTypes/SQLByteStorage.cs
@@ -7,6 +7,7 @@
 using System.IO;
 using System.Xml.Serialization;
 using System.Collections;
+using System.Diagnostics.CodeAnalysis;
 
 namespace System.Data.Common
 {
@@ -208,6 +209,7 @@ public override void SetCapacity(int capacity)
             _values = newValues;
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override object ConvertXmlToObject(string s)
         {
             SqlByte newValue = default;
@@ -223,6 +225,7 @@ public override object ConvertXmlToObject(string s)
             return ((SqlByte)tmp);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override string ConvertObjectToXml(object value)
         {
             Debug.Assert(!DataStorage.IsObjectNull(value), "we shouldn't have null here");
diff --git a/src/libraries/System.Data.Common/src/System/Data/Common/SQLTypes/SQLBytesStorage.cs b/src/libraries/System.Data.Common/src/System/Data/Common/SQLTypes/SQLBytesStorage.cs
index 76ba3946f7a98f..b3744e9a9201d4 100644
--- a/src/libraries/System.Data.Common/src/System/Data/Common/SQLTypes/SQLBytesStorage.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/Common/SQLTypes/SQLBytesStorage.cs
@@ -4,6 +4,7 @@
 using System.Collections;
 using System.Data.SqlTypes;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using System.Xml;
 using System.Xml.Serialization;
@@ -96,6 +97,7 @@ public override void SetCapacity(int capacity)
             _values = newValues;
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override object ConvertXmlToObject(string s)
         {
             SqlBinary newValue = default;
@@ -111,6 +113,7 @@ public override object ConvertXmlToObject(string s)
             return (new SqlBytes((SqlBinary)tmp));
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override string ConvertObjectToXml(object value)
         {
             Debug.Assert(!DataStorage.IsObjectNull(value), "we shouldn't have null here");
diff --git a/src/libraries/System.Data.Common/src/System/Data/Common/SQLTypes/SQLCharsStorage.cs b/src/libraries/System.Data.Common/src/System/Data/Common/SQLTypes/SQLCharsStorage.cs
index 74dc0329170eb7..2910a01853a4f5 100644
--- a/src/libraries/System.Data.Common/src/System/Data/Common/SQLTypes/SQLCharsStorage.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/Common/SQLTypes/SQLCharsStorage.cs
@@ -7,6 +7,7 @@
 using System.Data.SqlTypes;
 using System.Diagnostics;
 using System.Collections;
+using System.Diagnostics.CodeAnalysis;
 
 namespace System.Data.Common
 {
@@ -98,6 +99,7 @@ public override void SetCapacity(int capacity)
             _values = newValues;
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override object ConvertXmlToObject(string s)
         {
             SqlString newValue = default;
@@ -114,6 +116,7 @@ public override object ConvertXmlToObject(string s)
             return (new SqlChars((SqlString)tmp));
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override string ConvertObjectToXml(object value)
         {
             Debug.Assert(!DataStorage.IsObjectNull(value), "we shouldn't have null here");
diff --git a/src/libraries/System.Data.Common/src/System/Data/Common/SQLTypes/SQLDateTimeStorage.cs b/src/libraries/System.Data.Common/src/System/Data/Common/SQLTypes/SQLDateTimeStorage.cs
index e36e4e03a3ae19..467c856d89f2e1 100644
--- a/src/libraries/System.Data.Common/src/System/Data/Common/SQLTypes/SQLDateTimeStorage.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/Common/SQLTypes/SQLDateTimeStorage.cs
@@ -7,6 +7,7 @@
 using System.IO;
 using System.Xml.Serialization;
 using System.Collections;
+using System.Diagnostics.CodeAnalysis;
 
 namespace System.Data.Common
 {
@@ -134,6 +135,7 @@ public override void SetCapacity(int capacity)
             _values = newValues;
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override object ConvertXmlToObject(string s)
         {
             SqlDateTime newValue = default;
@@ -149,6 +151,7 @@ public override object ConvertXmlToObject(string s)
             return ((SqlDateTime)tmp);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override string ConvertObjectToXml(object value)
         {
             Debug.Assert(!DataStorage.IsObjectNull(value), "we shouldn't have null here");
diff --git a/src/libraries/System.Data.Common/src/System/Data/Common/SQLTypes/SQLDecimalStorage.cs b/src/libraries/System.Data.Common/src/System/Data/Common/SQLTypes/SQLDecimalStorage.cs
index 9245967133ec62..fb2e0b30c8771b 100644
--- a/src/libraries/System.Data.Common/src/System/Data/Common/SQLTypes/SQLDecimalStorage.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/Common/SQLTypes/SQLDecimalStorage.cs
@@ -7,6 +7,7 @@
 using System.IO;
 using System.Xml.Serialization;
 using System.Collections;
+using System.Diagnostics.CodeAnalysis;
 
 namespace System.Data.Common
 {
@@ -206,6 +207,7 @@ public override void SetCapacity(int capacity)
             _values = newValues;
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override object ConvertXmlToObject(string s)
         {
             SqlDecimal newValue = default;
@@ -221,6 +223,7 @@ public override object ConvertXmlToObject(string s)
             return ((SqlDecimal)tmp);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override string ConvertObjectToXml(object value)
         {
             Debug.Assert(!DataStorage.IsObjectNull(value), "we shouldn't have null here");
diff --git a/src/libraries/System.Data.Common/src/System/Data/Common/SQLTypes/SQLDoubleStorage.cs b/src/libraries/System.Data.Common/src/System/Data/Common/SQLTypes/SQLDoubleStorage.cs
index df041e67744253..a9e78552afe9f1 100644
--- a/src/libraries/System.Data.Common/src/System/Data/Common/SQLTypes/SQLDoubleStorage.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/Common/SQLTypes/SQLDoubleStorage.cs
@@ -7,6 +7,7 @@
 using System.IO;
 using System.Xml.Serialization;
 using System.Collections;
+using System.Diagnostics.CodeAnalysis;
 
 namespace System.Data.Common
 {
@@ -207,6 +208,7 @@ public override void SetCapacity(int capacity)
             _values = newValues;
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override object ConvertXmlToObject(string s)
         {
             SqlDouble newValue = default;
@@ -222,6 +224,7 @@ public override object ConvertXmlToObject(string s)
             return ((SqlDouble)tmp);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override string ConvertObjectToXml(object value)
         {
             Debug.Assert(!DataStorage.IsObjectNull(value), "we shouldn't have null here");
diff --git a/src/libraries/System.Data.Common/src/System/Data/Common/SQLTypes/SQLGuidStorage.cs b/src/libraries/System.Data.Common/src/System/Data/Common/SQLTypes/SQLGuidStorage.cs
index bb91efab77c675..38301908ccb591 100644
--- a/src/libraries/System.Data.Common/src/System/Data/Common/SQLTypes/SQLGuidStorage.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/Common/SQLTypes/SQLGuidStorage.cs
@@ -7,6 +7,7 @@
 using System.IO;
 using System.Xml.Serialization;
 using System.Collections;
+using System.Diagnostics.CodeAnalysis;
 
 namespace System.Data.Common
 {
@@ -99,6 +100,7 @@ public override void SetCapacity(int capacity)
             _values = newValues;
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override object ConvertXmlToObject(string s)
         {
             SqlGuid newValue = default;
@@ -114,6 +116,7 @@ public override object ConvertXmlToObject(string s)
             return ((SqlGuid)tmp);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override string ConvertObjectToXml(object value)
         {
             Debug.Assert(!DataStorage.IsObjectNull(value), "we shouldn't have null here");
diff --git a/src/libraries/System.Data.Common/src/System/Data/Common/SQLTypes/SQLInt16Storage.cs b/src/libraries/System.Data.Common/src/System/Data/Common/SQLTypes/SQLInt16Storage.cs
index 17f1aac7213ca7..e210830f4bc90f 100644
--- a/src/libraries/System.Data.Common/src/System/Data/Common/SQLTypes/SQLInt16Storage.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/Common/SQLTypes/SQLInt16Storage.cs
@@ -7,6 +7,7 @@
 using System.IO;
 using System.Xml.Serialization;
 using System.Collections;
+using System.Diagnostics.CodeAnalysis;
 
 namespace System.Data.Common
 {
@@ -207,6 +208,7 @@ public override void SetCapacity(int capacity)
             _values = newValues;
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override object ConvertXmlToObject(string s)
         {
             SqlInt16 newValue = default;
@@ -222,6 +224,7 @@ public override object ConvertXmlToObject(string s)
             return ((SqlInt16)tmp);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override string ConvertObjectToXml(object value)
         {
             Debug.Assert(!DataStorage.IsObjectNull(value), "we shouldn't have null here");
diff --git a/src/libraries/System.Data.Common/src/System/Data/Common/SQLTypes/SQLInt32Storage.cs b/src/libraries/System.Data.Common/src/System/Data/Common/SQLTypes/SQLInt32Storage.cs
index dd48d0237f2f12..d2a1b8118f702d 100644
--- a/src/libraries/System.Data.Common/src/System/Data/Common/SQLTypes/SQLInt32Storage.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/Common/SQLTypes/SQLInt32Storage.cs
@@ -7,6 +7,7 @@
 using System.IO;
 using System.Xml.Serialization;
 using System.Collections;
+using System.Diagnostics.CodeAnalysis;
 
 namespace System.Data.Common
 {
@@ -207,6 +208,7 @@ public override void SetCapacity(int capacity)
             _values = newValues;
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override object ConvertXmlToObject(string s)
         {
             SqlInt32 newValue = default;
@@ -222,6 +224,7 @@ public override object ConvertXmlToObject(string s)
             return ((SqlInt32)tmp);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override string ConvertObjectToXml(object value)
         {
             Debug.Assert(!DataStorage.IsObjectNull(value), "we shouldn't have null here");
diff --git a/src/libraries/System.Data.Common/src/System/Data/Common/SQLTypes/SQLInt64Storage.cs b/src/libraries/System.Data.Common/src/System/Data/Common/SQLTypes/SQLInt64Storage.cs
index e469f3218b5b1c..83d7e548f084cc 100644
--- a/src/libraries/System.Data.Common/src/System/Data/Common/SQLTypes/SQLInt64Storage.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/Common/SQLTypes/SQLInt64Storage.cs
@@ -7,6 +7,7 @@
 using System.IO;
 using System.Xml.Serialization;
 using System.Collections;
+using System.Diagnostics.CodeAnalysis;
 
 namespace System.Data.Common
 {
@@ -208,6 +209,7 @@ public override void SetCapacity(int capacity)
             _values = newValues;
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override object ConvertXmlToObject(string s)
         {
             SqlInt64 newValue = default;
@@ -223,6 +225,7 @@ public override object ConvertXmlToObject(string s)
             return ((SqlInt64)tmp);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override string ConvertObjectToXml(object value)
         {
             Debug.Assert(!DataStorage.IsObjectNull(value), "we shouldn't have null here");
diff --git a/src/libraries/System.Data.Common/src/System/Data/Common/SQLTypes/SQLMoneyStorage.cs b/src/libraries/System.Data.Common/src/System/Data/Common/SQLTypes/SQLMoneyStorage.cs
index a036989e6d8465..f220e760f4ebbb 100644
--- a/src/libraries/System.Data.Common/src/System/Data/Common/SQLTypes/SQLMoneyStorage.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/Common/SQLTypes/SQLMoneyStorage.cs
@@ -7,6 +7,7 @@
 using System.IO;
 using System.Xml.Serialization;
 using System.Collections;
+using System.Diagnostics.CodeAnalysis;
 
 namespace System.Data.Common
 {
@@ -207,6 +208,7 @@ public override void SetCapacity(int capacity)
             _values = newValues;
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override object ConvertXmlToObject(string s)
         {
             SqlMoney newValue = default;
@@ -222,6 +224,7 @@ public override object ConvertXmlToObject(string s)
             return ((SqlMoney)tmp);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override string ConvertObjectToXml(object value)
         {
             Debug.Assert(!DataStorage.IsObjectNull(value), "we shouldn't have null here");
diff --git a/src/libraries/System.Data.Common/src/System/Data/Common/SQLTypes/SQLSingleStorage.cs b/src/libraries/System.Data.Common/src/System/Data/Common/SQLTypes/SQLSingleStorage.cs
index 7a492b26382059..1250ed55ec495c 100644
--- a/src/libraries/System.Data.Common/src/System/Data/Common/SQLTypes/SQLSingleStorage.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/Common/SQLTypes/SQLSingleStorage.cs
@@ -7,6 +7,7 @@
 using System.IO;
 using System.Xml.Serialization;
 using System.Collections;
+using System.Diagnostics.CodeAnalysis;
 
 namespace System.Data.Common
 {
@@ -205,6 +206,7 @@ public override void SetCapacity(int capacity)
             _values = newValues;
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override object ConvertXmlToObject(string s)
         {
             SqlSingle newValue = default;
@@ -220,6 +222,7 @@ public override object ConvertXmlToObject(string s)
             return ((SqlSingle)tmp);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override string ConvertObjectToXml(object value)
         {
             Debug.Assert(!DataStorage.IsObjectNull(value), "we should have null here");
diff --git a/src/libraries/System.Data.Common/src/System/Data/Common/SQLTypes/SQLStringStorage.cs b/src/libraries/System.Data.Common/src/System/Data/Common/SQLTypes/SQLStringStorage.cs
index 7e8094c93610c8..d9413cd0e357d2 100644
--- a/src/libraries/System.Data.Common/src/System/Data/Common/SQLTypes/SQLStringStorage.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/Common/SQLTypes/SQLStringStorage.cs
@@ -7,6 +7,7 @@
 using System.IO;
 using System.Xml.Serialization;
 using System.Collections;
+using System.Diagnostics.CodeAnalysis;
 
 namespace System.Data.Common
 {
@@ -160,6 +161,7 @@ public override void SetCapacity(int capacity)
             _values = newValues;
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override object ConvertXmlToObject(string s)
         {
             SqlString newValue = default;
@@ -175,6 +177,7 @@ public override object ConvertXmlToObject(string s)
             return ((SqlString)tmp);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override string ConvertObjectToXml(object value)
         {
             Debug.Assert(!DataStorage.IsObjectNull(value), "we shouldn't have null here");
diff --git a/src/libraries/System.Data.Common/src/System/Data/Common/SQLTypes/SQlBooleanStorage.cs b/src/libraries/System.Data.Common/src/System/Data/Common/SQLTypes/SQlBooleanStorage.cs
index 4bfadc6eb08571..c8f7cdd257fafc 100644
--- a/src/libraries/System.Data.Common/src/System/Data/Common/SQLTypes/SQlBooleanStorage.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/Common/SQLTypes/SQlBooleanStorage.cs
@@ -7,6 +7,7 @@
 using System.IO;
 using System.Xml.Serialization;
 using System.Collections;
+using System.Diagnostics.CodeAnalysis;
 
 namespace System.Data.Common
 {
@@ -132,6 +133,7 @@ public override void SetCapacity(int capacity)
             _values = newValues;
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override object ConvertXmlToObject(string s)
         {
             SqlBoolean newValue = default;
@@ -147,6 +149,7 @@ public override object ConvertXmlToObject(string s)
             return ((SqlBoolean)tmp);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override string ConvertObjectToXml(object value)
         {
             Debug.Assert(!DataStorage.IsObjectNull(value), "we should have null here");
diff --git a/src/libraries/System.Data.Common/src/System/Data/Common/SingleStorage.cs b/src/libraries/System.Data.Common/src/System/Data/Common/SingleStorage.cs
index 3b10386f663dca..d7f0f5884b67cf 100644
--- a/src/libraries/System.Data.Common/src/System/Data/Common/SingleStorage.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/Common/SingleStorage.cs
@@ -3,6 +3,7 @@
 
 using System.Xml;
 using System.Collections;
+using System.Diagnostics.CodeAnalysis;
 
 namespace System.Data.Common
 {
@@ -242,11 +243,13 @@ public override void SetCapacity(int capacity)
             base.SetCapacity(capacity);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override object ConvertXmlToObject(string s)
         {
             return XmlConvert.ToSingle(s);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override string ConvertObjectToXml(object value)
         {
             return XmlConvert.ToString((float)value);
diff --git a/src/libraries/System.Data.Common/src/System/Data/Common/SqlUDTStorage.cs b/src/libraries/System.Data.Common/src/System/Data/Common/SqlUDTStorage.cs
index 1743d3f667a0ea..16aea8a6c0bb23 100644
--- a/src/libraries/System.Data.Common/src/System/Data/Common/SqlUDTStorage.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/Common/SqlUDTStorage.cs
@@ -10,6 +10,7 @@
 using System.Runtime.CompilerServices;
 using System.Collections.Concurrent;
 using System.Reflection;
+using System.Diagnostics.CodeAnalysis;
 
 namespace System.Data.Common
 {
@@ -21,7 +22,7 @@ internal sealed class SqlUdtStorage : DataStorage
 
         private static readonly ConcurrentDictionary<Type, object> s_typeToNull = new ConcurrentDictionary<Type, object>();
 
-        public SqlUdtStorage(DataColumn column, Type type)
+        public SqlUdtStorage(DataColumn column, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicFields)] Type type)
         : this(column, type, GetStaticNullForUdtType(type))
         {
         }
@@ -34,7 +35,11 @@ private SqlUdtStorage(DataColumn column, Type type, object nullValue)
         }
 
         // to support oracle types and other INUllable types that have static Null as field
-        internal static object GetStaticNullForUdtType(Type type) => s_typeToNull.GetOrAdd(type, t =>
+        internal static object GetStaticNullForUdtType([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicFields)] Type type) => s_typeToNull.GetOrAdd(type, t => GetStaticNullForUdtTypeCore(type));
+
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2070:UnrecognizedReflectionPattern",
+            Justification = "The only callsite is marked with DynamicallyAccessedMembers. Workaround for https://github.com/mono/linker/issues/1981")]
+        private static object GetStaticNullForUdtTypeCore(Type type)
         {
             // TODO: Is it OK for the null value of a UDT to be null? For now annotating is non-nullable.
             PropertyInfo? propInfo = type.GetProperty("Null", BindingFlags.Public | BindingFlags.Static);
@@ -50,7 +55,7 @@ internal static object GetStaticNullForUdtType(Type type) => s_typeToNull.GetOrA
             }
 
             throw ExceptionBuilder.INullableUDTwithoutStaticNull(type.AssemblyQualifiedName!);
-        });
+        }
 
         public override bool IsNull(int record)
         {
@@ -143,6 +148,7 @@ public override void SetCapacity(int capacity)
 
         // Prevent inlining so that reflection calls are not moved to caller that may be in a different assembly that may have a different grant set.
         [MethodImpl(MethodImplOptions.NoInlining)]
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override object ConvertXmlToObject(string s)
         {
             if (_implementsIXmlSerializable)
@@ -166,6 +172,7 @@ public override object ConvertXmlToObject(string s)
 
         // Prevent inlining so that reflection calls are not moved to caller that may be in a different assembly that may have a different grant set.
         [MethodImpl(MethodImplOptions.NoInlining)]
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override object ConvertXmlToObject(XmlReader xmlReader, XmlRootAttribute xmlAttrib)
         {
             if (null == xmlAttrib)
@@ -192,7 +199,7 @@ public override object ConvertXmlToObject(XmlReader xmlReader, XmlRootAttribute
             }
         }
 
-
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override string ConvertObjectToXml(object value)
         {
             StringWriter strwriter = new StringWriter(FormatProvider);
@@ -211,6 +218,7 @@ public override string ConvertObjectToXml(object value)
             return (strwriter.ToString());
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override void ConvertObjectToXml(object value, XmlWriter xmlWriter, XmlRootAttribute? xmlAttrib)
         {
             if (null == xmlAttrib)
diff --git a/src/libraries/System.Data.Common/src/System/Data/Common/StringStorage.cs b/src/libraries/System.Data.Common/src/System/Data/Common/StringStorage.cs
index fa919b377e891e..db06db53dcd332 100644
--- a/src/libraries/System.Data.Common/src/System/Data/Common/StringStorage.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/Common/StringStorage.cs
@@ -3,6 +3,7 @@
 
 using System.Diagnostics;
 using System.Collections;
+using System.Diagnostics.CodeAnalysis;
 
 namespace System.Data.Common
 {
@@ -186,11 +187,13 @@ public override void SetCapacity(int capacity)
             _values = newValues;
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override object ConvertXmlToObject(string s)
         {
             return s;
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override string ConvertObjectToXml(object value)
         {
             return (string)value;
diff --git a/src/libraries/System.Data.Common/src/System/Data/Common/TimeSpanStorage.cs b/src/libraries/System.Data.Common/src/System/Data/Common/TimeSpanStorage.cs
index 5ce9037b61bef6..b6fbd8a7ac3d37 100644
--- a/src/libraries/System.Data.Common/src/System/Data/Common/TimeSpanStorage.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/Common/TimeSpanStorage.cs
@@ -3,6 +3,7 @@
 
 using System.Xml;
 using System.Collections;
+using System.Diagnostics.CodeAnalysis;
 
 namespace System.Data.Common
 {
@@ -261,11 +262,13 @@ public override void SetCapacity(int capacity)
             base.SetCapacity(capacity);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override object ConvertXmlToObject(string s)
         {
             return XmlConvert.ToTimeSpan(s);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override string ConvertObjectToXml(object value)
         {
             return XmlConvert.ToString((TimeSpan)value);
diff --git a/src/libraries/System.Data.Common/src/System/Data/Common/UInt16Storage.cs b/src/libraries/System.Data.Common/src/System/Data/Common/UInt16Storage.cs
index 25d3b7c80d814d..a8a75051ef01c3 100644
--- a/src/libraries/System.Data.Common/src/System/Data/Common/UInt16Storage.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/Common/UInt16Storage.cs
@@ -3,6 +3,7 @@
 
 using System.Xml;
 using System.Collections;
+using System.Diagnostics.CodeAnalysis;
 
 namespace System.Data.Common
 {
@@ -254,11 +255,13 @@ public override void SetCapacity(int capacity)
             base.SetCapacity(capacity);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override object ConvertXmlToObject(string s)
         {
             return XmlConvert.ToUInt16(s);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override string ConvertObjectToXml(object value)
         {
             return XmlConvert.ToString((ushort)value);
diff --git a/src/libraries/System.Data.Common/src/System/Data/Common/UInt32Storage.cs b/src/libraries/System.Data.Common/src/System/Data/Common/UInt32Storage.cs
index b801841aa1e0fd..53a815a262a86e 100644
--- a/src/libraries/System.Data.Common/src/System/Data/Common/UInt32Storage.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/Common/UInt32Storage.cs
@@ -3,6 +3,7 @@
 
 using System.Xml;
 using System.Collections;
+using System.Diagnostics.CodeAnalysis;
 
 namespace System.Data.Common
 {
@@ -253,11 +254,13 @@ public override void SetCapacity(int capacity)
             base.SetCapacity(capacity);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override object ConvertXmlToObject(string s)
         {
             return XmlConvert.ToUInt32(s);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override string ConvertObjectToXml(object value)
         {
             return XmlConvert.ToString((uint)value);
diff --git a/src/libraries/System.Data.Common/src/System/Data/Common/UInt64Storage.cs b/src/libraries/System.Data.Common/src/System/Data/Common/UInt64Storage.cs
index 9dc67b24137cf6..fa18cdee966a6f 100644
--- a/src/libraries/System.Data.Common/src/System/Data/Common/UInt64Storage.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/Common/UInt64Storage.cs
@@ -3,6 +3,7 @@
 
 using System.Xml;
 using System.Collections;
+using System.Diagnostics.CodeAnalysis;
 
 namespace System.Data.Common
 {
@@ -244,11 +245,13 @@ public override void SetCapacity(int capacity)
             base.SetCapacity(capacity);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override object ConvertXmlToObject(string s)
         {
             return XmlConvert.ToUInt64(s);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public override string ConvertObjectToXml(object value)
         {
             return XmlConvert.ToString((ulong)value);
diff --git a/src/libraries/System.Data.Common/src/System/Data/DataColumn.cs b/src/libraries/System.Data.Common/src/System/Data/DataColumn.cs
index eec4b1d090f54f..796ea59699d032 100644
--- a/src/libraries/System.Data.Common/src/System/Data/DataColumn.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/DataColumn.cs
@@ -26,11 +26,13 @@ namespace System.Data
     [DefaultProperty(nameof(ColumnName))]
     [Editor("Microsoft.VSDesigner.Data.Design.DataColumnEditor, Microsoft.VSDesigner, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a",
             "System.Drawing.Design.UITypeEditor, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a")]
+    [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] // needed by Clone() to preserve derived ctors
     public class DataColumn : MarshalByValueComponent
     {
         private bool _allowNull = true;
         private string? _caption;
         private string _columnName;
+        [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicFields)]
         private Type _dataType = null!; // Always set in UpdateColumnType
         private StorageType _storageType;
         internal object _defaultValue = DBNull.Value; // DefaultValue Converter
@@ -76,6 +78,8 @@ public class DataColumn : MarshalByValueComponent
         /// Initializes a new instance of a <see cref='System.Data.DataColumn'/>
         /// class.
         /// </summary>
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
+            Justification = "This is safe because type is string and expression is null.")]
         public DataColumn() : this(null, typeof(string), null, MappingType.Element)
         {
         }
@@ -84,6 +88,8 @@ public DataColumn() : this(null, typeof(string), null, MappingType.Element)
         /// Initializes a new instance of the <see cref='System.Data.DataColumn'/> class
         /// using the specified column name.
         /// </summary>
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
+            Justification = "This is safe because type is string and expression is null.")]
         public DataColumn(string? columnName) : this(columnName, typeof(string), null, MappingType.Element)
         {
         }
@@ -92,7 +98,9 @@ public DataColumn(string? columnName) : this(columnName, typeof(string), null, M
         /// Initializes a new instance of the <see cref='System.Data.DataColumn'/> class
         /// using the specified column name and data type.
         /// </summary>
-        public DataColumn(string? columnName, Type dataType) : this(columnName, dataType, null, MappingType.Element)
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
+            Justification = "Expression is null and `dataType` is marked appropriately.")]
+        public DataColumn(string? columnName, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicFields)] Type dataType) : this(columnName, dataType, null, MappingType.Element)
         {
         }
 
@@ -101,7 +109,8 @@ public DataColumn(string? columnName, Type dataType) : this(columnName, dataType
         /// of the <see cref='System.Data.DataColumn'/> class
         /// using the specified name, data type, and expression.
         /// </summary>
-        public DataColumn(string? columnName, Type dataType, string? expr) : this(columnName, dataType, expr, MappingType.Element)
+        [RequiresUnreferencedCode("Members from serialized types or types used in expressions may be trimmed if not referenced directly.")]
+        public DataColumn(string? columnName, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicFields)] Type dataType, string? expr) : this(columnName, dataType, expr, MappingType.Element)
         {
         }
 
@@ -111,7 +120,8 @@ public DataColumn(string? columnName, Type dataType, string? expr) : this(column
         /// the specified name, data type, expression, and value that determines whether the
         /// column is an attribute.
         /// </summary>
-        public DataColumn(string? columnName, Type dataType, string? expr, MappingType type)
+        [RequiresUnreferencedCode("Members from serialized types or types used in expressions may be trimmed if not referenced directly.")]
+        public DataColumn(string? columnName, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicFields)] Type dataType, string? expr, MappingType type)
         {
             GC.SuppressFinalize(this);
             DataCommonEventSource.Log.Trace("<ds.DataColumn.DataColumn|API> {0}, columnName='{1}', expr='{2}', type={3}", ObjectID, columnName, expr, type);
@@ -143,7 +153,7 @@ public DataColumn(string? columnName, Type dataType, string? expr, MappingType t
             _columnMapping = type;
         }
 
-        private void UpdateColumnType(Type type, StorageType typeCode)
+        private void UpdateColumnType([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicFields)] Type type, StorageType typeCode)
         {
             TypeLimiter.EnsureTypeIsAllowed(type);
             _dataType = type;
@@ -449,6 +459,7 @@ public string Prefix
         // If the column type is string and it's value is empty, then the empty string is returned.
         // If the column type is not string, or the column type is string and the value is not empty string, then a non-empty string is returned
         // This method does not throw any formatting exceptions, since we can always format the field value to a string.
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal string? GetColumnValueAsString(DataRow row, DataRowVersion version)
         {
             object objValue = this[row.GetRecordFromVersion(version)];
@@ -479,6 +490,7 @@ public string Prefix
         [DefaultValue(typeof(string))]
         [RefreshProperties(RefreshProperties.All)]
         [TypeConverter(typeof(ColumnTypeConverter))]
+        [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicFields)]
         [AllowNull]
         public Type DataType
         {
@@ -716,6 +728,7 @@ public object DefaultValue
         public string Expression
         {
             get { return (_expression == null ? "" : _expression.Expression); }
+            [RequiresUnreferencedCode("Members from types used in the expressions may be trimmed if not referenced directly.")]
             set
             {
                 long logScopeId = DataCommonEventSource.Log.EnterScope("<ds.DataColumn.set_Expression|API> {0}, '{1}'", ObjectID, value);
@@ -1777,24 +1790,27 @@ public override string ToString() => _expression == null ?
             ColumnName :
             ColumnName + " + " + Expression;
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal object ConvertXmlToObject(string s)
         {
             Debug.Assert(s != null, "Caller is resposible for missing element/attribute case");
             return InsureStorage().ConvertXmlToObject(s);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal object ConvertXmlToObject(XmlReader xmlReader, XmlRootAttribute xmlAttrib)
         {
             return InsureStorage().ConvertXmlToObject(xmlReader, xmlAttrib);
         }
 
-
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal string ConvertObjectToXml(object value)
         {
             Debug.Assert(value != null && (value != DBNull.Value), "Caller is resposible for checking on DBNull");
             return InsureStorage().ConvertObjectToXml(value);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal void ConvertObjectToXml(object value, XmlWriter xmlWriter, XmlRootAttribute? xmlAttrib)
         {
             Debug.Assert(value != null && (value != DBNull.Value), "Caller is resposible for checking on DBNull");
@@ -1812,6 +1828,7 @@ internal void CopyValueIntoStore(int record, object store, BitArray nullbits, in
             _storage.CopyValueInternal(record, store, nullbits, storeIndex);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal void SetStorage(object store, BitArray nullbits)
         {
             InsureStorage().SetStorageInternal(store, nullbits);
@@ -1875,6 +1892,14 @@ internal void HandleDependentColumnList(DataExpression? oldExpression, DataExpre
                 _table.AddDependentColumn(this);
             }
         }
+
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
+            Justification = "User has already got warning when creating original column.")]
+        internal void CopyExpressionFrom(DataColumn source)
+        {
+            Expression = source.Expression;
+        }
+
     }
 
     internal abstract class AutoIncrementValue
diff --git a/src/libraries/System.Data.Common/src/System/Data/DataColumnCollection.cs b/src/libraries/System.Data.Common/src/System/Data/DataColumnCollection.cs
index 5a8742ae06965d..cfe21932b0a1ea 100644
--- a/src/libraries/System.Data.Common/src/System/Data/DataColumnCollection.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/DataColumnCollection.cs
@@ -182,7 +182,7 @@ internal void AddAt(int index, DataColumn column)
             }
             if (!_table.fInitInProgress && column != null && column.Computed)
             {
-                column.Expression = column.Expression;
+                column.CopyExpressionFrom(column);
             }
             OnCollectionChanged(new CollectionChangeEventArgs(CollectionChangeAction.Add, column));
         }
@@ -211,7 +211,8 @@ public void AddRange(DataColumn[] columns)
         /// Creates and adds a <see cref='System.Data.DataColumn'/>
         /// with the specified name, type, and compute expression to the columns collection.
         /// </summary>
-        public DataColumn Add(string? columnName, Type type, string expression)
+        [RequiresUnreferencedCode("Members might be trimmed for some data types or expressions.")]
+        public DataColumn Add(string? columnName, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicFields)] Type type, string expression)
         {
             var column = new DataColumn(columnName, type, expression);
             Add(column);
@@ -223,7 +224,7 @@ public DataColumn Add(string? columnName, Type type, string expression)
         /// with the
         /// specified name and type to the columns collection.
         /// </summary>
-        public DataColumn Add(string? columnName, Type type)
+        public DataColumn Add(string? columnName, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicFields)] Type type)
         {
             var column = new DataColumn(columnName, type);
             Add(column);
diff --git a/src/libraries/System.Data.Common/src/System/Data/DataRow.cs b/src/libraries/System.Data.Common/src/System/Data/DataRow.cs
index aab6210014ab31..19b725110bb143 100644
--- a/src/libraries/System.Data.Common/src/System/Data/DataRow.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/DataRow.cs
@@ -1360,6 +1360,7 @@ internal void SetParentRowToDBNull(DataRelation relation)
             parentKeyValues[0] = DBNull.Value;
             SetKeyValues(relation.ChildKey, parentKeyValues);
         }
+
         public void SetAdded()
         {
             if (RowState == DataRowState.Unchanged)
diff --git a/src/libraries/System.Data.Common/src/System/Data/DataSet.cs b/src/libraries/System.Data.Common/src/System/Data/DataSet.cs
index 9e4a168c8822bd..7543cb5b3b1423 100644
--- a/src/libraries/System.Data.Common/src/System/Data/DataSet.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/DataSet.cs
@@ -30,8 +30,10 @@ namespace System.Data
     [XmlSchemaProvider(nameof(GetDataSetSchema))]
     [XmlRoot(nameof(DataSet))]
     [System.Runtime.CompilerServices.TypeForwardedFrom("System.Data, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
+    [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor | DynamicallyAccessedMemberTypes.NonPublicConstructors)] // needed by Clone() to preserve derived ctors
     public class DataSet : MarshalByValueComponent, IListSource, IXmlSerializable, ISupportInitializeNotification, ISerializable
     {
+        internal const string RequiresUnreferencedCodeMessage = "Members from serialized types may be trimmed if not referenced directly.";
         private const string KEY_XMLSCHEMA = "XmlSchema";
         private const string KEY_XMLDIFFGRAM = "XmlDiffGram";
 
@@ -203,6 +205,7 @@ protected SchemaSerializationMode DetermineSchemaSerializationMode(XmlReader rea
 
         // Deserialize all the tables data of the dataset from binary/xml stream.
         // 'instance' method that consumes SerializationInfo
+        [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)]
         protected void GetSerializationData(SerializationInfo info, StreamingContext context)
         {
             // mainly for typed DS
@@ -223,10 +226,12 @@ protected void GetSerializationData(SerializationInfo info, StreamingContext con
 
 
         // Deserialize all the tables schema and data of the dataset from binary/xml stream.
+        [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)]
         protected DataSet(SerializationInfo info, StreamingContext context) : this(info, context, true)
         {
         }
 
+        [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)]
         protected DataSet(SerializationInfo info, StreamingContext context, bool ConstructSchema) : this()
         {
             SerializationFormat remotingFormat = SerializationFormat.Xml;
@@ -273,6 +278,7 @@ public virtual void GetObjectData(SerializationInfo info, StreamingContext conte
         protected virtual void InitializeDerivedDataSet() { }
 
         // Serialize all the tables.
+        [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)]
         private void SerializeDataSet(SerializationInfo info, StreamingContext context, SerializationFormat remotingFormat)
         {
             Debug.Assert(info != null);
@@ -358,6 +364,7 @@ private void SerializeDataSet(SerializationInfo info, StreamingContext context,
         }
 
         // Deserialize all the tables - marked internal so that DataTable can call into this
+        [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)]
         internal void DeserializeDataSet(SerializationInfo info, StreamingContext context, SerializationFormat remotingFormat, SchemaSerializationMode schemaSerializationMode)
         {
             // deserialize schema
@@ -367,6 +374,7 @@ internal void DeserializeDataSet(SerializationInfo info, StreamingContext contex
         }
 
         // Deserialize schema.
+        [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)]
         private void DeserializeDataSetSchema(SerializationInfo info, StreamingContext context, SerializationFormat remotingFormat, SchemaSerializationMode schemaSerializationMode)
         {
             if (remotingFormat != SerializationFormat.Xml)
@@ -425,6 +433,7 @@ private void DeserializeDataSetSchema(SerializationInfo info, StreamingContext c
         }
 
         // Deserialize all  data.
+        [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)]
         private void DeserializeDataSetData(SerializationInfo info, StreamingContext context, SerializationFormat remotingFormat)
         {
             if (remotingFormat != SerializationFormat.Xml)
@@ -1088,6 +1097,13 @@ public void Clear()
             }
         }
 
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
+            Justification = "Only parameterless constructors are used here but since nonPublic=true, all non-public constructors are being preserved causing a warning for the serialization constructors. Those constructors won't be used here.")]
+        private DataSet CreateInstanceOfThisType()
+        {
+            return (DataSet)Activator.CreateInstance(GetType(), true)!;
+        }
+
         /// <summary>
         /// Clones the structure of the <see cref='System.Data.DataSet'/>, including all <see cref='System.Data.DataTable'/> schemas, relations, and
         /// constraints.
@@ -1099,7 +1115,7 @@ public virtual DataSet Clone()
             long logScopeId = DataCommonEventSource.Log.EnterScope("<ds.DataSet.Clone|API> {0}", ObjectID);
             try
             {
-                DataSet ds = (DataSet)Activator.CreateInstance(GetType(), true)!;
+                DataSet ds = CreateInstanceOfThisType();
 
                 if (ds.Tables.Count > 0)  // To clean up all the schema in strong typed dataset.
                 {
@@ -1173,7 +1189,7 @@ public virtual DataSet Clone()
                     {
                         if (col.Expression.Length != 0)
                         {
-                            ds.Tables[table.TableName, table.Namespace]!.Columns[col.ColumnName]!.Expression = col.Expression;
+                            ds.Tables[table.TableName, table.Namespace]!.Columns[col.ColumnName]!.CopyExpressionFrom(col);
                         }
                     }
                 }
@@ -1395,11 +1411,12 @@ private void MarkRelatedRowsAsModified(TableChanges[] bitMatrix, DataRow row)
             }
         }
 
-// TODO: Enable after System.ComponentModel.TypeConverter is annotated
+        // TODO: Enable after System.ComponentModel.TypeConverter is annotated
 #nullable disable
         IList IListSource.GetList() => DefaultViewManager;
 #nullable enable
 
+        [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)]
         internal string GetRemotingDiffGram(DataTable table)
         {
             StringWriter strWriter = new StringWriter(CultureInfo.InvariantCulture);
@@ -1411,6 +1428,7 @@ internal string GetRemotingDiffGram(DataTable table)
             return strWriter.ToString();
         }
 
+        [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)]
         public string GetXml()
         {
             long logScopeId = DataCommonEventSource.Log.EnterScope("<ds.DataSet.GetXml|API> {0}", ObjectID);
@@ -1430,6 +1448,7 @@ public string GetXml()
             }
         }
 
+        [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)]
         public string GetXmlSchema()
         {
             long logScopeId = DataCommonEventSource.Log.EnterScope("<ds.DataSet.GetXmlSchema|API> {0}", ObjectID);
@@ -1448,6 +1467,7 @@ public string GetXmlSchema()
             }
         }
 
+        [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)]
         internal string GetXmlSchemaForRemoting(DataTable? table)
         {
             StringWriter strWriter = new StringWriter(CultureInfo.InvariantCulture);
@@ -1520,6 +1540,7 @@ public bool HasChanges(DataRowState rowStates)
         /// <summary>
         /// Infer the XML schema from the specified <see cref='System.IO.TextReader'/> into the <see cref='System.Data.DataSet'/>.
         /// </summary>
+        [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)]
         public void InferXmlSchema(XmlReader? reader, string[]? nsArray)
         {
             long logScopeId = DataCommonEventSource.Log.EnterScope("<ds.DataSet.InferXmlSchema|API> {0}", ObjectID);
@@ -1557,6 +1578,7 @@ public void InferXmlSchema(XmlReader? reader, string[]? nsArray)
         /// <summary>
         /// Infer the XML schema from the specified <see cref='System.IO.TextReader'/> into the <see cref='System.Data.DataSet'/>.
         /// </summary>
+        [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)]
         public void InferXmlSchema(Stream? stream, string[]? nsArray)
         {
             if (stream == null)
@@ -1570,6 +1592,7 @@ public void InferXmlSchema(Stream? stream, string[]? nsArray)
         /// <summary>
         /// Infer the XML schema from the specified <see cref='System.IO.TextReader'/> into the <see cref='System.Data.DataSet'/>.
         /// </summary>
+        [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)]
         public void InferXmlSchema(TextReader? reader, string[]? nsArray)
         {
             if (reader == null)
@@ -1583,6 +1606,7 @@ public void InferXmlSchema(TextReader? reader, string[]? nsArray)
         /// <summary>
         /// Infer the XML schema from the specified file into the <see cref='System.Data.DataSet'/>.
         /// </summary>
+        [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)]
         public void InferXmlSchema(string fileName, string[]? nsArray)
         {
             XmlTextReader xr = new XmlTextReader(fileName);
@@ -1599,8 +1623,10 @@ public void InferXmlSchema(string fileName, string[]? nsArray)
         /// <summary>
         /// Reads the XML schema from the specified <see cref="System.Xml.XmlReader" /> into the <see cref="System.Data.DataSet" />
         /// </summary>
+        [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)]
         public void ReadXmlSchema(XmlReader? reader) => ReadXmlSchema(reader, false);
 
+        [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)]
         internal void ReadXmlSchema(XmlReader? reader, bool denyResolving)
         {
             long logScopeId = DataCommonEventSource.Log.EnterScope("<ds.DataSet.ReadXmlSchema|INFO> {0}, reader, denyResolving={1}", ObjectID, denyResolving);
@@ -1745,6 +1771,7 @@ internal void ReadEndElement(XmlReader reader)
             }
         }
 
+        [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)]
         internal void ReadXSDSchema(XmlReader reader, bool denyResolving)
         {
             XmlSchemaSet sSet = new XmlSchemaSet();
@@ -1784,6 +1811,7 @@ internal void ReadXSDSchema(XmlReader reader, bool denyResolving)
             schema.LoadSchema(sSet, this);
         }
 
+        [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)]
         internal void ReadXDRSchema(XmlReader reader)
         {
             XmlDocument xdoc = new XmlDocument(); // we may need this to infer the schema
@@ -1798,6 +1826,7 @@ internal void ReadXDRSchema(XmlReader reader)
         /// Reads the XML schema from the specified <see cref='System.IO.Stream'/> into the
         /// <see cref='System.Data.DataSet'/>.
         /// </summary>
+        [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)]
         public void ReadXmlSchema(Stream? stream)
         {
             if (stream == null)
@@ -1811,6 +1840,7 @@ public void ReadXmlSchema(Stream? stream)
         /// <summary>
         /// Reads the XML schema from the specified <see cref='System.IO.TextReader'/> into the <see cref='System.Data.DataSet'/>.
         /// </summary>
+        [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)]
         public void ReadXmlSchema(TextReader? reader)
         {
             if (reader == null)
@@ -1824,6 +1854,7 @@ public void ReadXmlSchema(TextReader? reader)
         /// <summary>
         /// Reads the XML schema from the specified file into the <see cref='System.Data.DataSet'/>.
         /// </summary>
+        [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)]
         public void ReadXmlSchema(string fileName)
         {
             XmlTextReader xr = new XmlTextReader(fileName);
@@ -1840,11 +1871,13 @@ public void ReadXmlSchema(string fileName)
         #region WriteXmlSchema
         /// <summary>Writes the <see cref='DataSet'/> structure as an XML schema to using the specified <see cref='Stream'/> object.</summary>
         /// <param name="stream">A <see cref='Stream'/> object used to write to a file.</param>
+        [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)]
         public void WriteXmlSchema(Stream? stream) => WriteXmlSchema(stream, SchemaFormat.Public, null);
 
         /// <summary>Writes the <see cref='DataSet'/> structure as an XML schema to using the specified <see cref='Stream'/> object.</summary>
         /// <param name="stream">A <see cref='Stream'/> object used to write to a file.</param>
         /// <param name="multipleTargetConverter">A delegate used to convert <see cref='Type'/> into string.</param>
+        [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)]
         public void WriteXmlSchema(Stream? stream, Converter<Type, string> multipleTargetConverter)
         {
             ADP.CheckArgumentNull(multipleTargetConverter, nameof(multipleTargetConverter));
@@ -1853,11 +1886,13 @@ public void WriteXmlSchema(Stream? stream, Converter<Type, string> multipleTarge
 
         /// <summary>Writes the <see cref='DataSet'/> structure as an XML schema to a file.</summary>
         /// <param name="fileName">The file name (including the path) to which to write.</param>
+        [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)]
         public void WriteXmlSchema(string fileName) => WriteXmlSchema(fileName, SchemaFormat.Public, null);
 
         /// <summary>Writes the <see cref='DataSet'/> structure as an XML schema to a file.</summary>
         /// <param name="fileName">The file name (including the path) to which to write.</param>
         /// <param name="multipleTargetConverter">A delegate used to convert <see cref='Type'/> into string.</param>
+        [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)]
         public void WriteXmlSchema(string fileName, Converter<Type, string> multipleTargetConverter)
         {
             ADP.CheckArgumentNull(multipleTargetConverter, nameof(multipleTargetConverter));
@@ -1866,11 +1901,13 @@ public void WriteXmlSchema(string fileName, Converter<Type, string> multipleTarg
 
         /// <summary>Writes the <see cref='DataSet'/> structure as an XML schema to a <see cref='TextWriter'/> object.</summary>
         /// <param name="writer">The <see cref='TextWriter'/> object with which to write.</param>
+        [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)]
         public void WriteXmlSchema(TextWriter? writer) => WriteXmlSchema(writer, SchemaFormat.Public, null);
 
         /// <summary>Writes the <see cref='DataSet'/> structure as an XML schema to a <see cref='TextWriter'/> object.</summary>
         /// <param name="writer">The <see cref='TextWriter'/> object with which to write.</param>
         /// <param name="multipleTargetConverter">A delegate used to convert <see cref='Type'/> into string.</param>
+        [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)]
         public void WriteXmlSchema(TextWriter? writer, Converter<Type, string> multipleTargetConverter)
         {
             ADP.CheckArgumentNull(multipleTargetConverter, nameof(multipleTargetConverter));
@@ -1879,17 +1916,20 @@ public void WriteXmlSchema(TextWriter? writer, Converter<Type, string> multipleT
 
         /// <summary>Writes the <see cref='DataSet'/> structure as an XML schema to an <see cref='XmlWriter'/> object.</summary>
         /// <param name="writer">The <see cref='XmlWriter'/> object with which to write.</param>
+        [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)]
         public void WriteXmlSchema(XmlWriter? writer) => WriteXmlSchema(writer, SchemaFormat.Public, null);
 
         /// <summary>Writes the <see cref='DataSet'/> structure as an XML schema to an <see cref='XmlWriter'/> object.</summary>
         /// <param name="writer">The <see cref='XmlWriter'/> object with which to write.</param>
         /// <param name="multipleTargetConverter">A delegate used to convert <see cref='Type'/> into string.</param>
+        [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)]
         public void WriteXmlSchema(XmlWriter? writer, Converter<Type, string> multipleTargetConverter)
         {
             ADP.CheckArgumentNull(multipleTargetConverter, nameof(multipleTargetConverter));
             WriteXmlSchema(writer, SchemaFormat.Public, multipleTargetConverter);
         }
 
+        [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)]
         private void WriteXmlSchema(string fileName, SchemaFormat schemaFormat, Converter<Type, string>? multipleTargetConverter)
         {
             XmlTextWriter xw = new XmlTextWriter(fileName, null);
@@ -1906,6 +1946,7 @@ private void WriteXmlSchema(string fileName, SchemaFormat schemaFormat, Converte
             }
         }
 
+        [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)]
         private void WriteXmlSchema(Stream? stream, SchemaFormat schemaFormat, Converter<Type, string>? multipleTargetConverter)
         {
             if (stream == null)
@@ -1919,6 +1960,7 @@ private void WriteXmlSchema(Stream? stream, SchemaFormat schemaFormat, Converter
             WriteXmlSchema(w, schemaFormat, multipleTargetConverter);
         }
 
+        [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)]
         private void WriteXmlSchema(TextWriter? writer, SchemaFormat schemaFormat, Converter<Type, string>? multipleTargetConverter)
         {
             if (writer == null)
@@ -1932,6 +1974,7 @@ private void WriteXmlSchema(TextWriter? writer, SchemaFormat schemaFormat, Conve
             WriteXmlSchema(w, schemaFormat, multipleTargetConverter);
         }
 
+        [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)]
         private void WriteXmlSchema(XmlWriter? writer, SchemaFormat schemaFormat, Converter<Type, string>? multipleTargetConverter)
         {
             long logScopeId = DataCommonEventSource.Log.EnterScope("<ds.DataSet.WriteXmlSchema|INFO> {0}, schemaFormat={1}", ObjectID, schemaFormat);
@@ -1962,8 +2005,10 @@ private void WriteXmlSchema(XmlWriter? writer, SchemaFormat schemaFormat, Conver
         }
         #endregion
 
+        [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)]
         public XmlReadMode ReadXml(XmlReader? reader) => ReadXml(reader, false);
 
+        [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)]
         internal XmlReadMode ReadXml(XmlReader? reader, bool denyResolving)
         {
             IDisposable? restrictedScope = null;
@@ -2243,6 +2288,7 @@ internal XmlReadMode ReadXml(XmlReader? reader, bool denyResolving)
             }
         }
 
+        [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)]
         public XmlReadMode ReadXml(Stream? stream)
         {
             if (stream == null)
@@ -2258,6 +2304,7 @@ public XmlReadMode ReadXml(Stream? stream)
             return ReadXml(xr, false);
         }
 
+        [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)]
         public XmlReadMode ReadXml(TextReader? reader)
         {
             if (reader == null)
@@ -2273,6 +2320,7 @@ public XmlReadMode ReadXml(TextReader? reader)
             return ReadXml(xr, false);
         }
 
+        [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)]
         public XmlReadMode ReadXml(string fileName)
         {
             XmlTextReader xr = new XmlTextReader(fileName);
@@ -2290,6 +2338,7 @@ public XmlReadMode ReadXml(string fileName)
             }
         }
 
+        [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)]
         internal void InferSchema(XmlDocument xdoc, string[]? excludedNamespaces, XmlReadMode mode)
         {
             long logScopeId = DataCommonEventSource.Log.EnterScope("<ds.DataSet.InferSchema|INFO> {0}, mode={1}", ObjectID, mode);
@@ -2341,6 +2390,7 @@ private bool IsEmpty()
             return true;
         }
 
+        [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)]
         private void ReadXmlDiffgram(XmlReader reader)
         {
             long logScopeId = DataCommonEventSource.Log.EnterScope("<ds.DataSet.ReadXmlDiffgram|INFO> {0}", ObjectID);
@@ -2471,8 +2521,10 @@ private void ReadXmlDiffgram(XmlReader reader)
 
         /// <summary>
         /// </summary>
+        [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)]
         public XmlReadMode ReadXml(XmlReader? reader, XmlReadMode mode) => ReadXml(reader, mode, false);
 
+        [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)]
         internal XmlReadMode ReadXml(XmlReader? reader, XmlReadMode mode, bool denyResolving)
         {
             IDisposable? restictedScope = null;
@@ -2726,6 +2778,7 @@ internal XmlReadMode ReadXml(XmlReader? reader, XmlReadMode mode, bool denyResol
             }
         }
 
+        [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)]
         public XmlReadMode ReadXml(Stream? stream, XmlReadMode mode)
         {
             if (stream == null)
@@ -2739,6 +2792,7 @@ public XmlReadMode ReadXml(Stream? stream, XmlReadMode mode)
             return ReadXml(reader, mode, false);
         }
 
+        [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)]
         public XmlReadMode ReadXml(TextReader? reader, XmlReadMode mode)
         {
             if (reader == null)
@@ -2752,6 +2806,7 @@ public XmlReadMode ReadXml(TextReader? reader, XmlReadMode mode)
             return ReadXml(xmlreader, mode, false);
         }
 
+        [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)]
         public XmlReadMode ReadXml(string fileName, XmlReadMode mode)
         {
             XmlTextReader? xr = null;
@@ -2778,17 +2833,22 @@ public XmlReadMode ReadXml(string fileName, XmlReadMode mode)
             }
         }
 
+        [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)]
         public void WriteXml(Stream? stream) => WriteXml(stream, XmlWriteMode.IgnoreSchema);
 
+        [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)]
         public void WriteXml(TextWriter? writer) => WriteXml(writer, XmlWriteMode.IgnoreSchema);
 
+        [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)]
         public void WriteXml(XmlWriter? writer) => WriteXml(writer, XmlWriteMode.IgnoreSchema);
 
+        [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)]
         public void WriteXml(string fileName) => WriteXml(fileName, XmlWriteMode.IgnoreSchema);
 
         /// <summary>
         /// Writes schema and data for the DataSet.
         /// </summary>
+        [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)]
         public void WriteXml(Stream? stream, XmlWriteMode mode)
         {
             if (stream != null)
@@ -2800,6 +2860,7 @@ public void WriteXml(Stream? stream, XmlWriteMode mode)
             }
         }
 
+        [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)]
         public void WriteXml(TextWriter? writer, XmlWriteMode mode)
         {
             if (writer != null)
@@ -2811,6 +2872,7 @@ public void WriteXml(TextWriter? writer, XmlWriteMode mode)
             }
         }
 
+        [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)]
         public void WriteXml(XmlWriter? writer, XmlWriteMode mode)
         {
             long logScopeId = DataCommonEventSource.Log.EnterScope("<ds.DataSet.WriteXml|API> {0}, mode={1}", ObjectID, mode);
@@ -2837,6 +2899,7 @@ public void WriteXml(XmlWriter? writer, XmlWriteMode mode)
             }
         }
 
+        [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)]
         public void WriteXml(string fileName, XmlWriteMode mode)
         {
             long logScopeId = DataCommonEventSource.Log.EnterScope("<ds.DataSet.WriteXml|API> {0}, fileName='{1}', mode={2}", ObjectID, fileName, (int)mode);
@@ -3297,6 +3360,7 @@ internal bool ValidateLocaleConstraint()
             return null;
         }
 
+        [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)]
         protected virtual void ReadXmlSerializable(XmlReader reader)
         {
             // <DataSet xsi:nil="true"> does not mean DataSet is null,but it does not have any child
diff --git a/src/libraries/System.Data.Common/src/System/Data/DataTable.cs b/src/libraries/System.Data.Common/src/System/Data/DataTable.cs
index 8b4c1083b60882..f3e89e19b64a4d 100644
--- a/src/libraries/System.Data.Common/src/System/Data/DataTable.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/DataTable.cs
@@ -191,6 +191,7 @@ public DataTable(string? tableName, string? tableNamespace) : this(tableName)
         }
 
         // Deserialize the table from binary/xml stream.
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         protected DataTable(SerializationInfo info, StreamingContext context) : this()
         {
             bool isSingleTable = context.Context != null ? Convert.ToBoolean(context.Context, CultureInfo.InvariantCulture) : true;
@@ -217,6 +218,7 @@ public virtual void GetObjectData(SerializationInfo info, StreamingContext conte
         }
 
         // Serialize the table schema and data.
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void SerializeDataTable(SerializationInfo info, StreamingContext context, bool isSingleTable, SerializationFormat remotingFormat)
         {
             info.AddValue("DataTable.RemotingVersion", new Version(2, 0));
@@ -280,6 +282,7 @@ private void SerializeDataTable(SerializationInfo info, StreamingContext context
         }
 
         // Deserialize the table schema and data.
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal void DeserializeDataTable(SerializationInfo info, StreamingContext context, bool isSingleTable, SerializationFormat remotingFormat)
         {
             if (remotingFormat != SerializationFormat.Xml)
@@ -321,6 +324,7 @@ internal void DeserializeDataTable(SerializationInfo info, StreamingContext cont
         }
 
         // Serialize the columns
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal void SerializeTableSchema(SerializationInfo info, StreamingContext context, bool isSingleTable)
         {
             //DataTable basic  properties
@@ -397,6 +401,7 @@ internal void SerializeTableSchema(SerializationInfo info, StreamingContext cont
         }
 
         // Deserialize all the Columns
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal void DeserializeTableSchema(SerializationInfo info, StreamingContext context, bool isSingleTable)
         {
             //DataTable basic properties
@@ -645,6 +650,7 @@ internal void SerializeExpressionColumns(SerializationInfo info, StreamingContex
         }
 
         // Deserialize the expressions on the table - Marked internal so that DataSet deserializer can call into this
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal void DeserializeExpressionColumns(SerializationInfo info, StreamingContext context, int serIndex)
         {
             int colCount = Columns.Count;
@@ -659,6 +665,7 @@ internal void DeserializeExpressionColumns(SerializationInfo info, StreamingCont
         }
 
         // Serialize all the Rows.
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal void SerializeTableData(SerializationInfo info, StreamingContext context, int serIndex)
         {
             //Cache all the column count, row count
@@ -744,6 +751,7 @@ internal void SerializeTableData(SerializationInfo info, StreamingContext contex
         }
 
         // Deserialize all the Rows.
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal void DeserializeTableData(SerializationInfo info, StreamingContext context, int serIndex)
         {
             bool enforceConstraintsOrg = _enforceConstraints;
@@ -896,6 +904,7 @@ internal void GetRowAndColumnErrors(int rowIndex, Hashtable rowErrors, Hashtable
         }
 
         // Set the row and columns in error..
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void ConvertToRowError(int rowIndex, Hashtable rowErrors, Hashtable colErrors)
         {
             Debug.Assert(Rows.Count > rowIndex);
@@ -1242,6 +1251,7 @@ public DataView DefaultView
         public string DisplayExpression
         {
             get { return DisplayExpressionInternal; }
+            [RequiresUnreferencedCode("Members from types used in the expressions may be trimmed if not referenced directly.")]
             set
             {
                 _displayExpression = !string.IsNullOrEmpty(value) ?
@@ -2005,7 +2015,7 @@ public virtual void EndInit()
                 {
                     if (dc.Computed)
                     {
-                        dc.Expression = dc.Expression;
+                        dc.CopyExpressionFrom(dc);
                     }
                 }
             }
@@ -2316,7 +2326,6 @@ internal DataTable Clone(DataSet? cloneDS)
             }
         }
 
-
         private DataTable IncrementalCloneTo(DataTable sourceTable, DataTable targetTable)
         {
             foreach (DataColumn dc in sourceTable.Columns)
@@ -2409,7 +2418,7 @@ private DataTable CloneTo(DataTable clone, DataSet? cloneDS, bool skipExpression
             {
                 for (int i = 0; i < clmns.Count; i++)
                 {
-                    clone.Columns[clmns[i].ColumnName]!.Expression = clmns[i].Expression;
+                    clone.Columns[clmns[i].ColumnName]!.CopyExpressionFrom(clmns[i]);
                 }
             }
 
@@ -2811,7 +2820,6 @@ internal void CheckNotModifying(DataRow row)
         /// <summary>
         /// Clears the table of all data.
         /// </summary>
-
         public void Clear() => Clear(true);
 
         internal void Clear(bool clearAll)
@@ -2946,6 +2954,7 @@ internal int Compare(string s1, string s2, CompareInfo? comparer)
         /// <summary>
         /// Computes the given expression on the current rows that pass the filter criteria.
         /// </summary>
+        [RequiresUnreferencedCode("Members of types used in the filter or expression might be trimmed.")]
         public object Compute(string? expression, string? filter)
         {
             DataRow[] rows = Select(filter, "", DataViewRowState.CurrentRows);
@@ -3185,7 +3194,7 @@ internal Index GetIndex(IndexField[] indexDesc, DataViewRowState recordStates, I
             return ndx;
         }
 
-// TODO: Enable after System.ComponentModel.TypeConverter is annotated
+        // TODO: Enable after System.ComponentModel.TypeConverter is annotated
 #nullable disable
         IList IListSource.GetList() => DefaultView;
 
@@ -4194,6 +4203,8 @@ internal void RollbackRow(DataRow row)
         /// <summary>
         /// Returns an array of all <see cref='System.Data.DataRow'/> objects.
         /// </summary>
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
+            Justification = "Filter expression is empty therefore this is safe.")]
         public DataRow[] Select()
         {
             DataCommonEventSource.Log.Trace("<ds.DataTable.Select|API> {0}", ObjectID);
@@ -4204,6 +4215,7 @@ public DataRow[] Select()
         /// Returns an array of all <see cref='System.Data.DataRow'/> objects that match the filter criteria in order of
         /// primary key (or lacking one, order of addition.)
         /// </summary>
+        [RequiresUnreferencedCode(Data.Select.RequiresUnreferencedCodeMessage)]
         public DataRow[] Select(string? filterExpression)
         {
             DataCommonEventSource.Log.Trace("<ds.DataTable.Select|API> {0}, filterExpression='{1}'", ObjectID, filterExpression);
@@ -4214,6 +4226,7 @@ public DataRow[] Select(string? filterExpression)
         /// Returns an array of all <see cref='System.Data.DataRow'/> objects that match the filter criteria, in the
         /// specified sort order.
         /// </summary>
+        [RequiresUnreferencedCode(Data.Select.RequiresUnreferencedCodeMessage)]
         public DataRow[] Select(string? filterExpression, string? sort)
         {
             DataCommonEventSource.Log.Trace("<ds.DataTable.Select|API> {0}, filterExpression='{1}', sort='{2}'", ObjectID, filterExpression, sort);
@@ -4224,6 +4237,7 @@ public DataRow[] Select(string? filterExpression, string? sort)
         /// Returns an array of all <see cref='System.Data.DataRow'/> objects that match the filter in the order of the
         /// sort, that match the specified state.
         /// </summary>
+        [RequiresUnreferencedCode(Data.Select.RequiresUnreferencedCodeMessage)]
         public DataRow[] Select(string? filterExpression, string? sort, DataViewRowState recordStates)
         {
             DataCommonEventSource.Log.Trace("<ds.DataTable.Select|API> {0}, filterExpression='{1}', sort='{2}', recordStates={3}", ObjectID, filterExpression, sort, recordStates);
@@ -4821,6 +4835,8 @@ internal bool UpdatingCurrent(DataRow row, DataRowAction action)
                    action == DataRowAction.ChangeCurrentAndOriginal);
         }
 
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
+            Justification = "DataColumn with null expression and int data type is safe.")]
         internal DataColumn AddUniqueKey(int position)
         {
             if (_colUnique != null)
@@ -4868,6 +4884,8 @@ internal DataColumn AddUniqueKey(int position)
 
         internal DataColumn AddUniqueKey() => AddUniqueKey(-1);
 
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
+            Justification = "Expression is null and potential problem with data type has already been reported when constructing parentKey")]
         internal DataColumn AddForeignKey(DataColumn parentKey)
         {
             Debug.Assert(parentKey != null, "AddForeignKey: Invalid paramter.. related primary key is null");
@@ -5298,24 +5316,34 @@ private void SetDataRowWithLoadOption(DataRow dataRow, int recordNo, LoadOption
 
         public DataTableReader CreateDataReader() => new DataTableReader(this);
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public void WriteXml(Stream? stream) => WriteXml(stream, XmlWriteMode.IgnoreSchema, false);
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public void WriteXml(Stream? stream, bool writeHierarchy) => WriteXml(stream, XmlWriteMode.IgnoreSchema, writeHierarchy);
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public void WriteXml(TextWriter? writer) => WriteXml(writer, XmlWriteMode.IgnoreSchema, false);
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public void WriteXml(TextWriter? writer, bool writeHierarchy) => WriteXml(writer, XmlWriteMode.IgnoreSchema, writeHierarchy);
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public void WriteXml(XmlWriter? writer) => WriteXml(writer, XmlWriteMode.IgnoreSchema, false);
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public void WriteXml(XmlWriter? writer, bool writeHierarchy) => WriteXml(writer, XmlWriteMode.IgnoreSchema, writeHierarchy);
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public void WriteXml(string fileName) => WriteXml(fileName, XmlWriteMode.IgnoreSchema, false);
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public void WriteXml(string fileName, bool writeHierarchy) => WriteXml(fileName, XmlWriteMode.IgnoreSchema, writeHierarchy);
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public void WriteXml(Stream? stream, XmlWriteMode mode) => WriteXml(stream, mode, false);
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public void WriteXml(Stream? stream, XmlWriteMode mode, bool writeHierarchy)
         {
             if (stream != null)
@@ -5327,11 +5355,13 @@ public void WriteXml(Stream? stream, XmlWriteMode mode, bool writeHierarchy)
             }
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public void WriteXml(TextWriter? writer, XmlWriteMode mode)
         {
             WriteXml(writer, mode, false);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public void WriteXml(TextWriter? writer, XmlWriteMode mode, bool writeHierarchy)
         {
             if (writer != null)
@@ -5343,10 +5373,13 @@ public void WriteXml(TextWriter? writer, XmlWriteMode mode, bool writeHierarchy)
             }
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public void WriteXml(XmlWriter? writer, XmlWriteMode mode)
         {
             WriteXml(writer, mode, false);
         }
+
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public void WriteXml(XmlWriter? writer, XmlWriteMode mode, bool writeHierarchy)
         {
             long logScopeId = DataCommonEventSource.Log.EnterScope("<ds.DataTable.WriteXml|API> {0}, mode={1}", ObjectID, mode);
@@ -5414,8 +5447,10 @@ public void WriteXml(XmlWriter? writer, XmlWriteMode mode, bool writeHierarchy)
             }
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public void WriteXml(string fileName, XmlWriteMode mode) => WriteXml(fileName, mode, false);
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public void WriteXml(string fileName, XmlWriteMode mode, bool writeHierarchy)
         {
             long logScopeId = DataCommonEventSource.Log.EnterScope("<ds.DataTable.WriteXml|API> {0}, fileName='{1}', mode={2}", ObjectID, fileName, mode);
@@ -5437,8 +5472,10 @@ public void WriteXml(string fileName, XmlWriteMode mode, bool writeHierarchy)
             }
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public void WriteXmlSchema(Stream? stream) => WriteXmlSchema(stream, false);
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public void WriteXmlSchema(Stream? stream, bool writeHierarchy)
         {
             if (stream == null)
@@ -5452,8 +5489,10 @@ public void WriteXmlSchema(Stream? stream, bool writeHierarchy)
             WriteXmlSchema(w, writeHierarchy);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public void WriteXmlSchema(TextWriter? writer) => WriteXmlSchema(writer, false);
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public void WriteXmlSchema(TextWriter? writer, bool writeHierarchy)
         {
             if (writer == null)
@@ -5502,8 +5541,10 @@ private bool CheckForClosureOnExpressionTables(List<DataTable> tableList)
             return true;
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public void WriteXmlSchema(XmlWriter? writer) => WriteXmlSchema(writer, false);
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public void WriteXmlSchema(XmlWriter? writer, bool writeHierarchy)
         {
             long logScopeId = DataCommonEventSource.Log.EnterScope("<ds.DataTable.WriteXmlSchema|API> {0}", ObjectID);
@@ -5557,8 +5598,10 @@ public void WriteXmlSchema(XmlWriter? writer, bool writeHierarchy)
             }
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public void WriteXmlSchema(string fileName) => WriteXmlSchema(fileName, false);
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public void WriteXmlSchema(string fileName, bool writeHierarchy)
         {
             XmlTextWriter xw = new XmlTextWriter(fileName, null);
@@ -5575,6 +5618,7 @@ public void WriteXmlSchema(string fileName, bool writeHierarchy)
             }
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public XmlReadMode ReadXml(Stream? stream)
         {
             if (stream == null)
@@ -5590,6 +5634,7 @@ public XmlReadMode ReadXml(Stream? stream)
             return ReadXml(xr, false);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public XmlReadMode ReadXml(TextReader? reader)
         {
             if (reader == null)
@@ -5605,6 +5650,7 @@ public XmlReadMode ReadXml(TextReader? reader)
             return ReadXml(xr, false);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public XmlReadMode ReadXml(string fileName)
         {
             XmlTextReader xr = new XmlTextReader(fileName);
@@ -5622,6 +5668,7 @@ public XmlReadMode ReadXml(string fileName)
             }
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public XmlReadMode ReadXml(XmlReader? reader) => ReadXml(reader, false);
 
         private void RestoreConstraint(bool originalEnforceConstraint)
@@ -5659,6 +5706,7 @@ private bool IsEmptyXml(XmlReader reader)
             return false;
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal XmlReadMode ReadXml(XmlReader? reader, bool denyResolving)
         {
             IDisposable? restrictedScope = null;
@@ -6233,6 +6281,8 @@ internal bool MoveToElement(XmlReader reader, int depth)
             }
             return (reader.NodeType == XmlNodeType.Element);
         }
+
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void ReadXmlDiffgram(XmlReader reader)
         {
             // fill correctly
@@ -6342,6 +6392,7 @@ private void ReadXmlDiffgram(XmlReader reader)
             EnforceConstraints = fEnforce;
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal void ReadXSDSchema(XmlReader reader, bool denyResolving)
         {
             XmlSchemaSet sSet = new XmlSchemaSet();
@@ -6358,6 +6409,7 @@ internal void ReadXSDSchema(XmlReader reader, bool denyResolving)
             schema.LoadSchema(sSet, this);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public void ReadXmlSchema(Stream? stream)
         {
             if (stream == null)
@@ -6368,6 +6420,7 @@ public void ReadXmlSchema(Stream? stream)
             ReadXmlSchema(new XmlTextReader(stream), false);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public void ReadXmlSchema(TextReader? reader)
         {
             if (reader == null)
@@ -6378,6 +6431,7 @@ public void ReadXmlSchema(TextReader? reader)
             ReadXmlSchema(new XmlTextReader(reader), false);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public void ReadXmlSchema(string fileName)
         {
             XmlTextReader xr = new XmlTextReader(fileName);
@@ -6391,11 +6445,13 @@ public void ReadXmlSchema(string fileName)
             }
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public void ReadXmlSchema(XmlReader? reader)
         {
             ReadXmlSchema(reader, false);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal void ReadXmlSchema(XmlReader? reader, bool denyResolving)
         {
             long logScopeId = DataCommonEventSource.Log.EnterScope("<ds.DataTable.ReadXmlSchema|INFO> {0}, denyResolving={1}", ObjectID, denyResolving);
@@ -6646,7 +6702,7 @@ public static XmlSchemaComplexType GetDataTableSchema(XmlSchemaSet? schemaSet)
             return XmlSchema.Read(new XmlTextReader(stream), null);
         }
 
-// TODO: Enable after System.Private.Xml is annotated
+        // TODO: Enable after System.Private.Xml is annotated
 #nullable disable
 #pragma warning disable 8632
         void IXmlSerializable.ReadXml(XmlReader reader)
@@ -6668,12 +6724,18 @@ void IXmlSerializable.ReadXml(XmlReader reader)
 
         void IXmlSerializable.WriteXml(XmlWriter writer)
         {
-            WriteXmlSchema(writer, false);
-            WriteXml(writer, XmlWriteMode.DiffGram, false);
+            WriteXmlCore(writer);
         }
 #pragma warning restore 8632
 #nullable enable
 
+        // This method exists so that suppression can be placed on `IXmlSerializable.WriteXml(XmlWriter writer)`
+        private void WriteXmlCore(XmlWriter writer)
+        {
+            WriteXmlSchema(writer, false);
+            WriteXml(writer, XmlWriteMode.DiffGram, false);
+        }
+
         protected virtual void ReadXmlSerializable(XmlReader? reader) => ReadXml(reader, XmlReadMode.DiffGram, true);
 
         // RowDiffIdUsageSection & DSRowDiffIdUsageSection Usage:
@@ -6880,6 +6942,8 @@ internal void EvaluateExpressions()
             }
         }
 
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
+            Justification = "This is unsafe only when columns have associated expression. All ways to add such expression are marked unsafe.")]
         internal void EvaluateExpressions(DataRow row, DataRowAction action, List<DataRow>? cachedRows)
         {
             // evaluate all expressions for specified row
diff --git a/src/libraries/System.Data.Common/src/System/Data/DataView.cs b/src/libraries/System.Data.Common/src/System/Data/DataView.cs
index 11ed8cd79f61d9..ba1e5fa3f54456 100644
--- a/src/libraries/System.Data.Common/src/System/Data/DataView.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/DataView.cs
@@ -126,6 +126,7 @@ public DataView(DataTable? table) : this(table, false)
         /// Initializes a new instance of the <see cref='System.Data.DataView'/> class with the
         ///    specified <see cref='System.Data.DataTable'/>.
         /// </summary>
+        [RequiresUnreferencedCode(Select.RequiresUnreferencedCodeMessage)]
         public DataView(DataTable table, string? RowFilter, string? Sort, DataViewRowState RowState)
         {
             GC.SuppressFinalize(this);
@@ -314,6 +315,7 @@ public virtual string? RowFilter
                 DataExpression? expression = (_rowFilter as DataExpression);
                 return (expression == null ? "" : expression.Expression); // CONSIDER: return optimized expression here
             }
+            [RequiresUnreferencedCode(Select.RequiresUnreferencedCodeMessage)]
             set
             {
                 if (value == null)
@@ -577,6 +579,8 @@ public void BeginInit()
             _fInitInProgress = true;
         }
 
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
+            Justification = "Warning related to RowFilter has already been shown when RowFilter was delay set.")]
         public void EndInit()
         {
             if (_delayedTable != null && _delayedTable.fInitInProgress)
@@ -961,6 +965,7 @@ void IList.Remove(object? value)
         bool IBindingList.SupportsSearching => true;
         bool IBindingList.SupportsSorting => true;
         bool IBindingList.IsSorted => Sort.Length != 0;
+
         PropertyDescriptor IBindingList.SortProperty => GetSortProperty();
 
         internal PropertyDescriptor GetSortProperty()
@@ -1123,8 +1128,10 @@ private string CreateSortString(PropertyDescriptor property, ListSortDirection d
             return resultString.ToString();
         }
 
-// TODO: Enable after System.ComponentModel.TypeConverter is annotated
+        // TODO: Enable after System.ComponentModel.TypeConverter is annotated
 #nullable disable
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
+            Justification = "Safe because filter is set to empty string.")]
         void IBindingListView.RemoveFilter()
         {
             DataCommonEventSource.Log.Trace("<ds.DataView.RemoveFilter|API> {0}", ObjectID);
@@ -1516,7 +1523,7 @@ internal void SetDataViewManager(DataViewManager? dataViewManager)
                     {
                         // sdub: check that we will not do unnesasary operation here if dataViewSetting.Sort == this.Sort ...
                         _applyDefaultSort = dataViewSetting.ApplyDefaultSort;
-                        DataExpression newFilter = new DataExpression(_table, dataViewSetting.RowFilter);
+                        DataExpression newFilter = CreateDataExpressionFromDataViewSettings(dataViewSetting);
                         SetIndex(dataViewSetting.Sort, dataViewSetting.RowStateFilter, newFilter);
                     }
                     catch (Exception e) when (Common.ADP.IsCatchableExceptionType(e))
@@ -1532,6 +1539,14 @@ internal void SetDataViewManager(DataViewManager? dataViewManager)
             }
         }
 
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
+            Justification = "RowFilter is marked as unsafe because it can be used in DataExpression so that we only display warning when user is assigning an expression" +
+                " which means that in here we're either assigning empty filter which is safe or user has already seen a warning.")]
+        private DataExpression CreateDataExpressionFromDataViewSettings(DataViewSetting dataViewSetting)
+        {
+            return new DataExpression(_table, dataViewSetting.RowFilter);
+        }
+
         internal virtual void SetIndex(string newSort, DataViewRowState newRowStates, IFilter? newRowFilter)
         {
             SetIndex2(newSort, newRowStates, newRowFilter, true);
diff --git a/src/libraries/System.Data.Common/src/System/Data/DataViewListener.cs b/src/libraries/System.Data.Common/src/System/Data/DataViewListener.cs
index b278f160c6ad7f..db8424731ab346 100644
--- a/src/libraries/System.Data.Common/src/System/Data/DataViewListener.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/DataViewListener.cs
@@ -4,6 +4,7 @@
 using System.ComponentModel;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 
 namespace System.Data
 {
diff --git a/src/libraries/System.Data.Common/src/System/Data/DataViewManager.cs b/src/libraries/System.Data.Common/src/System/Data/DataViewManager.cs
index 8850e45f122ae9..1303b616edb261 100644
--- a/src/libraries/System.Data.Common/src/System/Data/DataViewManager.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/DataViewManager.cs
@@ -97,6 +97,7 @@ public string DataViewSettingCollectionString
                 builder.Append("</DataViewSettingCollectionString>");
                 return builder.ToString();
             }
+            [RequiresUnreferencedCode("Members of types used in the RowFilter expression might be trimmed.")]
             set
             {
                 if (string.IsNullOrEmpty(value))
diff --git a/src/libraries/System.Data.Common/src/System/Data/DataViewSetting.cs b/src/libraries/System.Data.Common/src/System/Data/DataViewSetting.cs
index 2ec0f4fcfa7389..0e910870633ad1 100644
--- a/src/libraries/System.Data.Common/src/System/Data/DataViewSetting.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/DataViewSetting.cs
@@ -56,6 +56,7 @@ internal void SetDataTable(DataTable table)
         public string RowFilter
         {
             get { return _rowFilter; }
+            [RequiresUnreferencedCode(Select.RequiresUnreferencedCodeMessage)]
             set
             {
                 if (value == null)
diff --git a/src/libraries/System.Data.Common/src/System/Data/EnumerableRowCollection.cs b/src/libraries/System.Data.Common/src/System/Data/EnumerableRowCollection.cs
index bbdf6b51a75183..f2e8743198ad7e 100644
--- a/src/libraries/System.Data.Common/src/System/Data/EnumerableRowCollection.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/EnumerableRowCollection.cs
@@ -5,6 +5,7 @@
 using System.Collections.Generic;
 using System.Data;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 
 namespace System.Data
diff --git a/src/libraries/System.Data.Common/src/System/Data/Filter/AggregateNode.cs b/src/libraries/System.Data.Common/src/System/Data/Filter/AggregateNode.cs
index 98760f2ecbf9b7..0dca43b20ca626 100644
--- a/src/libraries/System.Data.Common/src/System/Data/Filter/AggregateNode.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/Filter/AggregateNode.cs
@@ -3,6 +3,7 @@
 
 using System.Diagnostics;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 
 namespace System.Data
 {
@@ -155,11 +156,13 @@ internal static void Bind(DataRelation? relation, List<DataColumn> list)
             }
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal override object Eval()
         {
             return Eval(null, DataRowVersion.Default);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal override object Eval(DataRow? row, DataRowVersion version)
         {
             if (_childTable == null)
@@ -220,6 +223,7 @@ internal override object Eval(DataRow? row, DataRowVersion version)
         }
 
         // Helper for the DataTable.Compute method
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal override object Eval(int[] records)
         {
             if (_childTable == null)
diff --git a/src/libraries/System.Data.Common/src/System/Data/Filter/BinaryNode.cs b/src/libraries/System.Data.Common/src/System/Data/Filter/BinaryNode.cs
index fb537bdce17a1f..03c7c208352086 100644
--- a/src/libraries/System.Data.Common/src/System/Data/Filter/BinaryNode.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/Filter/BinaryNode.cs
@@ -6,6 +6,7 @@
 using System.Globalization;
 using System.Data.SqlTypes;
 using System.Data.Common;
+using System.Diagnostics.CodeAnalysis;
 
 namespace System.Data
 {
@@ -30,16 +31,19 @@ internal override void Bind(DataTable table, List<DataColumn> list)
             _right.Bind(table, list);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal override object Eval()
         {
             return Eval(null, DataRowVersion.Default);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal override object Eval(DataRow? row, DataRowVersion version)
         {
             return EvalBinaryOp(_op, _left, _right, row, version, null);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal override object Eval(int[] recordNos)
         {
             return EvalBinaryOp(_op, _left, _right, null, DataRowVersion.Default, recordNos);
@@ -109,7 +113,7 @@ internal override ExpressionNode Optimize()
 
             if (IsConstant())
             {
-                object val = Eval();
+                object val = EvalConstant();
 
                 if (val == DBNull.Value)
                 {
@@ -134,6 +138,15 @@ internal void SetTypeMismatchError(int op, Type left, Type right)
             throw ExprException.TypeMismatchInBinop(op, left, right);
         }
 
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
+            Justification = "Evaluating constant expression is safe.")]
+        private object EvalConstant()
+        {
+            Debug.Assert(IsConstant());
+            return Eval();
+        }
+
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private static object Eval(ExpressionNode expr, DataRow? row, DataRowVersion version, int[]? recordNos)
         {
             if (recordNos == null)
@@ -267,6 +280,7 @@ internal int BinaryCompare(object vLeft, object vRight, StorageType resultType,
             return result;
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private object EvalBinaryOp(int op, ExpressionNode left, ExpressionNode right, DataRow? row, DataRowVersion version, int[]? recordNos)
         {
             object vLeft;
@@ -1514,6 +1528,7 @@ internal LikeNode(DataTable? table, int op, ExpressionNode left, ExpressionNode
         {
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal override object Eval(DataRow? row, DataRowVersion version)
         {
             object vLeft = _left.Eval(row, version);
diff --git a/src/libraries/System.Data.Common/src/System/Data/Filter/ConstNode.cs b/src/libraries/System.Data.Common/src/System/Data/Filter/ConstNode.cs
index 63d3676890094f..308352fe6dbfcb 100644
--- a/src/libraries/System.Data.Common/src/System/Data/Filter/ConstNode.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/Filter/ConstNode.cs
@@ -4,6 +4,7 @@
 using System.Diagnostics;
 using System.Collections.Generic;
 using System.Globalization;
+using System.Diagnostics.CodeAnalysis;
 
 namespace System.Data
 {
@@ -68,16 +69,19 @@ internal override void Bind(DataTable table, List<DataColumn> list)
             BindTable(table);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal override object Eval()
         {
             return _val;
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal override object Eval(DataRow? row, DataRowVersion version)
         {
             return Eval();
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal override object Eval(int[] recordNos)
         {
             return Eval();
diff --git a/src/libraries/System.Data.Common/src/System/Data/Filter/DataExpression.cs b/src/libraries/System.Data.Common/src/System/Data/Filter/DataExpression.cs
index 8be3afbd84d3cf..79dc4a705ab7d8 100644
--- a/src/libraries/System.Data.Common/src/System/Data/Filter/DataExpression.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/Filter/DataExpression.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.Collections.Generic;
 using System.Data.SqlTypes;
 using System.Data.Common;
@@ -20,10 +21,12 @@ internal sealed class DataExpression : IFilter
         private readonly Type? _dataType;  // This set if the expression is part of ExpressionCoulmn
         private DataColumn[] _dependency = Array.Empty<DataColumn>();
 
+        [RequiresUnreferencedCode("Members of types used in the expression might be trimmed")]
         internal DataExpression(DataTable? table, string? expression) : this(table, expression, null)
         {
         }
 
+        [RequiresUnreferencedCode("Members of types used in the expression might be trimmed")]
         internal DataExpression(DataTable? table, string? expression, Type? type)
         {
             ExpressionParser parser = new ExpressionParser(table);
@@ -115,6 +118,8 @@ internal object Evaluate()
             return Evaluate((DataRow?)null, DataRowVersion.Default);
         }
 
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
+            Justification = "Constructors taking expression are marked as unsafe")]
         internal object Evaluate(DataRow? row, DataRowVersion version)
         {
             object? result;
@@ -158,7 +163,8 @@ internal object Evaluate(DataRow[] rows)
             return Evaluate(rows, DataRowVersion.Default);
         }
 
-
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
+            Justification = "Constructors taking expression are marked as unsafe")]
         internal object Evaluate(DataRow[] rows, DataRowVersion version)
         {
             if (!_bound)
@@ -185,6 +191,8 @@ internal object Evaluate(DataRow[] rows, DataRowVersion version)
             }
         }
 
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
+            Justification = "Constructors taking expression are marked as unsafe")]
         public bool Invoke(DataRow row, DataRowVersion version)
         {
             if (_expr == null)
diff --git a/src/libraries/System.Data.Common/src/System/Data/Filter/ExpressionNode.cs b/src/libraries/System.Data.Common/src/System/Data/Filter/ExpressionNode.cs
index 2febaeb4721a02..7d5c4ba4a4d59a 100644
--- a/src/libraries/System.Data.Common/src/System/Data/Filter/ExpressionNode.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/Filter/ExpressionNode.cs
@@ -3,6 +3,7 @@
 
 using System.Collections.Generic;
 using System.Data.Common;
+using System.Diagnostics.CodeAnalysis;
 
 namespace System.Data
 {
@@ -43,13 +44,17 @@ protected void BindTable(DataTable table)
         }
 
         internal abstract void Bind(DataTable table, List<DataColumn> list);
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal abstract object Eval();
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal abstract object Eval(DataRow? row, DataRowVersion version);
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal abstract object Eval(int[] recordNos);
         internal abstract bool IsConstant();
         internal abstract bool IsTableConstant();
         internal abstract bool HasLocalAggregate();
         internal abstract bool HasRemoteAggregate();
+
         internal abstract ExpressionNode Optimize();
         internal virtual bool DependsOn(DataColumn column)
         {
diff --git a/src/libraries/System.Data.Common/src/System/Data/Filter/ExpressionParser.cs b/src/libraries/System.Data.Common/src/System/Data/Filter/ExpressionParser.cs
index d6e20b5a9f0c74..83a5066a4261c5 100644
--- a/src/libraries/System.Data.Common/src/System/Data/Filter/ExpressionParser.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/Filter/ExpressionParser.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
 
 namespace System.Data
diff --git a/src/libraries/System.Data.Common/src/System/Data/Filter/FunctionNode.cs b/src/libraries/System.Data.Common/src/System/Data/Filter/FunctionNode.cs
index 6a666e60718f4b..79577f945b94e2 100644
--- a/src/libraries/System.Data.Common/src/System/Data/Filter/FunctionNode.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/Filter/FunctionNode.cs
@@ -5,6 +5,7 @@
 using System.Data.Common;
 using System.Data.SqlTypes;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.Runtime.Serialization;
 
 namespace System.Data
@@ -110,11 +111,13 @@ internal override void Bind(DataTable table, List<DataColumn> list)
             }
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal override object Eval()
         {
             return Eval(null, DataRowVersion.Default);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal override object Eval(DataRow? row, DataRowVersion version)
         {
             Debug.Assert(_info < s_funcs.Length && _info >= 0, "Invalid function info.");
@@ -173,6 +176,7 @@ internal override object Eval(DataRow? row, DataRowVersion version)
             return EvalFunction(s_funcs[_info]._id, argumentValues, row, version);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal override object Eval(int[] recordNos)
         {
             throw ExprException.ComputeNotAggregate(ToString()!);
@@ -242,6 +246,8 @@ internal override bool DependsOn(DataColumn column)
             return false;
         }
 
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
+            Justification = "Constant expressions are safe to be evaluated.")]
         internal override ExpressionNode Optimize()
         {
             for (int i = 0; i < _argumentCount; i++)
@@ -270,6 +276,7 @@ internal override ExpressionNode Optimize()
             return this;
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private Type GetDataType(ExpressionNode node)
         {
             Type nodeType = node.GetType();
@@ -304,6 +311,7 @@ private Type GetDataType(ExpressionNode node)
             return dataType;
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private object EvalFunction(FunctionId id, object[] argumentValues, DataRow? row, DataRowVersion version)
         {
             StorageType storageType;
diff --git a/src/libraries/System.Data.Common/src/System/Data/Filter/LookupNode.cs b/src/libraries/System.Data.Common/src/System/Data/Filter/LookupNode.cs
index bacf6d2fabc71f..d19576c26aa4be 100644
--- a/src/libraries/System.Data.Common/src/System/Data/Filter/LookupNode.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/Filter/LookupNode.cs
@@ -3,6 +3,7 @@
 
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 
 namespace System.Data
 {
@@ -82,11 +83,13 @@ internal override void Bind(DataTable table, List<DataColumn> list)
             AggregateNode.Bind(_relation, list);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal override object Eval()
         {
             throw ExprException.EvalNoContext();
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal override object Eval(DataRow? row, DataRowVersion version)
         {
             if (_column == null || _relation == null)
@@ -99,6 +102,7 @@ internal override object Eval(DataRow? row, DataRowVersion version)
             return parent[_column, parent.HasVersion(version) ? version : DataRowVersion.Current];
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal override object Eval(int[] recordNos)
         {
             throw ExprException.ComputeNotAggregate(ToString()!);
diff --git a/src/libraries/System.Data.Common/src/System/Data/Filter/NameNode.cs b/src/libraries/System.Data.Common/src/System/Data/Filter/NameNode.cs
index 8cb163db379f2d..ded0f3982a6c87 100644
--- a/src/libraries/System.Data.Common/src/System/Data/Filter/NameNode.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/Filter/NameNode.cs
@@ -3,6 +3,7 @@
 
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 
 namespace System.Data
 {
@@ -75,12 +76,14 @@ internal override void Bind(DataTable table, List<DataColumn> list)
             }
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal override object Eval()
         {
             // can not eval column without ROW value;
             throw ExprException.EvalNoContext();
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal override object Eval(DataRow? row, DataRowVersion version)
         {
             if (!_found)
@@ -101,6 +104,7 @@ internal override object Eval(DataRow? row, DataRowVersion version)
             return _column![row.GetRecordFromVersion(version)];
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal override object Eval(int[] records)
         {
             throw ExprException.ComputeNotAggregate(ToString()!);
diff --git a/src/libraries/System.Data.Common/src/System/Data/Filter/UnaryNode.cs b/src/libraries/System.Data.Common/src/System/Data/Filter/UnaryNode.cs
index 3bff8db070a367..5e0fcb37424479 100644
--- a/src/libraries/System.Data.Common/src/System/Data/Filter/UnaryNode.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/Filter/UnaryNode.cs
@@ -5,6 +5,7 @@
 using System.Diagnostics;
 using System.Data.Common;
 using System.Data.SqlTypes;
+using System.Diagnostics.CodeAnalysis;
 
 namespace System.Data
 {
@@ -26,16 +27,19 @@ internal override void Bind(DataTable table, List<DataColumn> list)
             _right.Bind(table, list);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal override object Eval()
         {
             return Eval(null, DataRowVersion.Default);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal override object Eval(DataRow? row, DataRowVersion version)
         {
             return EvalUnaryOp(_op, _right.Eval(row, version));
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal override object Eval(int[] recordNos)
         {
             return _right.Eval(recordNos);
@@ -170,7 +174,8 @@ internal override bool DependsOn(DataColumn column)
             return (_right.DependsOn(column));
         }
 
-
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
+            Justification = "Evaluating constant expression is safe")]
         internal override ExpressionNode Optimize()
         {
             _right = _right.Optimize();
diff --git a/src/libraries/System.Data.Common/src/System/Data/Filter/ZeroOpNode.cs b/src/libraries/System.Data.Common/src/System/Data/Filter/ZeroOpNode.cs
index 75291d3c86f679..28b6771c198119 100644
--- a/src/libraries/System.Data.Common/src/System/Data/Filter/ZeroOpNode.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/Filter/ZeroOpNode.cs
@@ -3,6 +3,7 @@
 
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 
 namespace System.Data
 {
@@ -24,6 +25,7 @@ internal override void Bind(DataTable table, List<DataColumn> list)
         {
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal override object Eval()
         {
             switch (_op)
@@ -40,11 +42,13 @@ internal override object Eval()
             }
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal override object Eval(DataRow? row, DataRowVersion version)
         {
             return Eval();
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal override object Eval(int[] recordNos)
         {
             return Eval();
diff --git a/src/libraries/System.Data.Common/src/System/Data/LinqDataView.cs b/src/libraries/System.Data.Common/src/System/Data/LinqDataView.cs
index 92753db288013c..361ef47e0f2fc9 100644
--- a/src/libraries/System.Data.Common/src/System/Data/LinqDataView.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/LinqDataView.cs
@@ -7,6 +7,7 @@
 using System.ComponentModel;
 using System.Data;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 
 namespace System.Data
 {
@@ -82,7 +83,7 @@ public override string? RowFilter
                     return null;
                 }
             }
-
+            [RequiresUnreferencedCode(Select.RequiresUnreferencedCodeMessage)]
             set
             {
                 if (value == null)
@@ -230,7 +231,7 @@ internal override void SetIndex(string newSort, DataViewRowState newRowStates, I
         #endregion
 
         #region IBindingList
-// TODO: Enable after System.ComponentModel.TypeConverter is annotated
+        // TODO: Enable after System.ComponentModel.TypeConverter is annotated
 #nullable disable
         /// <summary>
         /// Clears both expression-based and DataView's string-based sorting.
diff --git a/src/libraries/System.Data.Common/src/System/Data/Merger.cs b/src/libraries/System.Data.Common/src/System/Data/Merger.cs
index a06f531ab1ce91..5a4c7b1179f057 100644
--- a/src/libraries/System.Data.Common/src/System/Data/Merger.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/Merger.cs
@@ -4,6 +4,7 @@
 using System.Collections;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 
 namespace System.Data
 {
@@ -104,7 +105,7 @@ internal void MergeDataSet(DataSet source)
                             DataColumn targetColumn = targetTable.Columns[dc.ColumnName]!;
                             if (!existingColumns!.Contains(targetColumn))
                             {
-                                targetColumn.Expression = dc.Expression;
+                                targetColumn.CopyExpressionFrom(dc);
                             }
                         }
                     }
@@ -405,7 +406,7 @@ internal void MergeRows(DataRow[] rows)
                     {
                         for (int i = oldCount; i < targetTable.Columns.Count; i++)
                         {
-                            targetTable.Columns[i].Expression = table.Columns[targetTable.Columns[i].ColumnName]!.Expression;
+                            targetTable.Columns[i].CopyExpressionFrom(table.Columns[targetTable.Columns[i].ColumnName]!);
                         }
                     }
 
diff --git a/src/libraries/System.Data.Common/src/System/Data/ProviderBase/SchemaMapping.cs b/src/libraries/System.Data.Common/src/System/Data/ProviderBase/SchemaMapping.cs
index 849908991e48a8..432e0eb7142bf2 100644
--- a/src/libraries/System.Data.Common/src/System/Data/ProviderBase/SchemaMapping.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/ProviderBase/SchemaMapping.cs
@@ -4,6 +4,7 @@
 using System.Collections.Generic;
 using System.Data.Common;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
 
 namespace System.Data.ProviderBase
@@ -1138,6 +1139,7 @@ private void RollbackAddedItems(List<object>? items)
             return dataValues;
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void AddAdditionalProperties(DataColumn targetColumn, DataRow schemaRow)
         {
             DataColumnCollection columns = schemaRow.Table.Columns;
diff --git a/src/libraries/System.Data.Common/src/System/Data/RecordManager.cs b/src/libraries/System.Data.Common/src/System/Data/RecordManager.cs
index dfffcc6e52c216..585c6c248976d2 100644
--- a/src/libraries/System.Data.Common/src/System/Data/RecordManager.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/RecordManager.cs
@@ -94,6 +94,7 @@ private int NormalizedMinimumCapacity(int capacity)
 
             return (((capacity + 10) >> 10) + 1) << 10;
         }
+
         internal int NewRecordBase()
         {
             int record;
diff --git a/src/libraries/System.Data.Common/src/System/Data/Select.cs b/src/libraries/System.Data.Common/src/System/Data/Select.cs
index 97fbb80c7b08fc..79c273c1d5dc94 100644
--- a/src/libraries/System.Data.Common/src/System/Data/Select.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/Select.cs
@@ -4,11 +4,13 @@
 using System.Collections.Generic;
 using System.Data.Common;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 
 namespace System.Data
 {
     internal sealed class Select
     {
+        internal const string RequiresUnreferencedCodeMessage = "Members of types used in the filter expression might be trimmed.";
         private readonly DataTable _table;
         private readonly IndexField[] _indexFields;
         private readonly DataViewRowState _recordStates;
@@ -34,6 +36,7 @@ private sealed class ColumnInfo
         private int _nCandidates;
         private int _matchedCandidates;
 
+        [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)]
         public Select(DataTable table, string? filterExpression, string? sort, DataViewRowState recordStates)
         {
             _table = table;
@@ -596,6 +599,8 @@ public DataRow[] GetRows()
             return newRows;
         }
 
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
+            Justification = "All constructors are marked as unsafe.")]
         private bool AcceptRecord(int record)
         {
             DataRow? row = _table._recordManager[record];
@@ -630,6 +635,8 @@ private bool AcceptRecord(int record)
             return result;
         }
 
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
+            Justification = "All constructors are marked as unsafe.")]
         private int Eval(BinaryNode expr, DataRow row, DataRowVersion version)
         {
             if (expr._op == Operators.And)
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 2d3fa4c921c3d1..21a6d951393c19 100644
--- a/src/libraries/System.Data.Common/src/System/Data/Selection.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/Selection.cs
@@ -896,6 +896,7 @@ public void RecordChanged(int record)
                 }
             }
         }
+
         // new RecordChanged which takes oldIndex and newIndex and fires _onListChanged
         public void RecordChanged(int oldIndex, int newIndex)
         {
diff --git a/src/libraries/System.Data.Common/src/System/Data/TypedTableBase.cs b/src/libraries/System.Data.Common/src/System/Data/TypedTableBase.cs
index f7d8081614dd96..5c66f688595459 100644
--- a/src/libraries/System.Data.Common/src/System/Data/TypedTableBase.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/TypedTableBase.cs
@@ -3,6 +3,7 @@
 
 using System.Collections;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 
 namespace System.Data
@@ -27,6 +28,7 @@ protected TypedTableBase() : base() { }
         /// </summary>
         /// <param name="info">SerializationInfo containing data to construct the object.</param>
         /// <param name="context">The streaming context for the object being deserialized.</param>
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         protected TypedTableBase(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context)
             : base(info, context) { }
 
diff --git a/src/libraries/System.Data.Common/src/System/Data/XDRSchema.cs b/src/libraries/System.Data.Common/src/System/Data/XDRSchema.cs
index 7885dc7f66e75d..571d343deaf02b 100644
--- a/src/libraries/System.Data.Common/src/System/Data/XDRSchema.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/XDRSchema.cs
@@ -9,6 +9,7 @@
 using System.Globalization;
 using System.Diagnostics;
 using System.Data.Common;
+using System.Diagnostics.CodeAnalysis;
 
 namespace System.Data
 {
@@ -27,6 +28,7 @@ internal XDRSchema(DataSet ds, bool fInline)
             _ds = ds;
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal void LoadSchema(XmlElement schemaRoot, DataSet ds)
         {
             if (schemaRoot == null)
@@ -177,6 +179,7 @@ internal bool IsXDRField(XmlElement node, XmlElement typeNode)
             return true;
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal DataTable HandleTable(XmlElement node)
         {
             XmlElement typeNode;
@@ -217,8 +220,9 @@ internal DataTable HandleTable(XmlElement node)
         private sealed class NameType : IComparable
         {
             public string name;
+            [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicFields)]
             public Type type;
-            public NameType(string n, Type t)
+            public NameType(string n, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicFields)] Type t)
             {
                 name = n;
                 type = t;
@@ -292,6 +296,7 @@ private static NameType FindNameType(string name)
 
         private static readonly NameType s_enumerationNameType = FindNameType("enumeration");
 
+        [return: DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties)]
         private Type ParseDataType(string dt, string dtValues)
         {
             string strType = dt;
@@ -336,6 +341,7 @@ internal string GetInstanceName(XmlElement node)
             return instanceName;
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal void HandleColumn(XmlElement node, DataTable table)
         {
             Debug.Assert(FEqualIdentity(node, Keywords.XDR_ELEMENT, Keywords.XDRNS) ||
@@ -535,7 +541,7 @@ internal void GetMinMax(XmlElement elNode, bool isAttribute, ref int minOccurs,
             }
         }
 
-
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal void HandleTypeNode(XmlElement typeNode, DataTable table, ArrayList tableChildren)
         {
             DataTable tableChild;
@@ -564,6 +570,7 @@ internal void HandleTypeNode(XmlElement typeNode, DataTable table, ArrayList tab
             }
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal DataTable InstantiateTable(DataSet dataSet, XmlElement node, XmlElement typeNode)
         {
             string typeName = string.Empty;
@@ -656,6 +663,7 @@ internal DataTable InstantiateTable(DataSet dataSet, XmlElement node, XmlElement
             return table;
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal DataTable InstantiateSimpleTable(DataSet dataSet, XmlElement node)
         {
             string typeName;
diff --git a/src/libraries/System.Data.Common/src/System/Data/XMLDiffLoader.cs b/src/libraries/System.Data.Common/src/System/Data/XMLDiffLoader.cs
index 39e1eed9057d7e..12502ad9da104c 100644
--- a/src/libraries/System.Data.Common/src/System/Data/XMLDiffLoader.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/XMLDiffLoader.cs
@@ -8,6 +8,7 @@
 using System.Collections;
 using System.Xml;
 using System.Xml.Serialization;
+using System.Diagnostics.CodeAnalysis;
 
 namespace System.Data
 {
@@ -17,6 +18,7 @@ internal sealed class XMLDiffLoader
         private DataSet _dataSet;
         private DataTable _dataTable;
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal void LoadDiffGram(DataSet ds, XmlReader dataTextReader)
         {
             XmlReader reader = DataTextReader.CreateReader(dataTextReader);
@@ -48,6 +50,7 @@ private void CreateTablesHierarchy(DataTable dt)
             }
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal void LoadDiffGram(DataTable dt, XmlReader dataTextReader)
         {
             XmlReader reader = DataTextReader.CreateReader(dataTextReader);
@@ -70,6 +73,7 @@ internal void LoadDiffGram(DataTable dt, XmlReader dataTextReader)
             }
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal void ProcessDiffs(DataSet ds, XmlReader ssync)
         {
             DataTable tableBefore;
@@ -121,6 +125,8 @@ internal void ProcessDiffs(DataSet ds, XmlReader ssync)
 
             return;
         }
+
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal void ProcessDiffs(ArrayList tableList, XmlReader ssync)
         {
             DataTable tableBefore;
@@ -174,7 +180,7 @@ internal void ProcessDiffs(ArrayList tableList, XmlReader ssync)
             return;
         }
 
-
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal void ProcessErrors(DataSet ds, XmlReader ssync)
         {
             DataTable table;
@@ -214,6 +220,7 @@ internal void ProcessErrors(DataSet ds, XmlReader ssync)
             return;
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal void ProcessErrors(ArrayList dt, XmlReader ssync)
         {
             DataTable table;
@@ -284,6 +291,7 @@ private DataTable GetTable(string tableName, string ns)
             return null;
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private int ReadOldRowData(DataSet ds, ref DataTable table, ref int pos, XmlReader row)
         {
             // read table information
diff --git a/src/libraries/System.Data.Common/src/System/Data/XMLSchema.cs b/src/libraries/System.Data.Common/src/System/Data/XMLSchema.cs
index 1efbb5518dfe60..f7cfd54efe8c70 100644
--- a/src/libraries/System.Data.Common/src/System/Data/XMLSchema.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/XMLSchema.cs
@@ -26,6 +26,7 @@ internal static TypeConverter GetConverter(Type type)
             return TypeDescriptor.GetConverter(type);
         }
 
+        [RequiresUnreferencedCode("Calls into TypeDescriptor.GetProperties. Type cannot be statically discovered.")]
         internal static void SetProperties(object instance, XmlAttributeCollection attrs)
         {
             // This is called from both XSD and XDR schemas.
@@ -263,6 +264,7 @@ internal static string QualifiedName(string name)
                 return name;
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal static void SetProperties(object instance, XmlAttribute[] attrs)
         {
             // This is called from both XSD and XDR schemas.
@@ -323,6 +325,7 @@ internal static void SetProperties(object instance, XmlAttribute[] attrs)
             }
         }// SetProperties
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private static void SetExtProperties(object instance, XmlAttribute[] attrs)
         {
             PropertyCollection props = null;
@@ -396,6 +399,7 @@ internal static string GetMsdataAttribute(XmlSchemaAnnotated node, string ln)
             return null;
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private static void SetExtProperties(object instance, XmlAttributeCollection attrs)
         {
             PropertyCollection props = null;
@@ -415,6 +419,7 @@ private static void SetExtProperties(object instance, XmlAttributeCollection att
             }
         }// SetExtProperties
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal void HandleRefTableProperties(ArrayList RefTables, XmlSchemaElement element)
         {
             string typeName = GetInstanceName(element);
@@ -425,6 +430,7 @@ internal void HandleRefTableProperties(ArrayList RefTables, XmlSchemaElement ele
             SetExtProperties(table, element.UnhandledAttributes);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal void HandleRelation(XmlElement node, bool fNested)
         {
             string strName;
@@ -644,11 +650,14 @@ private XmlSchemaElement FindDatasetElement(XmlSchemaObjectCollection elements)
             return null;
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public void LoadSchema(XmlSchemaSet schemaSet, DataTable dt)
         {
             if (dt.DataSet != null)
                 LoadSchema(schemaSet, dt.DataSet);
         }
+
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public void LoadSchema(XmlSchemaSet schemaSet, DataSet ds)
         { //Element schemaRoot, DataSet ds) {
             _constraintNodes = new Hashtable();
@@ -857,6 +866,7 @@ public void LoadSchema(XmlSchemaSet schemaSet, DataSet ds)
             }
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void HandleRelations(XmlSchemaAnnotation ann, bool fNested)
         {
             foreach (object __items in ann.Items)
@@ -892,6 +902,7 @@ internal XmlSchemaObjectCollection GetParticleItems(XmlSchemaParticle pt)
             return null;
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal void HandleParticle(XmlSchemaParticle pt, DataTable table, ArrayList tableChildren, bool isBase)
         {
             XmlSchemaObjectCollection items = GetParticleItems(pt);
@@ -980,6 +991,7 @@ internal void HandleParticle(XmlSchemaParticle pt, DataTable table, ArrayList ta
             return;
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal void HandleAttributes(XmlSchemaObjectCollection attributes, DataTable table, bool isBase)
         {
             foreach (XmlSchemaObject so in attributes)
@@ -1000,6 +1012,7 @@ internal void HandleAttributes(XmlSchemaObjectCollection attributes, DataTable t
             }
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void HandleAttributeGroup(XmlSchemaAttributeGroup attributeGroup, DataTable table, bool isBase)
         {
             foreach (XmlSchemaObject obj in attributeGroup.Attributes)
@@ -1027,6 +1040,8 @@ private void HandleAttributeGroup(XmlSchemaAttributeGroup attributeGroup, DataTa
                 }
             }
         }
+
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal void HandleComplexType(XmlSchemaComplexType ct, DataTable table, ArrayList tableChildren, bool isNillable)
         {
             if (_complexTypes.Contains(ct))
@@ -1267,6 +1282,7 @@ internal static Rule TranslateRule(string strRule)
                 return ForeignKeyConstraint.Rule_Default;
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal void HandleKeyref(XmlSchemaKeyref keyref)
         {
             string refer = XmlConvert.DecodeName(keyref.Refer.Name); // check here!!!
@@ -1374,7 +1390,7 @@ internal void HandleKeyref(XmlSchemaKeyref keyref)
             }
         }
 
-
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal void HandleConstraint(XmlSchemaIdentityConstraint keyNode)
         {
             string name = null;
@@ -1428,6 +1444,7 @@ internal void HandleConstraint(XmlSchemaIdentityConstraint keyNode)
             }
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal DataTable InstantiateSimpleTable(XmlSchemaElement node)
         {
             DataTable table;
@@ -1542,6 +1559,7 @@ internal string GetInstanceName(XmlSchemaAnnotated node)
         }
 
         // Sequences of handling Elements, Attributes and Text-only column should be the same as in InferXmlSchema
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal DataTable InstantiateTable(XmlSchemaElement node, XmlSchemaComplexType typeNode, bool isRef)
         {
             DataTable table;
@@ -1760,8 +1778,9 @@ internal DataTable InstantiateTable(XmlSchemaElement node, XmlSchemaComplexType
         private sealed class NameType : IComparable
         {
             public readonly string name;
+            [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicFields)]
             public readonly Type type;
-            public NameType(string n, Type t)
+            public NameType(string n, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicFields)] Type t)
             {
                 name = n;
                 type = t;
@@ -1852,6 +1871,7 @@ private static NameType FindNameType(string name)
         }
 
         // input param dt is a "qName" for UDSimpleType else it assumes it's a XSD builtin simpleType
+        [return: DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties)]
         private Type ParseDataType(string dt)
         {
             if (!IsXsdType(dt))
@@ -1938,7 +1958,7 @@ internal XmlSchemaAnnotated FindTypeNode(XmlSchemaAnnotated node)
             return typeNode;
         }
 
-
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal void HandleSimpleTypeSimpleContentColumn(XmlSchemaSimpleType typeNode, string strType, DataTable table, bool isBase, XmlAttribute[] attrs, bool isNillable)
         {
             // disallow multiple simple content columns for the table
@@ -2075,6 +2095,7 @@ internal void HandleSimpleTypeSimpleContentColumn(XmlSchemaSimpleType typeNode,
                 }
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal void HandleSimpleContentColumn(string strType, DataTable table, bool isBase, XmlAttribute[] attrs, bool isNillable)
         {
             // for Named Simple type support : We should not recieved anything here other than string.
@@ -2175,6 +2196,7 @@ internal void HandleSimpleContentColumn(string strType, DataTable table, bool is
                 }
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal void HandleAttributeColumn(XmlSchemaAttribute attrib, DataTable table, bool isBase)
         {
             Type type = null;
@@ -2337,6 +2359,7 @@ internal void HandleAttributeColumn(XmlSchemaAttribute attrib, DataTable table,
                 }
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal void HandleElementColumn(XmlSchemaElement elem, DataTable table, bool isBase)
         {
             Type type = null;
@@ -2537,6 +2560,7 @@ internal void HandleElementColumn(XmlSchemaElement elem, DataTable table, bool i
                 }
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal void HandleDataSet(XmlSchemaElement node, bool isNewDataSet)
         {
             string dsName = node.Name;
@@ -2824,6 +2848,7 @@ internal bool IsTable(XmlSchemaElement node)
         //        internal bool IsTopLevelElement (XmlSchemaElement node) {
         //            return (elements.IndexOf(node) != -1);
         //        }
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal DataTable HandleTable(XmlSchemaElement node)
         {
             if (!IsTable(node))
diff --git a/src/libraries/System.Data.Common/src/System/Data/XmlDataLoader.cs b/src/libraries/System.Data.Common/src/System/Data/XmlDataLoader.cs
index 1453fe83ce86cd..b5f5eb009801e5 100644
--- a/src/libraries/System.Data.Common/src/System/Data/XmlDataLoader.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/XmlDataLoader.cs
@@ -8,6 +8,7 @@
 using System.Collections.Generic;
 using System.Data.Common;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
 using System.Text;
 using System.Xml;
@@ -94,6 +95,7 @@ internal bool FromInference
         }
 
         // after loading, all detached DataRows are attached to their tables
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void AttachRows(DataRow parentRow, XmlNode parentElement)
         {
             if (parentElement == null)
@@ -292,6 +294,7 @@ internal bool IsTextOnly(DataColumn c)
                 return true;
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal void LoadData(XmlDocument xdoc)
         {
             if (xdoc.DocumentElement == null)
@@ -369,6 +372,7 @@ internal void LoadData(XmlDocument xdoc)
             }
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void LoadRowData(DataRow row, XmlElement rowElement)
         {
             XmlNode n;
@@ -499,6 +503,7 @@ private void LoadRowData(DataRow row, XmlElement rowElement)
 
 
         // load all data from tree structre into datarows
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void LoadRows(DataRow parentRow, XmlNode parentElement)
         {
             if (parentElement == null)
@@ -545,6 +550,7 @@ private void LoadRows(DataRow parentRow, XmlNode parentElement)
             }
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void SetRowValueFromXmlText(DataRow row, DataColumn col, string xmlText)
         {
             row[col] = col.ConvertXmlToObject(xmlText);
@@ -584,6 +590,7 @@ private void InitNameTable()
             _ROWORDER = nameTable.Add(Keywords.ROWORDER);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal void LoadData(XmlReader reader)
         {
             _dataReader = DataTextReader.CreateReader(reader);
@@ -679,6 +686,7 @@ internal void LoadData(XmlReader reader)
         //
         // Yes, it is terrible and I don't like it also..
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void LoadTopMostTable(DataTable table)
         {
             //        /------------------------------- This one is in topMostNode (backed up to XML DOM)
@@ -859,6 +867,7 @@ private void LoadTopMostTable(DataTable table)
         // this method divided into 3 parts: attribute processing (including diffgram),
         // nested elements processing and loading data. Please keep it this way.
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void LoadTable(DataTable table, bool isNested)
         {
             //  <DataSet> /--------------------------- We are here on entrance
@@ -1127,6 +1136,7 @@ private void LoadTable(DataTable table, bool isNested)
         }
 
         // Returns column value
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void LoadColumn(DataColumn column, object[] foundColumns)
         {
             //  <DataSet>    /--------------------------------- We are here on entrance
@@ -1357,6 +1367,7 @@ private void LoadColumn(DataColumn column, object[] foundColumns)
         // Check for schema and skips or loads XSD schema if found. Returns true if schema found.
         // DataReader would be set on the first XML element after the schema of schema was found.
         // If no schema detected, reader's position will not change.
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private bool ProcessXsdSchema()
         {
             if (((object)_dataReader.LocalName == _XSD_SCHEMA && (object)_dataReader.NamespaceURI == _XSDNS))
diff --git a/src/libraries/System.Data.Common/src/System/Data/xmlsaver.cs b/src/libraries/System.Data.Common/src/System/Data/xmlsaver.cs
index 6e9fbb9ac1b17c..509a7f6082fe39 100644
--- a/src/libraries/System.Data.Common/src/System/Data/xmlsaver.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/xmlsaver.cs
@@ -106,6 +106,7 @@ internal static void AddExtendedProperties(PropertyCollection? props, XmlElement
             }
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal void AddXdoProperties(object? instance, XmlElement root, XmlDocument xd)
         {
             if (instance == null)
@@ -127,6 +128,7 @@ internal void AddXdoProperties(object? instance, XmlElement root, XmlDocument xd
             return;
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal void AddXdoProperty(PropertyDescriptor pd, object instance, XmlElement root, XmlDocument xd)
         {
             Type type = pd.PropertyType;
@@ -538,6 +540,7 @@ private DataTable[] CreateToplevelTables()
 
         // SxS: this method can generate XSD files if the input xmlWriter is XmlTextWriter or DataTextWriter and its underlying stream is FileStream
         // These XSDs are located in the same folder as the underlying stream's file path (see SetPath method).
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal void SchemaTree(XmlDocument xd, XmlWriter xmlWriter, DataSet? ds, DataTable? dt, bool writeHierarchy)
         {
             _constraintNames = new ArrayList();
@@ -934,6 +937,7 @@ internal void SchemaTree(XmlDocument xd, XmlWriter xmlWriter, DataSet? ds, DataT
             return; // rootSchema;
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal XmlElement SchemaTree(XmlDocument xd, DataTable dt)
         {
             _dsElement = xd.CreateElement(Keywords.XSD_PREFIX, Keywords.XSD_ELEMENT, Keywords.XSDNS);
@@ -1092,11 +1096,13 @@ internal void SetPath(XmlWriter xw)
                 _filePath = _filePath + "\\";
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal void Save(DataSet ds, XmlWriter xw)
         {
             Save(ds, null, xw);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal void Save(DataTable dt, XmlWriter xw)
         {
             XmlDocument doc = new XmlDocument();
@@ -1109,16 +1115,19 @@ internal void Save(DataTable dt, XmlWriter xw)
             doc.Save(xw);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal void Save(DataSet ds, DataTable? dt, XmlWriter xw)
         {
             Save(ds, dt, xw, false);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal void Save(DataSet? ds, DataTable? dt, XmlWriter xw, bool writeHierarchy)
         {
             Save(ds, dt, xw, writeHierarchy, null);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal void Save(DataSet? ds, DataTable? dt, XmlWriter xw, bool writeHierarchy, Converter<Type, string>? multipleTargetConverter)
         {
             _targetConverter = multipleTargetConverter;
@@ -1406,6 +1415,7 @@ private string FindTargetNamespace(DataTable table)
             return tgNamespace;
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal XmlElement HandleColumn(DataColumn col, XmlDocument dc, XmlElement schema, bool fWriteOrdinal)
         {
             Debug.Assert(_prefixes != null);
@@ -1581,6 +1591,7 @@ internal void AppendChildWithoutRef(XmlElement node, string Namespace, XmlElemen
             return null;
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal XmlElement HandleTable(DataTable table, XmlDocument dc, XmlElement schema)
         {
             return HandleTable(table, dc, schema, true);
@@ -1710,6 +1721,7 @@ private bool IsAutoGenerated(object o)
             return false;
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal XmlElement HandleTable(DataTable table, XmlDocument dc, XmlElement schema, bool genNested)
         {
             Debug.Assert(_prefixes != null);
@@ -2331,11 +2343,13 @@ private bool EmptyData()
             return true;
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal void Save(XmlWriter xmlw)
         {
             Save(xmlw, null);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal void Save(XmlWriter xmlw, DataTable? table)
         {
             _xmlw = DataTextWriter.CreateWriter(xmlw);
@@ -2395,6 +2409,7 @@ internal void Save(XmlWriter xmlw, DataTable? table)
             _xmlw.Flush();
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void GenerateTable(DataTable table)
         {
             int rowCount = table.Rows.Count;
@@ -2470,6 +2485,7 @@ private void GenerateTableErrors(DataTable table)
             }
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void GenerateRow(DataRow row)
         {
             DataRowState state = row.RowState;
@@ -2526,6 +2542,7 @@ private void GenerateRow(DataRow row)
             _xmlw.WriteEndElement();  //old row
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void GenerateColumn(DataRow row, DataColumn col, DataRowVersion version)
         {
             string? value = null;
@@ -2776,6 +2793,7 @@ internal static bool RowHasErrors(DataRow row)
         // the following line writes the data part
         // for the new diffgram format
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal void SaveDiffgramData(XmlWriter xw, Hashtable rowsOrder)
         {
             Debug.Assert(_ds != null || _dt != null);
@@ -2818,7 +2836,7 @@ internal void SaveDiffgramData(XmlWriter xw, Hashtable rowsOrder)
             _xmlw.Flush();
         }
 
-
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal void Save(XmlWriter xw, bool writeSchema)
         {
             Debug.Assert(_ds != null || _dt != null);
@@ -2910,7 +2928,7 @@ private ArrayList GetNestedChildRelations(DataRow row)
             return list;
         }
 
-
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal void XmlDataRowWriter(DataRow row, string encodedTableName)
         {
             Debug.Assert(_xmlw != null);
diff --git a/src/libraries/System.Data.Common/src/System/Xml/DataDocumentXPathNavigator.cs b/src/libraries/System.Data.Common/src/System/Xml/DataDocumentXPathNavigator.cs
index 1fc9394dd1253c..ed6c31b6e7c449 100644
--- a/src/libraries/System.Data.Common/src/System/Xml/DataDocumentXPathNavigator.cs
+++ b/src/libraries/System.Data.Common/src/System/Xml/DataDocumentXPathNavigator.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.Data;
+using System.Diagnostics.CodeAnalysis;
 using System.Xml.XPath;
 
 #pragma warning disable 0618 // ignore obsolete warning about XmlDataDocument
@@ -13,6 +15,7 @@ internal sealed class DataDocumentXPathNavigator : XPathNavigator, IHasXmlNode
         private XmlDataDocument _doc;     //pointer to remember the root -- can only be XmlDataDocument for DataDocumentXPathNavigator
         private readonly XPathNodePointer _temp;
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal DataDocumentXPathNavigator(XmlDataDocument doc, XmlNode node)
         {
             _curNode = new XPathNodePointer(this, doc, node);
@@ -20,12 +23,16 @@ internal DataDocumentXPathNavigator(XmlDataDocument doc, XmlNode node)
             _doc = doc;
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private DataDocumentXPathNavigator(DataDocumentXPathNavigator other)
         {
             _curNode = other._curNode.Clone(this);
             _temp = other._temp.Clone(this);
             _doc = other._doc;
         }
+
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
+            Justification = "This whole class is unsafe. Constructors are marked as such.")]
         public override XPathNavigator Clone() => new DataDocumentXPathNavigator(this);
 
         internal XPathNodePointer CurNode => _curNode;
@@ -44,6 +51,8 @@ private DataDocumentXPathNavigator(DataDocumentXPathNavigator other)
 
         public override string Value
         {
+            [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
+            Justification = "This whole class is unsafe. Constructors are marked as such.")]
             get
             {
                 XPathNodeType xnt = _curNode.NodeType;
@@ -62,6 +71,8 @@ public override string Value
         // Attributes
         public override bool HasAttributes => _curNode.AttributeCount > 0;
 
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
+            Justification = "This whole class is unsafe. Constructors are marked as such.")]
         public override string GetAttribute(string localName, string namespaceURI)
         {
             if (_curNode.NodeType != XPathNodeType.Element)
@@ -73,16 +84,22 @@ public override string GetAttribute(string localName, string namespaceURI)
             return _temp.MoveToAttribute(localName, namespaceURI) ? _temp.Value! : string.Empty;
         }
 
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
+            Justification = "This whole class is unsafe. Constructors are marked as such.")]
         public override string GetNamespace(string name) => _curNode.GetNamespace(name);
 
         public override bool MoveToNamespace(string name) =>
             _curNode.NodeType != XPathNodeType.Element ?
                 false : _curNode.MoveToNamespace(name);
 
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
+            Justification = "This whole class is unsafe. Constructors are marked as such.")]
         public override bool MoveToFirstNamespace(XPathNamespaceScope namespaceScope) =>
             _curNode.NodeType != XPathNodeType.Element ?
                 false : _curNode.MoveToFirstNamespace(namespaceScope);
 
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
+            Justification = "This whole class is unsafe. Constructors are marked as such.")]
         public override bool MoveToNextNamespace(XPathNamespaceScope namespaceScope) =>
             _curNode.NodeType != XPathNodeType.Namespace ?
                 false : _curNode.MoveToNextNamespace(namespaceScope);
@@ -155,8 +172,12 @@ public override bool IsSamePosition(XPathNavigator other)
 
         //the function is only called for XPathNodeList enumerate nodes and
         // shouldn't be promoted to frequently use because it will cause foliation
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
+            Justification = "This whole class is unsafe. Constructors are marked as such.")]
         XmlNode IHasXmlNode.GetNode() => _curNode.Node!;
 
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
+            Justification = "This whole class is unsafe. Constructors are marked as such.")]
         public override XmlNodeOrder ComparePosition(XPathNavigator? other)
         {
             if (other == null)
diff --git a/src/libraries/System.Data.Common/src/System/Xml/DataPointer.cs b/src/libraries/System.Data.Common/src/System/Xml/DataPointer.cs
index d04cd7d46fed03..3df260fa1abbcc 100644
--- a/src/libraries/System.Data.Common/src/System/Xml/DataPointer.cs
+++ b/src/libraries/System.Data.Common/src/System/Xml/DataPointer.cs
@@ -3,6 +3,7 @@
 
 using System.Data;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 
 #pragma warning disable 0618 // ignore obsolete warning about XmlDataDocument
 
@@ -550,6 +551,7 @@ internal string Prefix
 
         internal string? Value
         {
+            [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
             get
             {
                 RealFoliate();
diff --git a/src/libraries/System.Data.Common/src/System/Xml/XPathNodePointer.cs b/src/libraries/System.Data.Common/src/System/Xml/XPathNodePointer.cs
index f7095827dfcd20..4e4c878b51c54f 100644
--- a/src/libraries/System.Data.Common/src/System/Xml/XPathNodePointer.cs
+++ b/src/libraries/System.Data.Common/src/System/Xml/XPathNodePointer.cs
@@ -3,6 +3,7 @@
 
 using System.Data;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.Xml.XPath;
 
 #pragma warning disable 618 // ignore obsolete warning about XmlDataDocument
@@ -311,6 +312,7 @@ internal string Prefix
 
         internal string? Value
         {
+            [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
             get
             {
                 RealFoliate();
@@ -351,6 +353,7 @@ internal string? Value
 
         internal string InnerText
         {
+            [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
             get
             {
                 RealFoliate();
@@ -1062,6 +1065,7 @@ internal bool IsSamePosition(XPathNodePointer pointer)
                     && pointer._parentOfNS == _parentOfNS);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private XmlNodeOrder CompareNamespacePosition(XPathNodePointer other)
         {
             XPathNodePointer xp1 = Clone((DataDocumentXPathNavigator)(_owner.Target!));
@@ -1087,6 +1091,7 @@ private static XmlNode GetRoot(XmlNode node, ref int depth)
             return curNode;
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal XmlNodeOrder ComparePosition(XPathNodePointer other)
         {
             RealFoliate();
@@ -1230,6 +1235,7 @@ internal XmlNodeOrder ComparePosition(XPathNodePointer other)
 
         internal XmlNode? Node
         {
+            [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
             get
             {
                 RealFoliate();
@@ -1322,6 +1328,7 @@ private void RealFoliate()
 
         //The function only helps to find out if there is a namespace declaration of given name is defined on the given node
         //It will not check the ancestor of the given node.
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private string? GetNamespace(XmlBoundElement be, string name)
         {
             if (be == null)
@@ -1355,6 +1362,7 @@ private void RealFoliate()
             }
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal string GetNamespace(string name)
         {
             //we are checking the namespace nodes backwards comparing its normal order in DOM tree
@@ -1454,6 +1462,7 @@ internal bool MoveToNamespace(string name)
 
         //the function will find the next namespace node on the given bound element starting with the given column or attribute
         // whether to use column or attribute depends on if the bound element is foliated or not.
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private bool MoveToNextNamespace(XmlBoundElement? be, DataColumn? col, XmlAttribute? curAttr)
         {
             if (be != null)
@@ -1506,6 +1515,7 @@ private bool MoveToNextNamespace(XmlBoundElement? be, DataColumn? col, XmlAttrib
         }
 
         //Caller( DataDocumentXPathNavigator will make sure that the node is at the right position for this call )
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal bool MoveToFirstNamespace(XPathNamespaceScope namespaceScope)
         {
             RealFoliate();
@@ -1541,6 +1551,7 @@ internal bool MoveToFirstNamespace(XPathNamespaceScope namespaceScope)
         }
 
         //endElem is on the path from startElem to root is enforced by the caller
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private bool DuplicateNS(XmlBoundElement endElem, string lname)
         {
             if (_parentOfNS == null || endElem == null)
@@ -1562,6 +1573,7 @@ private bool DuplicateNS(XmlBoundElement endElem, string lname)
         }
 
         //Caller( DataDocumentXPathNavigator will make sure that the node is at the right position for this call )
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal bool MoveToNextNamespace(XPathNamespaceScope namespaceScope)
         {
             RealFoliate();
diff --git a/src/libraries/System.Data.Common/src/System/Xml/XmlBoundElement.cs b/src/libraries/System.Data.Common/src/System/Xml/XmlBoundElement.cs
index ae57ad3186ea90..97fcd22ba34122 100644
--- a/src/libraries/System.Data.Common/src/System/Xml/XmlBoundElement.cs
+++ b/src/libraries/System.Data.Common/src/System/Xml/XmlBoundElement.cs
@@ -3,6 +3,7 @@
 
 using System.Data;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.Threading;
 
 #pragma warning disable 618 // ignore obsolete warning about XmlDataDocument
@@ -24,6 +25,7 @@ internal sealed class XmlBoundElement : XmlElement
         private DataRow? _row;
         private ElementState _state;
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal XmlBoundElement(string prefix, string localName, string namespaceURI, XmlDocument doc) : base(prefix, localName, namespaceURI, doc)
         {
             _state = ElementState.None;
@@ -31,6 +33,8 @@ internal XmlBoundElement(string prefix, string localName, string namespaceURI, X
 
         public override XmlAttributeCollection Attributes
         {
+            [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
+                Justification = "This whole class is unsafe. Constructors are marked as such.")]
             get
             {
                 AutoFoliate();
@@ -42,6 +46,8 @@ public override XmlAttributeCollection Attributes
 
         public override XmlNode? FirstChild
         {
+            [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
+                Justification = "This whole class is unsafe. Constructors are marked as such.")]
             get
             {
                 AutoFoliate();
@@ -53,6 +59,8 @@ public override XmlNode? FirstChild
 
         public override XmlNode? LastChild
         {
+            [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
+                Justification = "This whole class is unsafe. Constructors are marked as such.")]
             get
             {
                 AutoFoliate();
@@ -62,6 +70,8 @@ public override XmlNode? LastChild
 
         public override XmlNode? PreviousSibling
         {
+            [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
+                Justification = "This whole class is unsafe. Constructors are marked as such.")]
             get
             {
                 XmlNode? prev = base.PreviousSibling;
@@ -82,6 +92,8 @@ public override XmlNode? PreviousSibling
 
         public override XmlNode? NextSibling
         {
+            [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
+                Justification = "This whole class is unsafe. Constructors are marked as such.")]
             get
             {
                 XmlNode? next = base.NextSibling;
@@ -102,6 +114,8 @@ public override XmlNode? NextSibling
 
         public override bool HasChildNodes
         {
+            [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
+                Justification = "This whole class is unsafe. Constructors are marked as such.")]
             get
             {
                 AutoFoliate();
@@ -109,24 +123,32 @@ public override bool HasChildNodes
             }
         }
 
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
+            Justification = "This whole class is unsafe. Constructors are marked as such.")]
         public override XmlNode? InsertBefore(XmlNode newChild, XmlNode? refChild)
         {
             AutoFoliate();
             return base.InsertBefore(newChild, refChild);
         }
 
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
+            Justification = "This whole class is unsafe. Constructors are marked as such.")]
         public override XmlNode? InsertAfter(XmlNode newChild, XmlNode? refChild)
         {
             AutoFoliate();
             return base.InsertAfter(newChild, refChild);
         }
 
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
+            Justification = "This whole class is unsafe. Constructors are marked as such.")]
         public override XmlNode ReplaceChild(XmlNode newChild, XmlNode oldChild)
         {
             AutoFoliate();
             return base.ReplaceChild(newChild, oldChild);
         }
 
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
+            Justification = "This whole class is unsafe. Constructors are marked as such.")]
         public override XmlNode? AppendChild(XmlNode newChild)
         {
             AutoFoliate();
@@ -149,6 +171,8 @@ internal void RemoveAllChildren()
         public override string InnerXml
         {
             get { return base.InnerXml; }
+            [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
+                Justification = "This whole class is unsafe. Constructors are marked as such.")]
             set
             {
                 RemoveAllChildren();
@@ -196,6 +220,8 @@ internal ElementState ElementState
             set { _state = value; }
         }
 
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
+            Justification = "This whole class is unsafe. Constructors are marked as such.")]
         internal void Foliate(ElementState newState)
         {
             XmlDataDocument doc = (XmlDataDocument)OwnerDocument;
@@ -206,6 +232,7 @@ internal void Foliate(ElementState newState)
         }
 
         // Foliate the node as a side effect of user calling functions on this node (like NextSibling) OR as a side effect of DataDocNav using nodes to do editing
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void AutoFoliate()
         {
             XmlDataDocument doc = (XmlDataDocument)OwnerDocument;
@@ -237,6 +264,8 @@ public override XmlNode CloneNode(bool deep)
             return element;
         }
 
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
+            Justification = "This whole class is unsafe. Constructors are marked as such.")]
         public override void WriteContentTo(XmlWriter w)
         {
             DataPointer dp = new DataPointer((XmlDataDocument)OwnerDocument, this);
@@ -251,6 +280,8 @@ public override void WriteContentTo(XmlWriter w)
             }
         }
 
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
+            Justification = "This whole class is unsafe. Constructors are marked as such.")]
         public override void WriteTo(XmlWriter w)
         {
             DataPointer dp = new DataPointer((XmlDataDocument)OwnerDocument, this);
@@ -265,6 +296,7 @@ public override void WriteTo(XmlWriter w)
             }
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void WriteRootBoundElementTo(DataPointer dp, XmlWriter w)
         {
             Debug.Assert(dp.NodeType == XmlNodeType.Element);
@@ -305,6 +337,7 @@ private void WriteRootBoundElementTo(DataPointer dp, XmlWriter w)
             }
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private static void WriteBoundElementTo(DataPointer dp, XmlWriter w)
         {
             Debug.Assert(dp.NodeType == XmlNodeType.Element);
@@ -333,6 +366,7 @@ private static void WriteBoundElementTo(DataPointer dp, XmlWriter w)
             }
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private static void WriteBoundElementContentTo(DataPointer dp, XmlWriter w)
         {
             if (!dp.IsEmptyElement && dp.MoveToFirstChild())
@@ -347,6 +381,7 @@ private static void WriteBoundElementContentTo(DataPointer dp, XmlWriter w)
             }
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private static void WriteTo(DataPointer dp, XmlWriter w)
         {
             switch (dp.NodeType)
diff --git a/src/libraries/System.Data.Common/src/System/Xml/XmlDataDocument.cs b/src/libraries/System.Data.Common/src/System/Xml/XmlDataDocument.cs
index 09d6ee751b9b3c..dfec09877cbf5c 100644
--- a/src/libraries/System.Data.Common/src/System/Xml/XmlDataDocument.cs
+++ b/src/libraries/System.Data.Common/src/System/Xml/XmlDataDocument.cs
@@ -19,6 +19,7 @@ namespace System.Xml
     [Obsolete("XmlDataDocument class will be removed in a future release.")]
     public class XmlDataDocument : XmlDocument
     {
+        private const string RequiresUnreferencedCodeMessage = "XmlDataDocument is used for serialization and deserialization. Members from serialized types may be trimmed if not referenced directly.";
         private DataSet _dataSet;
 
         private DataSetMapper _mapper;
@@ -94,6 +95,7 @@ internal void AssertPointerPresent(IXmlDataVirtualNode pointer)
         // We can set-up listeners and track each change in schema, but it is more perf-friendly to do it laizily, all at once, when the first DataRow is created
         // (we rely on the fact that DataRowCreated is a DataSet wide event, rather than a DataTable event)
         [MemberNotNull(nameof(_dataSet))]
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void AttachDataSet(DataSet ds)
         {
             // You should not have already an associated dataset
@@ -109,6 +111,7 @@ private void AttachDataSet(DataSet ds)
 
         // after loading, all detached DataRows are synchronized with the xml tree and inserted to their tables
         // or after setting the innerxml, synchronize the rows and if created new and detached, will be inserted.
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal void SyncRows(DataRow? parentRow, XmlNode node, bool fAddRowsToTable)
         {
             XmlBoundElement? be = node as XmlBoundElement;
@@ -142,6 +145,7 @@ internal void SyncRows(DataRow? parentRow, XmlNode node, bool fAddRowsToTable)
 
         // All detached DataRows are synchronized with the xml tree and inserted to their tables.
         // Synchronize the rows and if created new and detached, will be inserted.
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal void SyncTree(XmlNode node)
         {
             XmlBoundElement? be = null;
@@ -186,6 +190,7 @@ internal ElementState AutoFoliationState
             set { _autoFoliationState = value; }
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void BindForLoad()
         {
             Debug.Assert(_ignoreXmlEvents == true);
@@ -200,6 +205,7 @@ private void BindForLoad()
             _ignoreDataSetEvents = false;
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void Bind(bool fLoadFromDataSet)
         {
             // If we have a DocumentElement then it is illegal to call this func to load from data-set
@@ -234,6 +240,7 @@ internal void Bind(DataRow r, XmlBoundElement e)
         }
 
         // Binds special listeners to catch the 1st data-row created. When the 1st DataRow is created, XmlDataDocument will automatically bind all regular listeners.
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void BindSpecialListeners()
         {
             Debug.Assert(_fDataRowCreatedSpecial == false);
@@ -241,6 +248,8 @@ private void BindSpecialListeners()
             _dataSet.DataRowCreated += new DataRowCreatedEventHandler(OnDataRowCreatedSpecial);
             _fDataRowCreatedSpecial = true;
         }
+
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void UnBindSpecialListeners()
         {
             Debug.Assert(_fDataRowCreatedSpecial == true);
@@ -248,12 +257,14 @@ private void UnBindSpecialListeners()
             _fDataRowCreatedSpecial = false;
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void BindListeners()
         {
             BindToDocument();
             BindToDataSet();
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void BindToDataSet()
         {
             // We could be already bound to DataSet in this scenario:
@@ -292,6 +303,7 @@ private void BindToDataSet()
             _fBoundToDataSet = true;
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void BindToDocument()
         {
             if (!_fBoundToDocument)
@@ -306,6 +318,7 @@ private void BindToDocument()
             }
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void BindToTable(DataTable t)
         {
             t.ColumnChanged += new DataColumnChangeEventHandler(OnColumnChanged);
@@ -327,6 +340,8 @@ private void BindToTable(DataTable t)
         /// Creates an element with the specified Prefix, LocalName, and
         /// NamespaceURI.
         /// </summary>
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
+            Justification = "This whole class is unsafe. Constructors are marked as such.")]
         public override XmlElement CreateElement(string? prefix, string localName, string? namespaceURI)
         {
             // There are three states for the document:
@@ -452,6 +467,7 @@ private void DefoliateRegion(XmlBoundElement rowElem)
             }
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private XmlElement EnsureDocumentElement()
         {
             XmlElement? docelem = DocumentElement;
@@ -469,6 +485,8 @@ private XmlElement EnsureDocumentElement()
 
             return docelem;
         }
+
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private XmlElement EnsureNonRowDocumentElement()
         {
             XmlElement? docElem = DocumentElement;
@@ -481,6 +499,8 @@ private XmlElement EnsureNonRowDocumentElement()
 
             return DemoteDocumentElement();
         }
+
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private XmlElement DemoteDocumentElement()
         {
             // Changes of Xml here should not affect ROM
@@ -501,6 +521,7 @@ private XmlElement DemoteDocumentElement()
         // CreateElement will attach DataRows to newly created XmlBoundElement.
         // It should be called when we have special listeners hooked and we need to change from the special-listeners mode to the
         // populated/permanenet mode where all listeners are correctly hooked up and the mapper is correctly set-up.
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void EnsurePopulatedMode()
         {
             // Unbind special listeners, bind permanent ones, setup the mapping, etc
@@ -567,6 +588,7 @@ private void FixNestedChildren(DataRow row, XmlElement rowElement)
         }
 
         // This function accepts node params that are not row-elements. In this case, calling this function is a no-op
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal void Foliate(XmlBoundElement node, ElementState newState)
         {
             Debug.Assert(newState == ElementState.WeakFoliation || newState == ElementState.StrongFoliation);
@@ -608,6 +630,7 @@ internal void Foliate(XmlBoundElement node, ElementState newState)
             }
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void Foliate(XmlElement element)
         {
             if (element is XmlBoundElement)
@@ -615,6 +638,7 @@ private void Foliate(XmlElement element)
         }
 
         // Foliate rowElement region if there are DataPointers that points into it
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void FoliateIfDataPointers(DataRow row, XmlElement rowElement)
         {
             if (!IsFoliated(rowElement) && HasPointers(rowElement))
@@ -632,6 +656,7 @@ private void FoliateIfDataPointers(DataRow row, XmlElement rowElement)
             }
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void EnsureFoliation(XmlBoundElement rowElem, ElementState foliation)
         {
             if (rowElem.IsFoliated) //perf reason, avoid unecessary lock.
@@ -639,6 +664,7 @@ private void EnsureFoliation(XmlBoundElement rowElem, ElementState foliation)
             ForceFoliation(rowElem, foliation);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void ForceFoliation(XmlBoundElement node, ElementState newState)
         {
             lock (_foliationLock)
@@ -937,6 +963,7 @@ internal bool IsFoliationEnabled
         // This creates a tree and synchronize ROM w/ the created tree.
         // It requires the populated mode to be on - in case we are not in populated mode, it will make the XmlDataDocument be in populated mode.
         // It takes advantage of the fAssociateDataRow flag for populated mode, which allows creation of XmlBoundElement w/o associating DataRow objects.
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal XmlNode CloneTree(DataPointer other)
         {
             EnsurePopulatedMode();
@@ -975,6 +1002,7 @@ internal XmlNode CloneTree(DataPointer other)
             return newNode;
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private XmlNode CloneTreeInternal(DataPointer other)
         {
             Debug.Assert(_ignoreDataSetEvents == true);
@@ -1014,6 +1042,8 @@ private XmlNode CloneTreeInternal(DataPointer other)
             return newNode;
         }
 
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
+            Justification = "This whole class is unsafe. Constructors are marked as such.")]
         public override XmlNode CloneNode(bool deep)
         {
             XmlDataDocument clone = (XmlDataDocument)(base.CloneNode(false));
@@ -1046,6 +1076,7 @@ public override XmlNode CloneNode(bool deep)
             return clone;
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private XmlNode CloneNode(DataPointer dp) =>
             dp.NodeType switch
             {
@@ -1141,6 +1172,8 @@ public override void Load(TextReader txtReader)
         /// <summary>
         /// Loads the XML document from the specified XmlReader.
         /// </summary>
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
+            Justification = "This whole class is unsafe. Constructors are marked as such.")]
         public override void Load(XmlReader reader)
         {
             if (FirstChild != null)
@@ -1177,6 +1210,7 @@ public override void Load(XmlReader reader)
             }
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void LoadDataSetFromTree()
         {
             _ignoreDataSetEvents = true;
@@ -1202,6 +1236,7 @@ private void LoadDataSetFromTree()
             }
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void LoadTreeFromDataSet(DataSet ds)
         {
             _ignoreDataSetEvents = true;
@@ -1258,6 +1293,7 @@ private void LoadTreeFromDataSet(DataSet ds)
         }
 
         // load all data from tree structre into datarows
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void LoadRows(XmlBoundElement? rowElem, XmlNode node)
         {
             Debug.Assert(node != null);
@@ -1295,6 +1331,7 @@ internal DataSetMapper Mapper
             }
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal void OnDataRowCreated(object oDataSet, DataRow row)
         {
             Debug.Assert(row.RowState == DataRowState.Detached);
@@ -1306,6 +1343,7 @@ internal void OnClearCalled(object oDataSet, DataTable? table)
             throw new NotSupportedException(SR.DataDom_NotSupport_Clear);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal void OnDataRowCreatedSpecial(object oDataSet, DataRow row)
         {
             Debug.Assert(row.RowState == DataRowState.Detached);
@@ -1315,7 +1353,9 @@ internal void OnDataRowCreatedSpecial(object oDataSet, DataRow row)
             // Pass the event to the regular listener
             OnNewRow(row);
         }
+
         // Called when a new DataRow is created
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal void OnNewRow(DataRow row)
         {
             Debug.Assert(row.Element == null);
@@ -1325,6 +1365,7 @@ internal void OnNewRow(DataRow row)
             AttachBoundElementToDataRow(row);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private XmlBoundElement AttachBoundElementToDataRow(DataRow row)
         {
             Debug.Assert(row.Element == null);
@@ -1347,6 +1388,7 @@ private bool NeedXSI_NilAttr(DataRow row)
             return (Convert.IsDBNull(value));
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void OnAddRow(DataRow row)
         {
             // Xml operations in this func should not trigger ROM operations
@@ -1374,6 +1416,7 @@ private void OnAddRow(DataRow row)
             OnNestedParentChange(row, rowElement, null);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void OnColumnValueChanged(DataRow row, DataColumn col, XmlBoundElement rowElement)
         {
             if (IsNotMapped(col))
@@ -1552,6 +1595,7 @@ private void OnColumnValueChanged(DataRow row, DataColumn col, XmlBoundElement r
             }
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void OnColumnChanged(object sender, DataColumnChangeEventArgs args)
         {
             // You should not be able to make DataRow field changes if the DataRow is deleted
@@ -1588,6 +1632,7 @@ private void OnColumnChanged(object sender, DataColumnChangeEventArgs args)
             }
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void OnColumnValuesChanged(DataRow row, XmlBoundElement rowElement)
         {
             Debug.Assert(row != null);
@@ -1616,6 +1661,7 @@ private void OnColumnValuesChanged(DataRow row, XmlBoundElement rowElement)
             _columnChangeList.Clear();
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void OnDeleteRow(DataRow row, XmlBoundElement rowElement)
         {
             // IgnoreXmlEvents s/b on since we are manipulating the XML tree and we not want this to reflect in ROM view.
@@ -1629,6 +1675,7 @@ private void OnDeleteRow(DataRow row, XmlBoundElement rowElement)
             rowElement.ParentNode!.RemoveChild(rowElement);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void OnDeletingRow(DataRow row, XmlBoundElement rowElement)
         {
             // Note that this function is beeing called even if ignoreDataSetEvents == true.
@@ -1690,6 +1737,7 @@ private void OnFoliated(XmlNode node)
         }
 
         // Change the childElement position in the tree to conform to the parent nested relationship in ROM
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void OnNestedParentChange(DataRow child, XmlBoundElement childElement, DataColumn? childCol)
         {
             Debug.Assert(child.Element == childElement && childElement.Row == child);
@@ -1743,6 +1791,7 @@ private void OnNestedParentChange(DataRow child, XmlBoundElement childElement, D
 #endif
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void OnNodeChanged(object sender, XmlNodeChangedEventArgs args)
         {
             if (_ignoreXmlEvents)
@@ -1786,7 +1835,7 @@ private void OnNodeChanging(object sender, XmlNodeChangedEventArgs args)
                 throw new InvalidOperationException(SR.DataDom_EnforceConstraintsShouldBeOff);
         }
 
-
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void OnNodeInserted(object sender, XmlNodeChangedEventArgs args)
         {
             if (_ignoreXmlEvents)
@@ -1841,7 +1890,7 @@ private void OnNodeInserting(object sender, XmlNodeChangedEventArgs args)
                 throw new InvalidOperationException(SR.DataDom_EnforceConstraintsShouldBeOff);
         }
 
-
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void OnNodeRemoved(object sender, XmlNodeChangedEventArgs args)
         {
             if (_ignoreXmlEvents)
@@ -1894,6 +1943,7 @@ private void OnNodeRemoving(object sender, XmlNodeChangedEventArgs args)
         }
 
         // Node was removed from connected tree to disconnected tree
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void OnNodeRemovedFromTree(XmlNode node, XmlNode? oldParent)
         {
             XmlBoundElement? oldRowElem;
@@ -1916,7 +1966,9 @@ private void OnNodeRemovedFromTree(XmlNode node, XmlNode? oldParent)
             // Assert that all sub-regions are disconnected
             AssertNonLiveRows(node);
         }
+
         // Node was removed from the disconnected tree to disconnected tree
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void OnNodeRemovedFromFragment(XmlNode node, XmlNode? oldParent)
         {
             XmlBoundElement? oldRowElem;
@@ -1953,7 +2005,7 @@ private void OnNodeRemovedFromFragment(XmlNode node, XmlNode? oldParent)
             AssertNonLiveRows(node);
         }
 
-
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void OnRowChanged(object sender, DataRowChangeEventArgs args)
         {
             if (_ignoreDataSetEvents)
@@ -2020,6 +2072,7 @@ private void OnRowChanged(object sender, DataRowChangeEventArgs args)
             }
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void OnRowChanging(object sender, DataRowChangeEventArgs args)
         {
             // We foliate the region each time the assocaited row gets deleted
@@ -2198,6 +2251,7 @@ private void OnRelationPropertyChanging(object? oRelationsCollection, PropertyCh
                 throw new InvalidOperationException(SR.DataDom_DataSetNestedRelationsChange);
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void OnUndeleteRow(DataRow row, XmlElement rowElement)
         {
             XmlNode? refRow;
@@ -2244,6 +2298,7 @@ private void PromoteChild(XmlNode child, XmlNode prevSibling)
         }
 
         // Promote child regions under parent as next siblings of parent
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void PromoteInnerRegions(XmlNode parent)
         {
             Debug.Assert(parent != null);
@@ -2349,6 +2404,7 @@ private void ReplaceInitialChildText(XmlNode parent, string value)
                 return n.PreviousSibling;
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal static void SetRowValueToNull(DataRow row, DataColumn col)
         {
             Debug.Assert(col.ColumnMapping != MappingType.Hidden);
@@ -2359,6 +2415,7 @@ internal static void SetRowValueToNull(DataRow row, DataColumn col)
             }
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         internal static void SetRowValueFromXmlText(DataRow row, DataColumn col, string xmlText)
         {
             Debug.Assert(xmlText != null);
@@ -2381,12 +2438,15 @@ internal static void SetRowValueFromXmlText(DataRow row, DataColumn col, string
                 row[col] = oVal;
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void SynchronizeRowFromRowElement(XmlBoundElement rowElement)
         {
             SynchronizeRowFromRowElement(rowElement, null);
         }
+
         // Sync row fields w/ values from rowElem region.
         // If rowElemList is != null, all subregions of rowElem are appended to it.
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void SynchronizeRowFromRowElement(XmlBoundElement rowElement, ArrayList? rowElemList)
         {
             DataRow? row = rowElement.Row;
@@ -2424,6 +2484,8 @@ private void SynchronizeRowFromRowElement(XmlBoundElement rowElement, ArrayList?
             }
 #endif
         }
+
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void SynchronizeRowFromRowElementEx(XmlBoundElement rowElement, ArrayList? rowElemList)
         {
             Debug.Assert(rowElement != null);
@@ -2523,6 +2585,7 @@ private void SynchronizeRowFromRowElementEx(XmlBoundElement rowElement, ArrayLis
             }
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void UpdateAllColumns(DataRow row, XmlBoundElement rowElement)
         {
             foreach (DataColumn c in row.Table.Columns)
@@ -2534,6 +2597,7 @@ private void UpdateAllColumns(DataRow row, XmlBoundElement rowElement)
         /// <summary>
         /// Initializes a new instance of the XmlDataDocument class.
         /// </summary>
+        [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)]
         public XmlDataDocument() : base(new XmlDataImplementation())
         {
             Init();
@@ -2545,11 +2609,13 @@ public XmlDataDocument() : base(new XmlDataImplementation())
         /// Initializes a new instance of the XmlDataDocument class with the specified
         /// DataSet.
         /// </summary>
+        [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)]
         public XmlDataDocument(DataSet dataset) : base(new XmlDataImplementation())
         {
             Init(dataset);
         }
 
+        [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)]
         internal XmlDataDocument(XmlImplementation imp) : base(imp)
         {
             // This constructor is used by XmlDataImplementation.CreateDocument(), which
@@ -2592,6 +2658,7 @@ private void Init()
         [MemberNotNull(nameof(_foliationLock))]
         [MemberNotNull(nameof(_attrXml))]
         [MemberNotNull(nameof(_dataSet))]
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void Init(DataSet ds)
         {
             if (ds == null)
@@ -2624,6 +2691,8 @@ private bool IsRowLive(DataRow row)
         {
             return (row.RowState & (DataRowState.Added | DataRowState.Unchanged | DataRowState.Modified)) != 0;
         }
+
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private static void SetNestedParentRow(DataRow childRow, DataRow? parentRow)
         {
             DataRelation? rel = GetNestedParentRelation(childRow);
@@ -2638,6 +2707,7 @@ private static void SetNestedParentRow(DataRow childRow, DataRow? parentRow)
         }
 
         // A node (node) was inserted into the main tree (connected) from oldParent==null state
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void OnNodeInsertedInTree(XmlNode node)
         {
             XmlBoundElement? be;
@@ -2676,6 +2746,7 @@ private void OnNodeInsertedInTree(XmlNode node)
             AssertLiveRows(node);
         }
         // "node" was inserting into a disconnected tree from oldParent==null state
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void OnNodeInsertedInFragment(XmlNode node)
         {
             XmlBoundElement? be;
@@ -2713,6 +2784,7 @@ private void OnNodeInsertedInFragment(XmlNode node)
         }
 
         // A row-elem was inserted into the connected tree (connected) from oldParent==null state
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void OnRowElementInsertedInTree(XmlBoundElement rowElem, ArrayList rowElemList)
         {
             Debug.Assert(rowElem.Row != null);
@@ -2775,6 +2847,7 @@ private void OnRowElementInsertedInTree(XmlBoundElement rowElem, ArrayList rowEl
         }
 
         // Disconnect the DataRow associated w/ the rowElem region
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void EnsureDisconnectedDataRow(XmlBoundElement rowElem)
         {
             Debug.Assert(rowElem.Row != null);
@@ -2827,6 +2900,7 @@ private void EnsureDisconnectedDataRow(XmlBoundElement rowElem)
 
 
         // A non-row-elem was inserted into the connected tree (connected) from oldParent==null state
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void OnNonRowElementInsertedInTree(XmlNode node, XmlBoundElement rowElement, ArrayList rowElemList)
         {
             // non-row-elem is beeing inserted
@@ -2843,6 +2917,7 @@ private void OnNonRowElementInsertedInTree(XmlNode node, XmlBoundElement rowElem
         }
 
         // A non-row-elem was inserted into disconnected tree (fragment) from oldParent==null state (i.e. was disconnected)
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void OnNonRowElementInsertedInFragment(XmlNode node, XmlBoundElement rowElement, ArrayList rowElemList)
         {
             // non-row-elem is beeing inserted
@@ -2857,6 +2932,7 @@ private void OnNonRowElementInsertedInFragment(XmlNode node, XmlBoundElement row
             // Nothing to do if the row is deleted (there is no sync-ing from XML to ROM for deleted rows)
         }
 
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void SetNestedParentRegion(XmlBoundElement childRowElem)
         {
             Debug.Assert(childRowElem.Row != null);
@@ -2865,6 +2941,8 @@ private void SetNestedParentRegion(XmlBoundElement childRowElem)
             _mapper.GetRegion(childRowElem.ParentNode, out parentRowElem);
             SetNestedParentRegion(childRowElem, parentRowElem);
         }
+
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         private void SetNestedParentRegion(XmlBoundElement childRowElem, XmlBoundElement? parentRowElem)
         {
             DataRow childRow = childRowElem.Row!;
@@ -2925,7 +3003,8 @@ internal static bool IsOnlyWhitespace( string str ) {
             return true;
         }
         */
-
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
+            Justification = "This whole class is unsafe. Constructors are marked as such.")]
         protected override XPathNavigator? CreateNavigator(XmlNode node)
         {
             Debug.Assert(node.OwnerDocument == this || node == this);
diff --git a/src/libraries/System.Data.Common/src/System/Xml/XmlDataImplementation.cs b/src/libraries/System.Data.Common/src/System/Xml/XmlDataImplementation.cs
index a161154f3152fe..eb1adac8fe4fb1 100644
--- a/src/libraries/System.Data.Common/src/System/Xml/XmlDataImplementation.cs
+++ b/src/libraries/System.Data.Common/src/System/Xml/XmlDataImplementation.cs
@@ -3,11 +3,18 @@
 
 #pragma warning disable 618 // ignore obsolete warning about XmlDataDocument
 
+using System.Data;
+using System.Diagnostics.CodeAnalysis;
+
 namespace System.Xml
 {
     internal sealed class XmlDataImplementation : XmlImplementation
     {
+        [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)]
         public XmlDataImplementation() : base() { }
+
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
+            Justification = "This whole class is unsafe. Constructors are marked as such.")]
         public override XmlDocument CreateDocument() => new XmlDataDocument(this);
     }
 }
diff --git a/src/libraries/System.Data.Common/tests/System/Data/DataSetTest.cs b/src/libraries/System.Data.Common/tests/System/Data/DataSetTest.cs
index 4c2e8b38b4e5f3..0135cc8b8fb1bb 100644
--- a/src/libraries/System.Data.Common/tests/System/Data/DataSetTest.cs
+++ b/src/libraries/System.Data.Common/tests/System/Data/DataSetTest.cs
@@ -179,192 +179,61 @@ public void OwnWriteXmlSchema()
             TextWriter writer = new StringWriter();
             ds.WriteXmlSchema(writer);
 
+            string expected = @"<?xml version=""1.0"" encoding=""utf-16""?>
+<xs:schema id=""test_dataset"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"" xmlns:xs=""http://www.w3.org/2001/XMLSchema"">
+  <xs:element msdata:IsDataSet=""true"" msdata:UseCurrentLocale=""true"" name=""test_dataset"">
+    <xs:complexType>
+      <xs:choice maxOccurs=""unbounded"" minOccurs=""0"">
+        <xs:element name=""test_table"">
+          <xs:complexType>
+            <xs:sequence>
+              <xs:element default=""test_default_value"" minOccurs=""0"" msdata:Caption=""test"" name=""first"">
+                <xs:simpleType>
+                  <xs:restriction base=""xs:string"">
+                    <xs:maxLength value=""100"" />
+                  </xs:restriction>
+                </xs:simpleType>
+              </xs:element>
+              <xs:element minOccurs=""0"" msdata:DataType=""System.Data.SqlTypes.SqlGuid"" name=""second"" type=""xs:string"" />
+            </xs:sequence>
+          </xs:complexType>
+        </xs:element>
+        <xs:element name=""second_test_table"">
+          <xs:complexType>
+            <xs:sequence>
+              <xs:element default=""default_value"" minOccurs=""0"" name=""second_first"">
+                <xs:simpleType>
+                  <xs:restriction base=""xs:string"">
+                    <xs:maxLength value=""100"" />
+                  </xs:restriction>
+                </xs:simpleType>
+              </xs:element>
+            </xs:sequence>
+          </xs:complexType>
+        </xs:element>
+      </xs:choice>
+    </xs:complexType>
+    <xs:unique name=""Constraint1"">
+      <xs:selector xpath="".//test_table"" />
+      <xs:field xpath=""first"" />
+    </xs:unique>
+    <xs:unique msdata:ConstraintName=""Constraint1"" name=""second_test_table_Constraint1"">
+      <xs:selector xpath="".//second_test_table"" />
+      <xs:field xpath=""second_first"" />
+    </xs:unique>
+  </xs:element>
+</xs:schema>".ReplaceLineEndings();
+
+            // Some elements in 'expected' above contain differences from original DataSet.WriteXmlSchema() output:
+            //
+            // <xs:schema id="test_dataset" xmlns="" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+            //   <xs:element name="test_dataset" msdata:IsDataSet="true" msdata:Locale="fi-FI">
+            //               <xs:element name="first" msdata:Caption="test" default="test_default_value" minOccurs="0">
+            //               <xs:element name="second_first" default="default_value" minOccurs="0">
+            //     <xs:unique name="second_test_table_Constraint1" msdata:ConstraintName="Constraint1">
+
             string TextString = DataSetAssertion.GetNormalizedSchema(writer.ToString());
-            //            string TextString = writer.ToString ();
-
-            string substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            Assert.Equal("<?xml version=\"1.0\" encoding=\"utf-16\"?>", substring);
-
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            // This is original DataSet.WriteXmlSchema() output
-            //            Assert.Equal ("<xs:schema id=\"test_dataset\" xmlns=\"\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\">", substring);
-            Assert.Equal("<xs:schema id=\"test_dataset\" xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">", substring);
-
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            // This is original DataSet.WriteXmlSchema() output
-            //            Assert.Equal ("  <xs:element name=\"test_dataset\" msdata:IsDataSet=\"true\" msdata:Locale=\"fi-FI\">", substring);
-            Assert.Equal("  <xs:element msdata:IsDataSet=\"true\" msdata:UseCurrentLocale=\"true\" name=\"test_dataset\">", substring);
-
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            Assert.Equal("    <xs:complexType>", substring);
-
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            Assert.Equal("      <xs:choice maxOccurs=\"unbounded\" minOccurs=\"0\">", substring);
-
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            Assert.Equal("        <xs:element name=\"test_table\">", substring);
-
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            Assert.Equal("          <xs:complexType>", substring);
-
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            Assert.Equal("            <xs:sequence>", substring);
-
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            // This is original DataSet.WriteXmlSchema() output
-            //            Assert.Equal ("              <xs:element name=\"first\" msdata:Caption=\"test\" default=\"test_default_value\" minOccurs=\"0\">", substring);
-            Assert.Equal("              <xs:element default=\"test_default_value\" minOccurs=\"0\" msdata:Caption=\"test\" name=\"first\">", substring);
-
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            Assert.Equal("                <xs:simpleType>", substring);
-
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            Assert.Equal("                  <xs:restriction base=\"xs:string\">", substring);
-
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            Assert.Equal("                    <xs:maxLength value=\"100\" />", substring);
-
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            Assert.Equal("                  </xs:restriction>", substring);
-
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            Assert.Equal("                </xs:simpleType>", substring);
-
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            Assert.Equal("              </xs:element>", substring);
-
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            // This is original DataSet.WriteXmlSchema() output
-            Assert.Equal("              <xs:element minOccurs=\"0\" msdata:DataType=\"System.Data.SqlTypes.SqlGuid\" name=\"second\" type=\"xs:string\" />", substring);
-
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            Assert.Equal("            </xs:sequence>", substring);
-
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            Assert.Equal("          </xs:complexType>", substring);
-
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            Assert.Equal("        </xs:element>", substring);
-
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            Assert.Equal("        <xs:element name=\"second_test_table\">", substring);
-
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            Assert.Equal("          <xs:complexType>", substring);
-
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            Assert.Equal("            <xs:sequence>", substring);
-
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            // This is original DataSet.WriteXmlSchema() output
-            //            Assert.Equal ("              <xs:element name=\"second_first\" default=\"default_value\" minOccurs=\"0\">", substring);
-            Assert.Equal("              <xs:element default=\"default_value\" minOccurs=\"0\" name=\"second_first\">", substring);
-
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            Assert.Equal("                <xs:simpleType>", substring);
-
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            Assert.Equal("                  <xs:restriction base=\"xs:string\">", substring);
-
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            Assert.Equal("                    <xs:maxLength value=\"100\" />", substring);
-
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            Assert.Equal("                  </xs:restriction>", substring);
-
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            Assert.Equal("                </xs:simpleType>", substring);
-
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            Assert.Equal("              </xs:element>", substring);
-
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            Assert.Equal("            </xs:sequence>", substring);
-
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            Assert.Equal("          </xs:complexType>", substring);
-
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            Assert.Equal("        </xs:element>", substring);
-
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            Assert.Equal("      </xs:choice>", substring);
-
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            Assert.Equal("    </xs:complexType>", substring);
-
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            Assert.Equal("    <xs:unique name=\"Constraint1\">", substring);
-
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            Assert.Equal("      <xs:selector xpath=\".//test_table\" />", substring);
-
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            Assert.Equal("      <xs:field xpath=\"first\" />", substring);
-
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            Assert.Equal("    </xs:unique>", substring);
-
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            // This is original DataSet.WriteXmlSchema() output
-            //            Assert.Equal ("    <xs:unique name=\"second_test_table_Constraint1\" msdata:ConstraintName=\"Constraint1\">", substring);
-            Assert.Equal("    <xs:unique msdata:ConstraintName=\"Constraint1\" name=\"second_test_table_Constraint1\">", substring);
-
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            Assert.Equal("      <xs:selector xpath=\".//second_test_table\" />", substring);
-
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            Assert.Equal("      <xs:field xpath=\"second_first\" />", substring);
-
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            Assert.Equal("    </xs:unique>", substring);
-
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            Assert.Equal("  </xs:element>", substring);
-            Assert.Equal("</xs:schema>", TextString);
+            Assert.Equal(expected, TextString.ReplaceLineEndings());
         }
 
         [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNotInvariantGlobalization))]
@@ -375,53 +244,21 @@ public void ReadWriteXml()
             TextWriter writer = new StringWriter();
             ds.WriteXml(writer);
 
+            string expected = @"<Root>
+  <Region>
+    <RegionID>1</RegionID>
+    <RegionDescription>Eastern
+               </RegionDescription>
+  </Region>
+  <Region>
+    <RegionID>2</RegionID>
+    <RegionDescription>Western
+               </RegionDescription>
+  </Region>
+</Root>".ReplaceLineEndings();
+
             string TextString = writer.ToString();
-            string substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            Assert.Equal("<Root>", substring);
-
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            Assert.Equal("  <Region>", substring);
-
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            Assert.Equal("    <RegionID>1</RegionID>", substring);
-            // Here the end of line is text markup "\n"
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            Assert.Equal("    <RegionDescription>Eastern", substring);
-
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            Assert.Equal("               </RegionDescription>", substring);
-
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            Assert.Equal("  </Region>", substring);
-
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            Assert.Equal("  <Region>", substring);
-
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            Assert.Equal("    <RegionID>2</RegionID>", substring);
-
-            // Here the end of line is text markup "\n"
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            Assert.Equal("    <RegionDescription>Western", substring);
-
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            Assert.Equal("               </RegionDescription>", substring);
-
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            Assert.Equal("  </Region>", substring);
-
-            Assert.Equal("</Root>", TextString);
+            Assert.Equal(expected, TextString.ReplaceLineEndings());
         }
 
         [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNotInvariantGlobalization))]
@@ -449,62 +286,23 @@ public void ReadWriteXmlDiffGram()
             ds.ReadXml(new StringReader(DataProvider.region), XmlReadMode.DiffGram);
             ds.WriteXml(writer, XmlWriteMode.DiffGram);
 
-            TextString = writer.ToString();
-            string substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            Assert.Equal("<NewDataSet /><diffgr:diffgram xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\" xmlns:diffgr=\"urn:schemas-microsoft-com:xml-diffgram-v1\" /><diffgr:diffgram xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\" xmlns:diffgr=\"urn:schemas-microsoft-com:xml-diffgram-v1\">", substring);
-
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            Assert.Equal("  <Root>", substring);
-
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            Assert.Equal("    <Region diffgr:id=\"Region1\" msdata:rowOrder=\"0\" diffgr:hasChanges=\"inserted\">", substring);
+            string expected = @"<NewDataSet /><diffgr:diffgram xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"" xmlns:diffgr=""urn:schemas-microsoft-com:xml-diffgram-v1"" /><diffgr:diffgram xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"" xmlns:diffgr=""urn:schemas-microsoft-com:xml-diffgram-v1"">
+  <Root>
+    <Region diffgr:id=""Region1"" msdata:rowOrder=""0"" diffgr:hasChanges=""inserted"">
+      <RegionID>64</RegionID>
+      <RegionDescription>Eastern
+               </RegionDescription>
+    </Region>
+    <Region diffgr:id=""Region2"" msdata:rowOrder=""1"" diffgr:hasChanges=""inserted"">
+      <RegionID>2</RegionID>
+      <RegionDescription>Western
+               </RegionDescription>
+    </Region>
+  </Root>
+</diffgr:diffgram>".ReplaceLineEndings();
 
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            Assert.Equal("      <RegionID>64</RegionID>", substring);
-
-            // not '\n' but literal '\n'
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            Assert.Equal("      <RegionDescription>Eastern", substring);
-
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            Assert.Equal("               </RegionDescription>", substring);
-
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            Assert.Equal("    </Region>", substring);
-
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            Assert.Equal("    <Region diffgr:id=\"Region2\" msdata:rowOrder=\"1\" diffgr:hasChanges=\"inserted\">", substring);
-
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            Assert.Equal("      <RegionID>2</RegionID>", substring);
-
-            // not '\n' but literal '\n'
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            Assert.Equal("      <RegionDescription>Western", substring);
-
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            Assert.Equal("               </RegionDescription>", substring);
-
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            Assert.Equal("    </Region>", substring);
-
-            substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-            TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-            Assert.Equal("  </Root>", substring);
-
-            Assert.Equal("</diffgr:diffgram>", TextString);
+            TextString = writer.ToString();
+            Assert.Equal(expected, TextString.ReplaceLineEndings());
         }
 
         [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNotInvariantGlobalization))]
@@ -517,81 +315,32 @@ public void WriteXmlSchema()
                 TextWriter writer = new StringWriter();
                 ds.WriteXmlSchema(writer);
 
+                string expected = @"<?xml version=""1.0"" encoding=""utf-16""?>
+<xs:schema id=""Root"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"" xmlns:xs=""http://www.w3.org/2001/XMLSchema"">
+  <xs:element msdata:IsDataSet=""true"" msdata:Locale=""en-US"" name=""Root"">
+    <xs:complexType>
+      <xs:choice maxOccurs=""unbounded"" minOccurs=""0"">
+        <xs:element name=""Region"">
+          <xs:complexType>
+            <xs:sequence>
+              <xs:element minOccurs=""0"" name=""RegionID"" type=""xs:string"" />
+              <xs:element minOccurs=""0"" name=""RegionDescription"" type=""xs:string"" />
+            </xs:sequence>
+          </xs:complexType>
+        </xs:element>
+      </xs:choice>
+    </xs:complexType>
+  </xs:element>
+</xs:schema>".ReplaceLineEndings();
+
+                // Some elements in 'expected' above contain differences from original DataSet.WriteXmlSchema() output:
+                //
+                // <xs:schema id="Root" xmlns="" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+                //               <xs:element name="RegionID" type="xs:string" minOccurs="0" />
+                //               <xs:element name="RegionDescription" type="xs:string" minOccurs="0" />
 
                 string TextString = DataSetAssertion.GetNormalizedSchema(writer.ToString());
-                // string TextString = writer.ToString ();
-
-                string substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-                TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-                Assert.Equal("<?xml version=\"1.0\" encoding=\"utf-16\"?>", substring);
-
-                substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-                TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-                // This is original DataSet.WriteXmlSchema() output
-                // Assert.Equal ("<xs:schema id=\"Root\" xmlns=\"\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\">", substring);
-                Assert.Equal("<xs:schema id=\"Root\" xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">", substring);
-
-                substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-                TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-                Assert.Equal("  <xs:element msdata:IsDataSet=\"true\" msdata:Locale=\"en-US\" name=\"Root\">", substring);
-
-                substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-                TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-                Assert.Equal("    <xs:complexType>", substring);
-
-                substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-                TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-                Assert.Equal("      <xs:choice maxOccurs=\"unbounded\" minOccurs=\"0\">", substring);
-
-                substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-                TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-                Assert.Equal("        <xs:element name=\"Region\">", substring);
-
-                substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-                TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-                Assert.Equal("          <xs:complexType>", substring);
-
-                substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-                TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-                Assert.Equal("            <xs:sequence>", substring);
-
-                substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-                TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-                // This is original DataSet.WriteXmlSchema() output
-                // Assert.Equal ("              <xs:element name=\"RegionID\" type=\"xs:string\" minOccurs=\"0\" />", substring);
-                Assert.Equal("              <xs:element minOccurs=\"0\" name=\"RegionID\" type=\"xs:string\" />", substring);
-
-                substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-                TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-                // This is original DataSet.WriteXmlSchema() output
-                // Assert.Equal ("              <xs:element name=\"RegionDescription\" type=\"xs:string\" minOccurs=\"0\" />", substring);
-                Assert.Equal("              <xs:element minOccurs=\"0\" name=\"RegionDescription\" type=\"xs:string\" />", substring);
-
-                substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-                TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-                Assert.Equal("            </xs:sequence>", substring);
-
-                substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-                TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-                Assert.Equal("          </xs:complexType>", substring);
-
-                substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-                TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-                Assert.Equal("        </xs:element>", substring);
-
-                substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-                TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-                Assert.Equal("      </xs:choice>", substring);
-
-                substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-                TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-                Assert.Equal("    </xs:complexType>", substring);
-
-                substring = TextString.Substring(0, TextString.IndexOfAny(new[] { '\r', '\n' }));
-                TextString = TextString.Substring(TextString.IndexOf('\n') + 1);
-                Assert.Equal("  </xs:element>", substring);
-
-                Assert.Equal("</xs:schema>", TextString);
+                Assert.Equal(expected, TextString.ReplaceLineEndings());
             }
         }
 
diff --git a/src/libraries/System.Data.Common/tests/System/Data/DataTableTest.cs b/src/libraries/System.Data.Common/tests/System/Data/DataTableTest.cs
index df8276d0aac4eb..7edce6ba12f7ea 100644
--- a/src/libraries/System.Data.Common/tests/System/Data/DataTableTest.cs
+++ b/src/libraries/System.Data.Common/tests/System/Data/DataTableTest.cs
@@ -1444,69 +1444,27 @@ public void TestWriteXmlSchema1()
             dt1.Rows.Add(dr1);
             TextWriter writer = new StringWriter();
             dt.WriteXmlSchema(writer);
-            string textString = writer.ToString();
-            string substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("<?xml version=\"1.0\" encoding=\"utf-16\"?>", substring);
-
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("<xs:schema id=\"NewDataSet\" xmlns=\"\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\">", substring);
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("  <xs:element name=\"NewDataSet\" msdata:IsDataSet=\"true\" msdata:MainDataTable=\"TestWriteXmlSchema\" msdata:UseCurrentLocale=\"true\">", substring);
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("    <xs:complexType>", substring);
-
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("      <xs:choice minOccurs=\"0\" maxOccurs=\"unbounded\">", substring);
-
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("        <xs:element name=\"TestWriteXmlSchema\">", substring);
-
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("          <xs:complexType>", substring);
-
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("            <xs:sequence>", substring);
-
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("              <xs:element name=\"Col1\" type=\"xs:int\" minOccurs=\"0\" />", substring);
 
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("              <xs:element name=\"Col2\" type=\"xs:int\" minOccurs=\"0\" />", substring);
-
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("            </xs:sequence>", substring);
-
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("          </xs:complexType>", substring);
-
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("        </xs:element>", substring);
-
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("      </xs:choice>", substring);
-
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("    </xs:complexType>", substring);
+            string expected = @"<?xml version=""1.0"" encoding=""utf-16""?>
+<xs:schema id=""NewDataSet"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">
+  <xs:element name=""NewDataSet"" msdata:IsDataSet=""true"" msdata:MainDataTable=""TestWriteXmlSchema"" msdata:UseCurrentLocale=""true"">
+    <xs:complexType>
+      <xs:choice minOccurs=""0"" maxOccurs=""unbounded"">
+        <xs:element name=""TestWriteXmlSchema"">
+          <xs:complexType>
+            <xs:sequence>
+              <xs:element name=""Col1"" type=""xs:int"" minOccurs=""0"" />
+              <xs:element name=""Col2"" type=""xs:int"" minOccurs=""0"" />
+            </xs:sequence>
+          </xs:complexType>
+        </xs:element>
+      </xs:choice>
+    </xs:complexType>
+  </xs:element>
+</xs:schema>".ReplaceLineEndings();
 
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("  </xs:element>", substring);
-            Assert.Equal("</xs:schema>", textString);
+            string textString = writer.ToString();
+            Assert.Equal(expected, textString.ReplaceLineEndings());
         }
 
         [Fact]
@@ -1533,85 +1491,31 @@ public void TestWriteXmlSchema2()
             ds.Relations.Add(rel);
             TextWriter writer = new StringWriter();
             dt.WriteXmlSchema(writer);
-            string textString = writer.ToString();
-            string substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("<?xml version=\"1.0\" encoding=\"utf-16\"?>", substring);
-
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("<xs:schema id=\"NewDataSet\" xmlns=\"\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\">", substring);
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("  <xs:element name=\"NewDataSet\" msdata:IsDataSet=\"true\" msdata:MainDataTable=\"TestWriteXmlSchema\" msdata:UseCurrentLocale=\"true\">", substring);
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("    <xs:complexType>", substring);
 
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("      <xs:choice minOccurs=\"0\" maxOccurs=\"unbounded\">", substring);
-
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("        <xs:element name=\"TestWriteXmlSchema\">", substring);
-
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("          <xs:complexType>", substring);
-
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("            <xs:sequence>", substring);
-
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("              <xs:element name=\"Col1\" type=\"xs:int\" minOccurs=\"0\" />", substring);
-
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("              <xs:element name=\"Col2\" type=\"xs:int\" minOccurs=\"0\" />", substring);
-
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("            </xs:sequence>", substring);
-
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("          </xs:complexType>", substring);
-
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("        </xs:element>", substring);
-
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("      </xs:choice>", substring);
-
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("    </xs:complexType>", substring);
-
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("    <xs:unique name=\"Constraint1\">", substring);
-
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("      <xs:selector xpath=\".//TestWriteXmlSchema\" />", substring);
-
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("      <xs:field xpath=\"Col1\" />", substring);
-
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("    </xs:unique>", substring);
+            string expected = @"<?xml version=""1.0"" encoding=""utf-16""?>
+<xs:schema id=""NewDataSet"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">
+  <xs:element name=""NewDataSet"" msdata:IsDataSet=""true"" msdata:MainDataTable=""TestWriteXmlSchema"" msdata:UseCurrentLocale=""true"">
+    <xs:complexType>
+      <xs:choice minOccurs=""0"" maxOccurs=""unbounded"">
+        <xs:element name=""TestWriteXmlSchema"">
+          <xs:complexType>
+            <xs:sequence>
+              <xs:element name=""Col1"" type=""xs:int"" minOccurs=""0"" />
+              <xs:element name=""Col2"" type=""xs:int"" minOccurs=""0"" />
+            </xs:sequence>
+          </xs:complexType>
+        </xs:element>
+      </xs:choice>
+    </xs:complexType>
+    <xs:unique name=""Constraint1"">
+      <xs:selector xpath="".//TestWriteXmlSchema"" />
+      <xs:field xpath=""Col1"" />
+    </xs:unique>
+  </xs:element>
+</xs:schema>".ReplaceLineEndings();
 
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("  </xs:element>", substring);
-            Assert.Equal("</xs:schema>", textString);
+            string textString = writer.ToString();
+            Assert.Equal(expected, textString.ReplaceLineEndings());
         }
 
         [Fact]
@@ -1638,133 +1542,43 @@ public void TestWriteXmlSchema3()
             ds.Relations.Add(rel);
             TextWriter writer = new StringWriter();
             dt.WriteXmlSchema(writer, true);
-            string textString = writer.ToString();
-            string substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("<?xml version=\"1.0\" encoding=\"utf-16\"?>", substring);
-
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("<xs:schema id=\"NewDataSet\" xmlns=\"\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\">", substring);
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("  <xs:element name=\"NewDataSet\" msdata:IsDataSet=\"true\" msdata:MainDataTable=\"TestWriteXmlSchema\" msdata:UseCurrentLocale=\"true\">", substring);
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("    <xs:complexType>", substring);
-
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("      <xs:choice minOccurs=\"0\" maxOccurs=\"unbounded\">", substring);
-
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("        <xs:element name=\"TestWriteXmlSchema\">", substring);
-
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("          <xs:complexType>", substring);
-
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("            <xs:sequence>", substring);
-
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("              <xs:element name=\"Col1\" type=\"xs:int\" minOccurs=\"0\" />", substring);
-
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("              <xs:element name=\"Col2\" type=\"xs:int\" minOccurs=\"0\" />", substring);
-
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("            </xs:sequence>", substring);
-
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("          </xs:complexType>", substring);
-
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("        </xs:element>", substring);
-
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("        <xs:element name=\"HelloWorld\">", substring);
-
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("          <xs:complexType>", substring);
-
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("            <xs:sequence>", substring);
-
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("              <xs:element name=\"T1\" type=\"xs:int\" minOccurs=\"0\" />", substring);
-
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("              <xs:element name=\"T2\" type=\"xs:int\" minOccurs=\"0\" />", substring);
-
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("            </xs:sequence>", substring);
-
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("          </xs:complexType>", substring);
-
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("        </xs:element>", substring);
-
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("      </xs:choice>", substring);
-
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("    </xs:complexType>", substring);
-
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("    <xs:unique name=\"Constraint1\">", substring);
-
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("      <xs:selector xpath=\".//TestWriteXmlSchema\" />", substring);
-
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("      <xs:field xpath=\"Col1\" />", substring);
-
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("    </xs:unique>", substring);
-
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("    <xs:keyref name=\"Relation1\" refer=\"Constraint1\">", substring);
 
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("      <xs:selector xpath=\".//HelloWorld\" />", substring);
-
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("      <xs:field xpath=\"T1\" />", substring);
-
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("    </xs:keyref>", substring);
+            string expected = @"<?xml version=""1.0"" encoding=""utf-16""?>
+<xs:schema id=""NewDataSet"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">
+  <xs:element name=""NewDataSet"" msdata:IsDataSet=""true"" msdata:MainDataTable=""TestWriteXmlSchema"" msdata:UseCurrentLocale=""true"">
+    <xs:complexType>
+      <xs:choice minOccurs=""0"" maxOccurs=""unbounded"">
+        <xs:element name=""TestWriteXmlSchema"">
+          <xs:complexType>
+            <xs:sequence>
+              <xs:element name=""Col1"" type=""xs:int"" minOccurs=""0"" />
+              <xs:element name=""Col2"" type=""xs:int"" minOccurs=""0"" />
+            </xs:sequence>
+          </xs:complexType>
+        </xs:element>
+        <xs:element name=""HelloWorld"">
+          <xs:complexType>
+            <xs:sequence>
+              <xs:element name=""T1"" type=""xs:int"" minOccurs=""0"" />
+              <xs:element name=""T2"" type=""xs:int"" minOccurs=""0"" />
+            </xs:sequence>
+          </xs:complexType>
+        </xs:element>
+      </xs:choice>
+    </xs:complexType>
+    <xs:unique name=""Constraint1"">
+      <xs:selector xpath="".//TestWriteXmlSchema"" />
+      <xs:field xpath=""Col1"" />
+    </xs:unique>
+    <xs:keyref name=""Relation1"" refer=""Constraint1"">
+      <xs:selector xpath="".//HelloWorld"" />
+      <xs:field xpath=""T1"" />
+    </xs:keyref>
+  </xs:element>
+</xs:schema>".ReplaceLineEndings();
 
-            substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-            textString = textString.Substring(textString.IndexOf('\n') + 1);
-            Assert.Equal("  </xs:element>", substring);
-            Assert.Equal("</xs:schema>", textString);
+            string textString = writer.ToString();
+            Assert.Equal(expected, textString.ReplaceLineEndings());
         }
 
         [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsBinaryFormatterSupported), nameof(PlatformDetection.IsNotInvariantGlobalization))]
@@ -3121,74 +2935,27 @@ public void WriteXmlSchema()
                 TextWriter writer = new StringWriter();
                 ds.Tables[0].WriteXmlSchema(writer);
 
-                string textString = DataSetAssertion.GetNormalizedSchema(writer.ToString());
-
-                string substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-                textString = textString.Substring(textString.IndexOf('\n') + 1);
-                Assert.Equal("<?xml version=\"1.0\" encoding=\"utf-16\"?>", substring);
-
-                substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-                textString = textString.Substring(textString.IndexOf('\n') + 1);
-                Assert.Equal("<xs:schema id=\"Root\" xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">", substring);
-
-                substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-                textString = textString.Substring(textString.IndexOf('\n') + 1);
-                // Looks like whoever added this test depended on English culture, which is wrong.
-                Assert.Equal("  <xs:element msdata:IsDataSet=\"true\" msdata:Locale=\"en-US\" msdata:MainDataTable=\"Region\" name=\"Root\">", substring);
-
-                substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-                textString = textString.Substring(textString.IndexOf('\n') + 1);
-                Assert.Equal("    <xs:complexType>", substring);
-
-                substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-                textString = textString.Substring(textString.IndexOf('\n') + 1);
-                Assert.Equal("      <xs:choice maxOccurs=\"unbounded\" minOccurs=\"0\">", substring);
-
-                substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-                textString = textString.Substring(textString.IndexOf('\n') + 1);
-                Assert.Equal("        <xs:element name=\"Region\">", substring);
-
-                substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-                textString = textString.Substring(textString.IndexOf('\n') + 1);
-                Assert.Equal("          <xs:complexType>", substring);
-
-                substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-                textString = textString.Substring(textString.IndexOf('\n') + 1);
-                Assert.Equal("            <xs:sequence>", substring);
-
-                substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-                textString = textString.Substring(textString.IndexOf('\n') + 1);
-                Assert.Equal("              <xs:element minOccurs=\"0\" name=\"RegionID\" type=\"xs:string\" />", substring);
-
-                substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-                textString = textString.Substring(textString.IndexOf('\n') + 1);
-                Assert.Equal("              <xs:element minOccurs=\"0\" name=\"RegionDescription\" type=\"xs:string\" />", substring);
-
-                substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-                textString = textString.Substring(textString.IndexOf('\n') + 1);
-                Assert.Equal("            </xs:sequence>", substring);
-
-                substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-                textString = textString.Substring(textString.IndexOf('\n') + 1);
-                Assert.Equal("          </xs:complexType>", substring);
-
-                substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-                textString = textString.Substring(textString.IndexOf('\n') + 1);
-                Assert.Equal("        </xs:element>", substring);
-
-                substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-                textString = textString.Substring(textString.IndexOf('\n') + 1);
-                Assert.Equal("      </xs:choice>", substring);
-
-                substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-                textString = textString.Substring(textString.IndexOf('\n') + 1);
-                Assert.Equal("    </xs:complexType>", substring);
-
-                substring = textString.Substring(0, textString.IndexOfAny(new[] { '\r', '\n' }));
-                textString = textString.Substring(textString.IndexOf('\n') + 1);
-                Assert.Equal("  </xs:element>", substring);
+                // Looks like whoever added this test depended on en-US culture (see 'msdata:Locale attr' in 3rd line below), which is wrong.
+                string expected = @"<?xml version=""1.0"" encoding=""utf-16""?>
+<xs:schema id=""Root"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"" xmlns:xs=""http://www.w3.org/2001/XMLSchema"">
+  <xs:element msdata:IsDataSet=""true"" msdata:Locale=""en-US"" msdata:MainDataTable=""Region"" name=""Root"">
+    <xs:complexType>
+      <xs:choice maxOccurs=""unbounded"" minOccurs=""0"">
+        <xs:element name=""Region"">
+          <xs:complexType>
+            <xs:sequence>
+              <xs:element minOccurs=""0"" name=""RegionID"" type=""xs:string"" />
+              <xs:element minOccurs=""0"" name=""RegionDescription"" type=""xs:string"" />
+            </xs:sequence>
+          </xs:complexType>
+        </xs:element>
+      </xs:choice>
+    </xs:complexType>
+  </xs:element>
+</xs:schema>".ReplaceLineEndings();
 
-                Assert.Equal("</xs:schema>", textString);
+                string textString = DataSetAssertion.GetNormalizedSchema(writer.ToString());
+                Assert.Equal(expected, textString.ReplaceLineEndings());
             }
         }
 
diff --git a/src/libraries/System.Data.Common/tests/TrimmingTests/DbConnectionStringBuilder.cs b/src/libraries/System.Data.Common/tests/TrimmingTests/DbConnectionStringBuilder.cs
new file mode 100644
index 00000000000000..78ac56e9f751a2
--- /dev/null
+++ b/src/libraries/System.Data.Common/tests/TrimmingTests/DbConnectionStringBuilder.cs
@@ -0,0 +1,159 @@
+// 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.Data.Common;
+using System.ComponentModel;
+using System.Collections;
+
+namespace DbConnectionStringBuilderTrimmingTests
+{
+    class Program
+    {
+        static int Main(string[] args)
+        {
+            DbConnectionStringBuilder2 dcsb2 = new();
+            ICustomTypeDescriptor td = dcsb2;
+
+            if (td.GetClassName() != "DbConnectionStringBuilderTrimmingTests.DbConnectionStringBuilder2")
+            {
+                throw new Exception("Class name got trimmed");
+            }
+
+            if (td.GetComponentName() != "Test Component Name")
+            {
+                throw new Exception("Component name got trimmed");
+            }
+
+            bool foundAttr = false;
+
+            foreach (Attribute attr in td.GetAttributes())
+            {
+                if (attr.GetType().Name == "TestAttribute")
+                {
+                    if (attr.ToString() != "Test Attribute Value")
+                    {
+                        throw new Exception("Test attribute value differs");
+                    }
+
+                    if (foundAttr)
+                    {
+                        throw new Exception("More than one attribute found");
+                    }
+
+                    foundAttr = true;
+                }
+            }
+
+            if (!foundAttr)
+            {
+                throw new Exception("Attribute not found");
+            }
+
+            bool foundEvent = false;
+            bool foundEventWithDisplayName = false;
+
+            foreach (EventDescriptor ev in td.GetEvents())
+            {
+                if (ev.DisplayName == "TestEvent")
+                {
+                    if (foundEvent)
+                    {
+                        throw new Exception("More than one event TestEvent found.");
+                    }
+
+                    foundEvent = true;
+                }
+
+                if (ev.DisplayName == "Event With DisplayName")
+                {
+                    if (foundEventWithDisplayName)
+                    {
+                        throw new Exception("More than one event with display name found.");
+                    }
+
+                    foundEventWithDisplayName = true;
+                }
+            }
+
+            if (!foundEvent)
+            {
+                throw new Exception("Event not found");
+            }
+
+            if (!foundEventWithDisplayName)
+            {
+                throw new Exception("Event with DisplayName not found");
+            }
+
+            bool propertyFound = false;
+            foreach (DictionaryEntry kv in dcsb2.GetProperties2())
+            {
+                PropertyDescriptor val = (PropertyDescriptor)kv.Value;
+                if (val.Name == "TestProperty")
+                {
+                    if (propertyFound)
+                    {
+                        throw new Exception("More than one property TestProperty found.");
+                    }
+
+                    propertyFound = true;
+                }
+            }
+
+            if (!propertyFound)
+            {
+                throw new Exception("Property not found");
+            }
+
+            return 100;
+        }
+    }
+
+    [Test("Test Attribute Value")]
+    class DbConnectionStringBuilder2 : DbConnectionStringBuilder, IComponent
+    {
+#pragma warning disable CS0067 // The event is never used
+        public event EventHandler Disposed;
+        public event Action TestEvent;
+        [DisplayName("Event With DisplayName")]
+        public event Action TestEvent2;
+#pragma warning restore CS0067
+
+        public string TestProperty { get; set; }
+        public ISite Site { get => new TestSite(); set => throw new NotImplementedException(); }
+        public void Dispose() { }
+
+        public Hashtable GetProperties2()
+        {
+            Hashtable propertyDescriptors = new Hashtable();
+            GetProperties(propertyDescriptors);
+            return propertyDescriptors;
+        }
+    }
+
+    class TestSite : INestedSite
+    {
+        public string FullName => null;
+        public IComponent Component => throw new NotImplementedException();
+        public IContainer Container => throw new NotImplementedException();
+        public bool DesignMode => throw new NotImplementedException();
+        public string Name { get => "Test Component Name"; set => throw new NotImplementedException(); }
+        public object GetService(Type serviceType) => null;
+    }
+
+    class TestAttribute : Attribute
+    {
+        public string Test { get; private set; }
+
+        public TestAttribute(string test)
+        {
+            Test = test;
+        }
+
+        public override string ToString()
+        {
+            return Test;
+        }
+    }
+}
diff --git a/src/libraries/System.Data.Common/tests/TrimmingTests/System.Data.Common.TrimmingTests.proj b/src/libraries/System.Data.Common/tests/TrimmingTests/System.Data.Common.TrimmingTests.proj
index da4a46f2ae141a..7254c33fc9c7ba 100644
--- a/src/libraries/System.Data.Common/tests/TrimmingTests/System.Data.Common.TrimmingTests.proj
+++ b/src/libraries/System.Data.Common/tests/TrimmingTests/System.Data.Common.TrimmingTests.proj
@@ -1,5 +1,10 @@
 <Project DefaultTargets="Build">
   <Import Project="$([MSBuild]::GetPathOfFileAbove(Directory.Build.props))" />
 
+  <ItemGroup>
+    <TestConsoleAppSourceFiles Include="CreateSqlXmlReader.cs" />
+    <TestConsoleAppSourceFiles Include="DbConnectionStringBuilder.cs" />
+  </ItemGroup>
+
   <Import Project="$([MSBuild]::GetPathOfFileAbove(Directory.Build.targets))" />
 </Project>
diff --git a/src/libraries/System.Data.Odbc/ref/System.Data.Odbc.cs b/src/libraries/System.Data.Odbc/ref/System.Data.Odbc.cs
index 5a2a8319a5777f..235db70c644a3f 100644
--- a/src/libraries/System.Data.Odbc/ref/System.Data.Odbc.cs
+++ b/src/libraries/System.Data.Odbc/ref/System.Data.Odbc.cs
@@ -48,7 +48,7 @@ protected override void Dispose(bool disposing) { }
         public override object? ExecuteScalar() { throw null; }
         public override void Prepare() { }
         public void ResetCommandTimeout() { }
-        object? System.ICloneable.Clone() { throw null; }
+        object System.ICloneable.Clone() { throw null; }
     }
     public sealed partial class OdbcCommandBuilder : System.Data.Common.DbCommandBuilder
     {
@@ -154,7 +154,7 @@ public event System.Data.Odbc.OdbcRowUpdatingEventHandler? RowUpdating { add { }
         protected override System.Data.Common.RowUpdatingEventArgs CreateRowUpdatingEvent(System.Data.DataRow dataRow, System.Data.IDbCommand? command, System.Data.StatementType statementType, System.Data.Common.DataTableMapping tableMapping) { throw null; }
         protected override void OnRowUpdated(System.Data.Common.RowUpdatedEventArgs value) { }
         protected override void OnRowUpdating(System.Data.Common.RowUpdatingEventArgs value) { }
-        object? System.ICloneable.Clone() { throw null; }
+        object System.ICloneable.Clone() { throw null; }
     }
     public sealed partial class OdbcDataReader : System.Data.Common.DbDataReader
     {
@@ -287,7 +287,7 @@ public OdbcParameter(string? name, object? value) { }
         public override object? Value { get { throw null; } set { } }
         public override void ResetDbType() { }
         public void ResetOdbcType() { }
-        object? System.ICloneable.Clone() { throw null; }
+        object System.ICloneable.Clone() { throw null; }
         public override string ToString() { throw null; }
     }
     [System.ComponentModel.EditorAttribute("Microsoft.VSDesigner.Data.Design.DBParametersEditor, Microsoft.VSDesigner, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", "System.Drawing.Design.UITypeEditor, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a")]
diff --git a/src/libraries/System.Data.Odbc/ref/System.Data.Odbc.csproj b/src/libraries/System.Data.Odbc/ref/System.Data.Odbc.csproj
index ab06317e28cd68..3f557d722422ea 100644
--- a/src/libraries/System.Data.Odbc/ref/System.Data.Odbc.csproj
+++ b/src/libraries/System.Data.Odbc/ref/System.Data.Odbc.csproj
@@ -1,10 +1,19 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFrameworks>netstandard2.0;net461</TargetFrameworks>
+    <TargetFrameworks>$(NetCoreAppCurrent);netcoreapp3.1;netstandard2.0;net461</TargetFrameworks>
     <Nullable>enable</Nullable>
   </PropertyGroup>
   <ItemGroup>
     <Compile Condition="'$(TargetFramework)' != 'net461'" Include="System.Data.Odbc.cs" />
     <Compile Condition="'$(TargetFramework)' == 'net461'" Include="System.Data.Odbc.net461.cs" />
   </ItemGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == '$(NetCoreAppCurrent)'">
+    <ProjectReference Include="$(LibrariesProjectRoot)System.Data.Common\ref\System.Data.Common.csproj" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == 'netcoreapp3.1'">
+    <Reference Include="System.ComponentModel.Primitives" />
+    <Reference Include="System.ComponentModel.TypeConverter" />
+    <Reference Include="System.Data.Common" />
+    <Reference Include="System.Runtime" />
+  </ItemGroup>
 </Project>
diff --git a/src/libraries/System.Data.Odbc/src/ILLink/ILLink.Suppressions.xml b/src/libraries/System.Data.Odbc/src/ILLink/ILLink.Suppressions.xml
index 04be721d7102d0..533fc1cd0ed04d 100644
--- a/src/libraries/System.Data.Odbc/src/ILLink/ILLink.Suppressions.xml
+++ b/src/libraries/System.Data.Odbc/src/ILLink/ILLink.Suppressions.xml
@@ -7,5 +7,53 @@
       <property name="Scope">member</property>
       <property name="Target">M:Interop.Odbc.SQLSetConnectAttrW(System.Data.Odbc.OdbcConnectionHandle,System.Data.Odbc.ODBC32.SQL_ATTR,System.Transactions.IDtcTransaction,System.Int32)</property>
     </attribute>
+    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
+      <argument>ILLink</argument>
+      <argument>IL2026</argument>
+      <property name="Scope">member</property>
+      <property name="Target">M:System.Data.ProviderBase.DbMetaDataFactory.#ctor(System.IO.Stream,System.String,System.String)</property>
+    </attribute>
+    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
+      <argument>ILLink</argument>
+      <argument>IL2072</argument>
+      <property name="Scope">member</property>
+      <property name="Target">M:System.Data.ProviderBase.DbMetaDataFactory.ExecuteCommand(System.Data.DataRow,System.String[],System.Data.Common.DbConnection)</property>
+    </attribute>
+    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
+      <argument>ILLink</argument>
+      <argument>IL2026</argument>
+      <property name="Scope">member</property>
+      <property name="Target">M:System.Data.Odbc.OdbcDataAdapter.#ctor()</property>
+    </attribute>
+    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
+      <argument>ILLink</argument>
+      <argument>IL2026</argument>
+      <property name="Scope">member</property>
+      <property name="Target">M:System.Data.Odbc.OdbcDataAdapter.#ctor(System.String,System.String)</property>
+    </attribute>
+    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
+      <argument>ILLink</argument>
+      <argument>IL2026</argument>
+      <property name="Scope">member</property>
+      <property name="Target">M:System.Data.Odbc.OdbcDataAdapter.#ctor(System.String,System.Data.Odbc.OdbcConnection)</property>
+    </attribute>
+    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
+      <argument>ILLink</argument>
+      <argument>IL2026</argument>
+      <property name="Scope">member</property>
+      <property name="Target">M:System.Data.Odbc.OdbcDataAdapter.#ctor(System.Data.Odbc.OdbcCommand)</property>
+    </attribute>
+    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
+      <argument>ILLink</argument>
+      <argument>IL2026</argument>
+      <property name="Scope">member</property>
+      <property name="Target">M:System.Data.Odbc.OdbcDataAdapter.#ctor(System.Data.Odbc.OdbcDataAdapter)</property>
+    </attribute>
+    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
+      <argument>ILLink</argument>
+      <argument>IL2072</argument>
+      <property name="Scope">member</property>
+      <property name="Target">M:System.Data.Odbc.OdbcMetaDataFactory.NewDataTableFromReader(System.Data.IDataReader,System.Object[]@,System.String)</property>
+    </attribute>
   </assembly>
 </linker>
\ No newline at end of file
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 d6e6bd80456eb9..7a997cf9205c65 100644
--- a/src/libraries/System.Data.Odbc/src/System.Data.Odbc.csproj
+++ b/src/libraries/System.Data.Odbc/src/System.Data.Odbc.csproj
@@ -2,7 +2,6 @@
   <PropertyGroup>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <TargetFrameworks>$(NetCoreAppCurrent)-windows;$(NetCoreAppCurrent)-FreeBSD;$(NetCoreAppCurrent)-illumos;$(NetCoreAppCurrent)-Solaris;$(NetCoreAppCurrent)-Linux;$(NetCoreAppCurrent)-OSX;$(NetCoreAppCurrent)-iOS;$(NetCoreAppCurrent)-tvOS;$(NetCoreAppCurrent);netcoreapp3.1-windows;netcoreapp3.1-FreeBSD;netcoreapp3.1-Linux;netcoreapp3.1-OSX;netcoreapp3.1;netstandard2.0;net461-windows</TargetFrameworks>
-    <ExcludeCurrentNetCoreAppFromPackage>true</ExcludeCurrentNetCoreAppFromPackage>
     <NoWarn>$(NoWarn);CA2249;CA1838</NoWarn>
     <Nullable>enable</Nullable>
   </PropertyGroup>
diff --git a/src/libraries/System.Data.OleDb/ref/System.Data.OleDb.csproj b/src/libraries/System.Data.OleDb/ref/System.Data.OleDb.csproj
index e3202214d8843a..b7a09b249da428 100644
--- a/src/libraries/System.Data.OleDb/ref/System.Data.OleDb.csproj
+++ b/src/libraries/System.Data.OleDb/ref/System.Data.OleDb.csproj
@@ -13,9 +13,14 @@
     <Reference Include="System.Transactions" />
   </ItemGroup>
   <ItemGroup Condition="'$(TargetFramework)' != 'net461'">
-    <ProjectReference Include="..\..\System.IO.FileSystem.AccessControl\ref\System.IO.FileSystem.AccessControl.csproj" />
-    <ProjectReference Include="..\..\System.Security.AccessControl\ref\System.Security.AccessControl.csproj" />
-    <ProjectReference Include="..\..\System.Security.Permissions\ref\System.Security.Permissions.csproj" />
-    <ProjectReference Include="..\..\System.Security.Principal.Windows\ref\System.Security.Principal.Windows.csproj" />
+    <ProjectReference Include="$(LibrariesProjectRoot)System.Security.Permissions\ref\System.Security.Permissions.csproj" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">
+    <PackageReference Include="System.IO.FileSystem.AccessControl" Version="$(SystemIOFileSystemAccessControlVersion)" />
+    <!-- Manually reference the transitive dependency to make NuGet pick the package over the transitive project: https://github.com/NuGet/Home/issues/10368 -->
+    <PackageReference Include="System.Security.Principal.Windows" Version="$(SystemSecurityPrincipalWindowsVersion)" />
+    <PackageReference Include="System.Security.AccessControl" Version="$(SystemSecurityAccessControlVersion)" />
+    <PackageReference Include="System.Memory" Version="$(SystemMemoryVersion)" />
+    <PackageReference Include="System.Numerics.Vectors" Version="$(SystemNumericsVectorsVersion)" />
   </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/src/libraries/System.Data.OleDb/src/ILLink/ILLink.Suppressions.xml b/src/libraries/System.Data.OleDb/src/ILLink/ILLink.Suppressions.xml
index a177940c6f5fa5..2e52a33c8a98ed 100644
--- a/src/libraries/System.Data.OleDb/src/ILLink/ILLink.Suppressions.xml
+++ b/src/libraries/System.Data.OleDb/src/ILLink/ILLink.Suppressions.xml
@@ -19,5 +19,59 @@
       <property name="Scope">member</property>
       <property name="Target">M:System.Data.OleDb.OleDbConnectionInternal.CreateInstanceDataLinks</property>
     </attribute>
+    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
+      <argument>ILLink</argument>
+      <argument>IL2026</argument>
+      <property name="Scope">member</property>
+      <property name="Target">M:System.Data.ProviderBase.DbMetaDataFactory.#ctor(System.IO.Stream,System.String,System.String)</property>
+    </attribute>
+    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
+      <argument>ILLink</argument>
+      <argument>IL2072</argument>
+      <property name="Scope">member</property>
+      <property name="Target">M:System.Data.ProviderBase.DbMetaDataFactory.ExecuteCommand(System.Data.DataRow,System.String[],System.Data.Common.DbConnection)</property>
+    </attribute>
+    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
+      <argument>ILLink</argument>
+      <argument>IL2026</argument>
+      <property name="Scope">member</property>
+      <property name="Target">M:System.Data.OleDb.OleDbCommandBuilder.DeriveParametersFromStoredProcedure(System.Data.OleDb.OleDbConnection,System.Data.OleDb.OleDbCommand)</property>
+    </attribute>
+    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
+      <argument>ILLink</argument>
+      <argument>IL2026</argument>
+      <property name="Scope">member</property>
+      <property name="Target">M:System.Data.OleDb.OleDbDataAdapter.#ctor()</property>
+    </attribute>
+    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
+      <argument>ILLink</argument>
+      <argument>IL2026</argument>
+      <property name="Scope">member</property>
+      <property name="Target">M:System.Data.OleDb.OleDbDataAdapter.#ctor(System.String,System.String)</property>
+    </attribute>
+    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
+      <argument>ILLink</argument>
+      <argument>IL2026</argument>
+      <property name="Scope">member</property>
+      <property name="Target">M:System.Data.OleDb.OleDbDataAdapter.#ctor(System.String,System.Data.OleDb.OleDbConnection)</property>
+    </attribute>
+    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
+      <argument>ILLink</argument>
+      <argument>IL2026</argument>
+      <property name="Scope">member</property>
+      <property name="Target">M:System.Data.OleDb.OleDbDataAdapter.#ctor(System.Data.OleDb.OleDbCommand)</property>
+    </attribute>
+    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
+      <argument>ILLink</argument>
+      <argument>IL2026</argument>
+      <property name="Scope">member</property>
+      <property name="Target">M:System.Data.OleDb.OleDbDataAdapter.#ctor(System.Data.OleDb.OleDbDataAdapter)</property>
+    </attribute>
+    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
+      <argument>ILLink</argument>
+      <argument>IL2026</argument>
+      <property name="Scope">member</property>
+      <property name="Target">M:System.Data.OleDb.OleDbMetaDataFactory.GetDataSourceInformationTable(System.Data.OleDb.OleDbConnection,System.Data.OleDb.OleDbConnectionInternal)</property>
+    </attribute>
   </assembly>
 </linker>
\ No newline at end of file
diff --git a/src/libraries/System.Data.OleDb/src/System.Data.OleDb.csproj b/src/libraries/System.Data.OleDb/src/System.Data.OleDb.csproj
index 16505436d47f13..4140b529697a18 100644
--- a/src/libraries/System.Data.OleDb/src/System.Data.OleDb.csproj
+++ b/src/libraries/System.Data.OleDb/src/System.Data.OleDb.csproj
@@ -7,11 +7,11 @@
   </PropertyGroup>
   <!-- DesignTimeBuild requires all the TargetFramework Derived Properties to not be present in the first property group. -->
   <PropertyGroup>
-    <IsPartialFacadeAssembly Condition="$(TargetFramework.StartsWith('net4'))">true</IsPartialFacadeAssembly>
-    <GeneratePlatformNotSupportedAssemblyMessage Condition="'$(TargetsAnyOS)' == 'true' and $(TargetFramework.StartsWith('netstandard'))">SR.PlatformNotSupported_OleDb</GeneratePlatformNotSupportedAssemblyMessage>
-    <NoWarn Condition="'$(TargetsAnyOS)' == 'true' and $(TargetFramework.StartsWith('netstandard'))">$(NoWarn);CS0618</NoWarn>  
+    <IsPartialFacadeAssembly Condition="$([MSBuild]::GetTargetFrameworkIdentifier('$(TargetFramework)')) == '.NETFramework'">true</IsPartialFacadeAssembly>
+    <GeneratePlatformNotSupportedAssemblyMessage Condition="'$(IsPartialFacadeAssembly)' != 'true' and '$(TargetsWindows)' != 'true'">SR.PlatformNotSupported_OleDb</GeneratePlatformNotSupportedAssemblyMessage>
+    <NoWarn Condition="'$(GeneratePlatformNotSupportedAssemblyMessage)' != ''">$(NoWarn);CS0618</NoWarn>  
   </PropertyGroup>
-  <ItemGroup Condition="!$(TargetFramework.StartsWith('net4')) and '$(TargetsWindows)' == 'true'">
+  <ItemGroup Condition="'$(IsPartialFacadeAssembly)' != 'true' and '$(TargetsWindows)' == 'true'">
     <Compile Include="$(CommonPath)Interop\Windows\Interop.Libraries.cs"
              Link="Common\Interop\Windows\Interop.Libraries.cs" />
     <Compile Include="$(CommonPath)System\Data\Common\MultipartIdentifier.cs"
@@ -96,12 +96,14 @@
       <LogicalName>System.Data.OleDb.OleDbMetaData.xml</LogicalName>
     </EmbeddedResource>
   </ItemGroup>
-  <ItemGroup Condition="$(TargetFramework.StartsWith('netstandard'))">
+  <ItemGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETStandard'">
+    <PackageReference Include="Microsoft.Win32.Registry" Version="$(MicrosoftWin32RegistryVersion)" />
+    <PackageReference Include="System.Security.Principal.Windows" Version="$(SystemSecurityPrincipalWindowsVersion)" />
     <PackageReference Include="System.Memory" Version="$(SystemMemoryVersion)" />
-    <ProjectReference Include="$(LibrariesProjectRoot)Microsoft.Win32.Registry\src\Microsoft.Win32.Registry.csproj" />
+    <!-- Manually reference the transitive dependency to make NuGet pick the package over the transitive project: https://github.com/NuGet/Home/issues/10368 -->
+    <PackageReference Include="System.Security.AccessControl" Version="$(SystemSecurityAccessControlVersion)" />
     <ProjectReference Include="$(LibrariesProjectRoot)System.Runtime.CompilerServices.Unsafe\src\System.Runtime.CompilerServices.Unsafe.ilproj" />
     <ProjectReference Include="$(LibrariesProjectRoot)System.Configuration.ConfigurationManager\src\System.Configuration.ConfigurationManager.csproj" />
     <ProjectReference Include="$(LibrariesProjectRoot)System.Diagnostics.PerformanceCounter\src\System.Diagnostics.PerformanceCounter.csproj" />
-    <ProjectReference Include="$(LibrariesProjectRoot)System.Security.Principal.Windows\src\System.Security.Principal.Windows.csproj" />
   </ItemGroup>
 </Project>
diff --git a/src/libraries/System.Diagnostics.DiagnosticSource/ref/System.Diagnostics.DiagnosticSource.csproj b/src/libraries/System.Diagnostics.DiagnosticSource/ref/System.Diagnostics.DiagnosticSource.csproj
index a323120307be3b..11c17335ed8182 100644
--- a/src/libraries/System.Diagnostics.DiagnosticSource/ref/System.Diagnostics.DiagnosticSource.csproj
+++ b/src/libraries/System.Diagnostics.DiagnosticSource/ref/System.Diagnostics.DiagnosticSource.csproj
@@ -1,6 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFrameworks>netstandard2.0;net461</TargetFrameworks>
+    <TargetFrameworks>$(NetCoreAppCurrent);net5.0;netstandard2.0;net461</TargetFrameworks>
     <CLSCompliant>false</CLSCompliant>
     <Nullable>enable</Nullable>
   </PropertyGroup>
@@ -11,12 +11,19 @@
   <ItemGroup>
     <Compile Include="System.Diagnostics.DiagnosticSource.cs" />
     <Compile Include="System.Diagnostics.DiagnosticSourceActivity.cs" />
-    <Compile Include="$(CoreLibSharedDir)System\Diagnostics\CodeAnalysis\RequiresUnreferencedCodeAttribute.cs" />
+    <Compile Include="$(CoreLibSharedDir)System\Diagnostics\CodeAnalysis\RequiresUnreferencedCodeAttribute.cs"
+             Condition="!$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net5.0'))" />
   </ItemGroup>
-  <ItemGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == '$(NetCoreAppCurrent)'">
+    <ProjectReference Include="$(LibrariesProjectRoot)System.Runtime\ref\System.Runtime.csproj" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == 'net5.0'">
+    <Reference Include="System.Runtime" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(TargetFrameworkIdentifier)' != '.NETCoreApp'">
     <PackageReference Include="System.Memory" Version="$(SystemMemoryVersion)" />
   </ItemGroup>
   <ItemGroup Condition="'$(TargetFramework)' == 'net461'">
     <Reference Include="System.Runtime" />
   </ItemGroup>
-</Project>
\ No newline at end of file
+</Project>
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 ff1472fd799cf3..6c8fbb0203c4af 100644
--- a/src/libraries/System.Diagnostics.DiagnosticSource/src/System.Diagnostics.DiagnosticSource.csproj
+++ b/src/libraries/System.Diagnostics.DiagnosticSource/src/System.Diagnostics.DiagnosticSource.csproj
@@ -5,7 +5,6 @@
     <NoWarn>$(NoWarn);SA1205;CA1845</NoWarn>
     <Nullable>enable</Nullable>
     <TargetFrameworks>$(NetCoreAppCurrent);net5.0;netstandard2.0;net461</TargetFrameworks>
-    <ExcludeCurrentNetCoreAppFromPackage>true</ExcludeCurrentNetCoreAppFromPackage>
   </PropertyGroup>
   <!-- DesignTimeBuild requires all the TargetFramework Derived Properties to not be present in the first property group. -->
   <PropertyGroup>
@@ -18,7 +17,7 @@
     <Compile Include="System\Diagnostics\DiagnosticSourceEventSource.cs" />
     <None Include="DiagnosticSourceUsersGuide.md" />
   </ItemGroup>
-  <ItemGroup Condition="'$(TargetFrameworkIdentifier)' != '.NETCoreApp'">
+  <ItemGroup Condition="!$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net5.0'))">
     <Compile Include="$(CoreLibSharedDir)System\Diagnostics\CodeAnalysis\DynamicDependencyAttribute.cs" />
     <Compile Include="$(CoreLibSharedDir)System\Diagnostics\CodeAnalysis\DynamicallyAccessedMemberTypes.cs" />
     <Compile Include="$(CoreLibSharedDir)System\Diagnostics\CodeAnalysis\RequiresUnreferencedCodeAttribute.cs" />
diff --git a/src/libraries/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/Activity.cs b/src/libraries/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/Activity.cs
index ce695154faa1b2..9a16889b910224 100644
--- a/src/libraries/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/Activity.cs
+++ b/src/libraries/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/Activity.cs
@@ -1491,7 +1491,6 @@ public void Add(KeyValuePair<string, object?> value)
 
             public void Remove(string key)
             {
-
                 lock (this)
                 {
                     if (_first == null)
@@ -1501,6 +1500,10 @@ public void Remove(string key)
                     if (_first.Value.Key == key)
                     {
                         _first = _first.Next;
+                        if (_first is null)
+                        {
+                            _last = null;
+                        }
                         return;
                     }
 
@@ -1510,6 +1513,10 @@ public void Remove(string key)
                     {
                         if (previous.Next.Value.Key == key)
                         {
+                            if (object.ReferenceEquals(_last, previous.Next))
+                            {
+                                _last = previous;
+                            }
                             previous.Next = previous.Next.Next;
                             return;
                         }
diff --git a/src/libraries/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/DiagnosticListener.cs b/src/libraries/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/DiagnosticListener.cs
index cd588e6e49953d..e06a92777d14cb 100644
--- a/src/libraries/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/DiagnosticListener.cs
+++ b/src/libraries/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/DiagnosticListener.cs
@@ -39,12 +39,10 @@ public static IObservable<DiagnosticListener> AllListeners
 #if ENABLE_HTTP_HANDLER
                 GC.KeepAlive(HttpHandlerDiagnosticListener.s_instance);
 #endif
-
-                if (s_allListenerObservable == null)
-                {
-                    s_allListenerObservable = new AllListenerObservable();
-                }
-                return s_allListenerObservable;
+                return
+                    s_allListenerObservable ??
+                    Interlocked.CompareExchange(ref s_allListenerObservable, new AllListenerObservable(), null) ??
+                    s_allListenerObservable;
             }
         }
 
@@ -137,9 +135,7 @@ public DiagnosticListener(string name)
             lock (s_allListenersLock)
             {
                 // Issue the callback for this new diagnostic listener.
-                var allListenerObservable = s_allListenerObservable;
-                if (allListenerObservable != null)
-                    allListenerObservable.OnNewDiagnosticListener(this);
+                s_allListenerObservable?.OnNewDiagnosticListener(this);
 
                 // And add it to the list of all past listeners.
                 _next = s_allListeners;
@@ -460,7 +456,7 @@ private IDisposable SubscribeInternal(IObserver<KeyValuePair<string, object?>> o
         private bool _disposed;                        // Has Dispose been called?
 
         private static DiagnosticListener? s_allListeners;               // linked list of all instances of DiagnosticListeners.
-        private static AllListenerObservable? s_allListenerObservable;   // to make callbacks to this object when listeners come into existence.
+        private static volatile AllListenerObservable? s_allListenerObservable;   // to make callbacks to this object when listeners come into existence.
         private static readonly object s_allListenersLock = new object();
 #if false
         private static readonly DiagnosticListener s_default = new DiagnosticListener("DiagnosticListener.DefaultListener");
diff --git a/src/libraries/System.Diagnostics.DiagnosticSource/tests/ActivityTests.cs b/src/libraries/System.Diagnostics.DiagnosticSource/tests/ActivityTests.cs
index ed7e2f82101c95..2ac5efa2d9fad5 100644
--- a/src/libraries/System.Diagnostics.DiagnosticSource/tests/ActivityTests.cs
+++ b/src/libraries/System.Diagnostics.DiagnosticSource/tests/ActivityTests.cs
@@ -1547,7 +1547,6 @@ public void TestIsAllDataRequested()
         }
 
         [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
         public void TestTagObjects()
         {
             Activity activity = new Activity("TagObjects");
@@ -1605,10 +1604,39 @@ public void TestTagObjects()
                 Assert.Equal(tags[i].Key, tagObjects[i].Key);
                 Assert.Equal(tags[i].Value, tagObjects[i].Value);
             }
+
+            // Test Deleting last tag
+            activity = new Activity("LastTagObjects");
+
+            activity.SetTag("hello1", "1");
+            activity.SetTag("hello2", "1");
+            activity.SetTag("hello2", null); // last tag get deleted
+            activity.SetTag("hello3", "2");
+            activity.SetTag("hello4", "3");
+
+            tagObjects = activity.TagObjects.ToArray();
+            Assert.Equal(3, tagObjects.Length);
+            Assert.Equal("hello1", tagObjects[0].Key);
+            Assert.Equal("1", tagObjects[0].Value);
+            Assert.Equal("hello3", tagObjects[1].Key);
+            Assert.Equal("2", tagObjects[1].Value);
+            Assert.Equal("hello4", tagObjects[2].Key);
+            Assert.Equal("3", tagObjects[2].Value);
+
+            activity = new Activity("FirstLastTagObjects");
+            activity.SetTag("hello1", "1");
+            activity.SetTag("hello1", null); // Delete the first and last tag
+            activity.SetTag("hello2", "2");
+            activity.SetTag("hello3", "3");
+            tagObjects = activity.TagObjects.ToArray();
+            Assert.Equal(2, tagObjects.Length);
+            Assert.Equal("hello2", tagObjects[0].Key);
+            Assert.Equal("2", tagObjects[0].Value);
+            Assert.Equal("hello3", tagObjects[1].Key);
+            Assert.Equal("3", tagObjects[1].Value);
         }
 
         [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
         public void TestGetTagItem()
         {
             Activity a = new Activity("GetTagItem");
diff --git a/src/libraries/System.Diagnostics.EventLog/ref/System.Diagnostics.EventLog.csproj b/src/libraries/System.Diagnostics.EventLog/ref/System.Diagnostics.EventLog.csproj
index 2d78eb78addf9e..2631550443e3a7 100644
--- a/src/libraries/System.Diagnostics.EventLog/ref/System.Diagnostics.EventLog.csproj
+++ b/src/libraries/System.Diagnostics.EventLog/ref/System.Diagnostics.EventLog.csproj
@@ -1,13 +1,22 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFrameworks>netstandard2.0;net461</TargetFrameworks>
+    <TargetFrameworks>$(NetCoreAppCurrent);netcoreapp3.1;netstandard2.0;net461</TargetFrameworks>
   </PropertyGroup>
   <ItemGroup>
     <Compile Condition="'$(TargetFramework)' != 'net461'" Include="System.Diagnostics.EventLog.cs" />
     <Compile Condition="'$(TargetFramework)' == 'net461'" Include="System.Diagnostics.EventLog.net461.cs" />
   </ItemGroup>
   <ItemGroup Condition="'$(TargetFramework)' != 'net461'">
-    <ProjectReference Include="..\..\System.Security.Permissions\ref\System.Security.Permissions.csproj" />
-    <ProjectReference Include="..\..\System.Security.Principal.Windows\ref\System.Security.Principal.Windows.csproj" />
+    <ProjectReference Include="$(LibrariesProjectRoot)System.Security.Permissions\ref\System.Security.Permissions.csproj" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == '$(NetCoreAppCurrent)'">
+    <ProjectReference Include="$(LibrariesProjectRoot)System.Diagnostics.TraceSource\src\System.Diagnostics.TraceSource.csproj" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == 'netcoreapp3.1'">
+    <Reference Include="System.ComponentModel.Primitives" />
+    <Reference Include="System.ComponentModel.TypeConverter" />
+    <Reference Include="System.Diagnostics.TraceSource" />
+    <Reference Include="System.Runtime" />
+    <Reference Include="System.Runtime.InteropServices" />
   </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/src/libraries/System.Diagnostics.EventLog/src/System.Diagnostics.EventLog.csproj b/src/libraries/System.Diagnostics.EventLog/src/System.Diagnostics.EventLog.csproj
index 79220464303ad7..a093eb35ac7fb6 100644
--- a/src/libraries/System.Diagnostics.EventLog/src/System.Diagnostics.EventLog.csproj
+++ b/src/libraries/System.Diagnostics.EventLog/src/System.Diagnostics.EventLog.csproj
@@ -1,14 +1,13 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <TargetFrameworks>$(NetCoreAppCurrent)-windows;netcoreapp3.1-windows;net461;netstandard2.0</TargetFrameworks>
-    <ExcludeCurrentNetCoreAppFromPackage>true</ExcludeCurrentNetCoreAppFromPackage>
-    <NoWarn>$(NoWarn);CA1838</NoWarn>
+    <TargetFrameworks>$(NetCoreAppCurrent)-windows;$(NetCoreAppCurrent);netcoreapp3.1-windows;netcoreapp3.1;netstandard2.0;net461</TargetFrameworks>
+    <NoWarn>$(NoWarn);CA1838;CA1847</NoWarn>
   </PropertyGroup>
   <!-- DesignTimeBuild requires all the TargetFramework Derived Properties to not be present in the first property group. -->
   <PropertyGroup>
-    <IsPartialFacadeAssembly Condition="$(TargetFramework.StartsWith('net4'))">true</IsPartialFacadeAssembly>
-    <GeneratePlatformNotSupportedAssemblyMessage Condition="'$(TargetFramework)' == 'netstandard2.0'">SR.PlatformNotSupported_EventLog</GeneratePlatformNotSupportedAssemblyMessage>
+    <IsPartialFacadeAssembly Condition="'$(TargetFramework)' == 'net461'">true</IsPartialFacadeAssembly>
+    <GeneratePlatformNotSupportedAssemblyMessage Condition="'$(IsPartialFacadeAssembly)' != 'true' and '$(TargetsWindows)' != 'true'">SR.PlatformNotSupported_EventLog</GeneratePlatformNotSupportedAssemblyMessage>
   </PropertyGroup>
   <ItemGroup Condition="'$(TargetsWindows)' == 'true'">
     <Compile Include="System\Diagnostics\EntryWrittenEventArgs.cs" />
@@ -104,13 +103,15 @@
     <Compile Include="$(CoreLibSharedDir)System\Diagnostics\CodeAnalysis\DynamicallyAccessedMemberTypes.cs" />
     <Compile Include="$(CoreLibSharedDir)System\Diagnostics\CodeAnalysis\UnconditionalSuppressMessageAttribute.cs" />
   </ItemGroup>
-  <ItemGroup Condition="'$(TargetFrameworkIdentifier)' != '.NETFramework'">
-    <ProjectReference Include="$(LibrariesProjectRoot)System.Security.Principal.Windows\src\System.Security.Principal.Windows.csproj" />
+  <ItemGroup Condition="'$(IsPartialFacadeAssembly)' != 'true' and !$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net6.0'))">
+    <PackageReference Include="System.Security.Principal.Windows" Version="$(SystemSecurityPrincipalWindowsVersion)" />
   </ItemGroup>
   <ItemGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp'">
-    <ProjectReference Include="$(LibrariesProjectRoot)Microsoft.Win32.Registry\src\Microsoft.Win32.Registry.csproj" />
+    <PackageReference Include="Microsoft.Win32.Registry" Version="$(MicrosoftWin32RegistryVersion)" Condition="!$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net6.0'))" />
     <ProjectReference Include="$(LibrariesProjectRoot)System.Threading.AccessControl\src\System.Threading.AccessControl.csproj" />
+    <Reference Include="netstandard" Condition="$(TargetFramework.StartsWith('netcoreapp3.1'))" />
     <Reference Include="Microsoft.Win32.Primitives" />
+    <Reference Include="Microsoft.Win32.Registry" Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net6.0'))" />
     <Reference Include="System.Collections" />
     <Reference Include="System.Collections.Specialized" />
     <Reference Include="System.ComponentModel" />
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 dd9d4370bcbdbc..b01b83e73273ff 100644
--- a/src/libraries/System.Diagnostics.PerformanceCounter/ref/System.Diagnostics.PerformanceCounter.csproj
+++ b/src/libraries/System.Diagnostics.PerformanceCounter/ref/System.Diagnostics.PerformanceCounter.csproj
@@ -1,10 +1,21 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFrameworks>netstandard2.0;net461</TargetFrameworks>
+    <TargetFrameworks>$(NetCoreAppCurrent);netcoreapp3.1;netstandard2.0;net461</TargetFrameworks>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
   <ItemGroup>
     <Compile Condition="'$(TargetFramework)' != 'net461'" Include="System.Diagnostics.PerformanceCounter.cs" />
     <Compile Condition="'$(TargetFramework)' == 'net461'" Include="System.Diagnostics.PerformanceCounter.net461.cs" />
   </ItemGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == '$(NetCoreAppCurrent)'">
+    <ProjectReference Include="$(LibrariesProjectRoot)System.Collections.NonGeneric\ref\System.Collections.NonGeneric.csproj" />
+    <ProjectReference Include="$(LibrariesProjectRoot)System.ComponentModel.Primitives\ref\System.ComponentModel.Primitives.csproj" />
+    <ProjectReference Include="$(LibrariesProjectRoot)System.Runtime.InteropServices\ref\System.Runtime.InteropServices.csproj" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == 'netcoreapp3.1'">
+    <Reference Include="System.Collections.NonGeneric" />
+    <Reference Include="System.ComponentModel.Primitives" />
+    <Reference Include="System.Runtime" />
+    <Reference Include="System.Runtime.InteropServices" />
+  </ItemGroup>
 </Project>
\ No newline at end of file
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 317c566411f6d7..600f6fc58b993a 100644
--- a/src/libraries/System.Diagnostics.PerformanceCounter/src/System.Diagnostics.PerformanceCounter.csproj
+++ b/src/libraries/System.Diagnostics.PerformanceCounter/src/System.Diagnostics.PerformanceCounter.csproj
@@ -1,15 +1,15 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <TargetFrameworks>$(NetCoreAppCurrent)-windows;netcoreapp3.1-windows;netstandard2.0;net461</TargetFrameworks>
-    <ExcludeCurrentNetCoreAppFromPackage>true</ExcludeCurrentNetCoreAppFromPackage>
+    <TargetFrameworks>$(NetCoreAppCurrent)-windows;$(NetCoreAppCurrent);netcoreapp3.1-windows;netcoreapp3.1;netstandard2.0;net461</TargetFrameworks>
+    <NoWarn>$(NoWarn);CA1847</NoWarn>
   </PropertyGroup>
   <!-- DesignTimeBuild requires all the TargetFramework Derived Properties to not be present in the first property group. -->
   <PropertyGroup>
     <IsPartialFacadeAssembly Condition="'$(TargetFramework)' == 'net461'">true</IsPartialFacadeAssembly>
-    <GeneratePlatformNotSupportedAssemblyMessage Condition="'$(TargetFramework)' == 'netstandard2.0'">SR.PlatformNotSupported_PerfCounters</GeneratePlatformNotSupportedAssemblyMessage>
+    <GeneratePlatformNotSupportedAssemblyMessage Condition="'$(IsPartialFacadeAssembly)' != 'true' and '$(TargetsWindows)' != 'true'">SR.PlatformNotSupported_PerfCounters</GeneratePlatformNotSupportedAssemblyMessage>
   </PropertyGroup>
-  <ItemGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp'">
+  <ItemGroup Condition="'$(TargetsWindows)' == 'true'">
     <Compile Include="System\Diagnostics\DiagnosticsConfiguration.cs" />
     <Compile Include="System\Diagnostics\CounterCreationData.cs" />
     <Compile Include="System\Diagnostics\CounterCreationDataCollection.cs" />
@@ -122,10 +122,12 @@
              Link="Common\System\Diagnostics\NetFrameworkUtils.cs" />
   </ItemGroup>
   <ItemGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp'">
-    <ProjectReference Include="$(LibrariesProjectRoot)Microsoft.Win32.Registry\src\Microsoft.Win32.Registry.csproj" />
+    <PackageReference Include="Microsoft.Win32.Registry" Version="$(MicrosoftWin32RegistryVersion)" Condition="!$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net6.0'))" />
+    <PackageReference Include="System.Security.Principal.Windows" Version="$(SystemSecurityPrincipalWindowsVersion)" Condition="!$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net6.0'))" />
     <ProjectReference Include="$(LibrariesProjectRoot)System.Configuration.ConfigurationManager\src\System.Configuration.ConfigurationManager.csproj" />
-    <ProjectReference Include="$(LibrariesProjectRoot)System.Security.Principal.Windows\src\System.Security.Principal.Windows.csproj" />
+    <Reference Include="netstandard" Condition="$(TargetFramework.StartsWith('netcoreapp3.1'))" />
     <Reference Include="Microsoft.Win32.Primitives" />
+    <Reference Include="Microsoft.Win32.Registry" Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net6.0'))" />
     <Reference Include="System.Buffers" />
     <Reference Include="System.Collections" />
     <Reference Include="System.Collections.NonGeneric" />
@@ -143,6 +145,7 @@
     <Reference Include="System.Runtime.InteropServices" />
     <Reference Include="System.Security.Claims" />
     <Reference Include="System.Security.Principal" />
+    <Reference Include="System.Security.Principal.Windows" Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net6.0'))" />
     <Reference Include="System.Threading" />
     <Reference Include="System.Threading.Thread" />
   </ItemGroup>
diff --git a/src/libraries/System.Diagnostics.Process/src/System.Diagnostics.Process.csproj b/src/libraries/System.Diagnostics.Process/src/System.Diagnostics.Process.csproj
index f0c7d8eb136bf8..cdd65c22c44315 100644
--- a/src/libraries/System.Diagnostics.Process/src/System.Diagnostics.Process.csproj
+++ b/src/libraries/System.Diagnostics.Process/src/System.Diagnostics.Process.csproj
@@ -10,6 +10,9 @@
   <PropertyGroup>
     <GeneratePlatformNotSupportedAssemblyMessage Condition="'$(TargetsAnyOS)' == 'true'">SR.Process_PlatformNotSupported</GeneratePlatformNotSupportedAssemblyMessage>
   </PropertyGroup>
+  <PropertyGroup>
+    <IsiOSLike Condition="'$(TargetsMacCatalyst)' == 'true' or '$(TargetsiOS)' == 'true' or '$(TargetstvOS)' == 'true'">true</IsiOSLike>
+  </PropertyGroup>  
   <ItemGroup Condition="'$(TargetsAnyOS)' != 'true'">
     <Compile Include="Microsoft\Win32\SafeHandles\SafeProcessHandle.cs" />
     <Compile Include="System\Collections\Specialized\DictionaryWrapper.cs" />
@@ -234,8 +237,6 @@
              Link="Common\Interop\Unix\Interop.GetHostName.cs" />
     <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.SysConf.cs"
              Link="Common\Interop\Unix\Interop.SysConf.cs" />
-    <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.ConfigureTerminalForChildProcess.cs"
-             Link="Common\Interop\Unix\Interop.ConfigureTerminalForChildProcess.cs" />
     <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.ForkAndExecProcess.cs"
              Link="Common\Interop\Unix\Interop.ForkAndExecProcess.cs" />
     <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.GetGroupList.cs"
@@ -267,6 +268,11 @@
     <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.Access.cs"
              Link="Common\Interop\Unix\System.Native\Interop.Access.cs" />
   </ItemGroup>
+  <ItemGroup Condition=" '$(TargetsUnix)' == 'true' and '$(IsiOSLike)' != 'true'">
+    <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.ConfigureTerminalForChildProcess.cs"
+             Link="Common\Interop\Unix\Interop.ConfigureTerminalForChildProcess.cs" />
+    <Compile Include="System\Diagnostics\Process.Unix.ConfigureTerminalForChildProcesses.cs" />
+  </ItemGroup>
   <ItemGroup Condition=" '$(TargetsLinux)' == 'true'">
     <Compile Include="System\Diagnostics\Process.Linux.cs" />
     <Compile Include="System\Diagnostics\ProcessManager.Linux.cs" />
diff --git a/src/libraries/System.Diagnostics.Process/src/System/Diagnostics/Process.Unix.ConfigureTerminalForChildProcesses.cs b/src/libraries/System.Diagnostics.Process/src/System/Diagnostics/Process.Unix.ConfigureTerminalForChildProcesses.cs
new file mode 100644
index 00000000000000..6f84319b0c096c
--- /dev/null
+++ b/src/libraries/System.Diagnostics.Process/src/System/Diagnostics/Process.Unix.ConfigureTerminalForChildProcesses.cs
@@ -0,0 +1,36 @@
+// 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;
+
+namespace System.Diagnostics
+{
+    public partial class Process
+    {
+        private static int s_childrenUsingTerminalCount;
+
+        static partial void ConfigureTerminalForChildProcessesInner(int increment)
+        {
+            Debug.Assert(increment != 0);
+
+            int childrenUsingTerminalRemaining = Interlocked.Add(ref s_childrenUsingTerminalCount, increment);
+            if (increment > 0)
+            {
+                Debug.Assert(s_processStartLock.IsReadLockHeld);
+
+                // At least one child is using the terminal.
+                Interop.Sys.ConfigureTerminalForChildProcess(childUsesTerminal: true);
+            }
+            else
+            {
+                Debug.Assert(s_processStartLock.IsWriteLockHeld);
+
+                if (childrenUsingTerminalRemaining == 0)
+                {
+                    // No more children are using the terminal.
+                    Interop.Sys.ConfigureTerminalForChildProcess(childUsesTerminal: false);
+                }
+            }
+        }
+    }
+}
diff --git a/src/libraries/System.Diagnostics.Process/src/System/Diagnostics/Process.Unix.cs b/src/libraries/System.Diagnostics.Process/src/System/Diagnostics/Process.Unix.cs
index 0894dd9e6f7a01..1b52e4d141ebb2 100644
--- a/src/libraries/System.Diagnostics.Process/src/System/Diagnostics/Process.Unix.cs
+++ b/src/libraries/System.Diagnostics.Process/src/System/Diagnostics/Process.Unix.cs
@@ -19,7 +19,6 @@ public partial class Process : IDisposable
         private static volatile bool s_initialized;
         private static readonly object s_initializedGate = new object();
         private static readonly ReaderWriterLockSlim s_processStartLock = new ReaderWriterLockSlim();
-        private static int s_childrenUsingTerminalCount;
 
         /// <summary>
         /// Puts a Process component in state to interact with operating system processes that run in a
@@ -1051,26 +1050,9 @@ private static void OnSigChild(int reapAll)
         /// </summary>
         internal static void ConfigureTerminalForChildProcesses(int increment)
         {
-            Debug.Assert(increment != 0);
-
-            int childrenUsingTerminalRemaining = Interlocked.Add(ref s_childrenUsingTerminalCount, increment);
-            if (increment > 0)
-            {
-                Debug.Assert(s_processStartLock.IsReadLockHeld);
-
-                // At least one child is using the terminal.
-                Interop.Sys.ConfigureTerminalForChildProcess(childUsesTerminal: true);
-            }
-            else
-            {
-                Debug.Assert(s_processStartLock.IsWriteLockHeld);
-
-                if (childrenUsingTerminalRemaining == 0)
-                {
-                    // No more children are using the terminal.
-                    Interop.Sys.ConfigureTerminalForChildProcess(childUsesTerminal: false);
-                }
-            }
+            ConfigureTerminalForChildProcessesInner(increment);
         }
+
+        static partial void ConfigureTerminalForChildProcessesInner(int increment);
     }
 }
diff --git a/src/libraries/System.Diagnostics.Process/src/System/Diagnostics/ProcessManager.Win32.cs b/src/libraries/System.Diagnostics.Process/src/System/Diagnostics/ProcessManager.Win32.cs
index 53c9c743de856c..e272d5fa4af1f8 100644
--- a/src/libraries/System.Diagnostics.Process/src/System/Diagnostics/ProcessManager.Win32.cs
+++ b/src/libraries/System.Diagnostics.Process/src/System/Diagnostics/ProcessManager.Win32.cs
@@ -42,7 +42,7 @@ public static unsafe IntPtr FindMainWindow(int processId)
 
         private static bool IsMainWindow(IntPtr handle)
         {
-            return (Interop.User32.GetWindow(handle, GW_OWNER) == IntPtr.Zero) && Interop.User32.IsWindowVisible(handle);
+            return (Interop.User32.GetWindow(handle, GW_OWNER) == IntPtr.Zero) && Interop.User32.IsWindowVisible(handle) != Interop.BOOL.FALSE;
         }
 
         [UnmanagedCallersOnly]
@@ -51,7 +51,7 @@ private static unsafe Interop.BOOL EnumWindowsCallback(IntPtr handle, IntPtr ext
             MainWindowFinder* instance = (MainWindowFinder*)extraParameter;
 
             int processId = 0; // Avoid uninitialized variable if the window got closed in the meantime
-            Interop.User32.GetWindowThreadProcessId(handle, out processId);
+            Interop.User32.GetWindowThreadProcessId(handle, &processId);
 
             if ((processId == instance->_processId) && IsMainWindow(handle))
             {
diff --git a/src/libraries/System.Diagnostics.Process/tests/ProcessCollectionTests.cs b/src/libraries/System.Diagnostics.Process/tests/ProcessCollectionTests.cs
index 90acc19d048d76..3ac20166921f30 100644
--- a/src/libraries/System.Diagnostics.Process/tests/ProcessCollectionTests.cs
+++ b/src/libraries/System.Diagnostics.Process/tests/ProcessCollectionTests.cs
@@ -8,7 +8,6 @@
 
 namespace System.Diagnostics.Tests
 {
-    [ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
     public class ProcessCollectionTests : ProcessTestBase
     {
         [Fact]
diff --git a/src/libraries/System.Diagnostics.Process/tests/ProcessModuleTests.cs b/src/libraries/System.Diagnostics.Process/tests/ProcessModuleTests.cs
index e127633db8c364..2631cb8b1a3dcb 100644
--- a/src/libraries/System.Diagnostics.Process/tests/ProcessModuleTests.cs
+++ b/src/libraries/System.Diagnostics.Process/tests/ProcessModuleTests.cs
@@ -72,7 +72,6 @@ public ModuleCollectionSubClass() : base() { }
         }
 
         [ConditionalFact(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
         public void ModulesAreDisposedWhenProcessIsDisposed()
         {
             Process process = CreateDefaultProcess();
diff --git a/src/libraries/System.Diagnostics.Process/tests/ProcessStartInfoTests.cs b/src/libraries/System.Diagnostics.Process/tests/ProcessStartInfoTests.cs
index 1ffe9f0f24ca47..b061bf43d54afa 100644
--- a/src/libraries/System.Diagnostics.Process/tests/ProcessStartInfoTests.cs
+++ b/src/libraries/System.Diagnostics.Process/tests/ProcessStartInfoTests.cs
@@ -22,7 +22,6 @@
 
 namespace System.Diagnostics.Tests
 {
-    [ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
     public class ProcessStartInfoTests : ProcessTestBase
     {
         private const string ItemSeparator = "CAFF9451396B4EEF8A5155A15BDC2080"; // random string that shouldn't be in any env vars; used instead of newline to separate env var strings
diff --git a/src/libraries/System.Diagnostics.Process/tests/ProcessStreamReadTests.cs b/src/libraries/System.Diagnostics.Process/tests/ProcessStreamReadTests.cs
index 2620f965411e0c..3cbab6c843fbe1 100644
--- a/src/libraries/System.Diagnostics.Process/tests/ProcessStreamReadTests.cs
+++ b/src/libraries/System.Diagnostics.Process/tests/ProcessStreamReadTests.cs
@@ -14,7 +14,6 @@
 
 namespace System.Diagnostics.Tests
 {
-    [ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
     public class ProcessStreamReadTests : ProcessTestBase
     {
         [ConditionalFact(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))]
diff --git a/src/libraries/System.Diagnostics.Process/tests/ProcessTests.cs b/src/libraries/System.Diagnostics.Process/tests/ProcessTests.cs
index 47c538af8077f4..9921aac3e947cb 100644
--- a/src/libraries/System.Diagnostics.Process/tests/ProcessTests.cs
+++ b/src/libraries/System.Diagnostics.Process/tests/ProcessTests.cs
@@ -21,7 +21,6 @@
 
 namespace System.Diagnostics.Tests
 {
-    [ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
     public partial class ProcessTests : ProcessTestBase
     {
         private class FinalizingProcess : Process
diff --git a/src/libraries/System.Diagnostics.Process/tests/ProcessThreadTests.cs b/src/libraries/System.Diagnostics.Process/tests/ProcessThreadTests.cs
index 46305d91ac8651..2266582ac5190f 100644
--- a/src/libraries/System.Diagnostics.Process/tests/ProcessThreadTests.cs
+++ b/src/libraries/System.Diagnostics.Process/tests/ProcessThreadTests.cs
@@ -10,7 +10,6 @@
 
 namespace System.Diagnostics.Tests
 {
-    [ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
     public partial class ProcessThreadTests : ProcessTestBase
     {
         [ConditionalFact(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))]
diff --git a/src/libraries/System.Diagnostics.Process/tests/ProcessWaitingTests.cs b/src/libraries/System.Diagnostics.Process/tests/ProcessWaitingTests.cs
index 8bd7985a218fd0..5cbd89d5a7705e 100644
--- a/src/libraries/System.Diagnostics.Process/tests/ProcessWaitingTests.cs
+++ b/src/libraries/System.Diagnostics.Process/tests/ProcessWaitingTests.cs
@@ -11,7 +11,6 @@
 
 namespace System.Diagnostics.Tests
 {
-    [ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
     public class ProcessWaitingTests : ProcessTestBase
     {
         [ConditionalFact(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))]
diff --git a/src/libraries/System.DirectoryServices.AccountManagement/ref/System.DirectoryServices.AccountManagement.csproj b/src/libraries/System.DirectoryServices.AccountManagement/ref/System.DirectoryServices.AccountManagement.csproj
index 300e3c2c284393..46061476b9aeae 100644
--- a/src/libraries/System.DirectoryServices.AccountManagement/ref/System.DirectoryServices.AccountManagement.csproj
+++ b/src/libraries/System.DirectoryServices.AccountManagement/ref/System.DirectoryServices.AccountManagement.csproj
@@ -1,11 +1,20 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFrameworks>netstandard2.0</TargetFrameworks>
+    <TargetFrameworks>$(NetCoreAppCurrent);netcoreapp3.1;netstandard2.0</TargetFrameworks>
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="System.DirectoryServices.AccountManagement.cs" />
   </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="..\..\System.Security.Principal.Windows\ref\System.Security.Principal.Windows.csproj" />
+  <ItemGroup Condition="!$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net6.0'))">
+    <PackageReference Include="System.Security.Principal.Windows" Version="$(SystemSecurityPrincipalWindowsVersion)" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == '$(NetCoreAppCurrent)'">
+    <ProjectReference Include="$(LibrariesProjectRoot)System.Security.Cryptography.X509Certificates\ref\System.Security.Cryptography.X509Certificates.csproj" />
+    <ProjectReference Include="$(LibrariesProjectRoot)System.Security.Principal.Windows\ref\System.Security.Principal.Windows.csproj" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == 'netcoreapp3.1'">
+    <Reference Include="System.ComponentModel.Primitives" />
+    <Reference Include="System.Runtime" />
+    <Reference Include="System.Security.Cryptography.X509Certificates" />
   </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/src/libraries/System.DirectoryServices.AccountManagement/src/System.DirectoryServices.AccountManagement.csproj b/src/libraries/System.DirectoryServices.AccountManagement/src/System.DirectoryServices.AccountManagement.csproj
index 5208f0039b8b74..da50980a2a536b 100644
--- a/src/libraries/System.DirectoryServices.AccountManagement/src/System.DirectoryServices.AccountManagement.csproj
+++ b/src/libraries/System.DirectoryServices.AccountManagement/src/System.DirectoryServices.AccountManagement.csproj
@@ -3,15 +3,14 @@
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <DefineConstants>$(DefineConstants);FLAVOR_WHIDBEY;PAPI_AD;PAPI_REGSAM;USE_CTX_CACHE</DefineConstants>
     <IncludeDllSafeSearchPathAttribute>true</IncludeDllSafeSearchPathAttribute>
-    <TargetFrameworks>$(NetCoreAppCurrent)-windows;netcoreapp3.1-windows;netstandard2.0</TargetFrameworks>
-    <ExcludeCurrentNetCoreAppFromPackage>true</ExcludeCurrentNetCoreAppFromPackage>
+    <TargetFrameworks>$(NetCoreAppCurrent)-windows;$(NetCoreAppCurrent);netcoreapp3.1-windows;netcoreapp3.1;netstandard2.0</TargetFrameworks>
     <NoWarn>$(NoWarn);CA2249</NoWarn>
   </PropertyGroup>
   <!-- DesignTimeBuild requires all the TargetFramework Derived Properties to not be present in the first property group. -->
   <PropertyGroup>
-    <GeneratePlatformNotSupportedAssemblyMessage Condition="'$(TargetFramework)' == 'netstandard2.0'">SR.DirectoryServicesAccountManagement_PlatformNotSupported</GeneratePlatformNotSupportedAssemblyMessage>
+    <GeneratePlatformNotSupportedAssemblyMessage Condition="'$(TargetsWindows)' != 'true'">SR.DirectoryServicesAccountManagement_PlatformNotSupported</GeneratePlatformNotSupportedAssemblyMessage>
   </PropertyGroup>
-  <ItemGroup Condition="'$(TargetFramework)' != 'netstandard2.0'">
+  <ItemGroup Condition="'$(TargetsWindows)' == 'true'">
     <Compile Include="System\DirectoryServices\AccountManagement\interopt.cs" />
     <Compile Include="System\DirectoryServices\AccountManagement\PrincipalSearcher.cs" />
     <Compile Include="System\DirectoryServices\AccountManagement\Utils.cs" />
@@ -89,30 +88,34 @@
     <Compile Include="$(CommonPath)Interop\Windows\Advapi32\Interop.LookupAccountSid.cs"
              Link="Common\Interop\Windows\Advapi32\Interop.LookupAccountSid.cs" />
   </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="$(LibrariesProjectRoot)System.Security.Principal.Windows\src\System.Security.Principal.Windows.csproj" />
+  <ItemGroup Condition="!$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net6.0'))">
+    <PackageReference Include="System.Security.Principal.Windows" Version="$(SystemSecurityPrincipalWindowsVersion)" />
   </ItemGroup>
   <ItemGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp'">
+    <PackageReference Include="System.IO.FileSystem.AccessControl" Version="$(SystemIOFileSystemAccessControlVersion)" Condition="!$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net6.0'))" />
+    <PackageReference Include="System.Security.AccessControl" Version="$(SystemSecurityAccessControlVersion)" Condition="!$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net6.0'))" />
     <ProjectReference Include="$(LibrariesProjectRoot)System.Configuration.ConfigurationManager\src\System.Configuration.ConfigurationManager.csproj" />
     <ProjectReference Include="$(LibrariesProjectRoot)System.DirectoryServices\src\System.DirectoryServices.csproj" />
     <ProjectReference Include="$(LibrariesProjectRoot)System.DirectoryServices.Protocols\src\System.DirectoryServices.Protocols.csproj" />
-    <ProjectReference Include="$(LibrariesProjectRoot)System.IO.FileSystem.AccessControl\src\System.IO.FileSystem.AccessControl.csproj" />
-    <ProjectReference Include="$(LibrariesProjectRoot)System.Security.AccessControl\src\System.Security.AccessControl.csproj" />
+    <Reference Include="netstandard" Condition="$(TargetFramework.StartsWith('netcoreapp3.1'))" />
     <Reference Include="Microsoft.Win32.Primitives" />
     <Reference Include="System.Collections" />
     <Reference Include="System.Collections.NonGeneric" />
     <Reference Include="System.Collections.Specialized" />
     <Reference Include="System.ComponentModel.Primitives" />
     <Reference Include="System.Diagnostics.Debug" />
+    <Reference Include="System.IO.FileSystem.AccessControl" Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net6.0'))" />
     <Reference Include="System.Net.Primitives" />
     <Reference Include="System.Net.Security" />
     <Reference Include="System.Resources.ResourceManager" />
     <Reference Include="System.Runtime" />
     <Reference Include="System.Runtime.Extensions" />
     <Reference Include="System.Runtime.InteropServices" />
+    <Reference Include="System.Security.AccessControl" Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net6.0'))" />
     <Reference Include="System.Security.Claims" />
     <Reference Include="System.Security.Cryptography.X509Certificates" />
     <Reference Include="System.Security.Principal" />
+    <Reference Include="System.Security.Principal.Windows" Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net6.0'))" />
     <Reference Include="System.Text.RegularExpressions" />
     <Reference Include="System.Threading" />
     <Reference Include="System.Threading.Thread" />
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 ce5e870eea23c7..1947b66f588821 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
@@ -264,6 +264,10 @@ public bool Validate(string userName, string password)
                             // we don't return false here even if we failed with ERROR_LOGON_FAILURE. We must check Negotiate
                             // because there might be cases in which SSL fails and Negotiate succeeds
                         }
+                        catch (DirectoryOperationException)
+                        {
+                            // see LdapException
+                        }
 
                         BindLdap(networkCredential, defaultContextOptionsNegotiate);
                         _lastBindMethod = AuthMethod.Negotiate;
diff --git a/src/libraries/System.DirectoryServices.Protocols/ref/System.DirectoryServices.Protocols.csproj b/src/libraries/System.DirectoryServices.Protocols/ref/System.DirectoryServices.Protocols.csproj
index c5b64e36ad9cad..7779fa037c4bee 100644
--- a/src/libraries/System.DirectoryServices.Protocols/ref/System.DirectoryServices.Protocols.csproj
+++ b/src/libraries/System.DirectoryServices.Protocols/ref/System.DirectoryServices.Protocols.csproj
@@ -1,11 +1,22 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFrameworks>netstandard2.0</TargetFrameworks>
+    <TargetFrameworks>$(NetCoreAppCurrent);netcoreapp3.1;netstandard2.0</TargetFrameworks>
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="System.DirectoryServices.Protocols.cs" />
   </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="..\..\System.Security.Principal.Windows\ref\System.Security.Principal.Windows.csproj" />
+  <ItemGroup Condition="!$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net6.0'))">
+    <PackageReference Include="System.Security.Principal.Windows" Version="$(SystemSecurityPrincipalWindowsVersion)" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == '$(NetCoreAppCurrent)'">
+    <ProjectReference Include="$(LibrariesProjectRoot)System.Security.Cryptography.X509Certificates\ref\System.Security.Cryptography.X509Certificates.csproj" />
+    <ProjectReference Include="$(LibrariesProjectRoot)System.Security.Principal.Windows\ref\System.Security.Principal.Windows.csproj" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == 'netcoreapp3.1'">
+    <Reference Include="System.Collections.NonGeneric" />
+    <Reference Include="System.Collections.Specialized" />
+    <Reference Include="System.Net.Primitives" />
+    <Reference Include="System.Runtime" />
+    <Reference Include="System.Security.Cryptography.X509Certificates" />
   </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/src/libraries/System.DirectoryServices.Protocols/src/System.DirectoryServices.Protocols.csproj b/src/libraries/System.DirectoryServices.Protocols/src/System.DirectoryServices.Protocols.csproj
index 4eb0455b489a1c..ddd399cfcfd59e 100644
--- a/src/libraries/System.DirectoryServices.Protocols/src/System.DirectoryServices.Protocols.csproj
+++ b/src/libraries/System.DirectoryServices.Protocols/src/System.DirectoryServices.Protocols.csproj
@@ -2,14 +2,13 @@
   <PropertyGroup>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <IncludeDllSafeSearchPathAttribute>true</IncludeDllSafeSearchPathAttribute>
-    <TargetFrameworks>$(NetCoreAppCurrent)-windows;$(NetCoreAppCurrent)-OSX;$(NetCoreAppCurrent)-Linux;netcoreapp3.1-windows;netcoreapp3.1-OSX;netcoreapp3.1-Linux;netstandard2.0</TargetFrameworks>
-    <ExcludeCurrentNetCoreAppFromPackage>true</ExcludeCurrentNetCoreAppFromPackage>
+    <TargetFrameworks>$(NetCoreAppCurrent)-windows;$(NetCoreAppCurrent)-OSX;$(NetCoreAppCurrent)-Linux;$(NetCoreAppCurrent);netcoreapp3.1-windows;netcoreapp3.1-OSX;netcoreapp3.1-Linux;netcoreapp3.1;netstandard2.0</TargetFrameworks>
   </PropertyGroup>
   <!-- DesignTimeBuild requires all the TargetFramework Derived Properties to not be present in the first property group. -->
   <PropertyGroup>
-    <GeneratePlatformNotSupportedAssemblyMessage Condition="'$(TargetFramework)' == 'netstandard2.0'">SR.DirectoryServicesProtocols_PlatformNotSupported</GeneratePlatformNotSupportedAssemblyMessage>
+    <GeneratePlatformNotSupportedAssemblyMessage Condition="'$(TargetsAnyOS)' == 'true'">SR.DirectoryServicesProtocols_PlatformNotSupported</GeneratePlatformNotSupportedAssemblyMessage>
   </PropertyGroup>
-  <ItemGroup Condition="'$(TargetFramework)' != 'netstandard2.0'">
+  <ItemGroup Condition="'$(TargetsAnyOS)' != 'true'">
     <Compile Include="System\DirectoryServices\Protocols\common\AuthTypes.cs" />
     <Compile Include="System\DirectoryServices\Protocols\common\BerConverter.cs" />
     <Compile Include="System\DirectoryServices\Protocols\common\DereferenceAlias.cs" />
@@ -82,8 +81,8 @@
       <Link>Common\Interop\OSX\Interop.Libraries.cs</Link>
     </Compile>
   </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="$(LibrariesProjectRoot)System.Security.Principal.Windows\src\System.Security.Principal.Windows.csproj" />
+  <ItemGroup Condition="!$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net6.0'))">
+    <PackageReference Include="System.Security.Principal.Windows" Version="$(SystemSecurityPrincipalWindowsVersion)" />
   </ItemGroup>
   <ItemGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp'">
     <Reference Include="System.Collections" />
@@ -98,6 +97,8 @@
     <Reference Include="System.Runtime.Extensions" />
     <Reference Include="System.Runtime.InteropServices" />
     <Reference Include="System.Security.Cryptography.X509Certificates" />
+    <Reference Include="System.Security.Principal.Windows"
+               Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net6.0'))" />
     <Reference Include="System.Text.Encoding.Extensions" />
     <Reference Include="System.Threading" />
     <Reference Include="System.Threading.Tasks" />
diff --git a/src/libraries/System.DirectoryServices/ref/System.DirectoryServices.cs b/src/libraries/System.DirectoryServices/ref/System.DirectoryServices.cs
index 3e31f111d0eecd..9d1eb9f1c5fae8 100644
--- a/src/libraries/System.DirectoryServices/ref/System.DirectoryServices.cs
+++ b/src/libraries/System.DirectoryServices/ref/System.DirectoryServices.cs
@@ -419,7 +419,7 @@ internal PropertyCollection() { }
         public void CopyTo(System.DirectoryServices.PropertyValueCollection[] array, int index) { }
         public System.Collections.IDictionaryEnumerator GetEnumerator() { throw null; }
         void System.Collections.ICollection.CopyTo(System.Array array, int index) { }
-        void System.Collections.IDictionary.Add(object key, object value) { }
+        void System.Collections.IDictionary.Add(object key, object? value) { }
         void System.Collections.IDictionary.Clear() { }
         bool System.Collections.IDictionary.Contains(object value) { throw null; }
         void System.Collections.IDictionary.Remove(object key) { }
@@ -707,9 +707,9 @@ public void CopyTo(System.DirectoryServices.ActiveDirectory.ActiveDirectorySchem
         public int IndexOf(System.DirectoryServices.ActiveDirectory.ActiveDirectorySchemaClass schemaClass) { throw null; }
         public void Insert(int index, System.DirectoryServices.ActiveDirectory.ActiveDirectorySchemaClass schemaClass) { }
         protected override void OnClearComplete() { }
-        protected override void OnInsertComplete(int index, object value) { }
-        protected override void OnRemoveComplete(int index, object value) { }
-        protected override void OnSetComplete(int index, object oldValue, object newValue) { }
+        protected override void OnInsertComplete(int index, object? value) { }
+        protected override void OnRemoveComplete(int index, object? value) { }
+        protected override void OnSetComplete(int index, object? oldValue, object? newValue) { }
         protected override void OnValidate(object value) { }
         public void Remove(System.DirectoryServices.ActiveDirectory.ActiveDirectorySchemaClass schemaClass) { }
     }
@@ -754,9 +754,9 @@ public void CopyTo(System.DirectoryServices.ActiveDirectory.ActiveDirectorySchem
         public int IndexOf(System.DirectoryServices.ActiveDirectory.ActiveDirectorySchemaProperty schemaProperty) { throw null; }
         public void Insert(int index, System.DirectoryServices.ActiveDirectory.ActiveDirectorySchemaProperty schemaProperty) { }
         protected override void OnClearComplete() { }
-        protected override void OnInsertComplete(int index, object value) { }
-        protected override void OnRemoveComplete(int index, object value) { }
-        protected override void OnSetComplete(int index, object oldValue, object newValue) { }
+        protected override void OnInsertComplete(int index, object? value) { }
+        protected override void OnRemoveComplete(int index, object? value) { }
+        protected override void OnSetComplete(int index, object? oldValue, object? newValue) { }
         protected override void OnValidate(object value) { }
         public void Remove(System.DirectoryServices.ActiveDirectory.ActiveDirectorySchemaProperty schemaProperty) { }
     }
@@ -811,9 +811,9 @@ public void CopyTo(System.DirectoryServices.ActiveDirectory.ActiveDirectorySite[
         public int IndexOf(System.DirectoryServices.ActiveDirectory.ActiveDirectorySite site) { throw null; }
         public void Insert(int index, System.DirectoryServices.ActiveDirectory.ActiveDirectorySite site) { }
         protected override void OnClearComplete() { }
-        protected override void OnInsertComplete(int index, object value) { }
-        protected override void OnRemoveComplete(int index, object value) { }
-        protected override void OnSetComplete(int index, object oldValue, object newValue) { }
+        protected override void OnInsertComplete(int index, object? value) { }
+        protected override void OnRemoveComplete(int index, object? value) { }
+        protected override void OnSetComplete(int index, object? oldValue, object? newValue) { }
         protected override void OnValidate(object value) { }
         public void Remove(System.DirectoryServices.ActiveDirectory.ActiveDirectorySite site) { }
     }
@@ -868,9 +868,9 @@ public void CopyTo(System.DirectoryServices.ActiveDirectory.ActiveDirectorySiteL
         public int IndexOf(System.DirectoryServices.ActiveDirectory.ActiveDirectorySiteLink link) { throw null; }
         public void Insert(int index, System.DirectoryServices.ActiveDirectory.ActiveDirectorySiteLink link) { }
         protected override void OnClearComplete() { }
-        protected override void OnInsertComplete(int index, object value) { }
-        protected override void OnRemoveComplete(int index, object value) { }
-        protected override void OnSetComplete(int index, object oldValue, object newValue) { }
+        protected override void OnInsertComplete(int index, object? value) { }
+        protected override void OnRemoveComplete(int index, object? value) { }
+        protected override void OnSetComplete(int index, object? oldValue, object? newValue) { }
         protected override void OnValidate(object value) { }
         public void Remove(System.DirectoryServices.ActiveDirectory.ActiveDirectorySiteLink link) { }
     }
@@ -918,9 +918,9 @@ public void CopyTo(System.DirectoryServices.ActiveDirectory.ActiveDirectorySubne
         public void Insert(int index, System.DirectoryServices.ActiveDirectory.ActiveDirectorySubnet subnet) { }
         protected override void OnClear() { }
         protected override void OnClearComplete() { }
-        protected override void OnInsertComplete(int index, object value) { }
-        protected override void OnRemoveComplete(int index, object value) { }
-        protected override void OnSetComplete(int index, object oldValue, object newValue) { }
+        protected override void OnInsertComplete(int index, object? value) { }
+        protected override void OnRemoveComplete(int index, object? value) { }
+        protected override void OnSetComplete(int index, object? oldValue, object? newValue) { }
         protected override void OnValidate(object value) { }
         public void Remove(System.DirectoryServices.ActiveDirectory.ActiveDirectorySubnet subnet) { }
     }
@@ -1138,9 +1138,9 @@ public void CopyTo(System.DirectoryServices.ActiveDirectory.DirectoryServer[] ar
         public void Insert(int index, System.DirectoryServices.ActiveDirectory.DirectoryServer server) { }
         protected override void OnClear() { }
         protected override void OnClearComplete() { }
-        protected override void OnInsertComplete(int index, object value) { }
-        protected override void OnRemoveComplete(int index, object value) { }
-        protected override void OnSetComplete(int index, object oldValue, object newValue) { }
+        protected override void OnInsertComplete(int index, object? value) { }
+        protected override void OnRemoveComplete(int index, object? value) { }
+        protected override void OnSetComplete(int index, object? oldValue, object? newValue) { }
         protected override void OnValidate(object value) { }
         public void Remove(System.DirectoryServices.ActiveDirectory.DirectoryServer server) { }
     }
diff --git a/src/libraries/System.DirectoryServices/ref/System.DirectoryServices.csproj b/src/libraries/System.DirectoryServices/ref/System.DirectoryServices.csproj
index c49656ee622804..af21f39de271b5 100644
--- a/src/libraries/System.DirectoryServices/ref/System.DirectoryServices.csproj
+++ b/src/libraries/System.DirectoryServices/ref/System.DirectoryServices.csproj
@@ -1,6 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFrameworks>netstandard2.0</TargetFrameworks>
+    <TargetFrameworks>$(NetCoreAppCurrent);netcoreapp3.1;netstandard2.0</TargetFrameworks>
     <IncludeInternalObsoleteAttribute>true</IncludeInternalObsoleteAttribute>
     <Nullable>enable</Nullable>
   </PropertyGroup>
@@ -9,9 +9,30 @@
     <Compile Include="System.DirectoryServices.manual.cs" />
   </ItemGroup>
   <ItemGroup>
-    <ProjectReference Include="..\..\System.IO.FileSystem.AccessControl\ref\System.IO.FileSystem.AccessControl.csproj" />
-    <ProjectReference Include="..\..\System.Security.AccessControl\ref\System.Security.AccessControl.csproj" />
-    <ProjectReference Include="..\..\System.Security.Permissions\ref\System.Security.Permissions.csproj" />
-    <ProjectReference Include="..\..\System.Security.Principal.Windows\ref\System.Security.Principal.Windows.csproj" />
+    <ProjectReference Include="$(LibrariesProjectRoot)System.Security.Permissions\ref\System.Security.Permissions.csproj" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == '$(NetCoreAppCurrent)'">
+    <ProjectReference Include="$(LibrariesProjectRoot)System.IO.FileSystem.AccessControl\ref\System.IO.FileSystem.AccessControl.csproj" />
+  </ItemGroup>
+  <ItemGroup Condition="!$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net6.0'))">
+    <PackageReference Include="System.IO.FileSystem.AccessControl" Version="$(SystemIOFileSystemAccessControlVersion)" />
+    <PackageReference Include="System.Security.AccessControl" Version="$(SystemSecurityAccessControlVersion)" />
+    <PackageReference Include="System.Security.Principal.Windows" Version="$(SystemSecurityPrincipalWindowsVersion)" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == 'netcoreapp3.1'">
+    <Reference Include="netstandard" />
+    <Reference Include="System.Collections.NonGeneric" />
+    <Reference Include="System.Collections.Specialized" />
+    <Reference Include="System.ComponentModel.Primitives" />
+    <Reference Include="System.ComponentModel.TypeConverter" />
+    <Reference Include="System.ObjectModel" />
+    <Reference Include="System.Runtime" />
+    <Reference Include="System.Runtime.Extensions" />
+    <Reference Include="System.Runtime.InteropServices" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">
+    <!-- Manually reference the transitive dependency to make NuGet pick the package over the transitive project: https://github.com/NuGet/Home/issues/10368 -->
+    <PackageReference Include="System.Memory" Version="$(SystemMemoryVersion)" />
+    <PackageReference Include="System.Numerics.Vectors" Version="$(SystemNumericsVectorsVersion)" />
   </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/src/libraries/System.DirectoryServices/src/System.DirectoryServices.csproj b/src/libraries/System.DirectoryServices/src/System.DirectoryServices.csproj
index b7e9706b02ca56..4db82d2e78b000 100644
--- a/src/libraries/System.DirectoryServices/src/System.DirectoryServices.csproj
+++ b/src/libraries/System.DirectoryServices/src/System.DirectoryServices.csproj
@@ -1,18 +1,17 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <TargetFrameworks>$(NetCoreAppCurrent)-windows;netcoreapp3.1-windows;netstandard2.0</TargetFrameworks>
-    <ExcludeCurrentNetCoreAppFromPackage>true</ExcludeCurrentNetCoreAppFromPackage>
+    <TargetFrameworks>$(NetCoreAppCurrent)-windows;$(NetCoreAppCurrent);netcoreapp3.1-windows;netcoreapp3.1;netstandard2.0</TargetFrameworks>
     <IncludeInternalObsoleteAttribute>true</IncludeInternalObsoleteAttribute>
     <Nullable>enable</Nullable>
   </PropertyGroup>
   <!-- DesignTimeBuild requires all the TargetFramework Derived Properties to not be present in the first property group. -->
   <PropertyGroup>
-    <GeneratePlatformNotSupportedAssemblyMessage Condition="'$(TargetFramework)' == 'netstandard2.0'">SR.DirectoryServices_PlatformNotSupported</GeneratePlatformNotSupportedAssemblyMessage>
+    <GeneratePlatformNotSupportedAssemblyMessage Condition="'$(TargetsWindows)' != 'true'">SR.DirectoryServices_PlatformNotSupported</GeneratePlatformNotSupportedAssemblyMessage>
     <!-- TODO: Follow-up on nullability errors on netcoreapp3.1-windows -->
     <NoWarn Condition="'$(TargetFramework)' == 'netcoreapp3.1' and '$(TargetsWindows)' == 'true'">$(NoWarn);CS8600;CS8602;CS8604;CS8605</NoWarn>
   </PropertyGroup>
-  <ItemGroup Condition="'$(TargetFramework)' != 'netstandard2.0'">
+  <ItemGroup Condition="'$(TargetsWindows)' == 'true'">
     <Compile Include="System\DirectoryServices\ActiveDirectorySecurity.cs" />
     <Compile Include="System\DirectoryServices\AdsVLV.cs" />
     <Compile Include="System\DirectoryServices\AuthenticationTypes.cs" />
@@ -144,11 +143,14 @@
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="$(LibrariesProjectRoot)System.Security.Permissions\src\System.Security.Permissions.csproj" />
-    <ProjectReference Include="$(LibrariesProjectRoot)System.Security.AccessControl\src\System.Security.AccessControl.csproj" />
-    <ProjectReference Include="$(LibrariesProjectRoot)System.Security.Principal.Windows\src\System.Security.Principal.Windows.csproj" />
-    <ProjectReference Include="$(LibrariesProjectRoot)System.IO.FileSystem.AccessControl\src\System.IO.FileSystem.AccessControl.csproj" />
+  </ItemGroup>
+  <ItemGroup Condition="!$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net6.0'))">
+    <PackageReference Include="System.IO.FileSystem.AccessControl" Version="$(SystemIOFileSystemAccessControlVersion)" />
+    <PackageReference Include="System.Security.AccessControl" Version="$(SystemSecurityAccessControlVersion)" />
+    <PackageReference Include="System.Security.Principal.Windows" Version="$(SystemSecurityPrincipalWindowsVersion)" />
   </ItemGroup>
   <ItemGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp'">
+    <Reference Include="netstandard" Condition="!$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', '$(NetCoreAppCurrent)'))" />
     <Reference Include="Microsoft.Win32.Primitives" />
     <Reference Include="System.Collections" />
     <Reference Include="System.Collections.NonGeneric" />
@@ -158,6 +160,7 @@
     <Reference Include="System.ComponentModel.TypeConverter" />
     <Reference Include="System.Diagnostics.Debug" />
     <Reference Include="System.IO.FileSystem" />
+    <Reference Include="System.IO.FileSystem.AccessControl" Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net6.0'))" />
     <Reference Include="System.Net.NameResolution" />
     <Reference Include="System.Net.Primitives" />
     <Reference Include="System.Net.Security" />
@@ -166,8 +169,10 @@
     <Reference Include="System.Runtime" />
     <Reference Include="System.Runtime.Extensions" />
     <Reference Include="System.Runtime.InteropServices" />
+    <Reference Include="System.Security.AccessControl" Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net6.0'))" />
     <Reference Include="System.Security.Claims" />
     <Reference Include="System.Security.Cryptography.Algorithms" />
+    <Reference Include="System.Security.Principal.Windows" Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net6.0'))" />
     <Reference Include="System.Threading" />
     <Reference Include="System.Threading.Thread" />
   </ItemGroup>
diff --git a/src/libraries/System.Drawing.Common/ref/System.Drawing.Common.cs b/src/libraries/System.Drawing.Common/ref/System.Drawing.Common.cs
index 795297759344ec..3ac90d7c6ed247 100644
--- a/src/libraries/System.Drawing.Common/ref/System.Drawing.Common.cs
+++ b/src/libraries/System.Drawing.Common/ref/System.Drawing.Common.cs
@@ -347,6 +347,7 @@ public FontConverter() { }
         public override object ConvertTo(System.ComponentModel.ITypeDescriptorContext? context, System.Globalization.CultureInfo? culture, object? value, System.Type destinationType) { throw null; }
         public override object CreateInstance(System.ComponentModel.ITypeDescriptorContext? context, System.Collections.IDictionary propertyValues) { throw null; }
         public override bool GetCreateInstanceSupported(System.ComponentModel.ITypeDescriptorContext? context) { throw null; }
+        [Diagnostics.CodeAnalysis.RequiresUnreferencedCode("The Type of value cannot be statically discovered. The public parameterless constructor or the 'Default' static field may be trimmed from the Attribute's Type.")]
         public override System.ComponentModel.PropertyDescriptorCollection GetProperties(System.ComponentModel.ITypeDescriptorContext? context, object? value, System.Attribute[]? attributes) { throw null; }
         public override bool GetPropertiesSupported(System.ComponentModel.ITypeDescriptorContext context) { throw null; }
         public sealed partial class FontNameConverter : System.ComponentModel.TypeConverter, System.IDisposable
@@ -792,6 +793,7 @@ public ImageConverter() { }
         public override bool CanConvertTo(System.ComponentModel.ITypeDescriptorContext? context, System.Type? destinationType) { throw null; }
         public override object ConvertFrom(System.ComponentModel.ITypeDescriptorContext? context, System.Globalization.CultureInfo? culture, object value) { throw null; }
         public override object ConvertTo(System.ComponentModel.ITypeDescriptorContext? context, System.Globalization.CultureInfo? culture, object? value, System.Type destinationType) { throw null; }
+        [Diagnostics.CodeAnalysis.RequiresUnreferencedCode("The Type of value cannot be statically discovered. The public parameterless constructor or the 'Default' static field may be trimmed from the Attribute's Type.")]
         public override System.ComponentModel.PropertyDescriptorCollection GetProperties(System.ComponentModel.ITypeDescriptorContext? context, object? value, System.Attribute[]? attributes) { throw null; }
         public override bool GetPropertiesSupported(System.ComponentModel.ITypeDescriptorContext? context) { throw null; }
     }
diff --git a/src/libraries/System.Drawing.Common/ref/System.Drawing.Common.csproj b/src/libraries/System.Drawing.Common/ref/System.Drawing.Common.csproj
index baf975fbb72b1f..8dbce3bef1d292 100644
--- a/src/libraries/System.Drawing.Common/ref/System.Drawing.Common.csproj
+++ b/src/libraries/System.Drawing.Common/ref/System.Drawing.Common.csproj
@@ -1,7 +1,6 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <TargetFrameworks>$(NetCoreAppCurrent);netcoreapp3.1;netstandard2.0;net461</TargetFrameworks>
-    <ExcludeCurrentNetCoreAppFromPackage>true</ExcludeCurrentNetCoreAppFromPackage>
     <IncludeInternalObsoleteAttribute>true</IncludeInternalObsoleteAttribute>
     <Nullable>enable</Nullable>
   </PropertyGroup>
@@ -12,6 +11,9 @@
     <Compile Include="System.Drawing.Common.netstandard.cs" Condition="'$(TargetFrameworkIdentifier)' == '.NETStandard'" />
     <Compile Include="System.Drawing.Common.net461.cs" Condition="'$(TargetFrameworkIdentifier)' == '.NETFramework'" />
   </ItemGroup>
+  <ItemGroup Condition="!$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net5.0'))">
+    <Compile Include="$(CoreLibSharedDir)System\Diagnostics\CodeAnalysis\RequiresUnreferencedCodeAttribute.cs" />
+  </ItemGroup>
   <ItemGroup Condition="'$(TargetFramework)' == '$(NetCoreAppCurrent)'">
     <ProjectReference Include="$(LibrariesProjectRoot)System.Collections.NonGeneric\ref\System.Collections.NonGeneric.csproj" />
     <ProjectReference Include="$(LibrariesProjectRoot)System.ComponentModel\ref\System.ComponentModel.csproj" />
diff --git a/src/libraries/System.Drawing.Common/src/ILLink/ILLink.Suppressions.xml b/src/libraries/System.Drawing.Common/src/ILLink/ILLink.Suppressions.xml
index d19184f1f2224b..d5734aab1a2a96 100644
--- a/src/libraries/System.Drawing.Common/src/ILLink/ILLink.Suppressions.xml
+++ b/src/libraries/System.Drawing.Common/src/ILLink/ILLink.Suppressions.xml
@@ -1,54 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <linker>
   <assembly fullname="System.Drawing.Common, Version=6.0.0.0, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51">
-    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
-      <argument>ILLink</argument>
-      <argument>IL2026</argument>
-      <property name="Scope">member</property>
-      <property name="Target">M:System.Drawing.BitmapSelector.DoesAssemblyHaveCustomAttribute(System.Reflection.Assembly,System.String)</property>
-    </attribute>
-    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
-      <argument>ILLink</argument>
-      <argument>IL2026</argument>
-      <property name="Scope">member</property>
-      <property name="Target">M:System.Drawing.FontConverter.ConvertFrom(System.ComponentModel.ITypeDescriptorContext,System.Globalization.CultureInfo,System.Object)</property>
-    </attribute>
-    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
-      <argument>ILLink</argument>
-      <argument>IL2026</argument>
-      <property name="Scope">member</property>
-      <property name="Target">M:System.Drawing.FontConverter.GetProperties(System.ComponentModel.ITypeDescriptorContext,System.Object,System.Attribute[])</property>
-    </attribute>
-    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
-      <argument>ILLink</argument>
-      <argument>IL2026</argument>
-      <property name="Scope">member</property>
-      <property name="Target">M:System.Drawing.ImageConverter.GetProperties(System.ComponentModel.ITypeDescriptorContext,System.Object,System.Attribute[])</property>
-    </attribute>
-    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
-      <argument>ILLink</argument>
-      <argument>IL2026</argument>
-      <property name="Scope">member</property>
-      <property name="Target">M:System.Drawing.Printing.MarginsConverter.ConvertFrom(System.ComponentModel.ITypeDescriptorContext,System.Globalization.CultureInfo,System.Object)</property>
-    </attribute>
-    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
-      <argument>ILLink</argument>
-      <argument>IL2026</argument>
-      <property name="Scope">member</property>
-      <property name="Target">M:System.Drawing.Printing.MarginsConverter.ConvertTo(System.ComponentModel.ITypeDescriptorContext,System.Globalization.CultureInfo,System.Object,System.Type)</property>
-    </attribute>
-    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
-      <argument>ILLink</argument>
-      <argument>IL2046</argument>
-      <property name="Scope">member</property>
-      <property name="Target">M:System.Drawing.FontConverter.GetProperties(System.ComponentModel.ITypeDescriptorContext,System.Object,System.Attribute[])</property>
-    </attribute>
-    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
-      <argument>ILLink</argument>
-      <argument>IL2046</argument>
-      <property name="Scope">member</property>
-      <property name="Target">M:System.Drawing.ImageConverter.GetProperties(System.ComponentModel.ITypeDescriptorContext,System.Object,System.Attribute[])</property>
-    </attribute>
     <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
       <argument>ILLink</argument>
       <argument>IL2050</argument>
@@ -115,17 +67,5 @@
       <property name="Scope">member</property>
       <property name="Target">M:System.Drawing.SafeNativeMethods.Gdip.GdipSaveImageToStream(System.Runtime.InteropServices.HandleRef,Interop.Ole32.IStream,System.Guid@,System.Runtime.InteropServices.HandleRef)</property>
     </attribute>
-    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
-      <argument>ILLink</argument>
-      <argument>IL2026</argument>
-      <property name="Scope">member</property>
-      <property name="Target">M:System.Drawing.MacSupport.GetHwndDelegate</property>
-    </attribute>
-    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
-      <argument>ILLink</argument>
-      <argument>IL2075</argument>
-      <property name="Scope">member</property>
-      <property name="Target">M:System.Drawing.MacSupport.GetHwndDelegate</property>
-    </attribute>
   </assembly>
-</linker>
\ No newline at end of file
+</linker>
diff --git a/src/libraries/System.Drawing.Common/src/System.Drawing.Common.csproj b/src/libraries/System.Drawing.Common/src/System.Drawing.Common.csproj
index 35425e03b14ad1..092ea6af165e91 100644
--- a/src/libraries/System.Drawing.Common/src/System.Drawing.Common.csproj
+++ b/src/libraries/System.Drawing.Common/src/System.Drawing.Common.csproj
@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <DefineConstants>$(DefineConstants);DRAWING_NAMESPACE</DefineConstants>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
@@ -6,7 +6,6 @@
     <DefineConstants Condition="'$(TargetsWindows)' == 'true'">$(DefineConstants);FEATURE_WINDOWS_SYSTEM_COLORS;FEATURE_SYSTEM_EVENTS</DefineConstants>
     <IsPartialFacadeAssembly>true</IsPartialFacadeAssembly>
     <TargetFrameworks>$(NetCoreAppCurrent)-windows;$(NetCoreAppCurrent)-Unix;$(NetCoreAppCurrent);netcoreapp3.1-windows;netcoreapp3.1-Unix;netcoreapp3.1;netstandard2.0;net461</TargetFrameworks>
-    <ExcludeCurrentNetCoreAppFromPackage>true</ExcludeCurrentNetCoreAppFromPackage>
     <Nullable>enable</Nullable>
   </PropertyGroup>
   <!-- DesignTimeBuild requires all the TargetFramework Derived Properties to not be present in the first property group. -->
@@ -14,6 +13,10 @@
     <IncludeInternalObsoleteAttribute Condition="'$(TargetFramework)' != 'net461'">true</IncludeInternalObsoleteAttribute>
     <GeneratePlatformNotSupportedAssemblyMessage Condition="'$(TargetsAnyOS)' == 'true' and '$(TargetFramework)' != 'net461'">SR.SystemDrawingCommon_PlatformNotSupported</GeneratePlatformNotSupportedAssemblyMessage>
   </PropertyGroup>
+  <ItemGroup Condition="!$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net5.0'))">
+    <Compile Include="$(CoreLibSharedDir)System\Diagnostics\CodeAnalysis\RequiresUnreferencedCodeAttribute.cs" />
+    <Compile Include="$(CoreLibSharedDir)System\Diagnostics\CodeAnalysis\UnconditionalSuppressMessageAttribute.cs" />
+  </ItemGroup>
   <ItemGroup Condition="'$(TargetsAnyOS)' != 'true'">
     <Compile Include="System\Drawing\Bitmap.cs" />
     <Compile Include="System\Drawing\BitmapSuffixInSameAssemblyAttribute.cs" />
diff --git a/src/libraries/System.Drawing.Common/src/System/Drawing/BitmapSelector.cs b/src/libraries/System.Drawing.Common/src/System/Drawing/BitmapSelector.cs
index 956c1e5ded1dee..b5daa033aa805c 100644
--- a/src/libraries/System.Drawing.Common/src/System/Drawing/BitmapSelector.cs
+++ b/src/libraries/System.Drawing.Common/src/System/Drawing/BitmapSelector.cs
@@ -1,133 +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 System.IO;
+using System.Reflection;
+
 namespace System.Drawing
 {
-    using System.IO;
-    using System.Reflection;
-
     /// <summary>
-    /// Provides methods to select from multiple bitmaps depending on a "bitmapSuffix" config setting.
+    /// Provides methods to select bitmaps.
     /// </summary>
     internal static class BitmapSelector
     {
-        /// <summary>
-        /// Gets the bitmap ID suffix defined in the application configuration, or string.Empty if
-        /// the suffix is not specified.  Internal for unit tests
-        /// </summary>
-        /// <remarks>
-        /// For performance, the suffix is cached in a static variable so it only has to be read
-        /// once per appdomain.
-        /// </remarks>
-        private static string? s_suffix;
-        internal static string? Suffix
-        {
-            get
-            {
-                // NOTE: This value is read from the "SystemDrawingSection" of the ConfigurationManager on
-                // the .NET Framework. To avoid pulling in a direct dependency to that assembly, we are not
-                // reading the value in this implementation.
-                return s_suffix;
-            }
-            set
-            {
-                // So unit tests can clear the cached suffix
-                s_suffix = value;
-            }
-        }
-
-        /// <summary>
-        /// Appends the current suffix to <paramref name="filePath"/>.  The suffix is appended
-        /// before the existing extension (if any).  Internal for unit tests.
-        /// </summary>
-        /// <returns>
-        /// The new path with the suffix included.  If there is no suffix defined or there are
-        /// invalid characters in the original path, the original path is returned.
-        /// </returns>
-        internal static string AppendSuffix(string filePath)
-        {
-            try
-            {
-                return Path.ChangeExtension(filePath, Suffix + Path.GetExtension(filePath));
-            }
-            catch (ArgumentException)
-            { // there are invalid characters in the path
-                return filePath;
-            }
-        }
-
-        /// <summary>
-        /// Returns <paramref name="originalPath"/> with the current suffix appended (before the
-        /// existing extension) if the resulting file path exists; otherwise the original path is
-        /// returned.
-        /// </summary>
-        public static string GetFileName(string originalPath)
-        {
-            if (string.IsNullOrEmpty(Suffix))
-                return originalPath;
-
-            string newPath = AppendSuffix(originalPath);
-            return File.Exists(newPath) ? newPath : originalPath;
-        }
-
-        // Calls assembly.GetManifestResourceStream in a try/catch and returns null if not found
-        private static Stream? GetResourceStreamHelper(Assembly assembly, Type type, string name)
-        {
-            Stream? stream = null;
-            try
-            {
-                stream = assembly.GetManifestResourceStream(type, name);
-            }
-            catch (FileNotFoundException)
-            {
-            }
-            return stream;
-        }
-
-        private static bool DoesAssemblyHaveCustomAttribute(Assembly assembly, string typeName)
-        {
-            return DoesAssemblyHaveCustomAttribute(assembly, assembly.GetType(typeName));
-        }
-
-        private static bool DoesAssemblyHaveCustomAttribute(Assembly assembly, Type? attrType)
-        {
-            if (attrType != null)
-            {
-                var attr = assembly.GetCustomAttributes(attrType, false);
-                if (attr.Length > 0)
-                {
-                    return true;
-                }
-            }
-            return false;
-        }
-
-        // internal for unit tests
-        internal static bool SatelliteAssemblyOptIn(Assembly assembly)
-        {
-            // Try 4.5 public attribute type first
-            if (DoesAssemblyHaveCustomAttribute(assembly, typeof(BitmapSuffixInSatelliteAssemblyAttribute)))
-            {
-                return true;
-            }
-
-            // Also load attribute type by name for dlls compiled against older frameworks
-            return DoesAssemblyHaveCustomAttribute(assembly, "System.Drawing.BitmapSuffixInSatelliteAssemblyAttribute");
-        }
-
-        // internal for unit tests
-        internal static bool SameAssemblyOptIn(Assembly assembly)
-        {
-            // Try 4.5 public attribute type first
-            if (DoesAssemblyHaveCustomAttribute(assembly, typeof(BitmapSuffixInSameAssemblyAttribute)))
-            {
-                return true;
-            }
-
-            // Also load attribute type by name for dlls compiled against older frameworks
-            return DoesAssemblyHaveCustomAttribute(assembly, "System.Drawing.BitmapSuffixInSameAssemblyAttribute");
-        }
-
         /// <summary>
         /// Returns a resource stream loaded from the appropriate location according to the current
         /// suffix.
@@ -136,57 +19,10 @@ internal static bool SameAssemblyOptIn(Assembly assembly)
         /// <param name="type">The type whose namespace is used to scope the manifest resource name</param>
         /// <param name="originalName">The name of the manifest resource being requested</param>
         /// <returns>
-        /// The manifest resource stream corresponding to <paramref name="originalName"/> with the
-        /// current suffix applied; or if that is not found, the stream corresponding to <paramref name="originalName"/>.
+        /// The manifest resource stream corresponding to <paramref name="originalName"/>.
         /// </returns>
         public static Stream? GetResourceStream(Assembly assembly, Type type, string originalName)
         {
-            if (Suffix != string.Empty)
-            {
-                try
-                {
-                    // Resource with suffix has highest priority
-                    if (SameAssemblyOptIn(assembly))
-                    {
-                        string newName = AppendSuffix(originalName);
-                        Stream? stream = GetResourceStreamHelper(assembly, type, newName);
-                        if (stream != null)
-                        {
-                            return stream;
-                        }
-                    }
-                }
-                catch
-                {
-                    // Ignore failures and continue to try other options
-                }
-
-                try
-                {
-                    // Satellite assembly has second priority, using the original name
-                    if (SatelliteAssemblyOptIn(assembly))
-                    {
-                        AssemblyName assemblyName = assembly.GetName();
-                        assemblyName.Name += Suffix;
-                        assemblyName.ProcessorArchitecture = ProcessorArchitecture.None;
-                        Assembly satellite = Assembly.Load(assemblyName);
-                        if (satellite != null)
-                        {
-                            Stream? stream = GetResourceStreamHelper(satellite, type, originalName);
-                            if (stream != null)
-                            {
-                                return stream;
-                            }
-                        }
-                    }
-                }
-                catch
-                {
-                    // Ignore failures and continue to try other options
-                }
-            }
-
-            // Otherwise fall back to specified assembly and original name requested
             return assembly.GetManifestResourceStream(type, originalName);
         }
 
@@ -197,42 +33,11 @@ internal static bool SameAssemblyOptIn(Assembly assembly)
         /// <param name="type">The type from whose assembly the stream is loaded and whose namespace is used to scope the resource name</param>
         /// <param name="originalName">The name of the manifest resource being requested</param>
         /// <returns>
-        /// The manifest resource stream corresponding to <paramref name="originalName"/> with the
-        /// current suffix applied; or if that is not found, the stream corresponding to <paramref name="originalName"/>.
+        /// The manifest resource stream corresponding to <paramref name="originalName"/>.
         /// </returns>
         public static Stream? GetResourceStream(Type type, string originalName)
         {
             return GetResourceStream(type.Module.Assembly, type, originalName);
         }
-
-        /// <summary>
-        /// Returns an Icon created  from a resource stream loaded from the appropriate location according to the current
-        /// suffix.
-        /// </summary>
-        /// <param name="type">The type from whose assembly the stream is loaded and whose namespace is used to scope the resource name</param>
-        /// <param name="originalName">The name of the manifest resource being requested</param>
-        /// <returns>
-        /// The icon created from a manifest resource stream corresponding to <paramref name="originalName"/> with the
-        /// current suffix applied; or if that is not found, the stream corresponding to <paramref name="originalName"/>.
-        /// </returns>
-        public static Icon CreateIcon(Type type, string originalName)
-        {
-            return new Icon(GetResourceStream(type, originalName)!);
-        }
-
-        /// <summary>
-        /// Returns an Bitmap created  from a resource stream loaded from the appropriate location according to the current
-        /// suffix.
-        /// </summary>
-        /// <param name="type">The type from whose assembly the stream is loaded and whose namespace is used to scope the resource name</param>
-        /// <param name="originalName">The name of the manifest resource being requested</param>
-        /// <returns>
-        /// The bitmap created from a manifest resource stream corresponding to <paramref name="originalName"/> with the
-        /// current suffix applied; or if that is not found, the stream corresponding to <paramref name="originalName"/>.
-        /// </returns>
-        public static Bitmap CreateBitmap(Type type, string originalName)
-        {
-            return new Bitmap(GetResourceStream(type, originalName)!);
-        }
     }
 }
diff --git a/src/libraries/System.Drawing.Common/src/System/Drawing/FontConverter.cs b/src/libraries/System.Drawing.Common/src/System/Drawing/FontConverter.cs
index f289f5549b8fba..1ea09376a5cd02 100644
--- a/src/libraries/System.Drawing.Common/src/System/Drawing/FontConverter.cs
+++ b/src/libraries/System.Drawing.Common/src/System/Drawing/FontConverter.cs
@@ -5,6 +5,7 @@
 using System.ComponentModel;
 using System.ComponentModel.Design.Serialization;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.Drawing.Text;
 using System.Globalization;
 using System.Reflection;
@@ -168,7 +169,7 @@ public override object ConvertTo(ITypeDescriptorContext? context, CultureInfo? c
                 {
                     try
                     {
-                        fontSize = (float)TypeDescriptor.GetConverter(typeof(float)).ConvertFromString(context, culture, unitTokens.size);
+                        fontSize = (float)GetFloatConverter().ConvertFromString(context, culture, unitTokens.size);
                     }
                     catch
                     {
@@ -207,6 +208,10 @@ public override object ConvertTo(ITypeDescriptorContext? context, CultureInfo? c
             }
 
             return new Font(fontName, fontSize, fontStyle, units);
+
+            [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
+                Justification = "TypeDescriptor.GetConverter is safe for primitive types.")]
+            static TypeConverter GetFloatConverter() => TypeDescriptor.GetConverter(typeof(float));
         }
 
         private (string?, string?) ParseSizeTokens(string text, char separator)
@@ -360,6 +365,7 @@ public override object CreateInstance(ITypeDescriptorContext? context, IDictiona
 
         public override bool GetCreateInstanceSupported(ITypeDescriptorContext? context) => true;
 
+        [RequiresUnreferencedCode("The Type of value cannot be statically discovered. The public parameterless constructor or the 'Default' static field may be trimmed from the Attribute's Type.")]
         public override PropertyDescriptorCollection GetProperties(
             ITypeDescriptorContext? context,
             object? value,
diff --git a/src/libraries/System.Drawing.Common/src/System/Drawing/ImageConverter.cs b/src/libraries/System.Drawing.Common/src/System/Drawing/ImageConverter.cs
index 9836fbfc9a38d5..308df99d1d05f9 100644
--- a/src/libraries/System.Drawing.Common/src/System/Drawing/ImageConverter.cs
+++ b/src/libraries/System.Drawing.Common/src/System/Drawing/ImageConverter.cs
@@ -4,6 +4,7 @@
 using System.Buffers.Binary;
 using System.ComponentModel;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.Drawing.Imaging;
 using System.Globalization;
 using System.IO;
@@ -102,6 +103,7 @@ public override object ConvertTo(ITypeDescriptorContext? context, CultureInfo? c
             return null;
         }
 
+        [RequiresUnreferencedCode("The Type of value cannot be statically discovered. The public parameterless constructor or the 'Default' static field may be trimmed from the Attribute's Type.")]
         public override PropertyDescriptorCollection GetProperties(ITypeDescriptorContext? context, object? value, Attribute[]? attributes)
         {
             return TypeDescriptor.GetProperties(typeof(Image), attributes);
diff --git a/src/libraries/System.Drawing.Common/src/System/Drawing/NumericsExtensions.cs b/src/libraries/System.Drawing.Common/src/System/Drawing/NumericsExtensions.cs
index 1f468afdae269a..5cb3fa10ddd02d 100644
--- a/src/libraries/System.Drawing.Common/src/System/Drawing/NumericsExtensions.cs
+++ b/src/libraries/System.Drawing.Common/src/System/Drawing/NumericsExtensions.cs
@@ -1,12 +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.Collections.Generic;
-using System.Linq;
 using System.Numerics;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace System.Drawing
 {
diff --git a/src/libraries/System.Drawing.Common/src/System/Drawing/Printing/MarginsConverter.cs b/src/libraries/System.Drawing.Common/src/System/Drawing/Printing/MarginsConverter.cs
index 2431fde5eac15e..af6ac73329949f 100644
--- a/src/libraries/System.Drawing.Common/src/System/Drawing/Printing/MarginsConverter.cs
+++ b/src/libraries/System.Drawing.Common/src/System/Drawing/Printing/MarginsConverter.cs
@@ -64,7 +64,7 @@ public override bool CanConvertTo(ITypeDescriptorContext? context, Type? destina
                     char sep = culture.TextInfo.ListSeparator[0];
                     string[] tokens = text.Split(sep);
                     int[] values = new int[tokens.Length];
-                    TypeConverter intConverter = TypeDescriptor.GetConverter(typeof(int));
+                    TypeConverter intConverter = GetIntConverter();
                     for (int i = 0; i < values.Length; i++)
                     {
                         // Note: ConvertFromString will raise exception if value cannot be converted.
@@ -80,6 +80,10 @@ public override bool CanConvertTo(ITypeDescriptorContext? context, Type? destina
             return base.ConvertFrom(context, culture, value);
         }
 
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
+            Justification = "TypeDescriptor.GetConverter is safe for primitive types.")]
+        private static TypeConverter GetIntConverter() => TypeDescriptor.GetConverter(typeof(int));
+
         /// <summary>
         /// Converts the given object to another type. The most common types to convert
         /// are to and from a string object. The default implementation will make a call
@@ -102,7 +106,7 @@ public override object ConvertTo(ITypeDescriptorContext? context, CultureInfo? c
                         culture = CultureInfo.CurrentCulture;
                     }
                     string sep = culture.TextInfo.ListSeparator + " ";
-                    TypeConverter intConverter = TypeDescriptor.GetConverter(typeof(int));
+                    TypeConverter intConverter = GetIntConverter();
                     string[] args = new string[4];
                     int nArg = 0;
 
diff --git a/src/libraries/System.Drawing.Common/src/System/Drawing/ToolboxBitmapAttribute.cs b/src/libraries/System.Drawing.Common/src/System/Drawing/ToolboxBitmapAttribute.cs
index 2cc414e3e184a0..aad75a27f3516e 100644
--- a/src/libraries/System.Drawing.Common/src/System/Drawing/ToolboxBitmapAttribute.cs
+++ b/src/libraries/System.Drawing.Common/src/System/Drawing/ToolboxBitmapAttribute.cs
@@ -28,10 +28,6 @@ public class ToolboxBitmapAttribute : Attribute
         private static readonly Size s_largeSize = new Size(32, 32);
         private static readonly Size s_smallSize = new Size(16, 16);
 
-        // Used to help cache the last result of BitmapSelector.GetFileName.
-        private static string? s_lastOriginalFileName;
-        private static string? s_lastUpdatedFileName;
-
         public ToolboxBitmapAttribute(string imageFile) : this(GetImageFromFile(imageFile, false), GetImageFromFile(imageFile, true))
         {
             _imageFile = imageFile;
@@ -168,19 +164,6 @@ public override bool Equals([NotNullWhen(true)] object? value)
             return b;
         }
 
-        // Cache the last result of BitmapSelector.GetFileName because we commonly load images twice
-        // in succession from the same file and we don't need to compute the name twice.
-        private static string? GetFileNameFromBitmapSelector(string originalName)
-        {
-            if (originalName != s_lastOriginalFileName)
-            {
-                s_lastOriginalFileName = originalName;
-                s_lastUpdatedFileName = BitmapSelector.GetFileName(originalName);
-            }
-
-            return s_lastUpdatedFileName;
-        }
-
         // Just forwards to Image.FromFile eating any non-critical exceptions that may result.
         private static Image? GetImageFromFile(string? imageFile, bool large, bool scaled = true)
         {
@@ -189,8 +172,6 @@ public override bool Equals([NotNullWhen(true)] object? value)
             {
                 if (imageFile != null)
                 {
-                    imageFile = GetFileNameFromBitmapSelector(imageFile);
-
                     string? ext = Path.GetExtension(imageFile);
                     if (ext != null && string.Equals(ext, ".ico", StringComparison.OrdinalIgnoreCase))
                     {
diff --git a/src/libraries/System.Drawing.Common/src/System/Drawing/macFunctions.cs b/src/libraries/System.Drawing.Common/src/System/Drawing/macFunctions.cs
index 13e75725b83fdb..ddc7fef94d976a 100644
--- a/src/libraries/System.Drawing.Common/src/System/Drawing/macFunctions.cs
+++ b/src/libraries/System.Drawing.Common/src/System/Drawing/macFunctions.cs
@@ -28,10 +28,8 @@
 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 //
-#undef DEBUG_CLIPPING
 
 using System.Collections;
-using System.Reflection;
 using System.Runtime.InteropServices;
 
 namespace System.Drawing
@@ -40,31 +38,6 @@ internal static class MacSupport
     {
         internal static readonly Hashtable contextReference = new Hashtable();
         internal static readonly object lockobj = new object();
-        internal static readonly Delegate? hwnd_delegate = GetHwndDelegate();
-
-#if DEBUG_CLIPPING
-        internal static float red = 1.0f;
-        internal static float green = 0.0f;
-        internal static float blue = 0.0f;
-        internal static int debug_threshold = 1;
-#endif
-
-        private static Delegate? GetHwndDelegate()
-        {
-            foreach (Assembly asm in AppDomain.CurrentDomain.GetAssemblies())
-            {
-                if (string.Equals(asm.GetName().Name, "System.Windows.Forms"))
-                {
-                    Type? driver_type = asm.GetType("System.Windows.Forms.XplatUICarbon");
-                    if (driver_type != null)
-                    {
-                        return (Delegate?)driver_type.GetField("HwndDelegate", BindingFlags.NonPublic | BindingFlags.Static)!.GetValue(null);
-                    }
-                }
-            }
-
-            return null;
-        }
 
         internal static CocoaContext GetCGContextForNSView(IntPtr handle)
         {
@@ -129,39 +102,10 @@ internal static CarbonContext GetCGContextForView(IntPtr handle)
 
             CGContextSaveGState(context);
 
-            Rectangle[]? clip_rectangles = (Rectangle[]?)hwnd_delegate!.DynamicInvoke(new object[] { handle });
-            if (clip_rectangles != null && clip_rectangles.Length > 0)
-            {
-                int length = clip_rectangles.Length;
-
-                CGContextBeginPath(context);
-                CGContextAddRect(context, rc_clip);
-
-                for (int i = 0; i < length; i++)
-                {
-                    CGContextAddRect(context, new Rect(clip_rectangles[i].X, view_bounds.size.height - clip_rectangles[i].Y - clip_rectangles[i].Height, clip_rectangles[i].Width, clip_rectangles[i].Height));
-                }
-                CGContextClosePath(context);
-                CGContextEOClip(context);
-#if DEBUG_CLIPPING
-                if (clip_rectangles.Length >= debug_threshold) {
-                    CGContextSetRGBFillColor (context, red, green, blue, 0.5f);
-                    CGContextFillRect (context, rc_clip);
-                    CGContextFlush (context);
-                    System.Threading.Thread.Sleep (500);
-                    if (red == 1.0f) { red = 0.0f; blue = 1.0f; }
-                    else if (blue == 1.0f) { blue = 0.0f; green = 1.0f; }
-                    else if (green == 1.0f) { green = 0.0f; red = 1.0f; }
-                }
-#endif
-            }
-            else
-            {
-                CGContextBeginPath(context);
-                CGContextAddRect(context, rc_clip);
-                CGContextClosePath(context);
-                CGContextClip(context);
-            }
+            CGContextBeginPath(context);
+            CGContextAddRect(context, rc_clip);
+            CGContextClosePath(context);
+            CGContextClip(context);
 
             return new CarbonContext(port, context, (int)view_bounds.size.width, (int)view_bounds.size.height);
         }
@@ -285,13 +229,6 @@ internal static void ReleaseContext(IntPtr port, IntPtr context)
         internal static extern void CGContextSaveGState(IntPtr context);
         [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")]
         internal static extern void CGContextRestoreGState(IntPtr context);
-
-#if DEBUG_CLIPPING
-        [DllImport ("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")]
-        internal static extern void CGContextSetRGBFillColor (IntPtr context, float red, float green, float blue, float alpha);
-        [DllImport ("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")]
-        internal static extern void CGContextFillRect (IntPtr context, Rect rect);
-#endif
     }
 
     internal struct CGSize
diff --git a/src/libraries/System.Dynamic.Runtime/tests/Dynamic.DynamicType/Conformance.dynamic.dynamicType.conversions.cs b/src/libraries/System.Dynamic.Runtime/tests/Dynamic.DynamicType/Conformance.dynamic.dynamicType.conversions.cs
index a345456c53b8fe..d27e05bff2864a 100644
--- a/src/libraries/System.Dynamic.Runtime/tests/Dynamic.DynamicType/Conformance.dynamic.dynamicType.conversions.cs
+++ b/src/libraries/System.Dynamic.Runtime/tests/Dynamic.DynamicType/Conformance.dynamic.dynamicType.conversions.cs
@@ -397,7 +397,6 @@ private static bool NullableUlongTypeWithNullableNumbericConversionFromUintInAss
 
         #endregion
         [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
         public static void DynamicCSharpRunTest()
         {
             Assert.Equal(0, MainMethod());
diff --git a/src/libraries/System.Dynamic.Runtime/tests/Dynamic.NamedAndOptional/Conformance.dynamic.namedandoptional.usage.executeOrder.cs b/src/libraries/System.Dynamic.Runtime/tests/Dynamic.NamedAndOptional/Conformance.dynamic.namedandoptional.usage.executeOrder.cs
index a9b0ebba2ebeb5..b0a5792306e26f 100644
--- a/src/libraries/System.Dynamic.Runtime/tests/Dynamic.NamedAndOptional/Conformance.dynamic.namedandoptional.usage.executeOrder.cs
+++ b/src/libraries/System.Dynamic.Runtime/tests/Dynamic.NamedAndOptional/Conformance.dynamic.namedandoptional.usage.executeOrder.cs
@@ -1035,7 +1035,6 @@ public static int Bar3()
         }
 
         [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
         public static void DynamicCSharpRunTest()
         {
             Assert.Equal(0, MainMethod());
diff --git a/src/libraries/System.Dynamic.Runtime/tests/Dynamic.OverloadResolution/Conformance.dynamic.overloadResolution.Methods.1class2methods.cs b/src/libraries/System.Dynamic.Runtime/tests/Dynamic.OverloadResolution/Conformance.dynamic.overloadResolution.Methods.1class2methods.cs
index af1b08aa772d28..5cf0a1ffe9dfdf 100644
--- a/src/libraries/System.Dynamic.Runtime/tests/Dynamic.OverloadResolution/Conformance.dynamic.overloadResolution.Methods.1class2methods.cs
+++ b/src/libraries/System.Dynamic.Runtime/tests/Dynamic.OverloadResolution/Conformance.dynamic.overloadResolution.Methods.1class2methods.cs
@@ -2966,7 +2966,6 @@ public void Method(short? s)
         }
 
         [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
         public static void DynamicCSharpRunTest()
         {
             Assert.Equal(0, MainMethod());
@@ -2998,7 +2997,6 @@ public void Method(short? s)
         }
 
         [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
         public static void DynamicCSharpRunTest()
         {
             Assert.Equal(0, MainMethod());
diff --git a/src/libraries/System.Formats.Asn1/ref/System.Formats.Asn1.csproj b/src/libraries/System.Formats.Asn1/ref/System.Formats.Asn1.csproj
index ee0ebfbfe10401..adb92a819c4622 100644
--- a/src/libraries/System.Formats.Asn1/ref/System.Formats.Asn1.csproj
+++ b/src/libraries/System.Formats.Asn1/ref/System.Formats.Asn1.csproj
@@ -1,12 +1,16 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFrameworks>netstandard2.0;net461</TargetFrameworks>
+    <TargetFrameworks>$(NetCoreAppCurrent);netstandard2.0;net461</TargetFrameworks>
     <Nullable>enable</Nullable>
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="System.Formats.Asn1.cs" />
   </ItemGroup>
-  <ItemGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == '$(NetCoreAppCurrent)'">
+    <ProjectReference Include="$(LibrariesProjectRoot)System.Collections\ref\System.Collections.csproj" />
+    <ProjectReference Include="$(LibrariesProjectRoot)System.Runtime.Numerics\ref\System.Runtime.Numerics.csproj" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(TargetFrameworkIdentifier)' != '.NETCoreApp'">
     <PackageReference Include="System.Memory" Version="$(SystemMemoryVersion)" />
   </ItemGroup>
 </Project>
diff --git a/src/libraries/System.Formats.Asn1/src/System.Formats.Asn1.csproj b/src/libraries/System.Formats.Asn1/src/System.Formats.Asn1.csproj
index 059af38e99b740..d6ee9507e4d548 100644
--- a/src/libraries/System.Formats.Asn1/src/System.Formats.Asn1.csproj
+++ b/src/libraries/System.Formats.Asn1/src/System.Formats.Asn1.csproj
@@ -3,7 +3,6 @@
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <Nullable>enable</Nullable>
     <TargetFrameworks>$(NetCoreAppCurrent);netstandard2.0;net461</TargetFrameworks>
-    <ExcludeCurrentNetCoreAppFromPackage>true</ExcludeCurrentNetCoreAppFromPackage>
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="$(CommonPath)System\Security\Cryptography\CryptoPool.cs">
@@ -47,29 +46,23 @@
     <Compile Include="System\Formats\Asn1\TagClass.cs" />
     <Compile Include="System\Formats\Asn1\UniversalTagNumber.cs" />
   </ItemGroup>
-  <Choose>
-    <When Condition="'$(TargetFramework)' == '$(NetCoreAppCurrent)'">
-      <ItemGroup>
-        <Reference Include="System.Buffers" />
-        <Reference Include="System.Collections" />
-        <Reference Include="System.Memory" />
-        <Reference Include="System.Runtime" />
-        <Reference Include="System.Runtime.InteropServices" />
-        <Reference Include="System.Runtime.Numerics" />
-        <Reference Include="System.Security.Cryptography.Primitives" />
-        <Reference Include="System.Text.Encoding.Extensions" />
-      </ItemGroup>
-    </When>
-    <Otherwise>
-      <ItemGroup>
-        <PackageReference Include="System.Buffers" Version="$(SystemBuffersVersion)" />
-        <PackageReference Include="System.Memory" Version="$(SystemMemoryVersion)" />
-        <ProjectReference Include="$(LibrariesProjectRoot)System.Runtime.CompilerServices.Unsafe\src\System.Runtime.CompilerServices.Unsafe.ilproj" />
-      </ItemGroup>
-    </Otherwise>
-  </Choose>
-  <ItemGroup Condition="$(TargetFramework.StartsWith('net4'))">
+  <ItemGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp'">
+    <Reference Include="System.Buffers" />
+    <Reference Include="System.Collections" />
+    <Reference Include="System.Memory" />
+    <Reference Include="System.Runtime" />
+    <Reference Include="System.Runtime.InteropServices" />
+    <Reference Include="System.Runtime.Numerics" />
+    <Reference Include="System.Security.Cryptography.Primitives" />
+    <Reference Include="System.Text.Encoding.Extensions" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(TargetFrameworkIdentifier)' != '.NETCoreApp'">
+    <PackageReference Include="System.Buffers" Version="$(SystemBuffersVersion)" />
+    <PackageReference Include="System.Memory" Version="$(SystemMemoryVersion)" />
+    <ProjectReference Include="$(LibrariesProjectRoot)System.Runtime.CompilerServices.Unsafe\src\System.Runtime.CompilerServices.Unsafe.ilproj" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == 'net461'">
     <Reference Include="System.Numerics" />
-    <PackageReference Include="System.ValueTuple" Version="$(SystemValueTupleVersion)" Condition="'$(TargetFramework)' == 'net461'" />
+    <PackageReference Include="System.ValueTuple" Version="$(SystemValueTupleVersion)" />
   </ItemGroup>
 </Project>
diff --git a/src/libraries/System.Formats.Cbor/ref/System.Formats.Cbor.csproj b/src/libraries/System.Formats.Cbor/ref/System.Formats.Cbor.csproj
index f2aa426354bd44..c2f243296b552d 100644
--- a/src/libraries/System.Formats.Cbor/ref/System.Formats.Cbor.csproj
+++ b/src/libraries/System.Formats.Cbor/ref/System.Formats.Cbor.csproj
@@ -1,7 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <TargetFrameworks>$(NetCoreAppCurrent);net5.0</TargetFrameworks>
-    <ExcludeCurrentNetCoreAppFromPackage>true</ExcludeCurrentNetCoreAppFromPackage>
     <Nullable>enable</Nullable>
   </PropertyGroup>
   <ItemGroup>
@@ -11,7 +10,7 @@
     <Reference Include="System.Runtime" />
     <Reference Include="System.Runtime.Numerics" />
   </ItemGroup>
-  <ItemGroup Condition="'$(TargetFramework)' != 'net5.0'">
+  <ItemGroup Condition="'$(TargetFramework)' == '$(NetCoreAppCurrent)'">
     <ProjectReference Include="$(LibrariesProjectRoot)System.Runtime\ref\System.Runtime.csproj" />
     <ProjectReference Include="$(LibrariesProjectRoot)System.Runtime.Numerics\ref\System.Runtime.Numerics.csproj" />
   </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 23462998e03ebd..a79e50ff2c5be0 100644
--- a/src/libraries/System.Formats.Cbor/src/System.Formats.Cbor.csproj
+++ b/src/libraries/System.Formats.Cbor/src/System.Formats.Cbor.csproj
@@ -1,8 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFrameworks>net5.0;$(NetCoreAppCurrent)</TargetFrameworks>
+    <TargetFrameworks>$(NetCoreAppCurrent);net5.0</TargetFrameworks>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ExcludeCurrentNetCoreAppFromPackage>true</ExcludeCurrentNetCoreAppFromPackage>
     <Nullable>enable</Nullable>
   </PropertyGroup>
   <ItemGroup>
diff --git a/src/libraries/System.Formats.Cbor/src/System/Formats/Cbor/CborConformanceLevel.cs b/src/libraries/System.Formats.Cbor/src/System/Formats/Cbor/CborConformanceLevel.cs
index df160c57d4c367..bc9111a112ba55 100644
--- a/src/libraries/System.Formats.Cbor/src/System/Formats/Cbor/CborConformanceLevel.cs
+++ b/src/libraries/System.Formats.Cbor/src/System/Formats/Cbor/CborConformanceLevel.cs
@@ -207,8 +207,9 @@ public static bool RequireCanonicalSimpleValueEncodings(CborConformanceMode conf
         public static int GetKeyEncodingHashCode(ReadOnlySpan<byte> encoding)
         {
             HashCode hash = default;
-
-            // TODO: Use https://github.com/dotnet/runtime/issues/48702 if/when it's available
+#if NET6_0_OR_GREATER
+            hash.AddBytes(encoding);
+#else
             while (encoding.Length >= sizeof(int))
             {
                 hash.Add(MemoryMarshal.Read<int>(encoding));
@@ -219,7 +220,7 @@ public static int GetKeyEncodingHashCode(ReadOnlySpan<byte> encoding)
             {
                 hash.Add(b);
             }
-
+#endif
             return hash.ToHashCode();
         }
 
diff --git a/src/libraries/System.IO.Compression.Brotli/src/System.IO.Compression.Brotli.csproj b/src/libraries/System.IO.Compression.Brotli/src/System.IO.Compression.Brotli.csproj
index 570ff6cf1aaeab..9fdcecf8f5e1ef 100644
--- a/src/libraries/System.IO.Compression.Brotli/src/System.IO.Compression.Brotli.csproj
+++ b/src/libraries/System.IO.Compression.Brotli/src/System.IO.Compression.Brotli.csproj
@@ -11,6 +11,8 @@
   </PropertyGroup>
   <ItemGroup Condition="'$(TargetsAnyOS)' != 'true'">
     <Compile Include="$(CommonPath)Interop\Interop.Brotli.cs" />
+    <!-- The native compression lib uses a BROTLI_BOOL type analogous to the Windows BOOL type -->
+    <Compile Include="$(CommonPath)Interop\Windows\Interop.BOOL.cs" />
     <Compile Include="System\IO\Compression\enc\BrotliStream.Compress.cs" />
     <Compile Include="System\IO\Compression\dec\BrotliStream.Decompress.cs" />
     <Compile Include="System\IO\Compression\BrotliUtils.cs" />
diff --git a/src/libraries/System.IO.Compression.Brotli/src/System/IO/Compression/BrotliStream.cs b/src/libraries/System.IO.Compression.Brotli/src/System/IO/Compression/BrotliStream.cs
index 4401a4753d5ac1..73ecccf89262b7 100644
--- a/src/libraries/System.IO.Compression.Brotli/src/System/IO/Compression/BrotliStream.cs
+++ b/src/libraries/System.IO.Compression.Brotli/src/System/IO/Compression/BrotliStream.cs
@@ -173,7 +173,7 @@ private void EnsureNoActiveAsyncOperation()
 
         private void AsyncOperationStarting()
         {
-            if (Interlocked.CompareExchange(ref _activeAsyncOperation, 1, 0) != 0)
+            if (Interlocked.Exchange(ref _activeAsyncOperation, 1) != 0)
             {
                 ThrowInvalidBeginCall();
             }
@@ -181,13 +181,11 @@ private void AsyncOperationStarting()
 
         private void AsyncOperationCompleting()
         {
-            int oldValue = Interlocked.CompareExchange(ref _activeAsyncOperation, 0, 1);
-            Debug.Assert(oldValue == 1, $"Expected {nameof(_activeAsyncOperation)} to be 1, got {oldValue}");
+            Debug.Assert(_activeAsyncOperation == 1);
+            Volatile.Write(ref _activeAsyncOperation, 0);
         }
 
-        private static void ThrowInvalidBeginCall()
-        {
+        private static void ThrowInvalidBeginCall() =>
             throw new InvalidOperationException(SR.InvalidBeginCall);
-        }
     }
 }
diff --git a/src/libraries/System.IO.Compression.Brotli/src/System/IO/Compression/dec/BrotliDecoder.cs b/src/libraries/System.IO.Compression.Brotli/src/System/IO/Compression/dec/BrotliDecoder.cs
index e8db5c39630918..8b6730ef523801 100644
--- a/src/libraries/System.IO.Compression.Brotli/src/System/IO/Compression/dec/BrotliDecoder.cs
+++ b/src/libraries/System.IO.Compression.Brotli/src/System/IO/Compression/dec/BrotliDecoder.cs
@@ -59,7 +59,7 @@ public OperationStatus Decompress(ReadOnlySpan<byte> source, Span<byte> destinat
 
             bytesConsumed = 0;
             bytesWritten = 0;
-            if (Interop.Brotli.BrotliDecoderIsFinished(_state))
+            if (Interop.Brotli.BrotliDecoderIsFinished(_state) != Interop.BOOL.FALSE)
                 return OperationStatus.Done;
             nuint availableOutput = (nuint)destination.Length;
             nuint availableInput = (nuint)source.Length;
@@ -117,7 +117,7 @@ public static unsafe bool TryDecompress(ReadOnlySpan<byte> source, Span<byte> de
             fixed (byte* outBytes = &MemoryMarshal.GetReference(destination))
             {
                 nuint availableOutput = (nuint)destination.Length;
-                bool success = Interop.Brotli.BrotliDecoderDecompress((nuint)source.Length, inBytes, ref availableOutput, outBytes);
+                bool success = Interop.Brotli.BrotliDecoderDecompress((nuint)source.Length, inBytes, &availableOutput, outBytes) != Interop.BOOL.FALSE;
 
                 Debug.Assert(success ? availableOutput <= (nuint)destination.Length : availableOutput == 0);
 
diff --git a/src/libraries/System.IO.Compression.Brotli/src/System/IO/Compression/dec/BrotliStream.Decompress.cs b/src/libraries/System.IO.Compression.Brotli/src/System/IO/Compression/dec/BrotliStream.Decompress.cs
index f2f7d720c7ae7f..b9708e0c19df00 100644
--- a/src/libraries/System.IO.Compression.Brotli/src/System/IO/Compression/dec/BrotliStream.Decompress.cs
+++ b/src/libraries/System.IO.Compression.Brotli/src/System/IO/Compression/dec/BrotliStream.Decompress.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Buffers;
+using System.Diagnostics;
 using System.Runtime.InteropServices;
 using System.Threading;
 using System.Threading.Tasks;
@@ -42,8 +43,8 @@ public override int Read(byte[] buffer, int offset, int count)
         public override int ReadByte()
         {
             byte b = default;
-            int numRead = Read(MemoryMarshal.CreateSpan(ref b, 1));
-            return numRead != 0 ? b : -1;
+            int bytesRead = Read(MemoryMarshal.CreateSpan(ref b, 1));
+            return bytesRead != 0 ? b : -1;
         }
 
         /// <summary>Reads a sequence of bytes from the current Brotli stream to a byte span and advances the position within the Brotli stream by the number of bytes read.</summary>
@@ -57,59 +58,25 @@ public override int Read(Span<byte> buffer)
             if (_mode != CompressionMode.Decompress)
                 throw new InvalidOperationException(SR.BrotliStream_Compress_UnsupportedOperation);
             EnsureNotDisposed();
-            int totalWritten = 0;
 
-            OperationStatus lastResult = OperationStatus.DestinationTooSmall;
-            // We want to continue calling Decompress until we're either out of space for output or until Decompress indicates it is finished.
-            while (buffer.Length > 0 && lastResult != OperationStatus.Done)
+            int bytesWritten;
+            while (!TryDecompress(buffer, out bytesWritten))
             {
-                if (lastResult == OperationStatus.NeedMoreData)
+                int bytesRead = _stream.Read(_buffer, _bufferCount, _buffer.Length - _bufferCount);
+                if (bytesRead <= 0)
                 {
-                    // Ensure any left over data is at the beginning of the array so we can fill the remainder.
-                    if (_bufferCount > 0 && _bufferOffset != 0)
-                    {
-                        _buffer.AsSpan(_bufferOffset, _bufferCount).CopyTo(_buffer);
-                    }
-                    _bufferOffset = 0;
-
-                    int numRead = 0;
-                    while (_bufferCount < _buffer.Length && ((numRead = _stream.Read(_buffer, _bufferCount, _buffer.Length - _bufferCount)) > 0))
-                    {
-                        _bufferCount += numRead;
-                        if (_bufferCount > _buffer.Length)
-                        {
-                            // The stream is either malicious or poorly implemented and returned a number of
-                            // bytes larger than the buffer supplied to it.
-                            throw new InvalidDataException(SR.BrotliStream_Decompress_InvalidStream);
-                        }
-                    }
-
-                    if (_bufferCount <= 0)
-                    {
-                        break;
-                    }
-                }
-
-                lastResult = _decoder.Decompress(new ReadOnlySpan<byte>(_buffer, _bufferOffset, _bufferCount), buffer, out int bytesConsumed, out int bytesWritten);
-                if (lastResult == OperationStatus.InvalidData)
-                {
-                    throw new InvalidOperationException(SR.BrotliStream_Decompress_InvalidData);
+                    break;
                 }
 
-                if (bytesConsumed > 0)
-                {
-                    _bufferOffset += bytesConsumed;
-                    _bufferCount -= bytesConsumed;
-                }
+                _bufferCount += bytesRead;
 
-                if (bytesWritten > 0)
+                if (_bufferCount > _buffer.Length)
                 {
-                    totalWritten += bytesWritten;
-                    buffer = buffer.Slice(bytesWritten);
+                    ThrowInvalidStream();
                 }
             }
 
-            return totalWritten;
+            return bytesWritten;
         }
 
         /// <summary>Begins an asynchronous read operation. (Consider using the <see cref="System.IO.Stream.ReadAsync(byte[],int,int)" /> method instead.)</summary>
@@ -169,73 +136,100 @@ public override Task<int> ReadAsync(byte[] buffer, int offset, int count, Cancel
             {
                 return ValueTask.FromCanceled<int>(cancellationToken);
             }
-            return FinishReadAsyncMemory(buffer, cancellationToken);
-        }
 
-        private async ValueTask<int> FinishReadAsyncMemory(Memory<byte> buffer, CancellationToken cancellationToken)
-        {
-            AsyncOperationStarting();
-            try
+            return Core(buffer, cancellationToken);
+
+            async ValueTask<int> Core(Memory<byte> buffer, CancellationToken cancellationToken)
             {
-                int totalWritten = 0;
-                OperationStatus lastResult = OperationStatus.DestinationTooSmall;
-                // We want to continue calling Decompress until we're either out of space for output or until Decompress indicates it is finished.
-                while (buffer.Length > 0 && lastResult != OperationStatus.Done)
+                AsyncOperationStarting();
+                try
                 {
-                    if (lastResult == OperationStatus.NeedMoreData)
+                    int bytesWritten;
+                    while (!TryDecompress(buffer.Span, out bytesWritten))
                     {
-                        // Ensure any left over data is at the beginning of the array so we can fill the remainder.
-                        if (_bufferCount > 0 && _bufferOffset != 0)
+                        int bytesRead = await _stream.ReadAsync(_buffer.AsMemory(_bufferCount), cancellationToken).ConfigureAwait(false);
+                        if (bytesRead <= 0)
                         {
-                            _buffer.AsSpan(_bufferOffset, _bufferCount).CopyTo(_buffer);
+                            break;
                         }
-                        _bufferOffset = 0;
 
-                        int numRead = 0;
-                        while (_bufferCount < _buffer.Length &&
-                              ((numRead = await _stream.ReadAsync(new Memory<byte>(_buffer, _bufferCount, _buffer.Length - _bufferCount), cancellationToken).ConfigureAwait(false)) > 0))
-                        {
-                            _bufferCount += numRead;
-                            if (_bufferCount > _buffer.Length)
-                            {
-                                // The stream is either malicious or poorly implemented and returned a number of
-                                // bytes larger than the buffer supplied to it.
-                                throw new InvalidDataException(SR.BrotliStream_Decompress_InvalidStream);
-                            }
-                        }
+                        _bufferCount += bytesRead;
 
-                        if (_bufferCount <= 0)
+                        if (_bufferCount > _buffer.Length)
                         {
-                            break;
+                            ThrowInvalidStream();
                         }
                     }
 
-                    cancellationToken.ThrowIfCancellationRequested();
-                    lastResult = _decoder.Decompress(new ReadOnlySpan<byte>(_buffer, _bufferOffset, _bufferCount), buffer.Span, out int bytesConsumed, out int bytesWritten);
-                    if (lastResult == OperationStatus.InvalidData)
-                    {
-                        throw new InvalidOperationException(SR.BrotliStream_Decompress_InvalidData);
-                    }
+                    return bytesWritten;
+                }
+                finally
+                {
+                    AsyncOperationCompleting();
+                }
+            }
+        }
 
-                    if (bytesConsumed > 0)
-                    {
-                        _bufferOffset += bytesConsumed;
-                        _bufferCount -= bytesConsumed;
-                    }
+        /// <summary>Tries to decode available data into the destination buffer.</summary>
+        /// <param name="destination">The destination buffer for the decompressed data.</param>
+        /// <param name="bytesWritten">The number of bytes written to destination.</param>
+        /// <returns>true if the caller should consider the read operation completed; otherwise, false.</returns>
+        private bool TryDecompress(Span<byte> destination, out int bytesWritten)
+        {
+            // Decompress any data we may have in our buffer.
+            OperationStatus lastResult = _decoder.Decompress(new ReadOnlySpan<byte>(_buffer, _bufferOffset, _bufferCount), destination, out int bytesConsumed, out bytesWritten);
+            if (lastResult == OperationStatus.InvalidData)
+            {
+                throw new InvalidOperationException(SR.BrotliStream_Decompress_InvalidData);
+            }
 
-                    if (bytesWritten > 0)
-                    {
-                        totalWritten += bytesWritten;
-                        buffer = buffer.Slice(bytesWritten);
-                    }
-                }
+            if (bytesConsumed != 0)
+            {
+                _bufferOffset += bytesConsumed;
+                _bufferCount -= bytesConsumed;
+            }
+
+            // If we successfully decompressed any bytes, or if we've reached the end of the decompression, we're done.
+            if (bytesWritten != 0 || lastResult == OperationStatus.Done)
+            {
+                return true;
+            }
 
-                return totalWritten;
+            if (destination.IsEmpty)
+            {
+                // The caller provided a zero-byte buffer.  This is typically done in order to avoid allocating/renting
+                // a buffer until data is known to be available.  We don't have perfect knowledge here, as _decoder.Decompress
+                // will return DestinationTooSmall whether or not more data is required.  As such, we assume that if there's
+                // any data in our input buffer, it would have been decompressible into at least one byte of output, and
+                // otherwise we need to do a read on the underlying stream.  This isn't perfect, because having input data
+                // doesn't necessarily mean it'll decompress into at least one byte of output, but it's a reasonable approximation
+                // for the 99% case.  If it's wrong, it just means that a caller using zero-byte reads as a way to delay
+                // getting a buffer to use for a subsequent call may end up getting one earlier than otherwise preferred.
+                Debug.Assert(lastResult == OperationStatus.DestinationTooSmall);
+                if (_bufferCount != 0)
+                {
+                    Debug.Assert(bytesWritten == 0);
+                    return true;
+                }
             }
-            finally
+
+            Debug.Assert(
+                lastResult == OperationStatus.NeedMoreData ||
+                (lastResult == OperationStatus.DestinationTooSmall && destination.IsEmpty && _bufferCount == 0), $"{nameof(lastResult)} == {lastResult}, {nameof(destination.Length)} == {destination.Length}");
+
+            // Ensure any left over data is at the beginning of the array so we can fill the remainder.
+            if (_bufferCount != 0 && _bufferOffset != 0)
             {
-                AsyncOperationCompleting();
+                new ReadOnlySpan<byte>(_buffer, _bufferOffset, _bufferCount).CopyTo(_buffer);
             }
+            _bufferOffset = 0;
+
+            return false;
         }
+
+        private static void ThrowInvalidStream() =>
+            // The stream is either malicious or poorly implemented and returned a number of
+            // bytes larger than the buffer supplied to it.
+            throw new InvalidDataException(SR.BrotliStream_Decompress_InvalidStream);
     }
 }
diff --git a/src/libraries/System.IO.Compression.Brotli/src/System/IO/Compression/enc/BrotliEncoder.cs b/src/libraries/System.IO.Compression.Brotli/src/System/IO/Compression/enc/BrotliEncoder.cs
index 483ffed7d86b7d..fbd813f4412ec1 100644
--- a/src/libraries/System.IO.Compression.Brotli/src/System/IO/Compression/enc/BrotliEncoder.cs
+++ b/src/libraries/System.IO.Compression.Brotli/src/System/IO/Compression/enc/BrotliEncoder.cs
@@ -78,7 +78,7 @@ internal void SetQuality(int quality)
             {
                 throw new ArgumentOutOfRangeException(nameof(quality), SR.Format(SR.BrotliEncoder_Quality, quality, 0, BrotliUtils.Quality_Max));
             }
-            if (!Interop.Brotli.BrotliEncoderSetParameter(_state, BrotliEncoderParameter.Quality, (uint)quality))
+            if (Interop.Brotli.BrotliEncoderSetParameter(_state, BrotliEncoderParameter.Quality, (uint)quality) == Interop.BOOL.FALSE)
             {
                 throw new InvalidOperationException(SR.Format(SR.BrotliEncoder_InvalidSetParameter, "Quality"));
             }
@@ -96,7 +96,7 @@ internal void SetWindow(int window)
             {
                 throw new ArgumentOutOfRangeException(nameof(window), SR.Format(SR.BrotliEncoder_Window, window, BrotliUtils.WindowBits_Min, BrotliUtils.WindowBits_Max));
             }
-            if (!Interop.Brotli.BrotliEncoderSetParameter(_state, BrotliEncoderParameter.LGWin, (uint)window))
+            if (Interop.Brotli.BrotliEncoderSetParameter(_state, BrotliEncoderParameter.LGWin, (uint)window) == Interop.BOOL.FALSE)
             {
                 throw new InvalidOperationException(SR.Format(SR.BrotliEncoder_InvalidSetParameter, "Window"));
             }
@@ -161,7 +161,7 @@ internal OperationStatus Compress(ReadOnlySpan<byte> source, Span<byte> destinat
                     fixed (byte* inBytes = &MemoryMarshal.GetReference(source))
                     fixed (byte* outBytes = &MemoryMarshal.GetReference(destination))
                     {
-                        if (!Interop.Brotli.BrotliEncoderCompressStream(_state, operation, ref availableInput, &inBytes, ref availableOutput, &outBytes, out _))
+                        if (Interop.Brotli.BrotliEncoderCompressStream(_state, operation, ref availableInput, &inBytes, ref availableOutput, &outBytes, out _) == Interop.BOOL.FALSE)
                         {
                             return OperationStatus.InvalidData;
                         }
@@ -173,7 +173,7 @@ internal OperationStatus Compress(ReadOnlySpan<byte> source, Span<byte> destinat
                         bytesWritten += destination.Length - (int)availableOutput;
 
                         // no bytes written, no remaining input to give to the encoder, and no output in need of retrieving means we are Done
-                        if ((int)availableOutput == destination.Length && !Interop.Brotli.BrotliEncoderHasMoreOutput(_state) && availableInput == 0)
+                        if ((int)availableOutput == destination.Length && Interop.Brotli.BrotliEncoderHasMoreOutput(_state) == Interop.BOOL.FALSE && availableInput == 0)
                         {
                             return OperationStatus.Done;
                         }
@@ -218,7 +218,7 @@ public static bool TryCompress(ReadOnlySpan<byte> source, Span<byte> destination
                 fixed (byte* outBytes = &MemoryMarshal.GetReference(destination))
                 {
                     nuint availableOutput = (nuint)destination.Length;
-                    bool success = Interop.Brotli.BrotliEncoderCompress(quality, window, /*BrotliEncoderMode*/ 0, (nuint)source.Length, inBytes, ref availableOutput, outBytes);
+                    bool success = Interop.Brotli.BrotliEncoderCompress(quality, window, /*BrotliEncoderMode*/ 0, (nuint)source.Length, inBytes, &availableOutput, outBytes) != Interop.BOOL.FALSE;
 
                     Debug.Assert(success ? availableOutput <= (nuint)destination.Length : availableOutput == 0);
 
diff --git a/src/libraries/System.IO.Compression.Brotli/src/System/IO/Compression/enc/BrotliStream.Compress.cs b/src/libraries/System.IO.Compression.Brotli/src/System/IO/Compression/enc/BrotliStream.Compress.cs
index 44a368f58eeec2..efa17bc5f9cbb7 100644
--- a/src/libraries/System.IO.Compression.Brotli/src/System/IO/Compression/enc/BrotliStream.Compress.cs
+++ b/src/libraries/System.IO.Compression.Brotli/src/System/IO/Compression/enc/BrotliStream.Compress.cs
@@ -68,8 +68,8 @@ internal void WriteCore(ReadOnlySpan<byte> buffer, bool isFinalBlock = false)
             Span<byte> output = new Span<byte>(_buffer);
             while (lastResult == OperationStatus.DestinationTooSmall)
             {
-                int bytesConsumed = 0;
-                int bytesWritten = 0;
+                int bytesConsumed;
+                int bytesWritten;
                 lastResult = _encoder.Compress(buffer, output, out bytesConsumed, out bytesWritten, isFinalBlock);
                 if (lastResult == OperationStatus.InvalidData)
                     throw new InvalidOperationException(SR.BrotliStream_Compress_InvalidData);
@@ -176,7 +176,7 @@ public override void Flush()
                 Span<byte> output = new Span<byte>(_buffer);
                 while (lastResult == OperationStatus.DestinationTooSmall)
                 {
-                    int bytesWritten = 0;
+                    int bytesWritten;
                     lastResult = _encoder.Flush(output, out bytesWritten);
                     if (lastResult == OperationStatus.InvalidData)
                         throw new InvalidDataException(SR.BrotliStream_Compress_InvalidData);
diff --git a/src/libraries/System.IO.Compression.Brotli/tests/CompressionStreamUnitTests.Brotli.cs b/src/libraries/System.IO.Compression.Brotli/tests/CompressionStreamUnitTests.Brotli.cs
index 3960233e5eafa8..96eff305a0ef3e 100644
--- a/src/libraries/System.IO.Compression.Brotli/tests/CompressionStreamUnitTests.Brotli.cs
+++ b/src/libraries/System.IO.Compression.Brotli/tests/CompressionStreamUnitTests.Brotli.cs
@@ -14,7 +14,8 @@ public class BrotliStreamUnitTests : CompressionStreamUnitTestBase
         public override Stream CreateStream(Stream stream, CompressionLevel level) => new BrotliStream(stream, level);
         public override Stream CreateStream(Stream stream, CompressionLevel level, bool leaveOpen) => new BrotliStream(stream, level, leaveOpen);
         public override Stream BaseStream(Stream stream) => ((BrotliStream)stream).BaseStream;
-        protected override bool ReadsMayBlockUntilBufferFullOrEOF => true;
+
+        protected override bool FlushGuaranteesAllDataWritten => false;
 
         // The tests are relying on an implementation detail of BrotliStream, using knowledge of its internal buffer size
         // in various test calculations.  Currently the implementation is using the ArrayPool, which will round up to a
diff --git a/src/libraries/System.IO.Compression/src/System/IO/Compression/DeflateZLib/DeflateStream.cs b/src/libraries/System.IO.Compression/src/System/IO/Compression/DeflateZLib/DeflateStream.cs
index d9739b087b7041..84b7ad0e5acade 100644
--- a/src/libraries/System.IO.Compression/src/System/IO/Compression/DeflateZLib/DeflateStream.cs
+++ b/src/libraries/System.IO.Compression/src/System/IO/Compression/DeflateZLib/DeflateStream.cs
@@ -104,12 +104,14 @@ internal void InitializeDeflater(Stream stream, bool leaveOpen, int windowBits,
             InitializeBuffer();
         }
 
+        [MemberNotNull(nameof(_buffer))]
         private void InitializeBuffer()
         {
             Debug.Assert(_buffer == null);
             _buffer = ArrayPool<byte>.Shared.Rent(DefaultBufferSize);
         }
 
+        [MemberNotNull(nameof(_buffer))]
         private void EnsureBufferInitialized()
         {
             if (_buffer == null)
@@ -259,83 +261,94 @@ internal int ReadCore(Span<byte> buffer)
             EnsureDecompressionMode();
             EnsureNotDisposed();
             EnsureBufferInitialized();
-
-            int totalRead = 0;
-
             Debug.Assert(_inflater != null);
+
+            int bytesRead;
             while (true)
             {
-                int bytesRead = _inflater.Inflate(buffer.Slice(totalRead));
-                totalRead += bytesRead;
-                if (totalRead == buffer.Length)
-                {
-                    break;
-                }
-
-                // If the stream is finished then we have a few potential cases here:
-                // 1. DeflateStream => return
-                // 2. GZipStream that is finished but may have an additional GZipStream appended => feed more input
-                // 3. GZipStream that is finished and appended with garbage => return
-                if (_inflater.Finished() && (!_inflater.IsGzipStream() || !_inflater.NeedsInput()))
+                // Try to decompress any data from the inflater into the caller's buffer.
+                // If we're able to decompress any bytes, or if decompression is completed, we're done.
+                bytesRead = _inflater.Inflate(buffer);
+                if (bytesRead != 0 || InflatorIsFinished)
                 {
                     break;
                 }
 
+                // We were unable to decompress any data.  If the inflater needs additional input
+                // data to proceed, read some to populate it.
                 if (_inflater.NeedsInput())
                 {
-                    Debug.Assert(_buffer != null);
-                    int bytes = _stream.Read(_buffer, 0, _buffer.Length);
-                    if (bytes <= 0)
+                    int n = _stream.Read(_buffer, 0, _buffer.Length);
+                    if (n <= 0)
                     {
                         break;
                     }
-                    else if (bytes > _buffer.Length)
+                    else if (n > _buffer.Length)
+                    {
+                        ThrowGenericInvalidData();
+                    }
+                    else
                     {
-                        // The stream is either malicious or poorly implemented and returned a number of
-                        // bytes larger than the buffer supplied to it.
-                        throw new InvalidDataException(SR.GenericInvalidData);
+                        _inflater.SetInput(_buffer, 0, n);
                     }
+                }
 
-                    _inflater.SetInput(_buffer, 0, bytes);
+                if (buffer.IsEmpty)
+                {
+                    // The caller provided a zero-byte buffer.  This is typically done in order to avoid allocating/renting
+                    // a buffer until data is known to be available.  We don't have perfect knowledge here, as _inflater.Inflate
+                    // will return 0 whether or not more data is required, and having input data doesn't necessarily mean it'll
+                    // decompress into at least one byte of output, but it's a reasonable approximation for the 99% case.  If it's
+                    // wrong, it just means that a caller using zero-byte reads as a way to delay getting a buffer to use for a
+                    // subsequent call may end up getting one earlier than otherwise preferred.
+                    Debug.Assert(bytesRead == 0);
+                    break;
                 }
             }
 
-            return totalRead;
+            return bytesRead;
         }
 
+        private bool InflatorIsFinished =>
+            // If the stream is finished then we have a few potential cases here:
+            // 1. DeflateStream => return
+            // 2. GZipStream that is finished but may have an additional GZipStream appended => feed more input
+            // 3. GZipStream that is finished and appended with garbage => return
+            _inflater!.Finished() &&
+            (!_inflater.IsGzipStream() || !_inflater.NeedsInput());
+
         private void EnsureNotDisposed()
         {
             if (_stream == null)
                 ThrowStreamClosedException();
-        }
 
-        private static void ThrowStreamClosedException()
-        {
-            throw new ObjectDisposedException(nameof(DeflateStream), SR.ObjectDisposed_StreamClosed);
+            static void ThrowStreamClosedException() =>
+                throw new ObjectDisposedException(nameof(DeflateStream), SR.ObjectDisposed_StreamClosed);
         }
 
         private void EnsureDecompressionMode()
         {
             if (_mode != CompressionMode.Decompress)
                 ThrowCannotReadFromDeflateStreamException();
-        }
 
-        private static void ThrowCannotReadFromDeflateStreamException()
-        {
-            throw new InvalidOperationException(SR.CannotReadFromDeflateStream);
+            static void ThrowCannotReadFromDeflateStreamException() =>
+                throw new InvalidOperationException(SR.CannotReadFromDeflateStream);
         }
 
         private void EnsureCompressionMode()
         {
             if (_mode != CompressionMode.Compress)
                 ThrowCannotWriteToDeflateStreamException();
-        }
 
-        private static void ThrowCannotWriteToDeflateStreamException()
-        {
-            throw new InvalidOperationException(SR.CannotWriteToDeflateStream);
+            static void ThrowCannotWriteToDeflateStreamException() =>
+                throw new InvalidOperationException(SR.CannotWriteToDeflateStream);
         }
 
+        private static void ThrowGenericInvalidData() =>
+            // The stream is either malicious or poorly implemented and returned a number of
+            // bytes < 0 || > than the buffer supplied to it.
+            throw new InvalidDataException(SR.GenericInvalidData);
+
         public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback? asyncCallback, object? asyncState) =>
             TaskToApm.Begin(ReadAsync(buffer, offset, count, CancellationToken.None), asyncCallback, asyncState);
 
@@ -378,6 +391,7 @@ internal ValueTask<int> ReadAsyncMemory(Memory<byte> buffer, CancellationToken c
             }
 
             EnsureBufferInitialized();
+            Debug.Assert(_inflater != null);
 
             return Core(buffer, cancellationToken);
 
@@ -386,48 +400,49 @@ async ValueTask<int> Core(Memory<byte> buffer, CancellationToken cancellationTok
                 AsyncOperationStarting();
                 try
                 {
-                    int totalRead = 0;
-
-                    Debug.Assert(_inflater != null);
+                    int bytesRead;
                     while (true)
                     {
-                        int bytesRead = _inflater.Inflate(buffer.Span.Slice(totalRead));
-                        totalRead += bytesRead;
-                        if (totalRead == buffer.Length)
-                        {
-                            break;
-                        }
-
-                        // If the stream is finished then we have a few potential cases here:
-                        // 1. DeflateStream => return
-                        // 2. GZipStream that is finished but may have an additional GZipStream appended => feed more input
-                        // 3. GZipStream that is finished and appended with garbage => return
-                        if (_inflater.Finished() && (!_inflater.IsGzipStream() || !_inflater.NeedsInput()))
+                        // Try to decompress any data from the inflater into the caller's buffer.
+                        // If we're able to decompress any bytes, or if decompression is completed, we're done.
+                        bytesRead = _inflater.Inflate(buffer.Span);
+                        if (bytesRead != 0 || InflatorIsFinished)
                         {
                             break;
                         }
 
+                        // We were unable to decompress any data.  If the inflater needs additional input
+                        // data to proceed, read some to populate it.
                         if (_inflater.NeedsInput())
                         {
-                            Debug.Assert(_buffer != null);
-                            int bytes = await _stream.ReadAsync(_buffer, cancellationToken).ConfigureAwait(false);
-                            EnsureNotDisposed();
-                            if (bytes <= 0)
+                            int n = await _stream.ReadAsync(new Memory<byte>(_buffer, 0, _buffer.Length), cancellationToken).ConfigureAwait(false);
+                            if (n <= 0)
                             {
                                 break;
                             }
-                            else if (bytes > _buffer.Length)
+                            else if (n > _buffer.Length)
                             {
-                                // The stream is either malicious or poorly implemented and returned a number of
-                                // bytes larger than the buffer supplied to it.
-                                throw new InvalidDataException(SR.GenericInvalidData);
+                                ThrowGenericInvalidData();
                             }
+                            else
+                            {
+                                _inflater.SetInput(_buffer, 0, n);
+                            }
+                        }
 
-                            _inflater.SetInput(_buffer, 0, bytes);
+                        if (buffer.IsEmpty)
+                        {
+                            // The caller provided a zero-byte buffer.  This is typically done in order to avoid allocating/renting
+                            // a buffer until data is known to be available.  We don't have perfect knowledge here, as _inflater.Inflate
+                            // will return 0 whether or not more data is required, and having input data doesn't necessarily mean it'll
+                            // decompress into at least one byte of output, but it's a reasonable approximation for the 99% case.  If it's
+                            // wrong, it just means that a caller using zero-byte reads as a way to delay getting a buffer to use for a
+                            // subsequent call may end up getting one earlier than otherwise preferred.
+                            break;
                         }
                     }
 
-                    return totalRead;
+                    return bytesRead;
                 }
                 finally
                 {
@@ -1014,21 +1029,16 @@ private void EnsureNoActiveAsyncOperation()
 
         private void AsyncOperationStarting()
         {
-            if (Interlocked.CompareExchange(ref _activeAsyncOperation, 1, 0) != 0)
+            if (Interlocked.Exchange(ref _activeAsyncOperation, 1) != 0)
             {
                 ThrowInvalidBeginCall();
             }
         }
 
-        private void AsyncOperationCompleting()
-        {
-            int oldValue = Interlocked.CompareExchange(ref _activeAsyncOperation, 0, 1);
-            Debug.Assert(oldValue == 1, $"Expected {nameof(_activeAsyncOperation)} to be 1, got {oldValue}");
-        }
+        private void AsyncOperationCompleting() =>
+            Volatile.Write(ref _activeAsyncOperation, 0);
 
-        private static void ThrowInvalidBeginCall()
-        {
+        private static void ThrowInvalidBeginCall() =>
             throw new InvalidOperationException(SR.InvalidBeginCall);
-        }
     }
 }
diff --git a/src/libraries/System.IO.FileSystem.AccessControl/Directory.Build.props b/src/libraries/System.IO.FileSystem.AccessControl/Directory.Build.props
index 64a6b75c96c406..709a22a7537088 100644
--- a/src/libraries/System.IO.FileSystem.AccessControl/Directory.Build.props
+++ b/src/libraries/System.IO.FileSystem.AccessControl/Directory.Build.props
@@ -3,15 +3,5 @@
   <PropertyGroup>
     <StrongNameKeyId>Microsoft</StrongNameKeyId>
     <SupportedOSPlatforms>windows</SupportedOSPlatforms>
-    <PackageDescription>Provides types for managing access and audit control lists for files and directories.
-
-Commonly Used Types:
-System.Security.AccessControl.DirectoryObjectSecurity
-System.Security.AccessControl.DirectorySecurity
-System.Security.AccessControl.FileSecurity
-System.Security.AccessControl.FileSystemAccessRule
-System.Security.AccessControl.FileSystemAuditRule
-System.Security.AccessControl.FileSystemRights
-System.Security.AccessControl.FileSystemSecurity</PackageDescription>
   </PropertyGroup>
 </Project>
\ No newline at end of file
diff --git a/src/libraries/System.IO.FileSystem.AccessControl/NuGet.config b/src/libraries/System.IO.FileSystem.AccessControl/NuGet.config
deleted file mode 100644
index a66b7f9b013241..00000000000000
--- a/src/libraries/System.IO.FileSystem.AccessControl/NuGet.config
+++ /dev/null
@@ -1,12 +0,0 @@
-<configuration>
-  <!-- This disables restore in VS for projects that target platform specific target frameworks older than net5.0. -->
-  <packageRestore>
-    <!-- The 'automatic' key is set to True when the "Automatically check for missing packages during
-         build in Visual Studio" checkbox is set. Clearing the box sets this to False and disables
-         automatic restore. -->
-    <add key="automatic" value="False" />
-    <!-- The 'enabled' key is True when the "Allow NuGet to download missing packages" checkbox is set.
-         Clearing the box sets this to False, disabling command-line, automatic, and MSBuild-integrated restore. -->
-    <add key="enabled" value="False" />
-  </packageRestore>
-</configuration>
\ No newline at end of file
diff --git a/src/libraries/System.IO.FileSystem.AccessControl/pkg/System.IO.FileSystem.AccessControl.pkgproj b/src/libraries/System.IO.FileSystem.AccessControl/pkg/System.IO.FileSystem.AccessControl.pkgproj
deleted file mode 100644
index f6c16d48b531e8..00000000000000
--- a/src/libraries/System.IO.FileSystem.AccessControl/pkg/System.IO.FileSystem.AccessControl.pkgproj
+++ /dev/null
@@ -1,12 +0,0 @@
-<Project DefaultTargets="Build">
-  <Import Project="$([MSBuild]::GetPathOfFileAbove(Directory.Build.props))" />
-  <ItemGroup>
-    <ProjectReference Include="..\ref\System.IO.FileSystem.AccessControl.csproj">
-      <SupportedFramework>net461;netcoreapp2.0;uap10.0.16299;$(AllXamarinFrameworks)</SupportedFramework>
-    </ProjectReference>
-    <ProjectReference Include="..\src\System.IO.FileSystem.AccessControl.csproj" />
-    <!-- Exclude TFMs that aren't supported by the package anymore from validation. -->
-    <ExcludeHarvestedSupportedFramework Include="netcoreapp1.0;netcoreapp1.1;netcore50;uap10.0;net46" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetPathOfFileAbove(Directory.Build.targets))" />
-</Project>
\ No newline at end of file
diff --git a/src/libraries/System.IO.FileSystem.AccessControl/ref/System.IO.FileSystem.AccessControl.FileSystemAclExtensions.cs b/src/libraries/System.IO.FileSystem.AccessControl/ref/System.IO.FileSystem.AccessControl.FileSystemAclExtensions.cs
deleted file mode 100644
index 7bba41856ed222..00000000000000
--- a/src/libraries/System.IO.FileSystem.AccessControl/ref/System.IO.FileSystem.AccessControl.FileSystemAclExtensions.cs
+++ /dev/null
@@ -1,23 +0,0 @@
-// 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.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.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; }
-        public static System.Security.AccessControl.FileSecurity GetAccessControl(this System.IO.FileInfo fileInfo) { throw null; }
-        public static System.Security.AccessControl.FileSecurity GetAccessControl(this System.IO.FileInfo fileInfo, System.Security.AccessControl.AccessControlSections includeSections) { throw null; }
-        public static System.Security.AccessControl.FileSecurity GetAccessControl(this System.IO.FileStream fileStream) { throw null; }
-        public static void SetAccessControl(this System.IO.DirectoryInfo directoryInfo, System.Security.AccessControl.DirectorySecurity directorySecurity) { }
-        public static void SetAccessControl(this System.IO.FileInfo fileInfo, System.Security.AccessControl.FileSecurity fileSecurity) { }
-        public static void SetAccessControl(this System.IO.FileStream fileStream, System.Security.AccessControl.FileSecurity fileSecurity) { }
-    }
-}
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 01990765c3afb0..64455bbc92ccb6 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
@@ -4,6 +4,23 @@
 // Changes to this file must follow the https://aka.ms/api-review process.
 // ------------------------------------------------------------------------------
 
+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.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; }
+        public static System.Security.AccessControl.FileSecurity GetAccessControl(this System.IO.FileInfo fileInfo) { throw null; }
+        public static System.Security.AccessControl.FileSecurity GetAccessControl(this System.IO.FileInfo fileInfo, System.Security.AccessControl.AccessControlSections includeSections) { throw null; }
+        public static System.Security.AccessControl.FileSecurity GetAccessControl(this System.IO.FileStream fileStream) { throw null; }
+        public static void SetAccessControl(this System.IO.DirectoryInfo directoryInfo, System.Security.AccessControl.DirectorySecurity directorySecurity) { }
+        public static void SetAccessControl(this System.IO.FileInfo fileInfo, System.Security.AccessControl.FileSecurity fileSecurity) { }
+        public static void SetAccessControl(this System.IO.FileStream fileStream, System.Security.AccessControl.FileSecurity fileSecurity) { }
+    }
+}
 namespace System.Security.AccessControl
 {
     public abstract partial class DirectoryObjectSecurity : System.Security.AccessControl.ObjectSecurity
diff --git a/src/libraries/System.IO.FileSystem.AccessControl/ref/System.IO.FileSystem.AccessControl.csproj b/src/libraries/System.IO.FileSystem.AccessControl/ref/System.IO.FileSystem.AccessControl.csproj
index 48ce7b7289990a..5aab0ab81639e0 100644
--- a/src/libraries/System.IO.FileSystem.AccessControl/ref/System.IO.FileSystem.AccessControl.csproj
+++ b/src/libraries/System.IO.FileSystem.AccessControl/ref/System.IO.FileSystem.AccessControl.csproj
@@ -1,15 +1,13 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFrameworks>netstandard2.0;net461</TargetFrameworks>
+    <TargetFrameworks>$(NetCoreAppCurrent)</TargetFrameworks>
     <Nullable>enable</Nullable>
   </PropertyGroup>
   <ItemGroup>
-    <Compile Include="System.IO.FileSystem.AccessControl.FileSystemAclExtensions.cs" />
-    <Compile Condition="'$(TargetFramework)' != 'net461'" Include="System.IO.FileSystem.AccessControl.cs" />
-    <Compile Condition="'$(TargetFramework)' == 'net461'" Include="System.IO.FileSystem.AccessControl.net461.cs" />
+    <Compile Include="System.IO.FileSystem.AccessControl.cs" />
   </ItemGroup>
-  <ItemGroup Condition="'$(TargetFramework)' != 'net461'">
-    <ProjectReference Include="..\..\System.Security.AccessControl\ref\System.Security.AccessControl.csproj" />
-    <ProjectReference Include="..\..\System.Security.Principal.Windows\ref\System.Security.Principal.Windows.csproj" />
+  <ItemGroup>
+    <ProjectReference Include="$(LibrariesProjectRoot)System.IO.FileSystem\ref\System.IO.FileSystem.csproj" />
+    <ProjectReference Include="$(LibrariesProjectRoot)System.Security.AccessControl\ref\System.Security.AccessControl.csproj" />
   </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/src/libraries/System.IO.FileSystem.AccessControl/ref/System.IO.FileSystem.AccessControl.net461.cs b/src/libraries/System.IO.FileSystem.AccessControl/ref/System.IO.FileSystem.AccessControl.net461.cs
deleted file mode 100644
index 29364199c23857..00000000000000
--- a/src/libraries/System.IO.FileSystem.AccessControl/ref/System.IO.FileSystem.AccessControl.net461.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.
-// ------------------------------------------------------------------------------
-// Changes to this file must follow the https://aka.ms/api-review process.
-// ------------------------------------------------------------------------------
-
-using System.Runtime.CompilerServices;
-
-[assembly: TypeForwardedTo(typeof(System.Security.AccessControl.DirectoryObjectSecurity))]
-[assembly: TypeForwardedTo(typeof(System.Security.AccessControl.DirectorySecurity))]
-[assembly: TypeForwardedTo(typeof(System.Security.AccessControl.FileSecurity))]
-[assembly: TypeForwardedTo(typeof(System.Security.AccessControl.FileSystemAccessRule))]
-[assembly: TypeForwardedTo(typeof(System.Security.AccessControl.FileSystemAuditRule))]
-[assembly: TypeForwardedTo(typeof(System.Security.AccessControl.FileSystemRights))]
-[assembly: TypeForwardedTo(typeof(System.Security.AccessControl.FileSystemSecurity))]
diff --git a/src/libraries/System.IO.FileSystem.AccessControl/src/System.IO.FileSystem.AccessControl.csproj b/src/libraries/System.IO.FileSystem.AccessControl/src/System.IO.FileSystem.AccessControl.csproj
index a3d152ecf94b40..6e662893f353c2 100644
--- a/src/libraries/System.IO.FileSystem.AccessControl/src/System.IO.FileSystem.AccessControl.csproj
+++ b/src/libraries/System.IO.FileSystem.AccessControl/src/System.IO.FileSystem.AccessControl.csproj
@@ -1,21 +1,15 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFrameworks>$(NetCoreAppCurrent)-windows;netstandard2.0;netstandard2.0-windows;net461-windows</TargetFrameworks>
-    <ExcludeCurrentNetCoreAppFromPackage>true</ExcludeCurrentNetCoreAppFromPackage>
+    <TargetFrameworks>$(NetCoreAppCurrent)-windows;$(NetCoreAppCurrent)</TargetFrameworks>
     <Nullable>enable</Nullable>
   </PropertyGroup>
   <!-- DesignTimeBuild requires all the TargetFramework Derived Properties to not be present in the first property group. -->
   <PropertyGroup>
-    <IsPartialFacadeAssembly Condition="$(TargetFramework.StartsWith('net4'))">true</IsPartialFacadeAssembly>
     <AllowUnsafeBlocks Condition="'$(TargetsWindows)' == 'true'">true</AllowUnsafeBlocks>
     <GeneratePlatformNotSupportedAssemblyMessage Condition="'$(TargetsWindows)' != 'true'">SR.PlatformNotSupported_AccessControl</GeneratePlatformNotSupportedAssemblyMessage>
   </PropertyGroup>
-  <ItemGroup Condition="!$(TargetFramework.StartsWith('$(NetCoreAppCurrent)'))">
-    <Compile Include="$(CoreLibSharedDir)System\Runtime\InteropServices\SuppressGCTransitionAttribute.cs"
-             Link="System\Runtime\InteropServices\SuppressGCTransitionAttribute.cs" />
-  </ItemGroup>
   <!-- Source includes -->
-  <ItemGroup Condition="'$(TargetsWindows)' == 'true' and !$(TargetFramework.StartsWith('net4'))">
+  <ItemGroup Condition="'$(TargetsWindows)' == 'true'">
     <Compile Include="$(CommonPath)Interop\Windows\Interop.Errors.cs"
              Link="Common\Interop\Windows\Interop.Errors.cs" />
     <Compile Include="$(CommonPath)System\NotImplemented.cs"
@@ -91,14 +85,9 @@
     <Compile Include="$(CommonPath)System\IO\FileSystem.DirectoryCreation.Windows.cs"
              Link="Common\System\IO\FileSystem.DirectoryCreation.Windows.cs" />
   </ItemGroup>
-  <ItemGroup Condition="$(TargetFramework.StartsWith('net4'))">
-    <Compile Include="System\IO\FileSystemAclExtensions.net46.cs" />
-  </ItemGroup>
-  <ItemGroup Condition="'$(IsPartialFacadeAssembly)' != 'true'">
+  <ItemGroup>
     <ProjectReference Include="$(LibrariesProjectRoot)System.Security.AccessControl\src\System.Security.AccessControl.csproj" />
     <ProjectReference Include="$(LibrariesProjectRoot)System.Security.Principal.Windows\src\System.Security.Principal.Windows.csproj" />
-  </ItemGroup>
-  <ItemGroup Condition="$(TargetFramework.StartsWith('$(NetCoreAppCurrent)'))">
     <Reference Include="System.Buffers" Condition="'$(TargetsWindows)' == 'true'" />
     <Reference Include="System.Collections" Condition="'$(TargetsWindows)' == 'true'" />
     <Reference Include="System.Collections.NonGeneric" />
@@ -112,9 +101,4 @@
     <Reference Include="System.Runtime.InteropServices" Condition="'$(TargetsWindows)' == 'true'" />
     <Reference Include="System.Threading.Tasks" Condition="'$(TargetsWindows)' == 'true'" />
   </ItemGroup>
-  <ItemGroup Condition="$(TargetFramework.StartsWith('netstandard'))">
-    <PackageReference Include="System.Buffers" Version="$(SystemBuffersVersion)" />
-    <PackageReference Include="System.Memory" Version="$(SystemMemoryVersion)" />
-    <ProjectReference Include="$(LibrariesProjectRoot)System.Runtime.CompilerServices.Unsafe\src\System.Runtime.CompilerServices.Unsafe.ilproj" />
-  </ItemGroup>
 </Project>
diff --git a/src/libraries/System.IO.FileSystem.AccessControl/src/System/IO/FileSystemAclExtensions.net46.cs b/src/libraries/System.IO.FileSystem.AccessControl/src/System/IO/FileSystemAclExtensions.net46.cs
deleted file mode 100644
index 5fdb118b406dae..00000000000000
--- a/src/libraries/System.IO.FileSystem.AccessControl/src/System/IO/FileSystemAclExtensions.net46.cs
+++ /dev/null
@@ -1,119 +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.AccessControl;
-
-namespace System.IO
-{
-    public static class FileSystemAclExtensions
-    {
-        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));
-
-            return new FileStream(fileInfo.FullName, mode, rights, share, bufferSize, options, fileSecurity);
-        }
-
-        public static void Create(this DirectoryInfo directoryInfo, DirectorySecurity directorySecurity)
-        {
-            if (directoryInfo == null)
-                throw new ArgumentNullException(nameof(directoryInfo));
-
-            if (directorySecurity == null)
-                throw new ArgumentNullException(nameof(directorySecurity));
-
-            directoryInfo.Create(directorySecurity);
-        }
-
-        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);
-
-            return Directory.CreateDirectory(path, directorySecurity);
-        }
-
-        public static DirectorySecurity GetAccessControl(this DirectoryInfo directoryInfo)
-        {
-            if (directoryInfo == null)
-                throw new ArgumentNullException(nameof(directoryInfo));
-
-            return directoryInfo.GetAccessControl();
-        }
-
-        public static DirectorySecurity GetAccessControl(this DirectoryInfo directoryInfo, AccessControlSections includeSections)
-        {
-            if (directoryInfo == null)
-                throw new ArgumentNullException(nameof(directoryInfo));
-
-            return directoryInfo.GetAccessControl(includeSections);
-        }
-
-        public static void SetAccessControl(this DirectoryInfo directoryInfo, DirectorySecurity directorySecurity)
-        {
-            if (directoryInfo == null)
-                throw new ArgumentNullException(nameof(directoryInfo));
-
-            if (directorySecurity == null)
-                throw new ArgumentNullException(nameof(directorySecurity));
-
-            directoryInfo.SetAccessControl(directorySecurity);
-        }
-
-        public static FileSecurity GetAccessControl(this FileInfo fileInfo)
-        {
-            if (fileInfo == null)
-                throw new ArgumentNullException(nameof(fileInfo));
-
-            return fileInfo.GetAccessControl();
-        }
-
-        public static FileSecurity GetAccessControl(this FileInfo fileInfo, AccessControlSections includeSections)
-        {
-            if (fileInfo == null)
-                throw new ArgumentNullException(nameof(fileInfo));
-
-            return fileInfo.GetAccessControl(includeSections);
-        }
-
-        public static void SetAccessControl(this FileInfo fileInfo, FileSecurity fileSecurity)
-        {
-            if (fileInfo == null)
-                throw new ArgumentNullException(nameof(fileInfo));
-
-            if (fileSecurity == null)
-                throw new ArgumentNullException(nameof(fileSecurity));
-
-            fileInfo.SetAccessControl(fileSecurity);
-        }
-
-        public static FileSecurity GetAccessControl(this FileStream fileStream)
-        {
-            if (fileStream == null)
-                throw new ArgumentNullException(nameof(fileStream));
-
-            return fileStream.GetAccessControl();
-        }
-
-        public static void SetAccessControl(this FileStream fileStream, FileSecurity fileSecurity)
-        {
-            if (fileStream == null)
-                throw new ArgumentNullException(nameof(fileStream));
-
-            if (fileSecurity == null)
-                throw new ArgumentNullException(nameof(fileSecurity));
-
-            fileStream.SetAccessControl(fileSecurity);
-        }
-    }
-}
diff --git a/src/libraries/System.IO.FileSystem.AccessControl/tests/System.IO.FileSystem.AccessControl.Tests.csproj b/src/libraries/System.IO.FileSystem.AccessControl/tests/System.IO.FileSystem.AccessControl.Tests.csproj
index 8c4fa0e42afcd1..549173eee44fad 100644
--- a/src/libraries/System.IO.FileSystem.AccessControl/tests/System.IO.FileSystem.AccessControl.Tests.csproj
+++ b/src/libraries/System.IO.FileSystem.AccessControl/tests/System.IO.FileSystem.AccessControl.Tests.csproj
@@ -1,6 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFrameworks>$(NetCoreAppCurrent)-windows;net461-windows</TargetFrameworks>
+    <TargetFrameworks>$(NetCoreAppCurrent)-windows</TargetFrameworks>
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="DirectoryObjectSecurityTests.cs" />
@@ -17,11 +17,6 @@
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\src\System.IO.FileSystem.AccessControl.csproj" SkipUseReferenceAssembly="true" />
-  </ItemGroup>
-  <ItemGroup Condition="$(TargetFramework.StartsWith('$(NetCoreAppCurrent)'))">
     <ProjectReference Include="$(LibrariesProjectRoot)System.DirectoryServices\src\System.DirectoryServices.csproj" />
   </ItemGroup>
-  <ItemGroup Condition="'$(TargetFramework)' == 'net461'">
-    <Reference Include="System.DirectoryServices" />
-  </ItemGroup>
 </Project>
diff --git a/src/libraries/System.IO.FileSystem.DriveInfo/src/System/IO/DriveInfo.UnixOrBrowser.cs b/src/libraries/System.IO.FileSystem.DriveInfo/src/System/IO/DriveInfo.UnixOrBrowser.cs
index 51892986a5df68..b39b2232288345 100644
--- a/src/libraries/System.IO.FileSystem.DriveInfo/src/System/IO/DriveInfo.UnixOrBrowser.cs
+++ b/src/libraries/System.IO.FileSystem.DriveInfo/src/System/IO/DriveInfo.UnixOrBrowser.cs
@@ -24,7 +24,7 @@ public static DriveInfo[] GetDrives()
 
         private static string NormalizeDriveName(string driveName)
         {
-            if (driveName.Contains("\0")) // string.Contains(char) is .NetCore2.1+ specific
+            if (driveName.Contains('\0'))
             {
                 throw new ArgumentException(SR.Format(SR.Arg_InvalidDriveChars, driveName), nameof(driveName));
             }
diff --git a/src/libraries/System.IO.FileSystem/tests/File/AppendAsync.cs b/src/libraries/System.IO.FileSystem/tests/File/AppendAsync.cs
index 04d7ebec7ae4d8..457366266d69cf 100644
--- a/src/libraries/System.IO.FileSystem/tests/File/AppendAsync.cs
+++ b/src/libraries/System.IO.FileSystem/tests/File/AppendAsync.cs
@@ -86,7 +86,7 @@ public override Task TaskAlreadyCanceledAsync()
         }
     }
 
-    [ActiveIssue("https://github.com/dotnet/runtime/issues/34583", TestPlatforms.Windows, TargetFrameworkMonikers.Netcoreapp, TestRuntimes.Mono)]
+    [ActiveIssue("https://github.com/dotnet/runtime/issues/34582", TestPlatforms.Windows, TargetFrameworkMonikers.Netcoreapp, TestRuntimes.Mono)]
     public class File_AppendAllLinesAsync_Encoded : File_AppendAllLinesAsync
     {
         protected override Task WriteAsync(string path, string[] content) =>
diff --git a/src/libraries/System.IO.FileSystem/tests/File/Create.cs b/src/libraries/System.IO.FileSystem/tests/File/Create.cs
index a4a8de349f3bb3..bf0417dbfe0610 100644
--- a/src/libraries/System.IO.FileSystem/tests/File/Create.cs
+++ b/src/libraries/System.IO.FileSystem/tests/File/Create.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.Linq;
 using Xunit;
 
 namespace System.IO.Tests
@@ -51,6 +52,37 @@ public void ValidCreation()
             }
         }
 
+        [Fact]
+        public void CreateAndOverwrite()
+        {
+            const byte initialContent = 1;
+
+            DirectoryInfo testDir = Directory.CreateDirectory(GetTestFilePath());
+            string testFile = Path.Combine(testDir.FullName, GetTestFileName());
+
+            // Create
+            using (FileStream stream = Create(testFile))
+            {
+                Assert.True(File.Exists(testFile));
+
+                stream.WriteByte(initialContent);
+
+                Assert.Equal(1, stream.Length);
+                Assert.Equal(1, stream.Position);
+            }
+
+            Assert.Equal(initialContent, File.ReadAllBytes(testFile).Single());
+
+            // Overwrite
+            using (FileStream stream = Create(testFile))
+            {
+                Assert.Equal(0, stream.Length);
+                Assert.Equal(0, stream.Position);
+            }
+
+            Assert.Empty(File.ReadAllBytes(testFile));
+        }
+
         [ConditionalFact(nameof(UsingNewNormalization))]
         [PlatformSpecific(TestPlatforms.Windows)]  // Valid Windows path extended prefix
         public void ValidCreation_ExtendedSyntax()
@@ -335,7 +367,7 @@ public void NegativeBuffer()
             Assert.Throws<ArgumentOutOfRangeException>(() => Create(GetTestFilePath(), -100));
         }
     }
-    [ActiveIssue("https://github.com/dotnet/runtime/issues/34583", TestPlatforms.Windows, TargetFrameworkMonikers.Netcoreapp, TestRuntimes.Mono)]
+    [ActiveIssue("https://github.com/dotnet/runtime/issues/34582", TestPlatforms.Windows, TargetFrameworkMonikers.Netcoreapp, TestRuntimes.Mono)]
     public class File_Create_str_i_fo : File_Create_str_i
     {
         public override FileStream Create(string path)
diff --git a/src/libraries/System.IO.FileSystem/tests/File/EncryptDecrypt.cs b/src/libraries/System.IO.FileSystem/tests/File/EncryptDecrypt.cs
index 624eb2aae7cd8d..984afef972bc41 100644
--- a/src/libraries/System.IO.FileSystem/tests/File/EncryptDecrypt.cs
+++ b/src/libraries/System.IO.FileSystem/tests/File/EncryptDecrypt.cs
@@ -7,7 +7,7 @@
 
 namespace System.IO.Tests
 {
-    [ActiveIssue("https://github.com/dotnet/runtime/issues/34583", TestPlatforms.Windows, TargetFrameworkMonikers.Netcoreapp, TestRuntimes.Mono)]
+    [ActiveIssue("https://github.com/dotnet/runtime/issues/34582", TestPlatforms.Windows, TargetFrameworkMonikers.Netcoreapp, TestRuntimes.Mono)]
     public class EncryptDecrypt : FileSystemTest
     {
         [Fact]
diff --git a/src/libraries/System.IO.FileSystem/tests/File/Open.cs b/src/libraries/System.IO.FileSystem/tests/File/Open.cs
index 3a042d8a65b9ef..d014cf0efb94d8 100644
--- a/src/libraries/System.IO.FileSystem/tests/File/Open.cs
+++ b/src/libraries/System.IO.FileSystem/tests/File/Open.cs
@@ -42,6 +42,42 @@ protected override FileStream CreateFileStream(string path, FileMode mode, FileA
         }
     }
 
+    public class File_Open_str_options_as : FileStream_ctor_options_as
+    {
+        protected override FileStream CreateFileStream(string path, FileMode mode)
+        {
+            return File.Open(path,
+                new FileStreamOptions {
+                    Mode = mode,
+                    Access = mode == FileMode.Append ? FileAccess.Write : FileAccess.ReadWrite,
+                    PreallocationSize = PreallocationSize
+                });
+        }
+
+        protected override FileStream CreateFileStream(string path, FileMode mode, FileAccess access)
+        {
+            return File.Open(path,
+                new FileStreamOptions {
+                    Mode = mode,
+                    Access = access,
+                    PreallocationSize = PreallocationSize
+                });
+        }
+
+        protected override FileStream CreateFileStream(string path, FileMode mode, FileAccess access, FileShare share, int bufferSize, FileOptions options)
+        {
+            return File.Open(path,
+                new FileStreamOptions {
+                    Mode = mode,
+                    Access = access,
+                    Share = share,
+                    Options = options,
+                    BufferSize = bufferSize,
+                    PreallocationSize = PreallocationSize
+                });
+        }
+    }
+
     public class File_OpenSpecial : FileStream_ctor_str_fm_fa_fs
     {
         protected override FileStream CreateFileStream(string path, FileMode mode, FileAccess access)
diff --git a/src/libraries/System.IO.FileSystem/tests/File/OpenHandle.cs b/src/libraries/System.IO.FileSystem/tests/File/OpenHandle.cs
new file mode 100644
index 00000000000000..a283b01a0b7e94
--- /dev/null
+++ b/src/libraries/System.IO.FileSystem/tests/File/OpenHandle.cs
@@ -0,0 +1,70 @@
+// 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 Xunit;
+
+namespace System.IO.Tests
+{
+    // to avoid a lot of code duplication, we reuse FileStream tests
+    public class File_OpenHandle : FileStream_ctor_options_as
+    {
+        protected override string GetExpectedParamName(string paramName) => paramName;
+
+        protected override FileStream CreateFileStream(string path, FileMode mode)
+        {
+            FileAccess access = mode == FileMode.Append ? FileAccess.Write : FileAccess.ReadWrite;
+            return new FileStream(File.OpenHandle(path, mode, access, preallocationSize: PreallocationSize), access);
+        }
+
+        protected override FileStream CreateFileStream(string path, FileMode mode, FileAccess access)
+            => new FileStream(File.OpenHandle(path, mode, access, preallocationSize: PreallocationSize), access);
+
+        protected override FileStream CreateFileStream(string path, FileMode mode, FileAccess access, FileShare share, int bufferSize, FileOptions options)
+            => new FileStream(File.OpenHandle(path, mode, access, share, options, PreallocationSize), access, bufferSize, (options & FileOptions.Asynchronous) != 0);
+
+        [Fact]
+        public override void NegativePreallocationSizeThrows()
+        {
+            ArgumentOutOfRangeException ex = Assert.Throws<ArgumentOutOfRangeException>(
+                () => File.OpenHandle("validPath", FileMode.CreateNew, FileAccess.Write, FileShare.None, FileOptions.None, preallocationSize: -1));
+        }
+
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/53432")]
+        [Theory, MemberData(nameof(StreamSpecifiers))]
+        public override void FileModeAppendExisting(string streamSpecifier)
+        {
+            _ = streamSpecifier; // to keep the xUnit analyser happy
+        }
+
+        [Theory]
+        [InlineData(FileOptions.None)]
+        [InlineData(FileOptions.Asynchronous)]
+        public void SafeFileHandle_IsAsync_ReturnsCorrectInformation(FileOptions options)
+        {
+            using (var handle = File.OpenHandle(GetTestFilePath(), FileMode.Create, FileAccess.Write, options: options))
+            {
+                Assert.Equal((options & FileOptions.Asynchronous) != 0, handle.IsAsync);
+
+                // the following code exercises the code path where we don't know FileOptions used for opening the handle
+                // and instead we ask the OS about it
+                if (OperatingSystem.IsWindows()) // async file handles are a Windows concept
+                {
+                    SafeFileHandle createdFromIntPtr = new SafeFileHandle(handle.DangerousGetHandle(), ownsHandle: false);
+                    Assert.Equal((options & FileOptions.Asynchronous) != 0, createdFromIntPtr.IsAsync);
+                }
+            }
+        }
+
+        // Unix doesn't directly support DeleteOnClose
+        // For FileStream created out of path, we mimic it by closing the handle first
+        // and then unlinking the path
+        // Since SafeFileHandle does not always have the path and we can't find path for given file descriptor on Unix
+        // this test runs only on Windows
+        [PlatformSpecific(TestPlatforms.Windows)]
+        [Theory]
+        [InlineData(FileOptions.DeleteOnClose)]
+        [InlineData(FileOptions.DeleteOnClose | FileOptions.Asynchronous)]
+        public override void DeleteOnClose_FileDeletedAfterClose(FileOptions options) => base.DeleteOnClose_FileDeletedAfterClose(options);
+    }
+}
diff --git a/src/libraries/System.IO.FileSystem/tests/File/ReadWriteAllBytesAsync.cs b/src/libraries/System.IO.FileSystem/tests/File/ReadWriteAllBytesAsync.cs
index fdb0ec63776deb..111ecb545adea3 100644
--- a/src/libraries/System.IO.FileSystem/tests/File/ReadWriteAllBytesAsync.cs
+++ b/src/libraries/System.IO.FileSystem/tests/File/ReadWriteAllBytesAsync.cs
@@ -8,7 +8,7 @@
 
 namespace System.IO.Tests
 {
-    [ActiveIssue("https://github.com/dotnet/runtime/issues/34583", TestPlatforms.Windows, TargetFrameworkMonikers.Netcoreapp, TestRuntimes.Mono)]
+    [ActiveIssue("https://github.com/dotnet/runtime/issues/34582", TestPlatforms.Windows, TargetFrameworkMonikers.Netcoreapp, TestRuntimes.Mono)]
     public class File_ReadWriteAllBytesAsync : FileSystemTest
     {
         [Fact]
diff --git a/src/libraries/System.IO.FileSystem/tests/File/ReadWriteAllLinesAsync.cs b/src/libraries/System.IO.FileSystem/tests/File/ReadWriteAllLinesAsync.cs
index f5cbd0f3b7379d..76d1541d60c5e7 100644
--- a/src/libraries/System.IO.FileSystem/tests/File/ReadWriteAllLinesAsync.cs
+++ b/src/libraries/System.IO.FileSystem/tests/File/ReadWriteAllLinesAsync.cs
@@ -10,7 +10,7 @@
 
 namespace System.IO.Tests
 {
-    [ActiveIssue("https://github.com/dotnet/runtime/issues/34583", TestPlatforms.Windows, TargetFrameworkMonikers.Netcoreapp, TestRuntimes.Mono)]
+    [ActiveIssue("https://github.com/dotnet/runtime/issues/34582", TestPlatforms.Windows, TargetFrameworkMonikers.Netcoreapp, TestRuntimes.Mono)]
     public class File_ReadWriteAllLines_EnumerableAsync : FileSystemTest
     {
         #region Utilities
diff --git a/src/libraries/System.IO.FileSystem/tests/File/ReadWriteAllTextAsync.cs b/src/libraries/System.IO.FileSystem/tests/File/ReadWriteAllTextAsync.cs
index fe67d881c2ad19..3481bff97b4f41 100644
--- a/src/libraries/System.IO.FileSystem/tests/File/ReadWriteAllTextAsync.cs
+++ b/src/libraries/System.IO.FileSystem/tests/File/ReadWriteAllTextAsync.cs
@@ -9,7 +9,7 @@
 
 namespace System.IO.Tests
 {
-    [ActiveIssue("https://github.com/dotnet/runtime/issues/34583", TestPlatforms.Windows, TargetFrameworkMonikers.Netcoreapp, TestRuntimes.Mono)]
+    [ActiveIssue("https://github.com/dotnet/runtime/issues/34582", TestPlatforms.Windows, TargetFrameworkMonikers.Netcoreapp, TestRuntimes.Mono)]
     public class File_ReadWriteAllTextAsync : FileSystemTest
     {
         #region Utilities
@@ -145,7 +145,7 @@ public virtual Task TaskAlreadyCanceledAsync()
         #endregion
     }
 
-    [ActiveIssue("https://github.com/dotnet/runtime/issues/34583", TestPlatforms.Windows, TargetFrameworkMonikers.Netcoreapp, TestRuntimes.Mono)]
+    [ActiveIssue("https://github.com/dotnet/runtime/issues/34582", TestPlatforms.Windows, TargetFrameworkMonikers.Netcoreapp, TestRuntimes.Mono)]
     public class File_ReadWriteAllText_EncodedAsync : File_ReadWriteAllTextAsync
     {
         protected override Task WriteAsync(string path, string content) =>
diff --git a/src/libraries/System.IO.FileSystem/tests/FileInfo/Open.cs b/src/libraries/System.IO.FileSystem/tests/FileInfo/Open.cs
index 1401b8b2fef35d..2324a92eafce4f 100644
--- a/src/libraries/System.IO.FileSystem/tests/FileInfo/Open.cs
+++ b/src/libraries/System.IO.FileSystem/tests/FileInfo/Open.cs
@@ -74,6 +74,42 @@ protected override FileStream CreateFileStream(string path, FileMode mode, FileA
         }
     }
 
+    public class FileInfo_Open_options_as : FileStream_ctor_options_as
+    {
+        protected override FileStream CreateFileStream(string path, FileMode mode)
+        {
+            return new FileInfo(path).Open(
+                new FileStreamOptions {
+                    Mode = mode,
+                    Access = mode == FileMode.Append ? FileAccess.Write : FileAccess.ReadWrite,
+                    PreallocationSize = PreallocationSize
+                });
+        }
+
+        protected override FileStream CreateFileStream(string path, FileMode mode, FileAccess access)
+        {
+            return new FileInfo(path).Open(
+                new FileStreamOptions {
+                    Mode = mode,
+                    Access = access,
+                    PreallocationSize = PreallocationSize
+                });
+        }
+
+        protected override FileStream CreateFileStream(string path, FileMode mode, FileAccess access, FileShare share, int bufferSize, FileOptions options)
+        {
+            return new FileInfo(path).Open(
+                new FileStreamOptions {
+                    Mode = mode,
+                    Access = access,
+                    Share = share,
+                    Options = options,
+                    BufferSize = bufferSize,
+                    PreallocationSize = PreallocationSize
+                });
+        }
+    }
+
     public class FileInfo_OpenSpecial : FileStream_ctor_str_fm_fa_fs
     {
         protected override FileStream CreateFileStream(string path, FileMode mode, FileAccess access)
diff --git a/src/libraries/System.IO.FileSystem/tests/FileStream/CopyToAsync.cs b/src/libraries/System.IO.FileSystem/tests/FileStream/CopyToAsync.cs
index f059c49ab4ce03..3a48354964b8a5 100644
--- a/src/libraries/System.IO.FileSystem/tests/FileStream/CopyToAsync.cs
+++ b/src/libraries/System.IO.FileSystem/tests/FileStream/CopyToAsync.cs
@@ -8,7 +8,7 @@
 
 namespace System.IO.Tests
 {
-    [ActiveIssue("https://github.com/dotnet/runtime/issues/34583", TestPlatforms.Windows, TargetFrameworkMonikers.Netcoreapp, TestRuntimes.Mono)]
+    [ActiveIssue("https://github.com/dotnet/runtime/issues/34582", TestPlatforms.Windows, TargetFrameworkMonikers.Netcoreapp, TestRuntimes.Mono)]
     public class FileStream_CopyToAsync : FileSystemTest
     {
         [Theory]
diff --git a/src/libraries/System.IO.FileSystem/tests/FileStream/FileStreamConformanceTests.cs b/src/libraries/System.IO.FileSystem/tests/FileStream/FileStreamConformanceTests.cs
index 0fbc7711045693..d1fd4fe764f4d3 100644
--- a/src/libraries/System.IO.FileSystem/tests/FileStream/FileStreamConformanceTests.cs
+++ b/src/libraries/System.IO.FileSystem/tests/FileStream/FileStreamConformanceTests.cs
@@ -205,7 +205,7 @@ public class BufferedSyncFileStreamStandaloneConformanceTests : FileStreamStanda
         protected override int BufferSize => 10;
     }
 
-    [ActiveIssue("https://github.com/dotnet/runtime/issues/34583", TestPlatforms.Windows, TargetFrameworkMonikers.Netcoreapp, TestRuntimes.Mono)]
+    [ActiveIssue("https://github.com/dotnet/runtime/issues/34582", TestPlatforms.Windows, TargetFrameworkMonikers.Netcoreapp, TestRuntimes.Mono)]
     [SkipOnPlatform(TestPlatforms.Browser, "lots of operations aren't supported on browser")] // copied from StreamConformanceTests base class due to https://github.com/xunit/xunit/issues/2186
     public class UnbufferedAsyncFileStreamStandaloneConformanceTests : FileStreamStandaloneConformanceTests
     {
@@ -218,7 +218,7 @@ public class UnbufferedAsyncFileStreamStandaloneConformanceTests : FileStreamSta
 #endif
     }
 
-    [ActiveIssue("https://github.com/dotnet/runtime/issues/34583", TestPlatforms.Windows, TargetFrameworkMonikers.Netcoreapp, TestRuntimes.Mono)]
+    [ActiveIssue("https://github.com/dotnet/runtime/issues/34582", TestPlatforms.Windows, TargetFrameworkMonikers.Netcoreapp, TestRuntimes.Mono)]
     [SkipOnPlatform(TestPlatforms.Browser, "lots of operations aren't supported on browser")] // copied from StreamConformanceTests base class due to https://github.com/xunit/xunit/issues/2186
     public class BufferedAsyncFileStreamStandaloneConformanceTests : FileStreamStandaloneConformanceTests
     {
diff --git a/src/libraries/System.IO.FileSystem/tests/FileStream/FileStreamOptions.cs b/src/libraries/System.IO.FileSystem/tests/FileStream/FileStreamOptions.cs
new file mode 100644
index 00000000000000..d078deb07e55ef
--- /dev/null
+++ b/src/libraries/System.IO.FileSystem/tests/FileStream/FileStreamOptions.cs
@@ -0,0 +1,138 @@
+// 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.Linq;
+using Xunit;
+
+namespace System.IO.Tests
+{
+    public class FileStream_FileStreamOptions : FileSystemTest
+    {
+        [Fact]
+        public void NullOptionsThrows()
+        {
+            AssertExtensions.Throws<ArgumentNullException>("options", () => new FileStream(GetTestFilePath(), options: null));
+        }
+
+        [Theory]
+        [InlineData(FileMode.Create)]
+        [InlineData(FileMode.CreateNew)]
+        [InlineData(FileMode.Append)]
+        [InlineData(FileMode.Truncate)]
+        public void ModesThatRequireWriteAccessThrowWhenReadAccessIsProvided(FileMode fileMode)
+        {
+            Assert.Throws<ArgumentException>(() => new FileStream(GetTestFilePath(), new FileStreamOptions
+            {
+                Mode = fileMode,
+                Access = FileAccess.Read
+            }));
+        }
+
+        [Theory]
+        [InlineData(FileAccess.Read)]
+        [InlineData(FileAccess.ReadWrite)]
+        public void AppendWorksOnlyForWriteAccess(FileAccess fileAccess)
+        {
+            Assert.Throws<ArgumentException>(() => new FileStream(GetTestFilePath(), new FileStreamOptions
+            {
+                Mode = FileMode.Append,
+                Access = fileAccess
+            }));
+        }
+
+        [Fact]
+        public void Mode()
+        {
+            Assert.Equal(FileMode.Open, new FileStreamOptions().Mode);
+
+            FileMode[] validValues = Enum.GetValues<FileMode>();
+
+            foreach (var vaidValue in validValues)
+            {
+                Assert.Equal(vaidValue, (new FileStreamOptions { Mode = vaidValue }).Mode);
+            }
+
+            Assert.Throws<ArgumentOutOfRangeException>(() => new FileStreamOptions { Mode = validValues.Min() - 1 });
+            Assert.Throws<ArgumentOutOfRangeException>(() => new FileStreamOptions { Mode = validValues.Max() + 1 });
+        }
+
+        [Fact]
+        public void Access()
+        {
+            Assert.Equal(FileAccess.Read, new FileStreamOptions().Access);
+
+            FileAccess[] validValues = Enum.GetValues<FileAccess>();
+
+            foreach (var vaidValue in validValues)
+            {
+                Assert.Equal(vaidValue, (new FileStreamOptions { Access = vaidValue }).Access);
+            }
+
+            Assert.Throws<ArgumentOutOfRangeException>(() => new FileStreamOptions { Access = validValues.Min() - 1 });
+            Assert.Throws<ArgumentOutOfRangeException>(() => new FileStreamOptions { Access = validValues.Max() + 1 });
+        }
+
+        [Fact]
+        public void Share()
+        {
+            Assert.Equal(FileShare.Read, new FileStreamOptions().Share);
+
+            FileShare[] validValues = Enum.GetValues<FileShare>();
+
+            foreach (var vaidValue in validValues)
+            {
+                Assert.Equal(vaidValue, (new FileStreamOptions { Share = vaidValue }).Share);
+            }
+
+            FileShare all = validValues.Aggregate((x, y) => x | y);
+            Assert.Equal(all, (new FileStreamOptions { Share = all }).Share);
+
+            Assert.Throws<ArgumentOutOfRangeException>(() => new FileStreamOptions { Share = validValues.Min() - 1 });
+            Assert.Throws<ArgumentOutOfRangeException>(() => new FileStreamOptions { Share = all + 1 });
+        }
+
+        [Fact]
+        public void Options()
+        {
+            Assert.Equal(FileOptions.None, new FileStreamOptions().Options);
+
+            FileOptions[] validValues = Enum.GetValues<FileOptions>();
+
+            foreach (var option in validValues)
+            {
+                Assert.Equal(option, (new FileStreamOptions { Options = option }).Options);
+            }
+
+            FileOptions all = validValues.Aggregate((x, y) => x | y);
+            Assert.Equal(all, (new FileStreamOptions { Options = all }).Options);
+
+            Assert.Throws<ArgumentOutOfRangeException>(() => new FileStreamOptions { Options = validValues.Min() - 1 });
+            Assert.Throws<ArgumentOutOfRangeException>(() => new FileStreamOptions { Options = all + 1 });
+        }
+
+        [Fact]
+        public void PreallocationSize()
+        {
+            Assert.Equal(0, new FileStreamOptions().PreallocationSize);
+
+            Assert.Equal(0, new FileStreamOptions { PreallocationSize = 0 }.PreallocationSize);
+            Assert.Equal(1, new FileStreamOptions { PreallocationSize = 1 }.PreallocationSize);
+            Assert.Equal(123, new FileStreamOptions { PreallocationSize = 123 }.PreallocationSize);
+
+            Assert.Throws<ArgumentOutOfRangeException>(() => new FileStreamOptions { PreallocationSize = -1 });
+        }
+
+        [Fact]
+        public void BufferSize()
+        {
+            Assert.Equal(4096, new FileStreamOptions().BufferSize);
+
+            Assert.Equal(0, new FileStreamOptions { BufferSize = 0 }.BufferSize);
+            Assert.Equal(1, new FileStreamOptions { BufferSize = 1 }.BufferSize);
+            Assert.Equal(123, new FileStreamOptions { BufferSize = 123 }.BufferSize);
+
+            Assert.Throws<ArgumentOutOfRangeException>(() => new FileStreamOptions { BufferSize = -1 });
+        }
+    }
+}
diff --git a/src/libraries/System.IO.FileSystem/tests/FileStream/IsAsync.cs b/src/libraries/System.IO.FileSystem/tests/FileStream/IsAsync.cs
index b0900760c2687f..e187468035fe60 100644
--- a/src/libraries/System.IO.FileSystem/tests/FileStream/IsAsync.cs
+++ b/src/libraries/System.IO.FileSystem/tests/FileStream/IsAsync.cs
@@ -8,7 +8,7 @@
 
 namespace System.IO.Tests
 {
-    [ActiveIssue("https://github.com/dotnet/runtime/issues/34583", TestPlatforms.Windows, TargetFrameworkMonikers.Netcoreapp, TestRuntimes.Mono)]
+    [ActiveIssue("https://github.com/dotnet/runtime/issues/34582", TestPlatforms.Windows, TargetFrameworkMonikers.Netcoreapp, TestRuntimes.Mono)]
     public class FileStream_IsAsync : FileSystemTest
     {
         [Fact]
diff --git a/src/libraries/System.IO.FileSystem/tests/FileStream/ReadAsync.cs b/src/libraries/System.IO.FileSystem/tests/FileStream/ReadAsync.cs
index ef4458ef7f45be..da429bbad21874 100644
--- a/src/libraries/System.IO.FileSystem/tests/FileStream/ReadAsync.cs
+++ b/src/libraries/System.IO.FileSystem/tests/FileStream/ReadAsync.cs
@@ -94,14 +94,14 @@ public async Task ReadAsyncCanceledFile()
         }
     }
 
-    [ActiveIssue("https://github.com/dotnet/runtime/issues/34583", TestPlatforms.Windows, TargetFrameworkMonikers.Netcoreapp, TestRuntimes.Mono)]
+    [ActiveIssue("https://github.com/dotnet/runtime/issues/34582", TestPlatforms.Windows, TargetFrameworkMonikers.Netcoreapp, TestRuntimes.Mono)]
     public class FileStream_ReadAsync_AsyncReads : FileStream_AsyncReads
     {
         protected override Task<int> ReadAsync(FileStream stream, byte[] buffer, int offset, int count, CancellationToken cancellationToken) =>
             stream.ReadAsync(buffer, offset, count, cancellationToken);
     }
 
-    [ActiveIssue("https://github.com/dotnet/runtime/issues/34583", TestPlatforms.Windows, TargetFrameworkMonikers.Netcoreapp, TestRuntimes.Mono)]
+    [ActiveIssue("https://github.com/dotnet/runtime/issues/34582", TestPlatforms.Windows, TargetFrameworkMonikers.Netcoreapp, TestRuntimes.Mono)]
     public class FileStream_BeginEndRead_AsyncReads : FileStream_AsyncReads
     {
         protected override Task<int> ReadAsync(FileStream stream, byte[] buffer, int offset, int count, CancellationToken cancellationToken) =>
diff --git a/src/libraries/System.IO.FileSystem/tests/FileStream/SafeFileHandle.cs b/src/libraries/System.IO.FileSystem/tests/FileStream/SafeFileHandle.cs
index 40064cd42c359c..0740eed02f0d85 100644
--- a/src/libraries/System.IO.FileSystem/tests/FileStream/SafeFileHandle.cs
+++ b/src/libraries/System.IO.FileSystem/tests/FileStream/SafeFileHandle.cs
@@ -9,7 +9,7 @@
 
 namespace System.IO.Tests
 {
-    [ActiveIssue("https://github.com/dotnet/runtime/issues/34583", TestPlatforms.Windows, TargetFrameworkMonikers.Netcoreapp, TestRuntimes.Mono)]
+    [ActiveIssue("https://github.com/dotnet/runtime/issues/34582", TestPlatforms.Windows, TargetFrameworkMonikers.Netcoreapp, TestRuntimes.Mono)]
     public class FileStream_SafeFileHandle : FileSystemTest
     {
         [Fact]
diff --git a/src/libraries/System.IO.FileSystem/tests/FileStream/WriteAsync.cs b/src/libraries/System.IO.FileSystem/tests/FileStream/WriteAsync.cs
index 9e4db63e6fbc3a..7f7fd8ad240bab 100644
--- a/src/libraries/System.IO.FileSystem/tests/FileStream/WriteAsync.cs
+++ b/src/libraries/System.IO.FileSystem/tests/FileStream/WriteAsync.cs
@@ -324,7 +324,7 @@ public async Task WriteAsyncMiniStress()
         }
     }
 
-    [ActiveIssue("https://github.com/dotnet/runtime/issues/34583", TestPlatforms.Windows, TargetFrameworkMonikers.Netcoreapp, TestRuntimes.Mono)]
+    [ActiveIssue("https://github.com/dotnet/runtime/issues/34582", TestPlatforms.Windows, TargetFrameworkMonikers.Netcoreapp, TestRuntimes.Mono)]
     public class FileStream_WriteAsync_AsyncWrites : FileStream_AsyncWrites
     {
         protected override Task WriteAsync(FileStream stream, byte[] buffer, int offset, int count, CancellationToken cancellationToken) =>
@@ -371,7 +371,7 @@ public void CancelledTokenFastPath()
         }
     }
 
-    [ActiveIssue("https://github.com/dotnet/runtime/issues/34583", TestPlatforms.Windows, TargetFrameworkMonikers.Netcoreapp, TestRuntimes.Mono)]
+    [ActiveIssue("https://github.com/dotnet/runtime/issues/34582", TestPlatforms.Windows, TargetFrameworkMonikers.Netcoreapp, TestRuntimes.Mono)]
     public class FileStream_BeginEndWrite_AsyncWrites : FileStream_AsyncWrites
     {
         protected override Task WriteAsync(FileStream stream, byte[] buffer, int offset, int count, CancellationToken cancellationToken) =>
diff --git a/src/libraries/System.IO.FileSystem/tests/FileStream/ctor_options_as.Browser.cs b/src/libraries/System.IO.FileSystem/tests/FileStream/ctor_options_as.Browser.cs
index 03486aec6fc8c8..3475c8999ca6f9 100644
--- a/src/libraries/System.IO.FileSystem/tests/FileStream/ctor_options_as.Browser.cs
+++ b/src/libraries/System.IO.FileSystem/tests/FileStream/ctor_options_as.Browser.cs
@@ -1,11 +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 Xunit;
-
 namespace System.IO.Tests
 {
-    [PlatformSpecific(~TestPlatforms.Browser)]
     public partial class FileStream_ctor_options_as : FileStream_ctor_options_as_base
     {
         protected override long PreallocationSize => 10;
diff --git a/src/libraries/System.IO.FileSystem/tests/FileStream/ctor_options_as.cs b/src/libraries/System.IO.FileSystem/tests/FileStream/ctor_options_as.cs
index a202814d7f2565..f36e55ea16d2de 100644
--- a/src/libraries/System.IO.FileSystem/tests/FileStream/ctor_options_as.cs
+++ b/src/libraries/System.IO.FileSystem/tests/FileStream/ctor_options_as.cs
@@ -9,6 +9,8 @@ public abstract class FileStream_ctor_options_as_base : FileStream_ctor_str_fm_f
     {
         protected abstract long PreallocationSize { get; }
 
+        protected override string GetExpectedParamName(string paramName) => "value";
+
         protected override FileStream CreateFileStream(string path, FileMode mode)
             => new FileStream(path,
                     new FileStreamOptions
@@ -67,7 +69,7 @@ public partial class NoParallelTests { }
     public partial class FileStream_ctor_options_as : FileStream_ctor_options_as_base
     {
         [Fact]
-        public void NegativePreallocationSizeThrows()
+        public virtual void NegativePreallocationSizeThrows()
         {
             string filePath = GetPathToNonExistingFile();
             ArgumentOutOfRangeException ex = Assert.Throws<ArgumentOutOfRangeException>(
diff --git a/src/libraries/System.IO.FileSystem/tests/FileStream/ctor_sfh_fa.cs b/src/libraries/System.IO.FileSystem/tests/FileStream/ctor_sfh_fa.cs
index 49881c43dbab16..5ad232a6d3a94d 100644
--- a/src/libraries/System.IO.FileSystem/tests/FileStream/ctor_sfh_fa.cs
+++ b/src/libraries/System.IO.FileSystem/tests/FileStream/ctor_sfh_fa.cs
@@ -25,7 +25,7 @@ public void InvalidHandle_Throws()
         [Fact]
         public void InvalidAccess_Throws()
         {
-            using (var handle = new SafeFileHandle(new IntPtr(1), ownsHandle: false))
+            using (var handle = File.OpenHandle(GetTestFilePath(), FileMode.Create, FileAccess.Write))
             {
                 AssertExtensions.Throws<ArgumentOutOfRangeException>("access", () => CreateFileStream(handle, ~FileAccess.Read));
             }
@@ -34,7 +34,7 @@ public void InvalidAccess_Throws()
         [Fact]
         public void InvalidAccess_DoesNotCloseHandle()
         {
-            using (var handle = new SafeFileHandle(new IntPtr(1), ownsHandle: false))
+            using (var handle = File.OpenHandle(GetTestFilePath(), FileMode.Create, FileAccess.Write))
             {
                 Assert.Throws<ArgumentOutOfRangeException>(() => CreateFileStream(handle, ~FileAccess.Read));
                 GC.Collect();
diff --git a/src/libraries/System.IO.FileSystem/tests/FileStream/ctor_sfh_fa_buffer.cs b/src/libraries/System.IO.FileSystem/tests/FileStream/ctor_sfh_fa_buffer.cs
index 745ff57850888a..0c480d4a4fcb60 100644
--- a/src/libraries/System.IO.FileSystem/tests/FileStream/ctor_sfh_fa_buffer.cs
+++ b/src/libraries/System.IO.FileSystem/tests/FileStream/ctor_sfh_fa_buffer.cs
@@ -18,21 +18,19 @@ protected virtual FileStream CreateFileStream(SafeFileHandle handle, FileAccess
             return new FileStream(handle, access, bufferSize);
         }
 
-        [Theory,
-            InlineData(0),
-            InlineData(-1)]
-        public void InvalidBufferSize_Throws(int size)
+        [Fact]
+        public void NegativeBufferSize_Throws()
         {
-            using (var handle = new SafeFileHandle(new IntPtr(1), ownsHandle: false))
+            using (var handle = File.OpenHandle(GetTestFilePath(), FileMode.Create, FileAccess.Write))
             {
-                AssertExtensions.Throws<ArgumentOutOfRangeException>("bufferSize", () => CreateFileStream(handle, FileAccess.Read, size));
+                AssertExtensions.Throws<ArgumentOutOfRangeException>("bufferSize", () => CreateFileStream(handle, FileAccess.Read, -1));
             }
         }
 
         [Fact]
         public void InvalidBufferSize_DoesNotCloseHandle()
         {
-            using (var handle = new SafeFileHandle(new IntPtr(1), ownsHandle: false))
+            using (var handle = File.OpenHandle(GetTestFilePath(), FileMode.Create, FileAccess.Write))
             {
                 Assert.Throws<ArgumentOutOfRangeException>(() => CreateFileStream(handle, FileAccess.Read, -1));
                 GC.Collect();
diff --git a/src/libraries/System.IO.FileSystem/tests/FileStream/ctor_sfh_fa_buffer_async.cs b/src/libraries/System.IO.FileSystem/tests/FileStream/ctor_sfh_fa_buffer_async.cs
index f05cbce26f5b9d..b2a8ba19a1d1f7 100644
--- a/src/libraries/System.IO.FileSystem/tests/FileStream/ctor_sfh_fa_buffer_async.cs
+++ b/src/libraries/System.IO.FileSystem/tests/FileStream/ctor_sfh_fa_buffer_async.cs
@@ -6,7 +6,7 @@
 
 namespace System.IO.Tests
 {
-    [ActiveIssue("https://github.com/dotnet/runtime/issues/34583", TestPlatforms.Windows, TargetFrameworkMonikers.Netcoreapp, TestRuntimes.Mono)]
+    [ActiveIssue("https://github.com/dotnet/runtime/issues/34582", TestPlatforms.Windows, TargetFrameworkMonikers.Netcoreapp, TestRuntimes.Mono)]
     public class FileStream_ctor_sfh_fa_buffer_async : FileStream_ctor_sfh_fa_buffer
     {
         protected sealed override FileStream CreateFileStream(SafeFileHandle handle, FileAccess access, int bufferSize)
diff --git a/src/libraries/System.IO.FileSystem/tests/FileStream/ctor_str_fm.cs b/src/libraries/System.IO.FileSystem/tests/FileStream/ctor_str_fm.cs
index f442fbd4322190..60e3cd49ea71c2 100644
--- a/src/libraries/System.IO.FileSystem/tests/FileStream/ctor_str_fm.cs
+++ b/src/libraries/System.IO.FileSystem/tests/FileStream/ctor_str_fm.cs
@@ -14,6 +14,8 @@ protected virtual FileStream CreateFileStream(string path, FileMode mode)
 
         protected virtual long InitialLength => 0;
 
+        protected virtual string GetExpectedParamName(string paramName) => paramName;
+
         [Fact]
         public void NullPathThrows()
         {
@@ -35,7 +37,9 @@ public void DirectoryThrows()
         [Fact]
         public void InvalidModeThrows()
         {
-            AssertExtensions.Throws<ArgumentOutOfRangeException>("mode", () => CreateFileStream(GetTestFilePath(), ~FileMode.Open));
+            AssertExtensions.Throws<ArgumentOutOfRangeException>(
+                GetExpectedParamName("mode"),
+                () => CreateFileStream(GetTestFilePath(), ~FileMode.Open));
         }
 
         [Theory, MemberData(nameof(TrailingCharacters))]
diff --git a/src/libraries/System.IO.FileSystem/tests/FileStream/ctor_str_fm_fa.cs b/src/libraries/System.IO.FileSystem/tests/FileStream/ctor_str_fm_fa.cs
index 6ab972644c3000..810444ba051a08 100644
--- a/src/libraries/System.IO.FileSystem/tests/FileStream/ctor_str_fm_fa.cs
+++ b/src/libraries/System.IO.FileSystem/tests/FileStream/ctor_str_fm_fa.cs
@@ -21,7 +21,9 @@ protected virtual FileStream CreateFileStream(string path, FileMode mode, FileAc
         [Fact]
         public void InvalidAccessThrows()
         {
-            AssertExtensions.Throws<ArgumentOutOfRangeException>("access", () => CreateFileStream(GetTestFilePath(), FileMode.Create, ~FileAccess.Read));
+            AssertExtensions.Throws<ArgumentOutOfRangeException>(
+                GetExpectedParamName("access"),
+                () => CreateFileStream(GetTestFilePath(), FileMode.Create, ~FileAccess.Read));
         }
 
         [Fact]
diff --git a/src/libraries/System.IO.FileSystem/tests/FileStream/ctor_str_fm_fa_fs.cs b/src/libraries/System.IO.FileSystem/tests/FileStream/ctor_str_fm_fa_fs.cs
index 805354e31cd447..386b2992ee3e8f 100644
--- a/src/libraries/System.IO.FileSystem/tests/FileStream/ctor_str_fm_fa_fs.cs
+++ b/src/libraries/System.IO.FileSystem/tests/FileStream/ctor_str_fm_fa_fs.cs
@@ -18,7 +18,9 @@ protected virtual FileStream CreateFileStream(string path, FileMode mode, FileAc
         [Fact]
         public void InvalidShareThrows()
         {
-            AssertExtensions.Throws<ArgumentOutOfRangeException>("share", () => CreateFileStream(GetTestFilePath(), FileMode.Create, FileAccess.ReadWrite, ~FileShare.None));
+            AssertExtensions.Throws<ArgumentOutOfRangeException>(
+                GetExpectedParamName("share"),
+                () => CreateFileStream(GetTestFilePath(), FileMode.Create, FileAccess.ReadWrite, ~FileShare.None));
         }
 
         private static readonly FileShare[] s_shares =
diff --git a/src/libraries/System.IO.FileSystem/tests/FileStream/ctor_str_fm_fa_fs_buffer.cs b/src/libraries/System.IO.FileSystem/tests/FileStream/ctor_str_fm_fa_fs_buffer.cs
index 621586be7fb7da..20c4832a68a3e0 100644
--- a/src/libraries/System.IO.FileSystem/tests/FileStream/ctor_str_fm_fa_fs_buffer.cs
+++ b/src/libraries/System.IO.FileSystem/tests/FileStream/ctor_str_fm_fa_fs_buffer.cs
@@ -22,7 +22,9 @@ protected virtual FileStream CreateFileStream(string path, FileMode mode, FileAc
         [Fact]
         public void NegativeBufferSizeThrows()
         {
-            AssertExtensions.Throws<ArgumentOutOfRangeException>("bufferSize", () => CreateFileStream(GetTestFilePath(), FileMode.Create, FileAccess.ReadWrite, FileShare.Read, -1));
+            AssertExtensions.Throws<ArgumentOutOfRangeException>(
+                GetExpectedParamName("bufferSize"),
+                () => CreateFileStream(GetTestFilePath(), FileMode.Create, FileAccess.ReadWrite, FileShare.Read, -1));
         }
 
         [Fact]
diff --git a/src/libraries/System.IO.FileSystem/tests/FileStream/ctor_str_fm_fa_fs_buffer_fo.cs b/src/libraries/System.IO.FileSystem/tests/FileStream/ctor_str_fm_fa_fs_buffer_fo.cs
index 26f3a2fc55d2b0..61efd825f6e48e 100644
--- a/src/libraries/System.IO.FileSystem/tests/FileStream/ctor_str_fm_fa_fs_buffer_fo.cs
+++ b/src/libraries/System.IO.FileSystem/tests/FileStream/ctor_str_fm_fa_fs_buffer_fo.cs
@@ -5,7 +5,7 @@
 
 namespace System.IO.Tests
 {
-    [ActiveIssue("https://github.com/dotnet/runtime/issues/34583", TestPlatforms.Windows, TargetFrameworkMonikers.Netcoreapp, TestRuntimes.Mono)]
+    [ActiveIssue("https://github.com/dotnet/runtime/issues/34582", TestPlatforms.Windows, TargetFrameworkMonikers.Netcoreapp, TestRuntimes.Mono)]
     public class FileStream_ctor_str_fm_fa_fs_buffer_fo : FileStream_ctor_str_fm_fa_fs_buffer
     {
         protected sealed override FileStream CreateFileStream(string path, FileMode mode, FileAccess access, FileShare share, int bufferSize)
@@ -21,7 +21,9 @@ protected virtual FileStream CreateFileStream(string path, FileMode mode, FileAc
         [Fact]
         public void InvalidFileOptionsThrow()
         {
-            AssertExtensions.Throws<ArgumentOutOfRangeException>("options", () => CreateFileStream(GetTestFilePath(), FileMode.Create, FileAccess.ReadWrite, FileShare.Read, c_DefaultBufferSize, ~FileOptions.None));
+            AssertExtensions.Throws<ArgumentOutOfRangeException>(
+                GetExpectedParamName("options"),
+                () => CreateFileStream(GetTestFilePath(), FileMode.Create, FileAccess.ReadWrite, FileShare.Read, c_DefaultBufferSize, ~FileOptions.None));
         }
 
         [ConditionalTheory(typeof(PlatformDetection), nameof(PlatformDetection.IsThreadingSupported))]
@@ -77,7 +79,7 @@ public void ValidFileOptions_Encrypted(FileOptions option)
         [Theory]
         [InlineData(FileOptions.DeleteOnClose)]
         [InlineData(FileOptions.DeleteOnClose | FileOptions.Asynchronous)]
-        public void DeleteOnClose_FileDeletedAfterClose(FileOptions options)
+        public virtual void DeleteOnClose_FileDeletedAfterClose(FileOptions options)
         {
             string path = GetTestFilePath();
             Assert.False(File.Exists(path));
diff --git a/src/libraries/System.IO.FileSystem/tests/FileSystemTest.cs b/src/libraries/System.IO.FileSystem/tests/FileSystemTest.cs
index 2ba15d31b4144e..d82346f6f4f10a 100644
--- a/src/libraries/System.IO.FileSystem/tests/FileSystemTest.cs
+++ b/src/libraries/System.IO.FileSystem/tests/FileSystemTest.cs
@@ -127,5 +127,24 @@ protected void ReadOnly_FileSystemHelper(Action<string> testAction, string subDi
                 Assert.Equal(0, AdminHelpers.RunAsSudo($"umount {readOnlyDirectory}"));
             }
         }
+
+        /// <summary>
+        /// Determines whether the file system is case sensitive by creating a file in the specified folder and observing the result.
+        /// </summary>
+        /// <remarks>
+        /// Ideally we'd use something like pathconf with _PC_CASE_SENSITIVE, but that is non-portable,
+        /// not supported on Windows or Linux, etc. For now, this function creates a tmp file with capital letters
+        /// and then tests for its existence with lower-case letters.  This could return invalid results in corner
+        /// cases where, for example, different file systems are mounted with differing sensitivities.
+        /// </remarks>
+        protected static bool GetIsCaseSensitiveByProbing(string probingDirectory)
+        {
+            string pathWithUpperCase = Path.Combine(probingDirectory, "CASESENSITIVETEST" + Guid.NewGuid().ToString("N"));
+            using (new FileStream(pathWithUpperCase, FileMode.CreateNew, FileAccess.ReadWrite, FileShare.None, 0x1000, FileOptions.DeleteOnClose))
+            {
+                string lowerCased = pathWithUpperCase.ToLowerInvariant();
+                return !File.Exists(lowerCased);
+            }
+        }
     }
 }
diff --git a/src/libraries/System.IO.FileSystem/tests/Net5CompatTests/System.IO.FileSystem.Net5Compat.Tests.csproj b/src/libraries/System.IO.FileSystem/tests/Net5CompatTests/System.IO.FileSystem.Net5Compat.Tests.csproj
index dfabeb02694b11..58669657e51b14 100644
--- a/src/libraries/System.IO.FileSystem/tests/Net5CompatTests/System.IO.FileSystem.Net5Compat.Tests.csproj
+++ b/src/libraries/System.IO.FileSystem/tests/Net5CompatTests/System.IO.FileSystem.Net5Compat.Tests.csproj
@@ -19,10 +19,12 @@
   <ItemGroup Condition="'$(TargetsWindows)' == 'true'">
     <Compile Remove="..\**\*.Unix.cs" />
     <Compile Remove="..\**\*.Browser.cs" />
-    <Compile Include="$(CommonPath)Interop\Windows\Interop.BOOL.cs" Link="Interop\Windows\Interop.BOOL.cs" />
-    <Compile Include="$(CommonPath)Interop\Windows\Kernel32\Interop.FILE_STANDARD_INFO.cs" Link="Interop\Windows\Interop.FILE_STANDARD_INFO.cs" />
-    <Compile Include="$(CommonPath)Interop\Windows\Interop.Libraries.cs" Link="Interop\Windows\Interop.Libraries.cs" />
-    <Compile Include="$(CommonPath)Interop\Windows\Kernel32\Interop.GetFileInformationByHandleEx.cs" Link="Interop\Windows\Interop.GetFileInformationByHandleEx.cs" />
+    <Compile Include="$(CommonPath)Interop\Windows\Interop.BOOL.cs" Link="Common\Interop\Windows\Interop.BOOL.cs" />
+    <Compile Include="$(CommonPath)Interop\Windows\Interop.Libraries.cs" Link="Common\Interop\Windows\Interop.Libraries.cs" />
+    <Compile Include="$(CommonPath)Interop\Windows\Kernel32\Interop.FILE_STANDARD_INFO.cs" Link="Common\Interop\Windows\Interop.FILE_STANDARD_INFO.cs" />
+    <Compile Include="$(CommonPath)Interop\Windows\Kernel32\Interop.GetFileInformationByHandleEx.cs" Link="Common\Interop\Windows\Interop.GetFileInformationByHandleEx.cs" />
+    <Compile Include="$(CommonPath)Interop\Windows\Kernel32\Interop.MemOptions.cs" Link="Common\Interop\Windows\Interop.MemOptions.cs" />
+    <Compile Include="$(CommonPath)Interop\Windows\Kernel32\Interop.VirtualAlloc_Ptr.cs" Link="Common\Interop\Windows\Interop.VirtualAlloc_Ptr.cs" />
   </ItemGroup>
   <ItemGroup Condition="'$(TargetsBrowser)' == 'true'">
     <Compile Remove="..\**\*.Unix.cs" />
@@ -35,6 +37,8 @@
     <Compile Include="$(CommonTestPath)System\IO\TempFile.cs" Link="Common\System\IO\TempFile.cs" />
     <Compile Include="$(CommonTestPath)System\IO\PathFeatures.cs" Link="Common\System\IO\PathFeatures.cs" />
     <Content Include="..\DirectoryInfo\test-dir\dummy.txt" Link="test-dir\dummy.txt" />
+    <Compile Include="$(CommonPath)System\IO\PathInternal.CaseSensitivity.cs"
+             Link="Common\System\IO\PathInternal.CaseSensitivity.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="$(CommonTestPath)StreamConformanceTests\StreamConformanceTests.csproj" />
diff --git a/src/libraries/System.IO.FileSystem/tests/PathInternalTests.cs b/src/libraries/System.IO.FileSystem/tests/PathInternalTests.cs
new file mode 100644
index 00000000000000..c908601862eea9
--- /dev/null
+++ b/src/libraries/System.IO.FileSystem/tests/PathInternalTests.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.
+
+using Xunit;
+
+namespace System.IO.Tests
+{
+    public class PathInternalTests : FileSystemTest
+    {
+        [Fact]
+        [OuterLoop]
+        public void PathInternalIsCaseSensitiveMatchesProbing()
+        {
+            string probingDirectory = TestDirectory;
+            Assert.Equal(GetIsCaseSensitiveByProbing(probingDirectory), PathInternal.IsCaseSensitive);
+        }
+    }
+}
diff --git a/src/libraries/System.IO.FileSystem/tests/RandomAccess/Base.cs b/src/libraries/System.IO.FileSystem/tests/RandomAccess/Base.cs
new file mode 100644
index 00000000000000..8d876f30174cd0
--- /dev/null
+++ b/src/libraries/System.IO.FileSystem/tests/RandomAccess/Base.cs
@@ -0,0 +1,110 @@
+// 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.Pipes;
+using System.Threading;
+using Microsoft.Win32.SafeHandles;
+using Xunit;
+
+namespace System.IO.Tests
+{
+    public abstract class RandomAccess_Base<T> : FileSystemTest
+    {
+        protected abstract T MethodUnderTest(SafeFileHandle handle, byte[] bytes, long fileOffset);
+
+        protected virtual bool ShouldThrowForSyncHandle => false;
+
+        protected virtual bool ShouldThrowForAsyncHandle => false;
+
+        protected virtual bool UsesOffsets => true;
+
+        [Fact]
+        public void ThrowsArgumentNullExceptionForNullHandle()
+        {
+            AssertExtensions.Throws<ArgumentNullException>("handle", () => MethodUnderTest(null, Array.Empty<byte>(), 0));
+        }
+
+        [Fact]
+        public void ThrowsArgumentExceptionForInvalidHandle()
+        {
+            SafeFileHandle handle = new SafeFileHandle(new IntPtr(-1), ownsHandle: false);
+
+            AssertExtensions.Throws<ArgumentException>("handle", () => MethodUnderTest(handle, Array.Empty<byte>(), 0));
+        }
+
+        [Fact]
+        public void ThrowsObjectDisposedExceptionForDisposedHandle()
+        {
+            SafeFileHandle handle = File.OpenHandle(GetTestFilePath(), FileMode.Create, FileAccess.Write);
+            handle.Dispose();
+
+            Assert.Throws<ObjectDisposedException>(() => MethodUnderTest(handle, Array.Empty<byte>(), 0));
+        }
+
+        [Fact]
+        [SkipOnPlatform(TestPlatforms.Browser, "System.IO.Pipes aren't supported on browser")]
+        public void ThrowsNotSupportedExceptionForUnseekableFile()
+        {
+            using (var server = new AnonymousPipeServerStream(PipeDirection.Out))
+            using (SafeFileHandle handle = new SafeFileHandle(server.SafePipeHandle.DangerousGetHandle(), true))
+            {
+                Assert.Throws<NotSupportedException>(() => MethodUnderTest(handle, Array.Empty<byte>(), 0));
+            }
+        }
+
+        [Fact]
+        public void ThrowsArgumentOutOfRangeExceptionForNegativeFileOffset()
+        {
+            if (UsesOffsets)
+            {
+                FileOptions options = ShouldThrowForAsyncHandle ? FileOptions.None : FileOptions.Asynchronous;
+                using (SafeFileHandle handle = File.OpenHandle(GetTestFilePath(), FileMode.CreateNew, FileAccess.Write, options: options))
+                {
+                    AssertExtensions.Throws<ArgumentOutOfRangeException>("fileOffset", () => MethodUnderTest(handle, Array.Empty<byte>(), -1));
+                }
+            }
+        }
+
+        [Fact]
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/34582", TestPlatforms.Windows, TargetFrameworkMonikers.Netcoreapp, TestRuntimes.Mono)]
+        [SkipOnPlatform(TestPlatforms.Browser, "async file IO is not supported on browser")]
+        public void ThrowsArgumentExceptionForAsyncFileHandle()
+        {
+            if (ShouldThrowForAsyncHandle)
+            {
+                using (SafeFileHandle handle = File.OpenHandle(GetTestFilePath(), FileMode.CreateNew, FileAccess.Write, options: FileOptions.Asynchronous))
+                {
+                    AssertExtensions.Throws<ArgumentException>("handle", () => MethodUnderTest(handle, new byte[100], 0));
+                }
+            }
+        }
+
+        [Fact]
+        public void ThrowsArgumentExceptionForSyncFileHandle()
+        {
+            if (ShouldThrowForSyncHandle)
+            {
+                using (SafeFileHandle handle = File.OpenHandle(GetTestFilePath(), FileMode.CreateNew, FileAccess.Write, options: FileOptions.None))
+                {
+                    AssertExtensions.Throws<ArgumentException>("handle", () => MethodUnderTest(handle, new byte[100], 0));
+                }
+            }
+        }
+
+        protected static CancellationTokenSource GetCancelledTokenSource()
+        {
+            CancellationTokenSource source = new CancellationTokenSource();
+            source.Cancel();
+            return source;
+        }
+
+        protected SafeFileHandle GetHandleToExistingFile(FileAccess access)
+        {
+            string filePath = GetTestFilePath();
+            File.WriteAllBytes(filePath, new byte[1]);
+
+            FileOptions options = ShouldThrowForAsyncHandle ? FileOptions.None : FileOptions.Asynchronous;
+            return File.OpenHandle(filePath, FileMode.Open, access, FileShare.None, options);
+        }
+    }
+}
diff --git a/src/libraries/System.IO.FileSystem/tests/RandomAccess/GetLength.cs b/src/libraries/System.IO.FileSystem/tests/RandomAccess/GetLength.cs
new file mode 100644
index 00000000000000..46e2914aed1679
--- /dev/null
+++ b/src/libraries/System.IO.FileSystem/tests/RandomAccess/GetLength.cs
@@ -0,0 +1,38 @@
+// 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 Xunit;
+
+namespace System.IO.Tests
+{
+    public class RandomAccess_GetLength : RandomAccess_Base<long>
+    {
+        protected override long MethodUnderTest(SafeFileHandle handle, byte[] bytes, long fileOffset)
+            => RandomAccess.GetLength(handle);
+
+        protected override bool UsesOffsets => false;
+
+        [Fact]
+        public void ReturnsZeroForEmptyFile()
+        {
+            using (SafeFileHandle handle = File.OpenHandle(GetTestFilePath(), FileMode.CreateNew, FileAccess.Write))
+            {
+                Assert.Equal(0, RandomAccess.GetLength(handle));
+            }
+        }
+
+        [Fact]
+        public void ReturnsExactSizeForNonEmptyFiles()
+        {
+            const int fileSize = 123;
+            string filePath = GetTestFilePath();
+            File.WriteAllBytes(filePath, new byte[fileSize]);
+
+            using (SafeFileHandle handle = File.OpenHandle(filePath, FileMode.Open))
+            {
+                Assert.Equal(fileSize, RandomAccess.GetLength(handle));
+            }
+        }
+    }
+}
diff --git a/src/libraries/System.IO.FileSystem/tests/RandomAccess/NoBuffering.Windows.cs b/src/libraries/System.IO.FileSystem/tests/RandomAccess/NoBuffering.Windows.cs
new file mode 100644
index 00000000000000..ea9982600945ea
--- /dev/null
+++ b/src/libraries/System.IO.FileSystem/tests/RandomAccess/NoBuffering.Windows.cs
@@ -0,0 +1,153 @@
+// 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.Cryptography;
+using System.Threading.Tasks;
+using Microsoft.Win32.SafeHandles;
+using Xunit;
+
+namespace System.IO.Tests
+{
+    [ActiveIssue("https://github.com/dotnet/runtime/issues/34582", TestPlatforms.Windows, TargetFrameworkMonikers.Netcoreapp, TestRuntimes.Mono)]
+    [SkipOnPlatform(TestPlatforms.Browser, "async file IO is not supported on browser")]
+    public class RandomAccess_NoBuffering : FileSystemTest
+    {
+        private const FileOptions NoBuffering = (FileOptions)0x20000000;
+
+        [Fact]
+        public async Task ReadAsyncUsingSingleBuffer()
+        {
+            const int fileSize = 1_000_000; // 1 MB
+            string filePath = GetTestFilePath();
+            byte[] expected = RandomNumberGenerator.GetBytes(fileSize);
+            File.WriteAllBytes(filePath, expected);
+
+            using (SafeFileHandle handle = File.OpenHandle(filePath, FileMode.Open, options: FileOptions.Asynchronous | NoBuffering))
+            using (SectorAlignedMemory<byte> buffer = SectorAlignedMemory<byte>.Allocate(Environment.SystemPageSize))
+            {
+                int current = 0;
+                int total = 0;
+
+                // From https://docs.microsoft.com/en-us/windows/win32/fileio/file-buffering:
+                // "File access sizes, including the optional file offset in the OVERLAPPED structure,
+                // if specified, must be for a number of bytes that is an integer multiple of the volume sector size."
+                // So if buffer and physical sector size is 4096 and the file size is 4097:
+                // the read from offset=0 reads 4096 bytes
+                // the read from offset=4096 reads 1 byte
+                // the read from offset=4097 THROWS (Invalid argument, offset is not a multiple of sector size!)
+                // That is why we stop at the first incomplete read (the next one would throw).
+                // It's possible to get 0 if we are lucky and file size is a multiple of physical sector size.
+                do
+                {
+                    current = await RandomAccess.ReadAsync(handle, buffer.Memory, fileOffset: total);
+
+                    Assert.True(expected.AsSpan(total, current).SequenceEqual(buffer.GetSpan().Slice(0, current)));
+
+                    total += current;
+                }
+                while (current == buffer.Memory.Length);
+
+                Assert.Equal(fileSize, total);
+            }
+        }
+
+        [Fact]
+        public async Task ReadAsyncUsingMultipleBuffers()
+        {
+            const int fileSize = 1_000_000; // 1 MB
+            string filePath = GetTestFilePath();
+            byte[] expected = RandomNumberGenerator.GetBytes(fileSize);
+            File.WriteAllBytes(filePath, expected);
+
+            using (SafeFileHandle handle = File.OpenHandle(filePath, FileMode.Open, options: FileOptions.Asynchronous | NoBuffering))
+            using (SectorAlignedMemory<byte> buffer_1 = SectorAlignedMemory<byte>.Allocate(Environment.SystemPageSize))
+            using (SectorAlignedMemory<byte> buffer_2 = SectorAlignedMemory<byte>.Allocate(Environment.SystemPageSize))
+            {
+                long current = 0;
+                long total = 0;
+
+                do
+                {
+                    current = await RandomAccess.ReadAsync(
+                        handle,
+                        new Memory<byte>[]
+                        {
+                            buffer_1.Memory,
+                            buffer_2.Memory,
+                        },
+                        fileOffset: total);
+
+                    int takeFromFirst = Math.Min(buffer_1.Memory.Length, (int)current);
+                    Assert.True(expected.AsSpan((int)total, takeFromFirst).SequenceEqual(buffer_1.GetSpan().Slice(0, takeFromFirst)));
+                    int takeFromSecond = (int)current - takeFromFirst;
+                    Assert.True(expected.AsSpan((int)total + takeFromFirst, takeFromSecond).SequenceEqual(buffer_2.GetSpan().Slice(0, takeFromSecond)));
+
+                    total += current;
+                } while (current == buffer_1.Memory.Length + buffer_2.Memory.Length);
+
+                Assert.Equal(fileSize, total);
+            }
+        }
+
+        [Fact]
+        public async Task WriteAsyncUsingSingleBuffer()
+        {
+            string filePath = GetTestFilePath();
+            int bufferSize = Environment.SystemPageSize;
+            int fileSize = bufferSize * 10;
+            byte[] content = RandomNumberGenerator.GetBytes(fileSize);
+
+            using (SafeFileHandle handle = File.OpenHandle(filePath, FileMode.CreateNew, FileAccess.Write, FileShare.None, FileOptions.Asynchronous | NoBuffering))
+            using (SectorAlignedMemory<byte> buffer = SectorAlignedMemory<byte>.Allocate(bufferSize))
+            {
+                int total = 0;
+
+                while (total != fileSize)
+                {
+                    int take = Math.Min(content.Length - total, bufferSize);
+                    content.AsSpan(total, take).CopyTo(buffer.GetSpan());
+
+                    total += await RandomAccess.WriteAsync(
+                        handle,
+                        buffer.Memory,
+                        fileOffset: total);
+                }
+            }
+
+            Assert.Equal(content, File.ReadAllBytes(filePath));
+        }
+
+        [Fact]
+        public async Task WriteAsyncUsingMultipleBuffers()
+        {
+            string filePath = GetTestFilePath();
+            int bufferSize = Environment.SystemPageSize;
+            int fileSize = bufferSize * 10;
+            byte[] content = RandomNumberGenerator.GetBytes(fileSize);
+
+            using (SafeFileHandle handle = File.OpenHandle(filePath, FileMode.CreateNew, FileAccess.Write, FileShare.None, FileOptions.Asynchronous | NoBuffering))
+            using (SectorAlignedMemory<byte> buffer_1 = SectorAlignedMemory<byte>.Allocate(bufferSize))
+            using (SectorAlignedMemory<byte> buffer_2 = SectorAlignedMemory<byte>.Allocate(bufferSize))
+            {
+                long total = 0;
+
+                while (total != fileSize)
+                {
+                    content.AsSpan((int)total, bufferSize).CopyTo(buffer_1.GetSpan());
+                    content.AsSpan((int)total + bufferSize, bufferSize).CopyTo(buffer_2.GetSpan());
+
+                    total += await RandomAccess.WriteAsync(
+                        handle,
+                        new ReadOnlyMemory<byte>[]
+                        {
+                            buffer_1.Memory,
+                            buffer_2.Memory,
+                        },
+                        fileOffset: total);
+                }
+            }
+
+            Assert.Equal(content, File.ReadAllBytes(filePath));
+        }
+    }
+}
diff --git a/src/libraries/System.IO.FileSystem/tests/RandomAccess/Read.cs b/src/libraries/System.IO.FileSystem/tests/RandomAccess/Read.cs
new file mode 100644
index 00000000000000..81021d04aee161
--- /dev/null
+++ b/src/libraries/System.IO.FileSystem/tests/RandomAccess/Read.cs
@@ -0,0 +1,70 @@
+// 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 System.Security.Cryptography;
+using Microsoft.Win32.SafeHandles;
+using Xunit;
+
+namespace System.IO.Tests
+{
+    public class RandomAccess_Read : RandomAccess_Base<int>
+    {
+        protected override int MethodUnderTest(SafeFileHandle handle, byte[] bytes, long fileOffset)
+            => RandomAccess.Read(handle, bytes, fileOffset);
+
+        protected override bool ShouldThrowForAsyncHandle
+            => OperatingSystem.IsWindows(); // on Windows we can NOT perform sync IO using async handle
+
+        [Fact]
+        public void ThrowsOnWriteAccess()
+        {
+            using (SafeFileHandle handle = GetHandleToExistingFile(FileAccess.Write))
+            {
+                Assert.Throws<UnauthorizedAccessException>(() => RandomAccess.Read(handle, new byte[1], 0));
+            }
+        }
+
+        [Fact]
+        public void ReadToAnEmptyBufferReturnsZero()
+        {
+            string filePath = GetTestFilePath();
+            File.WriteAllBytes(filePath, new byte[1]);
+
+            using (SafeFileHandle handle = File.OpenHandle(filePath, FileMode.Open))
+            {
+                Assert.Equal(0, RandomAccess.Read(handle, Array.Empty<byte>(), fileOffset: 0));
+            }
+        }
+
+        [Fact]
+        public void ReadsBytesFromGivenFileAtGivenOffset()
+        {
+            const int fileSize = 4_001;
+            string filePath = GetTestFilePath();
+            byte[] expected = RandomNumberGenerator.GetBytes(fileSize);
+            File.WriteAllBytes(filePath, expected);
+
+            using (SafeFileHandle handle = File.OpenHandle(filePath, FileMode.Open))
+            {
+                byte[] actual = new byte[fileSize + 1];
+                int current = 0;
+                int total = 0;
+
+                do
+                {
+                    Span<byte> buffer = actual.AsSpan(total, Math.Min(actual.Length - total, fileSize / 4));
+
+                    current = RandomAccess.Read(handle, buffer, fileOffset: total);
+
+                    Assert.InRange(current, 0, buffer.Length);
+
+                    total += current;
+                } while (current != 0);
+
+                Assert.Equal(fileSize, total);
+                Assert.Equal(expected, actual.Take(total).ToArray());
+            }
+        }
+    }
+}
diff --git a/src/libraries/System.IO.FileSystem/tests/RandomAccess/ReadAsync.cs b/src/libraries/System.IO.FileSystem/tests/RandomAccess/ReadAsync.cs
new file mode 100644
index 00000000000000..c18da9ecd50595
--- /dev/null
+++ b/src/libraries/System.IO.FileSystem/tests/RandomAccess/ReadAsync.cs
@@ -0,0 +1,89 @@
+// 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 System.Security.Cryptography;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Win32.SafeHandles;
+using Xunit;
+
+namespace System.IO.Tests
+{
+    [ActiveIssue("https://github.com/dotnet/runtime/issues/34582", TestPlatforms.Windows, TargetFrameworkMonikers.Netcoreapp, TestRuntimes.Mono)]
+    [SkipOnPlatform(TestPlatforms.Browser, "async file IO is not supported on browser")]
+    public class RandomAccess_ReadAsync : RandomAccess_Base<ValueTask<int>>
+    {
+        protected override ValueTask<int> MethodUnderTest(SafeFileHandle handle, byte[] bytes, long fileOffset)
+            => RandomAccess.ReadAsync(handle, bytes, fileOffset);
+
+        protected override bool ShouldThrowForSyncHandle
+            => OperatingSystem.IsWindows(); // on Windows we can NOT perform async IO using sync handle
+
+        [Fact]
+        public async Task TaskAlreadyCanceledAsync()
+        {
+            using (SafeFileHandle handle = File.OpenHandle(GetTestFilePath(), FileMode.CreateNew, FileAccess.ReadWrite, options: FileOptions.Asynchronous))
+            {
+                CancellationTokenSource cts = GetCancelledTokenSource();
+                CancellationToken token = cts.Token;
+
+                Assert.True(RandomAccess.ReadAsync(handle, new byte[1], 0, token).IsCanceled);
+
+                TaskCanceledException ex = await Assert.ThrowsAsync<TaskCanceledException>(() => RandomAccess.ReadAsync(handle, new byte[1], 0, token).AsTask());
+                Assert.Equal(token, ex.CancellationToken);
+            }
+        }
+
+        [Fact]
+        public async Task ThrowsOnWriteAccess()
+        {
+            using (SafeFileHandle handle = GetHandleToExistingFile(FileAccess.Write))
+            {
+                await Assert.ThrowsAsync<UnauthorizedAccessException>(async () => await RandomAccess.ReadAsync(handle, new byte[1], 0));
+            }
+        }
+
+        [Fact]
+        public async Task ReadToAnEmptyBufferReturnsZeroAsync()
+        {
+            string filePath = GetTestFilePath();
+            File.WriteAllBytes(filePath, new byte[1]);
+
+            using (SafeFileHandle handle = File.OpenHandle(filePath, FileMode.Open, options: FileOptions.Asynchronous))
+            {
+                Assert.Equal(0, await RandomAccess.ReadAsync(handle, Array.Empty<byte>(), fileOffset: 0));
+            }
+        }
+
+        [Fact]
+        public async Task ReadsBytesFromGivenFileAtGivenOffsetAsync()
+        {
+            const int fileSize = 4_001;
+            string filePath = GetTestFilePath();
+            byte[] expected = RandomNumberGenerator.GetBytes(fileSize);
+            File.WriteAllBytes(filePath, expected);
+
+            using (SafeFileHandle handle = File.OpenHandle(filePath, FileMode.Open, options: FileOptions.Asynchronous))
+            {
+                byte[] actual = new byte[fileSize + 1];
+                int current = 0;
+                int total = 0;
+
+                do
+                {
+                    Memory<byte> buffer = actual.AsMemory(total, Math.Min(actual.Length - total, fileSize / 4));
+
+                    current = await RandomAccess.ReadAsync(handle, buffer, fileOffset: total);
+
+                    Assert.InRange(current, 0, buffer.Length);
+
+                    total += current;
+                } while (current != 0);
+
+                Assert.Equal(fileSize, total);
+                Assert.Equal(expected, actual.Take(total).ToArray());
+            }
+        }
+    }
+}
diff --git a/src/libraries/System.IO.FileSystem/tests/RandomAccess/ReadScatter.cs b/src/libraries/System.IO.FileSystem/tests/RandomAccess/ReadScatter.cs
new file mode 100644
index 00000000000000..68058b6242fc79
--- /dev/null
+++ b/src/libraries/System.IO.FileSystem/tests/RandomAccess/ReadScatter.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.Linq;
+using System.Security.Cryptography;
+using Microsoft.Win32.SafeHandles;
+using Xunit;
+
+namespace System.IO.Tests
+{
+    public class RandomAccess_ReadScatter : RandomAccess_Base<long>
+    {
+        protected override long MethodUnderTest(SafeFileHandle handle, byte[] bytes, long fileOffset)
+            => RandomAccess.Read(handle, new Memory<byte>[] { bytes }, fileOffset);
+
+        protected override bool ShouldThrowForAsyncHandle
+            => OperatingSystem.IsWindows(); // on Windows we can NOT perform sync IO using async handle
+
+        [Fact]
+        public void ThrowsArgumentNullExceptionForNullBuffers()
+        {
+            using (SafeFileHandle handle = File.OpenHandle(GetTestFilePath(), FileMode.CreateNew, FileAccess.Write))
+            {
+                AssertExtensions.Throws<ArgumentNullException>("buffers", () => RandomAccess.Read(handle, buffers: null, 0));
+            }
+        }
+
+        [Fact]
+        public void ThrowsOnWriteAccess()
+        {
+            using (SafeFileHandle handle = GetHandleToExistingFile(FileAccess.Write))
+            {
+                Assert.Throws<UnauthorizedAccessException>(() => RandomAccess.Read(handle, new Memory<byte>[] { new byte[1] }, 0));
+            }
+        }
+
+        [Fact]
+        public void ReadToAnEmptyBufferReturnsZero()
+        {
+            string filePath = GetTestFilePath();
+            File.WriteAllBytes(filePath, new byte[1]);
+
+            using (SafeFileHandle handle = File.OpenHandle(filePath, FileMode.Open))
+            {
+                Assert.Equal(0, RandomAccess.Read(handle, new Memory<byte>[] { Array.Empty<byte>() }, fileOffset: 0));
+            }
+        }
+
+        [Fact]
+        public void ReadsBytesFromGivenFileAtGivenOffset()
+        {
+            const int fileSize = 4_001;
+            string filePath = GetTestFilePath();
+            byte[] expected = RandomNumberGenerator.GetBytes(fileSize);
+            File.WriteAllBytes(filePath, expected);
+
+            using (SafeFileHandle handle = File.OpenHandle(filePath, FileMode.Open))
+            {
+                byte[] actual = new byte[fileSize + 1];
+                long current = 0;
+                long total = 0;
+
+                do
+                {
+                    int firstBufferLength = (int)Math.Min(actual.Length - total, fileSize / 4);
+                    Memory<byte> buffer_1 = actual.AsMemory((int)total, firstBufferLength);
+                    Memory<byte> buffer_2 = actual.AsMemory((int)total + firstBufferLength);
+
+                    current = RandomAccess.Read(
+                        handle,
+                        new Memory<byte>[]
+                        {
+                            buffer_1,
+                            Array.Empty<byte>(),
+                            buffer_2
+                        },
+                        fileOffset: total);
+
+                    Assert.InRange(current, 0, buffer_1.Length + buffer_2.Length);
+
+                    total += current;
+                } while (current != 0);
+
+                Assert.Equal(fileSize, total);
+                Assert.Equal(expected, actual.Take((int)total).ToArray());
+            }
+        }
+
+        [Fact]
+        public void ReadToTheSameBufferOverwritesContent()
+        {
+            string filePath = GetTestFilePath();
+            File.WriteAllBytes(filePath, new byte[3] { 1, 2, 3 });
+
+            using (SafeFileHandle handle = File.OpenHandle(filePath, FileMode.Open))
+            {
+                byte[] buffer = new byte[1];
+                Assert.Equal(buffer.Length + buffer.Length, RandomAccess.Read(handle, Enumerable.Repeat(buffer.AsMemory(), 2).ToList(), fileOffset: 0));
+                Assert.Equal(2, buffer[0]);
+            }
+        }
+    }
+}
diff --git a/src/libraries/System.IO.FileSystem/tests/RandomAccess/ReadScatterAsync.cs b/src/libraries/System.IO.FileSystem/tests/RandomAccess/ReadScatterAsync.cs
new file mode 100644
index 00000000000000..68d631a6dc390a
--- /dev/null
+++ b/src/libraries/System.IO.FileSystem/tests/RandomAccess/ReadScatterAsync.cs
@@ -0,0 +1,121 @@
+// 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 System.Security.Cryptography;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Win32.SafeHandles;
+using Xunit;
+
+namespace System.IO.Tests
+{
+    [ActiveIssue("https://github.com/dotnet/runtime/issues/34582", TestPlatforms.Windows, TargetFrameworkMonikers.Netcoreapp, TestRuntimes.Mono)]
+    [SkipOnPlatform(TestPlatforms.Browser, "async file IO is not supported on browser")]
+    public class RandomAccess_ReadScatterAsync : RandomAccess_Base<ValueTask<long>>
+    {
+        protected override ValueTask<long> MethodUnderTest(SafeFileHandle handle, byte[] bytes, long fileOffset)
+            => RandomAccess.ReadAsync(handle, new Memory<byte>[] { bytes }, fileOffset);
+
+        protected override bool ShouldThrowForSyncHandle
+            => OperatingSystem.IsWindows(); // on Windows we can NOT perform async IO using sync handle
+
+        [Fact]
+        public void ThrowsArgumentNullExceptionForNullBuffers()
+        {
+            using (SafeFileHandle handle = File.OpenHandle(GetTestFilePath(), FileMode.CreateNew, FileAccess.Write, options: FileOptions.Asynchronous))
+            {
+                AssertExtensions.Throws<ArgumentNullException>("buffers", () => RandomAccess.ReadAsync(handle, buffers: null, 0));
+            }
+        }
+
+        [Fact]
+        public async Task TaskAlreadyCanceledAsync()
+        {
+            using (SafeFileHandle handle = File.OpenHandle(GetTestFilePath(), FileMode.CreateNew, FileAccess.ReadWrite, options: FileOptions.Asynchronous))
+            {
+                CancellationTokenSource cts = GetCancelledTokenSource();
+                CancellationToken token = cts.Token;
+
+                Assert.True(RandomAccess.ReadAsync(handle, new Memory<byte>[] { new byte[1] }, 0, token).IsCanceled);
+
+                TaskCanceledException ex = await Assert.ThrowsAsync<TaskCanceledException>(() => RandomAccess.ReadAsync(handle, new Memory<byte>[] { new byte[1] }, 0, token).AsTask());
+                Assert.Equal(token, ex.CancellationToken);
+            }
+        }
+
+        [Fact]
+        public async Task ThrowsOnWriteAccess()
+        {
+            using (SafeFileHandle handle = GetHandleToExistingFile(FileAccess.Write))
+            {
+                await Assert.ThrowsAsync<UnauthorizedAccessException>(async () => await RandomAccess.ReadAsync(handle, new Memory<byte>[] { new byte[1] }, 0));
+            }
+        }
+
+        [Fact]
+        public async Task ReadToAnEmptyBufferReturnsZeroAsync()
+        {
+            string filePath = GetTestFilePath();
+            File.WriteAllBytes(filePath, new byte[1]);
+
+            using (SafeFileHandle handle = File.OpenHandle(filePath, FileMode.Open, options: FileOptions.Asynchronous))
+            {
+                Assert.Equal(0, await RandomAccess.ReadAsync(handle, new Memory<byte>[] { Array.Empty<byte>() }, fileOffset: 0));
+            }
+        }
+
+        [Fact]
+        public async Task ReadsBytesFromGivenFileAtGivenOffsetAsync()
+        {
+            const int fileSize = 4_001;
+            string filePath = GetTestFilePath();
+            byte[] expected = RandomNumberGenerator.GetBytes(fileSize);
+            File.WriteAllBytes(filePath, expected);
+
+            using (SafeFileHandle handle = File.OpenHandle(filePath, FileMode.Open, options: FileOptions.Asynchronous))
+            {
+                byte[] actual = new byte[fileSize + 1];
+                long current = 0;
+                long total = 0;
+
+                do
+                {
+                    int firstBufferLength = (int)Math.Min(actual.Length - total, fileSize / 4);
+                    Memory<byte> buffer_1 = actual.AsMemory((int)total, firstBufferLength);
+                    Memory<byte> buffer_2 = actual.AsMemory((int)total + firstBufferLength);
+
+                    current = await RandomAccess.ReadAsync(
+                        handle,
+                        new Memory<byte>[]
+                        {
+                            buffer_1,
+                            buffer_2
+                        },
+                        fileOffset: total);
+
+                    Assert.InRange(current, 0, buffer_1.Length + buffer_2.Length);
+
+                    total += current;
+                } while (current != 0);
+
+                Assert.Equal(fileSize, total);
+                Assert.Equal(expected, actual.Take((int)total).ToArray());
+            }
+        }
+
+        [Fact]
+        public async Task ReadToTheSameBufferOverwritesContent()
+        {
+            string filePath = GetTestFilePath();
+            File.WriteAllBytes(filePath, new byte[3] { 1, 2, 3 });
+
+            using (SafeFileHandle handle = File.OpenHandle(filePath, FileMode.Open, options: FileOptions.Asynchronous))
+            {
+                byte[] buffer = new byte[1];
+                Assert.Equal(buffer.Length + buffer.Length, await RandomAccess.ReadAsync(handle, Enumerable.Repeat(buffer.AsMemory(), 2).ToList(), fileOffset: 0));
+                Assert.Equal(2, buffer[0]);
+            }
+        }
+    }
+}
diff --git a/src/libraries/System.IO.FileSystem/tests/RandomAccess/SectorAlignedMemory.Windows.cs b/src/libraries/System.IO.FileSystem/tests/RandomAccess/SectorAlignedMemory.Windows.cs
new file mode 100644
index 00000000000000..593cc6e50246d3
--- /dev/null
+++ b/src/libraries/System.IO.FileSystem/tests/RandomAccess/SectorAlignedMemory.Windows.cs
@@ -0,0 +1,102 @@
+// 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.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Threading;
+using static Interop.Kernel32;
+
+namespace System.IO.Tests
+{
+    internal sealed class SectorAlignedMemory<T> : MemoryManager<T>
+    {
+        private bool _disposed;
+        private int _refCount;
+        private IntPtr _memory;
+        private int _length;
+
+        private unsafe SectorAlignedMemory(void* memory, int length)
+        {
+            _memory = (IntPtr)memory;
+            _length = length;
+        }
+
+        public static unsafe SectorAlignedMemory<T> Allocate(int length)
+        {
+            void* memory = VirtualAlloc(
+                IntPtr.Zero.ToPointer(),
+                new UIntPtr((uint)(Marshal.SizeOf<T>() * length)),
+                MemOptions.MEM_COMMIT | MemOptions.MEM_RESERVE,
+                PageOptions.PAGE_READWRITE);
+
+            return new SectorAlignedMemory<T>(memory, length);
+        }
+
+        public bool IsDisposed => _disposed;
+
+        public unsafe override Span<T> GetSpan() => new Span<T>((void*)_memory, _length);
+
+        public override MemoryHandle Pin(int elementIndex = 0)
+        {
+            unsafe
+            {
+                Retain();
+                if ((uint)elementIndex > _length) throw new ArgumentOutOfRangeException(nameof(elementIndex));
+                void* pointer = Unsafe.Add<T>((void*)_memory, elementIndex);
+                return new MemoryHandle(pointer, default, this);
+            }
+        }
+
+        private bool Release()
+        {
+            int newRefCount = Interlocked.Decrement(ref _refCount);
+
+            if (newRefCount < 0)
+            {
+                throw new InvalidOperationException("Unmatched Release/Retain");
+            }
+
+            return newRefCount != 0;
+        }
+
+        private void Retain()
+        {
+            if (_disposed)
+            {
+                throw new ObjectDisposedException(nameof(SectorAlignedMemory<T>));
+            }
+
+            Interlocked.Increment(ref _refCount);
+        }
+
+        protected override unsafe void Dispose(bool disposing)
+        {
+            if (_disposed)
+            {
+                return;
+            }
+
+            VirtualAlloc(
+                _memory.ToPointer(),
+                new UIntPtr((uint)(Marshal.SizeOf<T>() * _length)),
+                MemOptions.MEM_FREE,
+                PageOptions.PAGE_READWRITE);
+            _memory = IntPtr.Zero;
+
+            _disposed = true;
+        }
+
+        protected override bool TryGetArray(out ArraySegment<T> arraySegment)
+        {
+            // cannot expose managed array
+            arraySegment = default;
+            return false;
+        }
+
+        public override void Unpin()
+        {
+            Release();
+        }
+    }
+}
diff --git a/src/libraries/System.IO.FileSystem/tests/RandomAccess/Write.cs b/src/libraries/System.IO.FileSystem/tests/RandomAccess/Write.cs
new file mode 100644
index 00000000000000..abcac008dc6dd2
--- /dev/null
+++ b/src/libraries/System.IO.FileSystem/tests/RandomAccess/Write.cs
@@ -0,0 +1,63 @@
+// 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.Cryptography;
+using Microsoft.Win32.SafeHandles;
+using Xunit;
+
+namespace System.IO.Tests
+{
+    public class RandomAccess_Write : RandomAccess_Base<int>
+    {
+        protected override int MethodUnderTest(SafeFileHandle handle, byte[] bytes, long fileOffset)
+            => RandomAccess.Write(handle, bytes, fileOffset);
+
+        protected override bool ShouldThrowForAsyncHandle
+            => OperatingSystem.IsWindows(); // on Windows we can NOT perform sync IO using async handle
+
+        [Fact]
+        public void ThrowsOnReadAccess()
+        {
+            using (SafeFileHandle handle = GetHandleToExistingFile(FileAccess.Read))
+            {
+                Assert.Throws<UnauthorizedAccessException>(() => RandomAccess.Write(handle, new byte[1], 0));
+            }
+        }
+
+        [Fact]
+        public void WriteUsingEmptyBufferReturnsZero()
+        {
+            using (SafeFileHandle handle = File.OpenHandle(GetTestFilePath(), FileMode.Create, FileAccess.Write))
+            {
+                Assert.Equal(0, RandomAccess.Write(handle, Array.Empty<byte>(), fileOffset: 0));
+            }
+        }
+
+        [Fact]
+        public void WritesBytesFromGivenBufferToGivenFileAtGivenOffset()
+        {
+            const int fileSize = 4_001;
+            string filePath = GetTestFilePath();
+            byte[] content = RandomNumberGenerator.GetBytes(fileSize);
+
+            using (SafeFileHandle handle = File.OpenHandle(filePath, FileMode.CreateNew, FileAccess.Write, FileShare.None))
+            {
+                int total = 0;
+                int current = 0;
+
+                while (total != fileSize)
+                {
+                    Span<byte> buffer = content.AsSpan(total, Math.Min(content.Length - total, fileSize / 4));
+
+                    current = RandomAccess.Write(handle, buffer, fileOffset: total);
+
+                    Assert.InRange(current, 0, buffer.Length);
+
+                    total += current;
+                }
+            }
+
+            Assert.Equal(content, File.ReadAllBytes(filePath));
+        }
+    }
+}
diff --git a/src/libraries/System.IO.FileSystem/tests/RandomAccess/WriteAsync.cs b/src/libraries/System.IO.FileSystem/tests/RandomAccess/WriteAsync.cs
new file mode 100644
index 00000000000000..074f5baac59442
--- /dev/null
+++ b/src/libraries/System.IO.FileSystem/tests/RandomAccess/WriteAsync.cs
@@ -0,0 +1,82 @@
+// 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.Cryptography;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Win32.SafeHandles;
+using Xunit;
+
+namespace System.IO.Tests
+{
+    [ActiveIssue("https://github.com/dotnet/runtime/issues/34582", TestPlatforms.Windows, TargetFrameworkMonikers.Netcoreapp, TestRuntimes.Mono)]
+    [SkipOnPlatform(TestPlatforms.Browser, "async file IO is not supported on browser")]
+    public class RandomAccess_WriteAsync : RandomAccess_Base<ValueTask<int>>
+    {
+        protected override ValueTask<int> MethodUnderTest(SafeFileHandle handle, byte[] bytes, long fileOffset)
+            => RandomAccess.WriteAsync(handle, bytes, fileOffset);
+
+        protected override bool ShouldThrowForSyncHandle
+            => OperatingSystem.IsWindows(); // on Windows we can NOT perform async IO using sync handle
+
+        [Fact]
+        public async Task TaskAlreadyCanceledAsync()
+        {
+            using (SafeFileHandle handle = File.OpenHandle(GetTestFilePath(), FileMode.CreateNew, FileAccess.ReadWrite, options: FileOptions.Asynchronous))
+            {
+                CancellationTokenSource cts = GetCancelledTokenSource();
+                CancellationToken token = cts.Token;
+
+                Assert.True(RandomAccess.WriteAsync(handle, new byte[1], 0, token).IsCanceled);
+
+                TaskCanceledException ex = await Assert.ThrowsAsync<TaskCanceledException>(() => RandomAccess.WriteAsync(handle, new byte[1], 0, token).AsTask());
+                Assert.Equal(token, ex.CancellationToken);
+            }
+        }
+
+        [Fact]
+        public async Task ThrowsOnReadAccess()
+        {
+            using (SafeFileHandle handle = GetHandleToExistingFile(FileAccess.Read))
+            {
+                await Assert.ThrowsAsync<UnauthorizedAccessException>(async () => await RandomAccess.WriteAsync(handle, new byte[1], 0));
+            }
+        }
+
+        [Fact]
+        public async Task WriteUsingEmptyBufferReturnsZeroAsync()
+        {
+            using (SafeFileHandle handle = File.OpenHandle(GetTestFilePath(), FileMode.Create, FileAccess.Write, options: FileOptions.Asynchronous))
+            {
+                Assert.Equal(0, await RandomAccess.WriteAsync(handle, Array.Empty<byte>(), fileOffset: 0));
+            }
+        }
+
+        [Fact]
+        public async Task WritesBytesFromGivenBufferToGivenFileAtGivenOffsetAsync()
+        {
+            const int fileSize = 4_001;
+            string filePath = GetTestFilePath();
+            byte[] content = RandomNumberGenerator.GetBytes(fileSize);
+
+            using (SafeFileHandle handle = File.OpenHandle(filePath, FileMode.CreateNew, FileAccess.Write, FileShare.None, FileOptions.Asynchronous))
+            {
+                int total = 0;
+                int current = 0;
+
+                while (total != fileSize)
+                {
+                    Memory<byte> buffer = content.AsMemory(total, Math.Min(content.Length - total, fileSize / 4));
+
+                    current = await RandomAccess.WriteAsync(handle, buffer, fileOffset: total);
+
+                    Assert.InRange(current, 0, buffer.Length);
+
+                    total += current;
+                }
+            }
+
+            Assert.Equal(content, File.ReadAllBytes(filePath));
+        }
+    }
+}
diff --git a/src/libraries/System.IO.FileSystem/tests/RandomAccess/WriteGather.cs b/src/libraries/System.IO.FileSystem/tests/RandomAccess/WriteGather.cs
new file mode 100644
index 00000000000000..a9483d6c0eae21
--- /dev/null
+++ b/src/libraries/System.IO.FileSystem/tests/RandomAccess/WriteGather.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.Collections.Generic;
+using System.Linq;
+using System.Security.Cryptography;
+using Microsoft.Win32.SafeHandles;
+using Xunit;
+
+namespace System.IO.Tests
+{
+    public class RandomAccess_WriteGather : RandomAccess_Base<long>
+    {
+        protected override long MethodUnderTest(SafeFileHandle handle, byte[] bytes, long fileOffset)
+            => RandomAccess.Write(handle, new ReadOnlyMemory<byte>[] { bytes }, fileOffset);
+
+        protected override bool ShouldThrowForAsyncHandle
+            => OperatingSystem.IsWindows(); // on Windows we can NOT perform sync IO using async handle
+
+        [Fact]
+        public void ThrowsArgumentNullExceptionForNullBuffers()
+        {
+            using (SafeFileHandle handle = File.OpenHandle(GetTestFilePath(), FileMode.CreateNew, FileAccess.Write))
+            {
+                AssertExtensions.Throws<ArgumentNullException>("buffers", () => RandomAccess.Write(handle, buffers: null, 0));
+            }
+        }
+
+        [Fact]
+        public void ThrowsOnReadAccess()
+        {
+            using (SafeFileHandle handle = GetHandleToExistingFile(FileAccess.Read))
+            {
+                Assert.Throws<UnauthorizedAccessException>(() => RandomAccess.Write(handle, new ReadOnlyMemory<byte>[] { new byte[1] }, 0));
+            }
+        }
+
+        [Fact]
+        public void WriteUsingEmptyBufferReturnsZero()
+        {
+            using (SafeFileHandle handle = File.OpenHandle(GetTestFilePath(), FileMode.Create, FileAccess.Write))
+            {
+                Assert.Equal(0, RandomAccess.Write(handle, new ReadOnlyMemory<byte>[] { Array.Empty<byte>() }, fileOffset: 0));
+            }
+        }
+
+        [Fact]
+        public void WritesBytesFromGivenBuffersToGivenFileAtGivenOffset()
+        {
+            const int fileSize = 4_001;
+            string filePath = GetTestFilePath();
+            byte[] content = RandomNumberGenerator.GetBytes(fileSize);
+
+            using (SafeFileHandle handle = File.OpenHandle(filePath, FileMode.CreateNew, FileAccess.Write, FileShare.None))
+            {
+                long total = 0;
+                long current = 0;
+
+                while (total != fileSize)
+                {
+                    int firstBufferLength = (int)Math.Min(content.Length - total, fileSize / 4);
+                    Memory<byte> buffer_1 = content.AsMemory((int)total, firstBufferLength);
+                    Memory<byte> buffer_2 = content.AsMemory((int)total + firstBufferLength);
+
+                    current = RandomAccess.Write(
+                        handle,
+                        new ReadOnlyMemory<byte>[]
+                        {
+                            buffer_1,
+                            Array.Empty<byte>(),
+                            buffer_2
+                        },
+                        fileOffset: total);
+
+                    Assert.InRange(current, 0, buffer_1.Length + buffer_2.Length);
+
+                    total += current;
+                }
+            }
+
+            Assert.Equal(content, File.ReadAllBytes(filePath));
+        }
+
+        [Fact]
+        public void DuplicatedBufferDuplicatesContent()
+        {
+            const byte value = 1;
+            const int repeatCount = 2;
+            string filePath = GetTestFilePath();
+            ReadOnlyMemory<byte> buffer = new byte[1] { value };
+            List<ReadOnlyMemory<byte>> buffers = Enumerable.Repeat(buffer, repeatCount).ToList();
+
+            using (SafeFileHandle handle = File.OpenHandle(filePath, FileMode.Create, FileAccess.Write))
+            {
+                Assert.Equal(repeatCount, RandomAccess.Write(handle, buffers, fileOffset: 0));
+            }
+
+            byte[] actualContent = File.ReadAllBytes(filePath);
+            Assert.Equal(repeatCount, actualContent.Length);
+            Assert.All(actualContent, actual => Assert.Equal(value, actual));
+        }
+    }
+}
diff --git a/src/libraries/System.IO.FileSystem/tests/RandomAccess/WriteGatherAsync.cs b/src/libraries/System.IO.FileSystem/tests/RandomAccess/WriteGatherAsync.cs
new file mode 100644
index 00000000000000..f8369eb13c7823
--- /dev/null
+++ b/src/libraries/System.IO.FileSystem/tests/RandomAccess/WriteGatherAsync.cs
@@ -0,0 +1,121 @@
+// 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.Linq;
+using System.Security.Cryptography;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Win32.SafeHandles;
+using Xunit;
+
+namespace System.IO.Tests
+{
+    [ActiveIssue("https://github.com/dotnet/runtime/issues/34582", TestPlatforms.Windows, TargetFrameworkMonikers.Netcoreapp, TestRuntimes.Mono)]
+    [SkipOnPlatform(TestPlatforms.Browser, "async file IO is not supported on browser")]
+    public class RandomAccess_WriteGatherAsync : RandomAccess_Base<ValueTask<long>>
+    {
+        protected override ValueTask<long> MethodUnderTest(SafeFileHandle handle, byte[] bytes, long fileOffset)
+            => RandomAccess.WriteAsync(handle, new ReadOnlyMemory<byte>[] { bytes }, fileOffset);
+
+        protected override bool ShouldThrowForSyncHandle
+            => OperatingSystem.IsWindows(); // on Windows we can NOT perform async IO using sync handle
+
+        [Fact]
+        public void ThrowsArgumentNullExceptionForNullBuffers()
+        {
+            using (SafeFileHandle handle = File.OpenHandle(GetTestFilePath(), FileMode.CreateNew, FileAccess.Write, FileShare.None, FileOptions.Asynchronous))
+            {
+                AssertExtensions.Throws<ArgumentNullException>("buffers", () => RandomAccess.WriteAsync(handle, buffers: null, 0));
+            }
+        }
+
+        [Fact]
+        public async Task TaskAlreadyCanceledAsync()
+        {
+            using (SafeFileHandle handle = File.OpenHandle(GetTestFilePath(), FileMode.CreateNew, FileAccess.ReadWrite, options: FileOptions.Asynchronous))
+            {
+                CancellationTokenSource cts = GetCancelledTokenSource();
+                CancellationToken token = cts.Token;
+
+                Assert.True(RandomAccess.WriteAsync(handle, new ReadOnlyMemory<byte>[] { new byte[1] }, 0, token).IsCanceled);
+
+                TaskCanceledException ex = await Assert.ThrowsAsync<TaskCanceledException>(() => RandomAccess.WriteAsync(handle, new ReadOnlyMemory<byte>[] { new byte[1] }, 0, token).AsTask());
+                Assert.Equal(token, ex.CancellationToken);
+            }
+        }
+
+        [Fact]
+        public async Task ThrowsOnReadAccess()
+        {
+            using (SafeFileHandle handle = GetHandleToExistingFile(FileAccess.Read))
+            {
+                await Assert.ThrowsAsync<UnauthorizedAccessException>(async () => await RandomAccess.WriteAsync(handle, new ReadOnlyMemory<byte>[] { new byte[1] }, 0));
+            }
+        }
+
+        [Fact]
+        public async Task WriteUsingEmptyBufferReturnsZeroAsync()
+        {
+            using (SafeFileHandle handle = File.OpenHandle(GetTestFilePath(), FileMode.Create, FileAccess.Write, options: FileOptions.Asynchronous))
+            {
+                Assert.Equal(0, await RandomAccess.WriteAsync(handle, new ReadOnlyMemory<byte>[] { Array.Empty<byte>() }, fileOffset: 0));
+            }
+        }
+
+        [Fact]
+        public async Task WritesBytesFromGivenBufferToGivenFileAtGivenOffsetAsync()
+        {
+            const int fileSize = 4_001;
+            string filePath = GetTestFilePath();
+            byte[] content = RandomNumberGenerator.GetBytes(fileSize);
+
+            using (SafeFileHandle handle = File.OpenHandle(filePath, FileMode.CreateNew, FileAccess.Write, FileShare.None, FileOptions.Asynchronous))
+            {
+                long total = 0;
+                long current = 0;
+
+                while (total != fileSize)
+                {
+                    int firstBufferLength = (int)Math.Min(content.Length - total, fileSize / 4);
+                    Memory<byte> buffer_1 = content.AsMemory((int)total, firstBufferLength);
+                    Memory<byte> buffer_2 = content.AsMemory((int)total + firstBufferLength);
+
+                    current = await RandomAccess.WriteAsync(
+                        handle,
+                        new ReadOnlyMemory<byte>[]
+                        {
+                            buffer_1,
+                            buffer_2
+                        },
+                        fileOffset: total);
+
+                    Assert.InRange(current, 0, buffer_1.Length + buffer_2.Length);
+
+                    total += current;
+                }
+            }
+
+            Assert.Equal(content, File.ReadAllBytes(filePath));
+        }
+
+        [Fact]
+        public async Task DuplicatedBufferDuplicatesContentAsync()
+        {
+            const byte value = 1;
+            const int repeatCount = 2;
+            string filePath = GetTestFilePath();
+            ReadOnlyMemory<byte> buffer = new byte[1] { value };
+            List<ReadOnlyMemory<byte>> buffers = Enumerable.Repeat(buffer, repeatCount).ToList();
+
+            using (SafeFileHandle handle = File.OpenHandle(filePath, FileMode.Create, FileAccess.Write, options: FileOptions.Asynchronous))
+            {
+                Assert.Equal(repeatCount, await RandomAccess.WriteAsync(handle, buffers, fileOffset: 0));
+            }
+
+            byte[] actualContent = File.ReadAllBytes(filePath);
+            Assert.Equal(repeatCount, actualContent.Length);
+            Assert.All(actualContent, actual => Assert.Equal(value, actual));
+        }
+    }
+}
diff --git a/src/libraries/System.IO.FileSystem/tests/System.IO.FileSystem.Tests.csproj b/src/libraries/System.IO.FileSystem/tests/System.IO.FileSystem.Tests.csproj
index dba6172218ca0d..94cec86ce3a9aa 100644
--- a/src/libraries/System.IO.FileSystem/tests/System.IO.FileSystem.Tests.csproj
+++ b/src/libraries/System.IO.FileSystem/tests/System.IO.FileSystem.Tests.csproj
@@ -51,6 +51,17 @@
     <Compile Include="Enumeration\ExampleTests.cs" />
     <Compile Include="Enumeration\RemovedDirectoryTests.cs" />
     <Compile Include="Enumeration\SymbolicLinksTests.cs" />
+    <Compile Include="PathInternalTests.cs" />
+    <Compile Include="RandomAccess\Base.cs" />
+    <Compile Include="RandomAccess\GetLength.cs" />
+    <Compile Include="RandomAccess\Read.cs" />
+    <Compile Include="RandomAccess\ReadAsync.cs" />
+    <Compile Include="RandomAccess\ReadScatter.cs" />
+    <Compile Include="RandomAccess\ReadScatterAsync.cs" />
+    <Compile Include="RandomAccess\Write.cs" />
+    <Compile Include="RandomAccess\WriteAsync.cs" />
+    <Compile Include="RandomAccess\WriteGather.cs" />
+    <Compile Include="RandomAccess\WriteGatherAsync.cs" />
   </ItemGroup>
   <ItemGroup Condition="'$(TargetsUnix)' == 'true'">
     <Compile Include="FileSystemTest.Unix.cs" />
@@ -61,10 +72,14 @@
   <ItemGroup Condition="'$(TargetsWindows)' == 'true'">
     <Compile Include="FileSystemTest.Windows.cs" />
     <Compile Include="FileStream\ctor_options_as.Windows.cs" />
-    <Compile Include="$(CommonPath)Interop\Windows\Interop.BOOL.cs" Link="Interop\Windows\Interop.BOOL.cs" />
-    <Compile Include="$(CommonPath)Interop\Windows\Kernel32\Interop.FILE_STANDARD_INFO.cs" Link="Interop\Windows\Interop.FILE_STANDARD_INFO.cs" />
-    <Compile Include="$(CommonPath)Interop\Windows\Interop.Libraries.cs" Link="Interop\Windows\Interop.Libraries.cs" />
-    <Compile Include="$(CommonPath)Interop\Windows\Kernel32\Interop.GetFileInformationByHandleEx.cs" Link="Interop\Windows\Interop.GetFileInformationByHandleEx.cs" />
+    <Compile Include="RandomAccess\NoBuffering.Windows.cs" />
+    <Compile Include="RandomAccess\SectorAlignedMemory.Windows.cs" />
+    <Compile Include="$(CommonPath)Interop\Windows\Interop.BOOL.cs" Link="Common\Interop\Windows\Interop.BOOL.cs" />
+    <Compile Include="$(CommonPath)Interop\Windows\Interop.Libraries.cs" Link="Common\Interop\Windows\Interop.Libraries.cs" />
+    <Compile Include="$(CommonPath)Interop\Windows\Kernel32\Interop.FILE_STANDARD_INFO.cs" Link="Common\Interop\Windows\Interop.FILE_STANDARD_INFO.cs" />
+    <Compile Include="$(CommonPath)Interop\Windows\Kernel32\Interop.GetFileInformationByHandleEx.cs" Link="Common\Interop\Windows\Interop.GetFileInformationByHandleEx.cs" />
+    <Compile Include="$(CommonPath)Interop\Windows\Kernel32\Interop.MemOptions.cs" Link="Common\Interop\Windows\Interop.MemOptions.cs" />
+    <Compile Include="$(CommonPath)Interop\Windows\Kernel32\Interop.VirtualAlloc_Ptr.cs" Link="Common\Interop\Windows\Interop.VirtualAlloc_Ptr.cs" />
   </ItemGroup>
   <ItemGroup Condition="'$(TargetsBrowser)' == 'true'">
     <Compile Include="FileSystemTest.Browser.cs" />
@@ -90,6 +105,7 @@
     <Compile Include="FileStream\IsAsync.cs" />
     <Compile Include="FileStream\Name.cs" />
     <Compile Include="FileStream\CopyToAsync.cs" />
+    <Compile Include="FileStream\FileStreamOptions.cs" />
     <Compile Include="FileStream\Flush.cs" />
     <Compile Include="FileStream\Dispose.cs" />
     <Compile Include="FileStream\WriteAsync.cs" />
@@ -157,6 +173,7 @@
     <Compile Include="File\Exists.cs" />
     <Compile Include="File\GetSetTimes.cs" />
     <Compile Include="File\Open.cs" />
+    <Compile Include="File\OpenHandle.cs" />
     <Compile Include="FileInfo\Create.cs" />
     <Compile Include="FileInfo\Delete.cs" />
     <Compile Include="FileInfo\Exists.cs" />
@@ -175,6 +192,8 @@
     <Compile Include="$(CommonTestPath)System\IO\TempFile.cs" Link="Common\System\IO\TempFile.cs" />
     <Compile Include="$(CommonTestPath)System\IO\PathFeatures.cs" Link="Common\System\IO\PathFeatures.cs" />
     <Content Include="DirectoryInfo\test-dir\dummy.txt" Link="test-dir\dummy.txt" />
+    <Compile Include="$(CommonPath)System\IO\PathInternal.CaseSensitivity.cs"
+             Link="Common\System\IO\PathInternal.CaseSensitivity.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="$(CommonTestPath)StreamConformanceTests\StreamConformanceTests.csproj" />
diff --git a/src/libraries/System.IO.Hashing/Directory.Build.props b/src/libraries/System.IO.Hashing/Directory.Build.props
new file mode 100644
index 00000000000000..ba1f965d83cae7
--- /dev/null
+++ b/src/libraries/System.IO.Hashing/Directory.Build.props
@@ -0,0 +1,6 @@
+<Project>
+  <Import Project="..\Directory.Build.props" />
+  <PropertyGroup>
+    <StrongNameKeyId>Open</StrongNameKeyId>
+  </PropertyGroup>
+</Project>
diff --git a/src/libraries/System.IO.Hashing/System.IO.Hashing.sln b/src/libraries/System.IO.Hashing/System.IO.Hashing.sln
new file mode 100644
index 00000000000000..974d540529ab4b
--- /dev/null
+++ b/src/libraries/System.IO.Hashing/System.IO.Hashing.sln
@@ -0,0 +1,104 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 16
+VisualStudioVersion = 16.0.31320.298
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestUtilities", "..\Common\tests\TestUtilities\TestUtilities.csproj", "{F94DE827-A426-45CB-AE6E-4E1C154B5386}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Win32.Registry", "..\Microsoft.Win32.Registry\ref\Microsoft.Win32.Registry.csproj", "{38CB62AF-FD52-433E-AB63-CB07BA1D2CD8}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Collections.Immutable", "..\System.Collections.Immutable\src\System.Collections.Immutable.csproj", "{B51B75BA-A1AF-42FB-9845-E9AAC42CFB22}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.IO.Hashing", "ref\System.IO.Hashing.csproj", "{1548AC5C-27FD-4B46-A930-C168D622FAB0}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.IO.Hashing", "src\System.IO.Hashing.csproj", "{A078A4EB-27E8-42B1-BD44-3807732A4560}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.IO.Hashing.Tests", "tests\System.IO.Hashing.Tests.csproj", "{2E6DAC1B-9054-40AF-AF72-4C2DD7BD9294}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Reflection.Metadata", "..\System.Reflection.Metadata\src\System.Reflection.Metadata.csproj", "{0E49FF32-6CC1-42B0-AF30-25098C7DA18F}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Runtime.CompilerServices.Unsafe", "..\System.Runtime.CompilerServices.Unsafe\ref\System.Runtime.CompilerServices.Unsafe.csproj", "{696A5E1C-B7B4-4EA0-AE2A-3FDA1C50F4D9}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Runtime.CompilerServices.Unsafe", "..\System.Runtime.CompilerServices.Unsafe\src\System.Runtime.CompilerServices.Unsafe.ilproj", "{E5280823-9A9A-4314-B0C3-B983A7D50C85}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Security.AccessControl", "..\System.Security.AccessControl\ref\System.Security.AccessControl.csproj", "{A7AD2290-A979-4139-9C71-BBCD5594180D}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Security.Principal.Windows", "..\System.Security.Principal.Windows\ref\System.Security.Principal.Windows.csproj", "{3A873063-B154-4186-914D-1F4F3236101E}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "tests", "tests", "{3A73868D-BC2F-483A-B51B-0F3C862BBE85}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "ref", "ref", "{3F027944-9702-4DA5-A7E2-042D5037ABD3}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{BC246661-9887-4096-BF1A-AC25060547B2}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{F94DE827-A426-45CB-AE6E-4E1C154B5386}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{F94DE827-A426-45CB-AE6E-4E1C154B5386}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{F94DE827-A426-45CB-AE6E-4E1C154B5386}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{F94DE827-A426-45CB-AE6E-4E1C154B5386}.Release|Any CPU.Build.0 = Release|Any CPU
+		{38CB62AF-FD52-433E-AB63-CB07BA1D2CD8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{38CB62AF-FD52-433E-AB63-CB07BA1D2CD8}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{38CB62AF-FD52-433E-AB63-CB07BA1D2CD8}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{38CB62AF-FD52-433E-AB63-CB07BA1D2CD8}.Release|Any CPU.Build.0 = Release|Any CPU
+		{B51B75BA-A1AF-42FB-9845-E9AAC42CFB22}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{B51B75BA-A1AF-42FB-9845-E9AAC42CFB22}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{B51B75BA-A1AF-42FB-9845-E9AAC42CFB22}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{B51B75BA-A1AF-42FB-9845-E9AAC42CFB22}.Release|Any CPU.Build.0 = Release|Any CPU
+		{1548AC5C-27FD-4B46-A930-C168D622FAB0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{1548AC5C-27FD-4B46-A930-C168D622FAB0}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{1548AC5C-27FD-4B46-A930-C168D622FAB0}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{1548AC5C-27FD-4B46-A930-C168D622FAB0}.Release|Any CPU.Build.0 = Release|Any CPU
+		{A078A4EB-27E8-42B1-BD44-3807732A4560}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{A078A4EB-27E8-42B1-BD44-3807732A4560}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{A078A4EB-27E8-42B1-BD44-3807732A4560}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{A078A4EB-27E8-42B1-BD44-3807732A4560}.Release|Any CPU.Build.0 = Release|Any CPU
+		{2E6DAC1B-9054-40AF-AF72-4C2DD7BD9294}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{2E6DAC1B-9054-40AF-AF72-4C2DD7BD9294}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{2E6DAC1B-9054-40AF-AF72-4C2DD7BD9294}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{2E6DAC1B-9054-40AF-AF72-4C2DD7BD9294}.Release|Any CPU.Build.0 = Release|Any CPU
+		{0E49FF32-6CC1-42B0-AF30-25098C7DA18F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{0E49FF32-6CC1-42B0-AF30-25098C7DA18F}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{0E49FF32-6CC1-42B0-AF30-25098C7DA18F}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{0E49FF32-6CC1-42B0-AF30-25098C7DA18F}.Release|Any CPU.Build.0 = Release|Any CPU
+		{696A5E1C-B7B4-4EA0-AE2A-3FDA1C50F4D9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{696A5E1C-B7B4-4EA0-AE2A-3FDA1C50F4D9}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{696A5E1C-B7B4-4EA0-AE2A-3FDA1C50F4D9}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{696A5E1C-B7B4-4EA0-AE2A-3FDA1C50F4D9}.Release|Any CPU.Build.0 = Release|Any CPU
+		{E5280823-9A9A-4314-B0C3-B983A7D50C85}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{E5280823-9A9A-4314-B0C3-B983A7D50C85}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{E5280823-9A9A-4314-B0C3-B983A7D50C85}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{E5280823-9A9A-4314-B0C3-B983A7D50C85}.Release|Any CPU.Build.0 = Release|Any CPU
+		{A7AD2290-A979-4139-9C71-BBCD5594180D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{A7AD2290-A979-4139-9C71-BBCD5594180D}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{A7AD2290-A979-4139-9C71-BBCD5594180D}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{A7AD2290-A979-4139-9C71-BBCD5594180D}.Release|Any CPU.Build.0 = Release|Any CPU
+		{3A873063-B154-4186-914D-1F4F3236101E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{3A873063-B154-4186-914D-1F4F3236101E}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{3A873063-B154-4186-914D-1F4F3236101E}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{3A873063-B154-4186-914D-1F4F3236101E}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(NestedProjects) = preSolution
+		{F94DE827-A426-45CB-AE6E-4E1C154B5386} = {3A73868D-BC2F-483A-B51B-0F3C862BBE85}
+		{38CB62AF-FD52-433E-AB63-CB07BA1D2CD8} = {3F027944-9702-4DA5-A7E2-042D5037ABD3}
+		{B51B75BA-A1AF-42FB-9845-E9AAC42CFB22} = {BC246661-9887-4096-BF1A-AC25060547B2}
+		{1548AC5C-27FD-4B46-A930-C168D622FAB0} = {3F027944-9702-4DA5-A7E2-042D5037ABD3}
+		{A078A4EB-27E8-42B1-BD44-3807732A4560} = {BC246661-9887-4096-BF1A-AC25060547B2}
+		{2E6DAC1B-9054-40AF-AF72-4C2DD7BD9294} = {3A73868D-BC2F-483A-B51B-0F3C862BBE85}
+		{0E49FF32-6CC1-42B0-AF30-25098C7DA18F} = {BC246661-9887-4096-BF1A-AC25060547B2}
+		{696A5E1C-B7B4-4EA0-AE2A-3FDA1C50F4D9} = {3F027944-9702-4DA5-A7E2-042D5037ABD3}
+		{E5280823-9A9A-4314-B0C3-B983A7D50C85} = {BC246661-9887-4096-BF1A-AC25060547B2}
+		{A7AD2290-A979-4139-9C71-BBCD5594180D} = {3F027944-9702-4DA5-A7E2-042D5037ABD3}
+		{3A873063-B154-4186-914D-1F4F3236101E} = {3F027944-9702-4DA5-A7E2-042D5037ABD3}
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {4DF081FC-DC0D-4317-AB2C-4294B9FE6257}
+	EndGlobalSection
+EndGlobal
diff --git a/src/libraries/System.IO.Hashing/ref/System.IO.Hashing.cs b/src/libraries/System.IO.Hashing/ref/System.IO.Hashing.cs
new file mode 100644
index 00000000000000..2e103aeac0339f
--- /dev/null
+++ b/src/libraries/System.IO.Hashing/ref/System.IO.Hashing.cs
@@ -0,0 +1,78 @@
+// 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.IO.Hashing
+{
+    public sealed partial class Crc32 : System.IO.Hashing.NonCryptographicHashAlgorithm
+    {
+        public Crc32() : base (default(int)) { }
+        public override void Append(System.ReadOnlySpan<byte> source) { }
+        protected override void GetCurrentHashCore(System.Span<byte> destination) { }
+        protected override void GetHashAndResetCore(System.Span<byte> destination) { }
+        public static byte[] Hash(byte[] source) { throw null; }
+        public static byte[] Hash(System.ReadOnlySpan<byte> source) { throw null; }
+        public static int Hash(System.ReadOnlySpan<byte> source, System.Span<byte> destination) { throw null; }
+        public override void Reset() { }
+        public static bool TryHash(System.ReadOnlySpan<byte> source, System.Span<byte> destination, out int bytesWritten) { throw null; }
+    }
+    public sealed partial class Crc64 : System.IO.Hashing.NonCryptographicHashAlgorithm
+    {
+        public Crc64() : base (default(int)) { }
+        public override void Append(System.ReadOnlySpan<byte> source) { }
+        protected override void GetCurrentHashCore(System.Span<byte> destination) { }
+        protected override void GetHashAndResetCore(System.Span<byte> destination) { }
+        public static byte[] Hash(byte[] source) { throw null; }
+        public static byte[] Hash(System.ReadOnlySpan<byte> source) { throw null; }
+        public static int Hash(System.ReadOnlySpan<byte> source, System.Span<byte> destination) { throw null; }
+        public override void Reset() { }
+        public static bool TryHash(System.ReadOnlySpan<byte> source, System.Span<byte> destination, out int bytesWritten) { throw null; }
+    }
+    public abstract partial class NonCryptographicHashAlgorithm
+    {
+        protected NonCryptographicHashAlgorithm(int hashLengthInBytes) { }
+        public int HashLengthInBytes { get { throw null; } }
+        public void Append(byte[] source) { }
+        public void Append(System.IO.Stream stream) { }
+        public abstract void Append(System.ReadOnlySpan<byte> source);
+        public System.Threading.Tasks.Task AppendAsync(System.IO.Stream stream, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
+        public byte[] GetCurrentHash() { throw null; }
+        public int GetCurrentHash(System.Span<byte> destination) { throw null; }
+        protected abstract void GetCurrentHashCore(System.Span<byte> destination);
+        public byte[] GetHashAndReset() { throw null; }
+        public int GetHashAndReset(System.Span<byte> destination) { throw null; }
+        protected virtual void GetHashAndResetCore(System.Span<byte> destination) { }
+        public override int GetHashCode() { throw null; }
+        public abstract void Reset();
+        public bool TryGetCurrentHash(System.Span<byte> destination, out int bytesWritten) { throw null; }
+        public bool TryGetHashAndReset(System.Span<byte> destination, out int bytesWritten) { throw null; }
+    }
+    public sealed partial class XxHash32 : System.IO.Hashing.NonCryptographicHashAlgorithm
+    {
+        public XxHash32() : base (default(int)) { }
+        public XxHash32(int seed) : base (default(int)) { }
+        public override void Append(System.ReadOnlySpan<byte> source) { }
+        protected override void GetCurrentHashCore(System.Span<byte> destination) { }
+        public static byte[] Hash(byte[] source) { throw null; }
+        public static byte[] Hash(byte[] source, int seed) { throw null; }
+        public static byte[] Hash(System.ReadOnlySpan<byte> source, int seed = 0) { throw null; }
+        public static int Hash(System.ReadOnlySpan<byte> source, System.Span<byte> destination, int seed = 0) { throw null; }
+        public override void Reset() { }
+        public static bool TryHash(System.ReadOnlySpan<byte> source, System.Span<byte> destination, out int bytesWritten, int seed = 0) { throw null; }
+    }
+    public sealed partial class XxHash64 : System.IO.Hashing.NonCryptographicHashAlgorithm
+    {
+        public XxHash64() : base (default(int)) { }
+        public XxHash64(long seed) : base (default(int)) { }
+        public override void Append(System.ReadOnlySpan<byte> source) { }
+        protected override void GetCurrentHashCore(System.Span<byte> destination) { }
+        public static byte[] Hash(byte[] source) { throw null; }
+        public static byte[] Hash(byte[] source, long seed) { throw null; }
+        public static byte[] Hash(System.ReadOnlySpan<byte> source, long seed = (long)0) { throw null; }
+        public static int Hash(System.ReadOnlySpan<byte> source, System.Span<byte> destination, long seed = (long)0) { throw null; }
+        public override void Reset() { }
+        public static bool TryHash(System.ReadOnlySpan<byte> source, System.Span<byte> destination, out int bytesWritten, long seed = (long)0) { throw null; }
+    }
+}
diff --git a/src/libraries/System.IO.Hashing/src/Resources/Strings.resx b/src/libraries/System.IO.Hashing/src/Resources/Strings.resx
new file mode 100644
index 00000000000000..a8101c05698318
--- /dev/null
+++ b/src/libraries/System.IO.Hashing/src/Resources/Strings.resx
@@ -0,0 +1,126 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    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
+            : and then encoded with base64 encoding.
+    -->
+  <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">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <data name="Argument_DestinationTooShort" xml:space="preserve">
+    <value>Destination is too short.</value>
+  </data>
+  <data name="NotSupported_GetHashCode" xml:space="preserve">
+    <value>The GetHashCode method is not supported on this object. Use GetCurrentHash or GetHashAndReset to retrieve the hash code computed by this object.</value>
+  </data>
+</root>
\ No newline at end of file
diff --git a/src/libraries/System.IO.Hashing/src/System.IO.Hashing.csproj b/src/libraries/System.IO.Hashing/src/System.IO.Hashing.csproj
new file mode 100644
index 00000000000000..3ef2ef309ec117
--- /dev/null
+++ b/src/libraries/System.IO.Hashing/src/System.IO.Hashing.csproj
@@ -0,0 +1,36 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <Nullable>enable</Nullable>
+    <TargetFrameworks>$(NetCoreAppCurrent);netstandard2.0;net461</TargetFrameworks>
+    <IsPackable>true</IsPackable>
+    <!-- TODO: Remove when the package ships with .NET 6. -->
+    <EnablePackageBaselineValidation>false</EnablePackageBaselineValidation>
+    <PackageDescription>Provides non-cryptographic hash algorithms, such as CRC-32.
+
+Commonly Used Types:
+System.IO.Hashing.Crc32
+System.IO.Hashing.XxHash32</PackageDescription>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="System\IO\Hashing\Crc32.cs" />
+    <Compile Include="System\IO\Hashing\Crc32.Table.cs" />
+    <Compile Include="System\IO\Hashing\Crc64.cs" />
+    <Compile Include="System\IO\Hashing\Crc64.Table.cs" />
+    <Compile Include="System\IO\Hashing\XxHash32.cs" />
+    <Compile Include="System\IO\Hashing\XxHash32.State.cs" />
+    <Compile Include="System\IO\Hashing\XxHash64.cs" />
+    <Compile Include="System\IO\Hashing\XxHash64.State.cs" />
+    <Compile Include="System\IO\Hashing\NonCryptographicHashAlgorithm.cs" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp'">
+    <Reference Include="System.Buffers" />
+    <Reference Include="System.Memory" />
+    <Reference Include="System.Runtime" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(TargetFrameworkIdentifier)' != '.NETCoreApp'">
+    <Compile Include="System\IO\Hashing\BitOperations.cs" />
+    <PackageReference Include="System.Buffers" Version="$(SystemBuffersVersion)" />
+    <PackageReference Include="System.Memory" Version="$(SystemMemoryVersion)" />
+  </ItemGroup>
+</Project>
diff --git a/src/libraries/System.IO.Hashing/src/System/IO/Hashing/BitOperations.cs b/src/libraries/System.IO.Hashing/src/System/IO/Hashing/BitOperations.cs
new file mode 100644
index 00000000000000..01abfbb65be600
--- /dev/null
+++ b/src/libraries/System.IO.Hashing/src/System/IO/Hashing/BitOperations.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.
+
+using System.Runtime.CompilerServices;
+
+namespace System.Numerics
+{
+    internal static class BitOperations
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint RotateLeft(uint value, int offset)
+            => (value << offset) | (value >> (32 - offset));
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static ulong RotateLeft(ulong value, int offset)
+            => (value << offset) | (value >> (64 - offset));
+    }
+}
diff --git a/src/libraries/System.IO.Hashing/src/System/IO/Hashing/Crc32.Table.cs b/src/libraries/System.IO.Hashing/src/System/IO/Hashing/Crc32.Table.cs
new file mode 100644
index 00000000000000..6dc3fd7c518440
--- /dev/null
+++ b/src/libraries/System.IO.Hashing/src/System/IO/Hashing/Crc32.Table.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.
+
+namespace System.IO.Hashing
+{
+    public sealed partial class Crc32 : NonCryptographicHashAlgorithm
+    {
+        // Pre-computed CRC-32 transition table.
+        // While this implementation is based on the standard CRC-32 polynomial,
+        // x32 + x26 + x23 + x22 + x16 + x12 + x11 + x10 + x8 + x7 + x5 + x4 + x2 + x1 + x0,
+        // this version uses reflected bit ordering, so 0x04C11DB7 becomes 0xEDB88320
+        private static readonly uint[] s_crcLookup = GenerateReflectedTable(0xEDB88320u);
+
+        private static uint[] GenerateReflectedTable(uint reflectedPolynomial)
+        {
+            uint[] table = new uint[256];
+
+            for (int i = 0; i < 256; i++)
+            {
+                uint val = (uint)i;
+
+                for (int j = 0; j < 8; j++)
+                {
+                    if ((val & 0b0000_0001) == 0)
+                    {
+                        val >>= 1;
+                    }
+                    else
+                    {
+                        val = (val >> 1) ^ reflectedPolynomial;
+                    }
+                }
+
+                table[i] = val;
+            }
+
+            return table;
+        }
+    }
+}
diff --git a/src/libraries/System.IO.Hashing/src/System/IO/Hashing/Crc32.cs b/src/libraries/System.IO.Hashing/src/System/IO/Hashing/Crc32.cs
new file mode 100644
index 00000000000000..4f904ebaa64b07
--- /dev/null
+++ b/src/libraries/System.IO.Hashing/src/System/IO/Hashing/Crc32.cs
@@ -0,0 +1,168 @@
+// 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.Binary;
+
+namespace System.IO.Hashing
+{
+    /// <summary>
+    ///   Provides an implementation of the CRC-32 algorithm, as used in
+    ///   ITU-T V.42 and IEEE 802.3.
+    /// </summary>
+    /// <remarks>
+    ///   <para>
+    ///     This implementation emits the answer in the Little Endian byte order so that
+    ///     the CRC residue relationship (CRC(message concat CRC(message))) is a fixed value) holds.
+    ///     For CRC-32 this stable output is the byte sequence <c>{ 0x1C, 0xDF, 0x44, 0x21 }</c>,
+    ///     the Little Endian representation of <c>0x2144DF1C</c>.
+    ///   </para>
+    ///   <para>
+    ///     There are multiple, incompatible, definitions of a 32-bit cyclic redundancy
+    ///     check (CRC) algorithm. When interoperating with another system, ensure that you
+    ///     are using the same definition. The definition used by this implementation is not
+    ///     compatible with the cyclic redundancy check described in ITU-T I.363.5.
+    ///   </para>
+    /// </remarks>
+    public sealed partial class Crc32 : NonCryptographicHashAlgorithm
+    {
+        private const uint InitialState = 0xFFFF_FFFFu;
+        private const int Size = sizeof(uint);
+
+        private uint _crc = InitialState;
+
+        /// <summary>
+        ///   Initializes a new instance of the <see cref="Crc32"/> class.
+        /// </summary>
+        public Crc32()
+            : base(Size)
+        {
+        }
+
+        /// <summary>
+        ///   Appends the contents of <paramref name="source"/> to the data already
+        ///   processed for the current hash computation.
+        /// </summary>
+        /// <param name="source">The data to process.</param>
+        public override void Append(ReadOnlySpan<byte> source)
+        {
+            _crc = Update(_crc, source);
+        }
+
+        /// <summary>
+        ///   Resets the hash computation to the initial state.
+        /// </summary>
+        public override void Reset()
+        {
+            _crc = InitialState;
+        }
+
+        /// <summary>
+        ///   Writes the computed hash value to <paramref name="destination"/>
+        ///   without modifying accumulated state.
+        /// </summary>
+        /// <param name="destination">The buffer that receives the computed hash value.</param>
+        protected override void GetCurrentHashCore(Span<byte> destination)
+        {
+            // The finalization step of the CRC is to perform the ones' complement.
+            BinaryPrimitives.WriteUInt32LittleEndian(destination, ~_crc);
+        }
+
+        /// <summary>
+        ///   Writes the computed hash value to <paramref name="destination"/>
+        ///   then clears the accumulated state.
+        /// </summary>
+        protected override void GetHashAndResetCore(Span<byte> destination)
+        {
+            BinaryPrimitives.WriteUInt32LittleEndian(destination, ~_crc);
+            _crc = InitialState;
+        }
+
+        /// <summary>
+        ///   Computes the CRC-32 hash of the provided data.
+        /// </summary>
+        /// <param name="source">The data to hash.</param>
+        /// <returns>The CRC-32 hash of the provided data.</returns>
+        /// <exception cref="ArgumentNullException">
+        ///   <paramref name="source"/> is <see langword="null"/>.
+        /// </exception>
+        public static byte[] Hash(byte[] source)
+        {
+            if (source is null)
+                throw new ArgumentNullException(nameof(source));
+
+            return Hash(new ReadOnlySpan<byte>(source));
+        }
+
+        /// <summary>
+        ///   Computes the CRC-32 hash of the provided data.
+        /// </summary>
+        /// <param name="source">The data to hash.</param>
+        /// <returns>The CRC-32 hash of the provided data.</returns>
+        public static byte[] Hash(ReadOnlySpan<byte> source)
+        {
+            byte[] ret = new byte[Size];
+            StaticHash(source, ret);
+            return ret;
+        }
+
+        /// <summary>
+        ///   Attempts to compute the CRC-32 hash of the provided data into the provided destination.
+        /// </summary>
+        /// <param name="source">The data to hash.</param>
+        /// <param name="destination">The buffer that receives the computed hash value.</param>
+        /// <param name="bytesWritten">
+        ///   On success, receives the number of bytes written to <paramref name="destination"/>.
+        /// </param>
+        /// <returns>
+        ///   <see langword="true"/> if <paramref name="destination"/> is long enough to receive
+        ///   the computed hash value (4 bytes); otherwise, <see langword="false"/>.
+        /// </returns>
+        public static bool TryHash(ReadOnlySpan<byte> source, Span<byte> destination, out int bytesWritten)
+        {
+            if (destination.Length < Size)
+            {
+                bytesWritten = 0;
+                return false;
+            }
+
+            bytesWritten = StaticHash(source, destination);
+            return true;
+        }
+
+        /// <summary>
+        ///   Computes the CRC-32 hash of the provided data into the provided destination.
+        /// </summary>
+        /// <param name="source">The data to hash.</param>
+        /// <param name="destination">The buffer that receives the computed hash value.</param>
+        /// <returns>
+        ///   The number of bytes written to <paramref name="destination"/>.
+        /// </returns>
+        public static int Hash(ReadOnlySpan<byte> source, Span<byte> destination)
+        {
+            if (destination.Length < Size)
+                throw new ArgumentException(SR.Argument_DestinationTooShort, nameof(destination));
+
+            return StaticHash(source, destination);
+        }
+
+        private static int StaticHash(ReadOnlySpan<byte> source, Span<byte> destination)
+        {
+            uint crc = InitialState;
+            crc = Update(crc, source);
+            BinaryPrimitives.WriteUInt32LittleEndian(destination, ~crc);
+            return Size;
+        }
+
+        private static uint Update(uint crc, ReadOnlySpan<byte> source)
+        {
+            for (int i = 0; i < source.Length; i++)
+            {
+                byte idx = (byte)crc;
+                idx ^= source[i];
+                crc = s_crcLookup[idx] ^ (crc >> 8);
+            }
+
+            return crc;
+        }
+    }
+}
diff --git a/src/libraries/System.IO.Hashing/src/System/IO/Hashing/Crc64.Table.cs b/src/libraries/System.IO.Hashing/src/System/IO/Hashing/Crc64.Table.cs
new file mode 100644
index 00000000000000..886589e61a36c1
--- /dev/null
+++ b/src/libraries/System.IO.Hashing/src/System/IO/Hashing/Crc64.Table.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.
+
+namespace System.IO.Hashing
+{
+    public sealed partial class Crc64 : NonCryptographicHashAlgorithm
+    {
+        // Pre-computed CRC-64 transition table.
+        private static readonly ulong[] s_crcLookup = GenerateTable(0x42F0E1EBA9EA3693);
+
+        private static ulong[] GenerateTable(ulong polynomial)
+        {
+            ulong[] table = new ulong[256];
+
+            for (int i = 0; i < 256; i++)
+            {
+                ulong val = (ulong)i << 56;
+
+                for (int j = 0; j < 8; j++)
+                {
+                    if ((val & 0x8000_0000_0000_0000) == 0)
+                    {
+                        val <<= 1;
+                    }
+                    else
+                    {
+                        val = (val << 1) ^ polynomial;
+                    }
+                }
+
+                table[i] = val;
+            }
+
+            return table;
+        }
+    }
+}
diff --git a/src/libraries/System.IO.Hashing/src/System/IO/Hashing/Crc64.cs b/src/libraries/System.IO.Hashing/src/System/IO/Hashing/Crc64.cs
new file mode 100644
index 00000000000000..ca418218259790
--- /dev/null
+++ b/src/libraries/System.IO.Hashing/src/System/IO/Hashing/Crc64.cs
@@ -0,0 +1,166 @@
+// 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.Binary;
+
+namespace System.IO.Hashing
+{
+    /// <summary>
+    ///   Provides an implementation of the CRC-64 algorithm as described in ECMA-182, Annex B.
+    /// </summary>
+    /// <remarks>
+    ///   <para>
+    ///     This implementation emits the answer in the Big Endian byte order so that
+    ///     the CRC residue relationship (CRC(message concat CRC(message))) is a fixed value) holds.
+    ///     For CRC-64 this stable output is the byte sequence
+    ///     <c>{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }</c>.
+    ///   </para>
+    ///   <para>
+    ///     There are multiple, incompatible, definitions of a 64-bit cyclic redundancy
+    ///     check (CRC) algorithm. When interoperating with another system, ensure that you
+    ///     are using the same definition. The definition used by this implementation is not
+    ///     compatible with the cyclic redundancy check described in ISO 3309.
+    ///   </para>
+    /// </remarks>
+    public sealed partial class Crc64 : NonCryptographicHashAlgorithm
+    {
+        private const ulong InitialState = 0UL;
+        private const int Size = sizeof(ulong);
+
+        private ulong _crc = InitialState;
+
+        /// <summary>
+        ///   Initializes a new instance of the <see cref="Crc64"/> class.
+        /// </summary>
+        public Crc64()
+            : base(Size)
+        {
+        }
+
+        /// <summary>
+        ///   Appends the contents of <paramref name="source"/> to the data already
+        ///   processed for the current hash computation.
+        /// </summary>
+        /// <param name="source">The data to process.</param>
+        public override void Append(ReadOnlySpan<byte> source)
+        {
+            _crc = Update(_crc, source);
+        }
+
+        /// <summary>
+        ///   Resets the hash computation to the initial state.
+        /// </summary>
+        public override void Reset()
+        {
+            _crc = InitialState;
+        }
+
+        /// <summary>
+        ///   Writes the computed hash value to <paramref name="destination"/>
+        ///   without modifying accumulated state.
+        /// </summary>
+        /// <param name="destination">The buffer that receives the computed hash value.</param>
+        protected override void GetCurrentHashCore(Span<byte> destination)
+        {
+            BinaryPrimitives.WriteUInt64BigEndian(destination, _crc);
+        }
+
+        /// <summary>
+        ///   Writes the computed hash value to <paramref name="destination"/>
+        ///   then clears the accumulated state.
+        /// </summary>
+        protected override void GetHashAndResetCore(Span<byte> destination)
+        {
+            BinaryPrimitives.WriteUInt64BigEndian(destination, _crc);
+            _crc = InitialState;
+        }
+
+        /// <summary>
+        ///   Computes the CRC-64 hash of the provided data.
+        /// </summary>
+        /// <param name="source">The data to hash.</param>
+        /// <returns>The CRC-64 hash of the provided data.</returns>
+        /// <exception cref="ArgumentNullException">
+        ///   <paramref name="source"/> is <see langword="null"/>.
+        /// </exception>
+        public static byte[] Hash(byte[] source)
+        {
+            if (source is null)
+                throw new ArgumentNullException(nameof(source));
+
+            return Hash(new ReadOnlySpan<byte>(source));
+        }
+
+        /// <summary>
+        ///   Computes the CRC-64 hash of the provided data.
+        /// </summary>
+        /// <param name="source">The data to hash.</param>
+        /// <returns>The CRC-64 hash of the provided data.</returns>
+        public static byte[] Hash(ReadOnlySpan<byte> source)
+        {
+            byte[] ret = new byte[Size];
+            StaticHash(source, ret);
+            return ret;
+        }
+
+        /// <summary>
+        ///   Attempts to compute the CRC-64 hash of the provided data into the provided destination.
+        /// </summary>
+        /// <param name="source">The data to hash.</param>
+        /// <param name="destination">The buffer that receives the computed hash value.</param>
+        /// <param name="bytesWritten">
+        ///   On success, receives the number of bytes written to <paramref name="destination"/>.
+        /// </param>
+        /// <returns>
+        ///   <see langword="true"/> if <paramref name="destination"/> is long enough to receive
+        ///   the computed hash value (8 bytes); otherwise, <see langword="false"/>.
+        /// </returns>
+        public static bool TryHash(ReadOnlySpan<byte> source, Span<byte> destination, out int bytesWritten)
+        {
+            if (destination.Length < Size)
+            {
+                bytesWritten = 0;
+                return false;
+            }
+
+            bytesWritten = StaticHash(source, destination);
+            return true;
+        }
+
+        /// <summary>
+        ///   Computes the CRC-64 hash of the provided data into the provided destination.
+        /// </summary>
+        /// <param name="source">The data to hash.</param>
+        /// <param name="destination">The buffer that receives the computed hash value.</param>
+        /// <returns>
+        ///   The number of bytes written to <paramref name="destination"/>.
+        /// </returns>
+        public static int Hash(ReadOnlySpan<byte> source, Span<byte> destination)
+        {
+            if (destination.Length < Size)
+                throw new ArgumentException(SR.Argument_DestinationTooShort, nameof(destination));
+
+            return StaticHash(source, destination);
+        }
+
+        private static int StaticHash(ReadOnlySpan<byte> source, Span<byte> destination)
+        {
+            ulong crc = InitialState;
+            crc = Update(crc, source);
+            BinaryPrimitives.WriteUInt64BigEndian(destination, crc);
+            return Size;
+        }
+
+        private static ulong Update(ulong crc, ReadOnlySpan<byte> source)
+        {
+            for (int i = 0; i < source.Length; i++)
+            {
+                ulong idx = (crc >> 56);
+                idx ^= source[i];
+                crc = s_crcLookup[idx] ^ (crc << 8);
+            }
+
+            return crc;
+        }
+    }
+}
diff --git a/src/libraries/System.IO.Hashing/src/System/IO/Hashing/NonCryptographicHashAlgorithm.cs b/src/libraries/System.IO.Hashing/src/System/IO/Hashing/NonCryptographicHashAlgorithm.cs
new file mode 100644
index 00000000000000..75e76c313bf8cd
--- /dev/null
+++ b/src/libraries/System.IO.Hashing/src/System/IO/Hashing/NonCryptographicHashAlgorithm.cs
@@ -0,0 +1,330 @@
+// 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.ComponentModel;
+using System.Diagnostics;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace System.IO.Hashing
+{
+    /// <summary>
+    ///   Represents a non-cryptographic hash algorithm.
+    /// </summary>
+    public abstract class NonCryptographicHashAlgorithm
+    {
+        /// <summary>
+        ///   Gets the number of bytes produced from this hash algorithm.
+        /// </summary>
+        /// <value>The number of bytes produced from this hash algorithm.</value>
+        public int HashLengthInBytes { get; }
+
+        /// <summary>
+        ///   Called from constructors in derived classes to initialize the
+        ///   <see cref="NonCryptographicHashAlgorithm"/> class.
+        /// </summary>
+        /// <param name="hashLengthInBytes">
+        ///   The number of bytes produced from this hash algorithm.
+        /// </param>
+        /// <exception cref="ArgumentOutOfRangeException">
+        ///   <paramref name="hashLengthInBytes"/> is less than 1.
+        /// </exception>
+        protected NonCryptographicHashAlgorithm(int hashLengthInBytes)
+        {
+            if (hashLengthInBytes < 1)
+                throw new ArgumentOutOfRangeException(nameof(hashLengthInBytes));
+
+            HashLengthInBytes = hashLengthInBytes;
+        }
+
+        /// <summary>
+        ///   When overridden in a derived class,
+        ///   appends the contents of <paramref name="source"/> to the data already
+        ///   processed for the current hash computation.
+        /// </summary>
+        /// <param name="source">The data to process.</param>
+        public abstract void Append(ReadOnlySpan<byte> source);
+
+        /// <summary>
+        ///   When overridden in a derived class,
+        ///   resets the hash computation to the initial state.
+        /// </summary>
+        public abstract void Reset();
+
+        /// <summary>
+        ///   When overridden in a derived class,
+        ///   writes the computed hash value to <paramref name="destination"/>
+        ///   without modifying accumulated state.
+        /// </summary>
+        /// <param name="destination">The buffer that receives the computed hash value.</param>
+        /// <remarks>
+        ///   <para>
+        ///     Implementations of this method must write exactly
+        ///     <see cref="HashLengthInBytes"/> bytes to <paramref name="destination"/>.
+        ///     Do not assume that the buffer was zero-initialized.
+        ///   </para>
+        ///   <para>
+        ///     The <see cref="NonCryptographicHashAlgorithm"/> class validates the
+        ///     size of the buffer before calling this method, and slices the span
+        ///     down to be exactly <see cref="HashLengthInBytes"/> in length.
+        ///   </para>
+        /// </remarks>
+        protected abstract void GetCurrentHashCore(Span<byte> destination);
+
+        /// <summary>
+        ///   Appends the contents of <paramref name="source"/> to the data already
+        ///   processed for the current hash computation.
+        /// </summary>
+        /// <param name="source">The data to process.</param>
+        /// <exception cref="ArgumentNullException">
+        ///   <paramref name="source"/> is <see langword="null"/>.
+        /// </exception>
+        public void Append(byte[] source)
+        {
+            if (source is null)
+                throw new ArgumentNullException(nameof(source));
+
+            Append(new ReadOnlySpan<byte>(source));
+        }
+
+        /// <summary>
+        ///   Appends the contents of <paramref name="stream"/> to the data already
+        ///   processed for the current hash computation.
+        /// </summary>
+        /// <param name="stream">The data to process.</param>
+        /// <exception cref="ArgumentNullException">
+        ///   <paramref name="stream"/> is <see langword="null"/>.
+        /// </exception>
+        /// <seealso cref="AppendAsync(Stream, CancellationToken)"/>
+        public void Append(Stream stream)
+        {
+            if (stream is null)
+                throw new ArgumentNullException(nameof(stream));
+
+            byte[] buffer = ArrayPool<byte>.Shared.Rent(4096);
+
+            while (true)
+            {
+                int read = stream.Read(buffer, 0, buffer.Length);
+
+                if (read == 0)
+                {
+                    break;
+                }
+
+                Append(new ReadOnlySpan<byte>(buffer, 0, read));
+            }
+
+            ArrayPool<byte>.Shared.Return(buffer);
+        }
+
+        /// <summary>
+        ///   Asychronously reads the contents of <paramref name="stream"/>
+        ///   and appends them to the data already
+        ///   processed for the current hash computation.
+        /// </summary>
+        /// <param name="stream">The data to process.</param>
+        /// <param name="cancellationToken">
+        ///   The token to monitor for cancellation requests.
+        ///   The default value is <see cref="CancellationToken.None"/>.
+        /// </param>
+        /// <exception cref="ArgumentNullException">
+        ///   <paramref name="stream"/> is <see langword="null"/>.
+        /// </exception>
+        public Task AppendAsync(Stream stream, CancellationToken cancellationToken = default)
+        {
+            if (stream is null)
+                throw new ArgumentNullException(nameof(stream));
+
+            return AppendAsyncCore(stream, cancellationToken);
+        }
+
+        private async Task AppendAsyncCore(Stream stream, CancellationToken cancellationToken)
+        {
+            byte[] buffer = ArrayPool<byte>.Shared.Rent(4096);
+
+            while (true)
+            {
+#if NET5_0_OR_GREATER
+                int read = await stream.ReadAsync(buffer.AsMemory(), cancellationToken).ConfigureAwait(false);
+#else
+                int read = await stream.ReadAsync(buffer, 0, buffer.Length, cancellationToken).ConfigureAwait(false);
+#endif
+
+                if (read == 0)
+                {
+                    break;
+                }
+
+                Append(new ReadOnlySpan<byte>(buffer, 0, read));
+            }
+
+            ArrayPool<byte>.Shared.Return(buffer);
+        }
+
+        /// <summary>
+        ///   Gets the current computed hash value without modifying accumulated state.
+        /// </summary>
+        public byte[] GetCurrentHash()
+        {
+            byte[] ret = new byte[HashLengthInBytes];
+            GetCurrentHashCore(ret);
+            return ret;
+        }
+
+        /// <summary>
+        ///   Attempts to write the computed hash value to <paramref name="destination"/>
+        ///   without modifying accumulated state.
+        /// </summary>
+        /// <param name="destination">The buffer that receives the computed hash value.</param>
+        /// <param name="bytesWritten">
+        ///   On success, receives the number of bytes written to <paramref name="destination"/>.
+        /// </param>
+        /// <returns>
+        ///   <see langword="true"/> if <paramref name="destination"/> is long enough to receive
+        ///   the computed hash value; otherwise, <see langword="false"/>.
+        /// </returns>
+        public bool TryGetCurrentHash(Span<byte> destination, out int bytesWritten)
+        {
+            if (destination.Length < HashLengthInBytes)
+            {
+                bytesWritten = 0;
+                return false;
+            }
+
+            GetCurrentHashCore(destination.Slice(0, HashLengthInBytes));
+            bytesWritten = HashLengthInBytes;
+            return true;
+        }
+
+        /// <summary>
+        ///   Writes the computed hash value to <paramref name="destination"/>
+        ///   without modifying accumulated state.
+        /// </summary>
+        /// <param name="destination">The buffer that receives the computed hash value.</param>
+        /// <returns>
+        ///   The number of bytes written to <paramref name="destination"/>,
+        ///   which is always <see cref="HashLengthInBytes"/>.
+        /// </returns>
+        /// <exception cref="ArgumentException">
+        ///   <paramref name="destination"/> is shorter than <see cref="HashLengthInBytes"/>.
+        /// </exception>
+        public int GetCurrentHash(Span<byte> destination)
+        {
+            if (destination.Length < HashLengthInBytes)
+            {
+                throw new ArgumentException(SR.Argument_DestinationTooShort, nameof(destination));
+            }
+
+            GetCurrentHashCore(destination.Slice(0, HashLengthInBytes));
+            return HashLengthInBytes;
+        }
+
+        /// <summary>
+        ///   Gets the current computed hash value and clears the accumulated state.
+        /// </summary>
+        public byte[] GetHashAndReset()
+        {
+            byte[] ret = new byte[HashLengthInBytes];
+            GetHashAndResetCore(ret);
+            return ret;
+        }
+
+        /// <summary>
+        ///   Attempts to write the computed hash value to <paramref name="destination"/>.
+        ///   If successful, clears the accumulated state.
+        /// </summary>
+        /// <param name="destination">The buffer that receives the computed hash value.</param>
+        /// <param name="bytesWritten">
+        ///   On success, receives the number of bytes written to <paramref name="destination"/>.
+        /// </param>
+        /// <returns>
+        ///   <see langword="true"/> and clears the accumulated state
+        ///   if <paramref name="destination"/> is long enough to receive
+        ///   the computed hash value; otherwise, <see langword="false"/>.
+        /// </returns>
+        public bool TryGetHashAndReset(Span<byte> destination, out int bytesWritten)
+        {
+            if (destination.Length < HashLengthInBytes)
+            {
+                bytesWritten = 0;
+                return false;
+            }
+
+            GetHashAndResetCore(destination.Slice(0, HashLengthInBytes));
+            bytesWritten = HashLengthInBytes;
+            return true;
+        }
+
+        /// <summary>
+        ///   Writes the computed hash value to <paramref name="destination"/>
+        ///   then clears the accumulated state.
+        /// </summary>
+        /// <param name="destination">The buffer that receives the computed hash value.</param>
+        /// <returns>
+        ///   The number of bytes written to <paramref name="destination"/>,
+        ///   which is always <see cref="HashLengthInBytes"/>.
+        /// </returns>
+        /// <exception cref="ArgumentException">
+        ///   <paramref name="destination"/> is shorter than <see cref="HashLengthInBytes"/>.
+        /// </exception>
+        public int GetHashAndReset(Span<byte> destination)
+        {
+            if (destination.Length < HashLengthInBytes)
+            {
+                throw new ArgumentException(SR.Argument_DestinationTooShort, nameof(destination));
+            }
+
+            GetHashAndResetCore(destination.Slice(0, HashLengthInBytes));
+            return HashLengthInBytes;
+        }
+
+        /// <summary>
+        ///   Writes the computed hash value to <paramref name="destination"/>
+        ///   then clears the accumulated state.
+        /// </summary>
+        /// <param name="destination">The buffer that receives the computed hash value.</param>
+        /// <remarks>
+        ///   <para>
+        ///     Implementations of this method must write exactly
+        ///     <see cref="HashLengthInBytes"/> bytes to <paramref name="destination"/>.
+        ///     Do not assume that the buffer was zero-initialized.
+        ///   </para>
+        ///   <para>
+        ///     The <see cref="NonCryptographicHashAlgorithm"/> class validates the
+        ///     size of the buffer before calling this method, and slices the span
+        ///     down to be exactly <see cref="HashLengthInBytes"/> in length.
+        ///   </para>
+        ///   <para>
+        ///     The default implementation of this method calls
+        ///     <see cref="GetCurrentHashCore"/> followed by <see cref="Reset"/>.
+        ///     Overrides of this method do not need to call either of those methods,
+        ///     but must ensure that the caller cannot observe a difference in behavior.
+        ///   </para>
+        /// </remarks>
+        protected virtual void GetHashAndResetCore(Span<byte> destination)
+        {
+            Debug.Assert(destination.Length == HashLengthInBytes);
+
+            GetCurrentHashCore(destination);
+            Reset();
+        }
+
+        /// <summary>
+        ///   This method is not supported and should not be called.
+        ///   Call <see cref="GetCurrentHash()"/> or <see cref="GetHashAndReset()"/>
+        ///   instead.
+        /// </summary>
+        /// <returns>This method will always throw a <see cref="NotSupportedException"/>.</returns>
+        /// <exception cref="NotSupportedException">In all cases.</exception>
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        [Obsolete("Use GetCurrentHash() to retrieve the computed hash code.", true)]
+#pragma warning disable CS0809 // Obsolete member overrides non-obsolete member
+        public override int GetHashCode()
+#pragma warning restore CS0809 // Obsolete member overrides non-obsolete member
+        {
+            throw new NotSupportedException(SR.NotSupported_GetHashCode);
+        }
+    }
+}
diff --git a/src/libraries/System.IO.Hashing/src/System/IO/Hashing/XxHash32.State.cs b/src/libraries/System.IO.Hashing/src/System/IO/Hashing/XxHash32.State.cs
new file mode 100644
index 00000000000000..5a75c35ef01455
--- /dev/null
+++ b/src/libraries/System.IO.Hashing/src/System/IO/Hashing/XxHash32.State.cs
@@ -0,0 +1,108 @@
+// 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.Binary;
+using System.Diagnostics;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+
+// Implemented from the specification at
+// https://github.com/Cyan4973/xxHash/blob/f9155bd4c57e2270a4ffbb176485e5d713de1c9b/doc/xxhash_spec.md
+
+namespace System.IO.Hashing
+{
+    public sealed partial class XxHash32
+    {
+        private struct State
+        {
+            private const uint Prime32_1 = 0x9E3779B1;
+            private const uint Prime32_2 = 0x85EBCA77;
+            private const uint Prime32_3 = 0xC2B2AE3D;
+            private const uint Prime32_4 = 0x27D4EB2F;
+            private const uint Prime32_5 = 0x165667B1;
+
+            private uint _acc1;
+            private uint _acc2;
+            private uint _acc3;
+            private uint _acc4;
+            private readonly uint _smallAcc;
+            private bool _hadFullStripe;
+
+            internal State(uint seed)
+            {
+                _acc1 = seed + unchecked(Prime32_1 + Prime32_2);
+                _acc2 = seed + Prime32_2;
+                _acc3 = seed;
+                _acc4 = seed - Prime32_1;
+
+                _smallAcc = seed + Prime32_5;
+                _hadFullStripe = false;
+            }
+
+            internal void ProcessStripe(ReadOnlySpan<byte> source)
+            {
+                Debug.Assert(source.Length >= StripeSize);
+                source = source.Slice(0, StripeSize);
+
+                _acc1 = ApplyRound(_acc1, source);
+                _acc2 = ApplyRound(_acc2, source.Slice(sizeof(uint)));
+                _acc3 = ApplyRound(_acc3, source.Slice(2 * sizeof(uint)));
+                _acc4 = ApplyRound(_acc4, source.Slice(3 * sizeof(uint)));
+
+                _hadFullStripe = true;
+            }
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            private readonly uint Converge()
+            {
+                return
+                    BitOperations.RotateLeft(_acc1, 1) +
+                    BitOperations.RotateLeft(_acc2, 7) +
+                    BitOperations.RotateLeft(_acc3, 12) +
+                    BitOperations.RotateLeft(_acc4, 18);
+            }
+
+            private static uint ApplyRound(uint acc, ReadOnlySpan<byte> lane)
+            {
+                acc += BinaryPrimitives.ReadUInt32LittleEndian(lane) * Prime32_2;
+                acc = BitOperations.RotateLeft(acc, 13);
+                acc *= Prime32_1;
+
+                return acc;
+            }
+
+            internal readonly uint Complete(int length, ReadOnlySpan<byte> remaining)
+            {
+                uint acc = _hadFullStripe ? Converge() : _smallAcc;
+
+                acc += (uint)length;
+
+                while (remaining.Length >= sizeof(uint))
+                {
+                    uint lane = BinaryPrimitives.ReadUInt32LittleEndian(remaining);
+                    acc += lane * Prime32_3;
+                    acc = BitOperations.RotateLeft(acc, 17);
+                    acc *= Prime32_4;
+
+                    remaining = remaining.Slice(sizeof(uint));
+                }
+
+                for (int i = 0; i < remaining.Length; i++)
+                {
+                    uint lane = remaining[i];
+                    acc += lane * Prime32_5;
+                    acc = BitOperations.RotateLeft(acc, 11);
+                    acc *= Prime32_1;
+                }
+
+                acc ^= (acc >> 15);
+                acc *= Prime32_2;
+                acc ^= (acc >> 13);
+                acc *= Prime32_3;
+                acc ^= (acc >> 16);
+
+                return acc;
+            }
+        }
+    }
+}
diff --git a/src/libraries/System.IO.Hashing/src/System/IO/Hashing/XxHash32.cs b/src/libraries/System.IO.Hashing/src/System/IO/Hashing/XxHash32.cs
new file mode 100644
index 00000000000000..d6db9bae19b2e3
--- /dev/null
+++ b/src/libraries/System.IO.Hashing/src/System/IO/Hashing/XxHash32.cs
@@ -0,0 +1,229 @@
+// 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.Binary;
+
+// Implemented from the specification at
+// https://github.com/Cyan4973/xxHash/blob/f9155bd4c57e2270a4ffbb176485e5d713de1c9b/doc/xxhash_spec.md
+
+namespace System.IO.Hashing
+{
+    /// <summary>
+    ///   Provides an implementation of the XxHash32 algorithm.
+    /// </summary>
+    public sealed partial class XxHash32 : NonCryptographicHashAlgorithm
+    {
+        private const int HashSize = sizeof(uint);
+        private const int StripeSize = 4 * sizeof(uint);
+
+        private readonly uint _seed;
+        private State _state;
+        private byte[]? _holdback;
+        private int _length;
+
+        /// <summary>
+        ///   Initializes a new instance of the <see cref="XxHash32"/> class.
+        /// </summary>
+        /// <remarks>
+        ///   The XxHash32 algorithm supports an optional seed value.
+        ///   Instances created with this constructor use the default seed, zero.
+        /// </remarks>
+        public XxHash32()
+            : this(0)
+        {
+        }
+
+        /// <summary>
+        ///   Initializes a new instance of the <see cref="XxHash32"/> class with
+        ///   a specified seed.
+        /// </summary>
+        /// <param name="seed">
+        ///   The hash seed value for computations from this instance.
+        /// </param>
+        public XxHash32(int seed)
+            : base(HashSize)
+        {
+            _seed = (uint)seed;
+            Reset();
+        }
+
+        /// <summary>
+        ///   Resets the hash computation to the initial state.
+        /// </summary>
+        public override void Reset()
+        {
+            _state = new State(_seed);
+            _length = 0;
+        }
+
+        /// <summary>
+        ///   Appends the contents of <paramref name="source"/> to the data already
+        ///   processed for the current hash computation.
+        /// </summary>
+        /// <param name="source">The data to process.</param>
+        public override void Append(ReadOnlySpan<byte> source)
+        {
+            // Every time we've read 16 bytes, process the stripe.
+            // Data that isn't perfectly mod-16 gets stored in a holdback
+            // buffer.
+
+            int held = _length & 0x0F;
+
+            if (held != 0)
+            {
+                int remain = StripeSize - held;
+
+                if (source.Length > remain)
+                {
+                    source.Slice(0, remain).CopyTo(_holdback.AsSpan(held));
+                    _state.ProcessStripe(_holdback);
+
+                    source = source.Slice(remain);
+                    _length += remain;
+                }
+                else
+                {
+                    source.CopyTo(_holdback.AsSpan(held));
+                    _length += source.Length;
+                    return;
+                }
+            }
+
+            while (source.Length >= StripeSize)
+            {
+                _state.ProcessStripe(source);
+                source = source.Slice(StripeSize);
+                _length += StripeSize;
+            }
+
+            if (source.Length > 0)
+            {
+                _holdback ??= new byte[StripeSize];
+                source.CopyTo(_holdback);
+                _length += source.Length;
+            }
+        }
+
+        /// <summary>
+        ///   Writes the computed hash value to <paramref name="destination"/>
+        ///   without modifying accumulated state.
+        /// </summary>
+        protected override void GetCurrentHashCore(Span<byte> destination)
+        {
+            int remainingLength = _length & 0x0F;
+            ReadOnlySpan<byte> remaining = ReadOnlySpan<byte>.Empty;
+
+            if (remainingLength > 0)
+            {
+                remaining = new ReadOnlySpan<byte>(_holdback, 0, remainingLength);
+            }
+
+            uint acc = _state.Complete(_length, remaining);
+            BinaryPrimitives.WriteUInt32BigEndian(destination, acc);
+        }
+
+        /// <summary>
+        ///   Computes the XxHash32 hash of the provided data.
+        /// </summary>
+        /// <param name="source">The data to hash.</param>
+        /// <returns>The XxHash32 hash of the provided data.</returns>
+        /// <exception cref="ArgumentNullException">
+        ///   <paramref name="source"/> is <see langword="null"/>.
+        /// </exception>
+        public static byte[] Hash(byte[] source)
+        {
+            if (source is null)
+                throw new ArgumentNullException(nameof(source));
+
+            return Hash(new ReadOnlySpan<byte>(source));
+        }
+
+        /// <summary>
+        ///   Computes the XxHash32 hash of the provided data using the provided seed.
+        /// </summary>
+        /// <param name="source">The data to hash.</param>
+        /// <param name="seed">The seed value for this hash computation.</param>
+        /// <returns>The XxHash32 hash of the provided data.</returns>
+        /// <exception cref="ArgumentNullException">
+        ///   <paramref name="source"/> is <see langword="null"/>.
+        /// </exception>
+        public static byte[] Hash(byte[] source, int seed)
+        {
+            if (source is null)
+                throw new ArgumentNullException(nameof(source));
+
+            return Hash(new ReadOnlySpan<byte>(source), seed);
+        }
+
+        /// <summary>
+        ///   Computes the XxHash32 hash of the provided data.
+        /// </summary>
+        /// <param name="source">The data to hash.</param>
+        /// <param name="seed">The seed value for this hash computation. The default is zero.</param>
+        /// <returns>The XxHash32 hash of the provided data.</returns>
+        public static byte[] Hash(ReadOnlySpan<byte> source, int seed = 0)
+        {
+            byte[] ret = new byte[HashSize];
+            StaticHash(source, ret, seed);
+            return ret;
+        }
+
+        /// <summary>
+        ///   Attempts to compute the XxHash32 hash of the provided data into the provided destination.
+        /// </summary>
+        /// <param name="source">The data to hash.</param>
+        /// <param name="destination">The buffer that receives the computed hash value.</param>
+        /// <param name="bytesWritten">
+        ///   On success, receives the number of bytes written to <paramref name="destination"/>.
+        /// </param>
+        /// <param name="seed">The seed value for this hash computation. The default is zero.</param>
+        /// <returns>
+        ///   <see langword="true"/> if <paramref name="destination"/> is long enough to receive
+        ///   the computed hash value (4 bytes); otherwise, <see langword="false"/>.
+        /// </returns>
+        public static bool TryHash(ReadOnlySpan<byte> source, Span<byte> destination, out int bytesWritten, int seed = 0)
+        {
+            if (destination.Length < HashSize)
+            {
+                bytesWritten = 0;
+                return false;
+            }
+
+            bytesWritten = StaticHash(source, destination, seed);
+            return true;
+        }
+
+        /// <summary>
+        ///   Computes the XxHash32 hash of the provided data into the provided destination.
+        /// </summary>
+        /// <param name="source">The data to hash.</param>
+        /// <param name="destination">The buffer that receives the computed hash value.</param>
+        /// <param name="seed">The seed value for this hash computation. The default is zero.</param>
+        /// <returns>
+        ///   The number of bytes written to <paramref name="destination"/>.
+        /// </returns>
+        public static int Hash(ReadOnlySpan<byte> source, Span<byte> destination, int seed = 0)
+        {
+            if (destination.Length < HashSize)
+                throw new ArgumentException(SR.Argument_DestinationTooShort, nameof(destination));
+
+            return StaticHash(source, destination, seed);
+        }
+
+        private static int StaticHash(ReadOnlySpan<byte> source, Span<byte> destination, int seed)
+        {
+            int totalLength = source.Length;
+            State state = new State((uint)seed);
+
+            while (source.Length > StripeSize)
+            {
+                state.ProcessStripe(source);
+                source = source.Slice(StripeSize);
+            }
+
+            uint val = state.Complete(totalLength, source);
+            BinaryPrimitives.WriteUInt32BigEndian(destination, val);
+            return HashSize;
+        }
+    }
+}
diff --git a/src/libraries/System.IO.Hashing/src/System/IO/Hashing/XxHash64.State.cs b/src/libraries/System.IO.Hashing/src/System/IO/Hashing/XxHash64.State.cs
new file mode 100644
index 00000000000000..ecb289a945c957
--- /dev/null
+++ b/src/libraries/System.IO.Hashing/src/System/IO/Hashing/XxHash64.State.cs
@@ -0,0 +1,140 @@
+// 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.Binary;
+using System.Diagnostics;
+using System.Numerics;
+
+// Implemented from the specification at
+// https://github.com/Cyan4973/xxHash/blob/f9155bd4c57e2270a4ffbb176485e5d713de1c9b/doc/xxhash_spec.md
+
+namespace System.IO.Hashing
+{
+    public sealed partial class XxHash64
+    {
+        private struct State
+        {
+            private const ulong Prime64_1 = 0x9E3779B185EBCA87;
+            private const ulong Prime64_2 = 0xC2B2AE3D27D4EB4F;
+            private const ulong Prime64_3 = 0x165667B19E3779F9;
+            private const ulong Prime64_4 = 0x85EBCA77C2B2AE63;
+            private const ulong Prime64_5 = 0x27D4EB2F165667C5;
+
+            private ulong _acc1;
+            private ulong _acc2;
+            private ulong _acc3;
+            private ulong _acc4;
+            private readonly ulong _smallAcc;
+            private bool _hadFullStripe;
+
+            internal State(ulong seed)
+            {
+                _acc1 = seed + unchecked(Prime64_1 + Prime64_2);
+                _acc2 = seed + Prime64_2;
+                _acc3 = seed;
+                _acc4 = seed - Prime64_1;
+
+                _smallAcc = seed + Prime64_5;
+                _hadFullStripe = false;
+            }
+
+            internal void ProcessStripe(ReadOnlySpan<byte> source)
+            {
+                Debug.Assert(source.Length >= StripeSize);
+                source = source.Slice(0, StripeSize);
+
+                _acc1 = ApplyRound(_acc1, source);
+                _acc2 = ApplyRound(_acc2, source.Slice(sizeof(ulong)));
+                _acc3 = ApplyRound(_acc3, source.Slice(2 * sizeof(ulong)));
+                _acc4 = ApplyRound(_acc4, source.Slice(3 * sizeof(ulong)));
+
+                _hadFullStripe = true;
+            }
+
+            private static ulong MergeAccumulator(ulong acc, ulong accN)
+            {
+                acc ^= ApplyRound(0, accN);
+                acc *= Prime64_1;
+                acc += Prime64_4;
+
+                return acc;
+            }
+
+            private readonly ulong Converge()
+            {
+                ulong acc =
+                    BitOperations.RotateLeft(_acc1, 1) +
+                    BitOperations.RotateLeft(_acc2, 7) +
+                    BitOperations.RotateLeft(_acc3, 12) +
+                    BitOperations.RotateLeft(_acc4, 18);
+
+                acc = MergeAccumulator(acc, _acc1);
+                acc = MergeAccumulator(acc, _acc2);
+                acc = MergeAccumulator(acc, _acc3);
+                acc = MergeAccumulator(acc, _acc4);
+
+                return acc;
+            }
+
+            private static ulong ApplyRound(ulong acc, ReadOnlySpan<byte> lane)
+            {
+                return ApplyRound(acc, BinaryPrimitives.ReadUInt64LittleEndian(lane));
+            }
+
+            private static ulong ApplyRound(ulong acc, ulong lane)
+            {
+                acc += lane * Prime64_2;
+                acc = BitOperations.RotateLeft(acc, 31);
+                acc *= Prime64_1;
+
+                return acc;
+            }
+
+            internal readonly ulong Complete(int length, ReadOnlySpan<byte> remaining)
+            {
+                ulong acc = _hadFullStripe ? Converge() : _smallAcc;
+
+                acc += (ulong)length;
+
+                while (remaining.Length >= sizeof(ulong))
+                {
+                    ulong lane = BinaryPrimitives.ReadUInt64LittleEndian(remaining);
+                    acc ^= ApplyRound(0, lane);
+                    acc = BitOperations.RotateLeft(acc, 27);
+                    acc *= Prime64_1;
+                    acc += Prime64_4;
+
+                    remaining = remaining.Slice(sizeof(ulong));
+                }
+
+                // Doesn't need to be a while since it can occur at most once.
+                if (remaining.Length >= sizeof(uint))
+                {
+                    ulong lane = BinaryPrimitives.ReadUInt32LittleEndian(remaining);
+                    acc ^= lane * Prime64_1;
+                    acc = BitOperations.RotateLeft(acc, 23);
+                    acc *= Prime64_2;
+                    acc += Prime64_3;
+
+                    remaining = remaining.Slice(sizeof(uint));
+                }
+
+                for (int i = 0; i < remaining.Length; i++)
+                {
+                    ulong lane = remaining[i];
+                    acc ^= lane * Prime64_5;
+                    acc = BitOperations.RotateLeft(acc, 11);
+                    acc *= Prime64_1;
+                }
+
+                acc ^= (acc >> 33);
+                acc *= Prime64_2;
+                acc ^= (acc >> 29);
+                acc *= Prime64_3;
+                acc ^= (acc >> 32);
+
+                return acc;
+            }
+        }
+    }
+}
diff --git a/src/libraries/System.IO.Hashing/src/System/IO/Hashing/XxHash64.cs b/src/libraries/System.IO.Hashing/src/System/IO/Hashing/XxHash64.cs
new file mode 100644
index 00000000000000..990ed77d64de27
--- /dev/null
+++ b/src/libraries/System.IO.Hashing/src/System/IO/Hashing/XxHash64.cs
@@ -0,0 +1,229 @@
+// 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.Binary;
+
+// Implemented from the specification at
+// https://github.com/Cyan4973/xxHash/blob/f9155bd4c57e2270a4ffbb176485e5d713de1c9b/doc/xxhash_spec.md
+
+namespace System.IO.Hashing
+{
+    /// <summary>
+    ///   Provides an implementation of the XxHash64 algorithm.
+    /// </summary>
+    public sealed partial class XxHash64 : NonCryptographicHashAlgorithm
+    {
+        private const int HashSize = sizeof(ulong);
+        private const int StripeSize = 4 * sizeof(ulong);
+
+        private readonly ulong _seed;
+        private State _state;
+        private byte[]? _holdback;
+        private int _length;
+
+        /// <summary>
+        ///   Initializes a new instance of the <see cref="XxHash64"/> class.
+        /// </summary>
+        /// <remarks>
+        ///   The XxHash64 algorithm supports an optional seed value.
+        ///   Instances created with this constructor use the default seed, zero.
+        /// </remarks>
+        public XxHash64()
+            : this(0)
+        {
+        }
+
+        /// <summary>
+        ///   Initializes a new instance of the <see cref="XxHash64"/> class with
+        ///   a specified seed.
+        /// </summary>
+        /// <param name="seed">
+        ///   The hash seed value for computations from this instance.
+        /// </param>
+        public XxHash64(long seed)
+            : base(HashSize)
+        {
+            _seed = (ulong)seed;
+            Reset();
+        }
+
+        /// <summary>
+        ///   Resets the hash computation to the initial state.
+        /// </summary>
+        public override void Reset()
+        {
+            _state = new State(_seed);
+            _length = 0;
+        }
+
+        /// <summary>
+        ///   Appends the contents of <paramref name="source"/> to the data already
+        ///   processed for the current hash computation.
+        /// </summary>
+        /// <param name="source">The data to process.</param>
+        public override void Append(ReadOnlySpan<byte> source)
+        {
+            // Every time we've read 16 bytes, process the stripe.
+            // Data that isn't perfectly mod-16 gets stored in a holdback
+            // buffer.
+
+            int held = _length & 0x1F;
+
+            if (held != 0)
+            {
+                int remain = StripeSize - held;
+
+                if (source.Length > remain)
+                {
+                    source.Slice(0, remain).CopyTo(_holdback.AsSpan(held));
+                    _state.ProcessStripe(_holdback);
+
+                    source = source.Slice(remain);
+                    _length += remain;
+                }
+                else
+                {
+                    source.CopyTo(_holdback.AsSpan(held));
+                    _length += source.Length;
+                    return;
+                }
+            }
+
+            while (source.Length >= StripeSize)
+            {
+                _state.ProcessStripe(source);
+                source = source.Slice(StripeSize);
+                _length += StripeSize;
+            }
+
+            if (source.Length > 0)
+            {
+                _holdback ??= new byte[StripeSize];
+                source.CopyTo(_holdback);
+                _length += source.Length;
+            }
+        }
+
+        /// <summary>
+        ///   Writes the computed hash value to <paramref name="destination"/>
+        ///   without modifying accumulated state.
+        /// </summary>
+        protected override void GetCurrentHashCore(Span<byte> destination)
+        {
+            int remainingLength = _length & 0x1F;
+            ReadOnlySpan<byte> remaining = ReadOnlySpan<byte>.Empty;
+
+            if (remainingLength > 0)
+            {
+                remaining = new ReadOnlySpan<byte>(_holdback, 0, remainingLength);
+            }
+
+            ulong acc = _state.Complete(_length, remaining);
+            BinaryPrimitives.WriteUInt64BigEndian(destination, acc);
+        }
+
+        /// <summary>
+        ///   Computes the XxHash64 hash of the provided data.
+        /// </summary>
+        /// <param name="source">The data to hash.</param>
+        /// <returns>The XxHash64 hash of the provided data.</returns>
+        /// <exception cref="ArgumentNullException">
+        ///   <paramref name="source"/> is <see langword="null"/>.
+        /// </exception>
+        public static byte[] Hash(byte[] source)
+        {
+            if (source is null)
+                throw new ArgumentNullException(nameof(source));
+
+            return Hash(new ReadOnlySpan<byte>(source));
+        }
+
+        /// <summary>
+        ///   Computes the XxHash64 hash of the provided data using the provided seed.
+        /// </summary>
+        /// <param name="source">The data to hash.</param>
+        /// <param name="seed">The seed value for this hash computation.</param>
+        /// <returns>The XxHash64 hash of the provided data.</returns>
+        /// <exception cref="ArgumentNullException">
+        ///   <paramref name="source"/> is <see langword="null"/>.
+        /// </exception>
+        public static byte[] Hash(byte[] source, long seed)
+        {
+            if (source is null)
+                throw new ArgumentNullException(nameof(source));
+
+            return Hash(new ReadOnlySpan<byte>(source), seed);
+        }
+
+        /// <summary>
+        ///   Computes the XxHash64 hash of the provided data.
+        /// </summary>
+        /// <param name="source">The data to hash.</param>
+        /// <param name="seed">The seed value for this hash computation. The default is zero.</param>
+        /// <returns>The XxHash64 hash of the provided data.</returns>
+        public static byte[] Hash(ReadOnlySpan<byte> source, long seed = 0)
+        {
+            byte[] ret = new byte[HashSize];
+            StaticHash(source, ret, seed);
+            return ret;
+        }
+
+        /// <summary>
+        ///   Attempts to compute the XxHash64 hash of the provided data into the provided destination.
+        /// </summary>
+        /// <param name="source">The data to hash.</param>
+        /// <param name="destination">The buffer that receives the computed hash value.</param>
+        /// <param name="bytesWritten">
+        ///   On success, receives the number of bytes written to <paramref name="destination"/>.
+        /// </param>
+        /// <param name="seed">The seed value for this hash computation. The default is zero.</param>
+        /// <returns>
+        ///   <see langword="true"/> if <paramref name="destination"/> is long enough to receive
+        ///   the computed hash value (4 bytes); otherwise, <see langword="false"/>.
+        /// </returns>
+        public static bool TryHash(ReadOnlySpan<byte> source, Span<byte> destination, out int bytesWritten, long seed = 0)
+        {
+            if (destination.Length < HashSize)
+            {
+                bytesWritten = 0;
+                return false;
+            }
+
+            bytesWritten = StaticHash(source, destination, seed);
+            return true;
+        }
+
+        /// <summary>
+        ///   Computes the XxHash64 hash of the provided data into the provided destination.
+        /// </summary>
+        /// <param name="source">The data to hash.</param>
+        /// <param name="destination">The buffer that receives the computed hash value.</param>
+        /// <param name="seed">The seed value for this hash computation. The default is zero.</param>
+        /// <returns>
+        ///   The number of bytes written to <paramref name="destination"/>.
+        /// </returns>
+        public static int Hash(ReadOnlySpan<byte> source, Span<byte> destination, long seed = 0)
+        {
+            if (destination.Length < HashSize)
+                throw new ArgumentException(SR.Argument_DestinationTooShort, nameof(destination));
+
+            return StaticHash(source, destination, seed);
+        }
+
+        private static int StaticHash(ReadOnlySpan<byte> source, Span<byte> destination, long seed)
+        {
+            int totalLength = source.Length;
+            State state = new State((ulong)seed);
+
+            while (source.Length > StripeSize)
+            {
+                state.ProcessStripe(source);
+                source = source.Slice(StripeSize);
+            }
+
+            ulong val = state.Complete(totalLength, source);
+            BinaryPrimitives.WriteUInt64BigEndian(destination, val);
+            return HashSize;
+        }
+    }
+}
diff --git a/src/libraries/System.IO.Hashing/tests/Crc32Tests.cs b/src/libraries/System.IO.Hashing/tests/Crc32Tests.cs
new file mode 100644
index 00000000000000..4e5ac8753d3f79
--- /dev/null
+++ b/src/libraries/System.IO.Hashing/tests/Crc32Tests.cs
@@ -0,0 +1,146 @@
+// 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.Text;
+using Xunit;
+
+namespace System.IO.Hashing.Tests
+{
+    public class Crc32Tests : NonCryptoHashTestDriver
+    {
+        private static readonly byte[] s_emptyHashValue = new byte[4];
+
+        public Crc32Tests()
+            : base(s_emptyHashValue)
+        {
+        }
+
+        public static IEnumerable<object[]> TestCases
+        {
+            get
+            {
+                object[] arr = new object[1];
+
+                foreach (TestCase testCase in TestCaseDefinitions)
+                {
+                    arr[0] = testCase;
+                    yield return arr;
+                }
+            }
+        }
+
+        protected static IEnumerable<TestCase> TestCaseDefinitions { get; } =
+            new[]
+            {
+                new TestCase(
+                    "Empty",
+                    "",
+                    "00000000"),
+                new TestCase(
+                    "One",
+                    "01",
+                    "1BDF05A5"),
+                new TestCase(
+                    "Zero-Residue",
+                    "00000000",
+                    "1CDF4421"),
+                new TestCase(
+                    "Zero-InverseResidue",
+                    "FFFFFFFF",
+                    "FFFFFFFF"),
+                new TestCase(
+                    "Self-test 123456789",
+                    Encoding.ASCII.GetBytes("123456789"),
+                    "2639F4CB"),
+                new TestCase(
+                    "Self-test residue",
+                    "3132333435363738392639F4CB",
+                    "1CDF4421"),
+                new TestCase(
+                    "Self-test inverse residue",
+                    "313233343536373839D9C60B34",
+                    "FFFFFFFF"),
+                new TestCase(
+                    "The quick brown fox jumps over the lazy dog",
+                    Encoding.ASCII.GetBytes("The quick brown fox jumps over the lazy dog"),
+                    "39A34F41"),
+            };
+
+        protected override NonCryptographicHashAlgorithm CreateInstance() => new Crc32();
+
+        protected override byte[] StaticOneShot(byte[] source) => Crc32.Hash(source);
+
+        protected override byte[] StaticOneShot(ReadOnlySpan<byte> source) => Crc32.Hash(source);
+
+        protected override int StaticOneShot(ReadOnlySpan<byte> source, Span<byte> destination) =>
+            Crc32.Hash(source, destination);
+
+        protected override bool TryStaticOneShot(ReadOnlySpan<byte> source, Span<byte> destination, out int bytesWritten) =>
+            Crc32.TryHash(source, destination, out bytesWritten);
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void InstanceAppendAllocate(TestCase testCase)
+        {
+            InstanceAppendAllocateDriver(testCase);
+        }
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void InstanceAppendAllocateAndReset(TestCase testCase)
+        {
+            InstanceAppendAllocateAndResetDriver(testCase);
+        }
+
+        [SkipOnCoreClr("https://github.com/dotnet/runtime/issues/54007", RuntimeConfiguration.Checked)]
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void InstanceMultiAppendGetCurrentHash(TestCase testCase)
+        {
+            InstanceMultiAppendGetCurrentHashDriver(testCase);
+        }
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void InstanceVerifyEmptyState(TestCase testCase)
+        {
+            InstanceVerifyEmptyStateDriver(testCase);
+        }
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void InstanceVerifyResetState(TestCase testCase)
+        {
+            InstanceVerifyResetStateDriver(testCase);
+        }
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void StaticVerifyOneShotArray(TestCase testCase)
+        {
+            StaticVerifyOneShotArrayDriver(testCase);
+        }
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void StaticVerifyOneShotSpanToArray(TestCase testCase)
+        {
+            StaticVerifyOneShotSpanToArrayDriver(testCase);
+        }
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void StaticVerifyOneShotSpanToSpan(TestCase testCase)
+        {
+            StaticVerifyOneShotSpanToSpanDriver(testCase);
+        }
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void StaticVerifyTryOneShot(TestCase testCase)
+        {
+            StaticVerifyTryOneShotDriver(testCase);
+        }
+    }
+}
diff --git a/src/libraries/System.IO.Hashing/tests/Crc64Tests.cs b/src/libraries/System.IO.Hashing/tests/Crc64Tests.cs
new file mode 100644
index 00000000000000..546501aa4d5459
--- /dev/null
+++ b/src/libraries/System.IO.Hashing/tests/Crc64Tests.cs
@@ -0,0 +1,150 @@
+// 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.Text;
+using Xunit;
+
+namespace System.IO.Hashing.Tests
+{
+    public class Crc64Tests : NonCryptoHashTestDriver
+    {
+        private static readonly byte[] s_emptyHashValue = new byte[8];
+
+        public Crc64Tests()
+            : base(s_emptyHashValue)
+        {
+        }
+
+        public static IEnumerable<object[]> TestCases
+        {
+            get
+            {
+                object[] arr = new object[1];
+
+                foreach (TestCase testCase in TestCaseDefinitions)
+                {
+                    arr[0] = testCase;
+                    yield return arr;
+                }
+            }
+        }
+
+        protected static IEnumerable<TestCase> TestCaseDefinitions { get; } =
+            new[]
+            {
+                new TestCase(
+                    "Empty",
+                    "",
+                    "0000000000000000"),
+                new TestCase(
+                    "One",
+                    "01",
+                    "42F0E1EBA9EA3693"),
+                // Because CRC-64 has an initial state of 0, any input that is all
+                // zero-valued bytes will always produce 0x0ul as the output, since it
+                // never leaves state 0.
+                new TestCase(
+                    "{ 0x00 }",
+                    "00",
+                    "0000000000000000"),
+                // Once it has left the initial state, zero-value bytes matter.
+                new TestCase(
+                    "{ 0x01, 0x00 }",
+                    "0100",
+                    "AF052A6B538EDF09"),
+                new TestCase(
+                    "Zero-Residue",
+                    "0000000000000000",
+                    "0000000000000000"),
+                new TestCase(
+                    "Self-test 123456789",
+                    Encoding.ASCII.GetBytes("123456789"),
+                    "6C40DF5F0B497347"),
+                new TestCase(
+                    "Self-test residue",
+                    "3132333435363738396C40DF5F0B497347",
+                    "0000000000000000"),
+                new TestCase(
+                    "The quick brown fox jumps over the lazy dog",
+                    Encoding.ASCII.GetBytes("The quick brown fox jumps over the lazy dog"),
+                    "41E05242FFA9883B"),
+            };
+
+        protected override NonCryptographicHashAlgorithm CreateInstance() => new Crc64();
+
+        protected override byte[] StaticOneShot(byte[] source) => Crc64.Hash(source);
+
+        protected override byte[] StaticOneShot(ReadOnlySpan<byte> source) => Crc64.Hash(source);
+
+        protected override int StaticOneShot(ReadOnlySpan<byte> source, Span<byte> destination) =>
+            Crc64.Hash(source, destination);
+
+        protected override bool TryStaticOneShot(ReadOnlySpan<byte> source, Span<byte> destination, out int bytesWritten) =>
+            Crc64.TryHash(source, destination, out bytesWritten);
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void InstanceAppendAllocate(TestCase testCase)
+        {
+            InstanceAppendAllocateDriver(testCase);
+        }
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void InstanceAppendAllocateAndReset(TestCase testCase)
+        {
+            InstanceAppendAllocateAndResetDriver(testCase);
+        }
+
+        [SkipOnCoreClr("https://github.com/dotnet/runtime/issues/54007", RuntimeConfiguration.Checked)]
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void InstanceMultiAppendGetCurrentHash(TestCase testCase)
+        {
+            InstanceMultiAppendGetCurrentHashDriver(testCase);
+        }
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void InstanceVerifyEmptyState(TestCase testCase)
+        {
+            InstanceVerifyEmptyStateDriver(testCase);
+        }
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void InstanceVerifyResetState(TestCase testCase)
+        {
+            InstanceVerifyResetStateDriver(testCase);
+        }
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void StaticVerifyOneShotArray(TestCase testCase)
+        {
+            StaticVerifyOneShotArrayDriver(testCase);
+        }
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void StaticVerifyOneShotSpanToArray(TestCase testCase)
+        {
+            StaticVerifyOneShotSpanToArrayDriver(testCase);
+        }
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void StaticVerifyOneShotSpanToSpan(TestCase testCase)
+        {
+            StaticVerifyOneShotSpanToSpanDriver(testCase);
+        }
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void StaticVerifyTryOneShot(TestCase testCase)
+        {
+            StaticVerifyTryOneShotDriver(testCase);
+        }
+    }
+}
diff --git a/src/libraries/System.IO.Hashing/tests/NonCryptoHashBaseTests.cs b/src/libraries/System.IO.Hashing/tests/NonCryptoHashBaseTests.cs
new file mode 100644
index 00000000000000..bf72d4ef8513f0
--- /dev/null
+++ b/src/libraries/System.IO.Hashing/tests/NonCryptoHashBaseTests.cs
@@ -0,0 +1,581 @@
+// 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.Binary;
+using System.Threading;
+using System.Threading.Tasks;
+using Test.IO.Streams;
+using Xunit;
+
+namespace System.IO.Hashing.Tests
+{
+    public static class NonCryptoHashBaseTests
+    {
+        [Fact]
+        public static void ZeroLengthHashIsInvalid()
+        {
+            AssertExtensions.Throws<ArgumentOutOfRangeException>(
+                "hashLengthInBytes",
+                () => new FlexibleAlgorithm(0));
+        }
+
+        [Fact]
+        public static void NegativeHashLengthIsInvalid()
+        {
+            AssertExtensions.Throws<ArgumentOutOfRangeException>(
+                "hashLengthInBytes",
+                () => new FlexibleAlgorithm(-1));
+        }
+
+        [Fact]
+        public static void TryGetCurrentHash_TooSmall()
+        {
+            Span<byte> buf = stackalloc byte[7];
+            FlexibleAlgorithm hash = new FlexibleAlgorithm(buf.Length + 1);
+
+            Assert.True(hash.IsReset);
+            hash.Append(buf);
+            Assert.False(hash.IsReset);
+
+            while (true)
+            {
+                Assert.False(hash.TryGetCurrentHash(buf, out int written));
+                Assert.Equal(0, written);
+
+                if (buf.IsEmpty)
+                {
+                    break;
+                }
+
+                buf = buf.Slice(1);
+            }
+
+            Assert.Equal(0, hash.GetCurrentHashCoreCallCount);
+            Assert.False(hash.IsReset);
+        }
+
+        [Fact]
+        public static void TryGetCurrentHash_TooBig_Succeeds()
+        {
+            Span<byte> buf = stackalloc byte[16];
+            FlexibleAlgorithm hash = new FlexibleAlgorithm(buf.Length / 2);
+            int i = 0;
+
+            hash.Append(buf);
+
+            while (buf.Length > hash.HashLengthInBytes)
+            {
+                Assert.Equal(i, hash.GetCurrentHashCoreCallCount);
+
+                // TryGetCurrentHash in turn asserts that buf got Sliced down to HashLengthInBytes.
+                Assert.True(hash.TryGetCurrentHash(buf, out int written));
+                Assert.Equal(hash.HashLengthInBytes, written);
+
+                buf = buf.Slice(1);
+                i++;
+            }
+
+            Assert.Equal(i, hash.GetCurrentHashCoreCallCount);
+            Assert.False(hash.IsReset);
+        }
+
+        [Fact]
+        public static void GetCurrentHash_TooSmall()
+        {
+            byte[] buf = new byte[7];
+            FlexibleAlgorithm hash = new FlexibleAlgorithm(buf.Length + 1);
+
+            Assert.True(hash.IsReset);
+            hash.Append(buf);
+            Assert.False(hash.IsReset);
+
+            for (int i = 0; i <= buf.Length; i++)
+            {
+                AssertExtensions.Throws<ArgumentException>(
+                    "destination",
+                    () => hash.GetCurrentHash(buf.AsSpan(i)));
+            }
+
+            Assert.False(hash.IsReset);
+        }
+
+        [Fact]
+        public static void GetCurrentHash_TooBig_Succeeds()
+        {
+            Span<byte> buf = stackalloc byte[16];
+            FlexibleAlgorithm hash = new FlexibleAlgorithm(buf.Length / 2);
+            int i = 0;
+
+            hash.Append(buf);
+
+            while (buf.Length > hash.HashLengthInBytes)
+            {
+                Assert.Equal(i, hash.GetCurrentHashCoreCallCount);
+
+                // GetCurrentHash in turn asserts that buf got Sliced down to HashLengthInBytes.
+                int written = hash.GetCurrentHash(buf);
+                Assert.Equal(hash.HashLengthInBytes, written);
+
+                buf = buf.Slice(1);
+                i++;
+            }
+
+            Assert.Equal(i, hash.GetCurrentHashCoreCallCount);
+            Assert.False(hash.IsReset);
+        }
+
+        [Fact]
+        public static void AllocatingGetCurrentHash_CorrectSize()
+        {
+            FlexibleAlgorithm hash = new FlexibleAlgorithm(12);
+            byte[] ret = hash.GetCurrentHash();
+            Assert.Equal(hash.HashLengthInBytes, ret.Length);
+            Assert.Equal(1, hash.GetCurrentHashCoreCallCount);
+        }
+
+        [Fact]
+        public static void DefaultGetHashAndResetDoesWhatItSays()
+        {
+            Span<byte> buf = stackalloc byte[16];
+            FlexibleAlgorithm hash = new FlexibleAlgorithm(buf.Length);
+            Assert.True(hash.IsReset);
+            hash.Append(buf);
+            Assert.False(hash.IsReset);
+            Assert.Equal(0, hash.GetCurrentHashCoreCallCount);
+
+            byte[] ret = hash.GetHashAndReset();
+            Assert.True(hash.IsReset);
+            Assert.Equal(1, hash.GetCurrentHashCoreCallCount);
+            Assert.Equal(hash.HashLengthInBytes, ret.Length);
+
+            hash.Append(ret);
+            Assert.False(hash.IsReset);
+
+            Assert.True(hash.TryGetHashAndReset(buf, out int written));
+            Assert.True(hash.IsReset);
+            Assert.Equal(2, hash.GetCurrentHashCoreCallCount);
+            Assert.Equal(hash.HashLengthInBytes, written);
+
+            hash.Append(ret);
+            Assert.False(hash.IsReset);
+
+            written = hash.GetHashAndReset(buf);
+            Assert.True(hash.IsReset);
+            Assert.Equal(3, hash.GetCurrentHashCoreCallCount);
+            Assert.Equal(hash.HashLengthInBytes, written);
+        }
+
+        [Fact]
+        public static void TryGetHashAndReset_TooSmall()
+        {
+            Span<byte> buf = stackalloc byte[7];
+            FlexibleAlgorithm hash = new FlexibleAlgorithm(buf.Length + 1);
+
+            Assert.True(hash.IsReset);
+            hash.Append(buf);
+            Assert.False(hash.IsReset);
+
+            while (true)
+            {
+                Assert.False(hash.TryGetHashAndReset(buf, out int written));
+                Assert.Equal(0, written);
+
+                if (buf.IsEmpty)
+                {
+                    break;
+                }
+
+                buf = buf.Slice(1);
+            }
+
+            Assert.Equal(0, hash.GetCurrentHashCoreCallCount);
+            Assert.False(hash.IsReset);
+        }
+
+        [Fact]
+        public static void TryGetHashAndReset_TooBig_Succeeds()
+        {
+            Span<byte> buf = stackalloc byte[16];
+            FlexibleAlgorithm hash = new FlexibleAlgorithm(buf.Length / 2);
+            int i = 0;
+
+            while (buf.Length > hash.HashLengthInBytes)
+            {
+                Assert.Equal(i, hash.GetCurrentHashCoreCallCount);
+
+                hash.Append(buf);
+                Assert.False(hash.IsReset);
+
+                // TryGetCurrentHash in turn asserts that buf got Sliced down to HashLengthInBytes.
+                Assert.True(hash.TryGetHashAndReset(buf, out int written));
+                Assert.Equal(hash.HashLengthInBytes, written);
+                Assert.True(hash.IsReset);
+
+                buf = buf.Slice(1);
+                i++;
+            }
+
+            Assert.Equal(i, hash.GetCurrentHashCoreCallCount);
+            Assert.True(hash.IsReset);
+        }
+
+        [Fact]
+        public static void GetHashAndReset_TooSmall()
+        {
+            byte[] buf = new byte[7];
+            FlexibleAlgorithm hash = new FlexibleAlgorithm(buf.Length + 1);
+
+            Assert.True(hash.IsReset);
+            hash.Append(buf);
+            Assert.False(hash.IsReset);
+
+            for (int i = 0; i <= buf.Length; i++)
+            {
+                AssertExtensions.Throws<ArgumentException>(
+                    "destination",
+                    () => hash.GetHashAndReset(buf.AsSpan(i)));
+            }
+
+            Assert.Equal(0, hash.GetCurrentHashCoreCallCount);
+            Assert.False(hash.IsReset);
+        }
+
+        [Fact]
+        public static void GetHashAndReset_TooBig_Succeeds()
+        {
+            Span<byte> buf = stackalloc byte[16];
+            FlexibleAlgorithm hash = new FlexibleAlgorithm(buf.Length / 2);
+            int i = 0;
+
+            while (buf.Length > hash.HashLengthInBytes)
+            {
+                Assert.Equal(i, hash.GetCurrentHashCoreCallCount);
+
+                hash.Append(buf);
+                Assert.False(hash.IsReset);
+
+                Assert.True(hash.TryGetHashAndReset(buf, out int written));
+                Assert.Equal(hash.HashLengthInBytes, written);
+                Assert.True(hash.IsReset);
+
+                buf = buf.Slice(1);
+                i++;
+            }
+
+            Assert.Equal(i, hash.GetCurrentHashCoreCallCount);
+            Assert.True(hash.IsReset);
+        }
+
+        [Fact]
+        public static void AllocatingGetHashAndReset_CorrectSize()
+        {
+            FlexibleAlgorithm hash = new FlexibleAlgorithm(12);
+            byte[] ret = hash.GetHashAndReset();
+            Assert.Equal(hash.HashLengthInBytes, ret.Length);
+            Assert.Equal(1, hash.GetCurrentHashCoreCallCount);
+        }
+
+        [Fact]
+        public static void OverriddenTryGetHashAndReset_TooSmall()
+        {
+            Span<byte> buf = stackalloc byte[7];
+            var hash = new FlexibleAlgorithmOverride(buf.Length + 1);
+
+            Assert.True(hash.IsReset);
+            hash.Append(buf);
+            Assert.False(hash.IsReset);
+
+            while (true)
+            {
+                Assert.False(hash.TryGetHashAndReset(buf, out int written));
+                Assert.Equal(0, written);
+
+                if (buf.IsEmpty)
+                {
+                    break;
+                }
+
+                buf = buf.Slice(1);
+            }
+
+            Assert.Equal(0, hash.GetCurrentHashCoreCallCount);
+            Assert.Equal(0, hash.GetHashAndResetCoreCallCount);
+            Assert.False(hash.IsReset);
+        }
+
+        [Fact]
+        public static void OverriddenTryGetHashAndReset_TooBig_Succeeds()
+        {
+            Span<byte> buf = stackalloc byte[16];
+            var hash = new FlexibleAlgorithmOverride(buf.Length / 2);
+            int i = 0;
+
+            while (buf.Length > hash.HashLengthInBytes)
+            {
+                Assert.Equal(0, hash.GetCurrentHashCoreCallCount);
+                Assert.Equal(i, hash.GetHashAndResetCoreCallCount);
+
+                hash.Append(buf);
+                Assert.False(hash.IsReset);
+
+                // TryGetCurrentHash in turn asserts that buf got Sliced down to HashLengthInBytes.
+                Assert.True(hash.TryGetHashAndReset(buf, out int written));
+                Assert.Equal(hash.HashLengthInBytes, written);
+                Assert.True(hash.IsReset);
+
+                buf = buf.Slice(1);
+                i++;
+            }
+
+            Assert.Equal(0, hash.GetCurrentHashCoreCallCount);
+            Assert.Equal(i, hash.GetHashAndResetCoreCallCount);
+            Assert.True(hash.IsReset);
+        }
+
+        [Fact]
+        public static void OverriddenGetHashAndReset_TooSmall()
+        {
+            byte[] buf = new byte[7];
+            var hash = new FlexibleAlgorithmOverride(buf.Length + 1);
+
+            Assert.True(hash.IsReset);
+            hash.Append(buf);
+            Assert.False(hash.IsReset);
+
+            for (int i = 0; i <= buf.Length; i++)
+            {
+                AssertExtensions.Throws<ArgumentException>(
+                    "destination",
+                    () => hash.GetHashAndReset(buf.AsSpan(i)));
+            }
+
+            Assert.Equal(0, hash.GetCurrentHashCoreCallCount);
+            Assert.Equal(0, hash.GetHashAndResetCoreCallCount);
+            Assert.False(hash.IsReset);
+        }
+
+        [Fact]
+        public static void OverriddenGetHashAndReset_TooBig_Succeeds()
+        {
+            Span<byte> buf = stackalloc byte[16];
+            var hash = new FlexibleAlgorithmOverride(buf.Length / 2);
+            int i = 0;
+
+            while (buf.Length > hash.HashLengthInBytes)
+            {
+                Assert.Equal(0, hash.GetCurrentHashCoreCallCount);
+                Assert.Equal(i, hash.GetHashAndResetCoreCallCount);
+
+                hash.Append(buf);
+                Assert.False(hash.IsReset);
+
+                Assert.True(hash.TryGetHashAndReset(buf, out int written));
+                Assert.Equal(hash.HashLengthInBytes, written);
+                Assert.True(hash.IsReset);
+
+                buf = buf.Slice(1);
+                i++;
+            }
+
+            Assert.Equal(0, hash.GetCurrentHashCoreCallCount);
+            Assert.Equal(i, hash.GetHashAndResetCoreCallCount);
+            Assert.True(hash.IsReset);
+        }
+
+        [Fact]
+        public static void OverriddenAllocatingGetHashAndReset_CorrectSize()
+        {
+            var hash = new FlexibleAlgorithmOverride(12);
+            byte[] ret = hash.GetHashAndReset();
+            Assert.Equal(hash.HashLengthInBytes, ret.Length);
+            Assert.Equal(0, hash.GetCurrentHashCoreCallCount);
+            Assert.Equal(1, hash.GetHashAndResetCoreCallCount);
+        }
+
+        [Fact]
+        public static void AppendNullArrayThrows()
+        {
+            NonCryptographicHashAlgorithm hash = new FlexibleAlgorithm(5);
+            AssertExtensions.Throws<ArgumentNullException>("source", () => hash.Append((byte[])null));
+        }
+
+        [Fact]
+        public static void AppendNullStreamThrows()
+        {
+            NonCryptographicHashAlgorithm hash = new FlexibleAlgorithm(5);
+            AssertExtensions.Throws<ArgumentNullException>("stream", () => hash.Append((Stream)null));
+        }
+
+        [Fact]
+        public static void AppendAsyncNullStreamThrows_OutsideTask()
+        {
+            NonCryptographicHashAlgorithm hash = new FlexibleAlgorithm(5);
+            AssertExtensions.Throws<ArgumentNullException>("stream", () => hash.AppendAsync(null));
+        }
+
+        [Theory]
+        [InlineData(0)]
+        [InlineData(511)]
+        [InlineData(4097)]
+        [InlineData(1048581)]
+        public static void AppendStreamSanityTest(int streamSize)
+        {
+            NonCryptographicHashAlgorithm hash = new CountingAlgorithm();
+
+            using (PositionValueStream stream = new PositionValueStream(streamSize))
+            {
+                hash.Append(stream);
+            }
+
+            Span<byte> val = stackalloc byte[sizeof(int)];
+            hash.GetHashAndReset(val);
+            int res = BinaryPrimitives.ReadInt32LittleEndian(val);
+            Assert.Equal(streamSize, res);
+        }
+
+        [Theory]
+        [InlineData(0)]
+        [InlineData(511)]
+        [InlineData(4097)]
+        [InlineData(1048581)]
+        public static async Task AppendStreamAsyncSanityTest(int streamSize)
+        {
+            NonCryptographicHashAlgorithm hash = new CountingAlgorithm();
+
+            using (PositionValueStream stream = new PositionValueStream(streamSize))
+            {
+                await hash.AppendAsync(stream);
+            }
+
+            byte[] val = new byte[sizeof(int)];
+            hash.GetHashAndReset(val);
+            int res = BinaryPrimitives.ReadInt32LittleEndian(val);
+            Assert.Equal(streamSize, res);
+        }
+
+        [Fact]
+        public static void AppendStreamAsyncSupportsCancellation()
+        {
+            NonCryptographicHashAlgorithm hash = new CountingAlgorithm();
+
+            using (PositionValueStream stream = new PositionValueStream(21))
+            using (CancellationTokenSource cts = new CancellationTokenSource())
+            {
+                cts.Cancel();
+
+                Task task = hash.AppendAsync(stream, cts.Token);
+                Assert.True(task.IsCompleted);
+                Assert.True(task.IsCanceled);
+            }
+
+            byte[] val = new byte[sizeof(int)];
+            hash.GetHashAndReset(val);
+            int res = BinaryPrimitives.ReadInt32LittleEndian(val);
+            Assert.Equal(0, res);
+        }
+
+        [Fact]
+        public static void GetHashCode_NotSupported()
+        {
+            NonCryptographicHashAlgorithm hash = new CountingAlgorithm();
+            Assert.Throws<NotSupportedException>(() => hash.GetHashCode());
+        }
+        private sealed class CountingAlgorithm : NonCryptographicHashAlgorithm
+        {
+            private int _count;
+
+            public CountingAlgorithm()
+                : base(sizeof(int))
+            {
+            }
+
+            public override void Append(ReadOnlySpan<byte> source)
+            {
+                _count += source.Length;
+            }
+
+            public override void Reset()
+            {
+                _count = 0;
+            }
+
+            protected override void GetCurrentHashCore(Span<byte> destination)
+            {
+                BinaryPrimitives.WriteInt32LittleEndian(destination, _count);
+            }
+        }
+
+        private sealed class FlexibleAlgorithm : NonCryptographicHashAlgorithm
+        {
+            public bool IsReset { get; private set; }
+            public int GetCurrentHashCoreCallCount { get; private set; }
+
+            public FlexibleAlgorithm(int hashLengthInBytes)
+                : base(hashLengthInBytes)
+            {
+                Reset();
+            }
+
+            public override void Append(ReadOnlySpan<byte> source)
+            {
+                if (source.Length > 0)
+                {
+                    IsReset = false;
+                }
+            }
+
+            public override void Reset()
+            {
+                IsReset = true;
+            }
+
+            protected override void GetCurrentHashCore(Span<byte> destination)
+            {
+                Assert.Equal(HashLengthInBytes, destination.Length);
+                destination.Fill((byte)GetCurrentHashCoreCallCount);
+                GetCurrentHashCoreCallCount++;
+            }
+        }
+
+        private sealed class FlexibleAlgorithmOverride : NonCryptographicHashAlgorithm
+        {
+            public bool IsReset { get; private set; }
+            public int GetCurrentHashCoreCallCount { get; private set; }
+            public int GetHashAndResetCoreCallCount { get; private set; }
+
+            public FlexibleAlgorithmOverride(int hashLengthInBytes)
+                : base(hashLengthInBytes)
+            {
+                Reset();
+            }
+
+            public override void Append(ReadOnlySpan<byte> source)
+            {
+                if (source.Length > 0)
+                {
+                    IsReset = false;
+                }
+            }
+
+            public override void Reset()
+            {
+                IsReset = true;
+            }
+
+            protected override void GetCurrentHashCore(Span<byte> destination)
+            {
+                Assert.Equal(HashLengthInBytes, destination.Length);
+                destination.Fill(0xFE);
+                GetCurrentHashCoreCallCount++;
+            }
+
+            protected override void GetHashAndResetCore(Span<byte> destination)
+            {
+                Assert.Equal(HashLengthInBytes, destination.Length);
+                destination.Fill(0xFE);
+                Reset();
+                GetHashAndResetCoreCallCount++;
+            }
+        }
+    }
+}
diff --git a/src/libraries/System.IO.Hashing/tests/NonCryptoHashTestDriver.cs b/src/libraries/System.IO.Hashing/tests/NonCryptoHashTestDriver.cs
new file mode 100644
index 00000000000000..979e60a28065f6
--- /dev/null
+++ b/src/libraries/System.IO.Hashing/tests/NonCryptoHashTestDriver.cs
@@ -0,0 +1,361 @@
+// 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.Reflection;
+using Xunit;
+
+namespace System.IO.Hashing.Tests
+{
+    public abstract class NonCryptoHashTestDriver
+    {
+        private readonly int _hashLengthInBytes;
+        private readonly byte[] _emptyHash;
+        private string _emptyHashHex;
+
+        protected NonCryptoHashTestDriver(byte[] emptyHash)
+        {
+            _hashLengthInBytes = emptyHash.Length;
+            _emptyHash = emptyHash;
+        }
+
+        protected abstract NonCryptographicHashAlgorithm CreateInstance();
+
+        protected abstract byte[] StaticOneShot(byte[] source);
+        protected abstract byte[] StaticOneShot(ReadOnlySpan<byte> source);
+        protected abstract int StaticOneShot(ReadOnlySpan<byte> source, Span<byte> destination);
+
+        protected abstract bool TryStaticOneShot(
+            ReadOnlySpan<byte> source,
+            Span<byte> destination,
+            out int bytesWritten);
+
+        [Fact]
+        public void TestsDefined()
+        {
+            const string DriverSuffix = "Driver";
+            Type implType = GetType();
+            Type defType = typeof(NonCryptoHashTestDriver);
+            List<string>? missingMethods = null;
+
+            foreach (MethodInfo info in defType.GetMethods(BindingFlags.Instance | BindingFlags.NonPublic))
+            {
+                if (info.IsFamily && info.Name.EndsWith(DriverSuffix, StringComparison.Ordinal))
+                {
+                    string targetMethodName = info.Name.Substring(0, info.Name.Length - DriverSuffix.Length);
+
+                    MethodInfo info2 = implType.GetMethod(
+                        targetMethodName,
+                        BindingFlags.Instance | BindingFlags.Public);
+
+                    if (info2 is null)
+                    {
+                        missingMethods ??= new List<string>();
+                        missingMethods.Add(targetMethodName);
+                    }
+                }
+            }
+
+            if (missingMethods is not null)
+            {
+                Assert.Empty(missingMethods);
+            }
+        }
+
+        [Fact]
+        public void VerifyLengthProperty()
+        {
+            NonCryptographicHashAlgorithm hash = CreateInstance();
+            Assert.Equal(_hashLengthInBytes, hash.HashLengthInBytes);
+        }
+
+        protected void InstanceAppendAllocateDriver(TestCase testCase)
+        {
+            NonCryptographicHashAlgorithm hash = CreateInstance();
+            hash.Append(testCase.Input);
+            byte[] output = hash.GetCurrentHash();
+
+            Assert.Equal(testCase.OutputHex, TestCase.ToHexString(output));
+        }
+
+        protected void InstanceAppendAllocateAndResetDriver(TestCase testCase)
+        {
+            NonCryptographicHashAlgorithm hash = CreateInstance();
+            hash.Append(testCase.Input);
+            byte[] output = hash.GetHashAndReset();
+
+            Assert.Equal(testCase.OutputHex, TestCase.ToHexString(output));
+
+            int written = hash.GetHashAndReset(output);
+            Assert.Equal(output.Length, written);
+            VerifyEmptyResult(output);
+        }
+
+        protected void InstanceMultiAppendGetCurrentHashDriver(TestCase testCase)
+        {
+            ReadOnlySpan<byte> source = testCase.Input;
+            int div3 = source.Length / 3;
+            NonCryptographicHashAlgorithm hash = CreateInstance();
+            hash.Append(source.Slice(0, div3));
+            source = source.Slice(div3);
+            hash.Append(source.Slice(0, div3));
+            source = source.Slice(div3);
+            hash.Append(source);
+
+            Span<byte> buf = stackalloc byte[256];
+
+            // May as well check unaligned writes.
+            Span<byte> destination = buf.Slice(1);
+            int written = hash.GetCurrentHash(destination);
+            ReadOnlySpan<byte> answer = destination.Slice(0, written);
+
+            testCase.VerifyResponse(answer);
+
+            destination.Clear();
+            hash.GetCurrentHash(destination);
+            testCase.VerifyResponse(answer);
+        }
+
+        protected void InstanceVerifyEmptyStateDriver(TestCase testCase)
+        {
+            Span<byte> buf = stackalloc byte[256];
+            NonCryptographicHashAlgorithm hash = CreateInstance();
+            int written = hash.GetCurrentHash(buf);
+            VerifyEmptyResult(buf.Slice(0, written));
+
+            written = hash.GetHashAndReset(buf);
+            VerifyEmptyResult(buf.Slice(0, written));
+        }
+
+        protected void InstanceVerifyResetStateDriver(TestCase testCase)
+        {
+            NonCryptographicHashAlgorithm hash = CreateInstance();
+            Span<byte> buf = stackalloc byte[233];
+            int written = hash.GetHashAndReset(buf);
+            ReadOnlySpan<byte> ret = buf.Slice(0, written);
+            VerifyEmptyResult(ret);
+
+            hash.Append(testCase.Input);
+            hash.Reset();
+            hash.GetCurrentHash(buf);
+            VerifyEmptyResult(ret);
+
+            // Manual call to Reset while already in a pristine state.
+            hash.Reset();
+            hash.GetCurrentHash(buf);
+            VerifyEmptyResult(ret);
+
+            hash.Append(testCase.Input);
+            hash.GetHashAndReset(buf);
+            testCase.VerifyResponse(ret);
+
+            hash.GetHashAndReset(buf);
+            VerifyEmptyResult(ret);
+        }
+
+        [Fact]
+        public void StaticOneShotNullArrayThrows()
+        {
+            AssertExtensions.Throws<ArgumentNullException>(
+                "source",
+                () => StaticOneShot((byte[])null));
+        }
+
+        protected void StaticVerifyOneShotArrayDriver(TestCase testCase)
+        {
+            byte[] answer = StaticOneShot(testCase.Input.ToArray());
+            testCase.VerifyResponse(answer);
+        }
+
+        protected void StaticVerifyOneShotSpanToArrayDriver(TestCase testCase)
+        {
+            byte[] answer = StaticOneShot(testCase.Input);
+            testCase.VerifyResponse(answer);
+        }
+
+        protected void StaticVerifyOneShotSpanToSpanDriver(TestCase testCase)
+        {
+            Span<byte> destination = stackalloc byte[256];
+
+            int written = StaticOneShot(testCase.Input, destination);
+            testCase.VerifyResponse(destination.Slice(0, written));
+        }
+
+        protected void StaticVerifyTryOneShotDriver(TestCase testCase)
+        {
+            Span<byte> destination = stackalloc byte[256];
+
+            Assert.True(TryStaticOneShot(testCase.Input, destination, out int written));
+            testCase.VerifyResponse(destination.Slice(0, written));
+        }
+
+        [Fact]
+        public void StaticVerifyOneShotSpanTooShortThrows()
+        {
+            byte[] destination = new byte[256];
+
+            for (int i = 0; i < _hashLengthInBytes; i++)
+            {
+                byte fill = (byte)~i;
+                destination.AsSpan().Fill(fill);
+
+                AssertExtensions.Throws<ArgumentException>(
+                    "destination",
+                    () => StaticOneShot(ReadOnlySpan<byte>.Empty, destination.AsSpan(0, i)));
+
+                for (int j = 0; j < destination.Length; j++)
+                {
+                    Assert.Equal(fill, destination[j]);
+                }
+            }
+        }
+
+        [Fact]
+        public void StaticVerifyOneShotSpanTooLongNoOverwrite()
+        {
+            Span<byte> buf = stackalloc byte[256];
+
+            for (int i = 10; i < 40; i++)
+            {
+                buf.Fill((byte)i);
+
+                int written = StaticOneShot(buf.Slice(0, i), buf.Slice(i));
+                Assert.Equal(_hashLengthInBytes, written);
+
+                for (int j = i + written; j < buf.Length; j++)
+                {
+                    Assert.Equal(i, buf[j]);
+                }
+            }
+        }
+
+        [Fact]
+        public void StaticVerifyTryOneShotSpanTooLongNoOverwrite()
+        {
+            Span<byte> buf = stackalloc byte[256];
+
+            for (int i = 10; i < 40; i++)
+            {
+                buf.Fill((byte)i);
+
+                Assert.True(TryStaticOneShot(buf.Slice(0, i), buf.Slice(i), out int written));
+                Assert.Equal(_hashLengthInBytes, written);
+
+                for (int j = i + written; j < buf.Length; j++)
+                {
+                    Assert.Equal(i, buf[j]);
+                }
+            }
+        }
+
+        [Fact]
+        public void StaticVerifyTryOneShotSpanTooShortNoWrites()
+        {
+            Span<byte> buf = stackalloc byte[256];
+
+            for (int i = 0; i < _hashLengthInBytes; i++)
+            {
+                byte fill = (byte)~i;
+                buf.Fill(fill);
+
+                Assert.False(TryStaticOneShot(ReadOnlySpan<byte>.Empty, buf.Slice(0, i), out int written));
+                Assert.Equal(0, written);
+
+                for (int j = 0; j < buf.Length; j++)
+                {
+                    Assert.Equal(fill, buf[j]);
+                }
+            }
+        }
+
+        private void VerifyEmptyResult(ReadOnlySpan<byte> result)
+        {
+            if (!result.SequenceEqual(_emptyHash))
+            {
+                // We know this will fail, but it gives a nice presentation.
+
+                Assert.Equal(
+                    _emptyHashHex ??= TestCase.ToHexString(_emptyHash),
+                    TestCase.ToHexString(result));
+            }
+        }
+
+        public sealed class TestCase
+        {
+            private byte[] _input;
+            private byte[] _output;
+
+            public string Name { get; }
+            public ReadOnlySpan<byte> Input => new ReadOnlySpan<byte>(_input);
+            public string OutputHex { get; }
+
+            public TestCase(string name, byte[] input, byte[] output)
+            {
+                Name = name;
+                _input = input;
+                OutputHex = ToHexString(output);
+                _output = FromHexString(OutputHex);
+            }
+
+            public TestCase(string name, byte[] input, string outputHex)
+            {
+                Name = name;
+                _input = input;
+                OutputHex = outputHex.ToUpperInvariant();
+                _output = FromHexString(OutputHex);
+            }
+
+            public TestCase(string name, string inputHex, string outputHex)
+            {
+                Name = name;
+                _input = FromHexString(inputHex);
+                OutputHex = outputHex.ToUpperInvariant();
+                _output = FromHexString(OutputHex);
+            }
+
+            internal void VerifyResponse(ReadOnlySpan<byte> response)
+            {
+                if (!response.SequenceEqual(_output))
+                {
+                    // We know this will fail, but it gives a nice presentation.
+                    Assert.Equal(OutputHex, ToHexString(response));
+                }
+            }
+
+            internal static string ToHexString(ReadOnlySpan<byte> input)
+            {
+#if NET5_0_OR_GREATER
+                return Convert.ToHexString(input);
+#else
+                var builder = new global::System.Text.StringBuilder(input.Length * 2);
+
+                foreach (byte b in input)
+                {
+                    builder.Append(b.ToString("X2"));
+                }
+
+                return builder.ToString();
+#endif
+            }
+
+            internal static byte[] FromHexString(string hexString)
+            {
+#if NET5_0_OR_GREATER
+                return Convert.FromHexString(hexString);
+#else
+                byte[] bytes = new byte[hexString.Length / 2];
+
+                for (int i = 0; i < hexString.Length; i += 2)
+                {
+                    string s = hexString.Substring(i, 2);
+                    bytes[i / 2] = byte.Parse(s, global::System.Globalization.NumberStyles.HexNumber, null);
+                }
+
+                return bytes;
+#endif
+            }
+
+            public override string ToString() => Name;
+        }
+    }
+}
diff --git a/src/libraries/System.IO.Hashing/tests/System.IO.Hashing.Tests.csproj b/src/libraries/System.IO.Hashing/tests/System.IO.Hashing.Tests.csproj
new file mode 100644
index 00000000000000..4c6b5621e3bb1e
--- /dev/null
+++ b/src/libraries/System.IO.Hashing/tests/System.IO.Hashing.Tests.csproj
@@ -0,0 +1,24 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <TargetFrameworks>$(NetCoreAppCurrent);net461</TargetFrameworks>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="Crc32Tests.cs" />
+    <Compile Include="Crc64Tests.cs" />
+    <Compile Include="NonCryptoHashBaseTests.cs" />
+    <Compile Include="NonCryptoHashTestDriver.cs" />
+    <Compile Include="XxHash32Tests.cs" />
+    <Compile Include="XxHash32Tests.007.cs" />
+    <Compile Include="XxHash32Tests.f00d.cs" />
+    <Compile Include="XxHash64Tests.cs" />
+    <Compile Include="XxHash64Tests.007.cs" />
+    <Compile Include="XxHash64Tests.f00d.cs" />
+    <Compile Include="$(CommonTestPath)System\IO\PositionValueStream.cs">
+      <Link>CommonTest\System\IO\PositionValueStream.cs</Link>
+    </Compile>
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\src\System.IO.Hashing.csproj" />
+  </ItemGroup>
+</Project>
diff --git a/src/libraries/System.IO.Hashing/tests/XxHash32Tests.007.cs b/src/libraries/System.IO.Hashing/tests/XxHash32Tests.007.cs
new file mode 100644
index 00000000000000..cf2e967d32a688
--- /dev/null
+++ b/src/libraries/System.IO.Hashing/tests/XxHash32Tests.007.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.Collections.Generic;
+using System.Text;
+using Xunit;
+
+namespace System.IO.Hashing.Tests
+{
+    public class XxHash32Tests_Seeded_007 : NonCryptoHashTestDriver
+    {
+        private int Seed = 0x007_007_00;
+
+        private static readonly byte[] s_emptyHashValue = new byte[] { 0xC4, 0xD2, 0x6D, 0x9A };
+
+        public XxHash32Tests_Seeded_007()
+            : base(s_emptyHashValue)
+        {
+        }
+
+        public static IEnumerable<object[]> TestCases
+        {
+            get
+            {
+                object[] arr = new object[1];
+
+                foreach (TestCase testCase in TestCaseDefinitions)
+                {
+                    arr[0] = testCase;
+                    yield return arr;
+                }
+            }
+        }
+
+        private const string DotNetHashesThis = ".NET Hashes This!";
+        private const string DotNetHashesThis3 = DotNetHashesThis + DotNetHashesThis + DotNetHashesThis;
+        private const string DotNetNCHashing = ".NET now has non-crypto hashing";
+        private const string DotNetNCHashing3 = DotNetNCHashing + DotNetNCHashing + DotNetNCHashing;
+
+        protected static IEnumerable<TestCase> TestCaseDefinitions { get; } =
+            new[]
+            {
+                // Same inputs as the main XxHash32 tests, but with the seed applied.
+                new TestCase(
+                    "Nobody inspects the spammish repetition",
+                    Encoding.ASCII.GetBytes("Nobody inspects the spammish repetition"),
+                    "21C69E3A"),
+                new TestCase(
+                    "The quick brown fox jumps over the lazy dog",
+                    Encoding.ASCII.GetBytes("The quick brown fox jumps over the lazy dog"),
+                    "558D024f"),
+                new TestCase(
+                    "The quick brown fox jumps over the lazy dog.",
+                    Encoding.ASCII.GetBytes("The quick brown fox jumps over the lazy dog."),
+                    "E7D2C0A7"),
+                new TestCase(
+                    "abc",
+                    Encoding.ASCII.GetBytes("abc"),
+                    "D46070BB"),
+                new TestCase(
+                    "123456",
+                    "313233343536",
+                    "4256C97B"),
+                new TestCase(
+                    "12345678901234567890",
+                    "3132333435363738393031323334353637383930",
+                    "A57B8FEE"),
+                new TestCase(
+                    "123456789012345678901",
+                    "313233343536373839303132333435363738393031",
+                    "6789AD70"),
+                new TestCase(
+                    $"{DotNetHashesThis} (x3)",
+                    Encoding.ASCII.GetBytes(DotNetHashesThis3),
+                    "C5231E05"),
+                new TestCase(
+                    $"{DotNetNCHashing} (x3)",
+                    Encoding.ASCII.GetBytes(DotNetNCHashing3),
+                    "CABC8ABD"),
+            };
+
+        protected override NonCryptographicHashAlgorithm CreateInstance() => new XxHash32(Seed);
+
+        protected override byte[] StaticOneShot(byte[] source) => XxHash32.Hash(source, Seed);
+
+        protected override byte[] StaticOneShot(ReadOnlySpan<byte> source) => XxHash32.Hash(source, Seed);
+
+        protected override int StaticOneShot(ReadOnlySpan<byte> source, Span<byte> destination) =>
+            XxHash32.Hash(source, destination, Seed);
+
+        protected override bool TryStaticOneShot(ReadOnlySpan<byte> source, Span<byte> destination, out int bytesWritten) =>
+            XxHash32.TryHash(source, destination, out bytesWritten, Seed);
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void InstanceAppendAllocate(TestCase testCase)
+        {
+            InstanceAppendAllocateDriver(testCase);
+        }
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void InstanceAppendAllocateAndReset(TestCase testCase)
+        {
+            InstanceAppendAllocateAndResetDriver(testCase);
+        }
+
+        [SkipOnCoreClr("https://github.com/dotnet/runtime/issues/54007", RuntimeConfiguration.Checked)]
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void InstanceMultiAppendGetCurrentHash(TestCase testCase)
+        {
+            InstanceMultiAppendGetCurrentHashDriver(testCase);
+        }
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void InstanceVerifyEmptyState(TestCase testCase)
+        {
+            InstanceVerifyEmptyStateDriver(testCase);
+        }
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void InstanceVerifyResetState(TestCase testCase)
+        {
+            InstanceVerifyResetStateDriver(testCase);
+        }
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void StaticVerifyOneShotArray(TestCase testCase)
+        {
+            StaticVerifyOneShotArrayDriver(testCase);
+        }
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void StaticVerifyOneShotSpanToArray(TestCase testCase)
+        {
+            StaticVerifyOneShotSpanToArrayDriver(testCase);
+        }
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void StaticVerifyOneShotSpanToSpan(TestCase testCase)
+        {
+            StaticVerifyOneShotSpanToSpanDriver(testCase);
+        }
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void StaticVerifyTryOneShot(TestCase testCase)
+        {
+            StaticVerifyTryOneShotDriver(testCase);
+        }
+    }
+}
diff --git a/src/libraries/System.IO.Hashing/tests/XxHash32Tests.cs b/src/libraries/System.IO.Hashing/tests/XxHash32Tests.cs
new file mode 100644
index 00000000000000..15c671d12bee98
--- /dev/null
+++ b/src/libraries/System.IO.Hashing/tests/XxHash32Tests.cs
@@ -0,0 +1,171 @@
+// 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.Text;
+using Xunit;
+
+namespace System.IO.Hashing.Tests
+{
+    public class XxHash32Tests : NonCryptoHashTestDriver
+    {
+        private static readonly byte[] s_emptyHashValue = new byte[] { 0x02, 0xCC, 0x5D, 0x05 };
+
+        public XxHash32Tests()
+            : base(s_emptyHashValue)
+        {
+        }
+
+        public static IEnumerable<object[]> TestCases
+        {
+            get
+            {
+                object[] arr = new object[1];
+
+                foreach (TestCase testCase in TestCaseDefinitions)
+                {
+                    arr[0] = testCase;
+                    yield return arr;
+                }
+            }
+        }
+
+        private const string DotNetHashesThis = ".NET Hashes This!";
+        private const string DotNetHashesThis3 = DotNetHashesThis + DotNetHashesThis + DotNetHashesThis;
+        private const string DotNetNCHashing = ".NET now has non-crypto hashing";
+        private const string DotNetNCHashing3 = DotNetNCHashing + DotNetNCHashing + DotNetNCHashing;
+
+        protected static IEnumerable<TestCase> TestCaseDefinitions { get; } =
+            new[]
+            {
+                //https://asecuritysite.com/encryption/xxHash, Example 1
+                new TestCase(
+                    "Nobody inspects the spammish repetition",
+                    Encoding.ASCII.GetBytes("Nobody inspects the spammish repetition"),
+                    "E2293B2F"),
+                //https://asecuritysite.com/encryption/xxHash, Example 2
+                new TestCase(
+                    "The quick brown fox jumps over the lazy dog",
+                    Encoding.ASCII.GetBytes("The quick brown fox jumps over the lazy dog"),
+                    "E85EA4DE"),
+                //https://asecuritysite.com/encryption/xxHash, Example 3
+                new TestCase(
+                    "The quick brown fox jumps over the lazy dog.",
+                    Encoding.ASCII.GetBytes("The quick brown fox jumps over the lazy dog."),
+                    "68D039C8"),
+
+                // Manual exploration to force boundary conditions in code coverage.
+                // Output values produced by existing tools.
+
+                // The "in three pieces" test causes this to build up in the accumulator every time.
+                new TestCase(
+                    "abc",
+                    Encoding.ASCII.GetBytes("abc"),
+                    "32D153FF"),
+                // Accumulates every time.
+                new TestCase(
+                    "123456",
+                    "313233343536",
+                    "B7014066"),
+                // In the 3 pieces test, the third call to Append fills and process the holdback,
+                // then stores the remainder.
+                new TestCase(
+                    "12345678901234567890",
+                    "3132333435363738393031323334353637383930",
+                    "2D0C3D1B"),
+                // Same as above, but ends up with a byte that doesn't align to uints.
+                new TestCase(
+                    "123456789012345678901",
+                    "313233343536373839303132333435363738393031",
+                    "8ED1B04E"),
+                // 17 * 3 bytes long, in the "in three pieces" test each call to Append processes
+                // a lane and holds one byte.
+                new TestCase(
+                    $"{DotNetHashesThis} (x3)",
+                    Encoding.ASCII.GetBytes(DotNetHashesThis3),
+                    "1FE08A04"),
+                // 31 * 3 bytes long.  In the "in three pieces" test the later calls to Append call
+                // into ProcessStripe with unaligned starts.
+                new TestCase(
+                    $"{DotNetNCHashing} (x3)",
+                    Encoding.ASCII.GetBytes(DotNetNCHashing3),
+                    "65242024"),
+            };
+
+        protected override NonCryptographicHashAlgorithm CreateInstance() => new XxHash32();
+
+        protected override byte[] StaticOneShot(byte[] source) => XxHash32.Hash(source);
+
+        protected override byte[] StaticOneShot(ReadOnlySpan<byte> source) => XxHash32.Hash(source);
+
+        protected override int StaticOneShot(ReadOnlySpan<byte> source, Span<byte> destination) =>
+            XxHash32.Hash(source, destination);
+
+        protected override bool TryStaticOneShot(ReadOnlySpan<byte> source, Span<byte> destination, out int bytesWritten) =>
+            XxHash32.TryHash(source, destination, out bytesWritten);
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void InstanceAppendAllocate(TestCase testCase)
+        {
+            InstanceAppendAllocateDriver(testCase);
+        }
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void InstanceAppendAllocateAndReset(TestCase testCase)
+        {
+            InstanceAppendAllocateAndResetDriver(testCase);
+        }
+
+        [SkipOnCoreClr("https://github.com/dotnet/runtime/issues/54007", RuntimeConfiguration.Checked)]
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void InstanceMultiAppendGetCurrentHash(TestCase testCase)
+        {
+            InstanceMultiAppendGetCurrentHashDriver(testCase);
+        }
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void InstanceVerifyEmptyState(TestCase testCase)
+        {
+            InstanceVerifyEmptyStateDriver(testCase);
+        }
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void InstanceVerifyResetState(TestCase testCase)
+        {
+            InstanceVerifyResetStateDriver(testCase);
+        }
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void StaticVerifyOneShotArray(TestCase testCase)
+        {
+            StaticVerifyOneShotArrayDriver(testCase);
+        }
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void StaticVerifyOneShotSpanToArray(TestCase testCase)
+        {
+            StaticVerifyOneShotSpanToArrayDriver(testCase);
+        }
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void StaticVerifyOneShotSpanToSpan(TestCase testCase)
+        {
+            StaticVerifyOneShotSpanToSpanDriver(testCase);
+        }
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void StaticVerifyTryOneShot(TestCase testCase)
+        {
+            StaticVerifyTryOneShotDriver(testCase);
+        }
+    }
+}
diff --git a/src/libraries/System.IO.Hashing/tests/XxHash32Tests.f00d.cs b/src/libraries/System.IO.Hashing/tests/XxHash32Tests.f00d.cs
new file mode 100644
index 00000000000000..007acd7655f559
--- /dev/null
+++ b/src/libraries/System.IO.Hashing/tests/XxHash32Tests.f00d.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.Collections.Generic;
+using System.Text;
+using Xunit;
+
+namespace System.IO.Hashing.Tests
+{
+    public class XxHash32Tests_Seeded_f00d : NonCryptoHashTestDriver
+    {
+        private int Seed = unchecked((int)0xF00D_F00D);
+
+        private static readonly byte[] s_emptyHashValue = new byte[] { 0x62, 0xB3, 0x2B, 0x9D };
+
+        public XxHash32Tests_Seeded_f00d()
+            : base(s_emptyHashValue)
+        {
+        }
+
+        public static IEnumerable<object[]> TestCases
+        {
+            get
+            {
+                object[] arr = new object[1];
+
+                foreach (TestCase testCase in TestCaseDefinitions)
+                {
+                    arr[0] = testCase;
+                    yield return arr;
+                }
+            }
+        }
+
+        private const string DotNetHashesThis = ".NET Hashes This!";
+        private const string DotNetHashesThis3 = DotNetHashesThis + DotNetHashesThis + DotNetHashesThis;
+        private const string DotNetNCHashing = ".NET now has non-crypto hashing";
+        private const string DotNetNCHashing3 = DotNetNCHashing + DotNetNCHashing + DotNetNCHashing;
+
+        protected static IEnumerable<TestCase> TestCaseDefinitions { get; } =
+            new[]
+            {
+                // Same inputs as the main XxHash32 tests, but with the seed applied.
+                new TestCase(
+                    "Nobody inspects the spammish repetition",
+                    Encoding.ASCII.GetBytes("Nobody inspects the spammish repetition"),
+                    "E8FF660B"),
+                new TestCase(
+                    "The quick brown fox jumps over the lazy dog",
+                    Encoding.ASCII.GetBytes("The quick brown fox jumps over the lazy dog"),
+                    "C2B00BA1"),
+                new TestCase(
+                    "The quick brown fox jumps over the lazy dog.",
+                    Encoding.ASCII.GetBytes("The quick brown fox jumps over the lazy dog."),
+                    "11AC3BD7"),
+                new TestCase(
+                    "abc",
+                    Encoding.ASCII.GetBytes("abc"),
+                    "BC85BB95"),
+                new TestCase(
+                    "123456",
+                    "313233343536",
+                    "F549D3A7"),
+                new TestCase(
+                    "12345678901234567890",
+                    "3132333435363738393031323334353637383930",
+                    "E6173FEA"),
+                new TestCase(
+                    "123456789012345678901",
+                    "313233343536373839303132333435363738393031",
+                    "5F086DF1"),
+                new TestCase(
+                    $"{DotNetHashesThis} (x3)",
+                    Encoding.ASCII.GetBytes(DotNetHashesThis3),
+                    "893F4A6F"),
+                new TestCase(
+                    $"{DotNetNCHashing} (x3)",
+                    Encoding.ASCII.GetBytes(DotNetNCHashing3),
+                    "5A513E6D"),
+            };
+
+        protected override NonCryptographicHashAlgorithm CreateInstance() => new XxHash32(Seed);
+
+        protected override byte[] StaticOneShot(byte[] source) => XxHash32.Hash(source, Seed);
+
+        protected override byte[] StaticOneShot(ReadOnlySpan<byte> source) => XxHash32.Hash(source, Seed);
+
+        protected override int StaticOneShot(ReadOnlySpan<byte> source, Span<byte> destination) =>
+            XxHash32.Hash(source, destination, Seed);
+
+        protected override bool TryStaticOneShot(ReadOnlySpan<byte> source, Span<byte> destination, out int bytesWritten) =>
+            XxHash32.TryHash(source, destination, out bytesWritten, Seed);
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void InstanceAppendAllocate(TestCase testCase)
+        {
+            InstanceAppendAllocateDriver(testCase);
+        }
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void InstanceAppendAllocateAndReset(TestCase testCase)
+        {
+            InstanceAppendAllocateAndResetDriver(testCase);
+        }
+
+        [SkipOnCoreClr("https://github.com/dotnet/runtime/issues/54007", RuntimeConfiguration.Checked)]
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void InstanceMultiAppendGetCurrentHash(TestCase testCase)
+        {
+            InstanceMultiAppendGetCurrentHashDriver(testCase);
+        }
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void InstanceVerifyEmptyState(TestCase testCase)
+        {
+            InstanceVerifyEmptyStateDriver(testCase);
+        }
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void InstanceVerifyResetState(TestCase testCase)
+        {
+            InstanceVerifyResetStateDriver(testCase);
+        }
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void StaticVerifyOneShotArray(TestCase testCase)
+        {
+            StaticVerifyOneShotArrayDriver(testCase);
+        }
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void StaticVerifyOneShotSpanToArray(TestCase testCase)
+        {
+            StaticVerifyOneShotSpanToArrayDriver(testCase);
+        }
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void StaticVerifyOneShotSpanToSpan(TestCase testCase)
+        {
+            StaticVerifyOneShotSpanToSpanDriver(testCase);
+        }
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void StaticVerifyTryOneShot(TestCase testCase)
+        {
+            StaticVerifyTryOneShotDriver(testCase);
+        }
+    }
+}
diff --git a/src/libraries/System.IO.Hashing/tests/XxHash64Tests.007.cs b/src/libraries/System.IO.Hashing/tests/XxHash64Tests.007.cs
new file mode 100644
index 00000000000000..4da264fb5ff103
--- /dev/null
+++ b/src/libraries/System.IO.Hashing/tests/XxHash64Tests.007.cs
@@ -0,0 +1,168 @@
+// 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.Text;
+using Xunit;
+
+namespace System.IO.Hashing.Tests
+{
+    public class XxHash64Tests_Seeded_007 : NonCryptoHashTestDriver
+    {
+        private long Seed = 0x007_007_007_007_007;
+
+        private static readonly byte[] s_emptyHashValue =
+            new byte[] { 0x62, 0xAD, 0xCA, 0xD4, 0xEC, 0x80, 0x84, 0x0E };
+
+        public XxHash64Tests_Seeded_007()
+            : base(s_emptyHashValue)
+        {
+        }
+
+        public static IEnumerable<object[]> TestCases
+        {
+            get
+            {
+                object[] arr = new object[1];
+
+                foreach (TestCase testCase in TestCaseDefinitions)
+                {
+                    arr[0] = testCase;
+                    yield return arr;
+                }
+            }
+        }
+
+        private const string ThirtyThreeBytes = "This string has 33 ASCII bytes...";
+        private const string ThirtyThreeBytes3 = ThirtyThreeBytes + ThirtyThreeBytes + ThirtyThreeBytes;
+        private const string DotNetNCHashing = ".NET now has non-crypto hashing";
+        private const string SixtyThreeBytes = "A sixty-three byte test input requires substantial forethought!";
+        private const string SixtyThreeBytes3 = SixtyThreeBytes + SixtyThreeBytes + SixtyThreeBytes;
+
+        protected static IEnumerable<TestCase> TestCaseDefinitions { get; } =
+            new[]
+            {
+                // Same inputs as the main XxHash64 tests, but with the seed applied.
+                new TestCase(
+                    "Nobody inspects the spammish repetition",
+                    Encoding.ASCII.GetBytes("Nobody inspects the spammish repetition"),
+                    "C86A41E2F34280A0"),
+                new TestCase(
+                    "The quick brown fox jumps over the lazy dog",
+                    Encoding.ASCII.GetBytes("The quick brown fox jumps over the lazy dog"),
+                    "BB05857F11B054EB"),
+                new TestCase(
+                    "The quick brown fox jumps over the lazy dog.",
+                    Encoding.ASCII.GetBytes("The quick brown fox jumps over the lazy dog."),
+                    "618682461CB28F83"),
+                new TestCase(
+                    "abc",
+                    Encoding.ASCII.GetBytes("abc"),
+                    "6BF4B26E3CA10C20"),
+                new TestCase(
+                    "123456",
+                    "313233343536",
+                    "CA35E96DF53D4962"),
+                new TestCase(
+                    "1234567890123456789012345678901234567890",
+                    "31323334353637383930313233343536373839303132333435363738393031323334353637383930",
+                    "FA3195B38205C088"),
+                new TestCase(
+                    "12345678901234567890123456789012345678901",
+                    "3132333435363738393031323334353637383930313233343536373839303132333435363738393031",
+                    "1980150281DF51A9"),
+                new TestCase(
+                    "12345678901234567890123456789012345678901234",
+                    "3132333435363738393031323334353637383930313233343536373839303132333435363738393031323334",
+                    "4AE47735FD53BF97"),
+                new TestCase(
+                    DotNetNCHashing,
+                    Encoding.ASCII.GetBytes(DotNetNCHashing),
+                    "D3ECF5BFE5F49B6F"),
+                new TestCase(
+                    $"{ThirtyThreeBytes} (x3)",
+                    Encoding.ASCII.GetBytes(ThirtyThreeBytes3),
+                    "27C38ACA51CD2684"),
+                new TestCase(
+                    $"{SixtyThreeBytes} (x3)",
+                    Encoding.ASCII.GetBytes(SixtyThreeBytes3),
+                    "D6095B93EB10BEDA"),
+            };
+
+        protected override NonCryptographicHashAlgorithm CreateInstance() => new XxHash64(Seed);
+
+        protected override byte[] StaticOneShot(byte[] source) => XxHash64.Hash(source, Seed);
+
+        protected override byte[] StaticOneShot(ReadOnlySpan<byte> source) => XxHash64.Hash(source, Seed);
+
+        protected override int StaticOneShot(ReadOnlySpan<byte> source, Span<byte> destination) =>
+            XxHash64.Hash(source, destination, Seed);
+
+        protected override bool TryStaticOneShot(ReadOnlySpan<byte> source, Span<byte> destination, out int bytesWritten) =>
+            XxHash64.TryHash(source, destination, out bytesWritten, Seed);
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void InstanceAppendAllocate(TestCase testCase)
+        {
+            InstanceAppendAllocateDriver(testCase);
+        }
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void InstanceAppendAllocateAndReset(TestCase testCase)
+        {
+            InstanceAppendAllocateAndResetDriver(testCase);
+        }
+
+        [SkipOnCoreClr("https://github.com/dotnet/runtime/issues/54007", RuntimeConfiguration.Checked)]
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void InstanceMultiAppendGetCurrentHash(TestCase testCase)
+        {
+            InstanceMultiAppendGetCurrentHashDriver(testCase);
+        }
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void InstanceVerifyEmptyState(TestCase testCase)
+        {
+            InstanceVerifyEmptyStateDriver(testCase);
+        }
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void InstanceVerifyResetState(TestCase testCase)
+        {
+            InstanceVerifyResetStateDriver(testCase);
+        }
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void StaticVerifyOneShotArray(TestCase testCase)
+        {
+            StaticVerifyOneShotArrayDriver(testCase);
+        }
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void StaticVerifyOneShotSpanToArray(TestCase testCase)
+        {
+            StaticVerifyOneShotSpanToArrayDriver(testCase);
+        }
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void StaticVerifyOneShotSpanToSpan(TestCase testCase)
+        {
+            StaticVerifyOneShotSpanToSpanDriver(testCase);
+        }
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void StaticVerifyTryOneShot(TestCase testCase)
+        {
+            StaticVerifyTryOneShotDriver(testCase);
+        }
+    }
+}
diff --git a/src/libraries/System.IO.Hashing/tests/XxHash64Tests.cs b/src/libraries/System.IO.Hashing/tests/XxHash64Tests.cs
new file mode 100644
index 00000000000000..39245a975d8785
--- /dev/null
+++ b/src/libraries/System.IO.Hashing/tests/XxHash64Tests.cs
@@ -0,0 +1,184 @@
+// 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.Text;
+using Xunit;
+
+namespace System.IO.Hashing.Tests
+{
+    public class XxHash64Tests : NonCryptoHashTestDriver
+    {
+        private static readonly byte[] s_emptyHashValue =
+            new byte[] { 0xEF, 0x46, 0xDB, 0x37, 0x51, 0xD8, 0xE9, 0x99 };
+
+        public XxHash64Tests()
+            : base(s_emptyHashValue)
+        {
+        }
+
+        public static IEnumerable<object[]> TestCases
+        {
+            get
+            {
+                object[] arr = new object[1];
+
+                foreach (TestCase testCase in TestCaseDefinitions)
+                {
+                    arr[0] = testCase;
+                    yield return arr;
+                }
+            }
+        }
+
+        private const string ThirtyThreeBytes = "This string has 33 ASCII bytes...";
+        private const string ThirtyThreeBytes3 = ThirtyThreeBytes + ThirtyThreeBytes + ThirtyThreeBytes;
+        private const string DotNetNCHashing = ".NET now has non-crypto hashing";
+        private const string SixtyThreeBytes = "A sixty-three byte test input requires substantial forethought!";
+        private const string SixtyThreeBytes3 = SixtyThreeBytes + SixtyThreeBytes + SixtyThreeBytes;
+
+        protected static IEnumerable<TestCase> TestCaseDefinitions { get; } =
+            new[]
+            {
+                //https://asecuritysite.com/encryption/xxHash, Example 1
+                new TestCase(
+                    "Nobody inspects the spammish repetition",
+                    Encoding.ASCII.GetBytes("Nobody inspects the spammish repetition"),
+                    "FBCEA83C8A378BF1"),
+                //https://asecuritysite.com/encryption/xxHash, Example 2
+                new TestCase(
+                    "The quick brown fox jumps over the lazy dog",
+                    Encoding.ASCII.GetBytes("The quick brown fox jumps over the lazy dog"),
+                    "0B242D361FDA71BC"),
+                //https://asecuritysite.com/encryption/xxHash, Example 3
+                new TestCase(
+                    "The quick brown fox jumps over the lazy dog.",
+                    Encoding.ASCII.GetBytes("The quick brown fox jumps over the lazy dog."),
+                    "44AD33705751AD73"),
+
+                // Manual exploration to force boundary conditions in code coverage.
+                // Output values produced by existing tools.
+
+                // The "in three pieces" test causes this to build up in the accumulator every time.
+                new TestCase(
+                    "abc",
+                    Encoding.ASCII.GetBytes("abc"),
+                    "44BC2CF5AD770999"),
+                // Accumulates every time.
+                new TestCase(
+                    "123456",
+                    "313233343536",
+                    "2B2DC38AAA53C322"),
+                // In the 3 pieces test, the third call to Append fills and process the holdback,
+                // then stores the remainder.
+                // The remainder is 40-32 = 8 bytes, so the Complete phase hits 1/0/0.
+                new TestCase(
+                    "1234567890123456789012345678901234567890",
+                    "31323334353637383930313233343536373839303132333435363738393031323334353637383930",
+                    "5F3AF5E23EEB431D"),
+                // Same as above, but ends up with a byte that doesn't align to ulongs (1/0/1)
+                new TestCase(
+                    "12345678901234567890123456789012345678901",
+                    "3132333435363738393031323334353637383930313233343536373839303132333435363738393031",
+                    "45A03ED59AB5CAD6"),
+                // Same as above, but ends up with a spare uint (1/1/0)
+                new TestCase(
+                    "12345678901234567890123456789012345678901234",
+                    "3132333435363738393031323334353637383930313233343536373839303132333435363738393031323334",
+                    "CA5C1B5B9061279F"),
+                // The maximum amount of remainder work, 31 bytes (3/1/3)
+                new TestCase(
+                    DotNetNCHashing,
+                    Encoding.ASCII.GetBytes(DotNetNCHashing),
+                    "D8444D7806DFDE0E"),
+                // 33 * 3 bytes long, in the "in three pieces" test each call to Append processes
+                // a lane and holds one byte.
+                new TestCase(
+                    $"{ThirtyThreeBytes} (x3)",
+                    Encoding.ASCII.GetBytes(ThirtyThreeBytes3),
+                    "488DF4E623587E10"),
+                // 63 * 3 bytes long.  In the "in three pieces" test the later calls to Append call
+                // into ProcessStripe with unaligned starts.
+                new TestCase(
+                    $"{SixtyThreeBytes} (x3)",
+                    Encoding.ASCII.GetBytes(SixtyThreeBytes3),
+                    "239C7B3A85BD22B3"),
+            };
+
+        protected override NonCryptographicHashAlgorithm CreateInstance() => new XxHash64();
+
+        protected override byte[] StaticOneShot(byte[] source) => XxHash64.Hash(source);
+
+        protected override byte[] StaticOneShot(ReadOnlySpan<byte> source) => XxHash64.Hash(source);
+
+        protected override int StaticOneShot(ReadOnlySpan<byte> source, Span<byte> destination) =>
+            XxHash64.Hash(source, destination);
+
+        protected override bool TryStaticOneShot(ReadOnlySpan<byte> source, Span<byte> destination, out int bytesWritten) =>
+            XxHash64.TryHash(source, destination, out bytesWritten);
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void InstanceAppendAllocate(TestCase testCase)
+        {
+            InstanceAppendAllocateDriver(testCase);
+        }
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void InstanceAppendAllocateAndReset(TestCase testCase)
+        {
+            InstanceAppendAllocateAndResetDriver(testCase);
+        }
+
+        [SkipOnCoreClr("https://github.com/dotnet/runtime/issues/54007", RuntimeConfiguration.Checked)]
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void InstanceMultiAppendGetCurrentHash(TestCase testCase)
+        {
+            InstanceMultiAppendGetCurrentHashDriver(testCase);
+        }
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void InstanceVerifyEmptyState(TestCase testCase)
+        {
+            InstanceVerifyEmptyStateDriver(testCase);
+        }
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void InstanceVerifyResetState(TestCase testCase)
+        {
+            InstanceVerifyResetStateDriver(testCase);
+        }
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void StaticVerifyOneShotArray(TestCase testCase)
+        {
+            StaticVerifyOneShotArrayDriver(testCase);
+        }
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void StaticVerifyOneShotSpanToArray(TestCase testCase)
+        {
+            StaticVerifyOneShotSpanToArrayDriver(testCase);
+        }
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void StaticVerifyOneShotSpanToSpan(TestCase testCase)
+        {
+            StaticVerifyOneShotSpanToSpanDriver(testCase);
+        }
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void StaticVerifyTryOneShot(TestCase testCase)
+        {
+            StaticVerifyTryOneShotDriver(testCase);
+        }
+    }
+}
diff --git a/src/libraries/System.IO.Hashing/tests/XxHash64Tests.f00d.cs b/src/libraries/System.IO.Hashing/tests/XxHash64Tests.f00d.cs
new file mode 100644
index 00000000000000..79d370e93d197c
--- /dev/null
+++ b/src/libraries/System.IO.Hashing/tests/XxHash64Tests.f00d.cs
@@ -0,0 +1,168 @@
+// 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.Text;
+using Xunit;
+
+namespace System.IO.Hashing.Tests
+{
+    public class XxHash64Tests_Seeded_f00d : NonCryptoHashTestDriver
+    {
+        private long Seed = unchecked((long)0xF00D_F00D_F00D_F00D);
+
+        private static readonly byte[] s_emptyHashValue =
+            new byte[] { 0x01, 0x3F, 0x6A, 0x1B, 0xB3, 0x9C, 0x10, 0x87 };
+
+        public XxHash64Tests_Seeded_f00d()
+            : base(s_emptyHashValue)
+        {
+        }
+
+        public static IEnumerable<object[]> TestCases
+        {
+            get
+            {
+                object[] arr = new object[1];
+
+                foreach (TestCase testCase in TestCaseDefinitions)
+                {
+                    arr[0] = testCase;
+                    yield return arr;
+                }
+            }
+        }
+
+        private const string ThirtyThreeBytes = "This string has 33 ASCII bytes...";
+        private const string ThirtyThreeBytes3 = ThirtyThreeBytes + ThirtyThreeBytes + ThirtyThreeBytes;
+        private const string DotNetNCHashing = ".NET now has non-crypto hashing";
+        private const string SixtyThreeBytes = "A sixty-three byte test input requires substantial forethought!";
+        private const string SixtyThreeBytes3 = SixtyThreeBytes + SixtyThreeBytes + SixtyThreeBytes;
+
+        protected static IEnumerable<TestCase> TestCaseDefinitions { get; } =
+            new[]
+            {
+                // Same inputs as the main XxHash64 tests, but with the seed applied.
+                new TestCase(
+                    "Nobody inspects the spammish repetition",
+                    Encoding.ASCII.GetBytes("Nobody inspects the spammish repetition"),
+                    "76E6275980CF4E30"),
+                new TestCase(
+                    "The quick brown fox jumps over the lazy dog",
+                    Encoding.ASCII.GetBytes("The quick brown fox jumps over the lazy dog"),
+                    "5CC25b2B8248DF76"),
+                new TestCase(
+                    "The quick brown fox jumps over the lazy dog.",
+                    Encoding.ASCII.GetBytes("The quick brown fox jumps over the lazy dog."),
+                    "10E8D9E4DA841407"),
+                new TestCase(
+                    "abc",
+                    Encoding.ASCII.GetBytes("abc"),
+                    "AE9DA0E407940A85"),
+                new TestCase(
+                    "123456",
+                    "313233343536",
+                    "99E249386C1EB47D"),
+                new TestCase(
+                    "1234567890123456789012345678901234567890",
+                    "31323334353637383930313233343536373839303132333435363738393031323334353637383930",
+                    "0DA1BD86FAAA1BC8"),
+                new TestCase(
+                    "12345678901234567890123456789012345678901",
+                    "3132333435363738393031323334353637383930313233343536373839303132333435363738393031",
+                    "913DFB6C43C01EB3"),
+                new TestCase(
+                    "12345678901234567890123456789012345678901234",
+                    "3132333435363738393031323334353637383930313233343536373839303132333435363738393031323334",
+                    "F15334D3BCFC5841"),
+                new TestCase(
+                    DotNetNCHashing,
+                    Encoding.ASCII.GetBytes(DotNetNCHashing),
+                    "C5551996D9F3737F"),
+                new TestCase(
+                    $"{ThirtyThreeBytes} (x3)",
+                    Encoding.ASCII.GetBytes(ThirtyThreeBytes3),
+                    "6BD086C0CC425D9F"),
+                new TestCase(
+                    $"{SixtyThreeBytes} (x3)",
+                    Encoding.ASCII.GetBytes(SixtyThreeBytes3),
+                    "6F1C62EB48EA2FEC"),
+            };
+
+        protected override NonCryptographicHashAlgorithm CreateInstance() => new XxHash64(Seed);
+
+        protected override byte[] StaticOneShot(byte[] source) => XxHash64.Hash(source, Seed);
+
+        protected override byte[] StaticOneShot(ReadOnlySpan<byte> source) => XxHash64.Hash(source, Seed);
+
+        protected override int StaticOneShot(ReadOnlySpan<byte> source, Span<byte> destination) =>
+            XxHash64.Hash(source, destination, Seed);
+
+        protected override bool TryStaticOneShot(ReadOnlySpan<byte> source, Span<byte> destination, out int bytesWritten) =>
+            XxHash64.TryHash(source, destination, out bytesWritten, Seed);
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void InstanceAppendAllocate(TestCase testCase)
+        {
+            InstanceAppendAllocateDriver(testCase);
+        }
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void InstanceAppendAllocateAndReset(TestCase testCase)
+        {
+            InstanceAppendAllocateAndResetDriver(testCase);
+        }
+
+        [SkipOnCoreClr("https://github.com/dotnet/runtime/issues/54007", RuntimeConfiguration.Checked)]
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void InstanceMultiAppendGetCurrentHash(TestCase testCase)
+        {
+            InstanceMultiAppendGetCurrentHashDriver(testCase);
+        }
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void InstanceVerifyEmptyState(TestCase testCase)
+        {
+            InstanceVerifyEmptyStateDriver(testCase);
+        }
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void InstanceVerifyResetState(TestCase testCase)
+        {
+            InstanceVerifyResetStateDriver(testCase);
+        }
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void StaticVerifyOneShotArray(TestCase testCase)
+        {
+            StaticVerifyOneShotArrayDriver(testCase);
+        }
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void StaticVerifyOneShotSpanToArray(TestCase testCase)
+        {
+            StaticVerifyOneShotSpanToArrayDriver(testCase);
+        }
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void StaticVerifyOneShotSpanToSpan(TestCase testCase)
+        {
+            StaticVerifyOneShotSpanToSpanDriver(testCase);
+        }
+
+        [Theory]
+        [MemberData(nameof(TestCases))]
+        public void StaticVerifyTryOneShot(TestCase testCase)
+        {
+            StaticVerifyTryOneShotDriver(testCase);
+        }
+    }
+}
diff --git a/src/libraries/System.IO.MemoryMappedFiles/src/System/IO/MemoryMappedFiles/Interop.Windows.cs b/src/libraries/System.IO.MemoryMappedFiles/src/System/IO/MemoryMappedFiles/Interop.Windows.cs
index 202c3ead180f2c..d30e42c558a63a 100644
--- a/src/libraries/System.IO.MemoryMappedFiles/src/System/IO/MemoryMappedFiles/Interop.Windows.cs
+++ b/src/libraries/System.IO.MemoryMappedFiles/src/System/IO/MemoryMappedFiles/Interop.Windows.cs
@@ -13,7 +13,7 @@ public static unsafe void CheckForAvailableVirtualMemory(ulong nativeSize)
     {
         Interop.Kernel32.MEMORYSTATUSEX memoryStatus = default;
         memoryStatus.dwLength = (uint)sizeof(Interop.Kernel32.MEMORYSTATUSEX);
-        if (Interop.Kernel32.GlobalMemoryStatusEx(ref memoryStatus))
+        if (Interop.Kernel32.GlobalMemoryStatusEx(&memoryStatus) != Interop.BOOL.FALSE)
         {
             ulong totalVirtual = memoryStatus.ullTotalVirtual;
             if (nativeSize >= totalVirtual)
diff --git a/src/libraries/System.IO.MemoryMappedFiles/tests/MemoryMappedFile.CrossProcess.cs b/src/libraries/System.IO.MemoryMappedFiles/tests/MemoryMappedFile.CrossProcess.cs
index 61e5b9eb92b89e..fa8f454e3052eb 100644
--- a/src/libraries/System.IO.MemoryMappedFiles/tests/MemoryMappedFile.CrossProcess.cs
+++ b/src/libraries/System.IO.MemoryMappedFiles/tests/MemoryMappedFile.CrossProcess.cs
@@ -9,7 +9,6 @@ namespace System.IO.MemoryMappedFiles.Tests
     public class CrossProcessTests : FileCleanupTestBase
     {
         [ConditionalFact(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
         public void DataShared()
         {
             // Create a new file and load it into an MMF
diff --git a/src/libraries/System.IO.Packaging/tests/Tests.cs b/src/libraries/System.IO.Packaging/tests/Tests.cs
index 386523d0ee15e5..8dd92b410ba202 100644
--- a/src/libraries/System.IO.Packaging/tests/Tests.cs
+++ b/src/libraries/System.IO.Packaging/tests/Tests.cs
@@ -3823,9 +3823,15 @@ public void VeryLargePart()
                         byte[] readBuffer = new byte[buffer.Length];
                         for (long i = 0; i < SizeInMb; i++)
                         {
-                            int actualRead = partStream.Read(readBuffer, 0, readBuffer.Length);
+                            int totalRead = 0;
+                            while (totalRead < readBuffer.Length)
+                            {
+                                int actualRead = partStream.Read(readBuffer, totalRead, readBuffer.Length - totalRead);
+                                Assert.InRange(actualRead, 1, readBuffer.Length - totalRead);
+                                totalRead += actualRead;
+                            }
 
-                            Assert.Equal(actualRead, readBuffer.Length);
+                            Assert.Equal(readBuffer.Length, totalRead);
                             Assert.True(buffer.AsSpan().SequenceEqual(readBuffer));
                         }
                     }
diff --git a/src/libraries/System.IO.Pipelines/ref/System.IO.Pipelines.cs b/src/libraries/System.IO.Pipelines/ref/System.IO.Pipelines.cs
index 28a8f6d4286748..fda8e715aa2499 100644
--- a/src/libraries/System.IO.Pipelines/ref/System.IO.Pipelines.cs
+++ b/src/libraries/System.IO.Pipelines/ref/System.IO.Pipelines.cs
@@ -71,6 +71,7 @@ protected PipeWriter() { }
         public abstract void Advance(int bytes);
         public virtual System.IO.Stream AsStream(bool leaveOpen = false) { throw null; }
         public abstract void CancelPendingFlush();
+        public virtual bool CanGetUnflushedBytes => throw null;
         public abstract void Complete(System.Exception? exception = null);
         public virtual System.Threading.Tasks.ValueTask CompleteAsync(System.Exception? exception = null) { throw null; }
         protected internal virtual System.Threading.Tasks.Task CopyFromAsync(System.IO.Stream source, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
@@ -80,6 +81,7 @@ protected PipeWriter() { }
         public abstract System.Span<byte> GetSpan(int sizeHint = 0);
         [System.ObsoleteAttribute("OnReaderCompleted may not be invoked on all implementations of PipeWriter. This will be removed in a future release.")]
         public virtual void OnReaderCompleted(System.Action<System.Exception?, object?> callback, object? state) { }
+        public virtual long UnflushedBytes => throw null;
         public virtual System.Threading.Tasks.ValueTask<System.IO.Pipelines.FlushResult> WriteAsync(System.ReadOnlyMemory<byte> source, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
     }
     public readonly partial struct ReadResult
diff --git a/src/libraries/System.IO.Pipelines/ref/System.IO.Pipelines.csproj b/src/libraries/System.IO.Pipelines/ref/System.IO.Pipelines.csproj
index 507822d2232246..e51795c34c50df 100644
--- a/src/libraries/System.IO.Pipelines/ref/System.IO.Pipelines.csproj
+++ b/src/libraries/System.IO.Pipelines/ref/System.IO.Pipelines.csproj
@@ -2,9 +2,9 @@
   <PropertyGroup>
     <TargetFrameworks>$(NetCoreAppCurrent);netcoreapp3.1;netstandard2.0;net461</TargetFrameworks>
     <Nullable>enable</Nullable>
-    <!-- We only plan to use this ref in netcoreapp. For all other netstandard compatible frameworks
+    <!-- We only plan to use this ref on .NETCoreApp. For all other netstandard compatible frameworks
     we should use the lib asset instead. -->
-    <ExcludeFromPackage Condition="'$(TargetFramework)' != 'netcoreapp3.1'">true</ExcludeFromPackage>
+    <ExcludeFromPackage Condition="$([MSBuild]::GetTargetFrameworkIdentifier('$(TargetFramework)')) != '.NETCoreApp'">true</ExcludeFromPackage>
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="System.IO.Pipelines.cs" />
diff --git a/src/libraries/System.IO.Pipelines/src/Resources/Strings.resx b/src/libraries/System.IO.Pipelines/src/Resources/Strings.resx
index 457f167172113f..ab5264d0a42059 100644
--- a/src/libraries/System.IO.Pipelines/src/Resources/Strings.resx
+++ b/src/libraries/System.IO.Pipelines/src/Resources/Strings.resx
@@ -168,4 +168,7 @@
   <data name="WritingAfterCompleted" xml:space="preserve">
     <value>Writing is not allowed after writer was completed.</value>
   </data>
+  <data name="UnflushedBytesNotSupported" xml:space="preserve">
+    <value>UnflushedBytes is not supported.</value>
+  </data>
 </root>
\ No newline at end of file
diff --git a/src/libraries/System.IO.Pipelines/src/System.IO.Pipelines.csproj b/src/libraries/System.IO.Pipelines/src/System.IO.Pipelines.csproj
index 3357c47c3b7b66..be3d6242126f58 100644
--- a/src/libraries/System.IO.Pipelines/src/System.IO.Pipelines.csproj
+++ b/src/libraries/System.IO.Pipelines/src/System.IO.Pipelines.csproj
@@ -1,7 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <TargetFrameworks>$(NetCoreAppCurrent);netcoreapp3.1;netstandard2.0;net461</TargetFrameworks>
-    <ExcludeCurrentNetCoreAppFromPackage>true</ExcludeCurrentNetCoreAppFromPackage>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
     <Nullable>enable</Nullable>
   </PropertyGroup>
diff --git a/src/libraries/System.IO.Pipelines/src/System/IO/Pipelines/Pipe.DefaultPipeWriter.cs b/src/libraries/System.IO.Pipelines/src/System/IO/Pipelines/Pipe.DefaultPipeWriter.cs
index d566d7be30d52a..f4ec8a3b12254d 100644
--- a/src/libraries/System.IO.Pipelines/src/System/IO/Pipelines/Pipe.DefaultPipeWriter.cs
+++ b/src/libraries/System.IO.Pipelines/src/System/IO/Pipelines/Pipe.DefaultPipeWriter.cs
@@ -23,6 +23,8 @@ public DefaultPipeWriter(Pipe pipe)
 
             public override void CancelPendingFlush() => _pipe.CancelPendingFlush();
 
+            public override bool CanGetUnflushedBytes => true;
+
 #pragma warning disable CS0672 // Member overrides obsolete member
             public override void OnReaderCompleted(Action<Exception?, object?> callback, object? state) => _pipe.OnReaderCompleted(callback, state);
 #pragma warning restore CS0672 // Member overrides obsolete member
@@ -41,6 +43,8 @@ public DefaultPipeWriter(Pipe pipe)
 
             public void OnCompleted(Action<object?> continuation, object? state, short token, ValueTaskSourceOnCompletedFlags flags) => _pipe.OnFlushAsyncCompleted(continuation, state, flags);
 
+            public override long UnflushedBytes => _pipe.GetUnflushedBytes();
+
             public override ValueTask<FlushResult> WriteAsync(ReadOnlyMemory<byte> source, CancellationToken cancellationToken = default)
             {
                 return _pipe.WriteAsync(source, cancellationToken);
diff --git a/src/libraries/System.IO.Pipelines/src/System/IO/Pipelines/Pipe.cs b/src/libraries/System.IO.Pipelines/src/System/IO/Pipelines/Pipe.cs
index 14f0092125ad4e..9a0f5802d7dba0 100644
--- a/src/libraries/System.IO.Pipelines/src/System/IO/Pipelines/Pipe.cs
+++ b/src/libraries/System.IO.Pipelines/src/System/IO/Pipelines/Pipe.cs
@@ -664,6 +664,11 @@ internal ValueTask<ReadResult> ReadAtLeastAsync(int minimumBytes, CancellationTo
                 ThrowHelper.ThrowInvalidOperationException_NoReadingAllowed();
             }
 
+            if (token.IsCancellationRequested)
+            {
+                return new ValueTask<ReadResult>(Task.FromCanceled<ReadResult>(token));
+            }
+
             CompletionData completionData = default;
             ValueTask<ReadResult> result;
             lock (SyncObj)
@@ -715,6 +720,11 @@ internal ValueTask<ReadResult> ReadAsync(CancellationToken token)
                 ThrowHelper.ThrowInvalidOperationException_NoReadingAllowed();
             }
 
+            if (token.IsCancellationRequested)
+            {
+                return new ValueTask<ReadResult>(Task.FromCanceled<ReadResult>(token));
+            }
+
             ValueTask<ReadResult> result;
             lock (SyncObj)
             {
@@ -999,6 +1009,8 @@ internal FlushResult GetFlushAsyncResult()
             return result;
         }
 
+        internal long GetUnflushedBytes() => _unflushedBytes;
+
         private void GetFlushResult(ref FlushResult result)
         {
             // Change the state from to be canceled -> observed
diff --git a/src/libraries/System.IO.Pipelines/src/System/IO/Pipelines/PipeWriter.cs b/src/libraries/System.IO.Pipelines/src/System/IO/Pipelines/PipeWriter.cs
index 23eaf2d32559a3..f89b50ef8eb473 100644
--- a/src/libraries/System.IO.Pipelines/src/System/IO/Pipelines/PipeWriter.cs
+++ b/src/libraries/System.IO.Pipelines/src/System/IO/Pipelines/PipeWriter.cs
@@ -36,6 +36,10 @@ public virtual ValueTask CompleteAsync(Exception? exception = null)
         /// <remarks>The canceled <see cref="System.IO.Pipelines.PipeWriter.FlushAsync(System.Threading.CancellationToken)" /> or <see cref="System.IO.Pipelines.PipeWriter.WriteAsync(System.ReadOnlyMemory{byte},System.Threading.CancellationToken)" /> operation returns a <see cref="System.IO.Pipelines.FlushResult" /> where <see cref="System.IO.Pipelines.FlushResult.IsCanceled" /> is <see langword="true" />.</remarks>
         public abstract void CancelPendingFlush();
 
+        /// <summary>Gets a value that indicates whether the current <see cref="System.IO.Pipelines.PipeWriter" /> supports reporting the count of unflushed bytes.</summary>
+        /// <value><see langword="true" />If a class derived from <see cref="System.IO.Pipelines.PipeWriter" /> does not support getting the unflushed bytes, calls to <see cref="System.IO.Pipelines.PipeWriter.UnflushedBytes" /> throw <see cref="System.NotImplementedException" />.</value>
+        public virtual bool CanGetUnflushedBytes => false;
+
         /// <summary>Registers a callback that executes when the <see cref="System.IO.Pipelines.PipeReader" /> side of the pipe is completed.</summary>
         /// <param name="callback">The callback to register.</param>
         /// <param name="state">The state object to pass to <paramref name="callback" /> when it's invoked.</param>
@@ -143,5 +147,11 @@ protected internal virtual async Task CopyFromAsync(Stream source, CancellationT
                 }
             }
         }
+
+        /// <summary>
+        /// When overridden in a derived class, gets the count of unflushed bytes within the current writer.
+        /// </summary>
+        /// <exception cref="System.NotImplementedException">The <see cref="System.IO.Pipelines.PipeWriter"/> does not support getting the unflushed byte count.</exception>
+        public virtual long UnflushedBytes => throw ThrowHelper.CreateNotSupportedException_UnflushedBytes();
     }
 }
diff --git a/src/libraries/System.IO.Pipelines/src/System/IO/Pipelines/StreamPipeReader.cs b/src/libraries/System.IO.Pipelines/src/System/IO/Pipelines/StreamPipeReader.cs
index ccafce22367329..7b33539b540b33 100644
--- a/src/libraries/System.IO.Pipelines/src/System/IO/Pipelines/StreamPipeReader.cs
+++ b/src/libraries/System.IO.Pipelines/src/System/IO/Pipelines/StreamPipeReader.cs
@@ -194,7 +194,10 @@ public override ValueTask<ReadResult> ReadAsync(CancellationToken cancellationTo
             // TODO ReadyAsync needs to throw if there are overlapping reads.
             ThrowIfCompleted();
 
-            cancellationToken.ThrowIfCancellationRequested();
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return new ValueTask<ReadResult>(Task.FromCanceled<ReadResult>(cancellationToken));
+            }
 
             // PERF: store InternalTokenSource locally to avoid querying it twice (which acquires a lock)
             CancellationTokenSource tokenSource = InternalTokenSource;
@@ -273,7 +276,10 @@ protected override ValueTask<ReadResult> ReadAtLeastAsyncCore(int minimumSize, C
             // TODO ReadyAsync needs to throw if there are overlapping reads.
             ThrowIfCompleted();
 
-            cancellationToken.ThrowIfCancellationRequested();
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return new ValueTask<ReadResult>(Task.FromCanceled<ReadResult>(cancellationToken));
+            }
 
             // PERF: store InternalTokenSource locally to avoid querying it twice (which acquires a lock)
             CancellationTokenSource tokenSource = InternalTokenSource;
diff --git a/src/libraries/System.IO.Pipelines/src/System/IO/Pipelines/StreamPipeWriter.cs b/src/libraries/System.IO.Pipelines/src/System/IO/Pipelines/StreamPipeWriter.cs
index 80c4d77388d4ec..38de6ffad46b47 100644
--- a/src/libraries/System.IO.Pipelines/src/System/IO/Pipelines/StreamPipeWriter.cs
+++ b/src/libraries/System.IO.Pipelines/src/System/IO/Pipelines/StreamPipeWriter.cs
@@ -205,6 +205,9 @@ public override void CancelPendingFlush()
             Cancel();
         }
 
+        /// <inheritdoc />
+        public override bool CanGetUnflushedBytes => true;
+
         /// <inheritdoc />
         public override void Complete(Exception? exception = null)
         {
@@ -259,6 +262,9 @@ public override ValueTask<FlushResult> FlushAsync(CancellationToken cancellation
             return FlushAsyncInternal(writeToStream: true, data: Memory<byte>.Empty, cancellationToken);
         }
 
+        /// <inheritdoc />
+        public override long UnflushedBytes => _bytesBuffered;
+
         public override ValueTask<FlushResult> WriteAsync(ReadOnlyMemory<byte> source, CancellationToken cancellationToken = default)
         {
             return FlushAsyncInternal(writeToStream: true, data: source, cancellationToken);
diff --git a/src/libraries/System.IO.Pipelines/src/System/IO/Pipelines/ThrowHelper.cs b/src/libraries/System.IO.Pipelines/src/System/IO/Pipelines/ThrowHelper.cs
index ff3ce6923a67db..0fb31686d65d21 100644
--- a/src/libraries/System.IO.Pipelines/src/System/IO/Pipelines/ThrowHelper.cs
+++ b/src/libraries/System.IO.Pipelines/src/System/IO/Pipelines/ThrowHelper.cs
@@ -83,6 +83,11 @@ internal static class ThrowHelper
         public static void ThrowInvalidOperationException_InvalidZeroByteRead() => throw CreateInvalidOperationException_InvalidZeroByteRead();
         [MethodImpl(MethodImplOptions.NoInlining)]
         public static Exception CreateInvalidOperationException_InvalidZeroByteRead() => new InvalidOperationException(SR.InvalidZeroByteRead);
+
+        [DoesNotReturn]
+        public static void ThrowNotSupported_UnflushedBytes() => throw CreateNotSupportedException_UnflushedBytes();
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public static Exception CreateNotSupportedException_UnflushedBytes() => new NotSupportedException(SR.UnflushedBytesNotSupported);
     }
 
     internal enum ExceptionArgument
diff --git a/src/libraries/System.IO.Pipelines/tests/FlushAsyncTests.cs b/src/libraries/System.IO.Pipelines/tests/FlushAsyncTests.cs
index b95d49c473502e..9647a47055b186 100644
--- a/src/libraries/System.IO.Pipelines/tests/FlushAsyncTests.cs
+++ b/src/libraries/System.IO.Pipelines/tests/FlushAsyncTests.cs
@@ -22,7 +22,7 @@ public void FlushAsync_ReturnsCompletedTaskWhenMaxSizeIfZero()
         }
 
         [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/50959", typeof(PlatformDetection), nameof(PlatformDetection.IsBrowser), nameof(PlatformDetection.IsMonoAOT))]
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/50957", typeof(PlatformDetection), nameof(PlatformDetection.IsBrowser), nameof(PlatformDetection.IsMonoAOT))]
         public async Task FlushAsync_ThrowsIfWriterReaderWithException()
         {
             void ThrowTestException()
diff --git a/src/libraries/System.IO.Pipelines/tests/PipeReaderCopyToAsyncTests.cs b/src/libraries/System.IO.Pipelines/tests/PipeReaderCopyToAsyncTests.cs
index 2076d4ea66e153..e58e5af4e70598 100644
--- a/src/libraries/System.IO.Pipelines/tests/PipeReaderCopyToAsyncTests.cs
+++ b/src/libraries/System.IO.Pipelines/tests/PipeReaderCopyToAsyncTests.cs
@@ -178,7 +178,7 @@ public async Task CancelingBetweenReadsThrowsOperationCancelledException()
             Pipe.Writer.WriteEmpty(10);
             await Pipe.Writer.FlushAsync();
 
-            await Assert.ThrowsAsync<OperationCanceledException>(() => task);
+            await Assert.ThrowsAsync<TaskCanceledException>(() => task);
         }
 
         [Fact]
diff --git a/src/libraries/System.IO.Pipelines/tests/PipeReaderReadAtLeastAsyncTests.cs b/src/libraries/System.IO.Pipelines/tests/PipeReaderReadAtLeastAsyncTests.cs
index c2aaea3c29993a..c12d3b88253cfa 100644
--- a/src/libraries/System.IO.Pipelines/tests/PipeReaderReadAtLeastAsyncTests.cs
+++ b/src/libraries/System.IO.Pipelines/tests/PipeReaderReadAtLeastAsyncTests.cs
@@ -141,7 +141,8 @@ public async Task CanReadAtLeast(int bufferSize, bool bufferedRead)
         [Fact]
         public Task ReadAtLeastAsyncThrowsIfPassedCanceledCancellationToken()
         {
-            return Assert.ThrowsAsync<OperationCanceledException>(async () => await PipeReader.ReadAtLeastAsync(0, new CancellationToken(true)));
+            ValueTask<ReadResult> task = PipeReader.ReadAtLeastAsync(0, new CancellationToken(canceled: true));
+            return Assert.ThrowsAsync<TaskCanceledException>(async () => await task);
         }
 
         [Fact]
diff --git a/src/libraries/System.IO.Pipelines/tests/PipeReaderWriterFacts.cs b/src/libraries/System.IO.Pipelines/tests/PipeReaderWriterFacts.cs
index 8ffe91e91f5b8d..dc4593bfeb0db2 100644
--- a/src/libraries/System.IO.Pipelines/tests/PipeReaderWriterFacts.cs
+++ b/src/libraries/System.IO.Pipelines/tests/PipeReaderWriterFacts.cs
@@ -215,7 +215,7 @@ void ThrowTestException(Exception ex, Action<Exception> catchAction)
         }
 
         [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/50959", typeof(PlatformDetection), nameof(PlatformDetection.IsBrowser), nameof(PlatformDetection.IsMonoAOT))]
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/50957", typeof(PlatformDetection), nameof(PlatformDetection.IsBrowser), nameof(PlatformDetection.IsMonoAOT))]
         public async Task ReadAsync_ThrowsIfWriterCompletedWithException()
         {
             ThrowTestException(new InvalidOperationException("Writer exception"), e => _pipe.Writer.Complete(e));
@@ -234,7 +234,7 @@ public async Task ReadAsync_ThrowsIfWriterCompletedWithException()
         }
 
         [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/50959", typeof(PlatformDetection), nameof(PlatformDetection.IsBrowser), nameof(PlatformDetection.IsMonoAOT))]
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/50957", typeof(PlatformDetection), nameof(PlatformDetection.IsBrowser), nameof(PlatformDetection.IsMonoAOT))]
         public async Task WriteAsync_ThrowsIfReaderCompletedWithException()
         {
             ThrowTestException(new InvalidOperationException("Reader exception"), e => _pipe.Reader.Complete(e));
diff --git a/src/libraries/System.IO.Pipelines/tests/PipeWriterTests.cs b/src/libraries/System.IO.Pipelines/tests/PipeWriterTests.cs
index 0abdfa252da78d..8d94e720bf12c8 100644
--- a/src/libraries/System.IO.Pipelines/tests/PipeWriterTests.cs
+++ b/src/libraries/System.IO.Pipelines/tests/PipeWriterTests.cs
@@ -197,7 +197,7 @@ public async Task WritesUsingGetSpanWorks()
 
             await writer.FlushAsync();
             writer.Complete();
-
+            Assert.Equal(0, writer.UnflushedBytes);
             ReadResult readResult = await pipe.Reader.ReadAsync();
             Assert.Equal(bytes, readResult.Buffer.ToArray());
             pipe.Reader.AdvanceTo(readResult.Buffer.End);
@@ -220,7 +220,7 @@ public async Task WritesUsingGetMemoryWorks()
 
             await writer.FlushAsync();
             writer.Complete();
-
+            Assert.Equal(0, writer.UnflushedBytes);
             ReadResult readResult = await pipe.Reader.ReadAsync();
             Assert.Equal(bytes, readResult.Buffer.ToArray());
             pipe.Reader.AdvanceTo(readResult.Buffer.End);
@@ -290,6 +290,7 @@ public async Task GetMemoryFlushWithACompletedReaderNoops()
             Assert.Equal(1, pool.CurrentlyRentedBlocks);
             pipe.Writer.Complete();
             Assert.Equal(0, pool.CurrentlyRentedBlocks);
+            Assert.Equal(0, Pipe.Writer.UnflushedBytes);
         }
     }
 }
diff --git a/src/libraries/System.IO.Pipelines/tests/ReadAsyncCancellationTests.cs b/src/libraries/System.IO.Pipelines/tests/ReadAsyncCancellationTests.cs
index 0e9fe23999d82b..8422de30735845 100644
--- a/src/libraries/System.IO.Pipelines/tests/ReadAsyncCancellationTests.cs
+++ b/src/libraries/System.IO.Pipelines/tests/ReadAsyncCancellationTests.cs
@@ -362,12 +362,10 @@ public void ReadAsyncReturnsIsCancelOnCancelPendingReadBeforeGetResult()
         }
 
         [Fact]
-        public void ReadAsyncThrowsIfPassedCanceledCancellationToken()
+        public Task ReadAsyncThrowsIfPassedCanceledCancellationToken()
         {
-            var cancellationTokenSource = new CancellationTokenSource();
-            cancellationTokenSource.Cancel();
-
-            Assert.Throws<OperationCanceledException>(() => Pipe.Reader.ReadAsync(cancellationTokenSource.Token));
+            ValueTask<ReadResult> task = Pipe.Reader.ReadAsync(new CancellationToken(canceled: true));
+            return Assert.ThrowsAsync<TaskCanceledException>(async () => await task);
         }
 
         [Fact]
diff --git a/src/libraries/System.IO.Pipelines/tests/StreamPipeWriterTests.cs b/src/libraries/System.IO.Pipelines/tests/StreamPipeWriterTests.cs
index 9128999a29f69e..dcd07046b4889d 100644
--- a/src/libraries/System.IO.Pipelines/tests/StreamPipeWriterTests.cs
+++ b/src/libraries/System.IO.Pipelines/tests/StreamPipeWriterTests.cs
@@ -26,6 +26,8 @@ public void NothingWrittenToStreamUnlessFlushed()
             Assert.Equal(0, stream.Length);
 
             writer.Complete();
+
+
         }
 
         [Fact]
@@ -42,6 +44,7 @@ public void DataFlushedOnComplete()
 
             writer.Complete();
 
+            Assert.Equal(0, writer.UnflushedBytes);
             Assert.Equal(bytes.Length, stream.Length);
             Assert.Equal("Hello World", Encoding.ASCII.GetString(stream.ToArray()));
         }
@@ -62,6 +65,7 @@ public async Task DataFlushedOnCompleteAsync()
 
             Assert.Equal(bytes.Length, stream.Length);
             Assert.Equal("Hello World", Encoding.ASCII.GetString(stream.ToArray()));
+            Assert.Equal(0, writer.UnflushedBytes);
         }
 
         [Fact]
@@ -132,6 +136,8 @@ public async Task DataWrittenOnFlushAsync()
             Assert.Equal("Hello World", Encoding.ASCII.GetString(stream.ToArray()));
 
             writer.Complete();
+
+            Assert.Equal(0, writer.UnflushedBytes);
         }
 
         [Fact]
@@ -143,6 +149,7 @@ public async Task FlushAsyncWithoutWritingDoesNotFlushAsync()
 
             Assert.False(stream.FlushAsyncCalled);
             writer.Complete();
+            Assert.Equal(0, writer.UnflushedBytes);
         }
 
         [Fact]
@@ -162,6 +169,7 @@ public async Task WritesUsingGetSpanWorks()
             await writer.FlushAsync();
             Assert.Equal(bytes, stream.ToArray());
             writer.Complete();
+            Assert.Equal(0, writer.UnflushedBytes);
         }
 
         [Fact]
@@ -181,6 +189,7 @@ public async Task WritesUsingGetMemoryWorks()
             await writer.FlushAsync();
             Assert.Equal(bytes, stream.ToArray());
             writer.Complete();
+            Assert.Equal(0, writer.UnflushedBytes);
         }
 
         [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsThreadingSupported))]
@@ -397,6 +406,7 @@ public async Task WriteAsyncThrowsDuringMultiSegmentWriteCompleteReturnsAllMemor
                 Assert.Equal(1, pool.DisposedBlocks);
 
                 writer.Complete();
+                Assert.Equal(0, writer.UnflushedBytes);
                 Assert.Equal(0, pool.CurrentlyRentedBlocks);
                 Assert.Equal(3, pool.DisposedBlocks);
             }
@@ -441,6 +451,7 @@ public void CompletingWithBufferedBytesStillReturnsMemoryToPool()
                 Assert.Equal(0, stream.Length);
 
                 writer.Complete();
+                Assert.Equal(0, writer.UnflushedBytes);
                 Assert.Equal(0, pool.CurrentlyRentedBlocks);
                 Assert.Equal(1, pool.DisposedBlocks);
             }
@@ -462,7 +473,7 @@ public void GetMemorySameAsTheMaxPoolSizeUsesThePool()
                 Assert.Equal(0, pool.DisposedBlocks);
 
                 writer.Complete();
-
+                Assert.Equal(0, writer.UnflushedBytes);
                 Assert.Equal(0, pool.CurrentlyRentedBlocks);
                 Assert.Equal(1, pool.DisposedBlocks);
             }
@@ -482,7 +493,7 @@ public void GetMemoryBiggerThanPoolSizeAllocatesArrayPoolArray()
                 Assert.Equal(0, pool.DisposedBlocks);
 
                 writer.Complete();
-
+                Assert.Equal(0, writer.UnflushedBytes);
                 Assert.Equal(0, pool.CurrentlyRentedBlocks);
                 Assert.Equal(0, pool.DisposedBlocks);
             }
@@ -592,6 +603,25 @@ public async Task OperationCancelledExceptionNotSwallowedIfNotThrownFromSpecifie
             await Assert.ThrowsAsync<OperationCanceledException>(async () => await writer.WriteAsync(new byte[1]));
         }
 
+        [Fact]
+        public void UnflushedBytesWorks()
+        {
+            byte[] bytes = Encoding.ASCII.GetBytes("Hello World");
+            var stream = new MemoryStream();
+            PipeWriter writer = PipeWriter.Create(stream);
+
+            Assert.True(writer.CanGetUnflushedBytes);
+
+            bytes.AsSpan().CopyTo(writer.GetSpan(bytes.Length));
+            writer.Advance(bytes.Length);
+
+            Assert.Equal(bytes.Length, writer.UnflushedBytes);
+
+            writer.Complete();
+
+            Assert.Equal(0, writer.UnflushedBytes);
+        }
+
         private class ThrowsOperationCanceledExceptionStream : WriteOnlyStream
         {
             public override void Write(byte[] buffer, int offset, int count)
diff --git a/src/libraries/System.IO.Pipelines/tests/System.IO.Pipelines.Tests.csproj b/src/libraries/System.IO.Pipelines/tests/System.IO.Pipelines.Tests.csproj
index d5b3b44081dd5b..6b8db4abd8250c 100644
--- a/src/libraries/System.IO.Pipelines/tests/System.IO.Pipelines.Tests.csproj
+++ b/src/libraries/System.IO.Pipelines/tests/System.IO.Pipelines.Tests.csproj
@@ -42,6 +42,7 @@
     <Compile Include="Infrastructure\TestMemoryPool.cs" />
     <Compile Include="StreamPipeWriterTests.cs" />
     <Compile Include="Infrastructure\ThrowAfterNWritesStream.cs" />
+    <Compile Include="UnflushedBytesTests.cs" />
   </ItemGroup>
   <ItemGroup Condition="'$(TargetFramework)' == '$(NetCoreAppCurrent)'">
     <Compile Include="PipeLengthTests.cs" />
diff --git a/src/libraries/System.IO.Pipelines/tests/UnflushedBytesTests.cs b/src/libraries/System.IO.Pipelines/tests/UnflushedBytesTests.cs
new file mode 100644
index 00000000000000..1c2c15e94950b5
--- /dev/null
+++ b/src/libraries/System.IO.Pipelines/tests/UnflushedBytesTests.cs
@@ -0,0 +1,50 @@
+// 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.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace System.IO.Pipelines.Tests
+{
+    public class UnflushedBytesTests : PipeTest
+    {
+        internal class MinimalPipeWriter : PipeWriter
+        {
+            public override void Advance(int bytes) => throw new NotImplementedException();
+            public override void CancelPendingFlush() => throw new NotImplementedException();
+            public override void Complete(Exception? exception = null) => throw new NotImplementedException();
+            public override ValueTask<FlushResult> FlushAsync(CancellationToken cancellationToken = default) => throw new NotImplementedException();
+            public override Memory<byte> GetMemory(int sizeHint = 0) => throw new NotImplementedException();
+            public override Span<byte> GetSpan(int sizeHint = 0) => throw new NotImplementedException();
+        }
+
+        public UnflushedBytesTests() : base(0, 0)
+        {
+        }
+
+        [Fact]
+        public void NonOverriddenUnflushedBytesThrows()
+        {
+            MinimalPipeWriter writer = new MinimalPipeWriter();
+            Assert.False(writer.CanGetUnflushedBytes);
+            _ = Assert.Throws<NotSupportedException>(() => { long value = writer.UnflushedBytes; }); ;
+        }
+
+        [Fact]
+        public void UnflushedBytesWorks()
+        {
+            byte[] bytes = Encoding.ASCII.GetBytes("abcdefghijklmnopqrstuvwzyz");
+            Pipe.Writer.Write(bytes);
+            Assert.True(Pipe.Writer.CanGetUnflushedBytes);
+            Assert.Equal(bytes.Length,Pipe.Writer.UnflushedBytes);
+            _ = Pipe.Writer.FlushAsync().GetAwaiter().GetResult();
+            Assert.Equal(0, Pipe.Writer.UnflushedBytes);
+        }
+    }
+}
diff --git a/src/libraries/System.IO.Pipes.AccessControl/Directory.Build.props b/src/libraries/System.IO.Pipes.AccessControl/Directory.Build.props
index 735766f4aa1013..709a22a7537088 100644
--- a/src/libraries/System.IO.Pipes.AccessControl/Directory.Build.props
+++ b/src/libraries/System.IO.Pipes.AccessControl/Directory.Build.props
@@ -3,12 +3,5 @@
   <PropertyGroup>
     <StrongNameKeyId>Microsoft</StrongNameKeyId>
     <SupportedOSPlatforms>windows</SupportedOSPlatforms>
-    <PackageDescription>Provides types for managing access and audit control lists for pipes.
-
-Commonly Used Types:
-System.IO.Pipes.PipeSecurity
-System.IO.Pipes.PipeAccessRule
-System.IO.Pipes.PipeAuditRule
-System.IO.Pipes.PipeAccessRights</PackageDescription>
   </PropertyGroup>
 </Project>
\ No newline at end of file
diff --git a/src/libraries/System.IO.Pipes.AccessControl/NuGet.config b/src/libraries/System.IO.Pipes.AccessControl/NuGet.config
deleted file mode 100644
index a66b7f9b013241..00000000000000
--- a/src/libraries/System.IO.Pipes.AccessControl/NuGet.config
+++ /dev/null
@@ -1,12 +0,0 @@
-<configuration>
-  <!-- This disables restore in VS for projects that target platform specific target frameworks older than net5.0. -->
-  <packageRestore>
-    <!-- The 'automatic' key is set to True when the "Automatically check for missing packages during
-         build in Visual Studio" checkbox is set. Clearing the box sets this to False and disables
-         automatic restore. -->
-    <add key="automatic" value="False" />
-    <!-- The 'enabled' key is True when the "Allow NuGet to download missing packages" checkbox is set.
-         Clearing the box sets this to False, disabling command-line, automatic, and MSBuild-integrated restore. -->
-    <add key="enabled" value="False" />
-  </packageRestore>
-</configuration>
\ No newline at end of file
diff --git a/src/libraries/System.IO.Pipes.AccessControl/pkg/System.IO.Pipes.AccessControl.pkgproj b/src/libraries/System.IO.Pipes.AccessControl/pkg/System.IO.Pipes.AccessControl.pkgproj
deleted file mode 100644
index 21720f8bdddc20..00000000000000
--- a/src/libraries/System.IO.Pipes.AccessControl/pkg/System.IO.Pipes.AccessControl.pkgproj
+++ /dev/null
@@ -1,12 +0,0 @@
-<Project DefaultTargets="Build">
-  <Import Project="$([MSBuild]::GetPathOfFileAbove(Directory.Build.props))" />
-  <ItemGroup>
-    <ProjectReference Include="..\ref\System.IO.Pipes.AccessControl.csproj">
-      <SupportedFramework>net461;netcoreapp2.0;uap10.0.16299;$(AllXamarinFrameworks)</SupportedFramework>
-    </ProjectReference>
-    <ProjectReference Include="..\src\System.IO.Pipes.AccessControl.csproj" />
-    <!-- Exclude TFMs that aren't supported by the package anymore from validation. -->
-    <ExcludeHarvestedSupportedFramework Include="netcoreapp1.0;netcoreapp1.1;netcore50;uap10.0;net46" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetPathOfFileAbove(Directory.Build.targets))" />
-</Project>
\ No newline at end of file
diff --git a/src/libraries/System.IO.Pipes.AccessControl/ref/System.IO.Pipes.AccessControl.PipesAclExtensions.cs b/src/libraries/System.IO.Pipes.AccessControl/ref/System.IO.Pipes.AccessControl.PipesAclExtensions.cs
deleted file mode 100644
index cced321ba5ed60..00000000000000
--- a/src/libraries/System.IO.Pipes.AccessControl/ref/System.IO.Pipes.AccessControl.PipesAclExtensions.cs
+++ /dev/null
@@ -1,14 +0,0 @@
-// 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.IO.Pipes
-{
-    public static partial class PipesAclExtensions
-    {
-        public static System.IO.Pipes.PipeSecurity GetAccessControl(this System.IO.Pipes.PipeStream stream) { throw null; }
-        public static void SetAccessControl(this System.IO.Pipes.PipeStream stream, System.IO.Pipes.PipeSecurity pipeSecurity) { }
-    }
-}
diff --git a/src/libraries/System.IO.Pipes.AccessControl/ref/System.IO.Pipes.AccessControl.cs b/src/libraries/System.IO.Pipes.AccessControl/ref/System.IO.Pipes.AccessControl.cs
index 22c07faa6e764b..775004246a5e00 100644
--- a/src/libraries/System.IO.Pipes.AccessControl/ref/System.IO.Pipes.AccessControl.cs
+++ b/src/libraries/System.IO.Pipes.AccessControl/ref/System.IO.Pipes.AccessControl.cs
@@ -6,6 +6,14 @@
 
 namespace System.IO.Pipes
 {
+    public static class AnonymousPipeServerStreamAcl
+    {
+        public static System.IO.Pipes.AnonymousPipeServerStream Create(System.IO.Pipes.PipeDirection direction, System.IO.HandleInheritability inheritability, int bufferSize, System.IO.Pipes.PipeSecurity? pipeSecurity) { throw null; }
+    }
+    public static class NamedPipeServerStreamAcl
+    {
+        public static System.IO.Pipes.NamedPipeServerStream Create(string pipeName, System.IO.Pipes.PipeDirection direction, int maxNumberOfServerInstances, System.IO.Pipes.PipeTransmissionMode transmissionMode, System.IO.Pipes.PipeOptions options, int inBufferSize, int outBufferSize, System.IO.Pipes.PipeSecurity? pipeSecurity, System.IO.HandleInheritability inheritability = System.IO.HandleInheritability.None, System.IO.Pipes.PipeAccessRights additionalAccessRights = default) { throw null; }
+    }
     [System.FlagsAttribute]
     public enum PipeAccessRights
     {
@@ -60,4 +68,9 @@ public void ResetAccessRule(System.IO.Pipes.PipeAccessRule rule) { }
         public void SetAccessRule(System.IO.Pipes.PipeAccessRule rule) { }
         public void SetAuditRule(System.IO.Pipes.PipeAuditRule rule) { }
     }
+    public static partial class PipesAclExtensions
+    {
+        public static System.IO.Pipes.PipeSecurity GetAccessControl(this System.IO.Pipes.PipeStream stream) { throw null; }
+        public static void SetAccessControl(this System.IO.Pipes.PipeStream stream, System.IO.Pipes.PipeSecurity pipeSecurity) { }
+    }
 }
diff --git a/src/libraries/System.IO.Pipes.AccessControl/ref/System.IO.Pipes.AccessControl.csproj b/src/libraries/System.IO.Pipes.AccessControl/ref/System.IO.Pipes.AccessControl.csproj
index 06496ad316466e..685a31dbdf26ae 100644
--- a/src/libraries/System.IO.Pipes.AccessControl/ref/System.IO.Pipes.AccessControl.csproj
+++ b/src/libraries/System.IO.Pipes.AccessControl/ref/System.IO.Pipes.AccessControl.csproj
@@ -1,21 +1,13 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFrameworks>net5.0;netstandard2.0;net461</TargetFrameworks>
+    <TargetFrameworks>$(NetCoreAppCurrent)</TargetFrameworks>
     <Nullable>enable</Nullable>
   </PropertyGroup>
   <ItemGroup>
-    <Compile Include="System.IO.Pipes.AccessControl.PipesAclExtensions.cs" />
-    <Compile Include="System.IO.Pipes.AccessControl.net461.cs" Condition="'$(TargetFramework)' == 'net461'" />
-    <Compile Include="System.IO.Pipes.AccessControl.cs" Condition="'$(TargetFramework)' != 'net461'" />
-    <Compile Include="System.IO.Pipes.AccessControl.netcoreapp.cs" Condition="'$(TargetFramework)' == 'net5.0'" />
+    <Compile Include="System.IO.Pipes.AccessControl.cs" />
   </ItemGroup>
-  <ItemGroup Condition="'$(TargetFramework)' != 'net461'">
+  <ItemGroup>
+    <ProjectReference Include="$(LibrariesProjectRoot)System.IO.Pipes\ref\System.IO.Pipes.csproj" />
     <ProjectReference Include="$(LibrariesProjectRoot)System.Security.AccessControl\ref\System.Security.AccessControl.csproj" />
-    <ProjectReference Include="$(LibrariesProjectRoot)System.Security.Principal.Windows\ref\System.Security.Principal.Windows.csproj" />
-  </ItemGroup>
-  <ItemGroup Condition="'$(TargetFramework)' == 'net5.0'">
-    <Reference Include="netstandard" />
-    <Reference Include="System.IO.Pipes" />
-    <Reference Include="System.Runtime" />
   </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/src/libraries/System.IO.Pipes.AccessControl/ref/System.IO.Pipes.AccessControl.netcoreapp.cs b/src/libraries/System.IO.Pipes.AccessControl/ref/System.IO.Pipes.AccessControl.netcoreapp.cs
deleted file mode 100644
index ffa670b0b2cc5e..00000000000000
--- a/src/libraries/System.IO.Pipes.AccessControl/ref/System.IO.Pipes.AccessControl.netcoreapp.cs
+++ /dev/null
@@ -1,17 +0,0 @@
-// 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.IO.Pipes
-{
-    public static class AnonymousPipeServerStreamAcl
-    {
-        public static System.IO.Pipes.AnonymousPipeServerStream Create(System.IO.Pipes.PipeDirection direction, System.IO.HandleInheritability inheritability, int bufferSize, System.IO.Pipes.PipeSecurity? pipeSecurity) { throw null; }
-    }
-    public static class NamedPipeServerStreamAcl
-    {
-        public static System.IO.Pipes.NamedPipeServerStream Create(string pipeName, System.IO.Pipes.PipeDirection direction, int maxNumberOfServerInstances, System.IO.Pipes.PipeTransmissionMode transmissionMode, System.IO.Pipes.PipeOptions options, int inBufferSize, int outBufferSize, System.IO.Pipes.PipeSecurity? pipeSecurity, System.IO.HandleInheritability inheritability = System.IO.HandleInheritability.None, System.IO.Pipes.PipeAccessRights additionalAccessRights = default) { throw null; }
-    }
-}
diff --git a/src/libraries/System.IO.Pipes.AccessControl/src/Resources/Strings.resx b/src/libraries/System.IO.Pipes.AccessControl/src/Resources/Strings.resx
index 64b603eb3d18ee..0140e48ff2d8cf 100644
--- a/src/libraries/System.IO.Pipes.AccessControl/src/Resources/Strings.resx
+++ b/src/libraries/System.IO.Pipes.AccessControl/src/Resources/Strings.resx
@@ -57,15 +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="ArgumentOutOfRange_NeedValidPipeAccessRights" xml:space="preserve">
-    <value>Invalid PipeAccessRights value.</value>
-  </data>
-  <data name="Argument_NonContainerInvalidAnyFlag" xml:space="preserve">
-    <value>This flag may not be set on a pipe.</value>
-  </data>
-  <data name="IO_IO_PipeBroken" xml:space="preserve">
-    <value>Pipe is broken.</value>
-  </data>
   <data name="PlatformNotSupported_AccessControl" xml:space="preserve">
     <value>Access Control List (ACL) APIs are part of resource management on Windows and are not supported on this platform.</value>
   </data>
diff --git a/src/libraries/System.IO.Pipes.AccessControl/src/System.IO.Pipes.AccessControl.csproj b/src/libraries/System.IO.Pipes.AccessControl/src/System.IO.Pipes.AccessControl.csproj
index f1f4091ea1f781..f43c090d0810bd 100644
--- a/src/libraries/System.IO.Pipes.AccessControl/src/System.IO.Pipes.AccessControl.csproj
+++ b/src/libraries/System.IO.Pipes.AccessControl/src/System.IO.Pipes.AccessControl.csproj
@@ -1,46 +1,21 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <Nullable>enable</Nullable>
-    <TargetFrameworks>$(NetCoreAppCurrent)-windows;$(NetCoreAppCurrent);net5.0-windows;net5.0;netcoreapp3.1-windows;netcoreapp3.1;netstandard2.0-windows;netstandard2.0;net461-windows</TargetFrameworks>
-    <ExcludeCurrentNetCoreAppFromPackage>true</ExcludeCurrentNetCoreAppFromPackage>
+    <TargetFrameworks>$(NetCoreAppCurrent)-windows;$(NetCoreAppCurrent)</TargetFrameworks>
   </PropertyGroup>
 
   <!-- DesignTimeBuild requires all the TargetFramework Derived Properties to not be present in the first property group. -->
   <PropertyGroup>
     <GeneratePlatformNotSupportedAssemblyMessage Condition="'$(TargetsWindows)' != 'true'">SR.PlatformNotSupported_AccessControl</GeneratePlatformNotSupportedAssemblyMessage>
-    <IsPartialFacadeAssembly Condition="'$(TargetsWindows)' == 'true' and '$(TargetFramework)' != 'netstandard2.0'">true</IsPartialFacadeAssembly>
+    <IsPartialFacadeAssembly Condition="'$(TargetsWindows)' == 'true'">true</IsPartialFacadeAssembly>
     <OmitResources Condition="'$(IsPartialFacadeAssembly)' == 'true'">true</OmitResources>
-    <!-- API Compat will fail for these since we use a fake System.IO.Pipes to forward to. -->
-    <RunApiCompat Condition="'$(IsPartialFacadeAssembly)' == 'true' and '$(TargetFramework)' != '$(NetCoreAppCurrent)-windows'">false</RunApiCompat>
   </PropertyGroup>
 
-  <ItemGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETFramework'">
-    <Compile Include="System\IO\PipesAclExtensions.net461.cs" />
-  </ItemGroup>
-
-  <ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0' and '$(TargetsWindows)' == 'true'">
-    <Compile Include="$(LibrariesProjectRoot)System.IO.Pipes\src\System\IO\Pipes\PipeSecurity.cs" />
-    <Compile Include="$(LibrariesProjectRoot)System.IO.Pipes\src\System\IO\Pipes\PipeAccessRights.cs" />
-    <Compile Include="$(LibrariesProjectRoot)System.IO.Pipes\src\System\IO\Pipes\PipeAccessRule.cs" />
-    <Compile Include="$(LibrariesProjectRoot)System.IO.Pipes\src\System\IO\Pipes\PipeAuditRule.cs" />
-    <Compile Include="$(LibrariesProjectRoot)System.IO.Pipes\src\System\IO\Pipes\PipesAclExtensions.cs" />
-  </ItemGroup>
-
-  <ItemGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETStandard'">
+  <ItemGroup>
+    <ProjectReference Include="$(LibrariesProjectRoot)System.IO.Pipes\src\System.IO.Pipes.csproj">
+      <SkipUseReferenceAssembly Condition="'$(TargetsWindows)' == 'true'">true</SkipUseReferenceAssembly>
+    </ProjectReference>
     <ProjectReference Include="$(LibrariesProjectRoot)System.Security.AccessControl\src\System.Security.AccessControl.csproj" />
-    <ProjectReference Include="$(LibrariesProjectRoot)System.Security.Principal.Windows\src\System.Security.Principal.Windows.csproj" />
-  </ItemGroup>
-
-  <ItemGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp'">
-    <Reference Include="System.Resources.ResourceManager" Condition="'$(TargetFramework)' == 'netcoreapp3.1'" />
     <Reference Include="System.Runtime" />
-    <ProjectReference Include="$(LibrariesProjectRoot)System.Security.AccessControl\src\System.Security.AccessControl.csproj" />
-
-    <!-- Compile against the shipping reference assembly when not targeting Windows. -->
-    <Reference Include="System.IO.Pipes" Condition="'$(TargetsWindows)' != 'true'" />
-    <!-- Compile against the shipping implementation assembly when targeting NetCoreAppCurrent-Windows. -->
-    <ProjectReference Include="$(LibrariesProjectRoot)System.IO.Pipes\src\System.IO.Pipes.csproj" Condition="'$(TargetFramework)' == '$(NetCoreAppCurrent)-windows'" SkipUseReferenceAssembly="true" />
-    <!-- Compile against the non-shipping reference assembly when targeting Windows for older .NETCoreApp tfms. -->
-    <ProjectReference Include="$(LibrariesProjectRoot)System.IO.Pipes\ref\System.IO.Pipes.csproj" Condition="'$(TargetFramework)' != '$(NetCoreAppCurrent)-windows' and '$(TargetsWindows)' == 'true'" />
   </ItemGroup>
 </Project>
diff --git a/src/libraries/System.IO.Pipes.AccessControl/src/System/IO/PipesAclExtensions.net461.cs b/src/libraries/System.IO.Pipes.AccessControl/src/System/IO/PipesAclExtensions.net461.cs
deleted file mode 100644
index b55b5ab35de313..00000000000000
--- a/src/libraries/System.IO.Pipes.AccessControl/src/System/IO/PipesAclExtensions.net461.cs
+++ /dev/null
@@ -1,21 +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.IO;
-using System.Security.AccessControl;
-
-namespace System.IO.Pipes
-{
-    public static class PipesAclExtensions
-    {
-        public static PipeSecurity GetAccessControl(PipeStream stream)
-        {
-            return stream.GetAccessControl();
-        }
-
-        public static void SetAccessControl(PipeStream stream, PipeSecurity pipeSecurity)
-        {
-            stream.SetAccessControl(pipeSecurity);
-        }
-    }
-}
\ No newline at end of file
diff --git a/src/libraries/System.IO.Pipes/tests/AnonymousPipeTests/AnonymousPipeTest.CrossProcess.cs b/src/libraries/System.IO.Pipes/tests/AnonymousPipeTests/AnonymousPipeTest.CrossProcess.cs
index ff475367616d60..9a68529796319b 100644
--- a/src/libraries/System.IO.Pipes/tests/AnonymousPipeTests/AnonymousPipeTest.CrossProcess.cs
+++ b/src/libraries/System.IO.Pipes/tests/AnonymousPipeTests/AnonymousPipeTest.CrossProcess.cs
@@ -8,7 +8,6 @@
 
 namespace System.IO.Pipes.Tests
 {
-    [ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
     public class AnonymousPipeTest_CrossProcess
     {
         [ConditionalFact(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))]
diff --git a/src/libraries/System.IO.Pipes/tests/NamedPipeTests/NamedPipeTest.CrossProcess.cs b/src/libraries/System.IO.Pipes/tests/NamedPipeTests/NamedPipeTest.CrossProcess.cs
index 6e4fbc02c3494d..83e52342abd5b4 100644
--- a/src/libraries/System.IO.Pipes/tests/NamedPipeTests/NamedPipeTest.CrossProcess.cs
+++ b/src/libraries/System.IO.Pipes/tests/NamedPipeTests/NamedPipeTest.CrossProcess.cs
@@ -11,7 +11,6 @@
 
 namespace System.IO.Pipes.Tests
 {
-    [ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
     public sealed class NamedPipeTest_CrossProcess
     {
         [ConditionalFact(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))]
diff --git a/src/libraries/System.IO.Pipes/tests/NamedPipeTests/NamedPipeTest.Specific.cs b/src/libraries/System.IO.Pipes/tests/NamedPipeTests/NamedPipeTest.Specific.cs
index 4eb889567c6fbd..220be9d65ca8a8 100644
--- a/src/libraries/System.IO.Pipes/tests/NamedPipeTests/NamedPipeTest.Specific.cs
+++ b/src/libraries/System.IO.Pipes/tests/NamedPipeTests/NamedPipeTest.Specific.cs
@@ -346,7 +346,6 @@ public async Task Windows_GetImpersonationUserName_Succeed(TokenImpersonationLev
 
         [Fact]
         [PlatformSpecific(TestPlatforms.AnyUnix)]  // Uses P/Invoke to verify the user name
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
         public async Task Unix_GetImpersonationUserName_Succeed()
         {
             string pipeName = PipeStreamConformanceTests.GetUniquePipeName();
diff --git a/src/libraries/System.IO.Ports/src/System.IO.Ports.csproj b/src/libraries/System.IO.Ports/src/System.IO.Ports.csproj
index 9560e277889c4a..878c5e2a3f9887 100644
--- a/src/libraries/System.IO.Ports/src/System.IO.Ports.csproj
+++ b/src/libraries/System.IO.Ports/src/System.IO.Ports.csproj
@@ -4,15 +4,15 @@
     <DefineConstants>$(DefineConstants);NOSPAN;SERIAL_PORTS</DefineConstants>
     <IncludeDllSafeSearchPathAttribute>true</IncludeDllSafeSearchPathAttribute>
     <Nullable>annotations</Nullable>
-    <TargetFrameworks>netstandard2.0-windows;netstandard2.0-Linux;netstandard2.0-OSX;netstandard2.0;net461-windows;netstandard2.0-FreeBSD</TargetFrameworks>
+    <TargetFrameworks>netstandard2.0-windows;netstandard2.0-Linux;netstandard2.0-OSX;netstandard2.0-FreeBSD;netstandard2.0;net461-windows</TargetFrameworks>
   </PropertyGroup>
   <!-- DesignTimeBuild requires all the TargetFramework Derived Properties to not be present in the first property group. -->
   <PropertyGroup>
-    <IsPartialFacadeAssembly Condition="$(TargetFramework.StartsWith('net4'))">true</IsPartialFacadeAssembly>
-    <GeneratePlatformNotSupportedAssemblyMessage Condition="$(TargetFramework.StartsWith('netstandard')) and '$(TargetsAnyOS)' == 'true'">SR.PlatformNotSupported_IOPorts</GeneratePlatformNotSupportedAssemblyMessage>
+    <IsPartialFacadeAssembly Condition="$([MSBuild]::GetTargetFrameworkIdentifier('$(TargetFramework)')) == '.NETFramework'">true</IsPartialFacadeAssembly>
+    <GeneratePlatformNotSupportedAssemblyMessage Condition="'$(IsPartialFacadeAssembly)' != 'true' and '$(TargetsAnyOS)' == 'true'">SR.PlatformNotSupported_IOPorts</GeneratePlatformNotSupportedAssemblyMessage>
     <ExcludeFromPackage Condition="'$(TargetFramework)' == 'netstandard2.0' AND '$(TargetsFreeBSD)' == 'true'">true</ExcludeFromPackage>
   </PropertyGroup>
-  <ItemGroup Condition="$(TargetFramework.StartsWith('netstandard')) and '$(TargetsAnyOS)' != 'true'">
+  <ItemGroup Condition="'$(IsPartialFacadeAssembly)' != 'true' and '$(TargetsAnyOS)' != 'true'">
     <Compile Include="System\IO\Ports\Handshake.cs" />
     <Compile Include="System\IO\Ports\InternalResources.cs" />
     <Compile Include="System\IO\Ports\Parity.cs" />
@@ -29,7 +29,7 @@
     <Compile Include="System\IO\Ports\SerialStream.cs" />
     <Compile Include="System\IO\Ports\StopBits.cs" />
   </ItemGroup>
-  <ItemGroup Condition="!$(TargetFramework.StartsWith('net4')) and '$(TargetsWindows)' == 'true'">
+  <ItemGroup Condition="'$(IsPartialFacadeAssembly)' != 'true' and '$(TargetsWindows)' == 'true'">
     <Compile Include="System\IO\Ports\SerialStream.Windows.cs" />
     <Compile Include="$(CommonPath)Interop\Windows\Kernel32\Interop.DCB.cs"
              Link="Common\Interop\Windows\Kernel32\Interop.DCB.cs" />
@@ -99,8 +99,6 @@
              Link="Common\System\IO\Win32Marshal.cs" />
     <Compile Include="$(CommonPath)Interop\Windows\Kernel32\Interop.FormatMessage.cs"
              Link="Common\Interop\Windows\Interop.FormatMessage.cs" />
-  </ItemGroup>
-  <ItemGroup Condition="!$(TargetFramework.StartsWith('net4')) and '$(TargetsWindows)' == 'true'">
     <Compile Include="System\IO\Ports\SerialPort.Win32.cs" />
     <Compile Include="System\IO\Ports\SerialStream.Win32.cs" />
     <Compile Include="$(CommonPath)Interop\Windows\Kernel32\Interop.CreateFile.cs"
@@ -135,9 +133,9 @@
     <Compile Include="$(CommonPath)System\Threading\Tasks\TaskToApm.cs"
              Link="Common\System\Threading\Tasks\TaskToApm.cs" />
   </ItemGroup>
-  <ItemGroup Condition="$(TargetFramework.StartsWith('netstandard'))">
+  <ItemGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETStandard'">
     <PackageReference Include="System.Memory" Version="$(SystemMemoryVersion)" />
-    <ProjectReference Include="$(LibrariesProjectRoot)Microsoft.Win32.Registry\src\Microsoft.Win32.Registry.csproj" />
+    <PackageReference Include="Microsoft.Win32.Registry" Version="$(MicrosoftWin32RegistryVersion)" />
     <ProjectReference Include="$(LibrariesProjectRoot)System.Runtime.CompilerServices.Unsafe\src\System.Runtime.CompilerServices.Unsafe.ilproj" />
   </ItemGroup>
 </Project>
diff --git a/src/libraries/System.IO.Ports/tests/System.IO.Ports.Tests.csproj b/src/libraries/System.IO.Ports/tests/System.IO.Ports.Tests.csproj
index 1267d77477c099..13d9cb01024af3 100644
--- a/src/libraries/System.IO.Ports/tests/System.IO.Ports.Tests.csproj
+++ b/src/libraries/System.IO.Ports/tests/System.IO.Ports.Tests.csproj
@@ -118,7 +118,6 @@
     <Folder Include="Legacy\Manual\" />
   </ItemGroup>
   <ItemGroup>
-    <ProjectReference Include="$(LibrariesProjectRoot)Microsoft.Win32.Registry\src\Microsoft.Win32.Registry.csproj" />
     <ProjectReference Include="..\src\System.IO.Ports.csproj" />
   </ItemGroup>
   <ItemGroup Condition="'$(TargetFramework)' == 'net461'">
diff --git a/src/libraries/System.IO/tests/StreamReader/StreamReader.StringCtorTests.cs b/src/libraries/System.IO/tests/StreamReader/StreamReader.StringCtorTests.cs
index 51a8122a444fec..d4c7ac4ad847f1 100644
--- a/src/libraries/System.IO/tests/StreamReader/StreamReader.StringCtorTests.cs
+++ b/src/libraries/System.IO/tests/StreamReader/StreamReader.StringCtorTests.cs
@@ -14,12 +14,18 @@ public class StreamReader_StringCtorTests
         public static void NullArgs_ThrowsArgumentNullException()
         {
             AssertExtensions.Throws<ArgumentNullException>("path", () => new StreamReader((string)null));
-            AssertExtensions.Throws<ArgumentNullException>("path", () => new StreamReader((string)null, null));
+            AssertExtensions.Throws<ArgumentNullException>("path", () => new StreamReader((string)null, (FileStreamOptions)null));
+            AssertExtensions.Throws<ArgumentNullException>("path", () => new StreamReader((string)null, (Encoding)null));
             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("", null));
+            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>("options", () => new StreamReader("path", (FileStreamOptions)null));
+            AssertExtensions.Throws<ArgumentNullException>("options", () => new StreamReader("path", Encoding.UTF8, true, null));
+
         }
 
         [Fact]
@@ -27,8 +33,10 @@ 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));
         }
 
diff --git a/src/libraries/System.IO/tests/StreamReader/StreamReader.cs b/src/libraries/System.IO/tests/StreamReader/StreamReader.cs
index 8fe7e4d2ba7bbf..bd455448efccaf 100644
--- a/src/libraries/System.IO/tests/StreamReader/StreamReader.cs
+++ b/src/libraries/System.IO/tests/StreamReader/StreamReader.cs
@@ -72,5 +72,30 @@ public void DetectEncoding_EncodingRoundtrips(Encoding encoding)
                 Assert.Equal(encoding.EncodingName, reader.CurrentEncoding.EncodingName);
             }
         }
+
+        [Theory]
+        [MemberData(nameof(DetectEncoding_EncodingRoundtrips_MemberData))]
+        public void DetectEncoding_EncodingRoundtrips_Path(Encoding encoding)
+        {
+            const string Text = "This is some text for testing.";
+            string path = GetTestFilePath();
+
+            using (var writer = new StreamWriter(path, false, encoding))
+            {
+                writer.Write(Text);
+            }
+
+            using (var reader = new StreamReader(path, detectEncodingFromByteOrderMarks: true))
+            {
+                Assert.Equal(Text, reader.ReadToEnd());
+                Assert.Equal(encoding.EncodingName, reader.CurrentEncoding.EncodingName);
+            }
+
+            using (var reader = new StreamReader(path, encoding))
+            {
+                Assert.Equal(Text, reader.ReadToEnd());
+                Assert.Equal(encoding.EncodingName, reader.CurrentEncoding.EncodingName);
+            }
+        }
     }
 }
diff --git a/src/libraries/System.IO/tests/StreamWriter/StreamWriter.StringCtorTests.cs b/src/libraries/System.IO/tests/StreamWriter/StreamWriter.StringCtorTests.cs
index cf00dfc9df3278..95041cd56503a6 100644
--- a/src/libraries/System.IO/tests/StreamWriter/StreamWriter.StringCtorTests.cs
+++ b/src/libraries/System.IO/tests/StreamWriter/StreamWriter.StringCtorTests.cs
@@ -15,12 +15,15 @@ public class StreamWriter_StringCtorTests
         public static void NullArgs_ThrowsArgumentNullException()
         {
             AssertExtensions.Throws<ArgumentNullException>("path", () => new StreamWriter((string)null));
+            AssertExtensions.Throws<ArgumentNullException>("path", () => new StreamWriter((string)null, null));
             AssertExtensions.Throws<ArgumentNullException>("path", () => new StreamWriter((string)null, true));
             AssertExtensions.Throws<ArgumentNullException>("path", () => new StreamWriter((string)null, true, null));
             AssertExtensions.Throws<ArgumentNullException>("path", () => new StreamWriter((string)null, true, null, -1));
             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));
         }
 
@@ -29,8 +32,10 @@ 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));
         }
 
diff --git a/src/libraries/System.Linq.Expressions/src/System/Dynamic/Utils/TypeUtils.cs b/src/libraries/System.Linq.Expressions/src/System/Dynamic/Utils/TypeUtils.cs
index afa81a14932b81..3a0fc56030a92b 100644
--- a/src/libraries/System.Linq.Expressions/src/System/Dynamic/Utils/TypeUtils.cs
+++ b/src/libraries/System.Linq.Expressions/src/System/Dynamic/Utils/TypeUtils.cs
@@ -16,6 +16,8 @@ internal static class TypeUtils
             .Select(i => i.GetGenericTypeDefinition())
             .ToArray();
 
+        private static readonly ConstructorInfo s_nullableConstructor = typeof(Nullable<>).GetConstructor(typeof(Nullable<>).GetGenericArguments())!;
+
         public static Type GetNonNullableType(this Type type) => IsNullableType(type) ? type.GetGenericArguments()[0] : type;
 
         public static Type GetNullableType(this Type type)
@@ -29,15 +31,11 @@ public static Type GetNullableType(this Type type)
             return type;
         }
 
-        [DynamicDependency(DynamicallyAccessedMemberTypes.PublicConstructors, typeof(Nullable<>))]
-        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2070:UnrecognizedReflectionPattern",
-            Justification = "The Nullable<T> ctor will be preserved by the DynamicDependency.")]
-        public static ConstructorInfo GetNullableConstructor(Type nullableType, Type nonNullableType)
+        public static ConstructorInfo GetNullableConstructor(Type nullableType)
         {
             Debug.Assert(nullableType.IsNullableType());
-            Debug.Assert(!nonNullableType.IsNullableType() && nonNullableType.IsValueType);
 
-            return nullableType.GetConstructor(new Type[] { nonNullableType })!;
+            return (ConstructorInfo)nullableType.GetMemberWithSameMetadataDefinitionAs(s_nullableConstructor);
         }
 
         public static bool IsNullableType(this Type type) => type.IsConstructedGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>);
diff --git a/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/ILGen.cs b/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/ILGen.cs
index 673e213432a725..5cd7fd59185d29 100644
--- a/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/ILGen.cs
+++ b/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/ILGen.cs
@@ -12,6 +12,10 @@ namespace System.Linq.Expressions.Compiler
 {
     internal static class ILGen
     {
+        private static readonly MethodInfo s_nullableHasValueGetter = typeof(Nullable<>).GetMethod("get_HasValue", BindingFlags.Instance | BindingFlags.Public)!;
+        private static readonly MethodInfo s_nullableValueGetter = typeof(Nullable<>).GetMethod("get_Value", BindingFlags.Instance | BindingFlags.Public)!;
+        private static readonly MethodInfo s_nullableGetValueOrDefault = typeof(Nullable<>).GetMethod("GetValueOrDefault", Type.EmptyTypes)!;
+
         internal static void Emit(this ILGenerator il, OpCode opcode, MethodBase methodBase)
         {
             Debug.Assert(methodBase is MethodInfo || methodBase is ConstructorInfo);
@@ -485,7 +489,7 @@ private static bool TryEmitILConstant(this ILGenerator il, object value, Type ty
 
                 if (TryEmitILConstant(il, value, nonNullType))
                 {
-                    il.Emit(OpCodes.Newobj, TypeUtils.GetNullableConstructor(type, nonNullType));
+                    il.Emit(OpCodes.Newobj, TypeUtils.GetNullableConstructor(type));
                     return true;
                 }
 
@@ -826,7 +830,7 @@ private static void EmitNullableToNullableConversion(this ILGenerator il, Type t
             Type nnTypeTo = typeTo.GetNonNullableType();
             il.EmitConvertToType(nnTypeFrom, nnTypeTo, isChecked, locals);
             // construct result type
-            ConstructorInfo ci = TypeUtils.GetNullableConstructor(typeTo, nnTypeTo);
+            ConstructorInfo ci = TypeUtils.GetNullableConstructor(typeTo);
             il.Emit(OpCodes.Newobj, ci);
             labEnd = il.DefineLabel();
             il.Emit(OpCodes.Br_S, labEnd);
@@ -846,7 +850,7 @@ private static void EmitNonNullableToNullableConversion(this ILGenerator il, Typ
             Debug.Assert(typeTo.IsNullableType());
             Type nnTypeTo = typeTo.GetNonNullableType();
             il.EmitConvertToType(typeFrom, nnTypeTo, isChecked, locals);
-            ConstructorInfo ci = TypeUtils.GetNullableConstructor(typeTo, nnTypeTo);
+            ConstructorInfo ci = TypeUtils.GetNullableConstructor(typeTo);
             il.Emit(OpCodes.Newobj, ci);
         }
 
@@ -898,38 +902,29 @@ private static void EmitNullableConversion(this ILGenerator il, Type typeFrom, T
                 il.EmitNonNullableToNullableConversion(typeFrom, typeTo, isChecked, locals);
         }
 
-        [DynamicDependency("get_HasValue", typeof(Nullable<>))]
-        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2070:UnrecognizedReflectionPattern",
-            Justification = "The Nullable<T> method will be preserved by the DynamicDependency.")]
         internal static void EmitHasValue(this ILGenerator il, Type nullableType)
         {
             Debug.Assert(nullableType.IsNullableType());
 
-            MethodInfo mi = nullableType.GetMethod("get_HasValue", BindingFlags.Instance | BindingFlags.Public)!;
+            MethodInfo mi = (MethodInfo)nullableType.GetMemberWithSameMetadataDefinitionAs(s_nullableHasValueGetter);
             Debug.Assert(nullableType.IsValueType);
             il.Emit(OpCodes.Call, mi);
         }
 
-        [DynamicDependency("get_Value", typeof(Nullable<>))]
-        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2070:UnrecognizedReflectionPattern",
-            Justification = "The Nullable<T> method will be preserved by the DynamicDependency.")]
         internal static void EmitGetValue(this ILGenerator il, Type nullableType)
         {
             Debug.Assert(nullableType.IsNullableType());
 
-            MethodInfo mi = nullableType.GetMethod("get_Value", BindingFlags.Instance | BindingFlags.Public)!;
+            MethodInfo mi = (MethodInfo)nullableType.GetMemberWithSameMetadataDefinitionAs(s_nullableValueGetter);
             Debug.Assert(nullableType.IsValueType);
             il.Emit(OpCodes.Call, mi);
         }
 
-        [DynamicDependency("GetValueOrDefault()", typeof(Nullable<>))]
-        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2070:UnrecognizedReflectionPattern",
-            Justification = "The Nullable<T> method will be preserved by the DynamicDependency.")]
         internal static void EmitGetValueOrDefault(this ILGenerator il, Type nullableType)
         {
             Debug.Assert(nullableType.IsNullableType());
 
-            MethodInfo mi = nullableType.GetMethod("GetValueOrDefault", Type.EmptyTypes)!;
+            MethodInfo mi = (MethodInfo)nullableType.GetMemberWithSameMetadataDefinitionAs(s_nullableGetValueOrDefault);
             Debug.Assert(nullableType.IsValueType);
             il.Emit(OpCodes.Call, mi);
         }
diff --git a/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/LambdaCompiler.Binary.cs b/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/LambdaCompiler.Binary.cs
index a888be0831e219..c4e448a2dce29f 100644
--- a/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/LambdaCompiler.Binary.cs
+++ b/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/LambdaCompiler.Binary.cs
@@ -480,7 +480,7 @@ private void EmitLiftedBinaryArithmetic(ExpressionType op, Type leftType, Type r
             EmitBinaryOperator(op, leftType.GetNonNullableType(), rightType.GetNonNullableType(), resultNonNullableType, liftedToNull: false);
 
             // construct result type
-            ConstructorInfo ci = TypeUtils.GetNullableConstructor(resultType, resultNonNullableType);
+            ConstructorInfo ci = TypeUtils.GetNullableConstructor(resultType);
             _ilg.Emit(OpCodes.Newobj, ci);
             _ilg.Emit(OpCodes.Stloc, locResult);
             _ilg.Emit(OpCodes.Br_S, labEnd);
diff --git a/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/LambdaCompiler.Expressions.cs b/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/LambdaCompiler.Expressions.cs
index a3049f80d49277..505b29844da4b0 100644
--- a/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/LambdaCompiler.Expressions.cs
+++ b/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/LambdaCompiler.Expressions.cs
@@ -4,7 +4,6 @@
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
 using System.Dynamic.Utils;
 using System.Reflection;
 using System.Reflection.Emit;
@@ -14,6 +13,8 @@ namespace System.Linq.Expressions.Compiler
 {
     internal sealed partial class LambdaCompiler
     {
+        private static readonly FieldInfo s_callSiteTargetField = typeof(CallSite<>).GetField("Target")!;
+
         [Flags]
         internal enum CompilationFlags
         {
@@ -613,13 +614,10 @@ private void EmitDynamicExpression(Expression expr)
             EmitWriteBack(wb);
         }
 
-        [DynamicDependency("Target", typeof(CallSite<>))]
-        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2070:UnrecognizedReflectionPattern",
-            Justification = "The 'Target' field will be preserved by the DynamicDependency.")]
         private static FieldInfo GetCallSiteTargetField(Type siteType)
         {
             Debug.Assert(siteType.IsGenericType && siteType.GetGenericTypeDefinition() == typeof(CallSite<>));
-            return siteType.GetField("Target")!;
+            return (FieldInfo)siteType.GetMemberWithSameMetadataDefinitionAs(s_callSiteTargetField);
         }
 
         private void EmitNewExpression(Expression expr)
@@ -1171,7 +1169,7 @@ private void EmitLift(ExpressionType nodeType, Type resultType, MethodCallExpres
                         EmitMethodCallExpression(mc);
                         if (resultType.IsNullableType() && !TypeUtils.AreEquivalent(resultType, mc.Type))
                         {
-                            ConstructorInfo ci = TypeUtils.GetNullableConstructor(resultType, mc.Type);
+                            ConstructorInfo ci = TypeUtils.GetNullableConstructor(resultType);
                             _ilg.Emit(OpCodes.Newobj, ci);
                         }
                         _ilg.Emit(OpCodes.Br_S, exit);
@@ -1275,7 +1273,7 @@ private void EmitLift(ExpressionType nodeType, Type resultType, MethodCallExpres
                         EmitMethodCallExpression(mc);
                         if (resultType.IsNullableType() && !TypeUtils.AreEquivalent(resultType, mc.Type))
                         {
-                            ConstructorInfo ci = TypeUtils.GetNullableConstructor(resultType, mc.Type);
+                            ConstructorInfo ci = TypeUtils.GetNullableConstructor(resultType);
                             _ilg.Emit(OpCodes.Newobj, ci);
                         }
                         _ilg.Emit(OpCodes.Br_S, exit);
diff --git a/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/LambdaCompiler.Unary.cs b/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/LambdaCompiler.Unary.cs
index f487d73d7c3f2a..b17d4144664414 100644
--- a/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/LambdaCompiler.Unary.cs
+++ b/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/LambdaCompiler.Unary.cs
@@ -94,7 +94,7 @@ private void EmitUnary(UnaryExpression node, CompilationFlags flags)
                     EmitBinaryOperator(ExpressionType.SubtractChecked, nnType, nnType, nnType, liftedToNull: false);
 
                     // construct result
-                    _ilg.Emit(OpCodes.Newobj, TypeUtils.GetNullableConstructor(type, nnType));
+                    _ilg.Emit(OpCodes.Newobj, TypeUtils.GetNullableConstructor(type));
                     _ilg.Emit(OpCodes.Br_S, end);
 
                     // if null then push back on stack
@@ -164,7 +164,7 @@ private void EmitUnaryOperator(ExpressionType op, Type operandType, Type resultT
                         EmitUnaryOperator(op, nnOperandType, nnOperandType);
 
                         // construct result
-                        ConstructorInfo ci = TypeUtils.GetNullableConstructor(resultType, nnOperandType);
+                        ConstructorInfo ci = TypeUtils.GetNullableConstructor(resultType);
                         _ilg.Emit(OpCodes.Newobj, ci);
                         _ilg.Emit(OpCodes.Br_S, labEnd);
 
diff --git a/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/LambdaExpression.cs b/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/LambdaExpression.cs
index fc45b9c5ff81f8..a615e89056abda 100644
--- a/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/LambdaExpression.cs
+++ b/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/LambdaExpression.cs
@@ -21,6 +21,8 @@ namespace System.Linq.Expressions
     [DebuggerTypeProxy(typeof(LambdaExpressionProxy))]
     public abstract class LambdaExpression : Expression, IParameterProvider
     {
+        private static readonly MethodInfo s_expressionCompileMethodInfo = typeof(Expression<>).GetMethod("Compile", Type.EmptyTypes)!;
+
         private readonly Expression _body;
 
         internal LambdaExpression(Expression body)
@@ -119,20 +121,7 @@ internal static MethodInfo GetCompileMethod(Type lambdaExpressionType)
                 return typeof(LambdaExpression).GetMethod("Compile", Type.EmptyTypes)!;
             }
 
-            return GetDerivedCompileMethod(lambdaExpressionType);
-        }
-
-        [DynamicDependency("Compile()", typeof(Expression<>))]
-        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2070:UnrecognizedReflectionPattern",
-            Justification = "The 'Compile' method will be preserved by the DynamicDependency.")]
-        private static MethodInfo GetDerivedCompileMethod(Type lambdaExpressionType)
-        {
-            Debug.Assert(lambdaExpressionType.IsAssignableTo(typeof(LambdaExpression)) && lambdaExpressionType != typeof(LambdaExpression));
-
-            MethodInfo result = lambdaExpressionType.GetMethod("Compile", Type.EmptyTypes)!;
-            Debug.Assert(result.DeclaringType!.IsGenericType && result.DeclaringType.GetGenericTypeDefinition() == typeof(Expression<>));
-
-            return result;
+            return (MethodInfo)lambdaExpressionType.GetMemberWithSameMetadataDefinitionAs(s_expressionCompileMethodInfo);
         }
 
         /// <summary>
diff --git a/src/libraries/System.Linq.Expressions/tests/TrimmingTests/ExpressionPropertyTests.cs b/src/libraries/System.Linq.Expressions/tests/TrimmingTests/ExpressionPropertyTests.cs
new file mode 100644
index 00000000000000..0c038f0af75bf9
--- /dev/null
+++ b/src/libraries/System.Linq.Expressions/tests/TrimmingTests/ExpressionPropertyTests.cs
@@ -0,0 +1,77 @@
+// 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.Linq;
+using System.Linq.Expressions;
+using System.Reflection;
+
+/// <summary>
+/// Tests that the System.Linq.Expressions.Expression.Property will correctly preserve both
+/// accessors even if only one is referenced by MethodInfo.
+/// </summary>
+internal class Program
+{
+    static int Main(string[] args)
+    {
+        int result = ExplicitCreation.Test();
+        if (result != 100)
+            return result;
+
+        result = LambdaCreation.Test();
+
+        return result;
+    }
+
+    class ExplicitCreation
+    {
+        class TestType
+        {
+            public bool _testPropertyValue;
+
+            public bool TestProperty { 
+                get => _testPropertyValue;
+                set { _testPropertyValue = value; }
+            }
+        }
+
+        public static int Test()
+        {
+            var obj = new TestType();
+            var param = Expression.Parameter(typeof(TestType));
+            var prop = Expression.Property(param, typeof(TestType).GetMethod("get_TestProperty"));
+            ((PropertyInfo)prop.Member).SetValue(obj, true);
+            if (obj._testPropertyValue != true)
+                return -1;
+
+            return 100;
+        }
+    }
+
+    class LambdaCreation
+    {
+        class TestType
+        {
+            public bool _testPropertyValue;
+
+            public bool TestProperty { 
+                get => _testPropertyValue;
+                set { _testPropertyValue = value; }
+            }
+        }
+
+        public static int Test()
+        {
+            var obj = new TestType ();
+            Expression<Func<TestType, bool>> expression = t => t.TestProperty;
+            var prop = ((MemberExpression)expression.Body);
+            ((PropertyInfo)prop.Member).SetValue(obj, true);
+
+            if (obj._testPropertyValue != true)
+                return -2;
+
+            return 100;
+        }
+    }
+}
diff --git a/src/libraries/System.Management/ref/System.Management.csproj b/src/libraries/System.Management/ref/System.Management.csproj
index dad99c2aecffba..18b7fb4064a3cd 100644
--- a/src/libraries/System.Management/ref/System.Management.csproj
+++ b/src/libraries/System.Management/ref/System.Management.csproj
@@ -1,12 +1,24 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFrameworks>netstandard2.0</TargetFrameworks>
+    <TargetFrameworks>$(NetCoreAppCurrent);netcoreapp3.1;netstandard2.0</TargetFrameworks>
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="System.Management.cs" />
     <Compile Include="System.Management.manual.cs" />
   </ItemGroup>
   <ItemGroup>
-    <ProjectReference Include="..\..\System.CodeDom\ref\System.CodeDom.csproj" />
+    <ProjectReference Include="$(LibrariesProjectRoot)System.CodeDom\ref\System.CodeDom.csproj" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == '$(NetCoreAppCurrent)'">
+    <ProjectReference Include="$(LibrariesProjectRoot)System.ComponentModel.TypeConverter\ref\System.ComponentModel.TypeConverter.csproj" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == 'netcoreapp3.1'">
+    <Reference Include="netstandard" />
+    <Reference Include="System.Collections.Specialized" />
+    <Reference Include="System.ComponentModel.Primitives" />
+    <Reference Include="System.ComponentModel.TypeConverter" />
+    <Reference Include="System.ObjectModel" />
+    <Reference Include="System.Runtime" />
+    <Reference Include="System.Runtime.InteropServices" />
   </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/src/libraries/System.Management/src/System.Management.csproj b/src/libraries/System.Management/src/System.Management.csproj
index 07f592cf332b6f..9fac8892aed3ae 100644
--- a/src/libraries/System.Management/src/System.Management.csproj
+++ b/src/libraries/System.Management/src/System.Management.csproj
@@ -3,14 +3,13 @@
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <NoWarn>$(NoWarn);0618</NoWarn>
     <IncludeDllSafeSearchPathAttribute>true</IncludeDllSafeSearchPathAttribute>
-    <TargetFrameworks>$(NetCoreAppCurrent)-windows;netcoreapp3.1-windows;netstandard2.0</TargetFrameworks>
-    <ExcludeCurrentNetCoreAppFromPackage>true</ExcludeCurrentNetCoreAppFromPackage>
+    <TargetFrameworks>$(NetCoreAppCurrent)-windows;$(NetCoreAppCurrent);netcoreapp3.1-windows;netcoreapp3.1;netstandard2.0</TargetFrameworks>
   </PropertyGroup>
   <!-- DesignTimeBuild requires all the TargetFramework Derived Properties to not be present in the first property group. -->
   <PropertyGroup>
-    <GeneratePlatformNotSupportedAssemblyMessage Condition="'$(TargetFramework)' == 'netstandard2.0'">SR.PlatformNotSupported_SystemManagement</GeneratePlatformNotSupportedAssemblyMessage>
+    <GeneratePlatformNotSupportedAssemblyMessage Condition="'$(TargetsWindows)' != 'true'">SR.PlatformNotSupported_SystemManagement</GeneratePlatformNotSupportedAssemblyMessage>
   </PropertyGroup>
-  <ItemGroup Condition="'$(TargetFramework)' != 'netstandard2.0'">
+  <ItemGroup Condition="'$(TargetsWindows)' == 'true'">
     <Compile Include="$(CommonPath)Interop\Windows\Interop.Libraries.cs"
              Link="Common\Interop\Windows\Interop.Libraries.cs" />
     <Compile Include="$(CommonPath)Interop\Windows\Kernel32\Interop.FreeLibrary.cs"
@@ -63,8 +62,10 @@
     <ProjectReference Include="$(LibrariesProjectRoot)System.CodeDom\src\System.CodeDom.csproj" />
   </ItemGroup>
   <ItemGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp'">
-    <ProjectReference Include="$(LibrariesProjectRoot)Microsoft.Win32.Registry\src\Microsoft.Win32.Registry.csproj" />
+    <PackageReference Include="Microsoft.Win32.Registry" Version="$(MicrosoftWin32RegistryVersion)" Condition="!$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net6.0'))" />
+    <Reference Include="netstandard" Condition="$(TargetFramework.StartsWith('netcoreapp3.1'))" />
     <Reference Include="Microsoft.Win32.Primitives" />
+    <Reference Include="Microsoft.Win32.Registry" Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net6.0'))" />
     <Reference Include="System.Collections.NonGeneric" />
     <Reference Include="System.Collections.Specialized" />
     <Reference Include="System.ComponentModel.Primitives" />
diff --git a/src/libraries/System.Memory/ref/System.Memory.cs b/src/libraries/System.Memory/ref/System.Memory.cs
index d9d629deb04e5a..7318b4a0d3c576 100644
--- a/src/libraries/System.Memory/ref/System.Memory.cs
+++ b/src/libraries/System.Memory/ref/System.Memory.cs
@@ -49,6 +49,8 @@ public static void CopyTo<T>(this T[]? source, System.Span<T> destination) { }
         public static bool EndsWith(this System.ReadOnlySpan<char> span, System.ReadOnlySpan<char> value, System.StringComparison comparisonType) { throw null; }
         public static bool EndsWith<T>(this System.ReadOnlySpan<T> span, System.ReadOnlySpan<T> value) where T : System.IEquatable<T> { throw null; }
         public static bool EndsWith<T>(this System.Span<T> span, System.ReadOnlySpan<T> value) where T : System.IEquatable<T> { throw null; }
+        public static System.Text.SpanLineEnumerator EnumerateLines(this System.ReadOnlySpan<char> span) { throw null; }
+        public static System.Text.SpanLineEnumerator EnumerateLines(this System.Span<char> span) { throw null; }
         public static System.Text.SpanRuneEnumerator EnumerateRunes(this System.ReadOnlySpan<char> span) { throw null; }
         public static System.Text.SpanRuneEnumerator EnumerateRunes(this System.Span<char> span) { throw null; }
         public static bool Equals(this System.ReadOnlySpan<char> span, System.ReadOnlySpan<char> other, System.StringComparison comparisonType) { throw null; }
@@ -543,6 +545,14 @@ public static partial class EncodingExtensions
         public static long GetChars(this System.Text.Encoding encoding, System.ReadOnlySpan<byte> bytes, System.Buffers.IBufferWriter<char> writer) { throw null; }
         public static string GetString(this System.Text.Encoding encoding, in System.Buffers.ReadOnlySequence<byte> bytes) { throw null; }
     }
+    public ref partial struct SpanLineEnumerator
+    {
+        private object _dummy;
+        private int _dummyPrimitive;
+        public System.ReadOnlySpan<char> Current { get { throw null; } }
+        public System.Text.SpanLineEnumerator GetEnumerator() { throw null; }
+        public bool MoveNext() { throw null; }
+    }
     public ref partial struct SpanRuneEnumerator
     {
         private object _dummy;
diff --git a/src/libraries/System.Memory/tests/Span/EnumerateLines.cs b/src/libraries/System.Memory/tests/Span/EnumerateLines.cs
new file mode 100644
index 00000000000000..d6c4c653adfe75
--- /dev/null
+++ b/src/libraries/System.Memory/tests/Span/EnumerateLines.cs
@@ -0,0 +1,169 @@
+// 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.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using Xunit;
+
+namespace System.SpanTests
+{
+    public static partial class SpanTests
+    {
+        // newline chars given by Unicode Standard, Sec. 5.8, Recommendation R4 and Table 5-2
+        public static IEnumerable<object[]> NewLineChars => new object[][]
+        {
+            new object[] { '\r' },
+            new object[] { '\n' },
+            new object[] { '\f' },
+            new object[] { '\u0085' },
+            new object[] { '\u2028' },
+            new object[] { '\u2029' },
+        };
+
+        [Fact]
+        public static void EnumerateLines_Empty()
+        {
+            // Enumerations over empty inputs should return a single empty element
+
+            var enumerator = Span<char>.Empty.EnumerateLines().GetEnumerator();
+            Assert.True(enumerator.MoveNext());
+            Assert.Equal("", enumerator.Current.ToString());
+            Assert.False(enumerator.MoveNext());
+
+            enumerator = ReadOnlySpan<char>.Empty.EnumerateLines().GetEnumerator();
+            Assert.True(enumerator.MoveNext());
+            Assert.Equal("", enumerator.Current.ToString());
+            Assert.False(enumerator.MoveNext());
+        }
+
+        [Theory]
+        [InlineData(null, new[] { ".." })]
+        [InlineData("", new[] { ".." })]
+        [InlineData("abc", new[] { ".." })]
+        [InlineData("<CR>", new[] { "..0", "1.." })] // empty sequences before and after the CR
+        [InlineData("<CR><CR>", new[] { "0..0", "1..1", "2..2" })] // empty sequences before and after the CR (CR doesn't consume CR)
+        [InlineData("<CR><LF>", new[] { "..0", "^0.." })] // CR should swallow any LF which follows
+        [InlineData("a<CR><LF><LF>z", new[] { "..1", "3..3", "4.." })] // CR should swallow only a single LF which follows
+        [InlineData("a<CR>b<LF>c", new[] { "..1", "2..3", "4.." })] // CR shouldn't swallow anything other than LF
+        [InlineData("aa<CR>bb<LF><CR>cc", new[] { "..2", "3..5", "6..6", "7.." })] // LF shouldn't swallow CR which follows
+        [InlineData("a<CR>b<VT>c<LF>d<NEL>e<FF>f<PS>g<LS>h", new[] { "..1", "2..5", "6..7", "8..9", "10..11", "12..13", "14.." })] // VT not recognized as NLF
+        [InlineData("xyz<NEL>", new[] { "..3", "^0.." })] // sequence at end produces empty string
+        [InlineData("<NEL>xyz", new[] { "..0", "^3.." })] // sequence at beginning produces empty string
+        [InlineData("abc<NAK>%def", new[] { ".." })] // we don't recognize EBCDIC encodings for LF (see Unicode Standard, Sec. 5.8, Table 5-1)
+        public static void EnumerateLines_Battery(string input, string[] expectedRanges)
+        {
+            // This test is similar to the string.ReplaceLineEndings test, but it checks ranges instead of substrings,
+            // as we want to ensure that the method under test points to very specific slices within the original input string.
+
+            input = FixupSequences(input);
+            Range[] expectedRangesNormalized = expectedRanges.Select(element =>
+            {
+                Range parsed = ParseRange(element);
+                (int actualOffset, int actualLength) = parsed.GetOffsetAndLength(input?.Length ?? 0);
+                return actualOffset..(actualOffset + actualLength);
+            }).ToArray();
+
+            List<Range> actualRangesNormalized = new List<Range>();
+            foreach (ReadOnlySpan<char> line in input.AsSpan().EnumerateLines())
+            {
+                actualRangesNormalized.Add(GetNormalizedRangeFromSubspan(input, line));
+            }
+
+            Assert.Equal(expectedRangesNormalized, actualRangesNormalized);
+
+            static unsafe Range GetNormalizedRangeFromSubspan<T>(ReadOnlySpan<T> outer, ReadOnlySpan<T> inner)
+            {
+                // We can't use MemoryExtensions.Overlaps because it doesn't handle empty spans in the way we need.
+
+                ref T refOuter = ref MemoryMarshal.GetReference(outer);
+                ref T refInner = ref MemoryMarshal.GetReference(inner);
+
+                fixed (byte* pOuterStart = &Unsafe.As<T, byte>(ref refOuter))
+                fixed (byte* pInnerStart = &Unsafe.As<T, byte>(ref refInner))
+                {
+                    byte* pOuterEnd = pOuterStart + (uint)outer.Length * (nuint)Unsafe.SizeOf<T>();
+                    byte* pInnerEnd = pInnerStart + (uint)inner.Length * (nuint)Unsafe.SizeOf<T>();
+
+                    Assert.True(pOuterStart <= pInnerStart && pInnerStart <= pOuterEnd, "Inner span begins outside outer span.");
+                    Assert.True(pOuterStart <= pInnerEnd && pInnerEnd <= pOuterEnd, "Inner span ends outside outer span.");
+
+                    nuint byteOffset = (nuint)(pInnerStart - pOuterStart);
+                    Assert.Equal((nuint)0, byteOffset % (nuint)Unsafe.SizeOf<T>()); // Unaligned elements; cannot compute offset
+                    nuint elementOffset = byteOffset / (nuint)Unsafe.SizeOf<T>();
+                    return checked((int)elementOffset)..checked((int)elementOffset + inner.Length);
+                }
+            }
+
+            static string FixupSequences(string input)
+            {
+                // We use <XYZ> markers so that the original strings show up better in the xunit test runner
+                // <VT> is included as a negative test; we *do not* want ReplaceLineEndings to honor it
+
+                if (input is null) { return null; }
+                return input.Replace("<CR>", "\r")
+                    .Replace("<LF>", "\n")
+                    .Replace("<VT>", "\v")
+                    .Replace("<FF>", "\f")
+                    .Replace("<NAK>", "\u0015")
+                    .Replace("<NEL>", "\u0085")
+                    .Replace("<LS>", "\u2028")
+                    .Replace("<PS>", "\u2029");
+            }
+
+            static Range ParseRange(string input)
+            {
+                var idxOfDots = input.IndexOf("..", StringComparison.Ordinal);
+                if (idxOfDots < 0) { throw new ArgumentException(); }
+
+                ReadOnlySpan<char> begin = input.AsSpan(0, idxOfDots).Trim();
+                Index beginIdx = (begin.IsEmpty) ? Index.Start : ParseIndex(begin);
+                ReadOnlySpan<char> end = input.AsSpan(idxOfDots + 2).Trim();
+                Index endIdx = (end.IsEmpty) ? Index.End : ParseIndex(end);
+                return beginIdx..endIdx;
+
+                static Index ParseIndex(ReadOnlySpan<char> input)
+                {
+                    bool fromEnd = false;
+                    if (!input.IsEmpty && input[0] == '^') { fromEnd = true; input = input.Slice(1); }
+                    return new Index(int.Parse(input, NumberStyles.Integer, CultureInfo.InvariantCulture), fromEnd);
+                }
+            }
+        }
+
+        [Theory]
+        [MemberData(nameof(NewLineChars))]
+        public static void EnumerateLines_EnumerationIsNotPolynomialComplexity(char newlineChar)
+        {
+            // This test ensures that the complexity of any call to MoveNext is O(i), where i is the
+            // index of the first occurrence of any NLF within the span; rather than O(n), where
+            // n is the length of the span. See comments in SpanLineEnumerator.MoveNext and
+            // string.IndexOfNewlineChar for more information.
+            //
+            // We test this by utilizing the BoundedMemory infrastructure to allocate a poison page
+            // after the scratch buffer, then we intentionally use MemoryMarshal to manipulate the
+            // scratch buffer so that it extends into the poison page. If the runtime skips the first
+            // occurrence of the newline char and attempts to read all the way to the end of the span,
+            // this will manifest as an AV within this unit test.
+
+            using var boundedMem = BoundedMemory.Allocate<char>(4096, PoisonPagePlacement.After);
+            Span<char> span = boundedMem.Span;
+            span.Fill('a');
+            span[512] = newlineChar;
+            boundedMem.MakeReadonly();
+
+            span = MemoryMarshal.CreateSpan(ref MemoryMarshal.GetReference(span), span.Length + 4096);
+
+            var enumerator = span.EnumerateLines().GetEnumerator();
+            Assert.True(enumerator.MoveNext());
+            Assert.Equal(512, enumerator.Current.Length);
+
+            enumerator = ((ReadOnlySpan<char>)span).EnumerateLines().GetEnumerator();
+            Assert.True(enumerator.MoveNext());
+            Assert.Equal(512, enumerator.Current.Length);
+        }
+    }
+}
diff --git a/src/libraries/System.Memory/tests/System.Memory.Tests.csproj b/src/libraries/System.Memory/tests/System.Memory.Tests.csproj
index 6176b956641aef..5ab1670c7df700 100644
--- a/src/libraries/System.Memory/tests/System.Memory.Tests.csproj
+++ b/src/libraries/System.Memory/tests/System.Memory.Tests.csproj
@@ -64,6 +64,7 @@
     <Compile Include="Span\EndsWith.char.cs" />
     <Compile Include="Span\EndsWith.long.cs" />
     <Compile Include="Span\EndsWith.T.cs" />
+    <Compile Include="Span\EnumerateLines.cs" />
     <Compile Include="Span\EnumerateRunes.cs" />
     <Compile Include="Span\Equality.cs" />
     <Compile Include="Span\GcReporting.cs" />
diff --git a/src/libraries/System.Net.Http.Json/ref/System.Net.Http.Json.csproj b/src/libraries/System.Net.Http.Json/ref/System.Net.Http.Json.csproj
index 9e23fb4e092360..1687a6caa509fd 100644
--- a/src/libraries/System.Net.Http.Json/ref/System.Net.Http.Json.csproj
+++ b/src/libraries/System.Net.Http.Json/ref/System.Net.Http.Json.csproj
@@ -1,7 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <TargetFrameworks>$(NetCoreAppCurrent);net5.0;netstandard2.0;net461</TargetFrameworks>
-    <ExcludeCurrentNetCoreAppFromPackage>true</ExcludeCurrentNetCoreAppFromPackage>
     <Nullable>enable</Nullable>
   </PropertyGroup>
   <ItemGroup>
diff --git a/src/libraries/System.Net.Http.Json/src/System.Net.Http.Json.csproj b/src/libraries/System.Net.Http.Json/src/System.Net.Http.Json.csproj
index 120c77f330d3e4..af6fa91b1c1892 100644
--- a/src/libraries/System.Net.Http.Json/src/System.Net.Http.Json.csproj
+++ b/src/libraries/System.Net.Http.Json/src/System.Net.Http.Json.csproj
@@ -1,7 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <TargetFrameworks>$(NetCoreAppCurrent);net5.0;netstandard2.0;net461</TargetFrameworks>
-    <ExcludeCurrentNetCoreAppFromPackage>true</ExcludeCurrentNetCoreAppFromPackage>
     <Nullable>enable</Nullable>
   </PropertyGroup>
   <ItemGroup>
diff --git a/src/libraries/System.Net.Http/ref/System.Net.Http.cs b/src/libraries/System.Net.Http/ref/System.Net.Http.cs
index 9fa9bdc34287ed..02486ab68b11b8 100644
--- a/src/libraries/System.Net.Http/ref/System.Net.Http.cs
+++ b/src/libraries/System.Net.Http/ref/System.Net.Http.cs
@@ -4,6 +4,7 @@
 // Changes to this file must follow the https://aka.ms/api-review process.
 // ------------------------------------------------------------------------------
 
+using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 
 namespace System.Net.Http
@@ -520,6 +521,26 @@ public EntityTagHeaderValue(string tag, bool isWeak) { }
         public override string ToString() { throw null; }
         public static bool TryParse([System.Diagnostics.CodeAnalysis.NotNullWhenAttribute(true)] string? input, [System.Diagnostics.CodeAnalysis.NotNullWhenAttribute(true)] out System.Net.Http.Headers.EntityTagHeaderValue? parsedValue) { throw null; }
     }
+    public readonly partial struct HeaderStringValues : System.Collections.Generic.IEnumerable<string>, System.Collections.Generic.IReadOnlyCollection<string>, System.Collections.IEnumerable
+    {
+        private readonly object _dummy;
+        private readonly int _dummyPrimitive;
+        public int Count { get { throw null; } }
+        public System.Net.Http.Headers.HeaderStringValues.Enumerator GetEnumerator() { throw null; }
+        System.Collections.Generic.IEnumerator<string> System.Collections.Generic.IEnumerable<string>.GetEnumerator() { throw null; }
+        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { throw null; }
+        public override string ToString() { throw null; }
+        public partial struct Enumerator : System.Collections.Generic.IEnumerator<string>, System.Collections.IEnumerator, System.IDisposable
+        {
+            private object _dummy;
+            private int _dummyPrimitive;
+            public string Current { get { throw null; } }
+            object System.Collections.IEnumerator.Current { get { throw null; } }
+            public void Dispose() { }
+            public bool MoveNext() { throw null; }
+            void System.Collections.IEnumerator.Reset() { }
+        }
+    }
     public sealed partial class HttpContentHeaders : System.Net.Http.Headers.HttpHeaders
     {
         internal HttpContentHeaders() { }
@@ -538,6 +559,7 @@ internal HttpContentHeaders() { }
     public abstract partial class HttpHeaders : System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string, System.Collections.Generic.IEnumerable<string>>>, System.Collections.IEnumerable
     {
         protected HttpHeaders() { }
+        public System.Net.Http.Headers.HttpHeadersNonValidated NonValidated { get { throw null; } }
         public void Add(string name, System.Collections.Generic.IEnumerable<string?> values) { }
         public void Add(string name, string? value) { }
         public void Clear() { }
@@ -551,6 +573,32 @@ public void Clear() { }
         public bool TryAddWithoutValidation(string name, string? value) { throw null; }
         public bool TryGetValues(string name, [System.Diagnostics.CodeAnalysis.NotNullWhenAttribute(true)] out System.Collections.Generic.IEnumerable<string>? values) { throw null; }
     }
+    public readonly partial struct HttpHeadersNonValidated : System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string, System.Net.Http.Headers.HeaderStringValues>>, System.Collections.Generic.IReadOnlyCollection<System.Collections.Generic.KeyValuePair<string, System.Net.Http.Headers.HeaderStringValues>>, System.Collections.Generic.IReadOnlyDictionary<string, System.Net.Http.Headers.HeaderStringValues>, System.Collections.IEnumerable
+    {
+        private readonly object _dummy;
+        private readonly int _dummyPrimitive;
+        public int Count { get { throw null; } }
+        public System.Net.Http.Headers.HeaderStringValues this[string headerName] { get { throw null; } }
+        System.Collections.Generic.IEnumerable<string> System.Collections.Generic.IReadOnlyDictionary<string, System.Net.Http.Headers.HeaderStringValues>.Keys { get { throw null; } }
+        System.Collections.Generic.IEnumerable<System.Net.Http.Headers.HeaderStringValues> System.Collections.Generic.IReadOnlyDictionary<string, System.Net.Http.Headers.HeaderStringValues>.Values { get { throw null; } }
+        public bool Contains(string headerName) { throw null; }
+        bool System.Collections.Generic.IReadOnlyDictionary<string, System.Net.Http.Headers.HeaderStringValues>.ContainsKey(string key) { throw null; }
+        public System.Net.Http.Headers.HttpHeadersNonValidated.Enumerator GetEnumerator() { throw null; }
+        System.Collections.Generic.IEnumerator<System.Collections.Generic.KeyValuePair<string, System.Net.Http.Headers.HeaderStringValues>> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string, System.Net.Http.Headers.HeaderStringValues>>.GetEnumerator() { throw null; }
+        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { throw null; }
+        public bool TryGetValues(string headerName, out System.Net.Http.Headers.HeaderStringValues values) { throw null; }
+        bool System.Collections.Generic.IReadOnlyDictionary<string, System.Net.Http.Headers.HeaderStringValues>.TryGetValue(string key, out System.Net.Http.Headers.HeaderStringValues value) { throw null; }
+        public partial struct Enumerator : System.Collections.Generic.IEnumerator<System.Collections.Generic.KeyValuePair<string, System.Net.Http.Headers.HeaderStringValues>>, System.Collections.IEnumerator, System.IDisposable
+        {
+            private object _dummy;
+            private int _dummyPrimitive;
+            public System.Collections.Generic.KeyValuePair<string, System.Net.Http.Headers.HeaderStringValues> Current { get { throw null; } }
+            object System.Collections.IEnumerator.Current { get { throw null; } }
+            public void Dispose() { }
+            public bool MoveNext() { throw null; }
+            void System.Collections.IEnumerator.Reset() { }
+        }
+    }
     public sealed partial class HttpHeaderValueCollection<T> : System.Collections.Generic.ICollection<T>, System.Collections.Generic.IEnumerable<T>, System.Collections.IEnumerable where T : class
     {
         internal HttpHeaderValueCollection() { }
diff --git a/src/libraries/System.Net.Http/src/System.Net.Http.csproj b/src/libraries/System.Net.Http/src/System.Net.Http.csproj
index cf6c743ce044b1..0ce5ec1aa171ef 100644
--- a/src/libraries/System.Net.Http/src/System.Net.Http.csproj
+++ b/src/libraries/System.Net.Http/src/System.Net.Http.csproj
@@ -76,11 +76,13 @@
     <Compile Include="System\Net\Http\Headers\EntityTagHeaderValue.cs" />
     <Compile Include="System\Net\Http\Headers\GenericHeaderParser.cs" />
     <Compile Include="System\Net\Http\Headers\HeaderDescriptor.cs" />
+    <Compile Include="System\Net\Http\Headers\HeaderStringValues.cs" />
     <Compile Include="System\Net\Http\Headers\HeaderUtilities.cs" />
     <Compile Include="System\Net\Http\Headers\HttpContentHeaders.cs" />
     <Compile Include="System\Net\Http\Headers\HttpGeneralHeaders.cs" />
     <Compile Include="System\Net\Http\Headers\HttpHeaderParser.cs" />
     <Compile Include="System\Net\Http\Headers\HttpHeaders.cs" />
+    <Compile Include="System\Net\Http\Headers\HttpHeadersNonValidated.cs" />
     <Compile Include="System\Net\Http\Headers\HttpHeaderValueCollection.cs" />
     <Compile Include="System\Net\Http\Headers\HttpRequestHeaders.cs" />
     <Compile Include="System\Net\Http\Headers\HttpResponseHeaders.cs" />
diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/BrowserHttpHandler/BrowserHttpHandler.cs b/src/libraries/System.Net.Http/src/System/Net/Http/BrowserHttpHandler/BrowserHttpHandler.cs
index 7eb3a3ddc13b9d..b4450bb4256413 100644
--- a/src/libraries/System.Net.Http/src/System/Net/Http/BrowserHttpHandler/BrowserHttpHandler.cs
+++ b/src/libraries/System.Net.Http/src/System/Net/Http/BrowserHttpHandler/BrowserHttpHandler.cs
@@ -144,6 +144,11 @@ protected internal override HttpResponseMessage Send(HttpRequestMessage request,
 
         protected internal override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
         {
+            if (request == null)
+            {
+                throw new ArgumentNullException(nameof(request), SR.net_http_handler_norequest);
+            }
+
             try
             {
                 var requestObject = new JSObject();
diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/Headers/HeaderStringValues.cs b/src/libraries/System.Net.Http/src/System/Net/Http/Headers/HeaderStringValues.cs
new file mode 100644
index 00000000000000..a313a2306e78f0
--- /dev/null
+++ b/src/libraries/System.Net.Http/src/System/Net/Http/Headers/HeaderStringValues.cs
@@ -0,0 +1,130 @@
+// 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;
+using System.Collections.Generic;
+
+namespace System.Net.Http.Headers
+{
+    /// <summary>Provides a collection of header string values.</summary>
+    public readonly struct HeaderStringValues : IReadOnlyCollection<string>
+    {
+        /// <summary>The associated header.  This is used only for producing a string from <see cref="_value"/> when it's an array.</summary>
+        private readonly HeaderDescriptor _header;
+        /// <summary>A string or string array (or null if the instance is default).</summary>
+        private readonly object _value;
+
+        /// <summary>Initializes the instance.</summary>
+        /// <param name="descriptor">The header descriptor associated with the header value.</param>
+        /// <param name="value">The header value.</param>
+        internal HeaderStringValues(HeaderDescriptor descriptor, string value)
+        {
+            _header = descriptor;
+            _value = value;
+        }
+
+        /// <summary>Initializes the instance.</summary>
+        /// <param name="descriptor">The header descriptor associated with the header values.</param>
+        /// <param name="values">The header values.</param>
+        internal HeaderStringValues(HeaderDescriptor descriptor, string[] values)
+        {
+            _header = descriptor;
+            _value = values;
+        }
+
+        /// <summary>Gets the number of header values in the collection.</summary>
+        public int Count => _value switch
+        {
+            string => 1,
+            string[] values => values.Length,
+            _ => 0
+        };
+
+        /// <summary>Gets a string containing all the headers in the collection.</summary>
+        /// <returns></returns>
+        public override string ToString() => _value switch
+        {
+            string value => value,
+            string[] values => string.Join(_header.Parser is HttpHeaderParser parser && parser.SupportsMultipleValues ? parser.Separator : HttpHeaderParser.DefaultSeparator, values),
+            _ => string.Empty,
+        };
+
+        /// <summary>Gets an enumerator for all of the strings in the collection.</summary>
+        /// <returns></returns>
+        public Enumerator GetEnumerator() => new Enumerator(_value);
+
+        /// <inheritdoc/>
+        IEnumerator<string> IEnumerable<string>.GetEnumerator() => GetEnumerator();
+
+        /// <inheritdoc/>
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+        /// <summary>Enumerates the elements of a <see cref="HeaderStringValues"/>.</summary>
+        public struct Enumerator : IEnumerator<string>
+        {
+            /// <summary>If this wraps a string[], that array. Otherwise, null.</summary>
+            private readonly string[]? _values;
+            /// <summary>The current string header value.  If this wraps a single string, that string.</summary>
+            private string? _current;
+            /// <summary>Current state of the iteration.</summary>
+            private int _index;
+
+            /// <summary>Initializes the enumerator with a string or string[].</summary>
+            /// <param name="value">The string or string[] value, or null if this collection is empty.</param>
+            internal Enumerator(object value)
+            {
+                if (value is string s)
+                {
+                    _values = null;
+                    _current = s;
+                }
+                else
+                {
+                    _values = value as string[];
+                    _current = null;
+                }
+
+                _index = 0;
+            }
+
+            /// <inheritdoc/>
+            public bool MoveNext()
+            {
+                int index = _index;
+                if (index < 0)
+                {
+                    return false;
+                }
+
+                string[]? values = _values;
+                if (values != null)
+                {
+                    if ((uint)index < (uint)values.Length)
+                    {
+                        _index = index + 1;
+                        _current = values[index];
+                        return true;
+                    }
+
+                    _index = -1;
+                    return false;
+                }
+
+                _index = -1;
+                return _current != null;
+            }
+
+            /// <inheritdoc/>
+            public string Current => _current!;
+
+            /// <inheritdoc/>
+            object IEnumerator.Current => Current;
+
+            /// <inheritdoc/>
+            public void Dispose() { }
+
+            /// <inheritdoc/>
+            void IEnumerator.Reset() => throw new NotSupportedException();
+        }
+    }
+}
diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/Headers/HeaderUtilities.cs b/src/libraries/System.Net.Http/src/System/Net/Http/Headers/HeaderUtilities.cs
index d3802a1571fcef..eaae8e5e91e319 100644
--- a/src/libraries/System.Net.Http/src/System/Net/Http/Headers/HeaderUtilities.cs
+++ b/src/libraries/System.Net.Http/src/System/Net/Http/Headers/HeaderUtilities.cs
@@ -6,7 +6,6 @@
 using System.Diagnostics;
 using System.Globalization;
 using System.IO;
-using System.Net.Mail;
 using System.Text;
 
 namespace System.Net.Http.Headers
@@ -156,7 +155,7 @@ internal static void CheckValidToken(string value, string parameterName)
 
             if (HttpRuleParser.GetTokenLength(value, 0) != value.Length)
             {
-                throw new FormatException(SR.Format(System.Globalization.CultureInfo.InvariantCulture, SR.net_http_headers_invalid_value, value));
+                throw new FormatException(SR.Format(CultureInfo.InvariantCulture, SR.net_http_headers_invalid_value, value));
             }
         }
 
@@ -171,7 +170,7 @@ internal static void CheckValidComment(string value, string parameterName)
             if ((HttpRuleParser.GetCommentLength(value, 0, out length) != HttpParseResult.Parsed) ||
                 (length != value.Length)) // no trailing spaces allowed
             {
-                throw new FormatException(SR.Format(System.Globalization.CultureInfo.InvariantCulture, SR.net_http_headers_invalid_value, value));
+                throw new FormatException(SR.Format(CultureInfo.InvariantCulture, SR.net_http_headers_invalid_value, value));
             }
         }
 
@@ -186,7 +185,7 @@ internal static void CheckValidQuotedString(string value, string parameterName)
             if ((HttpRuleParser.GetQuotedStringLength(value, 0, out length) != HttpParseResult.Parsed) ||
                 (length != value.Length)) // no trailing spaces allowed
             {
-                throw new FormatException(SR.Format(System.Globalization.CultureInfo.InvariantCulture, SR.net_http_headers_invalid_value, value));
+                throw new FormatException(SR.Format(CultureInfo.InvariantCulture, SR.net_http_headers_invalid_value, value));
             }
         }
 
@@ -318,7 +317,7 @@ internal static int GetNextNonEmptyOrWhitespaceIndex(string input, int startInde
         }
 
         internal static bool TryParseInt32(string value, out int result) =>
-            int.TryParse(value, NumberStyles.None, provider: null, out result);
+            int.TryParse(value, NumberStyles.None, CultureInfo.InvariantCulture, out result);
 
         internal static bool TryParseInt32(string value, int offset, int length, out int result)
         {
@@ -328,7 +327,7 @@ internal static bool TryParseInt32(string value, int offset, int length, out int
                 return false;
             }
 
-            return int.TryParse(value.AsSpan(offset, length), NumberStyles.None, provider: null, out result);
+            return int.TryParse(value.AsSpan(offset, length), NumberStyles.None, CultureInfo.InvariantCulture, out result);
         }
 
         internal static bool TryParseInt64(string value, int offset, int length, out long result)
@@ -339,7 +338,7 @@ internal static bool TryParseInt64(string value, int offset, int length, out lon
                 return false;
             }
 
-            return long.TryParse(value.AsSpan(offset, length), NumberStyles.None, provider: null, out result);
+            return long.TryParse(value.AsSpan(offset, length), NumberStyles.None, CultureInfo.InvariantCulture, out result);
         }
 
         internal static void DumpHeaders(StringBuilder sb, params HttpHeaders?[] headers)
@@ -357,7 +356,7 @@ internal static void DumpHeaders(StringBuilder sb, params HttpHeaders?[] headers
             {
                 if (headers[i] is HttpHeaders hh)
                 {
-                    foreach (KeyValuePair<string, string[]> header in hh.EnumerateWithoutValidation())
+                    foreach (KeyValuePair<string, HeaderStringValues> header in hh.NonValidated)
                     {
                         foreach (string headerValue in header.Value)
                         {
diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/Headers/HttpHeaders.cs b/src/libraries/System.Net.Http/src/System/Net/Http/Headers/HttpHeaders.cs
index fcdee9f7c516a2..fd1074f16f9391 100644
--- a/src/libraries/System.Net.Http/src/System/Net/Http/Headers/HttpHeaders.cs
+++ b/src/libraries/System.Net.Http/src/System/Net/Http/Headers/HttpHeaders.cs
@@ -5,6 +5,7 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
+using System.Runtime.InteropServices;
 using System.Text;
 
 namespace System.Net.Http.Headers
@@ -36,45 +37,26 @@ public abstract class HttpHeaders : IEnumerable<KeyValuePair<string, IEnumerable
 
         private readonly HttpHeaderType _allowedHeaderTypes;
         private readonly HttpHeaderType _treatAsCustomHeaderTypes;
-        /// <summary>Whether to force values in <see cref="_headerStore"/> to be wrapped in <see cref="HeaderStoreItemInfo"/> objects.</summary>
-        /// <remarks>
-        /// In general, header and collection types in System.Net.Http are not thread-safe: it's an error to read/write the same header
-        /// collection on multiple threads, and even to enumerate a single header collection from multiple threads concurrently; doing
-        /// so may lazily-initialize various properties and structures.  However, there is one collection exempt from this based purely
-        /// on necessity: HttpClient.DefaultRequestHeaders.  DefaultRequestHeaders is enumerated to add all of its headers into each
-        /// request, and since requests may be sent on the same HttpClient instance concurrently, this collection may be enumerated
-        /// concurrently.  As such, we need to ensure that any mutation performed on DefaultRequestHeaders while enumerating is done in
-        /// a thread-safe way.  This is achieved by locking on the <see cref="HeaderStoreItemInfo"/> objects in the <see cref="_headerStore"/>,
-        /// but that means the value must be a <see cref="HeaderStoreItemInfo"/> rather than a raw string, which we prefer to store for
-        /// unvalidated additions.  To work around that, for the HttpClient.DefaultRequestHeaders collection sets <see cref="_forceHeaderStoreItems"/>
-        /// to true, which will cause additions to always be wrapped, even if we otherwise wouldn't need them to be.
-        /// </remarks>
-        private bool _forceHeaderStoreItems;
-
-        private enum StoreLocation
-        {
-            Raw,
-            Invalid,
-            Parsed
-        }
 
         protected HttpHeaders()
             : this(HttpHeaderType.All, HttpHeaderType.None)
         {
         }
 
-        internal HttpHeaders(HttpHeaderType allowedHeaderTypes, HttpHeaderType treatAsCustomHeaderTypes, bool forceHeaderStoreItems = false)
+        internal HttpHeaders(HttpHeaderType allowedHeaderTypes, HttpHeaderType treatAsCustomHeaderTypes)
         {
             // Should be no overlap
             Debug.Assert((allowedHeaderTypes & treatAsCustomHeaderTypes) == 0);
 
             _allowedHeaderTypes = allowedHeaderTypes & ~HttpHeaderType.NonTrailing;
             _treatAsCustomHeaderTypes = treatAsCustomHeaderTypes & ~HttpHeaderType.NonTrailing;
-            _forceHeaderStoreItems = forceHeaderStoreItems;
         }
 
         internal Dictionary<HeaderDescriptor, object>? HeaderStore => _headerStore;
 
+        /// <summary>Gets a view of the contents of this headers collection that does not parse nor validate the data upon access.</summary>
+        public HttpHeadersNonValidated NonValidated => new HttpHeadersNonValidated(this);
+
         public void Add(string name, string? value) => Add(GetHeaderDescriptor(name), value);
 
         internal void Add(HeaderDescriptor descriptor, string? value)
@@ -146,7 +128,7 @@ internal bool TryAddWithoutValidation(HeaderDescriptor descriptor, string? value
                 if (currentValue is HeaderStoreItemInfo info)
                 {
                     // The header store already contained a HeaderStoreItemInfo, so add to it.
-                    AddValue(info, value, StoreLocation.Raw);
+                    AddRawValue(info, value);
                 }
                 else
                 {
@@ -154,13 +136,13 @@ internal bool TryAddWithoutValidation(HeaderDescriptor descriptor, string? value
                     // to being a HeaderStoreItemInfo and add to it.
                     Debug.Assert(currentValue is string);
                     _headerStore[descriptor] = info = new HeaderStoreItemInfo() { RawValue = currentValue };
-                    AddValue(info, value, StoreLocation.Raw);
+                    AddRawValue(info, value);
                 }
             }
             else
             {
                 // The header store did not contain the header.  Add the raw string.
-                _headerStore.Add(descriptor, _forceHeaderStoreItems ? new HeaderStoreItemInfo { RawValue = value } : (object)value);
+                _headerStore.Add(descriptor, value);
             }
 
             return true;
@@ -187,7 +169,7 @@ internal bool TryAddWithoutValidation(HeaderDescriptor descriptor, IEnumerable<s
                         HeaderStoreItemInfo info = GetOrCreateHeaderInfo(descriptor, parseRawValues: false);
                         do
                         {
-                            AddValue(info, enumerator.Current ?? string.Empty, StoreLocation.Raw);
+                            AddRawValue(info, enumerator.Current ?? string.Empty);
                         }
                         while (enumerator.MoveNext());
                     }
@@ -226,7 +208,7 @@ internal bool TryGetValues(HeaderDescriptor descriptor, [NotNullWhen(true)] out
         {
             if (_headerStore != null && TryGetAndParseHeaderInfo(descriptor, out HeaderStoreItemInfo? info))
             {
-                values = GetValuesAsStrings(descriptor, info);
+                values = GetStoreValuesAsStringArray(descriptor, info);
                 return true;
             }
 
@@ -246,59 +228,63 @@ internal bool Contains(HeaderDescriptor descriptor)
 
         public override string ToString()
         {
-            if (_headerStore == null || _headerStore.Count == 0)
-            {
-                return string.Empty;
-            }
-
             // Return all headers as string similar to:
             // HeaderName1: Value1, Value2
             // HeaderName2: Value1
             // ...
-            var sb = new StringBuilder();
-            foreach (KeyValuePair<string, string> header in GetHeaderStrings())
-            {
-                sb.Append(header.Key).Append(": ").AppendLine(header.Value);
-            }
 
-            return sb.ToString();
-        }
+            var vsb = new ValueStringBuilder(stackalloc char[512]);
 
-        internal IEnumerable<KeyValuePair<string, string>> GetHeaderStrings()
-        {
-            if (_headerStore == null)
+            if (_headerStore is Dictionary<HeaderDescriptor, object> headerStore)
             {
-                yield break;
-            }
+                foreach (KeyValuePair<HeaderDescriptor, object> header in headerStore)
+                {
+                    vsb.Append(header.Key.Name);
+                    vsb.Append(": ");
 
-            foreach (KeyValuePair<HeaderDescriptor, object> header in _headerStore)
-            {
-                string stringValue = GetHeaderString(header.Key, header.Value);
+                    GetStoreValuesAsStringOrStringArray(header.Key, header.Value, out string? singleValue, out string[]? multiValue);
+                    Debug.Assert(singleValue is not null ^ multiValue is not null);
+
+                    if (singleValue is not null)
+                    {
+                        vsb.Append(singleValue);
+                    }
+                    else
+                    {
+                        // Note that if we get multiple values for a header that doesn't support multiple values, we'll
+                        // just separate the values using a comma (default separator).
+                        string? separator = header.Key.Parser is HttpHeaderParser parser && parser.SupportsMultipleValues ? parser.Separator : HttpHeaderParser.DefaultSeparator;
+
+                        for (int i = 0; i < multiValue!.Length; i++)
+                        {
+                            if (i != 0) vsb.Append(separator);
+                            vsb.Append(multiValue[i]);
+                        }
+                    }
 
-                yield return new KeyValuePair<string, string>(header.Key.Name, stringValue);
+                    vsb.Append(Environment.NewLine);
+                }
             }
+
+            return vsb.ToString();
         }
 
-        internal string GetHeaderString(HeaderDescriptor descriptor, object? exclude = null)
+        internal string GetHeaderString(HeaderDescriptor descriptor)
         {
             if (TryGetHeaderValue(descriptor, out object? info))
             {
-                string[] values = GetValuesAsStrings(descriptor, info, exclude);
+                GetStoreValuesAsStringOrStringArray(descriptor, info, out string? singleValue, out string[]? multiValue);
+                Debug.Assert(singleValue is not null ^ multiValue is not null);
 
-                if (values.Length == 1)
+                if (singleValue is not null)
                 {
-                    return values[0];
+                    return singleValue;
                 }
 
                 // Note that if we get multiple values for a header that doesn't support multiple values, we'll
                 // just separate the values using a comma (default separator).
-                string? separator = HttpHeaderParser.DefaultSeparator;
-                if (descriptor.Parser != null && descriptor.Parser.SupportsMultipleValues)
-                {
-                    separator = descriptor.Parser.Separator;
-                }
-
-                return string.Join(separator, values);
+                string? separator = descriptor.Parser != null && descriptor.Parser.SupportsMultipleValues ? descriptor.Parser.Separator : HttpHeaderParser.DefaultSeparator;
+                return string.Join(separator, multiValue!);
             }
 
             return string.Empty;
@@ -323,10 +309,7 @@ private IEnumerator<KeyValuePair<string, IEnumerable<string>>> GetEnumeratorCore
                     // To retain consistent semantics, we need to upgrade a raw string to a HeaderStoreItemInfo
                     // during enumeration so that we can parse the raw value in order to a) return
                     // the correct set of parsed values, and b) update the instance for subsequent enumerations
-                    // to reflect that parsing.  It is safe to write back into the dictionary here because
-                    // the only collection that can be enumerated concurrently is HttpClient.DefaultRequestHeaders,
-                    // and all values in it will be HeaderStoreItemInfo.
-                    Debug.Assert(!_forceHeaderStoreItems);
+                    // to reflect that parsing.
                     _headerStore[descriptor] = info = new HeaderStoreItemInfo() { RawValue = value };
                 }
 
@@ -336,36 +319,16 @@ private IEnumerator<KeyValuePair<string, IEnumerable<string>>> GetEnumeratorCore
                 if (!ParseRawHeaderValues(descriptor, info, removeEmptyHeader: false))
                 {
                     // We have an invalid header value (contains invalid newline chars). Delete it.
-                    // Note that ParseRawHeaderValues locks on the info object, such that only a single
-                    // call to it with the same info will return false, which makes this removal safe to
-                    // do even for HttpClient.DefaultRequestHeaders, which may be enumerated concurrently.
                     _headerStore.Remove(descriptor);
                 }
                 else
                 {
-                    string[] values = GetValuesAsStrings(descriptor, info);
+                    string[] values = GetStoreValuesAsStringArray(descriptor, info);
                     yield return new KeyValuePair<string, IEnumerable<string>>(descriptor.Name, values);
                 }
             }
         }
 
-        internal IEnumerable<KeyValuePair<string, string[]>> EnumerateWithoutValidation()
-        {
-            if (_headerStore == null)
-            {
-                yield break;
-            }
-
-            foreach (KeyValuePair<HeaderDescriptor, object> header in _headerStore)
-            {
-                string[] values = TryGetHeaderValue(header.Key, out object? info) ?
-                    GetValuesAsStrings(header.Key, info) :
-                    Array.Empty<string>();
-
-                yield return new KeyValuePair<string, string[]>(header.Key.Name, values);
-            }
-        }
-
         #endregion
 
         #region IEnumerable Members
@@ -385,7 +348,7 @@ internal void AddParsedValue(HeaderDescriptor descriptor, object value)
             // must not call AddParsedValue(), but SetParsedValue(). E.g. for headers like 'Date', 'Host'.
             Debug.Assert(descriptor.Parser.SupportsMultipleValues, $"Header '{descriptor.Name}' doesn't support multiple values");
 
-            AddValue(info, value, StoreLocation.Parsed);
+            AddParsedValue(info, value);
         }
 
         internal void SetParsedValue(HeaderDescriptor descriptor, object value)
@@ -401,7 +364,7 @@ internal void SetParsedValue(HeaderDescriptor descriptor, object value)
             info.ParsedValue = null;
             info.RawValue = null;
 
-            AddValue(info, value, StoreLocation.Parsed);
+            AddParsedValue(info, value);
         }
 
         internal void SetOrRemoveParsedValue(HeaderDescriptor descriptor, object? value)
@@ -577,7 +540,7 @@ internal virtual void AddHeaders(HttpHeaders sourceHeaders)
                     else
                     {
                         Debug.Assert(sourceValue is string);
-                        _headerStore.Add(header.Key, _forceHeaderStoreItems ? new HeaderStoreItemInfo { RawValue = sourceValue } : sourceValue);
+                        _headerStore.Add(header.Key, sourceValue);
                     }
                 }
             }
@@ -629,12 +592,12 @@ private static void CloneAndAddValue(HeaderStoreItemInfo destinationInfo, object
             // We only have one value. Clone it and assign it to the store.
             if (source is ICloneable cloneableValue)
             {
-                AddValue(destinationInfo, cloneableValue.Clone(), StoreLocation.Parsed);
+                AddParsedValue(destinationInfo, cloneableValue.Clone());
             }
             else
             {
                 // If it doesn't implement ICloneable, it's a value type or an immutable type like String/Uri.
-                AddValue(destinationInfo, source, StoreLocation.Parsed);
+                AddParsedValue(destinationInfo, source);
             }
         }
 
@@ -713,7 +676,7 @@ private void AddHeaderToStore(HeaderDescriptor descriptor, object value)
             (_headerStore ??= new Dictionary<HeaderDescriptor, object>()).Add(descriptor, value);
         }
 
-        private bool TryGetHeaderValue(HeaderDescriptor descriptor, [NotNullWhen(true)] out object? value)
+        internal bool TryGetHeaderValue(HeaderDescriptor descriptor, [NotNullWhen(true)] out object? value)
         {
             if (_headerStore == null)
             {
@@ -747,43 +710,38 @@ private bool TryGetAndParseHeaderInfo(HeaderDescriptor key, [NotNullWhen(true)]
 
         private bool ParseRawHeaderValues(HeaderDescriptor descriptor, HeaderStoreItemInfo info, bool removeEmptyHeader)
         {
-            // Prevent multiple threads from parsing the raw value at the same time, or else we would get
-            // false duplicates or false nulls.
-            lock (info)
+            // Unlike TryGetHeaderInfo() this method tries to parse all non-validated header values (if any)
+            // before returning to the caller.
+            if (info.RawValue != null)
             {
-                // Unlike TryGetHeaderInfo() this method tries to parse all non-validated header values (if any)
-                // before returning to the caller.
-                if (info.RawValue != null)
-                {
-                    List<string>? rawValues = info.RawValue as List<string>;
+                List<string>? rawValues = info.RawValue as List<string>;
 
-                    if (rawValues == null)
-                    {
-                        ParseSingleRawHeaderValue(descriptor, info);
-                    }
-                    else
-                    {
-                        ParseMultipleRawHeaderValues(descriptor, info, rawValues);
-                    }
+                if (rawValues == null)
+                {
+                    ParseSingleRawHeaderValue(descriptor, info);
+                }
+                else
+                {
+                    ParseMultipleRawHeaderValues(descriptor, info, rawValues);
+                }
 
-                    // At this point all values are either in info.ParsedValue, info.InvalidValue, or were removed since they
-                    // contain invalid newline chars. Reset RawValue.
-                    info.RawValue = null;
+                // At this point all values are either in info.ParsedValue, info.InvalidValue, or were removed since they
+                // contain invalid newline chars. Reset RawValue.
+                info.RawValue = null;
 
-                    // During parsing, we removed the value since it contains invalid newline chars. Return false to indicate that
-                    // this is an empty header. If the caller specified to remove empty headers, we'll remove the header before
-                    // returning.
-                    if ((info.InvalidValue == null) && (info.ParsedValue == null))
+                // During parsing, we removed the value since it contains invalid newline chars. Return false to indicate that
+                // this is an empty header. If the caller specified to remove empty headers, we'll remove the header before
+                // returning.
+                if ((info.InvalidValue == null) && (info.ParsedValue == null))
+                {
+                    if (removeEmptyHeader)
                     {
-                        if (removeEmptyHeader)
-                        {
-                            // After parsing the raw value, no value is left because all values contain invalid newline
-                            // chars.
-                            Debug.Assert(_headerStore != null);
-                            _headerStore.Remove(descriptor);
-                        }
-                        return false;
+                        // After parsing the raw value, no value is left because all values contain invalid newline
+                        // chars.
+                        Debug.Assert(_headerStore != null);
+                        _headerStore.Remove(descriptor);
                     }
+                    return false;
                 }
             }
 
@@ -798,7 +756,7 @@ private static void ParseMultipleRawHeaderValues(HeaderDescriptor descriptor, He
                 {
                     if (!ContainsInvalidNewLine(rawValue, descriptor.Name))
                     {
-                        AddValue(info, rawValue, StoreLocation.Parsed);
+                        AddParsedValue(info, rawValue);
                     }
                 }
             }
@@ -823,7 +781,7 @@ private static void ParseSingleRawHeaderValue(HeaderDescriptor descriptor, Heade
             {
                 if (!ContainsInvalidNewLine(rawValue, descriptor.Name))
                 {
-                    AddValue(info, rawValue, StoreLocation.Parsed);
+                    AddParsedValue(info, rawValue);
                 }
             }
             else
@@ -867,11 +825,11 @@ private static bool TryParseAndAddRawHeaderValue(HeaderDescriptor descriptor, He
             // and the current header doesn't support multiple values: e.g. trying to add a date/time value
             // to the 'Date' header if we already have a date/time value will result in the second value being
             // added to the 'invalid' header values.
-            if (!info.CanAddValue(descriptor.Parser))
+            if (!info.CanAddParsedValue(descriptor.Parser))
             {
                 if (addWhenInvalid)
                 {
-                    AddValue(info, value ?? string.Empty, StoreLocation.Invalid);
+                    AddInvalidValue(info, value ?? string.Empty);
                 }
                 return false;
             }
@@ -885,7 +843,7 @@ private static bool TryParseAndAddRawHeaderValue(HeaderDescriptor descriptor, He
                 {
                     if (parsedValue != null)
                     {
-                        AddValue(info, parsedValue, StoreLocation.Parsed);
+                        AddParsedValue(info, parsedValue);
                     }
                     return true;
                 }
@@ -912,7 +870,7 @@ private static bool TryParseAndAddRawHeaderValue(HeaderDescriptor descriptor, He
                     {
                         if (!ContainsInvalidNewLine(value, descriptor.Name) && addWhenInvalid)
                         {
-                            AddValue(info, value, StoreLocation.Invalid);
+                            AddInvalidValue(info, value);
                         }
                         return false;
                     }
@@ -921,7 +879,7 @@ private static bool TryParseAndAddRawHeaderValue(HeaderDescriptor descriptor, He
                 // All values were parsed correctly. Copy results to the store.
                 foreach (object item in parsedValues)
                 {
-                    AddValue(info, item, StoreLocation.Parsed);
+                    AddParsedValue(info, item);
                 }
                 return true;
             }
@@ -929,51 +887,31 @@ private static bool TryParseAndAddRawHeaderValue(HeaderDescriptor descriptor, He
             Debug.Assert(value != null);
             if (!ContainsInvalidNewLine(value, descriptor.Name) && addWhenInvalid)
             {
-                AddValue(info, value ?? string.Empty, StoreLocation.Invalid);
+                AddInvalidValue(info, value ?? string.Empty);
             }
             return false;
         }
 
-        private static void AddValue(HeaderStoreItemInfo info, object? value, StoreLocation location)
+        private static void AddParsedValue(HeaderStoreItemInfo info, object value)
         {
-            // Since we have the same pattern for all three store locations (raw, invalid, parsed), we use
-            // this helper method to deal with adding values:
-            // - if 'null' just set the store property to 'value'
-            // - if 'List<T>' append 'value' to the end of the list
-            // - if 'T', i.e. we have already a value stored (but no list), create a list, add the stored value
-            //   to the list and append 'value' at the end of the newly created list.
-
-            object? currentStoreValue = null;
-            switch (location)
-            {
-                case StoreLocation.Raw:
-                    currentStoreValue = info.RawValue;
-                    AddValueToStoreValue<string>(value, ref currentStoreValue);
-                    info.RawValue = currentStoreValue;
-                    break;
-
-                case StoreLocation.Invalid:
-                    currentStoreValue = info.InvalidValue;
-                    AddValueToStoreValue<string>(value, ref currentStoreValue);
-                    info.InvalidValue = currentStoreValue;
-                    break;
-
-                case StoreLocation.Parsed:
-                    Debug.Assert((value == null) || (!(value is List<object>)),
-                        "Header value types must not derive from List<object> since this type is used internally to store " +
-                        "lists of values. So we would not be able to distinguish between a single value and a list of values.");
-                    currentStoreValue = info.ParsedValue;
-                    AddValueToStoreValue<object>(value, ref currentStoreValue);
-                    info.ParsedValue = currentStoreValue;
-                    break;
-
-                default:
-                    Debug.Fail("Unknown StoreLocation value: " + location.ToString());
-                    break;
-            }
+            Debug.Assert(!(value is List<object>),
+                "Header value types must not derive from List<object> since this type is used internally to store " +
+                "lists of values. So we would not be able to distinguish between a single value and a list of values.");
+
+            AddValueToStoreValue<object>(value, ref info.ParsedValue);
+        }
+
+        private static void AddInvalidValue(HeaderStoreItemInfo info, string value)
+        {
+            AddValueToStoreValue<string>(value, ref info.InvalidValue);
         }
 
-        private static void AddValueToStoreValue<T>(object? value, ref object? currentStoreValue) where T : class
+        private static void AddRawValue(HeaderStoreItemInfo info, string value)
+        {
+            AddValueToStoreValue<string>(value, ref info.RawValue);
+        }
+
+        private static void AddValueToStoreValue<T>(T value, ref object? currentStoreValue) where T : class
         {
             // If there is no value set yet, then add current item as value (we don't create a list
             // if not required). If 'info.Value' is already assigned then make sure 'info.Value' is a
@@ -1037,13 +975,13 @@ private void ParseAndAddValue(HeaderDescriptor descriptor, HeaderStoreItemInfo i
                 // If we don't have a parser for the header, we consider the value valid if it doesn't contains
                 // invalid newline characters. We add the values as "parsed value". Note that we allow empty values.
                 CheckInvalidNewLine(value);
-                AddValue(info, value ?? string.Empty, StoreLocation.Parsed);
+                AddParsedValue(info, value ?? string.Empty);
                 return;
             }
 
             // If the header only supports 1 value, we can add the current value only if there is no
             // value already set.
-            if (!info.CanAddValue(descriptor.Parser))
+            if (!info.CanAddParsedValue(descriptor.Parser))
             {
                 throw new FormatException(SR.Format(System.Globalization.CultureInfo.InvariantCulture, SR.net_http_headers_single_value_header, descriptor.Name));
             }
@@ -1060,7 +998,7 @@ private void ParseAndAddValue(HeaderDescriptor descriptor, HeaderStoreItemInfo i
                 // but we don't add 'null' to the store either.
                 if (parsedValue != null)
                 {
-                    AddValue(info, parsedValue, StoreLocation.Parsed);
+                    AddParsedValue(info, parsedValue);
                 }
                 return;
             }
@@ -1086,7 +1024,7 @@ private void ParseAndAddValue(HeaderDescriptor descriptor, HeaderStoreItemInfo i
             // All values were parsed correctly. Copy results to the store.
             foreach (object item in parsedValues)
             {
-                AddValue(info, item, StoreLocation.Parsed);
+                AddParsedValue(info, item);
             }
         }
 
@@ -1162,46 +1100,46 @@ private static bool ContainsInvalidNewLine(string value, string name)
             return false;
         }
 
-        private static string[] GetValuesAsStrings(HeaderDescriptor descriptor, object value, object? exclude = null)
+        internal static string[] GetStoreValuesAsStringArray(HeaderDescriptor descriptor, HeaderStoreItemInfo info)
+        {
+            GetStoreValuesAsStringOrStringArray(descriptor, info, out string? singleValue, out string[]? multiValue);
+            Debug.Assert(singleValue is not null ^ multiValue is not null);
+            return multiValue ?? new[] { singleValue! };
+        }
+
+        internal static void GetStoreValuesAsStringOrStringArray(HeaderDescriptor descriptor, object sourceValues, out string? singleValue, out string[]? multiValue)
         {
-            HeaderStoreItemInfo? info = value as HeaderStoreItemInfo;
+            HeaderStoreItemInfo? info = sourceValues as HeaderStoreItemInfo;
             if (info is null)
             {
-                Debug.Assert(value is string);
-                return new string[1] { (string)value };
+                Debug.Assert(sourceValues is string);
+                singleValue = (string)sourceValues;
+                multiValue = null;
+                return;
             }
 
             int length = GetValueCount(info);
-            string[] values;
 
-            if (length > 0)
+            Span<string?> values;
+            singleValue = null;
+            if (length == 1)
             {
-                values = new string[length];
-                int currentIndex = 0;
-
-                ReadStoreValues<string?>(values, info.RawValue, null, null, ref currentIndex);
-                ReadStoreValues<object?>(values, info.ParsedValue, descriptor.Parser, exclude, ref currentIndex);
-
-                // Set parser parameter to 'null' for invalid values: The invalid values is always a string so we
-                // don't need the parser to "serialize" the value to a string.
-                ReadStoreValues<string?>(values, info.InvalidValue, null, null, ref currentIndex);
-
-                // The values array may not be full because some values were excluded
-                if (currentIndex < length)
-                {
-                    values = values.AsSpan(0, currentIndex).ToArray();
-                }
+                multiValue = null;
+                values = MemoryMarshal.CreateSpan(ref singleValue, 1);
             }
             else
             {
-                values = Array.Empty<string>();
+                values = multiValue = length != 0 ? new string[length] : Array.Empty<string>();
             }
 
-            Debug.Assert(values != null);
-            return values;
+            int currentIndex = 0;
+            ReadStoreValues<string?>(values, info.RawValue, null, ref currentIndex);
+            ReadStoreValues<object?>(values, info.ParsedValue, descriptor.Parser, ref currentIndex);
+            ReadStoreValues<string?>(values, info.InvalidValue, null, ref currentIndex);
+            Debug.Assert(currentIndex == length);
         }
 
-        internal static int GetValuesAsStrings(HeaderDescriptor descriptor, object sourceValues, [NotNull] ref string[]? values)
+        internal static int GetStoreValuesIntoStringArray(HeaderDescriptor descriptor, object sourceValues, [NotNull] ref string[]? values)
         {
             values ??= Array.Empty<string>();
 
@@ -1229,9 +1167,9 @@ internal static int GetValuesAsStrings(HeaderDescriptor descriptor, object sourc
                 }
 
                 int currentIndex = 0;
-                ReadStoreValues<string?>(values, info.RawValue, null, null, ref currentIndex);
-                ReadStoreValues<object?>(values, info.ParsedValue, descriptor.Parser, null, ref currentIndex);
-                ReadStoreValues<string?>(values, info.InvalidValue, null, null, ref currentIndex);
+                ReadStoreValues<string?>(values, info.RawValue, null, ref currentIndex);
+                ReadStoreValues<object?>(values, info.ParsedValue, descriptor.Parser, ref currentIndex);
+                ReadStoreValues<string?>(values, info.InvalidValue, null, ref currentIndex);
                 Debug.Assert(currentIndex == length);
             }
 
@@ -1253,55 +1191,29 @@ static int Count<T>(object? valueStore) =>
                 1;
         }
 
-        private static void ReadStoreValues<T>(string?[] values, object? storeValue, HttpHeaderParser? parser,
-            T exclude, ref int currentIndex)
+        private static void ReadStoreValues<T>(Span<string?> values, object? storeValue, HttpHeaderParser? parser, ref int currentIndex)
         {
-            Debug.Assert(values != null);
-
             if (storeValue != null)
             {
                 List<T>? storeValues = storeValue as List<T>;
 
                 if (storeValues == null)
                 {
-                    if (ShouldAdd<T>(storeValue, parser, exclude))
-                    {
-                        values[currentIndex] = parser == null ? storeValue.ToString() : parser.ToString(storeValue);
-                        currentIndex++;
-                    }
+                    values[currentIndex] = parser == null ? storeValue.ToString() : parser.ToString(storeValue);
+                    currentIndex++;
                 }
                 else
                 {
                     foreach (object? item in storeValues)
                     {
-                        if (ShouldAdd<T>(item, parser, exclude))
-                        {
-                            Debug.Assert(item != null);
-                            values[currentIndex] = parser == null ? item.ToString() : parser.ToString(item);
-                            currentIndex++;
-                        }
+                        Debug.Assert(item != null);
+                        values[currentIndex] = parser == null ? item.ToString() : parser.ToString(item);
+                        currentIndex++;
                     }
                 }
             }
         }
 
-        private static bool ShouldAdd<T>(object? storeValue, HttpHeaderParser? parser, T exclude)
-        {
-            bool add = true;
-            if (parser != null && exclude != null)
-            {
-                if (parser.Comparer != null)
-                {
-                    add = !parser.Comparer.Equals(exclude, storeValue);
-                }
-                else
-                {
-                    add = !exclude.Equals(storeValue);
-                }
-            }
-            return add;
-        }
-
         private bool AreEqual(object value, object? storeValue, IEqualityComparer? comparer)
         {
             Debug.Assert(value != null);
@@ -1315,17 +1227,15 @@ private bool AreEqual(object value, object? storeValue, IEqualityComparer? compa
             return value.Equals(storeValue);
         }
 
-        #region Private Classes
-
         internal sealed class HeaderStoreItemInfo
         {
             internal HeaderStoreItemInfo() { }
 
-            internal object? RawValue { get; set; }
-            internal object? InvalidValue { get; set; }
-            internal object? ParsedValue { get; set; }
+            internal object? RawValue;
+            internal object? InvalidValue;
+            internal object? ParsedValue;
 
-            internal bool CanAddValue(HttpHeaderParser parser)
+            internal bool CanAddParsedValue(HttpHeaderParser parser)
             {
                 Debug.Assert(parser != null, "There should be no reason to call CanAddValue if there is no parser for the current header.");
 
@@ -1343,6 +1253,5 @@ internal bool CanAddValue(HttpHeaderParser parser)
 
             internal bool IsEmpty => (RawValue == null) && (InvalidValue == null) && (ParsedValue == null);
         }
-        #endregion
     }
 }
diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/Headers/HttpHeadersNonValidated.cs b/src/libraries/System.Net.Http/src/System/Net/Http/Headers/HttpHeadersNonValidated.cs
new file mode 100644
index 00000000000000..ad1a1850ea83c4
--- /dev/null
+++ b/src/libraries/System.Net.Http/src/System/Net/Http/Headers/HttpHeadersNonValidated.cs
@@ -0,0 +1,172 @@
+// 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;
+using System.Collections.Generic;
+using System.Diagnostics;
+
+namespace System.Net.Http.Headers
+{
+    /// <summary>Provides a view on top of a <see cref="HttpHeaders"/> collection that avoids forcing validation or parsing on its contents.</summary>
+    /// <remarks>
+    /// The view surfaces data as it's stored in the headers collection.  Any header values that have not yet been parsed / validated won't be
+    /// as part of any accesses from this view, e.g. a raw header value of "one, two" that hasn't yet been parsed due to other operations
+    /// on the <see cref="HttpHeaders"/> will be surfaced as a single header value rather than two.  For any header values that have already
+    /// been parsed and validated, that value will be converted to a string to be returned from operations on this view.
+    /// </remarks>
+    public readonly struct HttpHeadersNonValidated : IReadOnlyDictionary<string, HeaderStringValues>
+    {
+        /// <summary>The wrapped headers collection.</summary>
+        private readonly HttpHeaders? _headers;
+
+        /// <summary>Initializes the view.</summary>
+        /// <param name="headers">The wrapped headers collection.</param>
+        internal HttpHeadersNonValidated(HttpHeaders headers) => _headers = headers;
+
+        /// <summary>Gets the number of headers stored in the collection.</summary>
+        /// <remarks>Multiple header values associated with the same header name are considered to be one header as far as this count is concerned.</remarks>
+        public int Count => _headers?.HeaderStore?.Count ?? 0;
+
+        /// <summary>Gets whether the collection contains the specified header.</summary>
+        /// <param name="headerName">The name of the header.</param>
+        /// <returns>true if the collection contains the header; otherwise, false.</returns>
+        public bool Contains(string headerName) =>
+            _headers is HttpHeaders headers &&
+            HeaderDescriptor.TryGet(headerName, out HeaderDescriptor descriptor) &&
+            headers.TryGetHeaderValue(descriptor, out _);
+
+        /// <summary>Gets the values for the specified header name.</summary>
+        /// <param name="headerName">The name of the header.</param>
+        /// <returns>The values for the specified header.</returns>
+        /// <exception cref="KeyNotFoundException">The header was not contained in the collection.</exception>
+        public HeaderStringValues this[string headerName]
+        {
+            get
+            {
+                if (TryGetValues(headerName, out HeaderStringValues values))
+                {
+                    return values;
+                }
+
+                throw new KeyNotFoundException(SR.net_http_headers_not_found);
+            }
+        }
+
+        /// <inheritdoc/>
+        bool IReadOnlyDictionary<string, HeaderStringValues>.ContainsKey(string key) => Contains(key);
+
+        /// <summary>Attempts to retrieve the values associated with the specified header name.</summary>
+        /// <param name="headerName">The name of the header.</param>
+        /// <param name="values">The retrieved header values.</param>
+        /// <returns>true if the collection contains the specified header; otherwise, false.</returns>
+        public bool TryGetValues(string headerName, out HeaderStringValues values)
+        {
+            if (_headers is HttpHeaders headers &&
+                HeaderDescriptor.TryGet(headerName, out HeaderDescriptor descriptor) &&
+                headers.TryGetHeaderValue(descriptor, out object? info))
+            {
+                HttpHeaders.GetStoreValuesAsStringOrStringArray(descriptor, info, out string? singleValue, out string[]? multiValue);
+                Debug.Assert(singleValue is not null ^ multiValue is not null);
+                values = singleValue is not null ?
+                    new HeaderStringValues(descriptor, singleValue) :
+                    new HeaderStringValues(descriptor, multiValue!);
+                return true;
+            }
+
+            values = default;
+            return false;
+        }
+
+        /// <inheritdoc/>
+        bool IReadOnlyDictionary<string, HeaderStringValues>.TryGetValue(string key, out HeaderStringValues value) => TryGetValues(key, out value);
+
+        /// <summary>Gets an enumerator that iterates through the <see cref="HttpHeadersNonValidated"/>.</summary>
+        /// <returns>An enumerator that iterates through the <see cref="HttpHeadersNonValidated"/>.</returns>
+        public Enumerator GetEnumerator() =>
+            _headers is HttpHeaders headers && headers.HeaderStore is Dictionary<HeaderDescriptor, object> store ?
+                new Enumerator(store.GetEnumerator()) :
+                default;
+
+        /// <inheritdoc/>
+        IEnumerator<KeyValuePair<string, HeaderStringValues>> IEnumerable<KeyValuePair<string, HeaderStringValues>>.GetEnumerator() => GetEnumerator();
+
+        /// <inheritdoc/>
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+        /// <inheritdoc/>
+        IEnumerable<string> IReadOnlyDictionary<string, HeaderStringValues>.Keys
+        {
+            get
+            {
+                foreach (KeyValuePair<string, HeaderStringValues> header in this)
+                {
+                    yield return header.Key;
+                }
+            }
+        }
+
+        /// <inheritdoc/>
+        IEnumerable<HeaderStringValues> IReadOnlyDictionary<string, HeaderStringValues>.Values
+        {
+            get
+            {
+                foreach (KeyValuePair<string, HeaderStringValues> header in this)
+                {
+                    yield return header.Value;
+                }
+            }
+        }
+
+        /// <summary>Enumerates the elements of a <see cref="HttpHeadersNonValidated"/>.</summary>
+        public struct Enumerator : IEnumerator<KeyValuePair<string, HeaderStringValues>>
+        {
+            /// <summary>The wrapped enumerator for the underlying headers dictionary.</summary>
+            private Dictionary<HeaderDescriptor, object>.Enumerator _headerStoreEnumerator;
+            /// <summary>The current value.</summary>
+            private KeyValuePair<string, HeaderStringValues> _current;
+            /// <summary>true if the enumerator was constructed via the ctor; otherwise, false./</summary>
+            private bool _valid;
+
+            /// <summary>Initializes the enumerator.</summary>
+            /// <param name="headerStoreEnumerator">The underlying dictionary enumerator.</param>
+            internal Enumerator(Dictionary<HeaderDescriptor, object>.Enumerator headerStoreEnumerator)
+            {
+                _headerStoreEnumerator = headerStoreEnumerator;
+                _current = default;
+                _valid = true;
+            }
+
+            /// <inheritdoc/>
+            public bool MoveNext()
+            {
+                if (_valid && _headerStoreEnumerator.MoveNext())
+                {
+                    KeyValuePair<HeaderDescriptor, object> current = _headerStoreEnumerator.Current;
+
+                    HttpHeaders.GetStoreValuesAsStringOrStringArray(current.Key, current.Value, out string? singleValue, out string[]? multiValue);
+                    Debug.Assert(singleValue is not null ^ multiValue is not null);
+
+                    _current = new KeyValuePair<string, HeaderStringValues>(
+                        current.Key.Name,
+                        singleValue is not null ? new HeaderStringValues(current.Key, singleValue) : new HeaderStringValues(current.Key, multiValue!));
+                    return true;
+                }
+
+                _current = default;
+                return false;
+            }
+
+            /// <inheritdoc/>
+            public KeyValuePair<string, HeaderStringValues> Current => _current;
+
+            /// <inheritdoc/>
+            object IEnumerator.Current => _current;
+
+            /// <inheritdoc/>
+            public void Dispose() { }
+
+            /// <inheritdoc/>
+            void IEnumerator.Reset() => throw new NotSupportedException();
+        }
+    }
+}
diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/Headers/HttpRequestHeaders.cs b/src/libraries/System.Net.Http/src/System/Net/Http/Headers/HttpRequestHeaders.cs
index 20c663676e5ab0..f3035cc6687b3a 100644
--- a/src/libraries/System.Net.Http/src/System/Net/Http/Headers/HttpRequestHeaders.cs
+++ b/src/libraries/System.Net.Http/src/System/Net/Http/Headers/HttpRequestHeaders.cs
@@ -261,11 +261,6 @@ internal HttpRequestHeaders()
         {
         }
 
-        internal HttpRequestHeaders(bool forceHeaderStoreItems)
-            : base(HttpHeaderType.General | HttpHeaderType.Request | HttpHeaderType.Custom, HttpHeaderType.Response, forceHeaderStoreItems)
-        {
-        }
-
         internal override void AddHeaders(HttpHeaders sourceHeaders)
         {
             base.AddHeaders(sourceHeaders);
diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/HttpClient.cs b/src/libraries/System.Net.Http/src/System/Net/Http/HttpClient.cs
index b09850ec9a4b0d..514744fee99d5d 100644
--- a/src/libraries/System.Net.Http/src/System/Net/Http/HttpClient.cs
+++ b/src/libraries/System.Net.Http/src/System/Net/Http/HttpClient.cs
@@ -43,7 +43,7 @@ public static IWebProxy DefaultProxy
         }
 
         public HttpRequestHeaders DefaultRequestHeaders =>
-            _defaultRequestHeaders ??= new HttpRequestHeaders(forceHeaderStoreItems: true);
+            _defaultRequestHeaders ??= new HttpRequestHeaders();
 
         public Version DefaultRequestVersion
         {
@@ -552,8 +552,9 @@ private void CheckRequestBeforeSend(HttpRequestMessage request)
         {
             if (request == null)
             {
-                throw new ArgumentNullException(nameof(request));
+                throw new ArgumentNullException(nameof(request), SR.net_http_handler_norequest);
             }
+
             CheckDisposed();
             CheckRequestMessage(request);
 
diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/MultipartContent.cs b/src/libraries/System.Net.Http/src/System/Net/Http/MultipartContent.cs
index 8227b4bdfdad63..4ac7a34a126950 100644
--- a/src/libraries/System.Net.Http/src/System/Net/Http/MultipartContent.cs
+++ b/src/libraries/System.Net.Http/src/System/Net/Http/MultipartContent.cs
@@ -4,7 +4,6 @@
 using System.Buffers;
 using System.Collections.Generic;
 using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using System.Net.Http.Headers;
 using System.Text;
@@ -333,7 +332,7 @@ private void SerializeHeadersToStream(Stream stream, HttpContent content, bool w
             }
 
             // Add headers.
-            foreach (KeyValuePair<string, IEnumerable<string>> headerPair in content.Headers)
+            foreach (KeyValuePair<string, HeaderStringValues> headerPair in content.Headers.NonValidated)
             {
                 Encoding headerValueEncoding = HeaderEncodingSelector?.Invoke(headerPair.Key, content) ?? HttpRuleParser.DefaultHttpEncoding;
 
@@ -388,7 +387,7 @@ protected internal override bool TryComputeLength(out long length)
             foreach (HttpContent content in _nestedContent)
             {
                 // Headers.
-                foreach (KeyValuePair<string, IEnumerable<string>> headerPair in content.Headers)
+                foreach (KeyValuePair<string, HeaderStringValues> headerPair in content.Headers.NonValidated)
                 {
                     currentLength += headerPair.Key.Length + ColonSpaceLength;
 
diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/AuthenticationHelper.NtAuth.cs b/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/AuthenticationHelper.NtAuth.cs
index c16c2b18b9012f..74abe97e80de91 100644
--- a/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/AuthenticationHelper.NtAuth.cs
+++ b/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/AuthenticationHelper.NtAuth.cs
@@ -119,7 +119,7 @@ private static async Task<HttpResponseMessage> SendWithNtAuthAsync(HttpRequestMe
                         }
 
                         ChannelBinding? channelBinding = connection.TransportContext?.GetChannelBinding(ChannelBindingKind.Endpoint);
-                        NTAuthentication authContext = new NTAuthentication(isServer: false, challenge.SchemeName, challenge.Credential, spn, ContextFlagsPal.Connection, channelBinding);
+                        NTAuthentication authContext = new NTAuthentication(isServer: false, challenge.SchemeName, challenge.Credential, spn, ContextFlagsPal.Connection | ContextFlagsPal.InitIntegrity, channelBinding);
                         string? challengeData = challenge.ChallengeData;
                         try
                         {
diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/ConnectHelper.cs b/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/ConnectHelper.cs
index b26f927d7e4ddf..97e8478fa7487e 100644
--- a/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/ConnectHelper.cs
+++ b/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/ConnectHelper.cs
@@ -101,7 +101,6 @@ private static async ValueTask<SslStream> EstablishSslConnectionAsyncCore(bool a
             return sslStream;
         }
 
-        // TODO: SupportedOSPlatform doesn't work for internal APIs https://github.com/dotnet/runtime/issues/51305
         [SupportedOSPlatform("windows")]
         [SupportedOSPlatform("linux")]
         [SupportedOSPlatform("macos")]
diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/Http2Connection.cs b/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/Http2Connection.cs
index 703a340d5128e3..c60370d6d8052d 100644
--- a/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/Http2Connection.cs
+++ b/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/Http2Connection.cs
@@ -1136,7 +1136,7 @@ private void WriteHeaderCollection(HttpRequestMessage request, HttpHeaders heade
             ref string[]? tmpHeaderValuesArray = ref t_headerValues;
             foreach (KeyValuePair<HeaderDescriptor, object> header in headers.HeaderStore)
             {
-                int headerValuesCount = HttpHeaders.GetValuesAsStrings(header.Key, header.Value, ref tmpHeaderValuesArray);
+                int headerValuesCount = HttpHeaders.GetStoreValuesIntoStringArray(header.Key, header.Value, ref tmpHeaderValuesArray);
                 Debug.Assert(headerValuesCount > 0, "No values for header??");
                 ReadOnlySpan<string> headerValues = tmpHeaderValuesArray.AsSpan(0, headerValuesCount);
 
diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/Http3Connection.cs b/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/Http3Connection.cs
index ca6dd5df9fc830..c091127350068a 100644
--- a/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/Http3Connection.cs
+++ b/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/Http3Connection.cs
@@ -14,7 +14,6 @@
 
 namespace System.Net.Http
 {
-    // TODO: SupportedOSPlatform doesn't work for internal APIs https://github.com/dotnet/runtime/issues/51305
     [SupportedOSPlatform("windows")]
     [SupportedOSPlatform("linux")]
     [SupportedOSPlatform("macos")]
@@ -49,11 +48,6 @@ internal sealed class Http3Connection : HttpConnectionBase, IDisposable
         private int _haveServerQpackDecodeStream;
         private int _haveServerQpackEncodeStream;
 
-        // Manages MAX_STREAM count from server.
-        private long _maximumRequestStreams;
-        private long _requestStreamsRemaining;
-        private readonly Queue<TaskCompletionSourceWithCancellation<bool>> _waitingRequests = new Queue<TaskCompletionSourceWithCancellation<bool>>();
-
         // A connection-level error will abort any future operations.
         private Exception? _abortException;
 
@@ -87,8 +81,6 @@ public Http3Connection(HttpConnectionPool pool, HttpAuthority? origin, HttpAutho
             string altUsedValue = altUsedDefaultPort ? authority.IdnHost : authority.IdnHost + ":" + authority.Port.ToString(Globalization.CultureInfo.InvariantCulture);
             _altUsedEncodedHeader = QPack.QPackEncoder.EncodeLiteralHeaderFieldWithoutNameReferenceToArray(KnownHeaders.AltUsed.Name, altUsedValue);
 
-            _maximumRequestStreams = _requestStreamsRemaining = connection.GetRemoteAvailableBidirectionalStreamCount();
-
             // Errors are observed via Abort().
             _ = SendSettingsAsync();
 
@@ -166,45 +158,34 @@ public override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage req
         {
             Debug.Assert(async);
 
-            // Wait for an available stream (based on QUIC MAX_STREAMS) if there isn't one available yet.
-
-            TaskCompletionSourceWithCancellation<bool>? waitForAvailableStreamTcs = null;
-
-            lock (SyncObj)
-            {
-                long remaining = _requestStreamsRemaining;
-
-                if (remaining > 0)
-                {
-                    _requestStreamsRemaining = remaining - 1;
-                }
-                else
-                {
-                    waitForAvailableStreamTcs = new TaskCompletionSourceWithCancellation<bool>();
-                    _waitingRequests.Enqueue(waitForAvailableStreamTcs);
-                }
-            }
-
-            if (waitForAvailableStreamTcs != null)
-            {
-                await waitForAvailableStreamTcs.WaitWithCancellationAsync(cancellationToken).ConfigureAwait(false);
-            }
-
             // Allocate an active request
-
             QuicStream? quicStream = null;
             Http3RequestStream? requestStream = null;
+            ValueTask waitTask = default;
 
             try
             {
-                lock (SyncObj)
+                while (true)
                 {
-                    if (_connection != null)
+                    lock (SyncObj)
                     {
-                        quicStream = _connection.OpenBidirectionalStream();
-                        requestStream = new Http3RequestStream(request, this, quicStream);
-                        _activeRequests.Add(quicStream, requestStream);
+                        if (_connection == null)
+                        {
+                            break;
+                        }
+
+                        if (_connection.GetRemoteAvailableBidirectionalStreamCount() > 0)
+                        {
+                            quicStream = _connection.OpenBidirectionalStream();
+                            requestStream = new Http3RequestStream(request, this, quicStream);
+                            _activeRequests.Add(quicStream, requestStream);
+                            break;
+                        }
+                        waitTask = _connection.WaitForAvailableBidirectionalStreamsAsync(cancellationToken);
                     }
+
+                    // Wait for an available stream (based on QUIC MAX_STREAMS) if there isn't one available yet.
+                    await waitTask.ConfigureAwait(false);
                 }
 
                 if (quicStream == null)
@@ -212,8 +193,6 @@ public override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage req
                     throw new HttpRequestException(SR.net_http_request_aborted, null, RequestRetryType.RetryOnConnectionFailure);
                 }
 
-                // 0-byte write to force QUIC to allocate a stream ID.
-                await quicStream.WriteAsync(Array.Empty<byte>(), cancellationToken).ConfigureAwait(false);
                 requestStream!.StreamId = quicStream.StreamId;
 
                 bool goAway;
@@ -246,76 +225,6 @@ public override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage req
             }
         }
 
-        /// <summary>
-        /// Waits for MAX_STREAMS to be raised by the server.
-        /// </summary>
-        private Task WaitForAvailableRequestStreamAsync(CancellationToken cancellationToken)
-        {
-            TaskCompletionSourceWithCancellation<bool> tcs;
-
-            lock (SyncObj)
-            {
-                long remaining = _requestStreamsRemaining;
-
-                if (remaining > 0)
-                {
-                    _requestStreamsRemaining = remaining - 1;
-                    return Task.CompletedTask;
-                }
-
-                tcs = new TaskCompletionSourceWithCancellation<bool>();
-                _waitingRequests.Enqueue(tcs);
-            }
-
-            // Note: cancellation on connection shutdown is handled in CancelWaiters.
-            return tcs.WaitWithCancellationAsync(cancellationToken).AsTask();
-        }
-
-        /// <summary>
-        /// Cancels any waiting SendAsync calls.
-        /// </summary>
-        /// <remarks>Requires <see cref="SyncObj"/> to be held.</remarks>
-        private void CancelWaiters()
-        {
-            Debug.Assert(Monitor.IsEntered(SyncObj));
-
-            while (_waitingRequests.TryDequeue(out TaskCompletionSourceWithCancellation<bool>? tcs))
-            {
-                tcs.TrySetException(new HttpRequestException(SR.net_http_request_aborted, null, RequestRetryType.RetryOnConnectionFailure));
-            }
-        }
-
-        // TODO: how do we get this event? -> HandleEventStreamsAvailable reports currently available Uni/Bi streams
-        private void OnMaximumStreamCountIncrease(long newMaximumStreamCount)
-        {
-            lock (SyncObj)
-            {
-                if (newMaximumStreamCount <= _maximumRequestStreams)
-                {
-                    return;
-                }
-
-                IncreaseRemainingStreamCount(newMaximumStreamCount - _maximumRequestStreams);
-                _maximumRequestStreams = newMaximumStreamCount;
-            }
-        }
-
-        private void IncreaseRemainingStreamCount(long delta)
-        {
-            Debug.Assert(Monitor.IsEntered(SyncObj));
-            Debug.Assert(delta > 0);
-
-            _requestStreamsRemaining += delta;
-
-            while (_requestStreamsRemaining != 0 && _waitingRequests.TryDequeue(out TaskCompletionSourceWithCancellation<bool>? tcs))
-            {
-                if (tcs.TrySetResult(true))
-                {
-                    --_requestStreamsRemaining;
-                }
-            }
-        }
-
         /// <summary>
         /// Aborts the connection with an error.
         /// </summary>
@@ -358,7 +267,6 @@ internal Exception Abort(Exception abortException)
                     _connectionClosedTask = _connection.CloseAsync((long)connectionResetErrorCode).AsTask();
                 }
 
-                CancelWaiters();
                 CheckForShutdown();
             }
 
@@ -396,7 +304,6 @@ private void OnServerGoAway(long lastProcessedStreamId)
                     }
                 }
 
-                CancelWaiters();
                 CheckForShutdown();
             }
 
@@ -414,8 +321,6 @@ public void RemoveStream(QuicStream stream)
                 bool removed = _activeRequests.Remove(stream);
                 Debug.Assert(removed == true);
 
-                IncreaseRemainingStreamCount(1);
-
                 if (ShuttingDown)
                 {
                     CheckForShutdown();
diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/Http3ConnectionException.cs b/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/Http3ConnectionException.cs
index caa666a0afc285..dbb22d36a79c5e 100644
--- a/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/Http3ConnectionException.cs
+++ b/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/Http3ConnectionException.cs
@@ -7,7 +7,6 @@
 namespace System.Net.Http
 {
     [Serializable]
-    // TODO: SupportedOSPlatform doesn't work for internal APIs https://github.com/dotnet/runtime/issues/51305
     [SupportedOSPlatform("windows")]
     [SupportedOSPlatform("linux")]
     [SupportedOSPlatform("macos")]
diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/Http3ProtocolException.cs b/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/Http3ProtocolException.cs
index 829c08f2468ae1..c3731643a238c1 100644
--- a/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/Http3ProtocolException.cs
+++ b/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/Http3ProtocolException.cs
@@ -7,7 +7,6 @@
 namespace System.Net.Http
 {
     [Serializable]
-    // TODO: SupportedOSPlatform doesn't work for internal APIs https://github.com/dotnet/runtime/issues/51305
     [SupportedOSPlatform("windows")]
     [SupportedOSPlatform("linux")]
     [SupportedOSPlatform("macos")]
diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/Http3RequestStream.cs b/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/Http3RequestStream.cs
index 970890ddcd9fbe..3d469f06c3b5f9 100644
--- a/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/Http3RequestStream.cs
+++ b/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/Http3RequestStream.cs
@@ -16,7 +16,6 @@
 
 namespace System.Net.Http
 {
-    // TODO: SupportedOSPlatform doesn't work for internal APIs https://github.com/dotnet/runtime/issues/51305
     [SupportedOSPlatform("windows")]
     [SupportedOSPlatform("linux")]
     [SupportedOSPlatform("macos")]
@@ -587,7 +586,7 @@ private void BufferHeaderCollection(HttpHeaders headers)
 
             foreach (KeyValuePair<HeaderDescriptor, object> header in headers.HeaderStore)
             {
-                int headerValuesCount = HttpHeaders.GetValuesAsStrings(header.Key, header.Value, ref _headerValues);
+                int headerValuesCount = HttpHeaders.GetStoreValuesIntoStringArray(header.Key, header.Value, ref _headerValues);
                 Debug.Assert(headerValuesCount > 0, "No values for header??");
                 ReadOnlySpan<string> headerValues = _headerValues.AsSpan(0, headerValuesCount);
 
diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/HttpConnection.cs b/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/HttpConnection.cs
index 01640d13692906..00e3f3b6fe322f 100644
--- a/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/HttpConnection.cs
+++ b/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/HttpConnection.cs
@@ -263,7 +263,7 @@ private async ValueTask WriteHeadersAsync(HttpHeaders headers, string? cookiesFr
                         await WriteTwoBytesAsync((byte)':', (byte)' ', async).ConfigureAwait(false);
                     }
 
-                    int headerValuesCount = HttpHeaders.GetValuesAsStrings(header.Key, header.Value, ref _headerValues);
+                    int headerValuesCount = HttpHeaders.GetStoreValuesIntoStringArray(header.Key, header.Value, ref _headerValues);
                     Debug.Assert(headerValuesCount > 0, "No values for header??");
                     if (headerValuesCount > 0)
                     {
diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/HttpConnectionPool.cs b/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/HttpConnectionPool.cs
index 2e0f7dce5bb757..00a1a376799e2c 100644
--- a/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/HttpConnectionPool.cs
+++ b/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/HttpConnectionPool.cs
@@ -75,10 +75,6 @@ internal sealed class HttpConnectionPool : IDisposable
         private SemaphoreSlim? _http2ConnectionCreateLock;
         private byte[]? _http2AltSvcOriginUri;
         internal readonly byte[]? _http2EncodedAuthorityHostHeader;
-
-        [SupportedOSPlatformGuard("linux")]
-        [SupportedOSPlatformGuard("macOS")]
-        [SupportedOSPlatformGuard("Windows")]
         private readonly bool _http3Enabled;
         private Http3Connection? _http3Connection;
         private SemaphoreSlim? _http3ConnectionCreateLock;
@@ -287,6 +283,7 @@ public HttpConnectionPool(HttpConnectionPoolManager poolManager, HttpConnectionK
         [SupportedOSPlatformGuard("macOS")]
         [SupportedOSPlatformGuard("Windows")]
         internal static bool IsHttp3Supported() => (OperatingSystem.IsLinux() && !OperatingSystem.IsAndroid()) || OperatingSystem.IsWindows() || OperatingSystem.IsMacOS();
+
         private static readonly List<SslApplicationProtocol> s_http3ApplicationProtocols = CreateHttp3ApplicationProtocols();
         private static readonly List<SslApplicationProtocol> s_http2ApplicationProtocols = new List<SslApplicationProtocol>() { SslApplicationProtocol.Http2, SslApplicationProtocol.Http11 };
         private static readonly List<SslApplicationProtocol> s_http2OnlyApplicationProtocols = new List<SslApplicationProtocol>() { SslApplicationProtocol.Http2 };
@@ -667,7 +664,6 @@ private void AddHttp2Connection(Http2Connection newConnection)
             }
         }
 
-        // TODO: SupportedOSPlatform doesn't work for internal APIs https://github.com/dotnet/runtime/issues/51305
         [SupportedOSPlatform("windows")]
         [SupportedOSPlatform("linux")]
         [SupportedOSPlatform("macos")]
@@ -767,7 +763,6 @@ private async ValueTask<Http3Connection> GetHttp3ConnectionAsync(HttpRequestMess
         }
 
         // Returns null if HTTP3 cannot be used.
-        // TODO: SupportedOSPlatform doesn't work for internal APIs https://github.com/dotnet/runtime/issues/51305
         [SupportedOSPlatform("windows")]
         [SupportedOSPlatform("linux")]
         [SupportedOSPlatform("macos")]
@@ -1004,7 +999,7 @@ internal void HandleAltSvc(IEnumerable<string> altSvcHeaderValues, TimeSpan? res
 
                     if (nextAuthority == null && value != null && value.AlpnProtocolName == "h3")
                     {
-                        var authority = new HttpAuthority(value.Host!, value.Port);
+                        var authority = new HttpAuthority(value.Host ?? _originAuthority!.IdnHost, value.Port);
 
                         if (IsAltSvcBlocked(authority))
                         {
diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/HttpConnectionSettings.cs b/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/HttpConnectionSettings.cs
index 1ccbc3d8673d1d..3c19737ae40032 100644
--- a/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/HttpConnectionSettings.cs
+++ b/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/HttpConnectionSettings.cs
@@ -187,7 +187,6 @@ private static bool AllowDraftHttp3
 
         private byte[]? _http3SettingsFrame;
 
-        // TODO: SupportedOSPlatform doesn't work for internal APIs https://github.com/dotnet/runtime/issues/51305
         [SupportedOSPlatform("windows")]
         [SupportedOSPlatform("linux")]
         [SupportedOSPlatform("macos")]
diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/SocketsHttpHandler.cs b/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/SocketsHttpHandler.cs
index 31a9e6ac2cc1e0..6f392af09ac4df 100644
--- a/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/SocketsHttpHandler.cs
+++ b/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/SocketsHttpHandler.cs
@@ -43,7 +43,7 @@ private void CheckDisposedOrStarted()
         /// Gets a value that indicates whether the handler is supported on the current platform.
         /// </summary>
         [UnsupportedOSPlatformGuard("browser")]
-        public static bool IsSupported => true;
+        public static bool IsSupported => !OperatingSystem.IsBrowser();
 
         public bool UseCookies
         {
@@ -500,6 +500,11 @@ private HttpMessageHandlerStage SetupHandlerChain()
         protected internal override HttpResponseMessage Send(HttpRequestMessage request,
             CancellationToken cancellationToken)
         {
+            if (request == null)
+            {
+                throw new ArgumentNullException(nameof(request), SR.net_http_handler_norequest);
+            }
+
             if (request.Version.Major >= 2)
             {
                 throw new NotSupportedException(SR.Format(SR.net_http_http2_sync_not_supported, GetType()));
@@ -528,6 +533,11 @@ protected internal override HttpResponseMessage Send(HttpRequestMessage request,
 
         protected internal override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
         {
+            if (request == null)
+            {
+                throw new ArgumentNullException(nameof(request), SR.net_http_handler_norequest);
+            }
+
             CheckDisposed();
 
             if (cancellationToken.IsCancellationRequested)
diff --git a/src/libraries/System.Net.Http/tests/FunctionalTests/DiagnosticsTests.cs b/src/libraries/System.Net.Http/tests/FunctionalTests/DiagnosticsTests.cs
index e9f993cb03dc7b..1fb6fd925fd33c 100644
--- a/src/libraries/System.Net.Http/tests/FunctionalTests/DiagnosticsTests.cs
+++ b/src/libraries/System.Net.Http/tests/FunctionalTests/DiagnosticsTests.cs
@@ -17,8 +17,6 @@
 
 namespace System.Net.Http.Functional.Tests
 {
-    using Configuration = System.Net.Test.Common.Configuration;
-
     public abstract class DiagnosticsTest : HttpClientHandlerTestBase
     {
         private const string EnableActivityPropagationEnvironmentVariableSettingName = "DOTNET_SYSTEM_NET_HTTP_ENABLEACTIVITYPROPAGATION";
@@ -27,6 +25,8 @@ public abstract class DiagnosticsTest : HttpClientHandlerTestBase
         private static bool EnableActivityPropagationEnvironmentVariableIsNotSetAndRemoteExecutorSupported =>
             string.IsNullOrEmpty(Environment.GetEnvironmentVariable(EnableActivityPropagationEnvironmentVariableSettingName)) && RemoteExecutor.IsSupported;
 
+        private static readonly Uri InvalidUri = new("http://nosuchhost.invalid");
+
         public DiagnosticsTest(ITestOutputHelper output) : base(output) { }
 
         [Fact]
@@ -46,43 +46,36 @@ public void EventSource_ExistsWithCorrectId()
         // could interfere with the tests, as well as the enabling of tracing interfering
         // with those tests.
 
-        /// <remarks>
-        /// This test must be in the same test collection as any others testing HttpClient/WinHttpHandler
-        /// DiagnosticSources, since the global logging mechanism makes them conflict inherently.
-        /// </remarks>
-        [OuterLoop("Uses external servers")]
         [ConditionalFact(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))]
         public void SendAsync_ExpectedDiagnosticSourceLogging()
         {
-            RemoteExecutor.Invoke(useVersionString =>
+            RemoteExecutor.Invoke(async (useVersion, testAsync) =>
             {
-                bool requestLogged = false;
+                HttpRequestMessage requestLogged = null;
+                HttpResponseMessage responseLogged = null;
                 Guid requestGuid = Guid.Empty;
-                bool responseLogged = false;
                 Guid responseGuid = Guid.Empty;
                 bool exceptionLogged = false;
                 bool activityLogged = false;
 
+                TaskCompletionSource responseLoggedTcs = new(TaskCreationOptions.RunContinuationsAsynchronously);
+
                 var diagnosticListenerObserver = new FakeDiagnosticListenerObserver(kvp =>
                 {
                     if (kvp.Key.Equals("System.Net.Http.Request"))
                     {
                         Assert.NotNull(kvp.Value);
-                        GetPropertyValueFromAnonymousTypeInstance<HttpRequestMessage>(kvp.Value, "Request");
-                        requestGuid = GetPropertyValueFromAnonymousTypeInstance<Guid>(kvp.Value, "LoggingRequestId");
-                        requestLogged = true;
+                        requestLogged = GetProperty<HttpRequestMessage>(kvp.Value, "Request");
+                        requestGuid = GetProperty<Guid>(kvp.Value, "LoggingRequestId");
                     }
                     else if (kvp.Key.Equals("System.Net.Http.Response"))
                     {
                         Assert.NotNull(kvp.Value);
-
-                        GetPropertyValueFromAnonymousTypeInstance<HttpResponseMessage>(kvp.Value, "Response");
-                        responseGuid = GetPropertyValueFromAnonymousTypeInstance<Guid>(kvp.Value, "LoggingRequestId");
-                        var requestStatus =
-                            GetPropertyValueFromAnonymousTypeInstance<TaskStatus>(kvp.Value, "RequestTaskStatus");
+                        responseLogged = GetProperty<HttpResponseMessage>(kvp.Value, "Response");
+                        responseGuid = GetProperty<Guid>(kvp.Value, "LoggingRequestId");
+                        TaskStatus requestStatus = GetProperty<TaskStatus>(kvp.Value, "RequestTaskStatus");
                         Assert.Equal(TaskStatus.RanToCompletion, requestStatus);
-
-                        responseLogged = true;
+                        responseLoggedTcs.SetResult();
                     }
                     else if (kvp.Key.Equals("System.Net.Http.Exception"))
                     {
@@ -97,32 +90,30 @@ public void SendAsync_ExpectedDiagnosticSourceLogging()
                 using (DiagnosticListener.AllListeners.Subscribe(diagnosticListenerObserver))
                 {
                     diagnosticListenerObserver.Enable(s => !s.Contains("HttpRequestOut"));
-                    using (HttpClient client = CreateHttpClient(useVersionString))
-                    {
-                        client.GetAsync(Configuration.Http.RemoteEchoServer).Result.Dispose();
-                    }
 
-                    Assert.True(requestLogged, "Request was not logged.");
-                    // Poll with a timeout since logging response is not synchronized with returning a response.
-                    WaitForTrue(() => responseLogged, TimeSpan.FromSeconds(1),
-                        "Response was not logged within 1 second timeout.");
+                    await GetFactoryForVersion(useVersion).CreateClientAndServerAsync(
+                        async uri =>
+                        {
+                            (HttpRequestMessage request, HttpResponseMessage response) = await GetAsync(useVersion, testAsync, uri);
+
+                            await responseLoggedTcs.Task;
+
+                            Assert.Same(request, requestLogged);
+                            Assert.Same(response, responseLogged);
+                        },
+                        async server => await server.HandleRequestAsync());
+
                     Assert.Equal(requestGuid, responseGuid);
                     Assert.False(exceptionLogged, "Exception was logged for successful request");
                     Assert.False(activityLogged, "HttpOutReq was logged while HttpOutReq logging was disabled");
-                    diagnosticListenerObserver.Disable();
                 }
-            }, UseVersion.ToString()).Dispose();
+            }, UseVersion.ToString(), TestAsync.ToString()).Dispose();
         }
 
-        /// <remarks>
-        /// This test must be in the same test collection as any others testing HttpClient/WinHttpHandler
-        /// DiagnosticSources, since the global logging mechanism makes them conflict inherently.
-        /// </remarks>
-        [OuterLoop("Uses external servers")]
         [ConditionalFact(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))]
         public void SendAsync_ExpectedDiagnosticSourceNoLogging()
         {
-            RemoteExecutor.Invoke(useVersionString =>
+            RemoteExecutor.Invoke(async (useVersion, testAsync) =>
             {
                 bool requestLogged = false;
                 bool responseLogged = false;
@@ -151,36 +142,36 @@ public void SendAsync_ExpectedDiagnosticSourceNoLogging()
 
                 using (DiagnosticListener.AllListeners.Subscribe(diagnosticListenerObserver))
                 {
-                    using (HttpClient client = CreateHttpClient(useVersionString))
-                    {
-                        LoopbackServer.CreateServerAsync(async (server, url) =>
+                    await GetFactoryForVersion(useVersion).CreateClientAndServerAsync(
+                        async uri =>
                         {
-                            Task<List<string>> requestLines = server.AcceptConnectionSendResponseAndCloseAsync();
-                            Task<HttpResponseMessage> response = client.GetAsync(url);
-                            await new Task[] { response, requestLines }.WhenAllOrAnyFailed();
-
-                            AssertNoHeadersAreInjected(requestLines.Result);
-                            response.Result.Dispose();
-                        }).GetAwaiter().GetResult();
-                    }
+                            await GetAsync(useVersion, testAsync, uri);
+                        },
+                        async server =>
+                        {
+                            HttpRequestData request = await server.AcceptConnectionSendResponseAndCloseAsync();
+                            AssertNoHeadersAreInjected(request);
+                        });
 
                     Assert.False(requestLogged, "Request was logged while logging disabled.");
                     Assert.False(activityStartLogged, "HttpRequestOut.Start was logged while logging disabled.");
-                    WaitForFalse(() => responseLogged, TimeSpan.FromSeconds(1),
-                        "Response was logged while logging disabled.");
+                    Assert.False(responseLogged, "Response was logged while logging disabled.");
                     Assert.False(activityStopLogged, "HttpRequestOut.Stop was logged while logging disabled.");
                 }
-            }, UseVersion.ToString()).Dispose();
+            }, UseVersion.ToString(), TestAsync.ToString()).Dispose();
         }
 
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/1477", TestPlatforms.AnyUnix)]
-        [OuterLoop("Uses external servers")]
         [ConditionalTheory(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))]
         [InlineData(false)]
         [InlineData(true)]
         public void SendAsync_HttpTracingEnabled_Succeeds(bool useSsl)
         {
-            RemoteExecutor.Invoke(async (useVersionString, useSslString) =>
+            if (useSsl && UseVersion == HttpVersion.Version20 && !PlatformDetection.SupportsAlpn)
+            {
+                return;
+            }
+
+            RemoteExecutor.Invoke(async (useVersion, useSsl, testAsync) =>
             {
                 using (var listener = new TestEventListener("Private.InternalDiagnostics.System.Net.Http", EventLevel.Verbose))
                 {
@@ -188,28 +179,10 @@ public void SendAsync_HttpTracingEnabled_Succeeds(bool useSsl)
                     await listener.RunWithCallbackAsync(events.Enqueue, async () =>
                     {
                         // Exercise various code paths to get coverage of tracing
-                        using (HttpClient client = CreateHttpClient(useVersionString))
-                        {
-                            // Do a get to a loopback server
-                            await LoopbackServer.CreateServerAsync(async (server, url) =>
-                            {
-                                await TestHelper.WhenAllCompletedOrAnyFailed(
-                                    server.AcceptConnectionSendResponseAndCloseAsync(),
-                                    client.GetAsync(url));
-                            });
-
-                            // Do a post to a remote server
-                            byte[] expectedData = Enumerable.Range(0, 20000).Select(i => unchecked((byte)i)).ToArray();
-                            Uri remoteServer = bool.Parse(useSslString)
-                                ? Configuration.Http.SecureRemoteEchoServer
-                                : Configuration.Http.RemoteEchoServer;
-                            var content = new ByteArrayContent(expectedData);
-                            content.Headers.ContentMD5 = TestHelper.ComputeMD5Hash(expectedData);
-                            using (HttpResponseMessage response = await client.PostAsync(remoteServer, content))
-                            {
-                                Assert.Equal(HttpStatusCode.OK, response.StatusCode);
-                            }
-                        }
+                        await GetFactoryForVersion(useVersion).CreateClientAndServerAsync(
+                            async uri => await GetAsync(useVersion, testAsync, uri),
+                            async server => await server.HandleRequestAsync(),
+                            options: new GenericLoopbackOptions { UseSsl = bool.Parse(useSsl) });
                     });
 
                     // We don't validate receiving specific events, but rather that we do at least
@@ -219,119 +192,127 @@ await TestHelper.WhenAllCompletedOrAnyFailed(
                         ev => ev.EventId == 0); // make sure there are no event source error messages
                     Assert.InRange(events.Count, 1, int.MaxValue);
                 }
-            }, UseVersion.ToString(), useSsl.ToString()).Dispose();
+            }, UseVersion.ToString(), useSsl.ToString(), TestAsync.ToString()).Dispose();
         }
 
-        [OuterLoop("Uses external servers")]
         [ConditionalFact(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))]
         public void SendAsync_ExpectedDiagnosticExceptionLogging()
         {
-            RemoteExecutor.Invoke(useVersionString =>
+            RemoteExecutor.Invoke(async (useVersion, testAsync) =>
             {
-                bool exceptionLogged = false;
-                bool responseLogged = false;
+                Exception exceptionLogged = null;
+
+                TaskCompletionSource responseLoggedTcs = new(TaskCreationOptions.RunContinuationsAsynchronously);
+
                 var diagnosticListenerObserver = new FakeDiagnosticListenerObserver(kvp =>
                 {
                     if (kvp.Key.Equals("System.Net.Http.Response"))
                     {
                         Assert.NotNull(kvp.Value);
-                        var requestStatus =
-                            GetPropertyValueFromAnonymousTypeInstance<TaskStatus>(kvp.Value, "RequestTaskStatus");
+                        TaskStatus requestStatus = GetProperty<TaskStatus>(kvp.Value, "RequestTaskStatus");
                         Assert.Equal(TaskStatus.Faulted, requestStatus);
-
-                        responseLogged = true;
+                        responseLoggedTcs.SetResult();
                     }
                     else if (kvp.Key.Equals("System.Net.Http.Exception"))
                     {
                         Assert.NotNull(kvp.Value);
-                        GetPropertyValueFromAnonymousTypeInstance<Exception>(kvp.Value, "Exception");
-
-                        exceptionLogged = true;
+                        exceptionLogged = GetProperty<Exception>(kvp.Value, "Exception");
                     }
                 });
 
                 using (DiagnosticListener.AllListeners.Subscribe(diagnosticListenerObserver))
                 {
-                    diagnosticListenerObserver.Enable(s => !s.Contains("HttpRequestOut"));
-                    using (HttpClient client = CreateHttpClient(useVersionString))
-                    {
-                        Assert.ThrowsAsync<HttpRequestException>(() => client.GetAsync($"http://_{Guid.NewGuid().ToString("N")}.com"))
-                            .GetAwaiter().GetResult();
-                    }
+                    diagnosticListenerObserver.Enable();
+
+                    Exception ex = await Assert.ThrowsAsync<HttpRequestException>(() => GetAsync(useVersion, testAsync, InvalidUri));
+
+                    await responseLoggedTcs.Task;
 
-                    // Poll with a timeout since logging response is not synchronized with returning a response.
-                    WaitForTrue(() => responseLogged, TimeSpan.FromSeconds(1),
-                        "Response with exception was not logged within 1 second timeout.");
-                    Assert.True(exceptionLogged, "Exception was not logged");
-                    diagnosticListenerObserver.Disable();
+                    Assert.Same(ex, exceptionLogged);
                 }
-            }, UseVersion.ToString()).Dispose();
+            }, UseVersion.ToString(), TestAsync.ToString()).Dispose();
         }
 
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/23167")]
-        [OuterLoop("Uses external servers")]
         [ConditionalFact(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))]
         public void SendAsync_ExpectedDiagnosticCancelledLogging()
         {
-            RemoteExecutor.Invoke(useVersionString =>
+            RemoteExecutor.Invoke(async (useVersion, testAsync) =>
             {
-                bool cancelLogged = false;
+                TaskCompletionSource responseLoggedTcs = new(TaskCreationOptions.RunContinuationsAsynchronously);
+                TaskCompletionSource activityStopTcs = new(TaskCreationOptions.RunContinuationsAsynchronously);
+
                 var diagnosticListenerObserver = new FakeDiagnosticListenerObserver(kvp =>
                 {
                     if (kvp.Key.Equals("System.Net.Http.Response"))
                     {
                         Assert.NotNull(kvp.Value);
-                        var status =
-                            GetPropertyValueFromAnonymousTypeInstance<TaskStatus>(kvp.Value, "RequestTaskStatus");
+                        TaskStatus status = GetProperty<TaskStatus>(kvp.Value, "RequestTaskStatus");
                         Assert.Equal(TaskStatus.Canceled, status);
-                        Volatile.Write(ref cancelLogged, true);
+                        responseLoggedTcs.SetResult();
+                    }
+                    else if (kvp.Key == "System.Net.Http.HttpRequestOut.Stop")
+                    {
+                        Assert.NotNull(kvp.Value);
+                        GetProperty<HttpRequestMessage>(kvp.Value, "Request");
+                        TaskStatus status = GetProperty<TaskStatus>(kvp.Value, "RequestTaskStatus");
+                        Assert.Equal(TaskStatus.Canceled, status);
+                        activityStopTcs.SetResult();;
                     }
                 });
 
                 using (DiagnosticListener.AllListeners.Subscribe(diagnosticListenerObserver))
                 {
-                    diagnosticListenerObserver.Enable(s => !s.Contains("HttpRequestOut"));
-                    using (HttpClient client = CreateHttpClient(useVersionString))
-                    {
-                        LoopbackServer.CreateServerAsync(async (server, url) =>
+                    diagnosticListenerObserver.Enable();
+
+                    var cts = new CancellationTokenSource();
+
+                    await GetFactoryForVersion(useVersion).CreateClientAndServerAsync(
+                        async uri =>
                         {
-                            CancellationTokenSource tcs = new CancellationTokenSource();
-                            Task request = server.AcceptConnectionAsync(connection =>
+                            await Assert.ThrowsAsync<TaskCanceledException>(() => GetAsync(useVersion, testAsync, uri, cts.Token));
+                        },
+                        async server =>
+                        {
+                            await server.AcceptConnectionAsync(async connection =>
                             {
-                                tcs.Cancel();
-                                return connection.ReadRequestHeaderAndSendResponseAsync();
+                                cts.Cancel();
+
+                                await responseLoggedTcs.Task;
+                                await activityStopTcs.Task;
                             });
-                            Task response = client.GetAsync(url, tcs.Token);
-                            await Assert.ThrowsAnyAsync<Exception>(() =>
-                                TestHelper.WhenAllCompletedOrAnyFailed(response, request));
-                        }).GetAwaiter().GetResult();
-                    }
+                        });
                 }
-
-                // Poll with a timeout since logging response is not synchronized with returning a response.
-                WaitForTrue(() => Volatile.Read(ref cancelLogged), TimeSpan.FromSeconds(1),
-                    "Cancellation was not logged within 1 second timeout.");
-                diagnosticListenerObserver.Disable();
-            }, UseVersion.ToString()).Dispose();
+            }, UseVersion.ToString(), TestAsync.ToString()).Dispose();
         }
 
-        [ConditionalFact(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))]
-        public void SendAsync_ExpectedDiagnosticSourceActivityLoggingRequestId()
+        [ConditionalTheory(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))]
+        [InlineData(ActivityIdFormat.Hierarchical)]
+        [InlineData(ActivityIdFormat.W3C)]
+        public void SendAsync_ExpectedDiagnosticSourceActivityLogging(ActivityIdFormat idFormat)
         {
-            RemoteExecutor.Invoke(useVersionString =>
+            RemoteExecutor.Invoke(async (useVersion, testAsync, idFormatString) =>
             {
+                ActivityIdFormat idFormat = Enum.Parse<ActivityIdFormat>(idFormatString);
+
                 bool requestLogged = false;
                 bool responseLogged = false;
-                bool activityStartLogged = false;
-                bool activityStopLogged = false;
                 bool exceptionLogged = false;
+                HttpRequestMessage activityStartRequestLogged = null;
+                HttpRequestMessage activityStopRequestLogged = null;
+                HttpResponseMessage activityStopResponseLogged = null;
+
+                TaskCompletionSource activityStopTcs = new(TaskCreationOptions.RunContinuationsAsynchronously);
 
                 Activity parentActivity = new Activity("parent");
+                parentActivity.SetIdFormat(idFormat);
                 parentActivity.AddBaggage("correlationId", Guid.NewGuid().ToString("N").ToString());
                 parentActivity.AddBaggage("moreBaggage", Guid.NewGuid().ToString("N").ToString());
-                parentActivity.AddTag("tag", "tag"); //add tag to ensure it is not injected into request
+                parentActivity.AddTag("tag", "tag"); // add tag to ensure it is not injected into request
+
                 parentActivity.Start();
 
+                Assert.Equal(idFormat, parentActivity.IdFormat);
+
                 var diagnosticListenerObserver = new FakeDiagnosticListenerObserver(kvp =>
                 {
                     if (kvp.Key.Equals("System.Net.Http.Request"))
@@ -351,9 +332,7 @@ public void SendAsync_ExpectedDiagnosticSourceActivityLoggingRequestId()
                         Assert.NotNull(kvp.Value);
                         Assert.NotNull(Activity.Current);
                         Assert.Equal(parentActivity, Activity.Current.Parent);
-                        GetPropertyValueFromAnonymousTypeInstance<HttpRequestMessage>(kvp.Value, "Request");
-
-                        activityStartLogged = true;
+                        activityStartRequestLogged = GetProperty<HttpRequestMessage>(kvp.Value, "Request");
                     }
                     else if (kvp.Key.Equals("System.Net.Http.HttpRequestOut.Stop"))
                     {
@@ -361,136 +340,51 @@ public void SendAsync_ExpectedDiagnosticSourceActivityLoggingRequestId()
                         Assert.NotNull(Activity.Current);
                         Assert.Equal(parentActivity, Activity.Current.Parent);
                         Assert.True(Activity.Current.Duration != TimeSpan.Zero);
-                        GetPropertyValueFromAnonymousTypeInstance<HttpRequestMessage>(kvp.Value, "Request");
-                        GetPropertyValueFromAnonymousTypeInstance<HttpResponseMessage>(kvp.Value, "Response");
-                        var requestStatus =
-                            GetPropertyValueFromAnonymousTypeInstance<TaskStatus>(kvp.Value, "RequestTaskStatus");
+                        activityStopRequestLogged = GetProperty<HttpRequestMessage>(kvp.Value, "Request");
+                        activityStopResponseLogged = GetProperty<HttpResponseMessage>(kvp.Value, "Response");
+                        TaskStatus requestStatus = GetProperty<TaskStatus>(kvp.Value, "RequestTaskStatus");
                         Assert.Equal(TaskStatus.RanToCompletion, requestStatus);
-
-                        activityStopLogged = true;
+                        activityStopTcs.SetResult();;
                     }
                 });
 
                 using (DiagnosticListener.AllListeners.Subscribe(diagnosticListenerObserver))
                 {
                     diagnosticListenerObserver.Enable(s => s.Contains("HttpRequestOut"));
-                    using (HttpClient client = CreateHttpClient(useVersionString))
-                    {
-                        LoopbackServer.CreateServerAsync(async (server, url) =>
-                        {
-                            Task<List<string>> requestLines = server.AcceptConnectionSendResponseAndCloseAsync();
-                            Task<HttpResponseMessage> response = client.GetAsync(url);
-                            await new Task[] { response, requestLines }.WhenAllOrAnyFailed();
-
-                            AssertHeadersAreInjected(requestLines.Result, parentActivity);
-                            response.Result.Dispose();
-                        }).GetAwaiter().GetResult();
-                    }
-
-                    Assert.True(activityStartLogged, "HttpRequestOut.Start was not logged.");
-                    Assert.False(requestLogged, "Request was logged when Activity logging was enabled.");
-                    // Poll with a timeout since logging response is not synchronized with returning a response.
-                    WaitForTrue(() => activityStopLogged, TimeSpan.FromSeconds(1),
-                        "HttpRequestOut.Stop was not logged within 1 second timeout.");
-                    Assert.False(exceptionLogged, "Exception was logged for successful request");
-                    Assert.False(responseLogged, "Response was logged when Activity logging was enabled.");
-                    diagnosticListenerObserver.Disable();
-                }
-            }, UseVersion.ToString()).Dispose();
-        }
-
-        [ConditionalFact(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))]
-        public void SendAsync_ExpectedDiagnosticSourceActivityLoggingW3C()
-        {
-            RemoteExecutor.Invoke(useVersionString =>
-            {
-                bool requestLogged = false;
-                bool responseLogged = false;
-                bool activityStartLogged = false;
-                bool activityStopLogged = false;
-                bool exceptionLogged = false;
-
-                Activity parentActivity = new Activity("parent");
-                parentActivity.SetParentId(ActivityTraceId.CreateRandom(), ActivitySpanId.CreateRandom());
-                parentActivity.AddBaggage("moreBaggage", Guid.NewGuid().ToString("N").ToString());
-                parentActivity.Start();
 
-                var diagnosticListenerObserver = new FakeDiagnosticListenerObserver(kvp =>
-                {
-                    if (kvp.Key.Equals("System.Net.Http.Request"))
-                    {
-                        requestLogged = true;
-                    }
-                    else if (kvp.Key.Equals("System.Net.Http.Response"))
-                    {
-                        responseLogged = true;
-                    }
-                    else if (kvp.Key.Equals("System.Net.Http.Exception"))
-                    {
-                        exceptionLogged = true;
-                    }
-                    else if (kvp.Key.Equals("System.Net.Http.HttpRequestOut.Start"))
-                    {
-                        Assert.NotNull(kvp.Value);
-                        Assert.NotNull(Activity.Current);
-                        Assert.Equal(parentActivity, Activity.Current.Parent);
-                        GetPropertyValueFromAnonymousTypeInstance<HttpRequestMessage>(kvp.Value, "Request");
-
-                        activityStartLogged = true;
-                    }
-                    else if (kvp.Key.Equals("System.Net.Http.HttpRequestOut.Stop"))
-                    {
-                        Assert.NotNull(kvp.Value);
-                        Assert.NotNull(Activity.Current);
-                        Assert.Equal(parentActivity, Activity.Current.Parent);
-                        Assert.True(Activity.Current.Duration != TimeSpan.Zero);
-                        GetPropertyValueFromAnonymousTypeInstance<HttpRequestMessage>(kvp.Value, "Request");
-                        GetPropertyValueFromAnonymousTypeInstance<HttpResponseMessage>(kvp.Value, "Response");
-                        var requestStatus =
-                            GetPropertyValueFromAnonymousTypeInstance<TaskStatus>(kvp.Value, "RequestTaskStatus");
-                        Assert.Equal(TaskStatus.RanToCompletion, requestStatus);
+                    await GetFactoryForVersion(useVersion).CreateClientAndServerAsync(
+                        async uri =>
+                        {
+                            (HttpRequestMessage request, HttpResponseMessage response) = await GetAsync(useVersion, testAsync, uri);
 
-                        activityStopLogged = true;
-                    }
-                });
+                            await activityStopTcs.Task;
 
-                using (DiagnosticListener.AllListeners.Subscribe(diagnosticListenerObserver))
-                {
-                    diagnosticListenerObserver.Enable(s => s.Contains("HttpRequestOut"));
-                    using (HttpClient client = CreateHttpClient(useVersionString))
-                    {
-                        LoopbackServer.CreateServerAsync(async (server, url) =>
+                            Assert.Same(request, activityStartRequestLogged);
+                            Assert.Same(request, activityStopRequestLogged);
+                            Assert.Same(response, activityStopResponseLogged);
+                        },
+                        async server =>
                         {
-                            Task<List<string>> requestLines = server.AcceptConnectionSendResponseAndCloseAsync();
-                            Task<HttpResponseMessage> response = client.GetAsync(url);
-                            await new Task[] { response, requestLines }.WhenAllOrAnyFailed();
-
-                            AssertHeadersAreInjected(requestLines.Result, parentActivity);
-                            response.Result.Dispose();
-                        }).GetAwaiter().GetResult();
-                    }
+                            HttpRequestData requestData = await server.AcceptConnectionSendResponseAndCloseAsync();
+                            AssertHeadersAreInjected(requestData, parentActivity);
+                        });
 
-                    Assert.True(activityStartLogged, "HttpRequestOut.Start was not logged.");
                     Assert.False(requestLogged, "Request was logged when Activity logging was enabled.");
-                    // Poll with a timeout since logging response is not synchronized with returning a response.
-                    WaitForTrue(() => activityStopLogged, TimeSpan.FromSeconds(1),
-                        "HttpRequestOut.Stop was not logged within 1 second timeout.");
                     Assert.False(exceptionLogged, "Exception was logged for successful request");
                     Assert.False(responseLogged, "Response was logged when Activity logging was enabled.");
-                    diagnosticListenerObserver.Disable();
                 }
-            }, UseVersion.ToString()).Dispose();
+            }, UseVersion.ToString(), TestAsync.ToString(), idFormat.ToString()).Dispose();
         }
 
-        [OuterLoop("Uses external servers")]
         [ConditionalFact(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))]
         public void SendAsync_ExpectedDiagnosticSourceActivityLogging_InvalidBaggage()
         {
-            RemoteExecutor.Invoke(useVersionString =>
+            RemoteExecutor.Invoke(async (useVersion, testAsync) =>
             {
-                bool activityStopLogged = false;
                 bool exceptionLogged = false;
 
+                TaskCompletionSource activityStopTcs = new(TaskCreationOptions.RunContinuationsAsynchronously);
+
                 Activity parentActivity = new Activity("parent");
                 parentActivity.SetIdFormat(ActivityIdFormat.Hierarchical);
                 parentActivity.AddBaggage("bad/key", "value");
@@ -506,18 +400,16 @@ public void SendAsync_ExpectedDiagnosticSourceActivityLogging_InvalidBaggage()
                         Assert.NotNull(Activity.Current);
                         Assert.Equal(parentActivity, Activity.Current.Parent);
                         Assert.True(Activity.Current.Duration != TimeSpan.Zero);
-                        var request = GetPropertyValueFromAnonymousTypeInstance<HttpRequestMessage>(kvp.Value, "Request");
+                        HttpRequestMessage request = GetProperty<HttpRequestMessage>(kvp.Value, "Request");
                         Assert.True(request.Headers.TryGetValues("Request-Id", out var requestId));
                         Assert.True(request.Headers.TryGetValues("Correlation-Context", out var correlationContext));
                         Assert.Equal(3, correlationContext.Count());
                         Assert.Contains("key=value", correlationContext);
                         Assert.Contains("bad%2Fkey=value", correlationContext);
                         Assert.Contains("goodkey=bad%2Fvalue", correlationContext);
-
-                        var requestStatus = GetPropertyValueFromAnonymousTypeInstance<TaskStatus>(kvp.Value, "RequestTaskStatus");
+                        TaskStatus requestStatus = GetProperty<TaskStatus>(kvp.Value, "RequestTaskStatus");
                         Assert.Equal(TaskStatus.RanToCompletion, requestStatus);
-
-                        activityStopLogged = true;
+                        activityStopTcs.SetResult();;
                     }
                     else if (kvp.Key.Equals("System.Net.Http.Exception"))
                     {
@@ -528,27 +420,29 @@ public void SendAsync_ExpectedDiagnosticSourceActivityLogging_InvalidBaggage()
                 using (DiagnosticListener.AllListeners.Subscribe(diagnosticListenerObserver))
                 {
                     diagnosticListenerObserver.Enable(s => s.Contains("HttpRequestOut"));
-                    using (HttpClient client = CreateHttpClient(useVersionString))
-                    {
-                        client.GetAsync(Configuration.Http.RemoteEchoServer).Result.Dispose();
-                    }
 
-                    // Poll with a timeout since logging response is not synchronized with returning a response.
-                    WaitForTrue(() => activityStopLogged, TimeSpan.FromSeconds(1), "Response was not logged within 1 second timeout.");
+                    await GetFactoryForVersion(useVersion).CreateClientAndServerAsync(
+                        async uri =>
+                        {
+                            await GetAsync(useVersion, testAsync, uri);
+                        },
+                        async server => await server.HandleRequestAsync());
+
+                    await activityStopTcs.Task;
+
                     Assert.False(exceptionLogged, "Exception was logged for successful request");
-                    diagnosticListenerObserver.Disable();
                 }
-            }, UseVersion.ToString()).Dispose();
+            }, UseVersion.ToString(), TestAsync.ToString()).Dispose();
         }
 
-        [OuterLoop("Uses external servers")]
         [ConditionalFact(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))]
         public void SendAsync_ExpectedDiagnosticSourceActivityLoggingDoesNotOverwriteHeader()
         {
-            RemoteExecutor.Invoke(useVersionString =>
+            RemoteExecutor.Invoke(async (useVersion, testAsync) =>
             {
                 bool activityStartLogged = false;
-                bool activityStopLogged = false;
+
+                TaskCompletionSource activityStopTcs = new(TaskCreationOptions.RunContinuationsAsynchronously);
 
                 Activity parentActivity = new Activity("parent");
                 parentActivity.SetIdFormat(ActivityIdFormat.Hierarchical);
@@ -560,52 +454,49 @@ public void SendAsync_ExpectedDiagnosticSourceActivityLoggingDoesNotOverwriteHea
                 {
                     if (kvp.Key.Equals("System.Net.Http.HttpRequestOut.Start"))
                     {
-                        var request =
-                            GetPropertyValueFromAnonymousTypeInstance<HttpRequestMessage>(kvp.Value, "Request");
+                        HttpRequestMessage request = GetProperty<HttpRequestMessage>(kvp.Value, "Request");
                         request.Headers.Add("Request-Id", customRequestIdHeader);
 
                         activityStartLogged = true;
                     }
                     else if (kvp.Key.Equals("System.Net.Http.HttpRequestOut.Stop"))
                     {
-                        var request =
-                            GetPropertyValueFromAnonymousTypeInstance<HttpRequestMessage>(kvp.Value, "Request");
+                        HttpRequestMessage request = GetProperty<HttpRequestMessage>(kvp.Value, "Request");
                         Assert.Single(request.Headers.GetValues("Request-Id"));
                         Assert.Equal(customRequestIdHeader, request.Headers.GetValues("Request-Id").Single());
 
                         Assert.False(request.Headers.TryGetValues("traceparent", out var _));
                         Assert.False(request.Headers.TryGetValues("tracestate", out var _));
-                        activityStopLogged = true;
+                        activityStopTcs.SetResult();;
                     }
                 });
 
                 using (DiagnosticListener.AllListeners.Subscribe(diagnosticListenerObserver))
                 {
                     diagnosticListenerObserver.Enable();
-                    using (HttpClient client = CreateHttpClient(useVersionString))
-                    {
-                        client.GetAsync(Configuration.Http.RemoteEchoServer).Result.Dispose();
-                    }
 
-                    Assert.True(activityStartLogged, "HttpRequestOut.Start was not logged.");
+                    await GetFactoryForVersion(useVersion).CreateClientAndServerAsync(
+                        async uri =>
+                        {
+                            await GetAsync(useVersion, testAsync, uri);
+                        },
+                        async server => await server.HandleRequestAsync());
 
-                    // Poll with a timeout since logging response is not synchronized with returning a response.
-                    WaitForTrue(() => activityStopLogged, TimeSpan.FromSeconds(1),
-                        "HttpRequestOut.Stop was not logged within 1 second timeout.");
-                    diagnosticListenerObserver.Disable();
+                    await activityStopTcs.Task;
+
+                    Assert.True(activityStartLogged, "HttpRequestOut.Start was not logged.");
                 }
-            }, UseVersion.ToString()).Dispose();
+            }, UseVersion.ToString(), TestAsync.ToString()).Dispose();
         }
 
-        [OuterLoop("Uses external servers")]
         [ConditionalFact(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))]
         public void SendAsync_ExpectedDiagnosticSourceActivityLoggingDoesNotOverwriteW3CTraceParentHeader()
         {
-            Assert.True(UseVersion.Major < 2, "The test currently only supports HTTP/1.");
-            RemoteExecutor.Invoke((useVersionString, testAsyncString) =>
+            RemoteExecutor.Invoke(async (useVersion, testAsync) =>
             {
                 bool activityStartLogged = false;
-                bool activityStopLogged = false;
+
+                TaskCompletionSource activityStopTcs = new(TaskCreationOptions.RunContinuationsAsynchronously);
 
                 Activity parentActivity = new Activity("parent");
                 parentActivity.SetParentId(ActivityTraceId.CreateRandom(), ActivitySpanId.CreateRandom());
@@ -617,8 +508,7 @@ public void SendAsync_ExpectedDiagnosticSourceActivityLoggingDoesNotOverwriteW3C
                 {
                     if (kvp.Key.Equals("System.Net.Http.HttpRequestOut.Start"))
                     {
-                        var request =
-                            GetPropertyValueFromAnonymousTypeInstance<HttpRequestMessage>(kvp.Value, "Request");
+                        HttpRequestMessage request = GetProperty<HttpRequestMessage>(kvp.Value, "Request");
                         Assert.Single(request.Headers.GetValues("traceparent"));
                         Assert.False(request.Headers.TryGetValues("tracestate", out var _));
                         Assert.Equal(customTraceParentHeader, request.Headers.GetValues("traceparent").Single());
@@ -629,35 +519,38 @@ public void SendAsync_ExpectedDiagnosticSourceActivityLoggingDoesNotOverwriteW3C
                     }
                     else if (kvp.Key.Equals("System.Net.Http.HttpRequestOut.Stop"))
                     {
-                        activityStopLogged = true;
+                        activityStopTcs.SetResult();;
                     }
                 });
 
                 using (DiagnosticListener.AllListeners.Subscribe(diagnosticListenerObserver))
                 {
                     diagnosticListenerObserver.Enable();
-                    using (var request = new HttpRequestMessage(HttpMethod.Get, Configuration.Http.RemoteEchoServer))
-                    using (HttpClient client = CreateHttpClient(useVersionString))
-                    {
-                        request.Headers.Add("traceparent", customTraceParentHeader);
-                        client.SendAsync(bool.Parse(testAsyncString), request).Result.Dispose();
-                    }
 
-                    Assert.True(activityStartLogged, "HttpRequestOut.Start was not logged.");
+                    await GetFactoryForVersion(useVersion).CreateClientAndServerAsync(
+                        async uri =>
+                        {
+                            using HttpClient client = CreateHttpClient(useVersion);
+                            var request = new HttpRequestMessage(HttpMethod.Get, uri)
+                            {
+                                Version = Version.Parse(useVersion)
+                            };
+                            request.Headers.Add("traceparent", customTraceParentHeader);
+                            await client.SendAsync(bool.Parse(testAsync), request);
+                        },
+                        async server => await server.HandleRequestAsync());
+
+                    await activityStopTcs.Task;
 
-                    // Poll with a timeout since logging response is not synchronized with returning a response.
-                    WaitForTrue(() => activityStopLogged, TimeSpan.FromSeconds(1),
-                        "HttpRequestOut.Stop was not logged within 1 second timeout.");
-                    diagnosticListenerObserver.Disable();
+                    Assert.True(activityStartLogged, "HttpRequestOut.Start was not logged.");
                 }
             }, UseVersion.ToString(), TestAsync.ToString()).Dispose();
         }
 
-        [OuterLoop("Uses external servers")]
         [ConditionalFact(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))]
         public void SendAsync_ExpectedDiagnosticSourceUrlFilteredActivityLogging()
         {
-            RemoteExecutor.Invoke(useVersionString =>
+            RemoteExecutor.Invoke(async (useVersion, testAsync) =>
             {
                 bool activityStartLogged = false;
                 bool activityStopLogged = false;
@@ -676,157 +569,155 @@ public void SendAsync_ExpectedDiagnosticSourceUrlFilteredActivityLogging()
 
                 using (DiagnosticListener.AllListeners.Subscribe(diagnosticListenerObserver))
                 {
-                    diagnosticListenerObserver.Enable((s, r, _) =>
-                    {
-                        if (s.StartsWith("System.Net.Http.HttpRequestOut"))
+                    await GetFactoryForVersion(useVersion).CreateClientAndServerAsync(
+                        async uri =>
                         {
-                            var request = r as HttpRequestMessage;
-                            if (request != null)
-                                return !request.RequestUri.Equals(Configuration.Http.RemoteEchoServer);
-                        }
+                            diagnosticListenerObserver.Enable((s, r, _) =>
+                            {
+                                if (s.StartsWith("System.Net.Http.HttpRequestOut") && r is HttpRequestMessage request)
+                                {
+                                    return request.RequestUri != uri;
+                                }
+                                return true;
+                            });
 
-                        return true;
-                    });
-                    using (HttpClient client = CreateHttpClient(useVersionString))
-                    {
-                        client.GetAsync(Configuration.Http.RemoteEchoServer).Result.Dispose();
-                    }
+                            await GetAsync(useVersion, testAsync, uri);
+                        },
+                        async server => await server.HandleRequestAsync());
 
                     Assert.False(activityStartLogged, "HttpRequestOut.Start was logged while URL disabled.");
-                    // Poll with a timeout since logging response is not synchronized with returning a response.
                     Assert.False(activityStopLogged, "HttpRequestOut.Stop was logged while URL disabled.");
-                    diagnosticListenerObserver.Disable();
                 }
-            }, UseVersion.ToString()).Dispose();
+            }, UseVersion.ToString(), TestAsync.ToString()).Dispose();
         }
 
-        [OuterLoop("Uses external servers")]
         [ConditionalFact(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))]
         public void SendAsync_ExpectedDiagnosticExceptionActivityLogging()
         {
-            RemoteExecutor.Invoke(useVersionString =>
+            RemoteExecutor.Invoke(async (useVersion, testAsync) =>
             {
-                bool exceptionLogged = false;
-                bool activityStopLogged = false;
+                Exception exceptionLogged = null;
+
+                TaskCompletionSource activityStopTcs = new(TaskCreationOptions.RunContinuationsAsynchronously);
+
                 var diagnosticListenerObserver = new FakeDiagnosticListenerObserver(kvp =>
                 {
                     if (kvp.Key.Equals("System.Net.Http.HttpRequestOut.Stop"))
                     {
                         Assert.NotNull(kvp.Value);
-                        GetPropertyValueFromAnonymousTypeInstance<HttpRequestMessage>(kvp.Value, "Request");
-                        var requestStatus =
-                            GetPropertyValueFromAnonymousTypeInstance<TaskStatus>(kvp.Value, "RequestTaskStatus");
+                        GetProperty<HttpRequestMessage>(kvp.Value, "Request");
+                        TaskStatus requestStatus = GetProperty<TaskStatus>(kvp.Value, "RequestTaskStatus");
                         Assert.Equal(TaskStatus.Faulted, requestStatus);
-
-                        activityStopLogged = true;
+                        activityStopTcs.SetResult();;
                     }
                     else if (kvp.Key.Equals("System.Net.Http.Exception"))
                     {
                         Assert.NotNull(kvp.Value);
-                        GetPropertyValueFromAnonymousTypeInstance<Exception>(kvp.Value, "Exception");
-
-                        exceptionLogged = true;
+                        exceptionLogged = GetProperty<Exception>(kvp.Value, "Exception");
                     }
                 });
 
                 using (DiagnosticListener.AllListeners.Subscribe(diagnosticListenerObserver))
                 {
                     diagnosticListenerObserver.Enable();
-                    using (HttpClient client = CreateHttpClient(useVersionString))
-                    {
-                        Assert.ThrowsAsync<HttpRequestException>(() => client.GetAsync($"http://_{Guid.NewGuid().ToString("N")}.com"))
-                            .GetAwaiter().GetResult();
-                    }
 
-                    // Poll with a timeout since logging response is not synchronized with returning a response.
-                    WaitForTrue(() => activityStopLogged, TimeSpan.FromSeconds(1),
-                        "Response with exception was not logged within 1 second timeout.");
-                    Assert.True(exceptionLogged, "Exception was not logged");
-                    diagnosticListenerObserver.Disable();
+                    Exception ex = await Assert.ThrowsAsync<HttpRequestException>(() => GetAsync(useVersion, testAsync, InvalidUri));
+
+                    await activityStopTcs.Task;
+
+                    Assert.Same(ex, exceptionLogged);
                 }
-            }, UseVersion.ToString()).Dispose();
+            }, UseVersion.ToString(), TestAsync.ToString()).Dispose();
         }
 
-        [OuterLoop("Uses external servers")]
         [ConditionalFact(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))]
         public void SendAsync_ExpectedDiagnosticSynchronousExceptionActivityLogging()
         {
-            RemoteExecutor.Invoke((useVersionString , testAsyncString)=>
+            RemoteExecutor.Invoke(async (useVersion, testAsync) =>
             {
-                bool exceptionLogged = false;
-                bool activityStopLogged = false;
+                Exception exceptionLogged = null;
+
+                TaskCompletionSource activityStopTcs = new(TaskCreationOptions.RunContinuationsAsynchronously);
+
                 var diagnosticListenerObserver = new FakeDiagnosticListenerObserver(kvp =>
                 {
                     if (kvp.Key.Equals("System.Net.Http.HttpRequestOut.Stop"))
                     {
                         Assert.NotNull(kvp.Value);
-                        GetPropertyValueFromAnonymousTypeInstance<HttpRequestMessage>(kvp.Value, "Request");
-                        var requestStatus =
-                            GetPropertyValueFromAnonymousTypeInstance<TaskStatus>(kvp.Value, "RequestTaskStatus");
+                        GetProperty<HttpRequestMessage>(kvp.Value, "Request");
+                        TaskStatus requestStatus = GetProperty<TaskStatus>(kvp.Value, "RequestTaskStatus");
                         Assert.Equal(TaskStatus.Faulted, requestStatus);
-
-                        activityStopLogged = true;
+                        activityStopTcs.SetResult();;
                     }
                     else if (kvp.Key.Equals("System.Net.Http.Exception"))
                     {
                         Assert.NotNull(kvp.Value);
-                        GetPropertyValueFromAnonymousTypeInstance<Exception>(kvp.Value, "Exception");
-
-                        exceptionLogged = true;
+                        exceptionLogged = GetProperty<Exception>(kvp.Value, "Exception");
                     }
                 });
 
                 using (DiagnosticListener.AllListeners.Subscribe(diagnosticListenerObserver))
                 {
                     diagnosticListenerObserver.Enable();
-                    using (HttpClientHandler handler = CreateHttpClientHandler(useVersionString))
-                    using (HttpClient client = CreateHttpClient(handler, useVersionString))
+
+                    using (HttpClientHandler handler = CreateHttpClientHandler(useVersion))
+                    using (HttpClient client = CreateHttpClient(handler, useVersion))
                     {
                         // Set a https proxy.
-                        handler.Proxy = new WebProxy($"https://_{Guid.NewGuid().ToString("N")}.com", false);
-                        HttpRequestMessage request =
-                            new HttpRequestMessage(HttpMethod.Get, $"http://_{Guid.NewGuid().ToString("N")}.com");
-
                         // Forces a synchronous exception for SocketsHttpHandler.
                         // SocketsHttpHandler only allow http scheme for proxies.
+                        handler.Proxy = new WebProxy($"https://foo.bar", false);
+                        var request = new HttpRequestMessage(HttpMethod.Get, InvalidUri)
+                        {
+                            Version = Version.Parse(useVersion)
+                        };
 
                         // We cannot use Assert.Throws<Exception>(() => { SendAsync(...); }) to verify the
                         // synchronous exception here, because DiagnosticsHandler SendAsync() method has async
                         // modifier, and returns Task. If the call is not awaited, the current test method will continue
                         // run before the call is completed, thus Assert.Throws() will not capture the exception.
                         // We need to wait for the Task to complete synchronously, to validate the exception.
-                        bool testAsync = bool.Parse(testAsyncString);
-                        Task sendTask = client.SendAsync(testAsync, request);
-                        if (!testAsync)
+
+                        Exception exception = null;
+                        if (bool.Parse(testAsync))
                         {
-                            // In sync test case we execute client.Send(...) in separate thread to prevent deadlocks,
-                            // so it will never finish immediately and we need to wait for it.
-                            ((IAsyncResult)sendTask).AsyncWaitHandle.WaitOne();
+                            Task sendTask = client.SendAsync(request);
+                            Assert.True(sendTask.IsFaulted);
+                            exception = sendTask.Exception.InnerException;
+                        }
+                        else
+                        {
+                            try
+                            {
+                                client.Send(request);
+                            }
+                            catch (Exception ex)
+                            {
+                                exception = ex;
+                            }
+                            Assert.NotNull(exception);
                         }
-                        Assert.True(sendTask.IsFaulted);
-                        Assert.IsType<NotSupportedException>(sendTask.Exception.InnerException);
-                    }
 
-                    // Poll with a timeout since logging response is not synchronized with returning a response.
-                    WaitForTrue(() => activityStopLogged, TimeSpan.FromSeconds(1),
-                        "Response with exception was not logged within 1 second timeout.");
-                    Assert.True(exceptionLogged, "Exception was not logged");
-                    diagnosticListenerObserver.Disable();
+                        await activityStopTcs.Task;
+
+                        Assert.IsType<NotSupportedException>(exception);
+                        Assert.Same(exceptionLogged, exception);
+                    }
                 }
             }, UseVersion.ToString(), TestAsync.ToString()).Dispose();
         }
 
-        [OuterLoop("Uses external servers")]
         [ConditionalFact(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))]
         public void SendAsync_ExpectedDiagnosticSourceNewAndDeprecatedEventsLogging()
         {
-            RemoteExecutor.Invoke(useVersionString =>
+            RemoteExecutor.Invoke(async (useVersion, testAsync) =>
             {
                 bool requestLogged = false;
-                bool responseLogged = false;
                 bool activityStartLogged = false;
                 bool activityStopLogged = false;
 
+                TaskCompletionSource responseLoggedTcs = new(TaskCreationOptions.RunContinuationsAsynchronously);
+
                 var diagnosticListenerObserver = new FakeDiagnosticListenerObserver(kvp =>
                 {
                     if (kvp.Key.Equals("System.Net.Http.Request"))
@@ -835,7 +726,7 @@ public void SendAsync_ExpectedDiagnosticSourceNewAndDeprecatedEventsLogging()
                     }
                     else if (kvp.Key.Equals("System.Net.Http.Response"))
                     {
-                        responseLogged = true;
+                        responseLoggedTcs.SetResult();
                     }
                     else if (kvp.Key.Equals("System.Net.Http.HttpRequestOut.Start"))
                     {
@@ -850,30 +741,33 @@ public void SendAsync_ExpectedDiagnosticSourceNewAndDeprecatedEventsLogging()
                 using (DiagnosticListener.AllListeners.Subscribe(diagnosticListenerObserver))
                 {
                     diagnosticListenerObserver.Enable();
-                    using (HttpClient client = CreateHttpClient(useVersionString))
-                    {
-                        client.GetAsync(Configuration.Http.RemoteEchoServer).Result.Dispose();
-                    }
+
+                    await GetFactoryForVersion(useVersion).CreateClientAndServerAsync(
+                        async uri =>
+                        {
+                            await GetAsync(useVersion, testAsync, uri);
+                        },
+                        async server => await server.HandleRequestAsync());
+
+                    await responseLoggedTcs.Task;
 
                     Assert.True(activityStartLogged, "HttpRequestOut.Start was not logged.");
                     Assert.True(requestLogged, "Request was not logged.");
-                    // Poll with a timeout since logging response is not synchronized with returning a response.
-                    WaitForTrue(() => activityStopLogged, TimeSpan.FromSeconds(1),
-                        "HttpRequestOut.Stop was not logged within 1 second timeout.");
-                    Assert.True(responseLogged, "Response was not logged.");
-                    diagnosticListenerObserver.Disable();
+                    Assert.True(activityStopLogged, "HttpRequestOut.Stop was not logged.");
                 }
-            }, UseVersion.ToString()).Dispose();
+            }, UseVersion.ToString(), TestAsync.ToString()).Dispose();
         }
 
-        [OuterLoop("Uses external servers")]
         [ConditionalFact(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))]
         public void SendAsync_ExpectedDiagnosticExceptionOnlyActivityLogging()
         {
-            RemoteExecutor.Invoke(useVersionString =>
+            RemoteExecutor.Invoke(async (useVersion, testAsync) =>
             {
-                bool exceptionLogged = false;
                 bool activityLogged = false;
+                Exception exceptionLogged = null;
+
+                TaskCompletionSource exceptionLoggedTcs = new(TaskCreationOptions.RunContinuationsAsynchronously);
+
                 var diagnosticListenerObserver = new FakeDiagnosticListenerObserver(kvp =>
                 {
                     if (kvp.Key.Equals("System.Net.Http.HttpRequestOut.Stop"))
@@ -883,256 +777,129 @@ public void SendAsync_ExpectedDiagnosticExceptionOnlyActivityLogging()
                     else if (kvp.Key.Equals("System.Net.Http.Exception"))
                     {
                         Assert.NotNull(kvp.Value);
-                        GetPropertyValueFromAnonymousTypeInstance<Exception>(kvp.Value, "Exception");
-
-                        exceptionLogged = true;
+                        exceptionLogged = GetProperty<Exception>(kvp.Value, "Exception");
+                        exceptionLoggedTcs.SetResult();
                     }
                 });
 
                 using (DiagnosticListener.AllListeners.Subscribe(diagnosticListenerObserver))
                 {
                     diagnosticListenerObserver.Enable(s => s.Equals("System.Net.Http.Exception"));
-                    using (HttpClient client = CreateHttpClient(useVersionString))
-                    {
-                        Assert.ThrowsAsync<HttpRequestException>(() => client.GetAsync($"http://_{Guid.NewGuid().ToString("N")}.com"))
-                            .GetAwaiter().GetResult();
-                    }
 
-                    // Poll with a timeout since logging response is not synchronized with returning a response.
-                    WaitForTrue(() => exceptionLogged, TimeSpan.FromSeconds(1),
-                        "Exception was not logged within 1 second timeout.");
-                    Assert.False(activityLogged, "HttpOutReq was logged when logging was disabled");
-                    diagnosticListenerObserver.Disable();
-                }
-            }, UseVersion.ToString()).Dispose();
-        }
+                    Exception ex = await Assert.ThrowsAsync<HttpRequestException>(() => GetAsync(useVersion, testAsync, InvalidUri));
 
-        [OuterLoop("Uses external servers")]
-        [ConditionalFact(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))]
-        public void SendAsync_ExpectedDiagnosticStopOnlyActivityLogging()
-        {
-            RemoteExecutor.Invoke(useVersionString =>
-            {
-                bool activityStartLogged = false;
-                bool activityStopLogged = false;
+                    await exceptionLoggedTcs.Task;
 
-                var diagnosticListenerObserver = new FakeDiagnosticListenerObserver(kvp =>
-                {
-                    if (kvp.Key.Equals("System.Net.Http.HttpRequestOut.Start"))
-                    {
-                        activityStartLogged = true;
-                    }
-                    else if (kvp.Key.Equals("System.Net.Http.HttpRequestOut.Stop"))
-                    {
-                        Assert.NotNull(Activity.Current);
-                        activityStopLogged = true;
-                    }
-                });
-
-                using (DiagnosticListener.AllListeners.Subscribe(diagnosticListenerObserver))
-                {
-                    diagnosticListenerObserver.Enable(s => s.Equals("System.Net.Http.HttpRequestOut"));
-                    using (HttpClient client = CreateHttpClient(useVersionString))
-                    {
-                        client.GetAsync(Configuration.Http.RemoteEchoServer).Result.Dispose();
-                    }
-
-                    // Poll with a timeout since logging response is not synchronized with returning a response.
-                    WaitForTrue(() => activityStopLogged, TimeSpan.FromSeconds(1),
-                        "HttpRequestOut.Stop was not logged within 1 second timeout.");
-                    Assert.False(activityStartLogged,
-                        "HttpRequestOut.Start was logged when start logging was disabled");
-                    diagnosticListenerObserver.Disable();
+                    Assert.Same(ex, exceptionLogged);
+                    Assert.False(activityLogged, "HttpOutReq was logged when logging was disabled");
                 }
-            }, UseVersion.ToString()).Dispose();
+            }, UseVersion.ToString(), TestAsync.ToString()).Dispose();
         }
 
-        [OuterLoop("Uses external servers")]
         [ConditionalFact(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))]
         public void SendAsync_ExpectedActivityPropagationWithoutListener()
         {
-            RemoteExecutor.Invoke(useVersionString =>
+            RemoteExecutor.Invoke(async (useVersion, testAsync) =>
             {
-                using (HttpClient client = CreateHttpClient(useVersionString))
-                {
-                    Activity parent = new Activity("parent").Start();
-                    using HttpResponseMessage response = client.GetAsync(Configuration.Http.RemoteEchoServer).Result;
+                Activity parent = new Activity("parent").Start();
 
-                    Assert.True(response.RequestMessage.Headers.Contains(parent.IdFormat == ActivityIdFormat.Hierarchical ? "Request-Id" : "traceparent"));
-                    parent.Stop();
-                }
-            }, UseVersion.ToString()).Dispose();
+                await GetFactoryForVersion(useVersion).CreateClientAndServerAsync(
+                    async uri =>
+                    {
+                        await GetAsync(useVersion, testAsync, uri);
+                    },
+                    async server =>
+                    {
+                        HttpRequestData requestData = await server.AcceptConnectionSendResponseAndCloseAsync();
+                        AssertHeadersAreInjected(requestData, parent);
+                    });
+            }, UseVersion.ToString(), TestAsync.ToString()).Dispose();
         }
 
-        [OuterLoop("Uses external servers")]
         [ConditionalFact(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))]
         public void SendAsync_ExpectedActivityPropagationWithoutListenerOrParentActivity()
         {
-            RemoteExecutor.Invoke(useVersionString =>
+            RemoteExecutor.Invoke(async (useVersion, testAsync) =>
             {
-                using (HttpClient client = CreateHttpClient(useVersionString))
-                {
-                    using HttpResponseMessage response = client.GetAsync(Configuration.Http.RemoteEchoServer).Result;
-
-                    Assert.False(response.RequestMessage.Headers.Contains("Request-Id"));
-                    Assert.False(response.RequestMessage.Headers.Contains("traceparent"));
-                    Assert.False(response.RequestMessage.Headers.Contains("tracestate"));
-                    Assert.False(response.RequestMessage.Headers.Contains("Correlation-Context"));
-                }
-            }, UseVersion.ToString()).Dispose();
+                await GetFactoryForVersion(useVersion).CreateClientAndServerAsync(
+                    async uri =>
+                    {
+                        await GetAsync(useVersion, testAsync, uri);
+                    },
+                    async server =>
+                    {
+                        HttpRequestData requestData = await server.AcceptConnectionSendResponseAndCloseAsync();
+                        AssertNoHeadersAreInjected(requestData);
+                    });
+            }, UseVersion.ToString(), TestAsync.ToString()).Dispose();
         }
 
-        [OuterLoop("Uses external servers")]
         [ConditionalTheory(nameof(EnableActivityPropagationEnvironmentVariableIsNotSetAndRemoteExecutorSupported))]
-        [InlineData("true", true)]
-        [InlineData("1", true)]
-        [InlineData("0", false)]
-        [InlineData("false", false)]
-        [InlineData("FALSE", false)]
-        [InlineData("fAlSe", false)]
-        [InlineData("helloworld", true)]
-        [InlineData("", true)]
-        public void SendAsync_SuppressedGlobalStaticPropagationEnvVar(string envVarValue, bool isInstrumentationEnabled)
+        [InlineData("true")]
+        [InlineData("1")]
+        [InlineData("0")]
+        [InlineData("false")]
+        [InlineData("FALSE")]
+        [InlineData("fAlSe")]
+        [InlineData("helloworld")]
+        [InlineData("")]
+        public void SendAsync_SuppressedGlobalStaticPropagationEnvVar(string envVarValue)
         {
-            RemoteExecutor.Invoke((innerEnvVarValue, innerIsInstrumentationEnabled) =>
+            RemoteExecutor.Invoke(async (useVersion, testAsync, envVarValue) =>
             {
-                Environment.SetEnvironmentVariable(EnableActivityPropagationEnvironmentVariableSettingName, innerEnvVarValue);
+                Environment.SetEnvironmentVariable(EnableActivityPropagationEnvironmentVariableSettingName, envVarValue);
+
+                bool isInstrumentationEnabled = !(envVarValue == "0" || envVarValue.Equals("false", StringComparison.OrdinalIgnoreCase));
 
-                string eventKey = null;
                 bool anyEventLogged = false;
                 var diagnosticListenerObserver = new FakeDiagnosticListenerObserver(kvp =>
                 {
                     anyEventLogged = true;
-                    eventKey = kvp.Key;
                 });
 
                 using (DiagnosticListener.AllListeners.Subscribe(diagnosticListenerObserver))
                 {
-                    diagnosticListenerObserver.Enable(s => s.Equals("System.Net.Http.HttpRequestOut"));
-                    using (HttpClient client = new HttpClient())
-                    {
-                        Activity parent = new Activity("parent").Start();
-                        using HttpResponseMessage response = client.GetAsync(Configuration.Http.RemoteEchoServer).Result;
-                        parent.Stop();
-                        Assert.Equal(bool.Parse(innerIsInstrumentationEnabled), response.RequestMessage.Headers.Contains(
-                            parent.IdFormat == ActivityIdFormat.Hierarchical ? "Request-Id" : "traceparent"));
-                    }
+                    diagnosticListenerObserver.Enable();
 
-                    if (!bool.Parse(innerIsInstrumentationEnabled))
-                    {
-                        Assert.False(anyEventLogged, $"{eventKey} event logged when Activity is suppressed globally");
-                    }
-                    else
-                    {
-                        Assert.True(anyEventLogged, $"{eventKey} event was not logged logged when Activity is not suppressed");
-                    }
+                    await GetFactoryForVersion(useVersion).CreateClientAndServerAsync(
+                        async uri =>
+                        {
+                            Activity parent = new Activity("parent").Start();
+                            (HttpRequestMessage request, _) = await GetAsync(useVersion, testAsync, uri);
+
+                            string headerName = parent.IdFormat == ActivityIdFormat.Hierarchical ? "Request-Id" : "traceparent";
+                            Assert.Equal(isInstrumentationEnabled, request.Headers.Contains(headerName));
+                        },
+                        async server => await server.HandleRequestAsync());
 
-                    diagnosticListenerObserver.Disable();
+                    Assert.Equal(isInstrumentationEnabled, anyEventLogged);
                 }
-            }, envVarValue, isInstrumentationEnabled.ToString()).Dispose();
+            }, UseVersion.ToString(), TestAsync.ToString(), envVarValue).Dispose();
         }
 
-        [OuterLoop("Uses external servers")]
         [ConditionalTheory(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))]
         [InlineData(true)]
         [InlineData(false)]
         public void SendAsync_SuppressedGlobalStaticPropagationNoListenerAppCtx(bool switchValue)
         {
-            RemoteExecutor.Invoke(innerSwitchValue =>
+            RemoteExecutor.Invoke(async (useVersion, testAsync, switchValue) =>
             {
-                AppContext.SetSwitch(EnableActivityPropagationAppCtxSettingName, bool.Parse(innerSwitchValue));
+                AppContext.SetSwitch(EnableActivityPropagationAppCtxSettingName, bool.Parse(switchValue));
 
-                using (HttpClient client = new HttpClient())
-                {
-                    Activity parent = new Activity("parent").Start();
-                    using HttpResponseMessage response = client.GetAsync(Configuration.Http.RemoteEchoServer).Result;
-                    parent.Stop();
-                    Assert.Equal(bool.Parse(innerSwitchValue), response.RequestMessage.Headers.Contains(
-                        parent.IdFormat == ActivityIdFormat.Hierarchical ? "Request-Id" : "traceparent"));
-                }
-            }, switchValue.ToString()).Dispose();
-        }
-
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/23167")]
-        [OuterLoop("Uses external servers")]
-        [ConditionalFact(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))]
-        public void SendAsync_ExpectedDiagnosticCancelledActivityLogging()
-        {
-            RemoteExecutor.Invoke(useVersionString =>
-            {
-                bool cancelLogged = false;
-                var diagnosticListenerObserver = new FakeDiagnosticListenerObserver(kvp =>
-                {
-                    if (kvp.Key == "System.Net.Http.HttpRequestOut.Stop")
+                await GetFactoryForVersion(useVersion).CreateClientAndServerAsync(
+                    async uri =>
                     {
-                        Assert.NotNull(kvp.Value);
-                        GetPropertyValueFromAnonymousTypeInstance<HttpRequestMessage>(kvp.Value, "Request");
-                        var status =
-                            GetPropertyValueFromAnonymousTypeInstance<TaskStatus>(kvp.Value, "RequestTaskStatus");
-                        Assert.Equal(TaskStatus.Canceled, status);
-                        Volatile.Write(ref cancelLogged, true);
-                    }
-                });
-
-                using (DiagnosticListener.AllListeners.Subscribe(diagnosticListenerObserver))
-                {
-                    diagnosticListenerObserver.Enable();
-                    using (HttpClient client = CreateHttpClient(useVersionString))
-                    {
-                        LoopbackServer.CreateServerAsync(async (server, url) =>
-                        {
-                            CancellationTokenSource tcs = new CancellationTokenSource();
-                            Task request = server.AcceptConnectionAsync(connection =>
-                            {
-                                tcs.Cancel();
-                                return connection.ReadRequestHeaderAndSendResponseAsync();
-                            });
-                            Task response = client.GetAsync(url, tcs.Token);
-                            await Assert.ThrowsAnyAsync<Exception>(() =>
-                                TestHelper.WhenAllCompletedOrAnyFailed(response, request));
-                        }).GetAwaiter().GetResult();
-                    }
-                }
-
-                // Poll with a timeout since logging response is not synchronized with returning a response.
-                WaitForTrue(() => Volatile.Read(ref cancelLogged), TimeSpan.FromSeconds(1),
-                    "Cancellation was not logged within 1 second timeout.");
-                diagnosticListenerObserver.Disable();
-            }, UseVersion.ToString()).Dispose();
-        }
-
-        [ConditionalFact(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))]
-        public void SendAsync_NullRequest_ThrowsArgumentNullException()
-        {
-            RemoteExecutor.Invoke(async () =>
-            {
-                var diagnosticListenerObserver = new FakeDiagnosticListenerObserver(null);
-                using (DiagnosticListener.AllListeners.Subscribe(diagnosticListenerObserver))
-                {
-                    diagnosticListenerObserver.Enable();
-
-                    using (MyHandler handler = new MyHandler())
-                    {
-                        // Getting the Task first from the .SendAsync() call also tests
-                        // that the exception comes from the async Task path.
-                        Task t = handler.SendAsync(null);
-                        await Assert.ThrowsAsync<ArgumentNullException>(() => t);
-                    }
-                }
-
-                diagnosticListenerObserver.Disable();
-            }).Dispose();
-        }
+                        Activity parent = new Activity("parent").Start();
+                        (HttpRequestMessage request, _) = await GetAsync(useVersion, testAsync, uri);
 
-        private class MyHandler : HttpClientHandler
-        {
-            internal Task<HttpResponseMessage> SendAsync(HttpRequestMessage request)
-            {
-                return SendAsync(request, CancellationToken.None);
-            }
+                        string headerName = parent.IdFormat == ActivityIdFormat.Hierarchical ? "Request-Id" : "traceparent";
+                        Assert.Equal(bool.Parse(switchValue), request.Headers.Contains(headerName));
+                    },
+                    async server => await server.HandleRequestAsync());
+            }, UseVersion.ToString(), TestAsync.ToString(), switchValue.ToString()).Dispose();
         }
 
-        private static T GetPropertyValueFromAnonymousTypeInstance<T>(object obj, string propertyName)
+        private static T GetProperty<T>(object obj, string propertyName)
         {
             Type t = obj.GetType();
 
@@ -1145,38 +912,24 @@ private static T GetPropertyValueFromAnonymousTypeInstance<T>(object obj, string
             return (T)propertyValue;
         }
 
-        private static void WaitForTrue(Func<bool> p, TimeSpan timeout, string message)
+        private static string GetHeaderValue(HttpRequestData request, string name)
         {
-            // Assert that spin doesn't time out.
-            Assert.True(SpinWait.SpinUntil(p, timeout), message);
+            return request.Headers.SingleOrDefault(h => h.Name.Equals(name, StringComparison.OrdinalIgnoreCase)).Value;
         }
 
-        private static void WaitForFalse(Func<bool> p, TimeSpan timeout, string message)
+        private static void AssertNoHeadersAreInjected(HttpRequestData request)
         {
-            // Assert that spin times out.
-            Assert.False(SpinWait.SpinUntil(p, timeout), message);
+            Assert.Null(GetHeaderValue(request, "Request-Id"));
+            Assert.Null(GetHeaderValue(request, "traceparent"));
+            Assert.Null(GetHeaderValue(request, "tracestate"));
+            Assert.Null(GetHeaderValue(request, "Correlation-Context"));
         }
 
-        private static string GetHeaderValue(string name, List<string> requestLines)
+        private static void AssertHeadersAreInjected(HttpRequestData request, Activity parent)
         {
-            string header = null;
-
-            foreach (var line in requestLines)
-            {
-                if (line.StartsWith(name))
-                {
-                    header = line.Substring(name.Length).Trim(' ', ':');
-                }
-            }
-
-            return header;
-        }
-
-        private static void AssertHeadersAreInjected(List<string> requestLines, Activity parent)
-        {
-            string requestId = GetHeaderValue("Request-Id", requestLines);
-            string traceparent = GetHeaderValue("traceparent", requestLines);
-            string tracestate = GetHeaderValue("tracestate", requestLines);
+            string requestId = GetHeaderValue(request, "Request-Id");
+            string traceparent = GetHeaderValue(request, "traceparent");
+            string tracestate = GetHeaderValue(request, "tracestate");
 
             if (parent.IdFormat == ActivityIdFormat.Hierarchical)
             {
@@ -1194,19 +947,10 @@ private static void AssertHeadersAreInjected(List<string> requestLines, Activity
                 Assert.Equal(parent.TraceStateString, tracestate);
             }
 
-            var correlationContext = new List<NameValueHeaderValue>();
-
-            foreach (var line in requestLines)
-            {
-                if (line.StartsWith("Correlation-Context"))
-                {
-                    var corrCtxString = line.Substring("Correlation-Context".Length).Trim(' ', ':');
-                    foreach (var kvp in corrCtxString.Split(','))
-                    {
-                        correlationContext.Add(NameValueHeaderValue.Parse(kvp));
-                    }
-                }
-            }
+            List<NameValueHeaderValue> correlationContext = (GetHeaderValue(request, "Correlation-Context") ?? string.Empty)
+                .Split(',', StringSplitOptions.RemoveEmptyEntries)
+                .Select(kvp => NameValueHeaderValue.Parse(kvp))
+                .ToList();
 
             List<KeyValuePair<string, string>> baggage = parent.Baggage.ToList();
             Assert.Equal(baggage.Count, correlationContext.Count);
@@ -1216,22 +960,13 @@ private static void AssertHeadersAreInjected(List<string> requestLines, Activity
             }
         }
 
-        private static void AssertNoHeadersAreInjected(List<string> requestLines)
+        private static async Task<(HttpRequestMessage, HttpResponseMessage)> GetAsync(string useVersion, string testAsync, Uri uri, CancellationToken cancellationToken = default)
         {
-            foreach (var line in requestLines)
-            {
-                Assert.False(line.StartsWith("Request-Id"),
-                    "Request-Id header was injected when instrumentation was disabled");
-
-                Assert.False(line.StartsWith("traceparent"),
-                    "traceparent header was injected when instrumentation was disabled");
-
-                Assert.False(line.StartsWith("tracestate"),
-                    "tracestate header was injected when instrumentation was disabled");
-
-                Assert.False(line.StartsWith("Correlation-Context"),
-                    "Correlation-Context header was injected when instrumentation was disabled");
-            }
+            HttpClientHandler handler = CreateHttpClientHandler(useVersion);
+            handler.ServerCertificateCustomValidationCallback = TestHelper.AllowAllCertificates;
+            using var client = new HttpClient(handler);
+            var request = CreateRequest(HttpMethod.Get, uri, Version.Parse(useVersion), exactVersion: true);
+            return (request, await client.SendAsync(bool.Parse(testAsync), request, cancellationToken));
         }
     }
 }
diff --git a/src/libraries/System.Net.Http/tests/FunctionalTests/FakeDiagnosticSourceListenerObserver.cs b/src/libraries/System.Net.Http/tests/FunctionalTests/FakeDiagnosticSourceListenerObserver.cs
index fdab702fcb097e..a2e3bac550d360 100644
--- a/src/libraries/System.Net.Http/tests/FunctionalTests/FakeDiagnosticSourceListenerObserver.cs
+++ b/src/libraries/System.Net.Http/tests/FunctionalTests/FakeDiagnosticSourceListenerObserver.cs
@@ -71,11 +71,6 @@ public void Enable(Func<string, object, object, bool> writeObserverEnabled)
             _writeObserverEnabled = writeObserverEnabled;
         }
 
-        public void Disable()
-        {
-            _writeObserverEnabled = (name, arg1, arg2) => false;
-        }
-
         private bool IsEnabled(string s, object arg1, object arg2)
         {
             return _writeObserverEnabled.Invoke(s, arg1, arg2);
diff --git a/src/libraries/System.Net.Http/tests/FunctionalTests/HttpClientHandlerTest.AltSvc.cs b/src/libraries/System.Net.Http/tests/FunctionalTests/HttpClientHandlerTest.AltSvc.cs
index d27a086527225b..6cb8bbc075c2b6 100644
--- a/src/libraries/System.Net.Http/tests/FunctionalTests/HttpClientHandlerTest.AltSvc.cs
+++ b/src/libraries/System.Net.Http/tests/FunctionalTests/HttpClientHandlerTest.AltSvc.cs
@@ -6,6 +6,7 @@
 using Xunit;
 using Xunit.Abstractions;
 using System.Net.Test.Common;
+using System.Net.Quic;
 
 namespace System.Net.Http.Functional.Tests
 {
@@ -18,35 +19,45 @@ public HttpClientHandler_AltSvc_Test(ITestOutputHelper output) : base(output)
         /// <summary>
         /// HTTP/3 tests by default use prenegotiated HTTP/3. To test Alt-Svc upgrades, that must be disabled.
         /// </summary>
-        protected override HttpClient CreateHttpClient()
+        private HttpClient CreateHttpClient(Version version)
         {
-            HttpClientHandler handler = CreateHttpClientHandler(HttpVersion.Version30);
-
-            return CreateHttpClient(handler);
+            var client = CreateHttpClient();
+            client.DefaultVersionPolicy = HttpVersionPolicy.RequestVersionOrHigher;
+            client.DefaultRequestVersion = version;
+            return client;
         }
 
         [Theory]
         [MemberData(nameof(AltSvcHeaderUpgradeVersions))]
-        public async Task AltSvc_Header_Upgrade_Success(Version fromVersion)
+        public async Task AltSvc_Header_Upgrade_Success(Version fromVersion, bool overrideHost)
         {
+            // [ActiveIssue("https://github.com/dotnet/runtime/issues/54050")]
+            if (UseQuicImplementationProvider == QuicImplementationProviders.Mock)
+            {
+                return;
+            }
+
             // The test makes a request to a HTTP/1 or HTTP/2 server first, which supplies an Alt-Svc header pointing to the second server.
             using GenericLoopbackServer firstServer =
                 fromVersion.Major switch
                 {
-                    1 => new LoopbackServer(new LoopbackServer.Options { UseSsl = true }),
+                    1 => Http11LoopbackServerFactory.Singleton.CreateServer(new LoopbackServer.Options { UseSsl = true }),
                     2 => Http2LoopbackServer.CreateServer(),
                     _ => throw new Exception("Unknown HTTP version.")
                 };
 
             // The second request is expected to come in on this HTTP/3 server.
             using Http3LoopbackServer secondServer = CreateHttp3LoopbackServer();
+            
+            if (!overrideHost)
+                Assert.Equal(firstServer.Address.IdnHost, secondServer.Address.IdnHost);
 
-            using HttpClient client = CreateHttpClient();
+            using HttpClient client = CreateHttpClient(fromVersion);
 
             Task<HttpResponseMessage> firstResponseTask = client.GetAsync(firstServer.Address);
             Task serverTask = firstServer.AcceptConnectionSendResponseAndCloseAsync(additionalHeaders: new[]
             {
-                new HttpHeaderData("Alt-Svc", $"h3=\"{secondServer.Address.IdnHost}:{secondServer.Address.Port}\"")
+                new HttpHeaderData("Alt-Svc", $"h3=\"{(overrideHost ? secondServer.Address.IdnHost : null)}:{secondServer.Address.Port}\"")
             });
 
             await new[] { firstResponseTask, serverTask }.WhenAllOrAnyFailed(30_000);
@@ -57,19 +68,27 @@ public async Task AltSvc_Header_Upgrade_Success(Version fromVersion)
             await AltSvc_Upgrade_Success(firstServer, secondServer, client);
         }
 
-        public static TheoryData<Version> AltSvcHeaderUpgradeVersions =>
-            new TheoryData<Version>
+        public static TheoryData<Version, bool> AltSvcHeaderUpgradeVersions =>
+            new TheoryData<Version, bool>
             {
-                { HttpVersion.Version11 },
-                { HttpVersion.Version20 }
+                { HttpVersion.Version11, true },
+                { HttpVersion.Version11, false },
+                { HttpVersion.Version20, true },
+                { HttpVersion.Version20, false }
             };
 
         [Fact]
         public async Task AltSvc_ConnectionFrame_UpgradeFrom20_Success()
         {
+            // [ActiveIssue("https://github.com/dotnet/runtime/issues/54050")]
+            if (UseQuicImplementationProvider == QuicImplementationProviders.Mock)
+            {
+                return;
+            }
+
             using Http2LoopbackServer firstServer = Http2LoopbackServer.CreateServer();
             using Http3LoopbackServer secondServer = CreateHttp3LoopbackServer();
-            using HttpClient client = CreateHttpClient();
+            using HttpClient client = CreateHttpClient(HttpVersion.Version20);
 
             Task<HttpResponseMessage> firstResponseTask = client.GetAsync(firstServer.Address);
             Task serverTask = Task.Run(async () =>
@@ -92,9 +111,15 @@ public async Task AltSvc_ConnectionFrame_UpgradeFrom20_Success()
         [Fact]
         public async Task AltSvc_ResponseFrame_UpgradeFrom20_Success()
         {
+            // [ActiveIssue("https://github.com/dotnet/runtime/issues/54050")]
+            if (UseQuicImplementationProvider == QuicImplementationProviders.Mock)
+            {
+                return;
+            }
+
             using Http2LoopbackServer firstServer = Http2LoopbackServer.CreateServer();
             using Http3LoopbackServer secondServer = CreateHttp3LoopbackServer();
-            using HttpClient client = CreateHttpClient();
+            using HttpClient client = CreateHttpClient(HttpVersion.Version20);
 
             Task<HttpResponseMessage> firstResponseTask = client.GetAsync(firstServer.Address);
             Task serverTask = Task.Run(async () =>
diff --git a/src/libraries/System.Net.Http/tests/FunctionalTests/HttpClientHandlerTest.Headers.cs b/src/libraries/System.Net.Http/tests/FunctionalTests/HttpClientHandlerTest.Headers.cs
index eb57adbbfc6357..7a1ceaf88c792f 100644
--- a/src/libraries/System.Net.Http/tests/FunctionalTests/HttpClientHandlerTest.Headers.cs
+++ b/src/libraries/System.Net.Http/tests/FunctionalTests/HttpClientHandlerTest.Headers.cs
@@ -23,7 +23,6 @@ public HttpClientHandlerTest_Headers(ITestOutputHelper output) : base(output) {
         private sealed class DerivedHttpHeaders : HttpHeaders { }
 
         [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/42852", TestPlatforms.Browser)]
         public async Task SendAsync_RequestWithSimpleHeader_ResponseReferencesUnmodifiedRequestHeaders()
         {
             const string HeaderKey = "some-header-123", HeaderValue = "this is the expected header value";
@@ -47,7 +46,7 @@ await LoopbackServerFactory.CreateClientAndServerAsync(async uri =>
         }
 
         [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/42852", TestPlatforms.Browser)]
+        [SkipOnPlatform(TestPlatforms.Browser, "User-Agent is not supported on Browser")]
         public async Task SendAsync_UserAgent_CorrectlyWritten()
         {
             string userAgent = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.18 Safari/537.36";
@@ -71,7 +70,6 @@ await LoopbackServerFactory.CreateClientAndServerAsync(async uri =>
         }
 
         [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/42852", TestPlatforms.Browser)]
         public async Task SendAsync_LargeHeaders_CorrectlyWritten()
         {
             if (UseVersion == HttpVersion.Version30)
@@ -107,7 +105,6 @@ await LoopbackServerFactory.CreateClientAndServerAsync(async uri =>
         }
 
         [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/42852", TestPlatforms.Browser)]
         public async Task SendAsync_DefaultHeaders_CorrectlyWritten()
         {
             const string Version = "2017-04-17";
@@ -137,7 +134,7 @@ await LoopbackServerFactory.CreateClientAndServerAsync(async uri =>
         [Theory]
         [InlineData("\u05D1\u05F1")]
         [InlineData("jp\u30A5")]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/42852", TestPlatforms.Browser)]
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/54160", TestPlatforms.Browser)]
         public async Task SendAsync_InvalidCharactersInHeader_Throw(string value)
         {
             await LoopbackServerFactory.CreateClientAndServerAsync(async uri =>
@@ -169,9 +166,14 @@ await LoopbackServerFactory.CreateClientAndServerAsync(async uri =>
         [InlineData("Accept-CharSet", "text/plain, text/json", false)] // invalid format for header but added with TryAddWithoutValidation
         [InlineData("Content-Location", "", false)] // invalid format for header but added with TryAddWithoutValidation
         [InlineData("Max-Forwards", "NotAnInteger", false)] // invalid format for header but added with TryAddWithoutValidation
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/42852", TestPlatforms.Browser)]
         public async Task SendAsync_SpecialHeaderKeyOrValue_Success(string key, string value, bool parsable)
         {
+            if (PlatformDetection.IsBrowser && (key == "Content-Location" || key == "Date" || key == "Accept-CharSet"))
+            {
+                // https://fetch.spec.whatwg.org/#forbidden-header-name
+                return;
+            }
+
             await LoopbackServerFactory.CreateClientAndServerAsync(async uri =>
             {
                 bool contentHeader = false;
@@ -209,7 +211,6 @@ await LoopbackServerFactory.CreateClientAndServerAsync(async uri =>
         [Theory]
         [InlineData("Content-Security-Policy", 4618)]
         [InlineData("RandomCustomHeader", 12345)]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/42852", TestPlatforms.Browser)]
         public async Task GetAsync_LargeHeader_Success(string headerName, int headerValueLength)
         {
             var rand = new Random(42);
@@ -234,7 +235,6 @@ await LoopbackServerFactory.CreateClientAndServerAsync(async uri =>
         }
 
         [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/42852", TestPlatforms.Browser)]
         public async Task GetAsync_EmptyResponseHeader_Success()
         {
             IList<HttpHeaderData> headers = new HttpHeaderData[] {
@@ -246,8 +246,12 @@ await LoopbackServerFactory.CreateClientAndServerAsync(async uri =>
             {
                 using (HttpClient client = CreateHttpClient())
                 {
-                    HttpResponseMessage response = await  client.GetAsync(uri).ConfigureAwait(false);
-                    Assert.Equal(headers.Count, response.Headers.Count());
+                    HttpResponseMessage response = await client.GetAsync(uri).ConfigureAwait(false);
+                    // browser sends more headers
+                    if (PlatformDetection.IsNotBrowser)
+                    {
+                        Assert.Equal(headers.Count, response.Headers.Count());
+                    }
                     Assert.NotNull(response.Headers.GetValues("x-empty"));
                 }
             },
@@ -262,7 +266,6 @@ await server.AcceptConnectionAsync(async connection =>
         }
 
         [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/42852", TestPlatforms.Browser)]
         public async Task GetAsync_MissingExpires_ReturnNull()
         {
              await LoopbackServerFactory.CreateClientAndServerAsync(async uri =>
@@ -283,7 +286,6 @@ await LoopbackServerFactory.CreateClientAndServerAsync(async uri =>
         [InlineData("Thu, 01 Dec 1994 16:00:00 GMT", true)]
         [InlineData("-1", false)]
         [InlineData("0", false)]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/42852", TestPlatforms.Browser)]
         public async Task SendAsync_Expires_Success(string value, bool isValid)
         {
             await LoopbackServerFactory.CreateClientAndServerAsync(async uri =>
@@ -322,7 +324,6 @@ public void HeadersAdd_CustomExpires_Success(string value, bool isValid)
 
         [Theory]
         [InlineData("Accept-Encoding", "identity,gzip")]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/42852", TestPlatforms.Browser)]
         public async Task SendAsync_RequestHeaderInResponse_Success(string name, string value)
         {
             await LoopbackServerFactory.CreateClientAndServerAsync(async uri =>
@@ -343,11 +344,10 @@ await LoopbackServerFactory.CreateClientAndServerAsync(async uri =>
             });
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [Theory]
         [InlineData(false)]
         [InlineData(true)]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/53018", TestPlatforms.Browser)]
         public async Task SendAsync_GetWithValidHostHeader_Success(bool withPort)
         {
             if (UseVersion == HttpVersion.Version30)
@@ -355,9 +355,16 @@ public async Task SendAsync_GetWithValidHostHeader_Success(bool withPort)
                 // External servers do not support HTTP3 currently.
                 return;
             }
+            if (PlatformDetection.LocalEchoServerIsAvailable && !withPort)
+            {
+                // we always have custom port with the local echo server, so we couldn't test without it
+                return;
+            }
 
             var m = new HttpRequestMessage(HttpMethod.Get, Configuration.Http.SecureRemoteEchoServer) { Version = UseVersion };
-            m.Headers.Host = withPort ? Configuration.Http.SecureHost + ":443" : Configuration.Http.SecureHost;
+            m.Headers.Host = !PlatformDetection.LocalEchoServerIsAvailable && withPort
+                                ? Configuration.Http.SecureHost + ":" + Configuration.Http.SecurePort
+                                : Configuration.Http.SecureHost;
 
             using (HttpClient client = CreateHttpClient())
             using (HttpResponseMessage response = await client.SendAsync(TestAsync, m))
@@ -372,8 +379,9 @@ public async Task SendAsync_GetWithValidHostHeader_Success(bool withPort)
             }
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [Fact]
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/53874", TestPlatforms.Browser)]
         public async Task SendAsync_GetWithInvalidHostHeader_ThrowsException()
         {
             if (LoopbackServerFactory.Version >= HttpVersion.Version20)
@@ -393,7 +401,7 @@ public async Task SendAsync_GetWithInvalidHostHeader_ThrowsException()
         }
 
         [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/42852", TestPlatforms.Browser)]
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/54160", TestPlatforms.Browser)]
         public async Task SendAsync_WithZeroLengthHeaderName_Throws()
         {
             await LoopbackServerFactory.CreateClientAndServerAsync(
@@ -436,7 +444,7 @@ private static readonly (string Name, Encoding ValueEncoding, string[] Values)[]
         };
 
         [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/42852", TestPlatforms.Browser)]
+        [SkipOnPlatform(TestPlatforms.Browser, "Socket is not supported on Browser")]
         public async Task SendAsync_CustomRequestEncodingSelector_CanSendNonAsciiHeaderValues()
         {
             await LoopbackServerFactory.CreateClientAndServerAsync(
@@ -491,7 +499,7 @@ await LoopbackServerFactory.CreateClientAndServerAsync(
         }
 
         [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/42852", TestPlatforms.Browser)]
+        [SkipOnPlatform(TestPlatforms.Browser, "Socket is not supported on Browser")]
         public async Task SendAsync_CustomResponseEncodingSelector_CanReceiveNonAsciiHeaderValues()
         {
             await LoopbackServerFactory.CreateClientAndServerAsync(
diff --git a/src/libraries/System.Net.Http/tests/FunctionalTests/HttpClientHandlerTest.Http1.cs b/src/libraries/System.Net.Http/tests/FunctionalTests/HttpClientHandlerTest.Http1.cs
index c7579cd114bb2a..f0e58b32ca3456 100644
--- a/src/libraries/System.Net.Http/tests/FunctionalTests/HttpClientHandlerTest.Http1.cs
+++ b/src/libraries/System.Net.Http/tests/FunctionalTests/HttpClientHandlerTest.Http1.cs
@@ -17,7 +17,6 @@ public class HttpClientHandlerTest_Http1 : HttpClientHandlerTestBase
         public HttpClientHandlerTest_Http1(ITestOutputHelper output) : base(output) { }
 
         [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/39187", TestPlatforms.Browser)]
         public async Task SendAsync_HostHeader_First()
         {
             // RFC 7230  3.2.2.  Field Order
diff --git a/src/libraries/System.Net.Http/tests/FunctionalTests/HttpClientHandlerTest.Http3.cs b/src/libraries/System.Net.Http/tests/FunctionalTests/HttpClientHandlerTest.Http3.cs
index 0732797672f82b..6a41bfb0195252 100644
--- a/src/libraries/System.Net.Http/tests/FunctionalTests/HttpClientHandlerTest.Http3.cs
+++ b/src/libraries/System.Net.Http/tests/FunctionalTests/HttpClientHandlerTest.Http3.cs
@@ -79,10 +79,12 @@ public async Task ClientSettingsReceived_Success(int headerSizeLimit)
         }
 
         [Theory]
+        [InlineData(10)]
         [InlineData(100)]
+        [InlineData(1000)]
         public async Task SendMoreThanStreamLimitRequests_Succeeds(int streamLimit)
         {
-            using Http3LoopbackServer server = CreateHttp3LoopbackServer();
+            using Http3LoopbackServer server = CreateHttp3LoopbackServer(new Http3Options(){ MaxBidirectionalStreams = streamLimit });
 
             Task serverTask = Task.Run(async () =>
             {
@@ -100,7 +102,7 @@ public async Task SendMoreThanStreamLimitRequests_Succeeds(int streamLimit)
 
                 for (int i = 0; i < streamLimit + 1; ++i)
                 {
-                    using HttpRequestMessage request = new()
+                    HttpRequestMessage request = new()
                     {
                         Method = HttpMethod.Get,
                         RequestUri = server.Address,
@@ -114,6 +116,162 @@ public async Task SendMoreThanStreamLimitRequests_Succeeds(int streamLimit)
             await new[] { clientTask, serverTask }.WhenAllOrAnyFailed(20_000);
         }
 
+        [Theory]
+        [InlineData(10)]
+        [InlineData(100)]
+        [InlineData(1000)]
+        public async Task SendStreamLimitRequestsConcurrently_Succeeds(int streamLimit)
+        {
+            using Http3LoopbackServer server = CreateHttp3LoopbackServer(new Http3Options(){ MaxBidirectionalStreams = streamLimit });
+
+            Task serverTask = Task.Run(async () =>
+            {
+                using Http3LoopbackConnection connection = (Http3LoopbackConnection)await server.EstablishGenericConnectionAsync();
+                for (int i = 0; i < streamLimit; ++i)
+                {
+                    using Http3LoopbackStream stream = await connection.AcceptRequestStreamAsync();
+                    await stream.HandleRequestAsync();
+                }
+            });
+
+            Task clientTask = Task.Run(async () =>
+            {
+                using HttpClient client = CreateHttpClient();
+
+                var tasks = new Task<HttpResponseMessage>[streamLimit];
+                Parallel.For(0, streamLimit, i =>
+                {
+                    HttpRequestMessage request = new()
+                    {
+                        Method = HttpMethod.Get,
+                        RequestUri = server.Address,
+                        Version = HttpVersion30,
+                        VersionPolicy = HttpVersionPolicy.RequestVersionExact
+                    };
+
+                    tasks[i] = client.SendAsync(request);
+                });
+
+                var responses = await Task.WhenAll(tasks);
+                foreach (var response in responses)
+                {
+                    response.Dispose();
+                }
+            });
+
+            await new[] { clientTask, serverTask }.WhenAllOrAnyFailed(20_000);
+        }
+
+        [Theory]
+        [InlineData(10)]
+        [InlineData(100)]
+        [InlineData(1000)]
+        public async Task SendMoreThanStreamLimitRequestsConcurrently_LastWaits(int streamLimit)
+        {
+            // This combination leads to a hang manifesting in CI only. Disabling it until there's more time to investigate.
+            // [ActiveIssue("https://github.com/dotnet/runtime/issues/53688")]
+            if (this.UseQuicImplementationProvider == QuicImplementationProviders.Mock)
+            {
+                return;
+            }
+
+            using Http3LoopbackServer server = CreateHttp3LoopbackServer(new Http3Options(){ MaxBidirectionalStreams = streamLimit });
+            var lastRequestContentStarted = new TaskCompletionSource();
+
+            Task serverTask = Task.Run(async () =>
+            {
+                // Read the first streamLimit requests, keep the streams open to make the last one wait.
+                using Http3LoopbackConnection connection = (Http3LoopbackConnection)await server.EstablishGenericConnectionAsync();
+                var streams = new Http3LoopbackStream[streamLimit];
+                for (int i = 0; i < streamLimit; ++i)
+                {
+                    Http3LoopbackStream stream = await connection.AcceptRequestStreamAsync();
+                    var body = await stream.ReadRequestDataAsync();
+                    streams[i] = stream;
+                }
+
+                // Make the last request running independently.
+                var lastRequest = Task.Run(async () => {
+                    using Http3LoopbackStream stream = await connection.AcceptRequestStreamAsync();
+                    await stream.HandleRequestAsync();
+                });
+
+                // All the initial streamLimit streams are still opened so the last request cannot started yet.
+                Assert.False(lastRequestContentStarted.Task.IsCompleted);
+
+                // Reply to the first streamLimit requests.
+                for (int i = 0; i < streamLimit; ++i)
+                {
+                    await streams[i].SendResponseAsync();
+                    streams[i].Dispose();
+                    // After the first request is fully processed, the last request should unblock and get processed.
+                    if (i == 0)
+                    {
+                        await lastRequestContentStarted.Task;
+                    }
+                }
+                await lastRequest;
+            });
+
+            Task clientTask = Task.Run(async () =>
+            {
+                using HttpClient client = CreateHttpClient();
+
+                // Fire out the first streamLimit requests in parallel, no waiting for the responses yet.
+                var countdown = new CountdownEvent(streamLimit);
+                var tasks = new Task<HttpResponseMessage>[streamLimit];
+                Parallel.For(0, streamLimit, i =>
+                {
+                    HttpRequestMessage request = new()
+                    {
+                        Method = HttpMethod.Post,
+                        RequestUri = server.Address,
+                        Version = HttpVersion30,
+                        VersionPolicy = HttpVersionPolicy.RequestVersionExact,
+                        Content = new StreamContent(new DelegateStream(
+                            canReadFunc: () => true,
+                            readFunc: (buffer, offset, count) =>
+                            {
+                                countdown.Signal();
+                                return 0;
+                            }))
+                    };
+
+                    tasks[i] = client.SendAsync(request);
+                });
+
+                // Wait for the first streamLimit request to get started.
+                countdown.Wait();
+
+                // Fire out the last request, that should wait until the server fully handles at least one request.
+                HttpRequestMessage last = new()
+                {
+                    Method = HttpMethod.Post,
+                    RequestUri = server.Address,
+                    Version = HttpVersion30,
+                    VersionPolicy = HttpVersionPolicy.RequestVersionExact,
+                    Content = new StreamContent(new DelegateStream(
+                        canReadFunc: () => true,
+                        readFunc: (buffer, offset, count) =>
+                        {
+                            lastRequestContentStarted.SetResult();
+                            return 0;
+                        }))
+                };
+                var lastTask = client.SendAsync(last);
+
+                // Wait for all requests to finish. Whether the last request was pending is checked on the server side.
+                var responses = await Task.WhenAll(tasks);
+                foreach (var response in responses)
+                {
+                    response.Dispose();
+                }
+                await lastTask;
+            });
+
+            await new[] { clientTask, serverTask }.WhenAllOrAnyFailed(20_000);
+        }
+
         [Fact]
         [ActiveIssue("https://github.com/dotnet/runtime/issues/53090")]
         public async Task ReservedFrameType_Throws()
diff --git a/src/libraries/System.Net.Http/tests/FunctionalTests/HttpClientHandlerTest.RequestRetry.cs b/src/libraries/System.Net.Http/tests/FunctionalTests/HttpClientHandlerTest.RequestRetry.cs
index ced259294f8c13..4e2426b958e658 100644
--- a/src/libraries/System.Net.Http/tests/FunctionalTests/HttpClientHandlerTest.RequestRetry.cs
+++ b/src/libraries/System.Net.Http/tests/FunctionalTests/HttpClientHandlerTest.RequestRetry.cs
@@ -19,7 +19,6 @@ public abstract class HttpClientHandlerTest_RequestRetry : HttpClientHandlerTest
         public HttpClientHandlerTest_RequestRetry(ITestOutputHelper output) : base(output) { }
 
         [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/42852", TestPlatforms.Browser)]
         public async Task GetAsyncOnNewConnection_RetryOnConnectionClosed_Success()
         {
             await LoopbackServer.CreateClientAndServerAsync(async url =>
diff --git a/src/libraries/System.Net.Http/tests/FunctionalTests/HttpClientHandlerTestBase.SocketsHttpHandler.cs b/src/libraries/System.Net.Http/tests/FunctionalTests/HttpClientHandlerTestBase.SocketsHttpHandler.cs
index bff9da8acf2b5d..81a4438a83ba67 100644
--- a/src/libraries/System.Net.Http/tests/FunctionalTests/HttpClientHandlerTestBase.SocketsHttpHandler.cs
+++ b/src/libraries/System.Net.Http/tests/FunctionalTests/HttpClientHandlerTestBase.SocketsHttpHandler.cs
@@ -31,6 +31,10 @@ public static bool IsMsQuicSupported
             }
         }
 
+        // This should correspond to platforms on which System.Net.Quic is supported. See also HttpConnectionPool.IsHttp3Supported().
+        public static bool IsMockQuicSupported
+            => (OperatingSystem.IsLinux() && !OperatingSystem.IsAndroid()) || OperatingSystem.IsWindows() || OperatingSystem.IsMacOS();
+
         protected static HttpClientHandler CreateHttpClientHandler(Version useVersion = null, QuicImplementationProvider quicImplementationProvider = null, bool allowAllHttp2Certificates = true)
         {
             useVersion ??= HttpVersion.Version11;
@@ -52,9 +56,9 @@ protected static HttpClientHandler CreateHttpClientHandler(Version useVersion =
             return handler;
         }
 
-        protected Http3LoopbackServer CreateHttp3LoopbackServer()
+        protected Http3LoopbackServer CreateHttp3LoopbackServer(Http3Options options = default)
         {
-            return new Http3LoopbackServer(UseQuicImplementationProvider);
+            return new Http3LoopbackServer(UseQuicImplementationProvider, options);
         }
 
         protected HttpClientHandler CreateHttpClientHandler() => CreateHttpClientHandler(UseVersion, UseQuicImplementationProvider);
@@ -63,10 +67,10 @@ protected static HttpClientHandler CreateHttpClientHandler(string useVersionStri
             CreateHttpClientHandler(Version.Parse(useVersionString));
 
 
-        protected static object GetUnderlyingSocketsHttpHandler(HttpClientHandler handler)
+        protected static SocketsHttpHandler GetUnderlyingSocketsHttpHandler(HttpClientHandler handler)
         {
             FieldInfo field = typeof(HttpClientHandler).GetField("_underlyingHandler", BindingFlags.Instance | BindingFlags.NonPublic);
-            return field?.GetValue(handler);
+            return (SocketsHttpHandler)field?.GetValue(handler);
         }
 
         protected static HttpRequestMessage CreateRequest(HttpMethod method, Uri uri, Version version, bool exactVersion = false) =>
@@ -78,6 +82,9 @@ protected static HttpRequestMessage CreateRequest(HttpMethod method, Uri uri, Ve
 
         protected LoopbackServerFactory LoopbackServerFactory => GetFactoryForVersion(UseVersion, UseQuicImplementationProvider);
 
+        protected static LoopbackServerFactory GetFactoryForVersion(string useVersion, QuicImplementationProvider quicImplementationProvider = null) =>
+            GetFactoryForVersion(Version.Parse(useVersion), quicImplementationProvider);
+
         protected static LoopbackServerFactory GetFactoryForVersion(Version useVersion, QuicImplementationProvider quicImplementationProvider = null)
         {
             return useVersion.Major switch
@@ -97,7 +104,7 @@ protected static LoopbackServerFactory GetFactoryForVersion(Version useVersion,
     internal class VersionHttpClientHandler : HttpClientHandler
     {
         private readonly Version _useVersion;
-        
+
         public VersionHttpClientHandler(Version useVersion)
         {
             _useVersion = useVersion;
@@ -120,7 +127,7 @@ protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage reques
             {
                 request.VersionPolicy = HttpVersionPolicy.RequestVersionExact;
             }
-            
+
             return base.SendAsync(request, cancellationToken);
         }
 
diff --git a/src/libraries/System.Net.Http/tests/FunctionalTests/HttpClientMiniStressTest.cs b/src/libraries/System.Net.Http/tests/FunctionalTests/HttpClientMiniStressTest.cs
index fb54f712a5a446..af3bdd764bc72c 100644
--- a/src/libraries/System.Net.Http/tests/FunctionalTests/HttpClientMiniStressTest.cs
+++ b/src/libraries/System.Net.Http/tests/FunctionalTests/HttpClientMiniStressTest.cs
@@ -40,7 +40,7 @@ public SocketsHttpHandler_HttpClientMiniStress_Http3_MsQuic(ITestOutputHelper ou
         protected override QuicImplementationProvider UseQuicImplementationProvider => QuicImplementationProviders.MsQuic;
     }
 
-    [ConditionalClass(typeof(HttpClientHandlerTestBase), nameof(IsMsQuicSupported))]
+    [ConditionalClass(typeof(HttpClientHandlerTestBase), nameof(IsMockQuicSupported))]
     public sealed class SocketsHttpHandler_HttpClientMiniStress_Http3_Mock : HttpClientMiniStress
     {
         public SocketsHttpHandler_HttpClientMiniStress_Http3_Mock(ITestOutputHelper output) : base(output) { }
@@ -98,6 +98,7 @@ await server.AcceptConnectionAsync(async connection =>
     }
 
     [Collection(nameof(HttpClientMiniStress))]
+    [SkipOnPlatform(TestPlatforms.Browser, "System.Net.Security is not supported on Browser")]
     public abstract class HttpClientMiniStress : HttpClientHandlerTestBase
     {
         public HttpClientMiniStress(ITestOutputHelper output) : base(output) { }
diff --git a/src/libraries/System.Net.Http/tests/FunctionalTests/HttpClientTest.cs b/src/libraries/System.Net.Http/tests/FunctionalTests/HttpClientTest.cs
index 5ac37fdd6ab7d5..451bb20d58fa1b 100644
--- a/src/libraries/System.Net.Http/tests/FunctionalTests/HttpClientTest.cs
+++ b/src/libraries/System.Net.Http/tests/FunctionalTests/HttpClientTest.cs
@@ -357,8 +357,6 @@ public async Task GetAsync_CustomException_Asynchronous_ThrowsException()
         }
 
         [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/39187", TestPlatforms.Browser)]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/42852", TestPlatforms.Browser)]
         public async Task GetStringAsync_Success()
         {
             string content = Guid.NewGuid().ToString();
@@ -378,8 +376,7 @@ await LoopbackServer.CreateClientAndServerAsync(
         }
 
         [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/39187", TestPlatforms.Browser)]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/42852", TestPlatforms.Browser)]
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/54270", TestPlatforms.Browser)]
         public async Task GetStringAsync_CanBeCanceled_AlreadyCanceledCts()
         {
             var onClientFinished = new SemaphoreSlim(0, 1);
@@ -404,8 +401,7 @@ await LoopbackServer.CreateClientAndServerAsync(
         }
 
         [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/39187", TestPlatforms.Browser)]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/42852", TestPlatforms.Browser)]
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/54270", TestPlatforms.Browser)]
         public async Task GetStringAsync_CanBeCanceled()
         {
             var cts = new CancellationTokenSource();
@@ -440,7 +436,7 @@ await server.AcceptConnectionAsync(async connection =>
         [InlineData(1, 0)]
         [InlineData(1, 1)]
         [InlineData(1, 2)]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/42852", TestPlatforms.Browser)]
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/54270", TestPlatforms.Browser)]
         public async Task GetAsync_ContentCanBeCanceled(int getMode, int cancelMode)
         {
             // cancelMode:
@@ -530,8 +526,6 @@ await LoopbackServerFactory.CreateClientAndServerAsync(
         }
 
         [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/39187", TestPlatforms.Browser)]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/42852", TestPlatforms.Browser)]
         public async Task GetByteArrayAsync_Success()
         {
             string content = Guid.NewGuid().ToString();
@@ -552,8 +546,7 @@ await LoopbackServer.CreateClientAndServerAsync(
         }
 
         [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/39187", TestPlatforms.Browser)]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/42852", TestPlatforms.Browser)]
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/54270", TestPlatforms.Browser)]
         public async Task GetByteArrayAsync_CanBeCanceled_AlreadyCanceledCts()
         {
             var onClientFinished = new SemaphoreSlim(0, 1);
@@ -578,8 +571,7 @@ await LoopbackServer.CreateClientAndServerAsync(
         }
 
         [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/39187", TestPlatforms.Browser)]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/42852", TestPlatforms.Browser)]
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/54270", TestPlatforms.Browser)]
         public async Task GetByteArrayAsync_CanBeCanceled()
         {
             var cts = new CancellationTokenSource();
@@ -607,8 +599,6 @@ await server.AcceptConnectionAsync(async connection =>
         }
 
         [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/39187", TestPlatforms.Browser)]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/42852", TestPlatforms.Browser)]
         public async Task GetStreamAsync_Success()
         {
             string content = Guid.NewGuid().ToString();
@@ -632,8 +622,7 @@ await LoopbackServer.CreateClientAndServerAsync(
         }
 
         [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/39187", TestPlatforms.Browser)]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/42852", TestPlatforms.Browser)]
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/54270", TestPlatforms.Browser)]
         public async Task GetStreamAsync_CanBeCanceled_AlreadyCanceledCts()
         {
             var onClientFinished = new SemaphoreSlim(0, 1);
@@ -658,8 +647,7 @@ await LoopbackServer.CreateClientAndServerAsync(
         }
 
         [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/39187", TestPlatforms.Browser)]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/42852", TestPlatforms.Browser)]
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/54270", TestPlatforms.Browser)]
         public async Task GetStreamAsync_CanBeCanceled()
         {
             var cts = new CancellationTokenSource();
@@ -916,8 +904,7 @@ public void Send_SingleThread_Succeeds(HttpCompletionOption completionOption)
         [Theory]
         [InlineData(HttpCompletionOption.ResponseContentRead)]
         [InlineData(HttpCompletionOption.ResponseHeadersRead)]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/39187", TestPlatforms.Browser)]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/42852", TestPlatforms.Browser)]
+        [SkipOnPlatform(TestPlatforms.Browser, "Synchronous Send is not supported on Browser")]
         public async Task Send_SingleThread_Loopback_Succeeds(HttpCompletionOption completionOption)
         {
             string content = "Test content";
@@ -970,7 +957,7 @@ await server.AcceptConnectionAsync(async connection =>
 
         [Fact]
         [OuterLoop]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/42852", TestPlatforms.Browser)]
+        [SkipOnPlatform(TestPlatforms.Browser, "Synchronous Send is not supported on Browser")]
         public async Task Send_CancelledRequestContent_Throws()
         {
             CancellationTokenSource cts = new CancellationTokenSource();
@@ -1017,7 +1004,6 @@ await server.AcceptConnectionAsync(async connection =>
         [Fact]
         [OuterLoop]
         [ActiveIssue("https://github.com/dotnet/runtime/issues/39056")]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/42852", TestPlatforms.Browser)]
         public async Task Send_TimeoutRequestContent_Throws()
         {
             await LoopbackServer.CreateClientAndServerAsync(
@@ -1060,7 +1046,7 @@ await server.AcceptConnectionAsync(async connection =>
 
         [Fact]
         [OuterLoop]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/42852", TestPlatforms.Browser)]
+        [SkipOnPlatform(TestPlatforms.Browser, "Synchronous Send is not supported on Browser")]
         public async Task Send_CancelledResponseContent_Throws()
         {
             string content = "Test content";
@@ -1110,12 +1096,13 @@ await server.AcceptConnectionAsync(async connection =>
 
         [Fact]
         [OuterLoop]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/42852", TestPlatforms.Browser)]
-        public void Send_TimeoutResponseContent_Throws()
+        [SkipOnPlatform(TestPlatforms.Browser, "Synchronous Send is not supported on Browser")]
+        public async Task Send_TimeoutResponseContent_Throws()
         {
             const string Content = "Test content";
 
             using var server = new LoopbackServer();
+            await server.ListenAsync();
 
             // Ignore all failures from the server. This includes being disposed of before ever accepting a connection,
             // which is possible if the client times out so quickly that it hasn't initiated a connection yet.
@@ -1163,8 +1150,7 @@ public static IEnumerable<object[]> VersionSelectionMemberData()
 
         [Theory]
         [MemberData(nameof(VersionSelectionMemberData))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/39187", TestPlatforms.Browser)]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/42852", TestPlatforms.Browser)]
+        [SkipOnPlatform(TestPlatforms.Browser, "Version is ignored on Browser")]
         public async Task SendAsync_CorrectVersionSelected_LoopbackServer(Version requestVersion, HttpVersionPolicy versionPolicy, Version serverVersion, bool useSsl, object expectedResult)
         {
             await HttpAgnosticLoopbackServer.CreateClientAndServerAsync(
@@ -1213,10 +1199,10 @@ await HttpAgnosticLoopbackServer.CreateClientAndServerAsync(
                 });
         }
 
+        [Theory]
         [OuterLoop("Uses external servers")]
         [MemberData(nameof(VersionSelectionMemberData))]
-        [ConditionalTheory(typeof(PlatformDetection), nameof(PlatformDetection.IsBrowserDomSupportedOrNotBrowser))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/53018", TestPlatforms.Browser)]
+        [SkipOnPlatform(TestPlatforms.Browser, "Version is ignored on Browser")]
         public async Task SendAsync_CorrectVersionSelected_ExternalServer(Version requestVersion, HttpVersionPolicy versionPolicy, Version serverVersion, bool useSsl, object expectedResult)
         {
             RemoteServer remoteServer = null;
@@ -1428,4 +1414,30 @@ public sealed class HttpClientSendTest_Sync : HttpClientTest.HttpClientSendTest
         public HttpClientSendTest_Sync(ITestOutputHelper output) : base(output) { }
         protected override bool TestAsync => false;
     }
+
+    public sealed class CustomHttpClientTest
+    {
+        private sealed class CustomHttpClient : HttpClientHandler
+        {
+            public Task<HttpResponseMessage> PublicSendAsync(HttpRequestMessage request, CancellationToken cancellationToken = default) =>
+                SendAsync(request, cancellationToken);
+
+            public HttpResponseMessage PublicSend(HttpRequestMessage request, CancellationToken cancellationToken = default) =>
+                Send(request, cancellationToken);
+        }
+
+        [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNotBrowser))]
+        public void Send_NullRequest_ThrowsException()
+        {
+            using var client = new CustomHttpClient();
+            AssertExtensions.Throws<ArgumentNullException>("request", () => client.PublicSend(null));
+        }
+
+        [Fact]
+        public async Task SendAsync_NullRequest_ThrowsException()
+        {
+            using var client = new CustomHttpClient();
+            await AssertExtensions.ThrowsAsync<ArgumentNullException>("request", () => client.PublicSendAsync(null));
+        }
+    }
 }
diff --git a/src/libraries/System.Net.Http/tests/FunctionalTests/HttpContentTest.cs b/src/libraries/System.Net.Http/tests/FunctionalTests/HttpContentTest.cs
index 214042a185040e..b09b0d2dc1a38d 100644
--- a/src/libraries/System.Net.Http/tests/FunctionalTests/HttpContentTest.cs
+++ b/src/libraries/System.Net.Http/tests/FunctionalTests/HttpContentTest.cs
@@ -613,8 +613,6 @@ public void Dispose_DisposedObjectThenAccessMembers_ThrowsObjectDisposedExceptio
 
 
         [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/39187", TestPlatforms.Browser)]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/42852", TestPlatforms.Browser)]
         public async Task ReadAsStringAsync_Buffered_IgnoresCancellationToken()
         {
             string content = Guid.NewGuid().ToString();
@@ -641,8 +639,6 @@ await LoopbackServer.CreateClientAndServerAsync(
         }
 
         [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/39187", TestPlatforms.Browser)]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/42852", TestPlatforms.Browser)]
         public async Task ReadAsStringAsync_Unbuffered_CanBeCanceled_AlreadyCanceledCts()
         {
             await LoopbackServer.CreateClientAndServerAsync(
@@ -670,8 +666,6 @@ await LoopbackServer.CreateClientAndServerAsync(
         }
 
         [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/39187", TestPlatforms.Browser)]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/42852", TestPlatforms.Browser)]
         public async Task ReadAsStringAsync_Unbuffered_CanBeCanceled()
         {
             var cts = new CancellationTokenSource();
@@ -706,8 +700,6 @@ await server.AcceptConnectionAsync(async connection =>
         }
 
         [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/39187", TestPlatforms.Browser)]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/42852", TestPlatforms.Browser)]
         public async Task ReadAsByteArrayAsync_Buffered_IgnoresCancellationToken()
         {
             string content = Guid.NewGuid().ToString();
@@ -735,8 +727,6 @@ await LoopbackServer.CreateClientAndServerAsync(
         }
 
         [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/39187", TestPlatforms.Browser)]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/42852", TestPlatforms.Browser)]
         public async Task ReadAsByteArrayAsync_Unbuffered_CanBeCanceled_AlreadyCanceledCts()
         {
             await LoopbackServer.CreateClientAndServerAsync(
@@ -764,8 +754,6 @@ await LoopbackServer.CreateClientAndServerAsync(
         }
 
         [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/39187", TestPlatforms.Browser)]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/42852", TestPlatforms.Browser)]
         public async Task ReadAsByteArrayAsync_Unbuffered_CanBeCanceled()
         {
             var cts = new CancellationTokenSource();
@@ -802,8 +790,6 @@ await server.AcceptConnectionAsync(async connection =>
         [Theory]
         [InlineData(true)]
         [InlineData(false)]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/39187", TestPlatforms.Browser)]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/42852", TestPlatforms.Browser)]
         public async Task ReadAsStreamAsync_Buffered_IgnoresCancellationToken(bool readStreamAsync)
         {
             string content = Guid.NewGuid().ToString();
@@ -835,10 +821,13 @@ await LoopbackServer.CreateClientAndServerAsync(
         [Theory]
         [InlineData(true)]
         [InlineData(false)]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/39187", TestPlatforms.Browser)]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/42852", TestPlatforms.Browser)]
         public async Task ReadAsStreamAsync_Unbuffered_IgnoresCancellationToken(bool readStreamAsync)
         {
+            if(PlatformDetection.IsBrowser && !readStreamAsync)
+            {
+                // syncronous operations are not supported on Browser
+                return;
+            }
             string content = Guid.NewGuid().ToString();
 
             await LoopbackServer.CreateClientAndServerAsync(
diff --git a/src/libraries/System.Net.Http/tests/FunctionalTests/HttpRequestMessageTest.cs b/src/libraries/System.Net.Http/tests/FunctionalTests/HttpRequestMessageTest.cs
index 167d5a0504c962..18b7fa9fe47cc6 100644
--- a/src/libraries/System.Net.Http/tests/FunctionalTests/HttpRequestMessageTest.cs
+++ b/src/libraries/System.Net.Http/tests/FunctionalTests/HttpRequestMessageTest.cs
@@ -3,6 +3,7 @@
 
 using System.Collections.Generic;
 using System.IO;
+using System.Linq;
 using System.Net.Http.Headers;
 using System.Net.Test.Common;
 using System.Threading.Tasks;
@@ -12,7 +13,6 @@
 
 namespace System.Net.Http.Functional.Tests
 {
-    [ConditionalClass(typeof(PlatformDetection), nameof(PlatformDetection.IsNotBrowser))]
     public class HttpRequestMessageTest : HttpClientHandlerTestBase
     {
         private readonly Version _expectedRequestMessageVersion = HttpVersion.Version11;
@@ -240,8 +240,12 @@ await LoopbackServer.CreateServerAsync(async (server, uri) =>
                     Task<HttpResponseMessage> requestTask = client.SendAsync(request);
                     await server.AcceptConnectionAsync(async connection =>
                     {
-                        List<string> headers = await connection.ReadRequestHeaderAsync();
-                        Assert.DoesNotContain(headers, line => line.StartsWith("Content-length"));
+                        var requestData = await connection.ReadRequestDataAsync().ConfigureAwait(false);
+#if TARGET_BROWSER
+                        requestData = await connection.HandleCORSPreFlight(requestData);
+#endif
+
+                        Assert.DoesNotContain(requestData.Headers, line => line.Name.StartsWith("Content-length"));
 
                         await connection.SendResponseAsync();
                         await requestTask;
diff --git a/src/libraries/System.Net.Http/tests/FunctionalTests/HttpClientHandlerTest.Cancellation.cs b/src/libraries/System.Net.Http/tests/FunctionalTests/SocketsHttpHandlerTest.Cancellation.cs
similarity index 57%
rename from src/libraries/System.Net.Http/tests/FunctionalTests/HttpClientHandlerTest.Cancellation.cs
rename to src/libraries/System.Net.Http/tests/FunctionalTests/SocketsHttpHandlerTest.Cancellation.cs
index 5589de00d62895..53fcb8fe229cae 100644
--- a/src/libraries/System.Net.Http/tests/FunctionalTests/HttpClientHandlerTest.Cancellation.cs
+++ b/src/libraries/System.Net.Http/tests/FunctionalTests/SocketsHttpHandlerTest.Cancellation.cs
@@ -1,13 +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;
-using System.Collections.Generic;
 using System.Diagnostics;
 using System.IO;
-using System.Linq;
 using System.Net.Test.Common;
-using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 using Xunit;
@@ -15,45 +11,69 @@
 
 namespace System.Net.Http.Functional.Tests
 {
-    public abstract class HttpClientHandler_Http11_Cancellation_Test : HttpClientHandler_Cancellation_Test
+    public abstract class SocketsHttpHandler_Cancellation_Test : HttpClientHandler_Cancellation_Test
     {
-        protected HttpClientHandler_Http11_Cancellation_Test(ITestOutputHelper output) : base(output) { }
+        protected SocketsHttpHandler_Cancellation_Test(ITestOutputHelper output) : base(output) { }
+
+        private async Task ValidateConnectTimeout(HttpMessageInvoker invoker, Uri uri, int minElapsed, int maxElapsed)
+        {
+            var sw = Stopwatch.StartNew();
+            await Assert.ThrowsAnyAsync<OperationCanceledException>(() =>
+                invoker.SendAsync(TestAsync, new HttpRequestMessage(HttpMethod.Get, uri) { Version = UseVersion }, default));
+            sw.Stop();
+
+            Assert.InRange(sw.ElapsedMilliseconds, minElapsed, maxElapsed);
+        }
 
         [OuterLoop]
         [Fact]
         public async Task ConnectTimeout_TimesOutSSLAuth_Throws()
         {
             var releaseServer = new TaskCompletionSource();
-            await LoopbackServer.CreateClientAndServerAsync(async uri =>
+            await LoopbackServerFactory.CreateClientAndServerAsync(async uri =>
             {
                 using (var handler = new SocketsHttpHandler())
                 using (var invoker = new HttpMessageInvoker(handler))
                 {
                     handler.ConnectTimeout = TimeSpan.FromSeconds(1);
 
-                    var sw = Stopwatch.StartNew();
-                    await Assert.ThrowsAnyAsync<OperationCanceledException>(() =>
-                        invoker.SendAsync(TestAsync, new HttpRequestMessage(HttpMethod.Get,
-                            new UriBuilder(uri) { Scheme = "https" }.ToString()) { Version = UseVersion }, default));
-                    sw.Stop();
+                    await ValidateConnectTimeout(invoker, new UriBuilder(uri) { Scheme = "https" }.Uri, 500, 85_000);
 
-                    Assert.InRange(sw.ElapsedMilliseconds, 500, 85_000);
                     releaseServer.SetResult();
                 }
             }, server => releaseServer.Task); // doesn't establish SSL connection
         }
 
+        [OuterLoop]
+        [Fact]
+        public async Task ConnectTimeout_ConnectCallbackTimesOut_Throws()
+        {
+            await LoopbackServerFactory.CreateClientAndServerAsync(async uri =>
+            {
+                using (var handler = CreateHttpClientHandler())
+                using (var invoker = new HttpMessageInvoker(handler))
+                {
+                    var socketsHandler = GetUnderlyingSocketsHttpHandler(handler);
+                    socketsHandler.ConnectTimeout = TimeSpan.FromSeconds(1);
+                    socketsHandler.ConnectCallback = async (context, token) => { await Task.Delay(-1, token); return null; };
+
+                    await ValidateConnectTimeout(invoker, uri, 500, 85_000);
+                }
+            }, server => Task.CompletedTask); // doesn't actually connect to server
+        }
+
         [OuterLoop("Incurs significant delay")]
         [Fact]
         public async Task Expect100Continue_WaitsExpectedPeriodOfTimeBeforeSendingContent()
         {
-            await LoopbackServer.CreateClientAndServerAsync(async uri =>
+            await LoopbackServerFactory.CreateClientAndServerAsync(async uri =>
             {
-                using (var handler = new SocketsHttpHandler())
+                using (var handler = CreateHttpClientHandler())
                 using (var invoker = new HttpMessageInvoker(handler))
                 {
+                    var socketsHandler = GetUnderlyingSocketsHttpHandler(handler);
                     TimeSpan delay = TimeSpan.FromSeconds(3);
-                    handler.Expect100ContinueTimeout = delay;
+                    socketsHandler.Expect100ContinueTimeout = delay;
 
                     var tcs = new TaskCompletionSource<bool>();
                     var content = new SetTcsContent(new MemoryStream(new byte[1]), tcs);
@@ -69,9 +89,7 @@ await LoopbackServer.CreateClientAndServerAsync(async uri =>
             {
                 await server.AcceptConnectionAsync(async connection =>
                 {
-                    await connection.ReadRequestHeaderAsync();
-                    await connection.ReadAsync(new byte[1], 0, 1);
-                    await connection.SendResponseAsync();
+                    await connection.HandleRequestAsync();
                 });
             });
         }
diff --git a/src/libraries/System.Net.Http/tests/FunctionalTests/SocketsHttpHandlerTest.cs b/src/libraries/System.Net.Http/tests/FunctionalTests/SocketsHttpHandlerTest.cs
index 640f468ec92369..cf7edc98814131 100644
--- a/src/libraries/System.Net.Http/tests/FunctionalTests/SocketsHttpHandlerTest.cs
+++ b/src/libraries/System.Net.Http/tests/FunctionalTests/SocketsHttpHandlerTest.cs
@@ -141,9 +141,15 @@ public sealed class SocketsHttpHandler_HttpProtocolTests_Dribble : HttpProtocolT
         public SocketsHttpHandler_HttpProtocolTests_Dribble(ITestOutputHelper output) : base(output) { }
     }
 
-    public sealed class SocketsHttpHandler_DiagnosticsTest : DiagnosticsTest
+    public sealed class SocketsHttpHandler_DiagnosticsTest_Http11 : DiagnosticsTest
     {
-        public SocketsHttpHandler_DiagnosticsTest(ITestOutputHelper output) : base(output) { }
+        public SocketsHttpHandler_DiagnosticsTest_Http11(ITestOutputHelper output) : base(output) { }
+    }
+
+    public sealed class SocketsHttpHandler_DiagnosticsTest_Http2 : DiagnosticsTest
+    {
+        public SocketsHttpHandler_DiagnosticsTest_Http2(ITestOutputHelper output) : base(output) { }
+        protected override Version UseVersion => HttpVersion.Version20;
     }
 
     public sealed class SocketsHttpHandler_HttpClient_SelectedSites_Test : HttpClient_SelectedSites_Test
@@ -164,19 +170,19 @@ public sealed class SocketsHttpHandler_HttpClientHandler_Decompression_Tests : H
         public SocketsHttpHandler_HttpClientHandler_Decompression_Tests(ITestOutputHelper output) : base(output) { }
     }
 
-    [ConditionalClass(typeof(PlatformDetection), nameof(PlatformDetection.IsNotBrowser))]
+    [SkipOnPlatform(TestPlatforms.Browser, "Certificates are not supported on Browser")]
     public sealed class SocketsHttpHandler_HttpClientHandler_DangerousAcceptAllCertificatesValidator_Test : HttpClientHandler_DangerousAcceptAllCertificatesValidator_Test
     {
         public SocketsHttpHandler_HttpClientHandler_DangerousAcceptAllCertificatesValidator_Test(ITestOutputHelper output) : base(output) { }
     }
 
-    [ConditionalClass(typeof(PlatformDetection), nameof(PlatformDetection.IsNotBrowser))]
+    [SkipOnPlatform(TestPlatforms.Browser, "Certificates are not supported on Browser")]
     public sealed class SocketsHttpHandler_HttpClientHandler_ClientCertificates_Test : HttpClientHandler_ClientCertificates_Test
     {
         public SocketsHttpHandler_HttpClientHandler_ClientCertificates_Test(ITestOutputHelper output) : base(output) { }
     }
 
-    [ConditionalClass(typeof(PlatformDetection), nameof(PlatformDetection.IsNotBrowser))]
+    [SkipOnPlatform(TestPlatforms.Browser, "Proxy is not supported on Browser")]
     public sealed class SocketsHttpHandler_HttpClientHandler_DefaultProxyCredentials_Test : HttpClientHandler_DefaultProxyCredentials_Test
     {
         public SocketsHttpHandler_HttpClientHandler_DefaultProxyCredentials_Test(ITestOutputHelper output) : base(output) { }
@@ -242,13 +248,13 @@ await server.AcceptConnectionAsync(async connection =>
         }
     }
 
-    [ConditionalClass(typeof(PlatformDetection), nameof(PlatformDetection.IsNotBrowser))]
+    [SkipOnPlatform(TestPlatforms.Browser, "Certificates are not supported on Browser")]
     public sealed class SocketsHttpHandler_HttpClientHandler_ServerCertificates_Test : HttpClientHandler_ServerCertificates_Test
     {
         public SocketsHttpHandler_HttpClientHandler_ServerCertificates_Test(ITestOutputHelper output) : base(output) { }
     }
 
-    [ConditionalClass(typeof(PlatformDetection), nameof(PlatformDetection.IsNotBrowser))]
+    [SkipOnPlatform(TestPlatforms.Browser, "ResponseDrainTimeout is not supported on Browser")]
     public sealed class SocketsHttpHandler_HttpClientHandler_ResponseDrain_Test : HttpClientHandler_ResponseDrain_Test
     {
         protected override void SetResponseDrainTimeout(HttpClientHandler handler, TimeSpan time)
@@ -554,13 +560,13 @@ public sealed class SocketsHttpHandler_ResponseStreamTest : ResponseStreamTest
         public SocketsHttpHandler_ResponseStreamTest(ITestOutputHelper output) : base(output) { }
     }
 
-    [ConditionalClass(typeof(PlatformDetection), nameof(PlatformDetection.IsNotBrowser))]
+    [ActiveIssue("https://github.com/dotnet/runtime/issues/37669", TestPlatforms.Browser)]
     public sealed class SocketsHttpHandler_HttpClientHandler_SslProtocols_Test : HttpClientHandler_SslProtocols_Test
     {
         public SocketsHttpHandler_HttpClientHandler_SslProtocols_Test(ITestOutputHelper output) : base(output) { }
     }
 
-    [ConditionalClass(typeof(PlatformDetection), nameof(PlatformDetection.IsNotBrowser))]
+    [SkipOnPlatform(TestPlatforms.Browser, "UseProxy not supported on Browser")]
     public sealed class SocketsHttpHandler_HttpClientHandler_Proxy_Test : HttpClientHandler_Proxy_Test
     {
         public SocketsHttpHandler_HttpClientHandler_Proxy_Test(ITestOutputHelper output) : base(output) { }
@@ -582,8 +588,7 @@ protected static Frame MakeDataFrame(int streamId, byte[] data, bool endStream =
             new DataFrame(data, (endStream ? FrameFlags.EndStream : FrameFlags.None), 0, streamId);
     }
 
-    // System.Net.Sockets is not supported on this platform
-    [ConditionalClass(typeof(PlatformDetection), nameof(PlatformDetection.IsNotBrowser))]
+    [ActiveIssue("https://github.com/dotnet/runtime/issues/54156", TestPlatforms.Browser)]
     public class SocketsHttpHandler_Http1_TrailingHeaders_Test : SocketsHttpHandler_TrailingHeaders_Test
     {
         public SocketsHttpHandler_Http1_TrailingHeaders_Test(ITestOutputHelper output) : base(output) { }
@@ -603,6 +608,7 @@ await TestHelper.WhenAllCompletedOrAnyFailed(
                         getResponseTask,
                         server.AcceptConnectionSendCustomResponseAndCloseAsync(
                             "HTTP/1.1 200 OK\r\n" +
+                            LoopbackServer.CorsHeaders +
                             "Connection: close\r\n" +
                             "Transfer-Encoding: chunked\r\n" +
                             (includeTrailerHeader ? "Trailer: MyCoolTrailerHeader, Hello\r\n" : "") +
@@ -656,6 +662,7 @@ await TestHelper.WhenAllCompletedOrAnyFailed(
                         getResponseTask,
                         server.AcceptConnectionSendCustomResponseAndCloseAsync(
                             "HTTP/1.1 200 OK\r\n" +
+                            LoopbackServer.CorsHeaders +
                             "Connection: close\r\n" +
                             "Transfer-Encoding: chunked\r\n" +
                             "Trailer: MyCoolTrailerHeader\r\n" +
@@ -745,6 +752,7 @@ await LoopbackServer.CreateClientAndServerAsync(async url =>
                 }
             }, server => server.AcceptConnectionSendCustomResponseAndCloseAsync(
                 "HTTP/1.1 200 OK\r\n" +
+                LoopbackServer.CorsHeaders +
                 "Connection: close\r\n" +
                 "Transfer-Encoding: chunked\r\n" +
                 $"Trailer: Set-Cookie, MyCoolTrailerHeader, {name}, Hello\r\n" +
@@ -774,6 +782,7 @@ await TestHelper.WhenAllCompletedOrAnyFailed(
                         server.AcceptConnectionSendCustomResponseAndCloseAsync(
                             "HTTP/1.1 200 OK\r\n" +
                             "Connection: close\r\n" +
+                            LoopbackServer.CorsHeaders +
                             "Transfer-Encoding: chunked\r\n" +
                             "Trailer: MyCoolTrailerHeader\r\n" +
                             "\r\n" +
@@ -981,7 +990,6 @@ public sealed class SocketsHttpHandler_SchSendAuxRecordHttpTest : SchSendAuxReco
         public SocketsHttpHandler_SchSendAuxRecordHttpTest(ITestOutputHelper output) : base(output) { }
     }
 
-    [SkipOnPlatform(TestPlatforms.Browser, "Tests hang with chrome. To be investigated")]
     public sealed class SocketsHttpHandler_HttpClientHandlerTest : HttpClientHandlerTest
     {
         public SocketsHttpHandler_HttpClientHandlerTest(ITestOutputHelper output) : base(output) { }
@@ -1011,22 +1019,22 @@ public sealed class SocketsHttpHandlerTest_RequestRetry : HttpClientHandlerTest_
         public SocketsHttpHandlerTest_RequestRetry(ITestOutputHelper output) : base(output) { }
     }
 
-    [ConditionalClass(typeof(PlatformDetection), nameof(PlatformDetection.IsNotBrowser))]
+    [SkipOnPlatform(TestPlatforms.Browser, "UseCookies is not supported on Browser")]
     public sealed class SocketsHttpHandlerTest_Cookies : HttpClientHandlerTest_Cookies
     {
         public SocketsHttpHandlerTest_Cookies(ITestOutputHelper output) : base(output) { }
     }
 
-    [ConditionalClass(typeof(PlatformDetection), nameof(PlatformDetection.IsNotBrowser))]
+    [SkipOnPlatform(TestPlatforms.Browser, "UseCookies is not supported on Browser")]
     public sealed class SocketsHttpHandlerTest_Cookies_Http11 : HttpClientHandlerTest_Cookies_Http11
     {
         public SocketsHttpHandlerTest_Cookies_Http11(ITestOutputHelper output) : base(output) { }
     }
 
-    [ConditionalClass(typeof(PlatformDetection), nameof(PlatformDetection.IsNotBrowser))]
-    public sealed class SocketsHttpHandler_HttpClientHandler_Cancellation_Test : HttpClientHandler_Http11_Cancellation_Test
+    [SkipOnPlatform(TestPlatforms.Browser, "ConnectTimeout is not supported on Browser")]
+    public sealed class SocketsHttpHandler_HttpClientHandler_Http11_Cancellation_Test : SocketsHttpHandler_Cancellation_Test
     {
-        public SocketsHttpHandler_HttpClientHandler_Cancellation_Test(ITestOutputHelper output) : base(output) { }
+        public SocketsHttpHandler_HttpClientHandler_Http11_Cancellation_Test(ITestOutputHelper output) : base(output) { }
 
         [Fact]
         public void ConnectTimeout_Default()
@@ -1124,15 +1132,13 @@ public void Expect100ContinueTimeout_SetAfterUse_Throws()
         }
     }
 
-    // BrowserHttpHandler.set_MaxResponseHeadersLength - Not supported on this platform
-    [ConditionalClass(typeof(PlatformDetection), nameof(PlatformDetection.IsNotBrowser))]
+    [SkipOnPlatform(TestPlatforms.Browser, "MaxResponseHeadersLength is not supported on Browser")]
     public sealed class SocketsHttpHandler_HttpClientHandler_MaxResponseHeadersLength_Test : HttpClientHandler_MaxResponseHeadersLength_Test
     {
         public SocketsHttpHandler_HttpClientHandler_MaxResponseHeadersLength_Test(ITestOutputHelper output) : base(output) { }
     }
 
-    //System.Net.Sockets is not supported on this platform
-    [ConditionalClass(typeof(PlatformDetection), nameof(PlatformDetection.IsNotBrowser))]
+    [SkipOnPlatform(TestPlatforms.Browser, "Socket is not supported on Browser")]
     public sealed class SocketsHttpHandler_HttpClientHandler_Authentication_Test : HttpClientHandler_Authentication_Test
     {
         public SocketsHttpHandler_HttpClientHandler_Authentication_Test(ITestOutputHelper output) : base(output) { }
@@ -1152,7 +1158,7 @@ await LoopbackServer.CreateServerAsync(async (server, url) =>
                 {
                     // We need to use ResponseHeadersRead here, otherwise we will hang trying to buffer the response body.
                     Task<HttpResponseMessage> getResponseTask = client.GetAsync(url, HttpCompletionOption.ResponseHeadersRead);
-                    await server.AcceptConnectionAsync(async connection =>
+                    await server.AcceptConnectionAsync(async (LoopbackServer.Connection connection) =>
                     {
                         Task<List<string>> serverTask = connection.ReadRequestHeaderAndSendCustomResponseAsync($"HTTP/1.1 101 Switching Protocols\r\nDate: {DateTimeOffset.UtcNow:R}\r\n\r\n");
 
@@ -1246,7 +1252,7 @@ await server.AcceptConnectionAsync(async connection =>
                             Task copyTask = clientStream.CopyToAsync(ms);
 
                             string bigString = string.Concat(Enumerable.Repeat("abcdefghijklmnopqrstuvwxyz", 1000));
-                            Task lotsOfDataSent = connection.Socket.SendAsync(Encoding.ASCII.GetBytes(bigString), SocketFlags.None);
+                            Task lotsOfDataSent = connection.SendResponseAsync(Encoding.ASCII.GetBytes(bigString));
                             connection.Socket.Shutdown(SocketShutdown.Send);
                             await copyTask;
                             await lotsOfDataSent;
@@ -1264,8 +1270,7 @@ public sealed class SocketsHttpHandler_Connect_Test : HttpClientHandler_Connect_
         public SocketsHttpHandler_Connect_Test(ITestOutputHelper output) : base(output) { }
     }
 
-    // System.Net.Sockets is not supported on this platform
-    [ConditionalClass(typeof(PlatformDetection), nameof(PlatformDetection.IsNotBrowser))]
+    [SkipOnPlatform(TestPlatforms.Browser, "Socket is not supported on Browser")]
     public sealed class SocketsHttpHandler_HttpClientHandler_ConnectionPooling_Test : HttpClientHandlerTestBase
     {
         public SocketsHttpHandler_HttpClientHandler_ConnectionPooling_Test(ITestOutputHelper output) : base(output) { }
@@ -1462,7 +1467,7 @@ await Http2LoopbackServerFactory.CreateServerAsync(async (server, url) =>
                     // Wait a small amount of time before making the second request, to give the first request time to timeout.
                     await Task.Delay(100);
                     // Grab reference to underlying socket and stream to make sure they are not disposed and closed.
-                    (Socket socket, Stream stream) = connection.ResetNetwork();
+                    (SocketWrapper socket, Stream stream) = connection.ResetNetwork();
 
                     // Make second request and expect it to be served from a different connection.
                     Task<string> request2 = client.GetStringAsync(url);
@@ -1991,8 +1996,7 @@ await Assert.ThrowsAnyAsync<Exception>(() =>
         }
     }
 
-    // System.Net.Sockets is not supported on this platform
-    [ConditionalClass(typeof(PlatformDetection), nameof(PlatformDetection.IsNotBrowser))]
+    [SkipOnPlatform(TestPlatforms.Browser, "Headers.Location are not supported on Browser")]
     public sealed class SocketsHttpHandlerTest_LocationHeader
     {
         private static readonly byte[] s_redirectResponseBefore = Encoding.ASCII.GetBytes(
@@ -2665,8 +2669,7 @@ public async Task ConnectCallback_ReturnsNull_ThrowsHttpRequestException(bool us
         private static bool PlatformSupportsUnixDomainSockets => Socket.OSSupportsUnixDomainSockets;
    }
 
-    // System.Net.Sockets is not supported on this platform
-    [ConditionalClass(typeof(PlatformDetection), nameof(PlatformDetection.IsNotBrowser))]
+    [SkipOnPlatform(TestPlatforms.Browser, "Socket is not supported on Browser")]
     public sealed class SocketsHttpHandlerTest_ConnectCallback_Http11 : SocketsHttpHandlerTest_ConnectCallback
     {
         public SocketsHttpHandlerTest_ConnectCallback_Http11(ITestOutputHelper output) : base(output) { }
@@ -3064,7 +3067,7 @@ public SocketsHttpHandlerTest_HttpClientHandlerTest_Headers_Http2(ITestOutputHel
     }
 
     [ConditionalClass(typeof(PlatformDetection), nameof(PlatformDetection.SupportsAlpn))]
-    public sealed class SocketsHttpHandler_HttpClientHandler_Cancellation_Test_Http2 : HttpClientHandler_Cancellation_Test
+    public sealed class SocketsHttpHandler_HttpClientHandler_Cancellation_Test_Http2 : SocketsHttpHandler_Cancellation_Test
     {
         public SocketsHttpHandler_HttpClientHandler_Cancellation_Test_Http2(ITestOutputHelper output) : base(output) { }
         protected override Version UseVersion => HttpVersion.Version20;
@@ -3077,7 +3080,7 @@ public SocketsHttpHandlerTest_Http3_MsQuic(ITestOutputHelper output) : base(outp
         protected override QuicImplementationProvider UseQuicImplementationProvider => QuicImplementationProviders.MsQuic;
     }
 
-    [ConditionalClass(typeof(HttpClientHandlerTestBase), nameof(IsMsQuicSupported))]
+    [ConditionalClass(typeof(HttpClientHandlerTestBase), nameof(IsMockQuicSupported))]
     public sealed class SocketsHttpHandlerTest_Http3_Mock : HttpClientHandlerTest_Http3
     {
         public SocketsHttpHandlerTest_Http3_Mock(ITestOutputHelper output) : base(output) { }
@@ -3092,7 +3095,7 @@ public SocketsHttpHandlerTest_HttpClientHandlerTest_Http3_MsQuic(ITestOutputHelp
         protected override QuicImplementationProvider UseQuicImplementationProvider => QuicImplementationProviders.MsQuic;
     }
 
-    [ConditionalClass(typeof(HttpClientHandlerTestBase), nameof(IsMsQuicSupported))]
+    [ConditionalClass(typeof(HttpClientHandlerTestBase), nameof(IsMockQuicSupported))]
     public sealed class SocketsHttpHandlerTest_HttpClientHandlerTest_Http3_Mock : HttpClientHandlerTest
     {
         public SocketsHttpHandlerTest_HttpClientHandlerTest_Http3_Mock(ITestOutputHelper output) : base(output) { }
@@ -3111,7 +3114,7 @@ public SocketsHttpHandlerTest_Cookies_Http3_MsQuic(ITestOutputHelper output) : b
     }
 
     [ActiveIssue("https://github.com/dotnet/runtime/issues/53093")]
-    [ConditionalClass(typeof(HttpClientHandlerTestBase), nameof(IsMsQuicSupported))]
+    [ConditionalClass(typeof(HttpClientHandlerTestBase), nameof(IsMockQuicSupported))]
     public sealed class SocketsHttpHandlerTest_Cookies_Http3_Mock : HttpClientHandlerTest_Cookies
     {
         public SocketsHttpHandlerTest_Cookies_Http3_Mock(ITestOutputHelper output) : base(output) { }
@@ -3127,7 +3130,7 @@ public SocketsHttpHandlerTest_HttpClientHandlerTest_Headers_Http3_MsQuic(ITestOu
         protected override QuicImplementationProvider UseQuicImplementationProvider => QuicImplementationProviders.MsQuic;
     }
 
-    [ConditionalClass(typeof(HttpClientHandlerTestBase), nameof(IsMsQuicSupported))]
+    [ConditionalClass(typeof(HttpClientHandlerTestBase), nameof(IsMockQuicSupported))]
     public sealed class SocketsHttpHandlerTest_HttpClientHandlerTest_Headers_Http3_Mock : HttpClientHandlerTest_Headers
     {
         public SocketsHttpHandlerTest_HttpClientHandlerTest_Headers_Http3_Mock(ITestOutputHelper output) : base(output) { }
@@ -3138,7 +3141,7 @@ public SocketsHttpHandlerTest_HttpClientHandlerTest_Headers_Http3_Mock(ITestOutp
     // TODO: Many cancellation tests are failing for HTTP3.
     [ActiveIssue("https://github.com/dotnet/runtime/issues/53093")]
     [ConditionalClass(typeof(HttpClientHandlerTestBase), nameof(IsMsQuicSupported))]
-    public sealed class SocketsHttpHandler_HttpClientHandler_Cancellation_Test_Http3_MsQuic : HttpClientHandler_Cancellation_Test
+    public sealed class SocketsHttpHandler_HttpClientHandler_Cancellation_Test_Http3_MsQuic : SocketsHttpHandler_Cancellation_Test
     {
         public SocketsHttpHandler_HttpClientHandler_Cancellation_Test_Http3_MsQuic(ITestOutputHelper output) : base(output) { }
         protected override Version UseVersion => HttpVersion.Version30;
@@ -3146,16 +3149,14 @@ public SocketsHttpHandler_HttpClientHandler_Cancellation_Test_Http3_MsQuic(ITest
     }
 
     [ActiveIssue("https://github.com/dotnet/runtime/issues/53093")]
-    [ConditionalClass(typeof(HttpClientHandlerTestBase), nameof(IsMsQuicSupported))]
-    public sealed class SocketsHttpHandler_HttpClientHandler_Cancellation_Test_Http3_Mock : HttpClientHandler_Cancellation_Test
+    [ConditionalClass(typeof(HttpClientHandlerTestBase), nameof(IsMockQuicSupported))]
+    public sealed class SocketsHttpHandler_HttpClientHandler_Cancellation_Test_Http3_Mock : SocketsHttpHandler_Cancellation_Test
     {
         public SocketsHttpHandler_HttpClientHandler_Cancellation_Test_Http3_Mock(ITestOutputHelper output) : base(output) { }
         protected override Version UseVersion => HttpVersion.Version30;
         protected override QuicImplementationProvider UseQuicImplementationProvider => QuicImplementationProviders.Mock;
     }
 
-    // TODO: Many AltSvc tests are failing for HTTP3.
-    [ActiveIssue("https://github.com/dotnet/runtime/issues/53093")]
     [ConditionalClass(typeof(HttpClientHandlerTestBase), nameof(IsMsQuicSupported))]
     public sealed class SocketsHttpHandler_HttpClientHandler_AltSvc_Test_Http3_MsQuic : HttpClientHandler_AltSvc_Test
     {
@@ -3164,8 +3165,7 @@ public SocketsHttpHandler_HttpClientHandler_AltSvc_Test_Http3_MsQuic(ITestOutput
         protected override QuicImplementationProvider UseQuicImplementationProvider => QuicImplementationProviders.MsQuic;
     }
 
-    [ActiveIssue("https://github.com/dotnet/runtime/issues/53093")]
-    [ConditionalClass(typeof(HttpClientHandlerTestBase), nameof(IsMsQuicSupported))]
+    [ConditionalClass(typeof(HttpClientHandlerTestBase), nameof(IsMockQuicSupported))]
     public sealed class SocketsHttpHandler_HttpClientHandler_AltSvc_Test_Http3_Mock : HttpClientHandler_AltSvc_Test
     {
         public SocketsHttpHandler_HttpClientHandler_AltSvc_Test_Http3_Mock(ITestOutputHelper output) : base(output) { }
@@ -3181,7 +3181,7 @@ public SocketsHttpHandler_HttpClientHandler_Finalization_Http3_MsQuic(ITestOutpu
         protected override QuicImplementationProvider UseQuicImplementationProvider => QuicImplementationProviders.MsQuic;
     }
 
-    [ConditionalClass(typeof(HttpClientHandlerTestBase), nameof(IsMsQuicSupported))]
+    [ConditionalClass(typeof(HttpClientHandlerTestBase), nameof(IsMockQuicSupported))]
     public sealed class SocketsHttpHandler_HttpClientHandler_Finalization_Http3_Mock : HttpClientHandler_Finalization_Test
     {
         public SocketsHttpHandler_HttpClientHandler_Finalization_Http3_Mock(ITestOutputHelper output) : base(output) { }
diff --git a/src/libraries/System.Net.Http/tests/FunctionalTests/SocksProxyTest.cs b/src/libraries/System.Net.Http/tests/FunctionalTests/SocksProxyTest.cs
index 633f562c9491bc..821794e9f82d5e 100644
--- a/src/libraries/System.Net.Http/tests/FunctionalTests/SocksProxyTest.cs
+++ b/src/libraries/System.Net.Http/tests/FunctionalTests/SocksProxyTest.cs
@@ -113,14 +113,14 @@ public async Task TestExceptionalAsync(string scheme, string host, bool useAuth,
     }
 
 
-    [ConditionalClass(typeof(PlatformDetection), nameof(PlatformDetection.IsNotBrowser))]
+    [SkipOnPlatform(TestPlatforms.Browser, "UseProxy not supported on Browser")]
     public sealed class SocksProxyTest_Http1_Async : SocksProxyTest
     {
         public SocksProxyTest_Http1_Async(ITestOutputHelper helper) : base(helper) { }
         protected override Version UseVersion => HttpVersion.Version11;
     }
 
-    [ConditionalClass(typeof(PlatformDetection), nameof(PlatformDetection.IsNotBrowser))]
+    [SkipOnPlatform(TestPlatforms.Browser, "UseProxy not supported on Browser")]
     public sealed class SocksProxyTest_Http1_Sync : SocksProxyTest
     {
         public SocksProxyTest_Http1_Sync(ITestOutputHelper helper) : base(helper) { }
@@ -128,7 +128,7 @@ public SocksProxyTest_Http1_Sync(ITestOutputHelper helper) : base(helper) { }
         protected override bool TestAsync => false;
     }
 
-    [ConditionalClass(typeof(PlatformDetection), nameof(PlatformDetection.IsNotBrowser))]
+    [SkipOnPlatform(TestPlatforms.Browser, "UseProxy not supported on Browser")]
     public sealed class SocksProxyTest_Http2 : SocksProxyTest
     {
         public SocksProxyTest_Http2(ITestOutputHelper helper) : base(helper) { }
diff --git a/src/libraries/System.Net.Http/tests/FunctionalTests/SyncHttpHandlerTest.cs b/src/libraries/System.Net.Http/tests/FunctionalTests/SyncHttpHandlerTest.cs
index f1028363a1e244..6e67a0173eac89 100644
--- a/src/libraries/System.Net.Http/tests/FunctionalTests/SyncHttpHandlerTest.cs
+++ b/src/libraries/System.Net.Http/tests/FunctionalTests/SyncHttpHandlerTest.cs
@@ -83,7 +83,7 @@ public SyncHttpHandlerTest_Cookies_Http11(ITestOutputHelper output) : base(outpu
     }
 
     [ConditionalClass(typeof(PlatformDetection), nameof(PlatformDetection.IsNotBrowser))]
-    public sealed class SyncHttpHandler_HttpClientHandler_Cancellation_Test : HttpClientHandler_Http11_Cancellation_Test
+    public sealed class SyncHttpHandler_HttpClientHandler_Cancellation_Test : SocketsHttpHandler_Cancellation_Test
     {
         public SyncHttpHandler_HttpClientHandler_Cancellation_Test(ITestOutputHelper output) : base(output) { }
         protected override bool TestAsync => false;
diff --git a/src/libraries/System.Net.Http/tests/FunctionalTests/System.Net.Http.Functional.Tests.csproj b/src/libraries/System.Net.Http/tests/FunctionalTests/System.Net.Http.Functional.Tests.csproj
index a5ae70bbb2feb4..672ce364f7061f 100644
--- a/src/libraries/System.Net.Http/tests/FunctionalTests/System.Net.Http.Functional.Tests.csproj
+++ b/src/libraries/System.Net.Http/tests/FunctionalTests/System.Net.Http.Functional.Tests.csproj
@@ -8,11 +8,24 @@
     <IncludeRemoteExecutor>true</IncludeRemoteExecutor>
     <TargetFrameworks>$(NetCoreAppCurrent)-windows;$(NetCoreAppCurrent)-Linux;$(NetCoreAppCurrent)-Browser;$(NetCoreAppCurrent)-OSX</TargetFrameworks>
   </PropertyGroup>
+
   <PropertyGroup Condition="'$(TargetOS)' == 'Browser'">
     <Scenario>WasmTestOnBrowser</Scenario>
     <TestArchiveTestsRoot>$(TestArchiveRoot)browseronly/</TestArchiveTestsRoot>
     <TestArchiveTestsDir>$(TestArchiveTestsRoot)$(OSPlatformConfig)/</TestArchiveTestsDir>
+    <DefineConstants>$(DefineConstants);TARGET_BROWSER</DefineConstants>
   </PropertyGroup>
+
+  <Import Condition="'$(TargetOS)' == 'Browser'" Project="$(CommonTestPath)System/Net/Prerequisites/LocalEchoServer.props" />
+
+  <!-- Browser specific files -->
+  <ItemGroup Condition="'$(TargetOS)' == 'Browser'">
+    <ProjectReference Include="$(CommonTestPath)System/Net/Prerequisites/NetCoreServer/NetCoreServer.csproj" ReferenceOutputAssembly="false"/>
+    <ProjectReference Include="$(CommonTestPath)System/Net/Prerequisites/RemoteLoopServer/RemoteLoopServer.csproj" ReferenceOutputAssembly="false"/>
+    <Compile Include="$(CommonTestPath)System\Net\WebSockets\WebSocketStream.cs"
+             Link="Common\System\Net\WebSockets\WebSocketStream.cs" />
+  </ItemGroup>
+
   <ItemGroup>
     <Compile Include="$(CommonPath)Interop\Unix\Interop.Libraries.cs" Condition="'$(TargetsUnix)' == 'true' or '$(TargetsBrowser)' == 'true'"
              Link="Common\Interop\Unix\Interop.Libraries.cs" />
@@ -116,7 +129,7 @@
     <Compile Include="$(CommonTestPath)System\Net\Http\HttpClientHandlerTest.DefaultProxyCredentials.cs"
              Link="Common\System\Net\Http\HttpClientHandlerTest.DefaultProxyCredentials.cs" />
     <Compile Include="HttpClientHandlerTest.AltSvc.cs" />
-    <Compile Include="HttpClientHandlerTest.Cancellation.cs" />
+    <Compile Include="SocketsHttpHandlerTest.Cancellation.cs" />
     <Compile Include="HttpClientHandlerTest.Connect.cs" />
     <Compile Include="HttpClientHandlerTest.Finalization.cs" />
     <Compile Include="HttpClientHandlerTest.Headers.cs" />
diff --git a/src/libraries/System.Net.Http/tests/UnitTests/HPack/HPackRoundtripTests.cs b/src/libraries/System.Net.Http/tests/UnitTests/HPack/HPackRoundtripTests.cs
index 03f801e39b26af..7ddee86b7f1251 100644
--- a/src/libraries/System.Net.Http/tests/UnitTests/HPack/HPackRoundtripTests.cs
+++ b/src/libraries/System.Net.Http/tests/UnitTests/HPack/HPackRoundtripTests.cs
@@ -62,7 +62,7 @@ private static Memory<byte> HPackEncode(HttpHeaders headers, Encoding? valueEnco
 
             foreach (KeyValuePair<HeaderDescriptor, object> header in headers.HeaderStore)
             {
-                int headerValuesCount = HttpHeaders.GetValuesAsStrings(header.Key, header.Value, ref headerValues);
+                int headerValuesCount = HttpHeaders.GetStoreValuesIntoStringArray(header.Key, header.Value, ref headerValues);
                 Assert.InRange(headerValuesCount, 0, int.MaxValue);
                 ReadOnlySpan<string> headerValuesSpan = headerValues.AsSpan(0, headerValuesCount);
 
diff --git a/src/libraries/System.Net.Http/tests/UnitTests/Headers/HttpHeadersTest.cs b/src/libraries/System.Net.Http/tests/UnitTests/Headers/HttpHeadersTest.cs
index 58dd95c97bcfce..2a25ea71961915 100644
--- a/src/libraries/System.Net.Http/tests/UnitTests/Headers/HttpHeadersTest.cs
+++ b/src/libraries/System.Net.Http/tests/UnitTests/Headers/HttpHeadersTest.cs
@@ -1,12 +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;
 using System.Collections;
 using System.Collections.Generic;
+using System.Globalization;
 using System.Linq;
 using System.Net.Http.Headers;
-using System.Text;
+using System.Tests;
 
 using Xunit;
 
@@ -1421,7 +1421,17 @@ public void GetParsedValues_GetParsedValuesForKnownHeaderWithInvalidNewlineChars
         }
 
         [Fact]
-        public void GetHeaderStrings_SetValidAndInvalidHeaderValues_AllHeaderValuesReturned()
+        public void NonValidated_Default_Empty()
+        {
+            HttpHeadersNonValidated v = default;
+            Assert.Equal(0, v.Count);
+            Assert.Empty(v);
+            Assert.False(v.TryGetValues("Host", out HeaderStringValues values));
+            Assert.Empty(values);
+        }
+
+        [Fact]
+        public void NonValidated_SetValidAndInvalidHeaderValues_AllHeaderValuesReturned()
         {
             MockHeaderParser parser = new MockHeaderParser("---");
             MockHeaders headers = new MockHeaders(parser);
@@ -1431,16 +1441,25 @@ public void GetHeaderStrings_SetValidAndInvalidHeaderValues_AllHeaderValuesRetur
             headers.TryAddWithoutValidation(headers.Descriptor, "value2,value3");
             headers.TryAddWithoutValidation(headers.Descriptor, invalidHeaderValue);
 
-            foreach (var header in headers.GetHeaderStrings())
+            string expectedValue = "value2,value3---" + invalidHeaderValue + "---" + parsedPrefix + "1";
+
+            Assert.Equal(1, headers.NonValidated.Count);
+
+            int iterations = 0;
+            foreach (KeyValuePair<string, HeaderStringValues> header in headers.NonValidated)
             {
-                Assert.Equal(headers.Descriptor.Name, header.Key);
                 // Note that raw values don't get parsed but just added to the result.
-                Assert.Equal("value2,value3---" + invalidHeaderValue + "---" + parsedPrefix + "1", header.Value);
+                iterations++;
+                Assert.Equal(headers.Descriptor.Name, header.Key);
+                Assert.Equal(3, header.Value.Count);
+                Assert.Equal(expectedValue, header.Value.ToString());
             }
+
+            Assert.Equal(1, iterations);
         }
 
         [Fact]
-        public void GetHeaderStrings_SetMultipleHeaders_AllHeaderValuesReturned()
+        public void NonValidated_SetMultipleHeaders_AllHeaderValuesReturned()
         {
             MockHeaderParser parser = new MockHeaderParser(true);
             MockHeaders headers = new MockHeaders(parser);
@@ -1456,17 +1475,17 @@ public void GetHeaderStrings_SetMultipleHeaders_AllHeaderValuesReturned()
             string[] expectedHeaderValues = { parsedPrefix + "1", "value2", "", "value41, value42" };
             int i = 0;
 
-            foreach (var header in headers.GetHeaderStrings())
+            foreach (KeyValuePair<string, HeaderStringValues> header in headers.NonValidated)
             {
                 Assert.NotEqual(expectedHeaderNames.Length, i);
                 Assert.Equal(expectedHeaderNames[i], header.Key);
-                Assert.Equal(expectedHeaderValues[i], header.Value);
+                Assert.Equal(expectedHeaderValues[i], header.Value.ToString());
                 i++;
             }
         }
 
         [Fact]
-        public void GetHeaderStrings_SetMultipleValuesOnSingleValueHeader_AllHeaderValuesReturned()
+        public void NonValidated_SetMultipleValuesOnSingleValueHeader_AllHeaderValuesReturned()
         {
             MockHeaderParser parser = new MockHeaderParser(false);
             MockHeaders headers = new MockHeaders(parser);
@@ -1474,11 +1493,75 @@ public void GetHeaderStrings_SetMultipleValuesOnSingleValueHeader_AllHeaderValue
             headers.TryAddWithoutValidation(headers.Descriptor, "value1");
             headers.TryAddWithoutValidation(headers.Descriptor, rawPrefix);
 
-            foreach (var header in headers.GetHeaderStrings())
+            foreach (KeyValuePair<string, HeaderStringValues> header in headers.NonValidated)
             {
                 Assert.Equal(headers.Descriptor.Name, header.Key);
                 // Note that the added rawPrefix did not get parsed
-                Assert.Equal("value1, " + rawPrefix, header.Value);
+                Assert.Equal("value1, " + rawPrefix, header.Value.ToString());
+            }
+        }
+
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/53647", TestPlatforms.Browser)]
+        [Fact]
+        public void NonValidated_ValidAndInvalidValues_DictionaryMembersWork()
+        {
+            var headers = new HttpResponseHeaders();
+            IReadOnlyDictionary<string, HeaderStringValues> nonValidated = headers.NonValidated;
+
+            Assert.True(headers.TryAddWithoutValidation("Location", "http:/invalidLocation"));
+            Assert.True(headers.TryAddWithoutValidation("Location", "http:/anotherLocation"));
+            Assert.True(headers.TryAddWithoutValidation("Date", "not a date"));
+
+            Assert.Equal(2, nonValidated.Count);
+
+            Assert.True(nonValidated.ContainsKey("Location"));
+            Assert.True(nonValidated.ContainsKey("Date"));
+
+            Assert.False(nonValidated.ContainsKey("Age"));
+            Assert.False(nonValidated.TryGetValue("Age", out _));
+            Assert.Throws<KeyNotFoundException>(() => nonValidated["Age"]);
+
+            Assert.True(nonValidated.TryGetValue("Location", out HeaderStringValues locations));
+            Assert.Equal(2, locations.Count);
+            Assert.Equal(new[] { "http:/invalidLocation", "http:/anotherLocation" }, locations.ToArray());
+            Assert.Equal("http:/invalidLocation, http:/anotherLocation", locations.ToString());
+
+            Assert.True(nonValidated.TryGetValue("Date", out HeaderStringValues dates));
+            Assert.Equal(1, dates.Count);
+            Assert.Equal(new[] { "not a date" }, dates.ToArray());
+            Assert.Equal("not a date", dates.ToString());
+
+            dates = nonValidated["Date"];
+            Assert.Equal(1, dates.Count);
+            Assert.Equal(new[] { "not a date" }, dates.ToArray());
+            Assert.Equal("not a date", dates.ToString());
+
+            Assert.Equal(new HashSet<string> { "Location", "Date" }, nonValidated.Keys.ToHashSet());
+        }
+
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/53647", TestPlatforms.Browser)]
+        [Fact]
+        public void NonValidated_ValidInvalidAndRaw_AllReturned()
+        {
+            var headers = new HttpResponseHeaders();
+            IReadOnlyDictionary<string, HeaderStringValues> nonValidated = headers.NonValidated;
+
+            // Parsed value
+            headers.Date = new DateTimeOffset(1, 2, 3, 4, 5, 6, TimeSpan.Zero);
+
+            // Invalid value
+            headers.TryAddWithoutValidation("Date", "not a date");
+            foreach (KeyValuePair<string, IEnumerable<string>> _ in headers) { }
+
+            // Raw value
+            headers.TryAddWithoutValidation("Date", "another not a date");
+
+            // All three show up
+            Assert.Equal(1, nonValidated.Count);
+            Assert.Equal(3, nonValidated["Date"].Count);
+            using (new ThreadCultureChange(new CultureInfo("en-US")))
+            {
+                Assert.Equal(new HashSet<string> { "not a date", "another not a date", "Sat, 03 Feb 0001 04:05:06 GMT" }, nonValidated["Date"].ToHashSet());
             }
         }
 
@@ -1562,7 +1645,7 @@ public void GetEnumerator_GetEnumeratorFromUninitializedHeaderStore_ReturnsEmpty
         {
             MockHeaders headers = new MockHeaders();
 
-            var enumerator = headers.GetEnumerator();
+            IEnumerator<KeyValuePair<string, IEnumerable<string>>> enumerator = headers.GetEnumerator();
             Assert.False(enumerator.MoveNext());
         }
 
@@ -1577,7 +1660,7 @@ public void GetEnumerator_FirstHeaderWithOneValueSecondHeaderWithTwoValues_Enume
             // The value added with TryAddWithoutValidation() wasn't parsed yet.
             Assert.Equal(1, headers.Parser.TryParseValueCallCount);
 
-            var enumerator = headers.GetEnumerator();
+            IEnumerator<KeyValuePair<string, IEnumerable<string>>> enumerator = headers.GetEnumerator();
 
             // Getting the enumerator doesn't trigger parsing.
             Assert.Equal(1, headers.Parser.TryParseValueCallCount);
@@ -1610,7 +1693,7 @@ public void GetEnumerator_FirstCustomHeaderWithEmptyValueSecondKnownHeaderWithEm
             headers.Add(customHeaderName, string.Empty);
             headers.Add(headers.Descriptor, string.Empty);
 
-            var enumerator = headers.GetEnumerator();
+            IEnumerator<KeyValuePair<string, IEnumerable<string>>> enumerator = headers.GetEnumerator();
 
             Assert.True(enumerator.MoveNext());
             Assert.Equal(customHeaderName, enumerator.Current.Key);
@@ -1631,7 +1714,7 @@ public void GetEnumerator_UseExplicitInterfaceImplementation_EnumeratorReturnsNo
 
             System.Collections.IEnumerable headersAsIEnumerable = headers;
 
-            var enumerator = headersAsIEnumerable.GetEnumerator();
+            IEnumerator enumerator = headersAsIEnumerable.GetEnumerator();
 
             KeyValuePair<string, IEnumerable<string>> currentValue;
 
@@ -2048,6 +2131,64 @@ public void AddHeaders_SourceHasInvalidHeaderValues_InvalidHeadersRemovedFromSou
             Assert.False(destination.Contains("custom"), "destination contains 'custom' header.");
         }
 
+        [Fact]
+        public void HeaderStringValues_Default_Empty()
+        {
+            HeaderStringValues v = default;
+            Assert.Equal(0, v.Count);
+            Assert.Empty(v);
+            Assert.Equal(string.Empty, v.ToString());
+        }
+
+        [Fact]
+        public void HeaderStringValues_Constructed_ProducesExpectedResults()
+        {
+            // 0 strings
+            foreach (HeaderStringValues hsv in new[] { new HeaderStringValues(KnownHeaders.Accept.Descriptor, Array.Empty<string>()) })
+            {
+                Assert.Equal(0, hsv.Count);
+
+                HeaderStringValues.Enumerator e = hsv.GetEnumerator();
+
+                Assert.False(e.MoveNext());
+
+                Assert.Equal(string.Empty, hsv.ToString());
+            }
+
+            // 1 string
+            foreach (HeaderStringValues hsv in new[] { new HeaderStringValues(KnownHeaders.Accept.Descriptor, "hello"), new HeaderStringValues(KnownHeaders.Accept.Descriptor, new[] { "hello" }) })
+            {
+                Assert.Equal(1, hsv.Count);
+
+                HeaderStringValues.Enumerator e = hsv.GetEnumerator();
+
+                Assert.True(e.MoveNext());
+                Assert.Equal("hello", e.Current);
+
+                Assert.False(e.MoveNext());
+
+                Assert.Equal("hello", hsv.ToString());
+            }
+
+            // 2 strings
+            foreach (HeaderStringValues hsv in new[] { new HeaderStringValues(KnownHeaders.Accept.Descriptor, new[] { "hello", "world" }) })
+            {
+                Assert.Equal(2, hsv.Count);
+
+                HeaderStringValues.Enumerator e = hsv.GetEnumerator();
+
+                Assert.True(e.MoveNext());
+                Assert.Equal("hello", e.Current);
+
+                Assert.True(e.MoveNext());
+                Assert.Equal("world", e.Current);
+
+                Assert.False(e.MoveNext());
+
+                Assert.Equal("hello, world", hsv.ToString());
+            }
+        }
+
         public static IEnumerable<object[]> GetInvalidHeaderNames()
         {
             yield return new object[] { "invalid header" };
diff --git a/src/libraries/System.Net.Http/tests/UnitTests/Headers/HttpRequestHeadersTest.cs b/src/libraries/System.Net.Http/tests/UnitTests/Headers/HttpRequestHeadersTest.cs
index b5df4722a16205..4ce88a86089b84 100644
--- a/src/libraries/System.Net.Http/tests/UnitTests/Headers/HttpRequestHeadersTest.cs
+++ b/src/libraries/System.Net.Http/tests/UnitTests/Headers/HttpRequestHeadersTest.cs
@@ -151,10 +151,10 @@ public void AcceptCharset_AddMultipleValuesAndGetValueString_AllValuesAddedUsing
             headers.Add("Accept-Charset", "utf-8");
             headers.AcceptCharset.Add(new StringWithQualityHeaderValue("iso-8859-5", 0.5));
 
-            foreach (var header in headers.GetHeaderStrings())
+            foreach (var header in headers.NonValidated)
             {
                 Assert.Equal("Accept-Charset", header.Key);
-                Assert.Equal("utf-8, iso-8859-5; q=0.5, invalid value", header.Value);
+                Assert.Equal("utf-8, iso-8859-5; q=0.5, invalid value", header.Value.ToString());
             }
         }
 
@@ -656,10 +656,10 @@ public void UserAgent_AddMultipleValuesAndGetValueString_AllValuesAddedUsingTheC
             headers.Add("User-Agent", "custom2/1.1");
             headers.UserAgent.Add(new ProductInfoHeaderValue("(comment)"));
 
-            foreach (var header in headers.GetHeaderStrings())
+            foreach (var header in headers.NonValidated)
             {
                 Assert.Equal("User-Agent", header.Key);
-                Assert.Equal("custom2/1.1 (comment) custom\u4F1A", header.Value);
+                Assert.Equal("custom2/1.1 (comment) custom\u4F1A", header.Value.ToString());
             }
         }
 
diff --git a/src/libraries/System.Net.Http/tests/UnitTests/HttpEnvironmentProxyTest.cs b/src/libraries/System.Net.Http/tests/UnitTests/HttpEnvironmentProxyTest.cs
index d6c3d12237c860..8c0669f6e62baa 100644
--- a/src/libraries/System.Net.Http/tests/UnitTests/HttpEnvironmentProxyTest.cs
+++ b/src/libraries/System.Net.Http/tests/UnitTests/HttpEnvironmentProxyTest.cs
@@ -10,7 +10,6 @@
 
 namespace System.Net.Http.Tests
 {
-    [ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
     public class HttpEnvironmentProxyTest
     {
         private readonly ITestOutputHelper _output;
diff --git a/src/libraries/System.Net.Http/tests/UnitTests/System.Net.Http.Unit.Tests.csproj b/src/libraries/System.Net.Http/tests/UnitTests/System.Net.Http.Unit.Tests.csproj
index 3b789055900514..186f1cbd888081 100644
--- a/src/libraries/System.Net.Http/tests/UnitTests/System.Net.Http.Unit.Tests.csproj
+++ b/src/libraries/System.Net.Http/tests/UnitTests/System.Net.Http.Unit.Tests.csproj
@@ -106,6 +106,8 @@
              Link="ProductionCode\System\Net\Http\Headers\GenericHeaderParser.cs" />
     <Compile Include="..\..\src\System\Net\Http\Headers\HeaderDescriptor.cs"
              Link="ProductionCode\System\Net\Http\Headers\HeaderDescriptor.cs" />
+    <Compile Include="..\..\src\System\Net\Http\Headers\HeaderStringValues.cs"
+             Link="ProductionCode\System\Net\Http\Headers\HeaderStringValues.cs" />
     <Compile Include="..\..\src\System\Net\Http\Headers\HeaderUtilities.cs"
              Link="ProductionCode\System\Net\Http\Headers\HeaderUtilities.cs" />
     <Compile Include="..\..\src\System\Net\Http\Headers\HttpContentHeaders.cs"
@@ -116,6 +118,8 @@
              Link="ProductionCode\System\Net\Http\Headers\HttpHeaderParser.cs" />
     <Compile Include="..\..\src\System\Net\Http\Headers\HttpHeaders.cs"
              Link="ProductionCode\System\Net\Http\Headers\HttpHeaders.cs" />
+    <Compile Include="..\..\src\System\Net\Http\Headers\HttpHeadersNonValidated.cs"
+             Link="ProductionCode\System\Net\Http\Headers\HttpHeadersNonValidated.cs" />
     <Compile Include="..\..\src\System\Net\Http\Headers\HttpHeaderType.cs"
              Link="ProductionCode\System\Net\Http\Headers\HttpHeaderType.cs" />
     <Compile Include="..\..\src\System\Net\Http\Headers\HttpHeaderValueCollection.cs"
diff --git a/src/libraries/System.Net.HttpListener/src/System/Net/HttpListenerRequestUriBuilder.cs b/src/libraries/System.Net.HttpListener/src/System/Net/HttpListenerRequestUriBuilder.cs
index 18c6106b27cde5..61f05ac248e936 100644
--- a/src/libraries/System.Net.HttpListener/src/System/Net/HttpListenerRequestUriBuilder.cs
+++ b/src/libraries/System.Net.HttpListener/src/System/Net/HttpListenerRequestUriBuilder.cs
@@ -242,7 +242,7 @@ private bool AppendUnicodeCodePointValuePercentEncoded(string codePoint)
             // http.sys only supports %uXXXX (4 hex-digits), even though unicode code points could have up to
             // 6 hex digits. Therefore we parse always 4 characters after %u and convert them to an int.
             int codePointValue;
-            if (!int.TryParse(codePoint, NumberStyles.HexNumber, null, out codePointValue))
+            if (!int.TryParse(codePoint, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out codePointValue))
             {
                 if (NetEventSource.Log.IsEnabled())
                     NetEventSource.Error(this, SR.Format(SR.net_log_listener_cant_convert_percent_value, codePoint));
@@ -274,7 +274,7 @@ private bool AppendUnicodeCodePointValuePercentEncoded(string codePoint)
         private bool AddPercentEncodedOctetToRawOctetsList(Encoding encoding, string escapedCharacter)
         {
             byte encodedValue;
-            if (!byte.TryParse(escapedCharacter, NumberStyles.HexNumber, null, out encodedValue))
+            if (!byte.TryParse(escapedCharacter, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out encodedValue))
             {
                 if (NetEventSource.Log.IsEnabled()) NetEventSource.Error(this, SR.Format(SR.net_log_listener_cant_convert_percent_value, escapedCharacter));
                 return false;
diff --git a/src/libraries/System.Net.HttpListener/src/System/Net/Managed/ChunkStream.cs b/src/libraries/System.Net.HttpListener/src/System/Net/Managed/ChunkStream.cs
index 97efc781a7841a..b81824bc4c0a37 100644
--- a/src/libraries/System.Net.HttpListener/src/System/Net/Managed/ChunkStream.cs
+++ b/src/libraries/System.Net.HttpListener/src/System/Net/Managed/ChunkStream.cs
@@ -274,7 +274,7 @@ private State GetChunkSize(byte[] buffer, ref int offset, int size)
                 {
                     if (_saved.Length > 0)
                     {
-                        _chunkSize = int.Parse(RemoveChunkExtension(_saved.ToString()), NumberStyles.HexNumber);
+                        _chunkSize = int.Parse(RemoveChunkExtension(_saved.ToString()), NumberStyles.HexNumber, CultureInfo.InvariantCulture);
                     }
                 }
                 catch (Exception)
@@ -288,7 +288,7 @@ private State GetChunkSize(byte[] buffer, ref int offset, int size)
             _chunkRead = 0;
             try
             {
-                _chunkSize = int.Parse(RemoveChunkExtension(_saved.ToString()), NumberStyles.HexNumber);
+                _chunkSize = int.Parse(RemoveChunkExtension(_saved.ToString()), NumberStyles.HexNumber, CultureInfo.InvariantCulture);
             }
             catch (Exception)
             {
diff --git a/src/libraries/System.Net.NetworkInformation/tests/FunctionalTests/FileUtil.cs b/src/libraries/System.Net.NetworkInformation/tests/FunctionalTests/FileUtil.cs
index 5fbc858538dcc2..b2c4e25a9a7d8b 100644
--- a/src/libraries/System.Net.NetworkInformation/tests/FunctionalTests/FileUtil.cs
+++ b/src/libraries/System.Net.NetworkInformation/tests/FunctionalTests/FileUtil.cs
@@ -14,22 +14,8 @@ internal static class FileUtil
         public static void NormalizeLineEndings(string source, string normalizedDest)
         {
             string contents = File.ReadAllText(source);
-            if (Environment.NewLine == "\r\n")
-            {
-                if (!contents.Contains(Environment.NewLine))
-                {
-                    contents = contents.Replace("\n", "\r\n");
-                }
-            }
-            else if (Environment.NewLine == "\n")
-            {
-                if (contents.Contains("\r\n"))
-                {
-                    contents = contents.Replace("\r\n", "\n");
-                }
-            }
-
-            File.WriteAllText(normalizedDest, contents);
+            string normalizedContents = contents.ReplaceLineEndings();
+            File.WriteAllText(normalizedDest, normalizedContents);
         }
     }
 }
diff --git a/src/libraries/System.Net.Primitives/tests/UnitTests/CookieContainerTest.cs b/src/libraries/System.Net.Primitives/tests/UnitTests/CookieContainerTest.cs
index 442c3495c94a31..b3673331aebcd6 100644
--- a/src/libraries/System.Net.Primitives/tests/UnitTests/CookieContainerTest.cs
+++ b/src/libraries/System.Net.Primitives/tests/UnitTests/CookieContainerTest.cs
@@ -125,11 +125,11 @@ public static IEnumerable<object[]> SetCookiesData()
             yield return new object[]
             {
                 u,
-                "name98=value98; path=/; domain=.uri.com; expires=Wed, 09 Jun 2021 10:18:14 GMT, name99=value99",
+                "name98=value98; path=/; domain=.uri.com; expires=Wed, 09 Jun 2050 10:18:14 GMT, name99=value99",
                 new Cookie[]
                 {
                     new Cookie("name99", "value99"),
-                    new Cookie("name98", "value98", "/", ".uri.com") { Expires = new DateTime(2021, 6, 9, 10, 18, 14) }
+                    new Cookie("name98", "value98", "/", ".uri.com") { Expires = new DateTime(2050, 6, 9, 10, 18, 14) }
                 }
             }; // Version0
 
@@ -169,11 +169,11 @@ public static IEnumerable<object[]> SetCookiesData()
             yield return new object[]
             {
                 uSecure,
-                "name98=value98; name98=value98; comment=comment; comment=comment2; commentURL=http://url.com; commentURL=commentURL2; discard; discard; domain=.uri.com; domain=domain2; max-age=400; max-age=400; path=/; path=path; port=\"80, 90, 443\"; port=port2; path=path; expires=Wed, 09 Jun 2021 10:18:14 GMT; expires=expires2; secure; secure; httponly; httponly; Version=100; Version=100, name99=value99",
+                "name98=value98; name98=value98; comment=comment; comment=comment2; commentURL=http://url.com; commentURL=commentURL2; discard; discard; domain=.uri.com; domain=domain2; max-age=400; max-age=400; path=/; path=path; port=\"80, 90, 443\"; port=port2; path=path; expires=Wed, 09 Jun 2050 10:18:14 GMT; expires=expires2; secure; secure; httponly; httponly; Version=100; Version=100, name99=value99",
                 new Cookie[]
                 {
                     new Cookie("name99", "value99"),
-                    new Cookie("name98", "value98", "/", ".uri.com") { Port = "\"80, 90, 443\"", Version = 100, Secure = true, HttpOnly = true, Discard = true, Expires = new DateTime(2021, 6, 9, 10, 18, 14), Comment = "comment", CommentUri = new Uri("http://url.com") }
+                    new Cookie("name98", "value98", "/", ".uri.com") { Port = "\"80, 90, 443\"", Version = 100, Secure = true, HttpOnly = true, Discard = true, Expires = new DateTime(2050, 6, 9, 10, 18, 14), Comment = "comment", CommentUri = new Uri("http://url.com") }
                 }
             }; // Double entries
 
diff --git a/src/libraries/System.Net.Quic/ref/System.Net.Quic.cs b/src/libraries/System.Net.Quic/ref/System.Net.Quic.cs
index 4f4abcf7e5236e..be6df9a7c479b4 100644
--- a/src/libraries/System.Net.Quic/ref/System.Net.Quic.cs
+++ b/src/libraries/System.Net.Quic/ref/System.Net.Quic.cs
@@ -27,10 +27,12 @@ public QuicConnection(System.Net.Quic.QuicClientConnectionOptions options) { }
         public System.Threading.Tasks.ValueTask CloseAsync(long errorCode, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
         public System.Threading.Tasks.ValueTask ConnectAsync(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
         public void Dispose() { }
-        public long GetRemoteAvailableBidirectionalStreamCount() { throw null; }
-        public long GetRemoteAvailableUnidirectionalStreamCount() { throw null; }
+        public int GetRemoteAvailableBidirectionalStreamCount() { throw null; }
+        public int GetRemoteAvailableUnidirectionalStreamCount() { throw null; }
         public System.Net.Quic.QuicStream OpenBidirectionalStream() { throw null; }
         public System.Net.Quic.QuicStream OpenUnidirectionalStream() { throw null; }
+        public System.Threading.Tasks.ValueTask WaitForAvailableBidirectionalStreamsAsync(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
+        public System.Threading.Tasks.ValueTask WaitForAvailableUnidirectionalStreamsAsync(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
     }
     public partial class QuicConnectionAbortedException : System.Net.Quic.QuicException
     {
@@ -73,8 +75,8 @@ public partial class QuicOptions
     {
         public QuicOptions() { }
         public System.TimeSpan IdleTimeout { get { throw null; } set { } }
-        public long MaxBidirectionalStreams { get { throw null; } set { } }
-        public long MaxUnidirectionalStreams { get { throw null; } set { } }
+        public int MaxBidirectionalStreams { get { throw null; } set { } }
+        public int MaxUnidirectionalStreams { get { throw null; } set { } }
     }
     public sealed partial class QuicStream : System.IO.Stream
     {
@@ -101,8 +103,8 @@ public override void Flush() { }
         public override long Seek(long offset, System.IO.SeekOrigin origin) { throw null; }
         public override void SetLength(long value) { }
         public void Shutdown() { }
-        public System.Threading.Tasks.ValueTask ShutdownWriteCompleted(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
         public System.Threading.Tasks.ValueTask ShutdownCompleted(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
+        public System.Threading.Tasks.ValueTask ShutdownWriteCompleted(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
         public override void Write(byte[] buffer, int offset, int count) { }
         public override void Write(System.ReadOnlySpan<byte> buffer) { }
         public System.Threading.Tasks.ValueTask WriteAsync(System.Buffers.ReadOnlySequence<byte> buffers, bool endStream, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
diff --git a/src/libraries/System.Net.Quic/src/System.Net.Quic.csproj b/src/libraries/System.Net.Quic/src/System.Net.Quic.csproj
index e1f29c77f0f322..eb0cac9ddec899 100644
--- a/src/libraries/System.Net.Quic/src/System.Net.Quic.csproj
+++ b/src/libraries/System.Net.Quic/src/System.Net.Quic.csproj
@@ -15,7 +15,16 @@
     <Compile Include="System\Net\Quic\Implementations\Mock\*.cs" />
     <Compile Include="System\Net\Quic\Implementations\MsQuic\*.cs" />
     <Compile Include="System\Net\Quic\Implementations\MsQuic\Internal\*.cs" />
-    <Compile Include="System\Net\Quic\Implementations\MsQuic\Interop\*.cs" />
+    <Compile Include="System\Net\Quic\Implementations\MsQuic\Interop\MsQuicAlpnHelper.cs" />
+    <Compile Include="System\Net\Quic\Implementations\MsQuic\Interop\MsQuicEnums.cs" />
+    <Compile Include="System\Net\Quic\Implementations\MsQuic\Interop\MsQuicNativeMethods.cs" />
+    <Compile Include="System\Net\Quic\Implementations\MsQuic\Interop\MsQuicStatusCodes.cs" />
+    <Compile Include="System\Net\Quic\Implementations\MsQuic\Interop\MsQuicStatusHelper.cs" />
+    <Compile Include="System\Net\Quic\Implementations\MsQuic\Interop\SafeMsQuicConfigurationHandle.cs" />
+    <Compile Include="System\Net\Quic\Implementations\MsQuic\Interop\SafeMsQuicConnectionHandle.cs" />
+    <Compile Include="System\Net\Quic\Implementations\MsQuic\Interop\SafeMsQuicListenerHandle.cs" />
+    <Compile Include="System\Net\Quic\Implementations\MsQuic\Interop\SafeMsQuicRegistrationHandle.cs" />
+    <Compile Include="System\Net\Quic\Implementations\MsQuic\Interop\SafeMsQuicStreamHandle.cs" />
   </ItemGroup>
   <!-- System.Net common -->
   <ItemGroup Condition="'$(TargetsAnyOS)' != 'true'">
@@ -28,18 +37,23 @@
   <!-- Windows specific files -->
   <ItemGroup Condition=" '$(TargetsWindows)' == 'true'">
     <Compile Include="$(CommonPath)Interop\Windows\Interop.Libraries.cs" Link="Common\Interop\Windows\Interop.Libraries.cs" />
+    <Compile Include="System\Net\Quic\Implementations\MsQuic\Interop\MsQuicStatusCodes.Windows.cs" />
   </ItemGroup>
   <!-- Linux specific files -->
   <ItemGroup Condition="'$(TargetsLinux)' == 'true'">
     <Compile Include="$(CommonPath)Interop\Linux\Interop.Libraries.cs" Link="Common\Interop\Linux\Interop.Libraries.cs" />
+    <Compile Include="System\Net\Quic\Implementations\MsQuic\Interop\MsQuicStatusCodes.Linux.cs" />
   </ItemGroup>
   <!-- FreeBSD specific files -->
   <ItemGroup Condition="'$(TargetsFreeBSD)' == 'true' ">
     <Compile Include="$(CommonPath)Interop\FreeBSD\Interop.Libraries.cs" Link="Common\Interop\FreeBSD\Interop.Libraries.cs" />
+    <!-- Assume similarity with OSX for now -->
+    <Compile Include="System\Net\Quic\Implementations\MsQuic\Interop\MsQuicStatusCodes.OSX.cs" />
   </ItemGroup>
   <!-- OSX specific files -->
   <ItemGroup Condition=" '$(TargetsOSX)' == 'true'">
     <Compile Include="$(CommonPath)Interop\OSX\Interop.Libraries.cs" Link="Common\Interop\OSX\Interop.Libraries.cs" />
+    <Compile Include="System\Net\Quic\Implementations\MsQuic\Interop\MsQuicStatusCodes.OSX.cs" />
   </ItemGroup>
   <!-- Project references -->
   <ItemGroup>
diff --git a/src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/Mock/MockConnection.cs b/src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/Mock/MockConnection.cs
index 9a24bc1436c2fa..3c1f232ed7e7e3 100644
--- a/src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/Mock/MockConnection.cs
+++ b/src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/Mock/MockConnection.cs
@@ -4,6 +4,7 @@
 using System.Diagnostics;
 using System.Net;
 using System.Net.Security;
+using System.Runtime.ExceptionServices;
 using System.Threading;
 using System.Threading.Channels;
 using System.Threading.Tasks;
@@ -20,11 +21,16 @@ internal sealed class MockConnection : QuicConnectionProvider
         private object _syncObject = new object();
         private long _nextOutboundBidirectionalStream;
         private long _nextOutboundUnidirectionalStream;
+        private readonly int _maxUnidirectionalStreams;
+        private readonly int _maxBidirectionalStreams;
 
         private ConnectionState? _state;
 
+        internal PeerStreamLimit? LocalStreamLimit => _isClient ? _state?._clientStreamLimit : _state?._serverStreamLimit;
+        internal PeerStreamLimit? RemoteStreamLimit => _isClient ? _state?._serverStreamLimit : _state?._clientStreamLimit;
+
         // Constructor for outbound connections
-        internal MockConnection(EndPoint? remoteEndPoint, SslClientAuthenticationOptions? sslClientAuthenticationOptions, IPEndPoint? localEndPoint = null)
+        internal MockConnection(EndPoint? remoteEndPoint, SslClientAuthenticationOptions? sslClientAuthenticationOptions, IPEndPoint? localEndPoint = null, int maxUnidirectionalStreams = 100, int maxBidirectionalStreams = 100)
         {
             if (remoteEndPoint is null)
             {
@@ -43,6 +49,8 @@ internal MockConnection(EndPoint? remoteEndPoint, SslClientAuthenticationOptions
             _sslClientAuthenticationOptions = sslClientAuthenticationOptions;
             _nextOutboundBidirectionalStream = 0;
             _nextOutboundUnidirectionalStream = 2;
+            _maxUnidirectionalStreams = maxUnidirectionalStreams;
+            _maxBidirectionalStreams = maxBidirectionalStreams;
 
             // _state is not initialized until ConnectAsync
         }
@@ -129,7 +137,10 @@ internal override ValueTask ConnectAsync(CancellationToken cancellationToken = d
             }
 
             // TODO: deal with protocol negotiation
-            _state = new ConnectionState(_sslClientAuthenticationOptions!.ApplicationProtocols![0]);
+            _state = new ConnectionState(_sslClientAuthenticationOptions!.ApplicationProtocols![0])
+            {
+                _clientStreamLimit = new PeerStreamLimit(_maxUnidirectionalStreams, _maxBidirectionalStreams)
+            };
             if (!listener.TryConnect(_state))
             {
                 throw new QuicException("Connection refused");
@@ -138,8 +149,41 @@ internal override ValueTask ConnectAsync(CancellationToken cancellationToken = d
             return ValueTask.CompletedTask;
         }
 
+        internal override ValueTask WaitForAvailableUnidirectionalStreamsAsync(CancellationToken cancellationToken = default)
+        {
+            PeerStreamLimit? streamLimit = RemoteStreamLimit;
+            if (streamLimit is null)
+            {
+                throw new InvalidOperationException("Not connected");
+            }
+
+            return streamLimit.Unidirectional.WaitForAvailableStreams(cancellationToken);
+        }
+
+        internal override ValueTask WaitForAvailableBidirectionalStreamsAsync(CancellationToken cancellationToken = default)
+        {
+            PeerStreamLimit? streamLimit = RemoteStreamLimit;
+            if (streamLimit is null)
+            {
+                throw new InvalidOperationException("Not connected");
+            }
+
+            return streamLimit.Bidirectional.WaitForAvailableStreams(cancellationToken);
+        }
+
         internal override QuicStreamProvider OpenUnidirectionalStream()
         {
+            PeerStreamLimit? streamLimit = RemoteStreamLimit;
+            if (streamLimit is null)
+            {
+                throw new InvalidOperationException("Not connected");
+            }
+
+            if (!streamLimit.Unidirectional.TryIncrement())
+            {
+                throw new QuicException("No available unidirectional stream");
+            }
+
             long streamId;
             lock (_syncObject)
             {
@@ -152,6 +196,17 @@ internal override QuicStreamProvider OpenUnidirectionalStream()
 
         internal override QuicStreamProvider OpenBidirectionalStream()
         {
+            PeerStreamLimit? streamLimit = RemoteStreamLimit;
+            if (streamLimit is null)
+            {
+                throw new InvalidOperationException("Not connected");
+            }
+
+            if (!streamLimit.Bidirectional.TryIncrement())
+            {
+                throw new QuicException("No available bidirectional stream");
+            }
+
             long streamId;
             lock (_syncObject)
             {
@@ -174,12 +229,30 @@ internal MockStream OpenStream(long streamId, bool bidirectional)
             Channel<MockStream.StreamState> streamChannel = _isClient ? state._clientInitiatedStreamChannel : state._serverInitiatedStreamChannel;
             streamChannel.Writer.TryWrite(streamState);
 
-            return new MockStream(streamState, true);
+            return new MockStream(this, streamState, true);
         }
 
-        internal override long GetRemoteAvailableUnidirectionalStreamCount() => long.MaxValue;
+        internal override int GetRemoteAvailableUnidirectionalStreamCount()
+        {
+            PeerStreamLimit? streamLimit = RemoteStreamLimit;
+            if (streamLimit is null)
+            {
+                throw new InvalidOperationException("Not connected");
+            }
+
+            return streamLimit.Unidirectional.AvailableCount;
+        }
+
+        internal override int GetRemoteAvailableBidirectionalStreamCount()
+        {
+            PeerStreamLimit? streamLimit = RemoteStreamLimit;
+            if (streamLimit is null)
+            {
+                throw new InvalidOperationException("Not connected");
+            }
 
-        internal override long GetRemoteAvailableBidirectionalStreamCount() => long.MaxValue;
+            return streamLimit.Bidirectional.AvailableCount;
+        }
 
         internal override async ValueTask<QuicStreamProvider> AcceptStreamAsync(CancellationToken cancellationToken = default)
         {
@@ -196,7 +269,7 @@ internal override async ValueTask<QuicStreamProvider> AcceptStreamAsync(Cancella
             try
             {
                 MockStream.StreamState streamState = await streamChannel.Reader.ReadAsync(cancellationToken).ConfigureAwait(false);
-                return new MockStream(streamState, false);
+                return new MockStream(this, streamState, false);
             }
             catch (ChannelClosedException)
             {
@@ -251,6 +324,14 @@ private void Dispose(bool disposing)
                         Channel<MockStream.StreamState> streamChannel = _isClient ? state._clientInitiatedStreamChannel : state._serverInitiatedStreamChannel;
                         streamChannel.Writer.Complete();
                     }
+
+
+                    PeerStreamLimit? streamLimit = LocalStreamLimit;
+                    if (streamLimit is not null)
+                    {
+                        streamLimit.Unidirectional.CloseWaiters();
+                        streamLimit.Bidirectional.CloseWaiters();
+                    }
                 }
 
                 // TODO: free unmanaged resources (unmanaged objects) and override a finalizer below.
@@ -271,11 +352,93 @@ public override void Dispose()
             GC.SuppressFinalize(this);
         }
 
+        internal sealed class StreamLimit
+        {
+            public readonly int MaxCount;
+
+            private int _actualCount;
+            // Since this is mock, we don't need to be conservative with the allocations.
+            // We keep the TCSes allocated all the time for the simplicity of the code.
+            private TaskCompletionSource _availableTcs = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+            private readonly object _syncRoot = new object();
+
+            public StreamLimit(int maxCount)
+            {
+                MaxCount = maxCount;
+            }
+
+            public int AvailableCount => MaxCount - _actualCount;
+
+            public void Decrement()
+            {
+                TaskCompletionSource? availableTcs = null;
+                lock (_syncRoot)
+                {
+                    --_actualCount;
+                    if (!_availableTcs.Task.IsCompleted)
+                    {
+                        availableTcs = _availableTcs;
+                        _availableTcs = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+                    }
+                }
+                if (availableTcs is not null)
+                {
+                    availableTcs.SetResult();
+                }
+            }
+
+            public bool TryIncrement()
+            {
+                lock (_syncRoot)
+                {
+                    if (_actualCount < MaxCount)
+                    {
+                        ++_actualCount;
+                        return true;
+                    }
+                    return false;
+                }
+            }
+
+            public ValueTask WaitForAvailableStreams(CancellationToken cancellationToken)
+            {
+                TaskCompletionSource availableTcs;
+                lock (_syncRoot)
+                {
+                    if (_actualCount > 0)
+                    {
+                        return default;
+                    }
+                    availableTcs = _availableTcs;
+                }
+                return new ValueTask(availableTcs.Task.WaitAsync(cancellationToken));
+            }
+
+            public void CloseWaiters()
+                => _availableTcs.SetException(ExceptionDispatchInfo.SetCurrentStackTrace(new QuicOperationAbortedException()));
+        }
+
+        internal class PeerStreamLimit
+        {
+            public readonly StreamLimit Unidirectional;
+            public readonly StreamLimit Bidirectional;
+
+            public PeerStreamLimit(int maxUnidirectional, int maxBidirectional)
+            {
+                Unidirectional = new StreamLimit(maxUnidirectional);
+                Bidirectional = new StreamLimit(maxBidirectional);
+            }
+        }
+
         internal sealed class ConnectionState
         {
             public readonly SslApplicationProtocol _applicationProtocol;
             public Channel<MockStream.StreamState> _clientInitiatedStreamChannel;
             public Channel<MockStream.StreamState> _serverInitiatedStreamChannel;
+
+            public PeerStreamLimit? _clientStreamLimit;
+            public PeerStreamLimit? _serverStreamLimit;
+
             public long _clientErrorCode;
             public long _serverErrorCode;
             public bool _closed;
diff --git a/src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/Mock/MockImplementationProvider.cs b/src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/Mock/MockImplementationProvider.cs
index 03b53613f15140..a46b1691bed6e8 100644
--- a/src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/Mock/MockImplementationProvider.cs
+++ b/src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/Mock/MockImplementationProvider.cs
@@ -16,7 +16,11 @@ internal override QuicListenerProvider CreateListener(QuicListenerOptions option
 
         internal override QuicConnectionProvider CreateConnection(QuicClientConnectionOptions options)
         {
-            return new MockConnection(options.RemoteEndPoint, options.ClientAuthenticationOptions, options.LocalEndPoint);
+            return new MockConnection(options.RemoteEndPoint,
+                                      options.ClientAuthenticationOptions,
+                                      options.LocalEndPoint,
+                                      options.MaxUnidirectionalStreams,
+                                      options.MaxBidirectionalStreams);
         }
     }
 }
diff --git a/src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/Mock/MockListener.cs b/src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/Mock/MockListener.cs
index 826746ad69700f..48ebf8a06035d8 100644
--- a/src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/Mock/MockListener.cs
+++ b/src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/Mock/MockListener.cs
@@ -69,6 +69,7 @@ internal override async ValueTask<QuicConnectionProvider> AcceptConnectionAsync(
         // Returns false if backlog queue is full.
         internal bool TryConnect(MockConnection.ConnectionState state)
         {
+            state._serverStreamLimit = new MockConnection.PeerStreamLimit(_options.MaxUnidirectionalStreams, _options.MaxBidirectionalStreams);
             return _listenQueue.Writer.TryWrite(state);
         }
 
diff --git a/src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/Mock/MockStream.cs b/src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/Mock/MockStream.cs
index 68964fc30688d6..bd814f690d952c 100644
--- a/src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/Mock/MockStream.cs
+++ b/src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/Mock/MockStream.cs
@@ -14,12 +14,14 @@ internal sealed class MockStream : QuicStreamProvider
     {
         private bool _disposed;
         private readonly bool _isInitiator;
+        private readonly MockConnection _connection;
 
         private readonly StreamState _streamState;
         private bool _writesCanceled;
 
-        internal MockStream(StreamState streamState, bool isInitiator)
+        internal MockStream(MockConnection connection, StreamState streamState, bool isInitiator)
         {
+            _connection = connection;
             _streamState = streamState;
             _isInitiator = isInitiator;
         }
@@ -186,7 +188,6 @@ internal override void AbortWrite(long errorCode)
             WriteStreamBuffer?.EndWrite();
         }
 
-
         internal override ValueTask ShutdownWriteCompleted(CancellationToken cancellationToken = default)
         {
             CheckDisposed();
@@ -208,6 +209,15 @@ internal override void Shutdown()
 
             // This seems to mean shutdown send, in particular, not both.
             WriteStreamBuffer?.EndWrite();
+
+            if (_streamState._inboundStreamBuffer is null) // unidirectional stream
+            {
+                _connection.LocalStreamLimit!.Unidirectional.Decrement();
+            }
+            else
+            {
+                _connection.LocalStreamLimit!.Bidirectional.Decrement();
+            }
         }
 
         private void CheckDisposed()
diff --git a/src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/MsQuic/Internal/MsQuicAddressHelpers.cs b/src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/MsQuic/Internal/MsQuicAddressHelpers.cs
index 8698b79028a7ee..5052c5f0200ca4 100644
--- a/src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/MsQuic/Internal/MsQuicAddressHelpers.cs
+++ b/src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/MsQuic/Internal/MsQuicAddressHelpers.cs
@@ -24,7 +24,6 @@ internal static unsafe IPEndPoint INetToIPEndPoint(ref SOCKADDR_INET inetAddress
         internal static unsafe SOCKADDR_INET IPEndPointToINet(IPEndPoint endpoint)
         {
             SOCKADDR_INET socketAddress = default;
-            byte[] buffer = endpoint.Address.GetAddressBytes();
             if (endpoint.Address != IPAddress.Any && endpoint.Address != IPAddress.IPv6Any)
             {
                 switch (endpoint.Address.AddressFamily)
diff --git a/src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/MsQuic/Internal/MsQuicApi.cs b/src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/MsQuic/Internal/MsQuicApi.cs
index 5914cf200c65b1..4483920196adad 100644
--- a/src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/MsQuic/Internal/MsQuicApi.cs
+++ b/src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/MsQuic/Internal/MsQuicApi.cs
@@ -119,18 +119,19 @@ private MsQuicApi(NativeApi* vtable)
 
         internal static bool IsQuicSupported { get; }
 
+        private const int MsQuicVersion = 1;
+
         static MsQuicApi()
         {
-            // TODO: Consider updating all of these delegates to instead use function pointers.
             if (NativeLibrary.TryLoad(Interop.Libraries.MsQuic, typeof(MsQuicApi).Assembly, DllImportSearchPath.AssemblyDirectory, out IntPtr msQuicHandle))
             {
                 try
                 {
-                    if (NativeLibrary.TryGetExport(msQuicHandle, "MsQuicOpen", out IntPtr msQuicOpenAddress))
+                    if (NativeLibrary.TryGetExport(msQuicHandle, "MsQuicOpenVersion", out IntPtr msQuicOpenVersionAddress))
                     {
-                        MsQuicOpenDelegate msQuicOpen =
-                            Marshal.GetDelegateForFunctionPointer<MsQuicOpenDelegate>(msQuicOpenAddress);
-                        uint status = msQuicOpen(out NativeApi* vtable);
+                        delegate* unmanaged[Cdecl]<uint, out NativeApi*, uint> msQuicOpenVersion =
+                            (delegate* unmanaged[Cdecl]<uint, out NativeApi*, uint>)msQuicOpenVersionAddress;
+                        uint status = msQuicOpenVersion(MsQuicVersion, out NativeApi* vtable);
                         if (MsQuicStatusHelper.SuccessfulStatusCode(status))
                         {
                             IsQuicSupported = true;
@@ -148,6 +149,7 @@ static MsQuicApi()
             }
         }
 
+        // TODO: Consider updating all of these delegates to instead use function pointers.
         internal RegistrationOpenDelegate RegistrationOpenDelegate { get; }
         internal RegistrationCloseDelegate RegistrationCloseDelegate { get; }
 
diff --git a/src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/MsQuic/Interop/MsQuicNativeMethods.cs b/src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/MsQuic/Interop/MsQuicNativeMethods.cs
index 3700edbb303952..325ee8170aedc4 100644
--- a/src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/MsQuic/Interop/MsQuicNativeMethods.cs
+++ b/src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/MsQuic/Interop/MsQuicNativeMethods.cs
@@ -51,10 +51,6 @@ internal struct NativeApi
             internal IntPtr DatagramSend;
         }
 
-        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
-        internal delegate uint MsQuicOpenDelegate(
-            out NativeApi* registration);
-
         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         internal delegate uint SetContextDelegate(
             SafeHandle handle,
diff --git a/src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/MsQuic/Interop/MsQuicStatusCodes.Linux.cs b/src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/MsQuic/Interop/MsQuicStatusCodes.Linux.cs
new file mode 100644
index 00000000000000..d99df7976d7951
--- /dev/null
+++ b/src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/MsQuic/Interop/MsQuicStatusCodes.Linux.cs
@@ -0,0 +1,32 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace System.Net.Quic.Implementations.MsQuic.Internal
+{
+    internal static partial class MsQuicStatusCodes
+    {
+        internal const uint Success = 0;
+        internal const uint Pending = unchecked((uint)-2);
+        internal const uint Continue = unchecked((uint)-1);
+        internal const uint OutOfMemory = 12;           // ENOMEM
+        internal const uint InvalidParameter = 22;      // EINVAL
+        internal const uint InvalidState = 1;           // EPERM
+        internal const uint NotSupported = 95;          // EOPNOTSUPP
+        internal const uint NotFound = 2;               // ENOENT
+        internal const uint BufferTooSmall = 75;        // EOVERFLOW
+        internal const uint HandshakeFailure = 103;     // ECONNABORTED
+        internal const uint Aborted = 125;              // ECANCELED
+        internal const uint AddressInUse = 98;          // EADDRINUSE
+        internal const uint ConnectionTimeout = 110;    // ETIMEDOUT
+        internal const uint ConnectionIdle = 62;        // ETIME
+        internal const uint HostUnreachable = 113;      // EHOSTUNREACH
+        internal const uint InternalError = 5;          // EIO
+        internal const uint ConnectionRefused = 111;    // ECONNREFUSED
+        internal const uint ProtocolError = 71;         // EPROTO
+        internal const uint VerNegError = 93;           // EPROTONOSUPPORT
+        internal const uint TlsError = 126;             // ENOKEY
+        internal const uint UserCanceled = 130;         // EOWNERDEAD
+        internal const uint AlpnNegotiationFailure = 92;// ENOPROTOOPT
+        internal const uint StreamLimit = 86;           // ESTRPIPE
+    }
+}
diff --git a/src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/MsQuic/Interop/MsQuicStatusCodes.OSX.cs b/src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/MsQuic/Interop/MsQuicStatusCodes.OSX.cs
new file mode 100644
index 00000000000000..03fc254f24781b
--- /dev/null
+++ b/src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/MsQuic/Interop/MsQuicStatusCodes.OSX.cs
@@ -0,0 +1,32 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace System.Net.Quic.Implementations.MsQuic.Internal
+{
+    internal static partial class MsQuicStatusCodes
+    {
+        internal const uint Success = 0;
+        internal const uint Pending = unchecked((uint)-2);
+        internal const uint Continue = unchecked((uint)-1);
+        internal const uint OutOfMemory = 12;           // ENOMEM
+        internal const uint InvalidParameter = 22;      // EINVAL
+        internal const uint InvalidState = 1;           // EPERM
+        internal const uint NotSupported = 102;         // EOPNOTSUPP
+        internal const uint NotFound = 2;               // ENOENT
+        internal const uint BufferTooSmall = 84;        // EOVERFLOW
+        internal const uint HandshakeFailure = 53;      // ECONNABORTED
+        internal const uint Aborted = 89;               // ECANCELED
+        internal const uint AddressInUse = 48;          // EADDRINUSE
+        internal const uint ConnectionTimeout = 60;     // ETIMEDOUT
+        internal const uint ConnectionIdle = 101;       // ETIME
+        internal const uint HostUnreachable = 65;       // EHOSTUNREACH
+        internal const uint InternalError = 5;          // EIO
+        internal const uint ConnectionRefused = 61;     // ECONNREFUSED
+        internal const uint ProtocolError = 100;        // EPROTO
+        internal const uint VerNegError = 43;           // EPROTONOSUPPORT
+        internal const uint TlsError = 126;             // ENOKEY Linux value
+        internal const uint UserCanceled = 105;         // EOWNERDEAD
+        internal const uint AlpnNegotiationFailure = 42;// ENOPROTOOPT
+        internal const uint StreamLimit = 86;           // ESTRPIPE Linux value
+    }
+}
diff --git a/src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/MsQuic/Interop/MsQuicStatusCodes.Windows.cs b/src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/MsQuic/Interop/MsQuicStatusCodes.Windows.cs
new file mode 100644
index 00000000000000..003aaa84ec6573
--- /dev/null
+++ b/src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/MsQuic/Interop/MsQuicStatusCodes.Windows.cs
@@ -0,0 +1,32 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace System.Net.Quic.Implementations.MsQuic.Internal
+{
+    internal static partial class MsQuicStatusCodes
+    {
+        internal const uint Success = 0;
+        internal const uint Pending = 0x703E5;
+        internal const uint Continue = 0x704DE;
+        internal const uint OutOfMemory = 0x8007000E;
+        internal const uint InvalidParameter = 0x80070057;
+        internal const uint InvalidState = 0x8007139F;
+        internal const uint NotSupported = 0x80004002;
+        internal const uint NotFound = 0x80070490;
+        internal const uint BufferTooSmall = 0x8007007A;
+        internal const uint HandshakeFailure = 0x80410000;
+        internal const uint Aborted = 0x80004004;
+        internal const uint AddressInUse = 0x80072740;
+        internal const uint ConnectionTimeout = 0x80410006;
+        internal const uint ConnectionIdle = 0x80410005;
+        internal const uint HostUnreachable = 0x800704D0;
+        internal const uint InternalError = 0x80410003;
+        internal const uint ConnectionRefused = 0x800704C9;
+        internal const uint ProtocolError = 0x80410004;
+        internal const uint VerNegError = 0x80410001;
+        internal const uint TlsError = 0x80072B18;
+        internal const uint UserCanceled = 0x80410002;
+        internal const uint AlpnNegotiationFailure = 0x80410007;
+        internal const uint StreamLimit = 0x80410008;
+    }
+}
diff --git a/src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/MsQuic/Interop/MsQuicStatusCodes.cs b/src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/MsQuic/Interop/MsQuicStatusCodes.cs
index 50f736d429f7f6..50bc0612ae3c7e 100644
--- a/src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/MsQuic/Interop/MsQuicStatusCodes.cs
+++ b/src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/MsQuic/Interop/MsQuicStatusCodes.cs
@@ -3,133 +3,38 @@
 
 namespace System.Net.Quic.Implementations.MsQuic.Internal
 {
-    internal static class MsQuicStatusCodes
+    internal static partial class MsQuicStatusCodes
     {
-        internal static uint Success => OperatingSystem.IsWindows() ? Windows.Success : Posix.Success;
-        internal static uint Pending => OperatingSystem.IsWindows() ? Windows.Pending : Posix.Pending;
-        internal static uint InternalError => OperatingSystem.IsWindows() ? Windows.InternalError : Posix.InternalError;
-        internal static uint InvalidState => OperatingSystem.IsWindows() ? Windows.InvalidState : Posix.InvalidState;
-        internal static uint HandshakeFailure => OperatingSystem.IsWindows() ? Windows.HandshakeFailure : Posix.HandshakeFailure;
-
         // TODO return better error messages here.
-        public static string GetError(uint status) => OperatingSystem.IsWindows() ? Windows.GetError(status) : Posix.GetError(status);
-
-        private static class Windows
-        {
-            internal const uint Success = 0;
-            internal const uint Pending = 0x703E5;
-            internal const uint Continue = 0x704DE;
-            internal const uint OutOfMemory = 0x8007000E;
-            internal const uint InvalidParameter = 0x80070057;
-            internal const uint InvalidState = 0x8007139F;
-            internal const uint NotSupported = 0x80004002;
-            internal const uint NotFound = 0x80070490;
-            internal const uint BufferTooSmall = 0x8007007A;
-            internal const uint HandshakeFailure = 0x80410000;
-            internal const uint Aborted = 0x80004004;
-            internal const uint AddressInUse = 0x80072740;
-            internal const uint ConnectionTimeout = 0x80410006;
-            internal const uint ConnectionIdle = 0x80410005;
-            internal const uint HostUnreachable = 0x800704D0;
-            internal const uint InternalError = 0x80410003;
-            internal const uint ConnectionRefused = 0x800704C9;
-            internal const uint ProtocolError = 0x80410004;
-            internal const uint VerNegError = 0x80410001;
-            internal const uint TlsError = 0x80072B18;
-            internal const uint UserCanceled = 0x80410002;
-            internal const uint AlpnNegotiationFailure = 0x80410007;
-
-            // TODO return better error messages here.
-            public static string GetError(uint status)
-            {
-                return status switch
-                {
-                    Success => "SUCCESS",
-                    Pending => "PENDING",
-                    Continue => "CONTINUE",
-                    OutOfMemory => "OUT_OF_MEMORY",
-                    InvalidParameter => "INVALID_PARAMETER",
-                    InvalidState => "INVALID_STATE",
-                    NotSupported => "NOT_SUPPORTED",
-                    NotFound => "NOT_FOUND",
-                    BufferTooSmall => "BUFFER_TOO_SMALL",
-                    HandshakeFailure => "HANDSHAKE_FAILURE",
-                    Aborted => "ABORTED",
-                    AddressInUse => "ADDRESS_IN_USE",
-                    ConnectionTimeout => "CONNECTION_TIMEOUT",
-                    ConnectionIdle => "CONNECTION_IDLE",
-                    HostUnreachable => "UNREACHABLE",
-                    InternalError => "INTERNAL_ERROR",
-                    ConnectionRefused => "CONNECTION_REFUSED",
-                    ProtocolError => "PROTOCOL_ERROR",
-                    VerNegError => "VER_NEG_ERROR",
-                    TlsError => "TLS_ERROR",
-                    UserCanceled => "USER_CANCELED",
-                    AlpnNegotiationFailure => "ALPN_NEG_FAILURE",
-                    _ => $"0x{status:X8}"
-                };
-            }
-        }
-
-        private static class Posix
+        public static string GetError(uint status)
         {
-            internal const uint Success = 0;
-            internal const uint Pending = unchecked((uint)-2);
-            internal const uint Continue = unchecked((uint)-1);
-            internal const uint OutOfMemory = 12;
-            internal const uint InvalidParameter = 22;
-            internal const uint InvalidState = 200000002;
-            internal const uint NotSupported = 95;
-            internal const uint NotFound = 2;
-            internal const uint BufferTooSmall = 75;
-            internal const uint HandshakeFailure = 200000009;
-            internal const uint Aborted = 200000008;
-            internal const uint AddressInUse = 98;
-            internal const uint ConnectionTimeout = 110;
-            internal const uint ConnectionIdle = 200000011;
-            internal const uint InternalError = 200000012;
-            internal const uint ConnectionRefused = 200000007;
-            internal const uint ProtocolError = 200000013;
-            internal const uint VerNegError = 200000014;
-            internal const uint EpollError = 200000015;
-            internal const uint DnsResolutionError = 200000016;
-            internal const uint SocketError = 200000017;
-            internal const uint TlsError = 200000018;
-            internal const uint UserCanceled = 200000019;
-            internal const uint AlpnNegotiationFailure = 200000020;
-
-            // TODO return better error messages here.
-            public static string GetError(uint status)
+            return status switch
             {
-                return status switch
-                {
-                    Success => "SUCCESS",
-                    Pending => "PENDING",
-                    Continue => "CONTINUE",
-                    OutOfMemory => "OUT_OF_MEMORY",
-                    InvalidParameter => "INVALID_PARAMETER",
-                    InvalidState => "INVALID_STATE",
-                    NotSupported => "NOT_SUPPORTED",
-                    NotFound => "NOT_FOUND",
-                    BufferTooSmall => "BUFFER_TOO_SMALL",
-                    HandshakeFailure => "HANDSHAKE_FAILURE",
-                    Aborted => "ABORTED",
-                    AddressInUse => "ADDRESS_IN_USE",
-                    ConnectionTimeout => "CONNECTION_TIMEOUT",
-                    ConnectionIdle => "CONNECTION_IDLE",
-                    InternalError => "INTERNAL_ERROR",
-                    ConnectionRefused => "CONNECTION_REFUSED",
-                    ProtocolError => "PROTOCOL_ERROR",
-                    VerNegError => "VER_NEG_ERROR",
-                    EpollError => "EPOLL_ERROR",
-                    DnsResolutionError => "DNS_RESOLUTION_ERROR",
-                    SocketError => "SOCKET_ERROR",
-                    TlsError => "TLS_ERROR",
-                    UserCanceled => "USER_CANCELED",
-                    AlpnNegotiationFailure => "ALPN_NEG_FAILURE",
-                    _ => $"0x{status:X8}"
-                };
-            }
+                Success => "SUCCESS",
+                Pending => "PENDING",
+                Continue => "CONTINUE",
+                OutOfMemory => "OUT_OF_MEMORY",
+                InvalidParameter => "INVALID_PARAMETER",
+                InvalidState => "INVALID_STATE",
+                NotSupported => "NOT_SUPPORTED",
+                NotFound => "NOT_FOUND",
+                BufferTooSmall => "BUFFER_TOO_SMALL",
+                HandshakeFailure => "HANDSHAKE_FAILURE",
+                Aborted => "ABORTED",
+                AddressInUse => "ADDRESS_IN_USE",
+                ConnectionTimeout => "CONNECTION_TIMEOUT",
+                ConnectionIdle => "CONNECTION_IDLE",
+                HostUnreachable => "UNREACHABLE",
+                InternalError => "INTERNAL_ERROR",
+                ConnectionRefused => "CONNECTION_REFUSED",
+                ProtocolError => "PROTOCOL_ERROR",
+                VerNegError => "VER_NEG_ERROR",
+                TlsError => "TLS_ERROR",
+                UserCanceled => "USER_CANCELED",
+                AlpnNegotiationFailure => "ALPN_NEG_FAILURE",
+                StreamLimit => "STREAM_LIMIT_REACHED",
+                _ => $"0x{status:X8}"
+            };
         }
     }
 }
diff --git a/src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/MsQuic/MsQuicConnection.cs b/src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/MsQuic/MsQuicConnection.cs
index 66c8add4be60e7..f31dfc36fd5bfa 100644
--- a/src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/MsQuic/MsQuicConnection.cs
+++ b/src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/MsQuic/MsQuicConnection.cs
@@ -29,8 +29,7 @@ internal sealed class MsQuicConnection : QuicConnectionProvider
         private readonly SafeMsQuicConfigurationHandle? _configuration;
 
         private readonly State _state = new State();
-        private GCHandle _stateHandle;
-        private bool _disposed;
+        private int _disposed;
 
         private IPEndPoint? _localEndPoint;
         private readonly EndPoint _remoteEndPoint;
@@ -43,6 +42,7 @@ internal sealed class MsQuicConnection : QuicConnectionProvider
         internal sealed class State
         {
             public SafeMsQuicConnectionHandle Handle = null!; // set inside of MsQuicConnection ctor.
+            public GCHandle StateGCHandle;
 
             // These exists to prevent GC of the MsQuicConnection in the middle of an async op (Connect or Shutdown).
             public MsQuicConnection? Connection;
@@ -51,8 +51,16 @@ internal sealed class State
             public readonly TaskCompletionSource<uint> ConnectTcs = new TaskCompletionSource<uint>(TaskCreationOptions.RunContinuationsAsynchronously);
             public readonly TaskCompletionSource<uint> ShutdownTcs = new TaskCompletionSource<uint>(TaskCreationOptions.RunContinuationsAsynchronously);
 
+            // Note that there's no such thing as resetable TCS, so we cannot reuse the same instance after we've set the result.
+            // We also cannot use solutions like ManualResetValueTaskSourceCore, since we can have multiple waiters on the same TCS.
+            // As a result, we allocate a new TCS when needed, which is when someone explicitely asks for them in WaitForAvailableStreamsAsync.
+            public TaskCompletionSource? NewUnidirectionalStreamsAvailable;
+            public TaskCompletionSource? NewBidirectionalStreamsAvailable;
+
             public bool Connected;
             public long AbortErrorCode = -1;
+            public int StreamCount;
+            private bool _closing;
 
             // Queue for accepted streams.
             // Backlog limit is managed by MsQuic so it can be unbounded here.
@@ -61,30 +69,83 @@ internal sealed class State
                 SingleReader = true,
                 SingleWriter = true,
             });
+
+            public void RemoveStream(MsQuicStream stream)
+            {
+                bool releaseHandles;
+                lock (this)
+                {
+                    StreamCount--;
+                    Debug.Assert(StreamCount >= 0);
+                    releaseHandles = _closing && StreamCount == 0;
+                }
+
+                if (releaseHandles)
+                {
+                    Handle?.Dispose();
+                    StateGCHandle.Free();
+                }
+            }
+
+            public bool TryQueueNewStream(SafeMsQuicStreamHandle streamHandle, QUIC_STREAM_OPEN_FLAGS flags)
+            {
+                var stream = new MsQuicStream(this, streamHandle, flags);
+                if (AcceptQueue.Writer.TryWrite(stream))
+                {
+                    return true;
+                }
+                else
+                {
+                    stream.Dispose();
+                    return false;
+                }
+            }
+
+            public bool TryAddStream(MsQuicStream stream)
+            {
+                lock (this)
+                {
+                    if (_closing)
+                    {
+                        return false;
+                    }
+
+                    StreamCount++;
+                    return true;
+                }
+            }
+
+            // This is called under lock from connection dispose
+            public void SetClosing()
+            {
+                lock (this)
+                {
+                    _closing = true;
+                }
+            }
         }
 
         // constructor for inbound connections
         public MsQuicConnection(IPEndPoint localEndPoint, IPEndPoint remoteEndPoint, SafeMsQuicConnectionHandle handle)
         {
             _state.Handle = handle;
+            _state.StateGCHandle = GCHandle.Alloc(_state);
             _state.Connected = true;
             _localEndPoint = localEndPoint;
             _remoteEndPoint = remoteEndPoint;
             _remoteCertificateRequired = false;
             _isServer = true;
 
-            _stateHandle = GCHandle.Alloc(_state);
-
             try
             {
                 MsQuicApi.Api.SetCallbackHandlerDelegate(
                     _state.Handle,
                     s_connectionDelegate,
-                    GCHandle.ToIntPtr(_stateHandle));
+                    GCHandle.ToIntPtr(_state.StateGCHandle));
             }
             catch
             {
-                _stateHandle.Free();
+                _state.StateGCHandle.Free();
                 throw;
             }
 
@@ -107,7 +168,7 @@ public MsQuicConnection(QuicClientConnectionOptions options)
                 _remoteCertificateValidationCallback = options.ClientAuthenticationOptions.RemoteCertificateValidationCallback;
             }
 
-            _stateHandle = GCHandle.Alloc(_state);
+            _state.StateGCHandle = GCHandle.Alloc(_state);
             try
             {
                 // this handle is ref counted by MsQuic, so safe to dispose here.
@@ -116,14 +177,14 @@ public MsQuicConnection(QuicClientConnectionOptions options)
                 uint status = MsQuicApi.Api.ConnectionOpenDelegate(
                     MsQuicApi.Api.Registration,
                     s_connectionDelegate,
-                    GCHandle.ToIntPtr(_stateHandle),
+                    GCHandle.ToIntPtr(_state.StateGCHandle),
                     out _state.Handle);
 
                 QuicExceptionHelpers.ThrowIfFailed(status, "Could not open the connection.");
             }
             catch
             {
-                _stateHandle.Free();
+                _state.StateGCHandle.Free();
                 throw;
             }
 
@@ -192,20 +253,70 @@ private static uint HandleEventShutdownComplete(State state, ref ConnectionEvent
 
             // Stop accepting new streams.
             state.AcceptQueue.Writer.Complete();
+
+            // Stop notifying about available streams.
+            TaskCompletionSource? unidirectionalTcs = null;
+            TaskCompletionSource? bidirectionalTcs = null;
+            lock (state)
+            {
+                unidirectionalTcs = state.NewUnidirectionalStreamsAvailable;
+                bidirectionalTcs = state.NewBidirectionalStreamsAvailable;
+                state.NewUnidirectionalStreamsAvailable = null;
+                state.NewBidirectionalStreamsAvailable = null;
+            }
+
+            if (unidirectionalTcs is not null)
+            {
+                unidirectionalTcs.SetException(ExceptionDispatchInfo.SetCurrentStackTrace(new QuicOperationAbortedException()));
+            }
+            if (bidirectionalTcs is not null)
+            {
+                bidirectionalTcs.SetException(ExceptionDispatchInfo.SetCurrentStackTrace(new QuicOperationAbortedException()));
+            }
             return MsQuicStatusCodes.Success;
         }
 
         private static uint HandleEventNewStream(State state, ref ConnectionEvent connectionEvent)
         {
             var streamHandle = new SafeMsQuicStreamHandle(connectionEvent.Data.PeerStreamStarted.Stream);
-            var stream = new MsQuicStream(state, streamHandle, connectionEvent.Data.PeerStreamStarted.Flags);
+            if (!state.TryQueueNewStream(streamHandle, connectionEvent.Data.PeerStreamStarted.Flags))
+            {
+                // This will call StreamCloseDelegate and free the stream.
+                // We will return Success to the MsQuic to prevent double free.
+                streamHandle.Dispose();
+            }
 
-            state.AcceptQueue.Writer.TryWrite(stream);
             return MsQuicStatusCodes.Success;
         }
 
         private static uint HandleEventStreamsAvailable(State state, ref ConnectionEvent connectionEvent)
         {
+            TaskCompletionSource? unidirectionalTcs = null;
+            TaskCompletionSource? bidirectionalTcs = null;
+            lock (state)
+            {
+                if (connectionEvent.Data.StreamsAvailable.UniDirectionalCount > 0)
+                {
+                    unidirectionalTcs = state.NewUnidirectionalStreamsAvailable;
+                    state.NewUnidirectionalStreamsAvailable = null;
+                }
+
+                if (connectionEvent.Data.StreamsAvailable.BiDirectionalCount > 0)
+                {
+                    bidirectionalTcs = state.NewBidirectionalStreamsAvailable;
+                    state.NewBidirectionalStreamsAvailable = null;
+                }
+            }
+
+            if (unidirectionalTcs is not null)
+            {
+                unidirectionalTcs.SetResult();
+            }
+            if (bidirectionalTcs is not null)
+            {
+                bidirectionalTcs.SetResult();
+            }
+
             return MsQuicStatusCodes.Success;
         }
 
@@ -234,27 +345,18 @@ private static uint HandleEventPeerCertificateReceived(State state, ref Connecti
                     {
                         unsafe
                         {
-                            ReadOnlySpan<QuicBuffer> quicBuffer;
+                            ReadOnlySpan<QuicBuffer> quicBuffer = new ReadOnlySpan<QuicBuffer>((void*)connectionEvent.Data.PeerCertificateReceived.PlatformCertificateHandle, sizeof(QuicBuffer));
+                            certificate = new X509Certificate2(new ReadOnlySpan<byte>(quicBuffer[0].Buffer, (int)quicBuffer[0].Length));
+
                             if (connectionEvent.Data.PeerCertificateReceived.PlatformCertificateChainHandle != IntPtr.Zero)
                             {
                                 quicBuffer = new ReadOnlySpan<QuicBuffer>((void*)connectionEvent.Data.PeerCertificateReceived.PlatformCertificateChainHandle, sizeof(QuicBuffer));
                                 if (quicBuffer[0].Length != 0 && quicBuffer[0].Buffer != null)
                                 {
-                                    ReadOnlySpan<byte> asn1 = new ReadOnlySpan<byte>(quicBuffer[0].Buffer, (int)quicBuffer[0].Length);
                                     additionalCertificates = new X509Certificate2Collection();
-                                    additionalCertificates.Import(asn1);
-                                    if (additionalCertificates.Count > 0)
-                                    {
-                                        certificate = additionalCertificates[additionalCertificates.Count - 1];
-                                    }
+                                    additionalCertificates.Import(new ReadOnlySpan<byte>(quicBuffer[0].Buffer, (int)quicBuffer[0].Length));
                                 }
                             }
-                            else
-                            {
-                                 quicBuffer = new ReadOnlySpan<QuicBuffer>((void*)connectionEvent.Data.PeerCertificateReceived.PlatformCertificateHandle, sizeof(QuicBuffer));
-                                 ReadOnlySpan<byte> asn1 = new ReadOnlySpan<byte>(quicBuffer[0].Buffer, (int)quicBuffer[0].Length);
-                                 certificate = new X509Certificate2(asn1);
-                            }
                         }
                     }
                 }
@@ -273,10 +375,7 @@ private static uint HandleEventPeerCertificateReceived(State state, ref Connecti
 
                     if (additionalCertificates != null && additionalCertificates.Count > 1)
                     {
-                        for (int i = 0; i < additionalCertificates.Count - 1; i++)
-                        {
-                            chain.ChainPolicy.ExtraStore.Add(additionalCertificates[i]);
-                        }
+                        chain.ChainPolicy.ExtraStore.AddRange(additionalCertificates);
                     }
 
                     if (!chain.Build(certificate))
@@ -329,24 +428,82 @@ internal override async ValueTask<QuicStreamProvider> AcceptStreamAsync(Cancella
             return stream;
         }
 
+        internal override ValueTask WaitForAvailableUnidirectionalStreamsAsync(CancellationToken cancellationToken = default)
+        {
+            TaskCompletionSource? tcs = _state.NewUnidirectionalStreamsAvailable;
+            if (tcs is null)
+            {
+                lock (_state)
+                {
+                    if (_state.NewUnidirectionalStreamsAvailable is null)
+                    {
+                        if (_state.ShutdownTcs.Task.IsCompleted)
+                        {
+                            throw new QuicOperationAbortedException();
+                        }
+
+                        if (GetRemoteAvailableUnidirectionalStreamCount() > 0)
+                        {
+                            return ValueTask.CompletedTask;
+                        }
+
+                        _state.NewUnidirectionalStreamsAvailable = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+                    }
+                    tcs = _state.NewUnidirectionalStreamsAvailable;
+                }
+            }
+
+            return new ValueTask(tcs.Task.WaitAsync(cancellationToken));
+        }
+
+        internal override ValueTask WaitForAvailableBidirectionalStreamsAsync(CancellationToken cancellationToken = default)
+        {
+            TaskCompletionSource? tcs = _state.NewBidirectionalStreamsAvailable;
+            if (tcs is null)
+            {
+                lock (_state)
+                {
+                    if (_state.NewBidirectionalStreamsAvailable is null)
+                    {
+                        if (_state.ShutdownTcs.Task.IsCompleted)
+                        {
+                            throw new QuicOperationAbortedException();
+                        }
+
+                        if (GetRemoteAvailableBidirectionalStreamCount() > 0)
+                        {
+                            return ValueTask.CompletedTask;
+                        }
+
+                        _state.NewBidirectionalStreamsAvailable = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+                    }
+                    tcs = _state.NewBidirectionalStreamsAvailable;
+                }
+            }
+
+            return new ValueTask(tcs.Task.WaitAsync(cancellationToken));
+        }
+
         internal override QuicStreamProvider OpenUnidirectionalStream()
         {
             ThrowIfDisposed();
+
             return new MsQuicStream(_state, QUIC_STREAM_OPEN_FLAGS.UNIDIRECTIONAL);
         }
 
         internal override QuicStreamProvider OpenBidirectionalStream()
         {
             ThrowIfDisposed();
+
             return new MsQuicStream(_state, QUIC_STREAM_OPEN_FLAGS.NONE);
         }
 
-        internal override long GetRemoteAvailableUnidirectionalStreamCount()
+        internal override int GetRemoteAvailableUnidirectionalStreamCount()
         {
             return MsQuicParameterHelpers.GetUShortParam(MsQuicApi.Api, _state.Handle, QUIC_PARAM_LEVEL.CONNECTION, (uint)QUIC_PARAM_CONN.LOCAL_UNIDI_STREAM_COUNT);
         }
 
-        internal override long GetRemoteAvailableBidirectionalStreamCount()
+        internal override int GetRemoteAvailableBidirectionalStreamCount()
         {
             return MsQuicParameterHelpers.GetUShortParam(MsQuicApi.Api, _state.Handle, QUIC_PARAM_LEVEL.CONNECTION, (uint)QUIC_PARAM_CONN.LOCAL_BIDI_STREAM_COUNT);
         }
@@ -488,16 +645,45 @@ public override void Dispose()
             Dispose(false);
         }
 
+        private async Task FlushAcceptQueue()
+        {
+            _state.AcceptQueue.Writer.TryComplete();
+            await foreach (MsQuicStream item in _state.AcceptQueue.Reader.ReadAllAsync().ConfigureAwait(false))
+            {
+                item.Dispose();
+            }
+        }
+
         private void Dispose(bool disposing)
         {
-            if (_disposed)
+            int disposed = Interlocked.Exchange(ref _disposed, 1);
+            if (disposed != 0)
             {
                 return;
             }
 
-            _state?.Handle?.Dispose();
-            if (_stateHandle.IsAllocated) _stateHandle.Free();
-            _disposed = true;
+            bool releaseHandles = false;
+            lock (_state)
+            {
+                _state.Connection = null;
+                if (_state.StreamCount == 0)
+                {
+                    releaseHandles = true;
+                }
+                else
+                {
+                    // We have pending streams so we need to defer cleanup until last one is gone.
+                    _state.SetClosing();
+                }
+            }
+
+            FlushAcceptQueue().GetAwaiter().GetResult();
+            _configuration?.Dispose();
+            if (releaseHandles)
+            {
+                _state!.Handle?.Dispose();
+                if (_state.StateGCHandle.IsAllocated) _state.StateGCHandle.Free();
+            }
         }
 
         // TODO: this appears abortive and will cause prior successfully shutdown and closed streams to drop data.
@@ -511,7 +697,7 @@ internal override ValueTask CloseAsync(long errorCode, CancellationToken cancell
 
         private void ThrowIfDisposed()
         {
-            if (_disposed)
+            if (_disposed == 1)
             {
                 throw new ObjectDisposedException(nameof(MsQuicStream));
             }
diff --git a/src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/MsQuic/MsQuicStream.cs b/src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/MsQuic/MsQuicStream.cs
index bb1468cd525586..e796496bcf1f59 100644
--- a/src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/MsQuic/MsQuicStream.cs
+++ b/src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/MsQuic/MsQuicStream.cs
@@ -64,7 +64,6 @@ private sealed class State
             // Set once writes have been shutdown.
             public readonly TaskCompletionSource ShutdownWriteCompletionSource = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
 
-
             public ShutdownState ShutdownState;
 
             // Set once stream have been shutdown.
@@ -75,7 +74,6 @@ private sealed class State
         internal MsQuicStream(MsQuicConnection.State connectionState, SafeMsQuicStreamHandle streamHandle, QUIC_STREAM_OPEN_FLAGS flags)
         {
             _state.Handle = streamHandle;
-            _state.ConnectionState = connectionState;
             _canRead = true;
             _canWrite = !flags.HasFlag(QUIC_STREAM_OPEN_FLAGS.UNIDIRECTIONAL);
             _started = true;
@@ -94,6 +92,14 @@ internal MsQuicStream(MsQuicConnection.State connectionState, SafeMsQuicStreamHa
                 throw;
             }
 
+            if (!connectionState.TryAddStream(this))
+            {
+                _stateHandle.Free();
+                throw new ObjectDisposedException(nameof(QuicConnection));
+            }
+
+            _state.ConnectionState = connectionState;
+
             if (NetEventSource.Log.IsEnabled())
             {
                 NetEventSource.Info(
@@ -108,10 +114,8 @@ internal MsQuicStream(MsQuicConnection.State connectionState, QUIC_STREAM_OPEN_F
         {
             Debug.Assert(connectionState.Handle != null);
 
-            _state.ConnectionState = connectionState;
             _canRead = !flags.HasFlag(QUIC_STREAM_OPEN_FLAGS.UNIDIRECTIONAL);
             _canWrite = true;
-
             _stateHandle = GCHandle.Alloc(_state);
             try
             {
@@ -124,7 +128,7 @@ internal MsQuicStream(MsQuicConnection.State connectionState, QUIC_STREAM_OPEN_F
 
                 QuicExceptionHelpers.ThrowIfFailed(status, "Failed to open stream to peer.");
 
-                status = MsQuicApi.Api.StreamStartDelegate(_state.Handle, QUIC_STREAM_START_FLAGS.ASYNC);
+                status = MsQuicApi.Api.StreamStartDelegate(_state.Handle, QUIC_STREAM_START_FLAGS.FAIL_BLOCKED);
                 QuicExceptionHelpers.ThrowIfFailed(status, "Could not start stream.");
             }
             catch
@@ -134,6 +138,15 @@ internal MsQuicStream(MsQuicConnection.State connectionState, QUIC_STREAM_OPEN_F
                 throw;
             }
 
+            if (!connectionState.TryAddStream(this))
+            {
+                _state.Handle?.Dispose();
+                _stateHandle.Free();
+                throw new ObjectDisposedException(nameof(QuicConnection));
+            }
+
+            _state.ConnectionState = connectionState;
+
             if (NetEventSource.Log.IsEnabled())
             {
                 NetEventSource.Info(
@@ -322,7 +335,6 @@ internal override async ValueTask<int> ReadAsync(Memory<byte> destination, Cance
                     {
                         shouldComplete = true;
                     }
-
                     state.ReadState = ReadState.Aborted;
                 }
 
@@ -492,6 +504,7 @@ internal override async ValueTask ShutdownCompleted(CancellationToken cancellati
         internal override void Shutdown()
         {
             ThrowIfDisposed();
+
             // it is ok to send shutdown several times, MsQuic will ignore it
             StartShutdown(QUIC_STREAM_SHUTDOWN_FLAGS.GRACEFUL, errorCode: 0);
         }
@@ -500,8 +513,17 @@ internal override void Shutdown()
         internal override int Read(Span<byte> buffer)
         {
             ThrowIfDisposed();
-
-            return ReadAsync(buffer.ToArray()).AsTask().GetAwaiter().GetResult();
+            byte[] rentedBuffer = ArrayPool<byte>.Shared.Rent(buffer.Length);
+            try
+            {
+                int readLength = ReadAsync(new Memory<byte>(rentedBuffer, 0, buffer.Length)).AsTask().GetAwaiter().GetResult();
+                rentedBuffer.AsSpan(0, readLength).CopyTo(buffer);
+                return readLength;
+            }
+            finally
+            {
+                ArrayPool<byte>.Shared.Return(rentedBuffer);
+            }
         }
 
         internal override void Write(ReadOnlySpan<byte> buffer)
@@ -557,6 +579,7 @@ private void Dispose(bool disposing)
             Marshal.FreeHGlobal(_state.SendQuicBuffers);
             if (_stateHandle.IsAllocated) _stateHandle.Free();
             CleanupSendState(_state);
+            _state.ConnectionState?.RemoveStream(this);
 
             if (NetEventSource.Log.IsEnabled())
             {
@@ -592,7 +615,7 @@ private static uint HandleEvent(State state, ref StreamEvent evt)
                     // Stream has started.
                     // Will only be done for outbound streams (inbound streams have already started)
                     case QUIC_STREAM_EVENT_TYPE.START_COMPLETE:
-                        return HandleStartComplete(state);
+                        return HandleEventStartComplete(state);
                     // Received data on the stream
                     case QUIC_STREAM_EVENT_TYPE.RECEIVE:
                         return HandleEventRecv(state, ref evt);
@@ -678,7 +701,7 @@ private static uint HandleEventPeerRecvAborted(State state, ref StreamEvent evt)
             return MsQuicStatusCodes.Success;
         }
 
-        private static uint HandleStartComplete(State state)
+        private static uint HandleEventStartComplete(State state)
         {
             bool shouldComplete = false;
             lock (state)
diff --git a/src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/QuicConnectionProvider.cs b/src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/QuicConnectionProvider.cs
index 94258334135896..e5153c3fae4b2e 100644
--- a/src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/QuicConnectionProvider.cs
+++ b/src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/QuicConnectionProvider.cs
@@ -16,13 +16,17 @@ internal abstract class QuicConnectionProvider : IDisposable
 
         internal abstract ValueTask ConnectAsync(CancellationToken cancellationToken = default);
 
+        internal abstract ValueTask WaitForAvailableUnidirectionalStreamsAsync(CancellationToken cancellationToken = default);
+
+        internal abstract ValueTask WaitForAvailableBidirectionalStreamsAsync(CancellationToken cancellationToken = default);
+
         internal abstract QuicStreamProvider OpenUnidirectionalStream();
 
         internal abstract QuicStreamProvider OpenBidirectionalStream();
 
-        internal abstract long GetRemoteAvailableUnidirectionalStreamCount();
+        internal abstract int GetRemoteAvailableUnidirectionalStreamCount();
 
-        internal abstract long GetRemoteAvailableBidirectionalStreamCount();
+        internal abstract int GetRemoteAvailableBidirectionalStreamCount();
 
         internal abstract ValueTask<QuicStreamProvider> AcceptStreamAsync(CancellationToken cancellationToken = default);
 
diff --git a/src/libraries/System.Net.Quic/src/System/Net/Quic/QuicConnection.cs b/src/libraries/System.Net.Quic/src/System/Net/Quic/QuicConnection.cs
index fd21c4116f7b67..e91913f9d7bac6 100644
--- a/src/libraries/System.Net.Quic/src/System/Net/Quic/QuicConnection.cs
+++ b/src/libraries/System.Net.Quic/src/System/Net/Quic/QuicConnection.cs
@@ -67,6 +67,18 @@ internal QuicConnection(QuicConnectionProvider provider)
         /// <returns></returns>
         public ValueTask ConnectAsync(CancellationToken cancellationToken = default) => _provider.ConnectAsync(cancellationToken);
 
+        /// <summary>
+        /// Waits for available unidirectional stream capacity to be announced by the peer. If any capacity is available, returns immediately.
+        /// </summary>
+        /// <returns></returns>
+        public ValueTask WaitForAvailableUnidirectionalStreamsAsync(CancellationToken cancellationToken = default) => _provider.WaitForAvailableUnidirectionalStreamsAsync(cancellationToken);
+
+        /// <summary>
+        /// Waits for available bidirectional stream capacity to be announced by the peer. If any capacity is available, returns immediately.
+        /// </summary>
+        /// <returns></returns>
+        public ValueTask WaitForAvailableBidirectionalStreamsAsync(CancellationToken cancellationToken = default) => _provider.WaitForAvailableBidirectionalStreamsAsync(cancellationToken);
+
         /// <summary>
         /// Create an outbound unidirectional stream.
         /// </summary>
@@ -95,11 +107,11 @@ internal QuicConnection(QuicConnectionProvider provider)
         /// <summary>
         /// Gets the maximum number of bidirectional streams that can be made to the peer.
         /// </summary>
-        public long GetRemoteAvailableUnidirectionalStreamCount() => _provider.GetRemoteAvailableUnidirectionalStreamCount();
+        public int GetRemoteAvailableUnidirectionalStreamCount() => _provider.GetRemoteAvailableUnidirectionalStreamCount();
 
         /// <summary>
         /// Gets the maximum number of unidirectional streams that can be made to the peer.
         /// </summary>
-        public long GetRemoteAvailableBidirectionalStreamCount() => _provider.GetRemoteAvailableBidirectionalStreamCount();
+        public int GetRemoteAvailableBidirectionalStreamCount() => _provider.GetRemoteAvailableBidirectionalStreamCount();
     }
 }
diff --git a/src/libraries/System.Net.Quic/src/System/Net/Quic/QuicOptions.cs b/src/libraries/System.Net.Quic/src/System/Net/Quic/QuicOptions.cs
index 86dd644aaac1c7..44a5fd0ae9d97f 100644
--- a/src/libraries/System.Net.Quic/src/System/Net/Quic/QuicOptions.cs
+++ b/src/libraries/System.Net.Quic/src/System/Net/Quic/QuicOptions.cs
@@ -3,7 +3,6 @@
 
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 
@@ -19,14 +18,14 @@ public class QuicOptions
         /// Default is 100.
         /// </summary>
         // TODO consider constraining these limits to 0 to whatever the max of the QUIC library we are using.
-        public long MaxBidirectionalStreams { get; set; } = 100;
+        public int MaxBidirectionalStreams { get; set; } = 100;
 
         /// <summary>
         /// Limit on the number of unidirectional streams the remote peer connection can create on an open connection.
         /// Default is 100.
         /// </summary>
         // TODO consider constraining these limits to 0 to whatever the max of the QUIC library we are using.
-        public long MaxUnidirectionalStreams { get; set; } = 100;
+        public int MaxUnidirectionalStreams { get; set; } = 100;
 
         /// <summary>
         /// Idle timeout for connections, after which the connection will be closed.
diff --git a/src/libraries/System.Net.Quic/tests/FunctionalTests/MsQuicTests.cs b/src/libraries/System.Net.Quic/tests/FunctionalTests/MsQuicTests.cs
index 0e2a227b0ef1d5..277265a17a53a7 100644
--- a/src/libraries/System.Net.Quic/tests/FunctionalTests/MsQuicTests.cs
+++ b/src/libraries/System.Net.Quic/tests/FunctionalTests/MsQuicTests.cs
@@ -10,14 +10,21 @@
 using System.Text;
 using System.Threading.Tasks;
 using Xunit;
+using Xunit.Abstractions;
 
 namespace System.Net.Quic.Tests
 {
     [ConditionalClass(typeof(QuicTestBase<MsQuicProviderFactory>), nameof(IsSupported))]
     public class MsQuicTests : QuicTestBase<MsQuicProviderFactory>
     {
+        readonly ITestOutputHelper _output;
         private static ReadOnlyMemory<byte> s_data = Encoding.UTF8.GetBytes("Hello world!");
 
+        public MsQuicTests(ITestOutputHelper output)
+        {
+            _output = output;
+        }
+
         [Fact]
         public async Task UnidirectionalAndBidirectionalStreamCountsWork()
         {
@@ -83,9 +90,22 @@ public async Task ConnectWithCertificateChain()
                 // With trusted root, we should be able to build chain.
                 chain.ChainPolicy.CustomTrustStore.Add(rootCA);
                 chain.ChainPolicy.TrustMode = X509ChainTrustMode.CustomRootTrust;
-                Assert.True(chain.Build(certificate));
+                bool ret = chain.Build(certificate);
+                if (!ret)
+                {
+                    _output.WriteLine("Chain build failed with {0} elements", chain.ChainElements);
+                    foreach (X509ChainElement element in chain.ChainElements)
+                    {
+                        _output.WriteLine("Element subject {0} and issuer {1}", element.Certificate.Subject, element.Certificate.Issuer);
+                        _output.WriteLine("Element status len {0}", element.ChainElementStatus.Length);
+                        foreach (X509ChainStatus status in element.ChainElementStatus)
+                        {
+                            _output.WriteLine($"Status:  {status.Status}: {status.StatusInformation}");
+                        }
+                    }
+                }
 
-                return true;
+                return ret;
             };
 
             using QuicConnection clientConnection = new QuicConnection(QuicImplementationProviders.MsQuic, options);
@@ -95,6 +115,54 @@ public async Task ConnectWithCertificateChain()
             await clientTask;
         }
 
+        [Fact]
+        public async Task WaitForAvailableUnidirectionStreamsAsyncWorks()
+        {
+            using QuicListener listener = CreateQuicListener(maxUnidirectionalStreams: 1);
+            using QuicConnection clientConnection = CreateQuicConnection(listener.ListenEndPoint);
+
+            ValueTask clientTask = clientConnection.ConnectAsync();
+            using QuicConnection serverConnection = await listener.AcceptConnectionAsync();
+            await clientTask;
+
+            // No stream opened yet, should return immediately.
+            Assert.True(clientConnection.WaitForAvailableUnidirectionalStreamsAsync().IsCompletedSuccessfully);
+
+            // Open one stream, should wait till it closes.
+            QuicStream stream = clientConnection.OpenUnidirectionalStream();
+            ValueTask waitTask = clientConnection.WaitForAvailableUnidirectionalStreamsAsync();
+            Assert.False(waitTask.IsCompleted);
+            Assert.Throws<QuicException>(() => clientConnection.OpenUnidirectionalStream());
+
+            // Close the stream, the waitTask should finish as a result.
+            stream.Dispose();
+            await waitTask.AsTask().WaitAsync(TimeSpan.FromSeconds(10));
+        }
+
+        [Fact]
+        public async Task WaitForAvailableBidirectionStreamsAsyncWorks()
+        {
+            using QuicListener listener = CreateQuicListener(maxBidirectionalStreams: 1);
+            using QuicConnection clientConnection = CreateQuicConnection(listener.ListenEndPoint);
+
+            ValueTask clientTask = clientConnection.ConnectAsync();
+            using QuicConnection serverConnection = await listener.AcceptConnectionAsync();
+            await clientTask;
+
+            // No stream opened yet, should return immediately.
+            Assert.True(clientConnection.WaitForAvailableBidirectionalStreamsAsync().IsCompletedSuccessfully);
+
+            // Open one stream, should wait till it closes.
+            QuicStream stream = clientConnection.OpenBidirectionalStream();
+            ValueTask waitTask = clientConnection.WaitForAvailableBidirectionalStreamsAsync();
+            Assert.False(waitTask.IsCompleted);
+            Assert.Throws<QuicException>(() => clientConnection.OpenBidirectionalStream());
+
+            // Close the stream, the waitTask should finish as a result.
+            stream.Dispose();
+            await waitTask.AsTask().WaitAsync(TimeSpan.FromSeconds(10));
+        }
+
         [Fact]
         [OuterLoop("May take several seconds")]
         public async Task SetListenerTimeoutWorksWithSmallTimeout()
@@ -234,7 +302,7 @@ public async Task CallDifferentWriteMethodsWorks()
             int res = await serverStream.ReadAsync(memory);
             Assert.Equal(12, res);
             ReadOnlyMemory<ReadOnlyMemory<byte>> romrom = new ReadOnlyMemory<ReadOnlyMemory<byte>>(new ReadOnlyMemory<byte>[] { helloWorld, helloWorld });
-            
+
             await clientStream.WriteAsync(romrom);
 
             res = await serverStream.ReadAsync(memory);
@@ -254,7 +322,7 @@ await RunClientServer(
                 {
                     var acceptTask = serverConnection.AcceptStreamAsync();
                     await serverConnection.CloseAsync(errorCode: 0);
-                    // make sure 
+                    // make sure
                     await Assert.ThrowsAsync<QuicOperationAbortedException>(() => acceptTask.AsTask());
                 });
         }
@@ -392,7 +460,6 @@ await RunClientServer(
             await (new[] { t1, t2 }).WhenAllOrAnyFailed(millisecondsTimeout: 1000000);
         }
 
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/52048")]
         [Fact]
         public async Task ManagedAVE_MinimalFailingTest()
         {
@@ -411,6 +478,32 @@ async Task GetStreamIdWithoutStartWorks()
                 // TODO: stream that is opened by client but left unaccepted by server may cause AccessViolationException in its Finalizer
             }
 
+            await GetStreamIdWithoutStartWorks().WaitAsync(TimeSpan.FromSeconds(15));
+
+            GC.Collect();
+        }
+
+        [Fact]
+        public async Task DisposingConnection_OK()
+        {
+            async Task GetStreamIdWithoutStartWorks()
+            {
+                using QuicListener listener = CreateQuicListener();
+                using QuicConnection clientConnection = CreateQuicConnection(listener.ListenEndPoint);
+
+                ValueTask clientTask = clientConnection.ConnectAsync();
+                using QuicConnection serverConnection = await listener.AcceptConnectionAsync();
+                await clientTask;
+
+                using QuicStream clientStream = clientConnection.OpenBidirectionalStream();
+                Assert.Equal(0, clientStream.StreamId);
+
+                // Dispose all connections before the streams;
+                clientConnection.Dispose();
+                serverConnection.Dispose();
+                listener.Dispose();
+            }
+
             await GetStreamIdWithoutStartWorks();
 
             GC.Collect();
diff --git a/src/libraries/System.Net.Quic/tests/FunctionalTests/QuicStreamConnectedStreamConformanceTests.cs b/src/libraries/System.Net.Quic/tests/FunctionalTests/QuicStreamConnectedStreamConformanceTests.cs
index ad7b74c12e887f..cd83662a1baa95 100644
--- a/src/libraries/System.Net.Quic/tests/FunctionalTests/QuicStreamConnectedStreamConformanceTests.cs
+++ b/src/libraries/System.Net.Quic/tests/FunctionalTests/QuicStreamConnectedStreamConformanceTests.cs
@@ -6,6 +6,7 @@
 using System.IO.Tests;
 using System.Net.Quic.Implementations;
 using System.Net.Security;
+using System.Security.Cryptography.X509Certificates;
 using System.Threading.Tasks;
 using Xunit;
 
@@ -20,6 +21,8 @@ public sealed class MockQuicStreamConformanceTests : QuicStreamConformanceTests
     public sealed class MsQuicQuicStreamConformanceTests : QuicStreamConformanceTests
     {
         protected override QuicImplementationProvider Provider => QuicImplementationProviders.MsQuic;
+        protected override bool UsableAfterCanceledReads => false;
+        protected override bool BlocksOnZeroByteReads => true;
 
         // TODO: These are all hanging, likely due to Stream close behavior.
         [ActiveIssue("https://github.com/dotnet/runtime/issues/756")]
@@ -37,91 +40,72 @@ public sealed class MsQuicQuicStreamConformanceTests : QuicStreamConformanceTest
 
         // TODO: new additions, find out the actual reason for hanging
         [ActiveIssue("https://github.com/dotnet/runtime/issues/49157")]
-        public override Task ReadTimeout_Expires_Throws() => base.ReadTimeout_Expires_Throws();
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/49157")]
-        public override Task ConcurrentBidirectionalReadsWrites_Success() => base.ConcurrentBidirectionalReadsWrites_Success();
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/49157")]
-        public override Task ArgumentValidation_ThrowsExpectedException() => base.ArgumentValidation_ThrowsExpectedException();
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/49157")]
         public override Task ReadWriteAsync_PrecanceledOperations_ThrowsCancellationException() => base.ReadWriteAsync_PrecanceledOperations_ThrowsCancellationException();
         [ActiveIssue("https://github.com/dotnet/runtime/issues/49157")]
         public override Task Read_DataStoredAtDesiredOffset(ReadWriteMode mode) => base.Read_DataStoredAtDesiredOffset(mode);
         [ActiveIssue("https://github.com/dotnet/runtime/issues/49157")]
-        public override Task ReadAsync_CancelPendingRead_DoesntImpactSubsequentReads() => base.ReadAsync_CancelPendingRead_DoesntImpactSubsequentReads();
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/49157")]
-        public override Task Disposed_ThrowsObjectDisposedException() => base.Disposed_ThrowsObjectDisposedException();
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/49157")]
-        public override Task Timeout_Roundtrips() => base.Timeout_Roundtrips();
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/49157")]
-        public override Task ZeroByteWrite_OtherDataReceivedSuccessfully(ReadWriteMode mode) => base.ZeroByteWrite_OtherDataReceivedSuccessfully(mode);
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/49157")]
-        public override Task ReadAsync_ContinuesOnCurrentTaskSchedulerIfDesired(bool flowExecutionContext, bool? continueOnCapturedContext) => base.ReadAsync_ContinuesOnCurrentTaskSchedulerIfDesired(flowExecutionContext, continueOnCapturedContext);
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/49157")]
-        public override Task ZeroByteRead_BlocksUntilDataAvailableOrNops(ReadWriteMode mode) => base.ZeroByteRead_BlocksUntilDataAvailableOrNops(mode);
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/49157")]
-        public override Task ReadAsync_CancelPendingTask_ThrowsCancellationException() => base.ReadAsync_CancelPendingTask_ThrowsCancellationException();
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/49157")]
-        public override Task ReadAsync_ContinuesOnCurrentSynchronizationContextIfDesired(bool flowExecutionContext, bool? continueOnCapturedContext) => base.ReadAsync_ContinuesOnCurrentSynchronizationContextIfDesired(flowExecutionContext, continueOnCapturedContext);
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/49157")]
-        public override Task ReadWriteByte_Success() => base.ReadWriteByte_Success();
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/49157")]
-        public override Task ReadWrite_Success(ReadWriteMode mode, int writeSize, bool startWithFlush) => base.ReadWrite_Success(mode, writeSize, startWithFlush);
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/49157")]
-        public override Task ReadWrite_Success_Large(ReadWriteMode mode, int writeSize, bool startWithFlush) => base.ReadWrite_Success_Large(mode, writeSize, startWithFlush);
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/49157")]
-        public override Task Flush_ValidOnWriteableStreamWithNoData_Success() => base.Flush_ValidOnWriteableStreamWithNoData_Success();
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/49157")]
-        public override Task ReadAsync_CancelPendingValueTask_ThrowsCancellationException() => base.ReadAsync_CancelPendingValueTask_ThrowsCancellationException();
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/49157")]
         public override Task ReadAsync_DuringReadAsync_ThrowsIfUnsupported() => base.ReadAsync_DuringReadAsync_ThrowsIfUnsupported();
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/49157")]
-        public override Task ReadWrite_CustomMemoryManager_Success(bool useAsync) => base.ReadWrite_CustomMemoryManager_Success(useAsync);
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/49157")]
-        public override Task Flush_ValidOnReadableStream_Success() => base.Flush_ValidOnReadableStream_Success();
-
     }
 
     public abstract class QuicStreamConformanceTests : ConnectedStreamConformanceTests
     {
+        public X509Certificate2 ServerCertificate = System.Net.Test.Common.Configuration.Certificates.GetServerCertificate();
+
+        public bool RemoteCertificateValidationCallback(object sender, X509Certificate? certificate, X509Chain? chain, SslPolicyErrors sslPolicyErrors)
+        {
+            Assert.Equal(ServerCertificate.GetCertHash(), certificate?.GetCertHash());
+            return true;
+        }
+
         public SslServerAuthenticationOptions GetSslServerAuthenticationOptions()
         {
             return new SslServerAuthenticationOptions()
             {
                 ApplicationProtocols = new List<SslApplicationProtocol>() { new SslApplicationProtocol("quictest") },
-                // TODO: use a cert. MsQuic currently only allows certs that are trusted.
-                ServerCertificate = System.Net.Test.Common.Configuration.Certificates.GetServerCertificate()
+                ServerCertificate = ServerCertificate
+            };
+        }
+
+        public SslClientAuthenticationOptions GetSslClientAuthenticationOptions()
+        {
+            return new SslClientAuthenticationOptions()
+            {
+                ApplicationProtocols = new List<SslApplicationProtocol>() { new SslApplicationProtocol("quictest") },
+                RemoteCertificateValidationCallback = RemoteCertificateValidationCallback
             };
         }
-        
+
         protected abstract QuicImplementationProvider Provider { get; }
 
         protected override async Task<StreamPair> CreateConnectedStreamsAsync()
         {
             QuicImplementationProvider provider = Provider;
-            var protocol = new SslApplicationProtocol("quictest");
-
             var listener = new QuicListener(
                 provider,
                 new IPEndPoint(IPAddress.Loopback, 0),
                 GetSslServerAuthenticationOptions());
 
+            byte[] buffer = new byte[1] { 42 };
             QuicConnection connection1 = null, connection2 = null;
             QuicStream stream1 = null, stream2 = null;
-
             await WhenAllOrAnyFailed(
                 Task.Run(async () =>
                 {
                     connection1 = await listener.AcceptConnectionAsync();
                     stream1 = await connection1.AcceptStreamAsync();
+                    Assert.Equal(1, await stream1.ReadAsync(buffer));
                 }),
                 Task.Run(async () =>
                 {
                     connection2 = new QuicConnection(
                         provider,
                         listener.ListenEndPoint,
-                        new SslClientAuthenticationOptions() { ApplicationProtocols = new List<SslApplicationProtocol>() { protocol } });
+                        GetSslClientAuthenticationOptions());
                     await connection2.ConnectAsync();
                     stream2 = connection2.OpenBidirectionalStream();
+                    // OpenBidirectionalStream only allocates ID. We will force stream opening
+                    // by Writing there and receiving data on the other side.
+                    await stream2.WriteAsync(buffer);
                 }));
 
             var result = new StreamPairWithOtherDisposables(stream1, stream2);
diff --git a/src/libraries/System.Net.Quic/tests/FunctionalTests/QuicTestBase.cs b/src/libraries/System.Net.Quic/tests/FunctionalTests/QuicTestBase.cs
index 027d0adb258adf..ee7501868bebab 100644
--- a/src/libraries/System.Net.Quic/tests/FunctionalTests/QuicTestBase.cs
+++ b/src/libraries/System.Net.Quic/tests/FunctionalTests/QuicTestBase.cs
@@ -53,16 +53,30 @@ internal QuicConnection CreateQuicConnection(IPEndPoint endpoint)
             return new QuicConnection(ImplementationProvider, endpoint, GetSslClientAuthenticationOptions());
         }
 
-        internal QuicListener CreateQuicListener()
+        internal QuicListener CreateQuicListener(int maxUnidirectionalStreams = 100, int maxBidirectionalStreams = 100)
         {
-            return CreateQuicListener(new IPEndPoint(IPAddress.Loopback, 0));
+            var options = new QuicListenerOptions()
+            {
+                ListenEndPoint = new IPEndPoint(IPAddress.Loopback, 0),
+                ServerAuthenticationOptions = GetSslServerAuthenticationOptions(),
+                MaxUnidirectionalStreams = maxUnidirectionalStreams,
+                MaxBidirectionalStreams = maxBidirectionalStreams
+            };
+            return CreateQuicListener(options);
         }
 
         internal QuicListener CreateQuicListener(IPEndPoint endpoint)
         {
-            return new QuicListener(ImplementationProvider, endpoint, GetSslServerAuthenticationOptions());
+            var options = new QuicListenerOptions()
+            {
+                ListenEndPoint = endpoint,
+                ServerAuthenticationOptions = GetSslServerAuthenticationOptions()
+            };
+            return CreateQuicListener(options);
         }
 
+        private QuicListener CreateQuicListener(QuicListenerOptions options) => new QuicListener(ImplementationProvider, options);
+
         internal async Task RunClientServer(Func<QuicConnection, Task> clientFunction, Func<QuicConnection, Task> serverFunction, int iterations = 1, int millisecondsTimeout = 10_000)
         {
             using QuicListener listener = CreateQuicListener();
diff --git a/src/libraries/System.Net.Security/src/Resources/Strings.resx b/src/libraries/System.Net.Security/src/Resources/Strings.resx
index c002340abcbcae..8181afecaaa620 100644
--- a/src/libraries/System.Net.Security/src/Resources/Strings.resx
+++ b/src/libraries/System.Net.Security/src/Resources/Strings.resx
@@ -455,4 +455,7 @@
   <data name="net_ssl_renegotiate_data" xml:space="preserve">
     <value>Received data during renegotiation.</value>
   </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>
 </root>
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 b838db0c252b4c..81f2c92880b559 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
@@ -914,11 +914,12 @@ private async ValueTask<int> ReadAsyncInternal<TIOAdapter>(TIOAdapter adapter, M
                             // If that happen before EncryptData() runs, _handshakeWaiter will be set to null
                             // and EncryptData() will work normally e.g. no waiting, just exclusion with DecryptData()
 
-                            if (_sslAuthenticationOptions!.AllowRenegotiation || SslProtocol == SslProtocols.Tls13)
+                            if (_sslAuthenticationOptions!.AllowRenegotiation || SslProtocol == SslProtocols.Tls13 || _nestedAuth != 0)
                             {
                                 // create TCS only if we plan to proceed. If not, we will throw in block bellow outside of the lock.
                                 // Tls1.3 does not have renegotiation. However on Windows this error code is used
                                 // for session management e.g. anything lsass needs to see.
+                                // We also allow it when explicitly requested using RenegotiateAsync().
                                 _handshakeWaiter = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
                             }
                         }
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 1416e397903896..98a21e128569cb 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
@@ -49,20 +49,51 @@ public static SafeFreeCredentials AcquireCredentialsHandle(SslStreamCertificateC
 
         public static SecurityStatusPal EncryptMessage(SafeDeleteSslContext securityContext, ReadOnlyMemory<byte> input, int headerSize, int trailerSize, ref byte[] output, out int resultSize)
         {
-            return EncryptDecryptHelper(securityContext, input, offset: 0, size: 0, encrypt: true, output: ref output, resultSize: out resultSize);
+            try
+            {
+                resultSize = Interop.OpenSsl.Encrypt(securityContext.SslContext, input.Span, ref output, out Interop.Ssl.SslErrorCode errorCode);
+
+                return MapNativeErrorCode(errorCode);
+            }
+            catch (Exception ex)
+            {
+                resultSize = 0;
+                return new SecurityStatusPal(SecurityStatusPalErrorCode.InternalError, ex);
+            }
         }
 
         public static SecurityStatusPal DecryptMessage(SafeDeleteSslContext securityContext, byte[] buffer, ref int offset, ref int count)
         {
-            SecurityStatusPal retVal = EncryptDecryptHelper(securityContext, buffer, offset, count, false, ref buffer, out int resultSize);
-            if (retVal.ErrorCode == SecurityStatusPalErrorCode.OK ||
-                retVal.ErrorCode == SecurityStatusPalErrorCode.Renegotiate)
+            try
             {
-                count = resultSize;
+                int resultSize = Interop.OpenSsl.Decrypt(securityContext.SslContext, new Span<byte>(buffer, offset, count), out Interop.Ssl.SslErrorCode errorCode);
+
+                SecurityStatusPal retVal = MapNativeErrorCode(errorCode);
+
+                if (retVal.ErrorCode == SecurityStatusPalErrorCode.OK ||
+                    retVal.ErrorCode == SecurityStatusPalErrorCode.Renegotiate)
+                {
+                    count = resultSize;
+                }
+
+                return retVal;
+            }
+            catch (Exception ex)
+            {
+                return new SecurityStatusPal(SecurityStatusPalErrorCode.InternalError, ex);
             }
-            return retVal;
         }
 
+        private static SecurityStatusPal MapNativeErrorCode(Interop.Ssl.SslErrorCode errorCode) =>
+            errorCode switch
+            {
+                Interop.Ssl.SslErrorCode.SSL_ERROR_RENEGOTIATE => new SecurityStatusPal(SecurityStatusPalErrorCode.Renegotiate),
+                Interop.Ssl.SslErrorCode.SSL_ERROR_ZERO_RETURN => new SecurityStatusPal(SecurityStatusPalErrorCode.ContextExpired),
+                Interop.Ssl.SslErrorCode.SSL_ERROR_NONE or
+                Interop.Ssl.SslErrorCode.SSL_ERROR_WANT_READ => new SecurityStatusPal(SecurityStatusPalErrorCode.OK),
+                _ => new SecurityStatusPal(SecurityStatusPalErrorCode.InternalError, new Interop.OpenSsl.SslException((int)errorCode))
+            };
+
         public static ChannelBinding? QueryContextChannelBinding(SafeDeleteSslContext securityContext, ChannelBindingKind attribute)
         {
             ChannelBinding? bindingHandle;
@@ -155,42 +186,6 @@ private static SecurityStatusPal HandshakeInternal(SafeFreeCredentials credentia
             return Interop.Ssl.SslGetAlpnSelected(context.SslContext);
         }
 
-        private static SecurityStatusPal EncryptDecryptHelper(SafeDeleteSslContext securityContext, ReadOnlyMemory<byte> input, int offset, int size, bool encrypt, ref byte[] output, out int resultSize)
-        {
-            resultSize = 0;
-            try
-            {
-                Interop.Ssl.SslErrorCode errorCode = Interop.Ssl.SslErrorCode.SSL_ERROR_NONE;
-                SafeSslHandle scHandle = securityContext.SslContext;
-
-                if (encrypt)
-                {
-                    resultSize = Interop.OpenSsl.Encrypt(scHandle, input.Span, ref output, out errorCode);
-                }
-                else
-                {
-                    resultSize = Interop.OpenSsl.Decrypt(scHandle, output, offset, size, out errorCode);
-                }
-
-                switch (errorCode)
-                {
-                    case Interop.Ssl.SslErrorCode.SSL_ERROR_RENEGOTIATE:
-                        return new SecurityStatusPal(SecurityStatusPalErrorCode.Renegotiate);
-                    case Interop.Ssl.SslErrorCode.SSL_ERROR_ZERO_RETURN:
-                        return new SecurityStatusPal(SecurityStatusPalErrorCode.ContextExpired);
-                    case Interop.Ssl.SslErrorCode.SSL_ERROR_NONE:
-                    case Interop.Ssl.SslErrorCode.SSL_ERROR_WANT_READ:
-                        return new SecurityStatusPal(SecurityStatusPalErrorCode.OK);
-                    default:
-                        return new SecurityStatusPal(SecurityStatusPalErrorCode.InternalError, new Interop.OpenSsl.SslException((int)errorCode));
-                }
-            }
-            catch (Exception ex)
-            {
-                return new SecurityStatusPal(SecurityStatusPalErrorCode.InternalError, ex);
-            }
-        }
-
         public static SecurityStatusPal ApplyAlertToken(ref SafeFreeCredentials? credentialsHandle, SafeDeleteContext? securityContext, TlsAlertType alertType, TlsAlertMessage alertMessage)
         {
             // There doesn't seem to be an exposed API for writing an alert,
diff --git a/src/libraries/System.Net.Security/tests/FunctionalTests/SslStreamNetworkStreamTest.cs b/src/libraries/System.Net.Security/tests/FunctionalTests/SslStreamNetworkStreamTest.cs
index 957a40d2403755..00fafd6652bf78 100644
--- a/src/libraries/System.Net.Security/tests/FunctionalTests/SslStreamNetworkStreamTest.cs
+++ b/src/libraries/System.Net.Security/tests/FunctionalTests/SslStreamNetworkStreamTest.cs
@@ -243,6 +243,78 @@ await TestConfiguration.WhenAllOrAnyFailedWithTimeout(
             }
         }
 
+        [ConditionalTheory(typeof(PlatformDetection), nameof(PlatformDetection.IsNotWindows7))]
+        [InlineData(true)]
+        [InlineData(false)]
+        [PlatformSpecific(TestPlatforms.Windows)]
+        public async Task SslStream_NegotiateClientCertificateAsyncNoRenego_Succeeds(bool sendClientCertificate)
+        {
+            bool negotiateClientCertificateCalled = false;
+            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"),
+                    EnabledSslProtocols = SslProtocols.Tls | SslProtocols.Tls11 | SslProtocols.Tls12,
+                };
+                clientOptions.RemoteCertificateValidationCallback = (sender, certificate, chain, sslPolicyErrors) => true;
+                clientOptions.LocalCertificateSelectionCallback = (sender, targetHost, localCertificates, remoteCertificate, acceptableIssuers) =>
+                {
+                    return sendClientCertificate ? clientCertificate : null;
+                };
+
+                SslServerAuthenticationOptions serverOptions = new SslServerAuthenticationOptions() { ServerCertificate = serverCertificate,
+                                                                                                      AllowRenegotiation = false  };
+                serverOptions.RemoteCertificateValidationCallback = (sender, certificate, chain, sslPolicyErrors) =>
+                {
+                    if (negotiateClientCertificateCalled && sendClientCertificate)
+                    {
+                        Assert.Equal(clientCertificate.GetCertHash(), certificate?.GetCertHash());
+                    }
+                    else
+                    {
+                        Assert.Null(certificate);
+                    }
+
+                    return true;
+                };
+
+                await TestConfiguration.WhenAllOrAnyFailedWithTimeout(
+                                client.AuthenticateAsClientAsync(clientOptions, cts.Token),
+                                server.AuthenticateAsServerAsync(serverOptions, cts.Token));
+
+                Assert.Null(server.RemoteCertificate);
+
+                // Client needs to be reading for renegotiation to happen.
+                byte[] buffer = new byte[TestHelper.s_ping.Length];
+                ValueTask<int> t = client.ReadAsync(buffer, cts.Token);
+
+                negotiateClientCertificateCalled = true;
+                await server.NegotiateClientCertificateAsync(cts.Token);
+                if (sendClientCertificate)
+                {
+                    Assert.NotNull(server.RemoteCertificate);
+                }
+                else
+                {
+                    Assert.Null(server.RemoteCertificate);
+                }
+                // Finish the client's read
+                await server.WriteAsync(TestHelper.s_ping, cts.Token);
+                await t;
+                // 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)]
         [InlineData(false)]
diff --git a/src/libraries/System.Net.Security/tests/UnitTests/SslAuthenticationOptionsTests.cs b/src/libraries/System.Net.Security/tests/UnitTests/SslAuthenticationOptionsTests.cs
index 6a75b0bf2bf6e1..91d40fc7448373 100644
--- a/src/libraries/System.Net.Security/tests/UnitTests/SslAuthenticationOptionsTests.cs
+++ b/src/libraries/System.Net.Security/tests/UnitTests/SslAuthenticationOptionsTests.cs
@@ -68,7 +68,7 @@ public void LocalCertificateSelectionCallback_Get_Set_Succeeds()
         {
             Assert.Null(_clientOptions.LocalCertificateSelectionCallback);
 
-            LocalCertificateSelectionCallback callback = (sender, host, localCertificates, remoteCertificate, issuers) => { return new X509Certificate(); };
+            LocalCertificateSelectionCallback callback = (sender, host, localCertificates, remoteCertificate, issuers) => default;
             _clientOptions.LocalCertificateSelectionCallback = callback;
 
             Assert.Equal(callback, _clientOptions.LocalCertificateSelectionCallback);
@@ -109,7 +109,7 @@ public void ServerCertificate_Get_Set_Succeeds()
             _serverOptions.ServerCertificate = null;
 
             Assert.Null(_serverOptions.ServerCertificate);
-            X509Certificate cert = new X509Certificate();
+            X509Certificate cert = new X509Certificate2(stackalloc byte[0]);
             _serverOptions.ServerCertificate = cert;
 
             Assert.Equal(cert, _serverOptions.ServerCertificate);
diff --git a/src/libraries/System.Net.Sockets/src/System.Net.Sockets.csproj b/src/libraries/System.Net.Sockets/src/System.Net.Sockets.csproj
index 9f56ca5250a529..35d10bb679f163 100644
--- a/src/libraries/System.Net.Sockets/src/System.Net.Sockets.csproj
+++ b/src/libraries/System.Net.Sockets/src/System.Net.Sockets.csproj
@@ -236,6 +236,8 @@
              Link="Common\Interop\Unix\Interop.Stat.cs" />
     <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.Listen.cs"
              Link="Common\Interop\Unix\System.Native\Interop.Listen.cs" />
+    <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.IOVector.cs"
+             Link="Common\Interop\Unix\System.Native\Interop.IOVector.cs" />
     <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.MessageHeader.cs"
              Link="Common\Interop\Unix\System.Native\Interop.MessageHeader.cs" />
     <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.MulticastOption.cs"
diff --git a/src/libraries/System.Net.Sockets/src/System/Net/Sockets/Socket.cs b/src/libraries/System.Net.Sockets/src/System/Net/Sockets/Socket.cs
index 30b5c05c4979b7..247b02a2431d94 100644
--- a/src/libraries/System.Net.Sockets/src/System/Net/Sockets/Socket.cs
+++ b/src/libraries/System.Net.Sockets/src/System/Net/Sockets/Socket.cs
@@ -52,9 +52,9 @@ public partial class Socket : IDisposable
         // to poll for the real state until we're done connecting.
         private bool _nonBlockingConnectInProgress;
 
-        // Keep track of the kind of endpoint used to do a non-blocking connect, so we can set
-        // it to _rightEndPoint when we discover we're connected.
-        private EndPoint? _nonBlockingConnectRightEndPoint;
+        // Keep track of the kind of endpoint used to do a connect, so we can set
+        // it to _rightEndPoint when we're connected.
+        private EndPoint? _pendingConnectRightEndPoint;
 
         // These are constants initialized by constructor.
         private AddressFamily _addressFamily;
@@ -285,11 +285,8 @@ public EndPoint? LocalEndPoint
 
                 if (_nonBlockingConnectInProgress && Poll(0, SelectMode.SelectWrite))
                 {
-                    // Update the state if we've become connected after a non-blocking connect.
-                    _isConnected = true;
-                    _rightEndPoint ??= _nonBlockingConnectRightEndPoint;
-                    UpdateLocalEndPointOnConnect();
                     _nonBlockingConnectInProgress = false;
+                    SetToConnected();
                 }
 
                 if (_rightEndPoint == null)
@@ -332,11 +329,9 @@ public EndPoint? RemoteEndPoint
                 {
                     if (_nonBlockingConnectInProgress && Poll(0, SelectMode.SelectWrite))
                     {
-                        // Update the state if we've become connected after a non-blocking connect.
-                        _isConnected = true;
-                        _rightEndPoint ??= _nonBlockingConnectRightEndPoint;
-                        UpdateLocalEndPointOnConnect();
                         _nonBlockingConnectInProgress = false;
+                        // Update the state if we've become connected after a non-blocking connect.
+                        SetToConnected();
                     }
 
                     if (_rightEndPoint == null || !_isConnected)
@@ -439,11 +434,9 @@ public bool Connected
 
                 if (_nonBlockingConnectInProgress && Poll(0, SelectMode.SelectWrite))
                 {
-                    // Update the state if we've become connected after a non-blocking connect.
-                    _isConnected = true;
-                    _rightEndPoint ??= _nonBlockingConnectRightEndPoint;
-                    UpdateLocalEndPointOnConnect();
                     _nonBlockingConnectInProgress = false;
+                    // Update the state if we've become connected after a non-blocking connect.
+                    SetToConnected();
                 }
 
                 return _isConnected;
@@ -856,12 +849,8 @@ public void Connect(EndPoint remoteEP)
             ValidateForMultiConnect(isMultiEndpoint: false);
 
             Internals.SocketAddress socketAddress = Serialize(ref remoteEP);
-
-            if (!Blocking)
-            {
-                _nonBlockingConnectRightEndPoint = remoteEP;
-                _nonBlockingConnectInProgress = true;
-            }
+            _pendingConnectRightEndPoint = remoteEP;
+            _nonBlockingConnectInProgress = !Blocking;
 
             DoConnect(remoteEP, socketAddress);
         }
@@ -2768,13 +2757,11 @@ internal bool ConnectAsync(SocketAsyncEventArgs e, bool userSocket, bool saeaCan
                 }
 
                 e._socketAddress = Serialize(ref endPointSnapshot);
+                _pendingConnectRightEndPoint = endPointSnapshot;
+                _nonBlockingConnectInProgress = false;
 
                 WildcardBindForConnectIfNecessary(endPointSnapshot.AddressFamily);
 
-                // Save the old RightEndPoint and prep new RightEndPoint.
-                EndPoint? oldEndPoint = _rightEndPoint;
-                _rightEndPoint ??= endPointSnapshot;
-
                 if (SocketsTelemetry.Log.IsEnabled())
                 {
                     SocketsTelemetry.Log.ConnectStart(e._socketAddress!);
@@ -2801,7 +2788,6 @@ internal bool ConnectAsync(SocketAsyncEventArgs e, bool userSocket, bool saeaCan
                         SocketsTelemetry.Log.AfterConnect(SocketError.NotSocket, ex.Message);
                     }
 
-                    _rightEndPoint = oldEndPoint;
                     _localEndPoint = null;
 
                     // Clear in-use flag on event args object.
@@ -3217,12 +3203,11 @@ private void DoConnect(EndPoint endPointSnapshot, Internals.SocketAddress socket
 
             if (SocketsTelemetry.Log.IsEnabled()) SocketsTelemetry.Log.AfterConnect(SocketError.Success);
 
-            // Save a copy of the EndPoint so we can use it for Create().
-            _rightEndPoint ??= endPointSnapshot;
-
             if (NetEventSource.Log.IsEnabled()) NetEventSource.Info(this, $"connection to:{endPointSnapshot}");
 
             // Update state and performance counters.
+            _pendingConnectRightEndPoint = endPointSnapshot;
+            _nonBlockingConnectInProgress = false;
             SetToConnected();
             if (NetEventSource.Log.IsEnabled()) NetEventSource.Connected(this, LocalEndPoint, RemoteEndPoint);
         }
@@ -3659,10 +3644,14 @@ internal void SetToConnected()
                 return;
             }
 
+            Debug.Assert(_nonBlockingConnectInProgress == false);
+
             // Update the status: this socket was indeed connected at
             // some point in time update the perf counter as well.
             _isConnected = true;
             _isDisconnected = false;
+            _rightEndPoint ??= _pendingConnectRightEndPoint;
+            _pendingConnectRightEndPoint = null;
             UpdateLocalEndPointOnConnect();
             if (NetEventSource.Log.IsEnabled()) NetEventSource.Info(this, "now connected");
         }
diff --git a/src/libraries/System.Net.Sockets/src/System/Net/Sockets/SocketAsyncContext.Unix.cs b/src/libraries/System.Net.Sockets/src/System/Net/Sockets/SocketAsyncContext.Unix.cs
index a9bf3de2cc56a6..3a9066db918a0f 100644
--- a/src/libraries/System.Net.Sockets/src/System/Net/Sockets/SocketAsyncContext.Unix.cs
+++ b/src/libraries/System.Net.Sockets/src/System/Net/Sockets/SocketAsyncContext.Unix.cs
@@ -113,9 +113,10 @@ private abstract class AsyncOperation : IThreadPoolWorkItem
             private enum State
             {
                 Waiting = 0,
-                Running = 1,
-                Complete = 2,
-                Cancelled = 3
+                Running,
+                RunningWithPendingCancellation,
+                Complete,
+                Canceled
             }
 
             private int _state; // Actually AsyncOperation.State.
@@ -149,92 +150,103 @@ public void Reset()
 #endif
             }
 
-            public bool TryComplete(SocketAsyncContext context)
+            public OperationResult TryComplete(SocketAsyncContext context)
             {
                 TraceWithContext(context, "Enter");
 
-                bool result = DoTryComplete(context);
-
-                TraceWithContext(context, $"Exit, result={result}");
+                // Set state to Running, unless we've been canceled
+                int oldState = Interlocked.CompareExchange(ref _state, (int)State.Running, (int)State.Waiting);
+                if (oldState == (int)State.Canceled)
+                {
+                    TraceWithContext(context, "Exit, Previously canceled");
+                    return OperationResult.Cancelled;
+                }
 
-                return result;
-            }
+                Debug.Assert(oldState == (int)State.Waiting, $"Unexpected operation state: {(State)oldState}");
 
-            public bool TrySetRunning()
-            {
-                State oldState = (State)Interlocked.CompareExchange(ref _state, (int)State.Running, (int)State.Waiting);
-                if (oldState == State.Cancelled)
+                // Try to perform the IO
+                if (DoTryComplete(context))
                 {
-                    // This operation has already been cancelled, and had its completion processed.
-                    // Simply return false to indicate no further processing is needed.
-                    return false;
+                    Debug.Assert((State)Volatile.Read(ref _state) is State.Running or State.RunningWithPendingCancellation, "Unexpected operation state");
+
+                    Volatile.Write(ref _state, (int)State.Complete);
+
+                    TraceWithContext(context, "Exit, Completed");
+                    return OperationResult.Completed;
                 }
 
-                Debug.Assert(oldState == (int)State.Waiting);
-                return true;
-            }
+                // Set state back to Waiting, unless we were canceled, in which case we have to process cancellation now
+                int newState;
+                while (true)
+                {
+                    int state = Volatile.Read(ref _state);
+                    Debug.Assert(state is (int)State.Running or (int)State.RunningWithPendingCancellation, $"Unexpected operation state: {(State)state}");
 
-            public void SetComplete()
-            {
-                Debug.Assert(Volatile.Read(ref _state) == (int)State.Running);
+                    newState = (state == (int)State.Running ? (int)State.Waiting : (int)State.Canceled);
+                    if (state == Interlocked.CompareExchange(ref _state, newState, state))
+                    {
+                        break;
+                    }
 
-                Volatile.Write(ref _state, (int)State.Complete);
-            }
+                    // Race to update the state. Loop and try again.
+                }
 
-            public void SetWaiting()
-            {
-                Debug.Assert(Volatile.Read(ref _state) == (int)State.Running);
+                if (newState == (int)State.Canceled)
+                {
+                    ProcessCancellation();
+                    TraceWithContext(context, "Exit, Newly cancelled");
+                    return OperationResult.Cancelled;
+                }
 
-                Volatile.Write(ref _state, (int)State.Waiting);
+                TraceWithContext(context, "Exit, Pending");
+                return OperationResult.Pending;
             }
 
             public bool TryCancel()
             {
                 Trace("Enter");
 
-                // We're already canceling, so we don't need to still be hooked up to listen to cancellation.
-                // The cancellation request could also be caused by something other than the token, so it's
-                // important we clean it up, regardless.
+                // Note we could be cancelling because of socket close. Regardless, we don't need the registration anymore.
                 CancellationRegistration.Dispose();
 
-                // Try to transition from Waiting to Cancelled
-                SpinWait spinWait = default;
-                bool keepWaiting = true;
-                while (keepWaiting)
+                int newState;
+                while (true)
                 {
-                    int state = Interlocked.CompareExchange(ref _state, (int)State.Cancelled, (int)State.Waiting);
-                    switch ((State)state)
+                    int state = Volatile.Read(ref _state);
+                    if (state is (int)State.Complete or (int)State.Canceled or (int)State.RunningWithPendingCancellation)
                     {
-                        case State.Running:
-                            // A completion attempt is in progress. Keep busy-waiting.
-                            Trace("Busy wait");
-                            spinWait.SpinOnce();
-                            break;
+                        return false;
+                    }
 
-                        case State.Complete:
-                            // A completion attempt succeeded. Consider this operation as having completed within the timeout.
-                            Trace("Exit, previously completed");
-                            return false;
+                    newState = (state == (int)State.Waiting ? (int)State.Canceled : (int)State.RunningWithPendingCancellation);
+                    if (state == Interlocked.CompareExchange(ref _state, newState, state))
+                    {
+                        break;
+                    }
 
-                        case State.Waiting:
-                            // This operation was successfully cancelled.
-                            // Break out of the loop to handle the cancellation
-                            keepWaiting = false;
-                            break;
+                    // Race to update the state. Loop and try again.
+                }
 
-                        case State.Cancelled:
-                            // Someone else cancelled the operation.
-                            // The previous canceller will have fired the completion, etc.
-                            Trace("Exit, previously cancelled");
-                            return false;
-                    }
+                if (newState == (int)State.RunningWithPendingCancellation)
+                {
+                    // TryComplete will either succeed, or it will see the pending cancellation and deal with it.
+                    return false;
                 }
 
-                Trace("Cancelled, processing completion");
+                ProcessCancellation();
 
-                // The operation successfully cancelled.
-                // It's our responsibility to set the error code and queue the completion.
-                DoAbort();
+                // Note, we leave the operation in the OperationQueue.
+                // When we get around to processing it, we'll see it's cancelled and skip it.
+                return true;
+            }
+
+            public void ProcessCancellation()
+            {
+                Trace("Enter");
+
+                Debug.Assert(_state == (int)State.Canceled);
+
+                ErrorCode = SocketError.OperationAborted;
 
                 ManualResetEventSlim? e = Event;
                 if (e != null)
@@ -252,12 +264,6 @@ public bool TryCancel()
                     // to do further processing on the item that's still in the list.
                     ThreadPool.UnsafeQueueUserWorkItem(o => ((AsyncOperation)o!).InvokeCallback(allowPooling: false), this);
                 }
-
-                Trace("Exit");
-
-                // Note, we leave the operation in the OperationQueue.
-                // When we get around to processing it, we'll see it's cancelled and skip it.
-                return true;
             }
 
             public void Dispatch()
@@ -306,12 +312,9 @@ void IThreadPoolWorkItem.Execute()
             // Called when op is not in the queue yet, so can't be otherwise executing
             public void DoAbort()
             {
-                Abort();
                 ErrorCode = SocketError.OperationAborted;
             }
 
-            protected abstract void Abort();
-
             protected abstract bool DoTryComplete(SocketAsyncContext context);
 
             public abstract void InvokeCallback(bool allowPooling);
@@ -354,8 +357,6 @@ private abstract class SendOperation : WriteOperation
 
             public SendOperation(SocketAsyncContext context) : base(context) { }
 
-            protected sealed override void Abort() { }
-
             public Action<int, byte[]?, int, SocketFlags, SocketError>? Callback { get; set; }
 
             public override void InvokeCallback(bool allowPooling) =>
@@ -442,8 +443,6 @@ private abstract class ReceiveOperation : ReadOperation
 
             public ReceiveOperation(SocketAsyncContext context) : base(context) { }
 
-            protected sealed override void Abort() { }
-
             public Action<int, byte[]?, int, SocketFlags, SocketError>? Callback { get; set; }
 
             public override void InvokeCallback(bool allowPooling) =>
@@ -554,8 +553,6 @@ private sealed class ReceiveMessageFromOperation : ReadOperation
 
             public ReceiveMessageFromOperation(SocketAsyncContext context) : base(context) { }
 
-            protected sealed override void Abort() { }
-
             public Action<int, byte[], int, SocketFlags, IPPacketInformation, SocketError>? Callback { get; set; }
 
             protected override bool DoTryComplete(SocketAsyncContext context) =>
@@ -579,8 +576,6 @@ private sealed unsafe class BufferPtrReceiveMessageFromOperation : ReadOperation
 
             public BufferPtrReceiveMessageFromOperation(SocketAsyncContext context) : base(context) { }
 
-            protected sealed override void Abort() { }
-
             public Action<int, byte[], int, SocketFlags, IPPacketInformation, SocketError>? Callback { get; set; }
 
             protected override bool DoTryComplete(SocketAsyncContext context) =>
@@ -598,9 +593,6 @@ public AcceptOperation(SocketAsyncContext context) : base(context) { }
 
             public Action<IntPtr, byte[], int, SocketError>? Callback { get; set; }
 
-            protected override void Abort() =>
-                AcceptedFileDescriptor = (IntPtr)(-1);
-
             protected override bool DoTryComplete(SocketAsyncContext context)
             {
                 bool completed = SocketPal.TryCompleteAccept(context._socket, SocketAddress!, ref SocketAddressLen, out AcceptedFileDescriptor, out ErrorCode);
@@ -631,8 +623,6 @@ public ConnectOperation(SocketAsyncContext context) : base(context) { }
 
             public Action<SocketError>? Callback { get; set; }
 
-            protected override void Abort() { }
-
             protected override bool DoTryComplete(SocketAsyncContext context)
             {
                 bool result = SocketPal.TryCompleteConnect(context._socket, SocketAddressLen, out ErrorCode);
@@ -653,8 +643,6 @@ private sealed class SendFileOperation : WriteOperation
 
             public SendFileOperation(SocketAsyncContext context) : base(context) { }
 
-            protected override void Abort() { }
-
             public Action<long, SocketError>? Callback { get; set; }
 
             public override void InvokeCallback(bool allowPooling) =>
@@ -694,6 +682,13 @@ public void Dispose()
             }
         }
 
+        public enum OperationResult
+        {
+            Pending = 0,
+            Completed = 1,
+            Cancelled = 2
+        }
+
         private struct OperationQueue<TOperation>
             where TOperation : AsyncOperation
         {
@@ -864,7 +859,7 @@ public bool StartAsyncOperation(SocketAsyncContext context, TOperation operation
                     }
 
                     // Retry the operation.
-                    if (operation.TryComplete(context))
+                    if (operation.TryComplete(context) != OperationResult.Pending)
                     {
                         Trace(context, $"Leave, retry succeeded");
                         return false;
@@ -880,7 +875,7 @@ static void HandleFailedRegistration(SocketAsyncContext context, TOperation oper
                     {
                         // Because the other end close, we expect the operation to complete when we retry it.
                         // If it doesn't, we fall through and throw an Exception.
-                        if (operation.TryComplete(context))
+                        if (operation.TryComplete(context) != OperationResult.Pending)
                         {
                             return;
                         }
@@ -979,13 +974,6 @@ internal void ProcessAsyncOperation(TOperation op)
                 }
             }
 
-            public enum OperationResult
-            {
-                Pending = 0,
-                Completed = 1,
-                Cancelled = 2
-            }
-
             public OperationResult ProcessQueuedOperation(TOperation op)
             {
                 SocketAsyncContext context = op.AssociatedContext;
@@ -1010,27 +998,15 @@ public OperationResult ProcessQueuedOperation(TOperation op)
                     }
                 }
 
-                bool wasCompleted = false;
+                OperationResult result;
                 while (true)
                 {
-                    // Try to change the op state to Running.
-                    // If this fails, it means the operation was previously cancelled,
-                    // and we should just remove it from the queue without further processing.
-                    if (!op.TrySetRunning())
-                    {
-                        break;
-                    }
-
-                    // Try to perform the IO
-                    if (op.TryComplete(context))
+                    result = op.TryComplete(context);
+                    if (result != OperationResult.Pending)
                     {
-                        op.SetComplete();
-                        wasCompleted = true;
                         break;
                     }
 
-                    op.SetWaiting();
-
                     // Check for retry and reset queue state.
 
                     using (Lock())
@@ -1097,7 +1073,8 @@ public OperationResult ProcessQueuedOperation(TOperation op)
 
                 nextOp?.Dispatch();
 
-                return (wasCompleted ? OperationResult.Completed : OperationResult.Cancelled);
+                Debug.Assert(result != OperationResult.Pending);
+                return result;
             }
 
             public void CancelAndContinueProcessing(TOperation op)
@@ -1360,9 +1337,9 @@ private void PerformSyncOperation<TOperation>(ref OperationQueue<TOperation> que
                     e.Reset();
 
                     // We've been signalled to try to process the operation.
-                    OperationQueue<TOperation>.OperationResult result = queue.ProcessQueuedOperation(operation);
-                    if (result == OperationQueue<TOperation>.OperationResult.Completed ||
-                        result == OperationQueue<TOperation>.OperationResult.Cancelled)
+                    OperationResult result = queue.ProcessQueuedOperation(operation);
+                    if (result == OperationResult.Completed ||
+                        result == OperationResult.Cancelled)
                     {
                         break;
                     }
diff --git a/src/libraries/System.Net.Sockets/tests/FunctionalTests/Connect.cs b/src/libraries/System.Net.Sockets/tests/FunctionalTests/Connect.cs
index d31cf2d43c4789..5f9730e8ab076c 100644
--- a/src/libraries/System.Net.Sockets/tests/FunctionalTests/Connect.cs
+++ b/src/libraries/System.Net.Sockets/tests/FunctionalTests/Connect.cs
@@ -83,6 +83,60 @@ public async Task Connect_MultipleIPAddresses_Success(IPAddress listenAt)
             }
         }
 
+        [Fact]
+        public async Task Connect_DualMode_MultiAddressFamilyConnect_RetrievedEndPoints_Success()
+        {
+            if (!SupportsMultiConnect)
+                return;
+
+            int port;
+            using (SocketTestServer.SocketTestServerFactory(SocketImplementationType.Async, IPAddress.Loopback, out port))
+            using (Socket client = new Socket(SocketType.Stream, ProtocolType.Tcp))
+            {
+                Assert.True(client.DualMode);
+
+                Task connectTask = MultiConnectAsync(client, new IPAddress[] { IPAddress.IPv6Loopback, IPAddress.Loopback }, port);
+                await connectTask;
+
+                var localEndPoint = client.LocalEndPoint as IPEndPoint;
+                Assert.NotNull(localEndPoint);
+                Assert.Equal(IPAddress.Loopback.MapToIPv6(), localEndPoint.Address);
+
+                var remoteEndPoint = client.RemoteEndPoint as IPEndPoint;
+                Assert.NotNull(remoteEndPoint);
+                Assert.Equal(IPAddress.Loopback.MapToIPv6(), remoteEndPoint.Address);
+            }
+        }
+
+        [Fact]
+        public async Task Connect_DualMode_DnsConnect_RetrievedEndPoints_Success()
+        {
+            var localhostAddresses = Dns.GetHostAddresses("localhost");
+            if (Array.IndexOf(localhostAddresses, IPAddress.Loopback) == -1 ||
+                Array.IndexOf(localhostAddresses, IPAddress.IPv6Loopback) == -1)
+            {
+                return;
+            }
+
+            int port;
+            using (SocketTestServer.SocketTestServerFactory(SocketImplementationType.Async, IPAddress.Loopback, out port))
+            using (Socket client = new Socket(SocketType.Stream, ProtocolType.Tcp))
+            {
+                Assert.True(client.DualMode);
+
+                Task connectTask = ConnectAsync(client, new DnsEndPoint("localhost", port));
+                await connectTask;
+
+                var localEndPoint = client.LocalEndPoint as IPEndPoint;
+                Assert.NotNull(localEndPoint);
+                Assert.Equal(IPAddress.Loopback.MapToIPv6(), localEndPoint.Address);
+
+                var remoteEndPoint = client.RemoteEndPoint as IPEndPoint;
+                Assert.NotNull(remoteEndPoint);
+                Assert.Equal(IPAddress.Loopback.MapToIPv6(), remoteEndPoint.Address);
+            }
+        }
+
         [Fact]
         public async Task Connect_OnConnectedSocket_Fails()
         {
diff --git a/src/libraries/System.Net.Sockets/tests/FunctionalTests/SendReceive/SendReceive.cs b/src/libraries/System.Net.Sockets/tests/FunctionalTests/SendReceive/SendReceive.cs
index 053bc0a2feec22..4d43977fa2b3cf 100644
--- a/src/libraries/System.Net.Sockets/tests/FunctionalTests/SendReceive/SendReceive.cs
+++ b/src/libraries/System.Net.Sockets/tests/FunctionalTests/SendReceive/SendReceive.cs
@@ -952,7 +952,8 @@ await RetryHelper.ExecuteAsync(async () =>
                 msDelay *= 2;
                 Task disposeTask = Task.Run(() => socket.Dispose());
 
-                await Task.WhenAny(disposeTask, receiveTask).WaitAsync(TimeSpan.FromSeconds(30));
+                await Task.WhenAny(disposeTask, receiveTask)
+                          .WaitAsync(TimeSpan.FromMilliseconds(TestSettings.PassingTestTimeout));
                 await disposeTask;
 
                 SocketError? localSocketError = null;
@@ -996,7 +997,7 @@ await RetryHelper.ExecuteAsync(async () =>
             { false, true, false },
         };
 
-        [Theory(Timeout = 40000)]
+        [Theory]
         [MemberData(nameof(TcpReceiveSendGetsCanceledByDispose_Data))]
         [ActiveIssue("https://github.com/dotnet/runtime/issues/50568", TestPlatforms.Android)]
         public async Task TcpReceiveSendGetsCanceledByDispose(bool receiveOrSend, bool ipv6Server, bool dualModeClient)
@@ -1028,7 +1029,9 @@ await RetryHelper.ExecuteAsync(async () =>
                             var buffer = new ArraySegment<byte>(new byte[4096]);
                             while (true)
                             {
-                                SendAsync(socket1, buffer).GetAwaiter().GetResult();
+                                SendAsync(socket1, buffer)
+                                    .WaitAsync(TimeSpan.FromMilliseconds(TestSettings.PassingTestTimeout))
+                                    .GetAwaiter().GetResult();
                             }
                         });
                     }
@@ -1038,14 +1041,17 @@ await RetryHelper.ExecuteAsync(async () =>
                     msDelay *= 2;
                     Task disposeTask = Task.Run(() => socket1.Dispose());
 
-                    await Task.WhenAny(disposeTask, socketOperation).WaitAsync(TimeSpan.FromSeconds(30));
-                    await disposeTask;
+                    await Task.WhenAny(disposeTask, socketOperation)
+                              .WaitAsync(TimeSpan.FromMilliseconds(TestSettings.PassingTestTimeout));
+                    await disposeTask
+                              .WaitAsync(TimeSpan.FromMilliseconds(TestSettings.PassingTestTimeout));
 
                     SocketError? localSocketError = null;
                     bool disposedException = false;
                     try
                     {
-                        await socketOperation;
+                        await socketOperation
+                              .WaitAsync(TimeSpan.FromMilliseconds(TestSettings.PassingTestTimeout));
                     }
                     catch (SocketException se)
                     {
@@ -1080,7 +1086,8 @@ await RetryHelper.ExecuteAsync(async () =>
                         {
                             try
                             {
-                                int received = await ReceiveAsync(socket2, receiveBuffer);
+                                int received = await ReceiveAsync(socket2, receiveBuffer)
+                                                     .WaitAsync(TimeSpan.FromMilliseconds(TestSettings.PassingTestTimeout));
                                 if (received == 0)
                                 {
                                     break;
diff --git a/src/libraries/System.Net.Sockets/tests/FunctionalTests/SocketTaskExtensionsTest.cs b/src/libraries/System.Net.Sockets/tests/FunctionalTests/SocketTaskExtensionsTest.cs
index bdc7ec7e3ef0f3..c53ab9583230f4 100644
--- a/src/libraries/System.Net.Sockets/tests/FunctionalTests/SocketTaskExtensionsTest.cs
+++ b/src/libraries/System.Net.Sockets/tests/FunctionalTests/SocketTaskExtensionsTest.cs
@@ -23,6 +23,9 @@ public async Task EnsureMethodsAreCallable()
             await Assert.ThrowsAsync<InvalidOperationException>(async () => await SocketTaskExtensions.AcceptAsync(s));
             await Assert.ThrowsAsync<InvalidOperationException>(async () => await SocketTaskExtensions.AcceptAsync(s, null));
 
+            await Assert.ThrowsAsync<InvalidOperationException>(async () => await SocketTaskExtensions.ReceiveFromAsync(s, new ArraySegment<byte>(buffer), SocketFlags.None, badEndPoint));
+            await Assert.ThrowsAsync<InvalidOperationException>(async () => await SocketTaskExtensions.ReceiveMessageFromAsync(s, new ArraySegment<byte>(buffer), SocketFlags.None, badEndPoint));
+
             await Assert.ThrowsAsync<SocketException>(async () => await SocketTaskExtensions.ConnectAsync(s, badEndPoint));
             await Assert.ThrowsAsync<SocketException>(async () => await SocketTaskExtensions.ConnectAsync(s, badEndPoint, CancellationToken.None));
             await Assert.ThrowsAsync<SocketException>(async () => await SocketTaskExtensions.ConnectAsync(s, badEndPoint.Address, badEndPoint.Port));
@@ -35,8 +38,6 @@ public async Task EnsureMethodsAreCallable()
             await Assert.ThrowsAsync<SocketException>(async () => await SocketTaskExtensions.ReceiveAsync(s, new ArraySegment<byte>(buffer), SocketFlags.None));
             await Assert.ThrowsAsync<SocketException>(async () => await SocketTaskExtensions.ReceiveAsync(s, buffer.AsMemory(), SocketFlags.None));
             await Assert.ThrowsAsync<SocketException>(async () => await SocketTaskExtensions.ReceiveAsync(s, new ArraySegment<byte>[] { new ArraySegment<byte>(buffer) }, SocketFlags.None));
-            await Assert.ThrowsAsync<SocketException>(async () => await SocketTaskExtensions.ReceiveFromAsync(s, new ArraySegment<byte>(buffer), SocketFlags.None, badEndPoint));
-            await Assert.ThrowsAsync<SocketException>(async () => await SocketTaskExtensions.ReceiveMessageFromAsync(s, new ArraySegment<byte>(buffer), SocketFlags.None, badEndPoint));
 
             await Assert.ThrowsAsync<SocketException>(async () => await SocketTaskExtensions.SendAsync(s, new ArraySegment<byte>(buffer), SocketFlags.None));
             await Assert.ThrowsAsync<SocketException>(async () => await SocketTaskExtensions.SendAsync(s, buffer.AsMemory(), SocketFlags.None));
diff --git a/src/libraries/System.Net.WebClient/src/System/Net/WebClient.cs b/src/libraries/System.Net.WebClient/src/System/Net/WebClient.cs
index 4c7dbd63f5d58e..0c32b6d906d2a1 100644
--- a/src/libraries/System.Net.WebClient/src/System/Net/WebClient.cs
+++ b/src/libraries/System.Net.WebClient/src/System/Net/WebClient.cs
@@ -8,7 +8,6 @@
 using System.Globalization;
 using System.IO;
 using System.Net.Cache;
-using System.Net.Http;
 using System.Security;
 using System.Text;
 using System.Threading;
diff --git a/src/libraries/System.Net.WebSockets.Client/src/System/Net/WebSockets/BrowserWebSockets/BrowserWebSocket.cs b/src/libraries/System.Net.WebSockets.Client/src/System/Net/WebSockets/BrowserWebSockets/BrowserWebSocket.cs
index ac05989f6ea862..0eae170576a7d6 100644
--- a/src/libraries/System.Net.WebSockets.Client/src/System/Net/WebSockets/BrowserWebSockets/BrowserWebSocket.cs
+++ b/src/libraries/System.Net.WebSockets.Client/src/System/Net/WebSockets/BrowserWebSockets/BrowserWebSocket.cs
@@ -1,7 +1,6 @@
 // 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.Concurrent;
 using System.Collections.Generic;
 using System.IO;
 using System.Text;
diff --git a/src/libraries/System.Net.WebSockets.Client/src/System/Net/WebSockets/WebSocketHandle.Managed.cs b/src/libraries/System.Net.WebSockets.Client/src/System/Net/WebSockets/WebSocketHandle.Managed.cs
index e0c3902a915909..0af0cd5fb145c7 100644
--- a/src/libraries/System.Net.WebSockets.Client/src/System/Net/WebSockets/WebSocketHandle.Managed.cs
+++ b/src/libraries/System.Net.WebSockets.Client/src/System/Net/WebSockets/WebSocketHandle.Managed.cs
@@ -411,17 +411,24 @@ private static KeyValuePair<string, string> CreateSecKeyAndSecWebSocketAccept()
 
         private static void ValidateHeader(HttpHeaders headers, string name, string expectedValue)
         {
-            if (!headers.TryGetValues(name, out IEnumerable<string>? values))
+            if (headers.NonValidated.TryGetValues(name, out HeaderStringValues hsv))
             {
-                throw new WebSocketException(WebSocketError.Faulted, SR.Format(SR.net_WebSockets_MissingResponseHeader, name));
-            }
+                if (hsv.Count == 1)
+                {
+                    foreach (string value in hsv)
+                    {
+                        if (string.Equals(value, expectedValue, StringComparison.OrdinalIgnoreCase))
+                        {
+                            return;
+                        }
+                        break;
+                    }
+                }
 
-            Debug.Assert(values is string[]);
-            string[] array = (string[])values;
-            if (array.Length != 1 || !string.Equals(array[0], expectedValue, StringComparison.OrdinalIgnoreCase))
-            {
-                throw new WebSocketException(WebSocketError.HeaderError, SR.Format(SR.net_WebSockets_InvalidResponseHeader, name, string.Join(", ", array)));
+                throw new WebSocketException(WebSocketError.HeaderError, SR.Format(SR.net_WebSockets_InvalidResponseHeader, name, hsv));
             }
+
+            throw new WebSocketException(WebSocketError.Faulted, SR.Format(SR.net_WebSockets_MissingResponseHeader, name));
         }
 
         /// <summary>Used as a sentinel to indicate that ClientWebSocket should use the system's default proxy.</summary>
diff --git a/src/libraries/System.Net.WebSockets.Client/tests/CancelTest.cs b/src/libraries/System.Net.WebSockets.Client/tests/CancelTest.cs
index 8c74513e0a0c8a..da80a1678346b9 100644
--- a/src/libraries/System.Net.WebSockets.Client/tests/CancelTest.cs
+++ b/src/libraries/System.Net.WebSockets.Client/tests/CancelTest.cs
@@ -13,7 +13,7 @@ public class CancelTest : ClientWebSocketTestBase
     {
         public CancelTest(ITestOutputHelper output) : base(output) { }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [ConditionalTheory(nameof(WebSocketsSupported)), MemberData(nameof(EchoServers))]
         public async Task ConnectAsync_Cancel_ThrowsCancellationException(Uri server)
         {
@@ -29,7 +29,7 @@ public async Task ConnectAsync_Cancel_ThrowsCancellationException(Uri server)
             }
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [ConditionalTheory(nameof(WebSocketsSupported)), MemberData(nameof(EchoServers))]
         public async Task SendAsync_Cancel_Success(Uri server)
         {
@@ -44,7 +44,7 @@ await TestCancellation((cws) =>
             }, server);
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [ConditionalTheory(nameof(WebSocketsSupported)), MemberData(nameof(EchoServers))]
         [ActiveIssue("https://github.com/dotnet/runtime/issues/19217")]
         public async Task ReceiveAsync_Cancel_Success(Uri server)
@@ -67,7 +67,7 @@ await cws.SendAsync(
             }, server);
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [ConditionalTheory(nameof(WebSocketsSupported)), MemberData(nameof(EchoServers))]
         public async Task CloseAsync_Cancel_Success(Uri server)
         {
@@ -89,7 +89,7 @@ await cws.SendAsync(
             }, server);
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [ConditionalTheory(nameof(WebSocketsSupported)), MemberData(nameof(EchoServers))]
         public async Task CloseOutputAsync_Cancel_Success(Uri server)
         {
@@ -112,7 +112,7 @@ await cws.SendAsync(
             }, server);
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [ConditionalTheory(nameof(WebSocketsSupported)), MemberData(nameof(EchoServers))]
         public async Task ReceiveAsync_CancelThenReceive_ThrowsOperationCanceledException(Uri server)
         {
@@ -128,7 +128,7 @@ public async Task ReceiveAsync_CancelThenReceive_ThrowsOperationCanceledExceptio
             }
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [ConditionalTheory(nameof(WebSocketsSupported)), MemberData(nameof(EchoServers))]
         public async Task ReceiveAsync_ReceiveThenCancel_ThrowsOperationCanceledException(Uri server)
         {
@@ -144,7 +144,7 @@ public async Task ReceiveAsync_ReceiveThenCancel_ThrowsOperationCanceledExceptio
             }
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [ConditionalTheory(nameof(WebSocketsSupported)), MemberData(nameof(EchoServers))]
         public async Task ReceiveAsync_AfterCancellationDoReceiveAsync_ThrowsWebSocketException(Uri server)
         {
diff --git a/src/libraries/System.Net.WebSockets.Client/tests/CloseTest.cs b/src/libraries/System.Net.WebSockets.Client/tests/CloseTest.cs
index bee31155b396fb..a10e9e4639e713 100644
--- a/src/libraries/System.Net.WebSockets.Client/tests/CloseTest.cs
+++ b/src/libraries/System.Net.WebSockets.Client/tests/CloseTest.cs
@@ -18,7 +18,7 @@ public class CloseTest : ClientWebSocketTestBase
         public CloseTest(ITestOutputHelper output) : base(output) { }
 
         [ActiveIssue("https://github.com/dotnet/runtime/issues/28957")]
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [ConditionalTheory(nameof(WebSocketsSupported)), MemberData(nameof(EchoServersAndBoolean))]
         public async Task CloseAsync_ServerInitiatedClose_Success(Uri server, bool useCloseOutputAsync)
         {
@@ -65,7 +65,7 @@ await cws.SendAsync(
             }
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [ConditionalTheory(nameof(WebSocketsSupported)), MemberData(nameof(EchoServers))]
         public async Task CloseAsync_ClientInitiatedClose_Success(Uri server)
         {
@@ -87,7 +87,7 @@ public async Task CloseAsync_ClientInitiatedClose_Success(Uri server)
             }
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [ConditionalTheory(nameof(WebSocketsSupported)), MemberData(nameof(EchoServers))]
         public async Task CloseAsync_CloseDescriptionIsMaxLength_Success(Uri server)
         {
@@ -101,7 +101,7 @@ public async Task CloseAsync_CloseDescriptionIsMaxLength_Success(Uri server)
             }
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [ConditionalTheory(nameof(WebSocketsSupported)), MemberData(nameof(EchoServers))]
         public async Task CloseAsync_CloseDescriptionIsMaxLengthPlusOne_ThrowsArgumentException(Uri server)
         {
@@ -126,7 +126,7 @@ public async Task CloseAsync_CloseDescriptionIsMaxLengthPlusOne_ThrowsArgumentEx
             }
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [ConditionalTheory(nameof(WebSocketsSupported)), MemberData(nameof(EchoServers))]
         public async Task CloseAsync_CloseDescriptionHasUnicode_Success(Uri server)
         {
@@ -145,7 +145,7 @@ public async Task CloseAsync_CloseDescriptionHasUnicode_Success(Uri server)
             }
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [ConditionalTheory(nameof(WebSocketsSupported)), MemberData(nameof(EchoServers))]
         public async Task CloseAsync_CloseDescriptionIsNull_Success(Uri server)
         {
@@ -161,7 +161,7 @@ public async Task CloseAsync_CloseDescriptionIsNull_Success(Uri server)
             }
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [ConditionalTheory(nameof(WebSocketsSupported)), MemberData(nameof(EchoServers))]
         public async Task CloseOutputAsync_ExpectedStates(Uri server)
         {
@@ -180,7 +180,7 @@ public async Task CloseOutputAsync_ExpectedStates(Uri server)
             }
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [ConditionalTheory(nameof(WebSocketsSupported)), MemberData(nameof(EchoServers))]
         public async Task CloseAsync_CloseOutputAsync_Throws(Uri server)
         {
@@ -205,7 +205,7 @@ await Assert.ThrowsAnyAsync<WebSocketException>(async () =>
             }
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [ConditionalTheory(nameof(WebSocketsSupported)), MemberData(nameof(EchoServers))]
         public async Task CloseOutputAsync_ClientInitiated_CanReceive_CanClose(Uri server)
         {
@@ -245,7 +245,7 @@ public async Task CloseOutputAsync_ClientInitiated_CanReceive_CanClose(Uri serve
         }
 
         [ActiveIssue("https://github.com/dotnet/runtime/issues/28957")]
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [ConditionalTheory(nameof(WebSocketsSupported)), MemberData(nameof(EchoServers))]
         public async Task CloseOutputAsync_ServerInitiated_CanSend(Uri server)
         {
@@ -292,7 +292,7 @@ await cws.SendAsync(
             }
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [ConditionalTheory(nameof(WebSocketsSupported)), MemberData(nameof(EchoServers))]
         public async Task CloseOutputAsync_CloseDescriptionIsNull_Success(Uri server)
         {
@@ -308,7 +308,7 @@ public async Task CloseOutputAsync_CloseDescriptionIsNull_Success(Uri server)
         }
 
         [ActiveIssue("https://github.com/dotnet/runtime/issues/22000", TargetFrameworkMonikers.Netcoreapp)]
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [ConditionalTheory(nameof(WebSocketsSupported)), MemberData(nameof(EchoServers))]
         public async Task CloseOutputAsync_DuringConcurrentReceiveAsync_ExpectedStates(Uri server)
         {
@@ -345,7 +345,7 @@ public async Task CloseOutputAsync_DuringConcurrentReceiveAsync_ExpectedStates(U
             }
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [ConditionalTheory(nameof(WebSocketsSupported)), MemberData(nameof(EchoServers))]
         public async Task CloseAsync_DuringConcurrentReceiveAsync_ExpectedStates(Uri server)
         {
@@ -374,7 +374,7 @@ public async Task CloseAsync_DuringConcurrentReceiveAsync_ExpectedStates(Uri ser
 
         [ConditionalFact(nameof(WebSocketsSupported))]
         [ActiveIssue("https://github.com/dotnet/runtime/issues/34690", TestPlatforms.Windows, TargetFrameworkMonikers.Netcoreapp, TestRuntimes.Mono)]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/42852", TestPlatforms.Browser)]
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/54153", TestPlatforms.Browser)]
         public async Task CloseAsync_CancelableEvenWhenPendingReceive_Throws()
         {
             var tcs = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
diff --git a/src/libraries/System.Net.WebSockets.Client/tests/ConnectTest.cs b/src/libraries/System.Net.WebSockets.Client/tests/ConnectTest.cs
index 1f3f37f1a37103..0fb1314a6068ee 100644
--- a/src/libraries/System.Net.WebSockets.Client/tests/ConnectTest.cs
+++ b/src/libraries/System.Net.WebSockets.Client/tests/ConnectTest.cs
@@ -17,7 +17,7 @@ public class ConnectTest : ClientWebSocketTestBase
         public ConnectTest(ITestOutputHelper output) : base(output) { }
 
         [ActiveIssue("https://github.com/dotnet/runtime/issues/1895")]
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [ConditionalTheory(nameof(WebSocketsSupported)), MemberData(nameof(UnavailableWebSocketServers))]
         public async Task ConnectAsync_NotWebSocketServer_ThrowsWebSocketExceptionWithMessage(Uri server, string exceptionMessage, WebSocketError errorCode)
         {
@@ -42,23 +42,23 @@ public async Task ConnectAsync_NotWebSocketServer_ThrowsWebSocketExceptionWithMe
             }
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [ConditionalTheory(nameof(WebSocketsSupported)), MemberData(nameof(EchoServers))]
         public async Task EchoBinaryMessage_Success(Uri server)
         {
             await WebSocketHelper.TestEcho(server, WebSocketMessageType.Binary, TimeOutMilliseconds, _output);
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [ConditionalTheory(nameof(WebSocketsSupported)), MemberData(nameof(EchoServers))]
         public async Task EchoTextMessage_Success(Uri server)
         {
             await WebSocketHelper.TestEcho(server, WebSocketMessageType.Text, TimeOutMilliseconds, _output);
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [ConditionalTheory(nameof(WebSocketsSupported)), MemberData(nameof(EchoHeadersServers))]
-        [SkipOnPlatform(TestPlatforms.Browser, "CustomHeaders not supported on browser")]
+        [SkipOnPlatform(TestPlatforms.Browser, "SetRequestHeader not supported on browser")]
         public async Task ConnectAsync_AddCustomHeaders_Success(Uri server)
         {
             using (var cws = new ClientWebSocket())
@@ -96,7 +96,7 @@ public async Task ConnectAsync_AddCustomHeaders_Success(Uri server)
 
         [ConditionalFact(nameof(WebSocketsSupported))]
         [ActiveIssue("https://github.com/dotnet/runtime/issues/34690", TestPlatforms.Windows, TargetFrameworkMonikers.Netcoreapp, TestRuntimes.Mono)]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/42852", TestPlatforms.Browser)]
+        [SkipOnPlatform(TestPlatforms.Browser, "SetRequestHeader not supported on browser")]
         public async Task ConnectAsync_AddHostHeader_Success()
         {
             string expectedHost = null;
@@ -118,7 +118,7 @@ await LoopbackServer.CreateClientAndServerAsync(async uri =>
             }), new LoopbackServer.Options { WebSocketEndpoint = true });
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [ConditionalTheory(nameof(WebSocketsSupported)), MemberData(nameof(EchoHeadersServers))]
         [SkipOnPlatform(TestPlatforms.Browser, "Cookies not supported on browser")]
         public async Task ConnectAsync_CookieHeaders_Success(Uri server)
@@ -168,7 +168,7 @@ public async Task ConnectAsync_CookieHeaders_Success(Uri server)
             }
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [ConditionalTheory(nameof(WebSocketsSupported)), MemberData(nameof(EchoServers))]
         [ActiveIssue("https://github.com/dotnet/runtime/issues/45583", TestPlatforms.Browser)]
         public async Task ConnectAsync_PassNoSubProtocol_ServerRequires_ThrowsWebSocketException(Uri server)
@@ -194,7 +194,7 @@ public async Task ConnectAsync_PassNoSubProtocol_ServerRequires_ThrowsWebSocketE
             }
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [ConditionalTheory(nameof(WebSocketsSupported)), MemberData(nameof(EchoServers))]
         public async Task ConnectAsync_PassMultipleSubProtocols_ServerRequires_ConnectionUsesAgreedSubProtocol(Uri server)
         {
@@ -218,7 +218,7 @@ public async Task ConnectAsync_PassMultipleSubProtocols_ServerRequires_Connectio
 
         [ConditionalFact(nameof(WebSocketsSupported))]
         [ActiveIssue("https://github.com/dotnet/runtime/issues/34690", TestPlatforms.Windows, TargetFrameworkMonikers.Netcoreapp, TestRuntimes.Mono)]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/42852", TestPlatforms.Browser)]
+        [SkipOnPlatform(TestPlatforms.Browser, "SetRequestHeader not supported on Browser")]
         public async Task ConnectAsync_NonStandardRequestHeaders_HeadersAddedWithoutValidation()
         {
             await LoopbackServer.CreateClientAndServerAsync(async uri =>
@@ -235,9 +235,9 @@ await LoopbackServer.CreateClientAndServerAsync(async uri =>
             }), new LoopbackServer.Options { WebSocketEndpoint = true });
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [ConditionalTheory(nameof(WebSocketsSupported)), MemberData(nameof(EchoServers))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/42852", TestPlatforms.Browser)]
+        [SkipOnPlatform(TestPlatforms.Browser, "Proxy not supported on Browser")]
         public async Task ConnectAndCloseAsync_UseProxyServer_ExpectedClosedState(Uri server)
         {
             using (var cws = new ClientWebSocket())
@@ -282,7 +282,7 @@ public async Task ConnectAsync_CancellationRequestedInflightConnect_ThrowsOperat
 
         [ConditionalFact(nameof(WebSocketsSupported))]
         [ActiveIssue("https://github.com/dotnet/runtime/issues/34690", TestPlatforms.Windows, TargetFrameworkMonikers.Netcoreapp, TestRuntimes.Mono)]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/42852", TestPlatforms.Browser)]
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/54152", TestPlatforms.Browser)]
         public async Task ConnectAsync_CancellationRequestedAfterConnect_ThrowsOperationCanceledException()
         {
             var releaseServer = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
diff --git a/src/libraries/System.Net.WebSockets.Client/tests/DeflateTests.cs b/src/libraries/System.Net.WebSockets.Client/tests/DeflateTests.cs
index 1f12d76743357a..e0a0e1e59fd846 100644
--- a/src/libraries/System.Net.WebSockets.Client/tests/DeflateTests.cs
+++ b/src/libraries/System.Net.WebSockets.Client/tests/DeflateTests.cs
@@ -22,7 +22,6 @@ public DeflateTests(ITestOutputHelper output) : base(output)
 
         [ConditionalTheory(nameof(WebSocketsSupported))]
         [ActiveIssue("https://github.com/dotnet/runtime/issues/34690", TestPlatforms.Windows, TargetFrameworkMonikers.Netcoreapp, TestRuntimes.Mono)]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/42852", TestPlatforms.Browser)]
         [InlineData(15, true, 15, true, "permessage-deflate; client_max_window_bits")]
         [InlineData(14, true, 15, true, "permessage-deflate; client_max_window_bits=14")]
         [InlineData(15, true, 14, true, "permessage-deflate; client_max_window_bits; server_max_window_bits=14")]
diff --git a/src/libraries/System.Net.WebSockets.Client/tests/SendReceiveTest.cs b/src/libraries/System.Net.WebSockets.Client/tests/SendReceiveTest.cs
index 5d36a8c6c32bda..6266f01e8ede53 100644
--- a/src/libraries/System.Net.WebSockets.Client/tests/SendReceiveTest.cs
+++ b/src/libraries/System.Net.WebSockets.Client/tests/SendReceiveTest.cs
@@ -49,7 +49,7 @@ public abstract class SendReceiveTest : ClientWebSocketTestBase
 
         public SendReceiveTest(ITestOutputHelper output) : base(output) { }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [ConditionalTheory(nameof(WebSocketsSupported)), MemberData(nameof(EchoServers))]
         public async Task SendReceive_PartialMessageDueToSmallReceiveBuffer_Success(Uri server)
         {
@@ -86,7 +86,7 @@ public async Task SendReceive_PartialMessageDueToSmallReceiveBuffer_Success(Uri
             }
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [ConditionalTheory(nameof(WebSocketsSupported)), MemberData(nameof(EchoServers))]
         [SkipOnPlatform(TestPlatforms.Browser, "JS Websocket does not support see issue https://github.com/dotnet/runtime/issues/46983")]
         public async Task SendReceive_PartialMessageBeforeCompleteMessageArrives_Success(Uri server)
@@ -128,7 +128,7 @@ public async Task SendReceive_PartialMessageBeforeCompleteMessageArrives_Success
             }
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [ConditionalTheory(nameof(WebSocketsSupported)), MemberData(nameof(EchoServers))]
         public async Task SendAsync_SendCloseMessageType_ThrowsArgumentExceptionWithMessage(Uri server)
         {
@@ -156,7 +156,7 @@ public async Task SendAsync_SendCloseMessageType_ThrowsArgumentExceptionWithMess
             }
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [ConditionalTheory(nameof(WebSocketsSupported)), MemberData(nameof(EchoServers))]
         public async Task SendAsync_MultipleOutstandingSendOperations_Throws(Uri server)
         {
@@ -215,7 +215,7 @@ public async Task SendAsync_MultipleOutstandingSendOperations_Throws(Uri server)
             }
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [ConditionalTheory(nameof(WebSocketsSupported)), MemberData(nameof(EchoServers))]
         public async Task ReceiveAsync_MultipleOutstandingReceiveOperations_Throws(Uri server)
         {
@@ -279,7 +279,7 @@ await SendAsync(
             }
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [ConditionalTheory(nameof(WebSocketsSupported)), MemberData(nameof(EchoServers))]
         public async Task SendAsync_SendZeroLengthPayloadAsEndOfMessage_Success(Uri server)
         {
@@ -318,7 +318,7 @@ await SendAsync(
             }
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [ConditionalTheory(nameof(WebSocketsSupported)), MemberData(nameof(EchoServers))]
         public async Task SendReceive_VaryingLengthBuffers_Success(Uri server)
         {
@@ -358,7 +358,7 @@ public async Task SendReceive_VaryingLengthBuffers_Success(Uri server)
             }
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [ConditionalTheory(nameof(WebSocketsSupported)), MemberData(nameof(EchoServers))]
         public async Task SendReceive_Concurrent_Success(Uri server)
         {
@@ -387,9 +387,9 @@ public async Task SendReceive_Concurrent_Success(Uri server)
             }
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [ConditionalFact(nameof(WebSocketsSupported))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/42852", TestPlatforms.Browser)]
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/54153", TestPlatforms.Browser)]
         public async Task SendReceive_ConnectionClosedPrematurely_ReceiveAsyncFailsAndWebSocketStateUpdated()
         {
             var options = new LoopbackServer.Options { WebSocketEndpoint = true };
@@ -457,7 +457,7 @@ await LoopbackServer.CreateServerAsync(async (server, url) =>
             }, options);
         }
 
-        [OuterLoop("Uses external servers")]
+        [OuterLoop("Uses external servers", typeof(PlatformDetection), nameof(PlatformDetection.LocalEchoServerIsNotAvailable))]
         [ConditionalTheory(nameof(WebSocketsSupported)), MemberData(nameof(EchoServers))]
         public async Task ZeroByteReceive_CompletesWhenDataAvailable(Uri server)
         {
diff --git a/src/libraries/System.Net.WebSockets.Client/tests/System.Net.WebSockets.Client.Tests.csproj b/src/libraries/System.Net.WebSockets.Client/tests/System.Net.WebSockets.Client.Tests.csproj
index 3da2d56665aebf..956ee4d4146122 100644
--- a/src/libraries/System.Net.WebSockets.Client/tests/System.Net.WebSockets.Client.Tests.csproj
+++ b/src/libraries/System.Net.WebSockets.Client/tests/System.Net.WebSockets.Client.Tests.csproj
@@ -4,11 +4,24 @@
     <TargetFrameworks>$(NetCoreAppCurrent);$(NetCoreAppCurrent)-Browser</TargetFrameworks>
     <DefineConstants>$(DefineConstants);NETSTANDARD</DefineConstants>
   </PropertyGroup>
+
   <PropertyGroup Condition="'$(TargetOS)' == 'Browser'">
     <Scenario>WasmTestOnBrowser</Scenario>
     <TestArchiveTestsRoot>$(TestArchiveRoot)browseronly/</TestArchiveTestsRoot>
     <TestArchiveTestsDir>$(TestArchiveTestsRoot)$(OSPlatformConfig)/</TestArchiveTestsDir>
+    <DefineConstants>$(DefineConstants);TARGET_BROWSER</DefineConstants>
   </PropertyGroup>
+
+  <Import Condition="'$(TargetOS)' == 'Browser'" Project="$(CommonTestPath)System/Net/Prerequisites/LocalEchoServer.props" />
+
+  <!-- Browser specific files -->
+  <ItemGroup Condition="'$(TargetOS)' == 'Browser'">
+    <ProjectReference Include="$(CommonTestPath)System/Net/Prerequisites/NetCoreServer/NetCoreServer.csproj" ReferenceOutputAssembly="false"/>
+    <ProjectReference Include="$(CommonTestPath)System/Net/Prerequisites/RemoteLoopServer/RemoteLoopServer.csproj" ReferenceOutputAssembly="false"/>
+    <Compile Include="$(CommonTestPath)System\Net\WebSockets\WebSocketStream.cs"
+             Link="Common\System\Net\WebSockets\WebSocketStream.cs" />
+  </ItemGroup>
+
   <!-- Do not reference these assemblies from the TargetingPack since we are building part of the source code for tests. -->
   <ItemGroup>
     <DefaultReferenceExclusion Include="System.Configuration" />
diff --git a/src/libraries/System.Numerics.Vectors/ref/System.Numerics.Vectors.cs b/src/libraries/System.Numerics.Vectors/ref/System.Numerics.Vectors.cs
index 4e9121fe5f131c..1824bd38d32558 100644
--- a/src/libraries/System.Numerics.Vectors/ref/System.Numerics.Vectors.cs
+++ b/src/libraries/System.Numerics.Vectors/ref/System.Numerics.Vectors.cs
@@ -300,6 +300,7 @@ public static partial class Vector
         [System.CLSCompliantAttribute(false)]
         public static void Widen(System.Numerics.Vector<System.UInt32> source, out System.Numerics.Vector<System.UInt64> low, out System.Numerics.Vector<System.UInt64> high) { throw null; }
         public static System.Numerics.Vector<T> Xor<T>(System.Numerics.Vector<T> left, System.Numerics.Vector<T> right) where T : struct { throw null; }
+        public static T Sum<T>(System.Numerics.Vector<T> value) where T : struct { throw null; }
     }
     public partial struct Vector2 : System.IEquatable<System.Numerics.Vector2>, System.IFormattable
     {
diff --git a/src/libraries/System.Numerics.Vectors/tests/GenericVectorTests.cs b/src/libraries/System.Numerics.Vectors/tests/GenericVectorTests.cs
index 6124cd6294e745..aa8113ca5b4fc9 100644
--- a/src/libraries/System.Numerics.Vectors/tests/GenericVectorTests.cs
+++ b/src/libraries/System.Numerics.Vectors/tests/GenericVectorTests.cs
@@ -3137,6 +3137,49 @@ private unsafe void TestAs<TFrom, TTo>() where TFrom : unmanaged where TTo : unm
         }
         #endregion
 
+        #region Sum
+
+        [Fact]
+        public void SumInt32() => TestSum<int>(x => x.Aggregate((a, b) => a + b));
+
+        [Fact]
+        public void SumInt64() => TestSum<long>(x => x.Aggregate((a, b) => a + b));
+
+        [Fact]
+        public void SumSingle() => TestSum<float>(x => x.Aggregate((a, b) => a + b));
+
+        [Fact]
+        public void SumDouble() => TestSum<double>(x => x.Aggregate((a, b) => a + b));
+
+        [Fact]
+        public void SumUInt32() => TestSum<uint>(x => x.Aggregate((a, b) => a + b));
+
+        [Fact]
+        public void SumUInt64() => TestSum<ulong>(x => x.Aggregate((a, b) => a + b));
+
+        [Fact]
+        public void SumByte() => TestSum<byte>(x => x.Aggregate((a, b) => (byte)(a + b)));
+
+        [Fact]
+        public void SumSByte() => TestSum<sbyte>(x => x.Aggregate((a, b) => (sbyte)(a + b)));
+
+        [Fact]
+        public void SumInt16() => TestSum<short>(x => x.Aggregate((a, b) => (short)(a + b)));
+
+        [Fact]
+        public void SumUInt16() => TestSum<ushort>(x => x.Aggregate((a, b) => (ushort)(a + b)));
+
+        private static void TestSum<T>(Func<T[], T> expected) where T : struct, IEquatable<T>
+        {
+            T[] values = GenerateRandomValuesForVector<T>();
+            Vector<T> vector = new(values);
+            T sum = Vector.Sum(vector);
+
+            AssertEqual(expected(values), sum, "Sum");
+        }
+
+        #endregion
+
         #region Helper Methods
         private static void AssertEqual<T>(T expected, T actual, string operation, int precision = -1) where T : IEquatable<T>
         {
diff --git a/src/libraries/System.Private.CoreLib/src/ILLink/ILLink.Substitutions.Shared.xml b/src/libraries/System.Private.CoreLib/src/ILLink/ILLink.Substitutions.Shared.xml
index 67f7b46489ab2f..629afffc730089 100644
--- a/src/libraries/System.Private.CoreLib/src/ILLink/ILLink.Substitutions.Shared.xml
+++ b/src/libraries/System.Private.CoreLib/src/ILLink/ILLink.Substitutions.Shared.xml
@@ -6,8 +6,12 @@
       <method signature="System.Boolean IsEnabled(System.Diagnostics.Tracing.EventLevel,System.Diagnostics.Tracing.EventKeywords)" body="stub" value="false" />
       <method signature="System.Boolean IsEnabled(System.Diagnostics.Tracing.EventLevel,System.Diagnostics.Tracing.EventKeywords,System.Diagnostics.Tracing.EventChannel)" body="stub" value="false" />
     </type>
+    <!-- Note: Invariant=true and Invariant=false are substituted at different levels. This allows for the whole Settings nested class
+         to be trimmed when Invariant=true, and allows for the Settings static cctor (on Unix) to be preserved when Invariant=false. -->
     <type fullname="System.Globalization.GlobalizationMode">
       <method signature="System.Boolean get_Invariant()" body="stub" value="true" feature="System.Globalization.Invariant" featurevalue="true" />
+    </type>
+    <type fullname="System.Globalization.GlobalizationMode/Settings">
       <method signature="System.Boolean get_Invariant()" body="stub" value="false" feature="System.Globalization.Invariant" featurevalue="false" />
     </type>
     <type fullname="System.LocalAppContextSwitches">
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 27efa1fd31979b..7a13a80610d040 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
@@ -4,11 +4,15 @@
 using System;
 using System.Diagnostics;
 using System.IO;
+using System.IO.Strategies;
 
 namespace Microsoft.Win32.SafeHandles
 {
     public sealed class SafeFileHandle : SafeHandleZeroOrMinusOneIsInvalid
     {
+        // not using bool? as it's not thread safe
+        private volatile NullableBool _canSeek = NullableBool.Undefined;
+
         public SafeFileHandle() : this(ownsHandle: true)
         {
         }
@@ -24,14 +28,16 @@ public SafeFileHandle(IntPtr preexistingHandle, bool ownsHandle) : this(ownsHand
             SetHandle(preexistingHandle);
         }
 
-        internal bool? IsAsync { get; set; }
+        public bool IsAsync { get; private set; }
+
+        internal bool CanSeek => !IsClosed && GetCanSeek();
 
         /// <summary>Opens the specified file with the requested flags and mode.</summary>
         /// <param name="path">The path to the file.</param>
         /// <param name="flags">The flags with which to open the file.</param>
         /// <param name="mode">The mode for opening the file.</param>
         /// <returns>A SafeFileHandle for the opened file.</returns>
-        internal static SafeFileHandle Open(string path, Interop.Sys.OpenFlags flags, int mode)
+        private static SafeFileHandle Open(string path, Interop.Sys.OpenFlags flags, int mode)
         {
             Debug.Assert(path != null);
             SafeFileHandle handle = Interop.Sys.Open(path, flags, mode);
@@ -73,6 +79,15 @@ internal static SafeFileHandle Open(string path, Interop.Sys.OpenFlags flags, in
                 throw Interop.GetExceptionForIoErrno(Interop.Error.EACCES.Info(), path, isDirectory: true);
             }
 
+            if ((status.Mode & Interop.Sys.FileTypes.S_IFMT) == Interop.Sys.FileTypes.S_IFREG)
+            {
+                // we take advantage of the information provided by the fstat syscall
+                // and for regular files (most common case)
+                // avoid one extra sys call for determining whether file can be seeked
+                handle._canSeek = NullableBool.True;
+                Debug.Assert(Interop.Sys.LSeek(handle, 0, Interop.Sys.SeekWhence.SEEK_CUR) >= 0);
+            }
+
             return handle;
         }
 
@@ -125,5 +140,189 @@ public override bool IsInvalid
                 return h < 0 || h > int.MaxValue;
             }
         }
+
+        internal static SafeFileHandle Open(string fullPath, FileMode mode, FileAccess access, FileShare share, FileOptions options, long preallocationSize)
+        {
+            // Translate the arguments into arguments for an open call.
+            Interop.Sys.OpenFlags openFlags = PreOpenConfigurationFromOptions(mode, access, share, options);
+
+            // If the file gets created a new, we'll select the permissions for it.  Most Unix utilities by default use 666 (read and
+            // write for all), so we do the same (even though this doesn't match Windows, where by default it's possible to write out
+            // a file and then execute it). No matter what we choose, it'll be subject to the umask applied by the system, such that the
+            // actual permissions will typically be less than what we select here.
+            const Interop.Sys.Permissions OpenPermissions =
+                Interop.Sys.Permissions.S_IRUSR | Interop.Sys.Permissions.S_IWUSR |
+                Interop.Sys.Permissions.S_IRGRP | Interop.Sys.Permissions.S_IWGRP |
+                Interop.Sys.Permissions.S_IROTH | Interop.Sys.Permissions.S_IWOTH;
+
+            SafeFileHandle safeFileHandle = Open(fullPath, openFlags, (int)OpenPermissions);
+            try
+            {
+                safeFileHandle.Init(fullPath, mode, access, share, options, preallocationSize);
+
+                return safeFileHandle;
+            }
+            catch (Exception)
+            {
+                safeFileHandle.Dispose();
+
+                throw;
+            }
+        }
+
+        /// <summary>Translates the FileMode, FileAccess, and FileOptions values into flags to be passed when opening the file.</summary>
+        /// <param name="mode">The FileMode provided to the stream's constructor.</param>
+        /// <param name="access">The FileAccess provided to the stream's constructor</param>
+        /// <param name="share">The FileShare provided to the stream's constructor</param>
+        /// <param name="options">The FileOptions provided to the stream's constructor</param>
+        /// <returns>The flags value to be passed to the open system call.</returns>
+        private static Interop.Sys.OpenFlags PreOpenConfigurationFromOptions(FileMode mode, FileAccess access, FileShare share, FileOptions options)
+        {
+            // Translate FileMode.  Most of the values map cleanly to one or more options for open.
+            Interop.Sys.OpenFlags flags = default;
+            switch (mode)
+            {
+                default:
+                case FileMode.Open: // Open maps to the default behavior for open(...).  No flags needed.
+                case FileMode.Truncate: // We truncate the file after getting the lock
+                    break;
+
+                case FileMode.Append: // Append is the same as OpenOrCreate, except that we'll also separately jump to the end later
+                case FileMode.OpenOrCreate:
+                case FileMode.Create: // We truncate the file after getting the lock
+                    flags |= Interop.Sys.OpenFlags.O_CREAT;
+                    break;
+
+                case FileMode.CreateNew:
+                    flags |= (Interop.Sys.OpenFlags.O_CREAT | Interop.Sys.OpenFlags.O_EXCL);
+                    break;
+            }
+
+            // Translate FileAccess.  All possible values map cleanly to corresponding values for open.
+            switch (access)
+            {
+                case FileAccess.Read:
+                    flags |= Interop.Sys.OpenFlags.O_RDONLY;
+                    break;
+
+                case FileAccess.ReadWrite:
+                    flags |= Interop.Sys.OpenFlags.O_RDWR;
+                    break;
+
+                case FileAccess.Write:
+                    flags |= Interop.Sys.OpenFlags.O_WRONLY;
+                    break;
+            }
+
+            // Handle Inheritable, other FileShare flags are handled by Init
+            if ((share & FileShare.Inheritable) == 0)
+            {
+                flags |= Interop.Sys.OpenFlags.O_CLOEXEC;
+            }
+
+            // Translate some FileOptions; some just aren't supported, and others will be handled after calling open.
+            // - Asynchronous: Handled in ctor, setting _useAsync and SafeFileHandle.IsAsync to true
+            // - DeleteOnClose: Doesn't have a Unix equivalent, but we approximate it in Dispose
+            // - Encrypted: No equivalent on Unix and is ignored
+            // - RandomAccess: Implemented after open if posix_fadvise is available
+            // - SequentialScan: Implemented after open if posix_fadvise is available
+            // - WriteThrough: Handled here
+            if ((options & FileOptions.WriteThrough) != 0)
+            {
+                flags |= Interop.Sys.OpenFlags.O_SYNC;
+            }
+
+            return flags;
+        }
+
+        private void Init(string path, FileMode mode, FileAccess access, FileShare share, FileOptions options, long preallocationSize)
+        {
+            IsAsync = (options & FileOptions.Asynchronous) != 0;
+
+            // Lock the file if requested via FileShare.  This is only advisory locking. FileShare.None implies an exclusive
+            // lock on the file and all other modes use a shared lock.  While this is not as granular as Windows, not mandatory,
+            // and not atomic with file opening, it's better than nothing.
+            Interop.Sys.LockOperations lockOperation = (share == FileShare.None) ? Interop.Sys.LockOperations.LOCK_EX : Interop.Sys.LockOperations.LOCK_SH;
+            if (Interop.Sys.FLock(this, lockOperation | Interop.Sys.LockOperations.LOCK_NB) < 0)
+            {
+                // The only error we care about is EWOULDBLOCK, which indicates that the file is currently locked by someone
+                // else and we would block trying to access it.  Other errors, such as ENOTSUP (locking isn't supported) or
+                // EACCES (the file system doesn't allow us to lock), will only hamper FileStream's usage without providing value,
+                // given again that this is only advisory / best-effort.
+                Interop.ErrorInfo errorInfo = Interop.Sys.GetLastErrorInfo();
+                if (errorInfo.Error == Interop.Error.EWOULDBLOCK)
+                {
+                    throw Interop.GetExceptionForIoErrno(errorInfo, path, isDirectory: false);
+                }
+            }
+
+            // These provide hints around how the file will be accessed.  Specifying both RandomAccess
+            // and Sequential together doesn't make sense as they are two competing options on the same spectrum,
+            // so if both are specified, we prefer RandomAccess (behavior on Windows is unspecified if both are provided).
+            Interop.Sys.FileAdvice fadv =
+                (options & FileOptions.RandomAccess) != 0 ? Interop.Sys.FileAdvice.POSIX_FADV_RANDOM :
+                (options & FileOptions.SequentialScan) != 0 ? Interop.Sys.FileAdvice.POSIX_FADV_SEQUENTIAL :
+                0;
+            if (fadv != 0)
+            {
+                FileStreamHelpers.CheckFileCall(Interop.Sys.PosixFAdvise(this, 0, 0, fadv), path,
+                    ignoreNotSupported: true); // just a hint.
+            }
+
+            if (mode == FileMode.Create || mode == FileMode.Truncate)
+            {
+                // Truncate the file now if the file mode requires it. This ensures that the file only will be truncated
+                // if opened successfully.
+                if (Interop.Sys.FTruncate(this, 0) < 0)
+                {
+                    Interop.ErrorInfo errorInfo = Interop.Sys.GetLastErrorInfo();
+                    if (errorInfo.Error != Interop.Error.EBADF && errorInfo.Error != Interop.Error.EINVAL)
+                    {
+                        // We know the file descriptor is valid and we know the size argument to FTruncate is correct,
+                        // so if EBADF or EINVAL is returned, it means we're dealing with a special file that can't be
+                        // truncated.  Ignore the error in such cases; in all others, throw.
+                        throw Interop.GetExceptionForIoErrno(errorInfo, path, isDirectory: false);
+                    }
+                }
+            }
+
+            // If preallocationSize has been provided for a creatable and writeable file
+            if (FileStreamHelpers.ShouldPreallocate(preallocationSize, access, mode))
+            {
+                int fallocateResult = Interop.Sys.PosixFAllocate(this, 0, preallocationSize);
+                if (fallocateResult != 0)
+                {
+                    Dispose();
+                    Interop.Sys.Unlink(path!); // remove the file to mimic Windows behaviour (atomic operation)
+
+                    Debug.Assert(fallocateResult == -1 || fallocateResult == -2);
+                    throw new IOException(SR.Format(
+                        fallocateResult == -1 ? SR.IO_DiskFull_Path_AllocationSize : SR.IO_FileTooLarge_Path_AllocationSize,
+                        path,
+                        preallocationSize));
+                }
+            }
+        }
+
+        private bool GetCanSeek()
+        {
+            Debug.Assert(!IsClosed);
+            Debug.Assert(!IsInvalid);
+
+            NullableBool canSeek = _canSeek;
+            if (canSeek == NullableBool.Undefined)
+            {
+                _canSeek = canSeek = Interop.Sys.LSeek(this, 0, Interop.Sys.SeekWhence.SEEK_CUR) >= 0 ? NullableBool.True : NullableBool.False;
+            }
+
+            return canSeek == NullableBool.True;
+        }
+
+        private enum NullableBool
+        {
+            Undefined = 0,
+            False = -1,
+            True = 1
+        }
     }
 }
diff --git a/src/libraries/System.Private.CoreLib/src/System/IO/Strategies/AsyncWindowsFileStreamStrategy.ValueTaskSource.cs b/src/libraries/System.Private.CoreLib/src/Microsoft/Win32/SafeHandles/SafeFileHandle.ValueTaskSource.Windows.cs
similarity index 77%
rename from src/libraries/System.Private.CoreLib/src/System/IO/Strategies/AsyncWindowsFileStreamStrategy.ValueTaskSource.cs
rename to src/libraries/System.Private.CoreLib/src/Microsoft/Win32/SafeHandles/SafeFileHandle.ValueTaskSource.Windows.cs
index f1153a5cc041ce..69371a45aff9b3 100644
--- a/src/libraries/System.Private.CoreLib/src/System/IO/Strategies/AsyncWindowsFileStreamStrategy.ValueTaskSource.cs
+++ b/src/libraries/System.Private.CoreLib/src/Microsoft/Win32/SafeHandles/SafeFileHandle.ValueTaskSource.Windows.cs
@@ -1,22 +1,49 @@
 // 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.Buffers;
 using System.Diagnostics;
+using System.IO;
 using System.Threading;
 using System.Threading.Tasks.Sources;
 
-namespace System.IO.Strategies
+namespace Microsoft.Win32.SafeHandles
 {
-    internal sealed partial class AsyncWindowsFileStreamStrategy : WindowsFileStreamStrategy
+    public sealed partial class SafeFileHandle : SafeHandleZeroOrMinusOneIsInvalid
     {
+        private ValueTaskSource? _reusableValueTaskSource; // reusable ValueTaskSource that is currently NOT being used
+
+        // Rent the reusable ValueTaskSource, or create a new one to use if we couldn't get one (which
+        // should only happen on first use or if the FileStream is being used concurrently).
+        internal ValueTaskSource GetValueTaskSource() => Interlocked.Exchange(ref _reusableValueTaskSource, null) ?? new ValueTaskSource(this);
+
+        protected override bool ReleaseHandle()
+        {
+            bool result = Interop.Kernel32.CloseHandle(handle);
+
+            Interlocked.Exchange(ref _reusableValueTaskSource, null)?.Dispose();
+
+            return result;
+        }
+
+        private void TryToReuse(ValueTaskSource source)
+        {
+            source._source.Reset();
+
+            if (Interlocked.CompareExchange(ref _reusableValueTaskSource, source, null) is not null)
+            {
+                source._preallocatedOverlapped.Dispose();
+            }
+        }
+
         /// <summary>Reusable IValueTaskSource for FileStream ValueTask-returning async operations.</summary>
-        private sealed unsafe class ValueTaskSource : IValueTaskSource<int>, IValueTaskSource
+        internal sealed unsafe class ValueTaskSource : IValueTaskSource<int>, IValueTaskSource
         {
             internal static readonly IOCompletionCallback s_ioCallback = IOCallback;
 
             internal readonly PreAllocatedOverlapped _preallocatedOverlapped;
-            private readonly AsyncWindowsFileStreamStrategy _strategy;
+            private readonly SafeFileHandle _fileHandle;
             internal MemoryHandle _memoryHandle;
             internal ManualResetValueTaskSourceCore<int> _source; // mutable struct; do not make this readonly
             private NativeOverlapped* _overlapped;
@@ -28,9 +55,9 @@ private sealed unsafe class ValueTaskSource : IValueTaskSource<int>, IValueTaskS
             /// </summary>
             internal ulong _result;
 
-            internal ValueTaskSource(AsyncWindowsFileStreamStrategy strategy)
+            internal ValueTaskSource(SafeFileHandle fileHandle)
             {
-                _strategy = strategy;
+                _fileHandle = fileHandle;
                 _source.RunContinuationsAsynchronously = true;
                 _preallocatedOverlapped = PreAllocatedOverlapped.UnsafeCreate(s_ioCallback, this, null);
             }
@@ -41,11 +68,18 @@ internal void Dispose()
                 _preallocatedOverlapped.Dispose();
             }
 
-            internal NativeOverlapped* PrepareForOperation(ReadOnlyMemory<byte> memory)
+            internal static Exception GetIOError(int errorCode, string? path)
+                => errorCode == Interop.Errors.ERROR_HANDLE_EOF
+                    ? ThrowHelper.CreateEndOfFileException()
+                    : Win32Marshal.GetExceptionForWin32Error(errorCode, path);
+
+            internal NativeOverlapped* PrepareForOperation(ReadOnlyMemory<byte> memory, long fileOffset)
             {
                 _result = 0;
                 _memoryHandle = memory.Pin();
-                _overlapped = _strategy._fileHandle.ThreadPoolBinding!.AllocateNativeOverlapped(_preallocatedOverlapped);
+                _overlapped = _fileHandle.ThreadPoolBinding!.AllocateNativeOverlapped(_preallocatedOverlapped);
+                _overlapped->OffsetLow = (int)fileOffset;
+                _overlapped->OffsetHigh = (int)(fileOffset >> 32);
                 return _overlapped;
             }
 
@@ -63,7 +97,7 @@ private int GetResultAndRelease(short token)
                 finally
                 {
                     // The instance is ready to be reused
-                    _strategy.TryToReuse(this);
+                    _fileHandle.TryToReuse(this);
                 }
             }
 
@@ -79,11 +113,11 @@ internal void RegisterForCancellation(CancellationToken cancellationToken)
                         _cancellationRegistration = cancellationToken.UnsafeRegister(static (s, token) =>
                         {
                             ValueTaskSource vts = (ValueTaskSource)s!;
-                            if (!vts._strategy._fileHandle.IsInvalid)
+                            if (!vts._fileHandle.IsInvalid)
                             {
                                 try
                                 {
-                                    Interop.Kernel32.CancelIoEx(vts._strategy._fileHandle, vts._overlapped);
+                                    Interop.Kernel32.CancelIoEx(vts._fileHandle, vts._overlapped);
                                     // Ignore all failures: no matter whether it succeeds or fails, completion is handled via the IOCallback.
                                 }
                                 catch (ObjectDisposedException) { } // in case the SafeHandle is (erroneously) closed concurrently
@@ -112,7 +146,7 @@ internal void ReleaseResources()
                 // Free the overlapped.
                 if (_overlapped != null)
                 {
-                    _strategy._fileHandle.ThreadPoolBinding!.FreeNativeOverlapped(_overlapped);
+                    _fileHandle.ThreadPoolBinding!.FreeNativeOverlapped(_overlapped);
                     _overlapped = null;
                 }
             }
@@ -161,6 +195,7 @@ internal void Complete(uint errorCode, uint numBytes)
                     case 0:
                     case Interop.Errors.ERROR_BROKEN_PIPE:
                     case Interop.Errors.ERROR_NO_DATA:
+                    case Interop.Errors.ERROR_HANDLE_EOF: // logically success with 0 bytes read (read at end of file)
                         // Success
                         _source.SetResult((int)numBytes);
                         break;
diff --git a/src/libraries/System.Private.CoreLib/src/Microsoft/Win32/SafeHandles/SafeFileHandle.Windows.cs b/src/libraries/System.Private.CoreLib/src/Microsoft/Win32/SafeHandles/SafeFileHandle.Windows.cs
index dfcce3cfc65ac8..5aa7a2c7f4dd66 100644
--- a/src/libraries/System.Private.CoreLib/src/Microsoft/Win32/SafeHandles/SafeFileHandle.Windows.cs
+++ b/src/libraries/System.Private.CoreLib/src/Microsoft/Win32/SafeHandles/SafeFileHandle.Windows.cs
@@ -2,35 +2,239 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Diagnostics;
+using System.IO;
+using System.IO.Strategies;
+using System.Runtime.InteropServices;
 using System.Threading;
 
 namespace Microsoft.Win32.SafeHandles
 {
-    public sealed class SafeFileHandle : SafeHandleZeroOrMinusOneIsInvalid
+    public sealed partial class SafeFileHandle : SafeHandleZeroOrMinusOneIsInvalid
     {
-        private bool? _isAsync;
+        internal const FileOptions NoBuffering = (FileOptions)0x20000000;
+        private volatile FileOptions _fileOptions = (FileOptions)(-1);
+        private volatile int _fileType = -1;
 
         public SafeFileHandle() : base(true)
         {
-            _isAsync = null;
         }
 
         public SafeFileHandle(IntPtr preexistingHandle, bool ownsHandle) : base(ownsHandle)
         {
             SetHandle(preexistingHandle);
+        }
+
+        public bool IsAsync => (GetFileOptions() & FileOptions.Asynchronous) != 0;
+
+        internal bool CanSeek => !IsClosed && GetFileType() == Interop.Kernel32.FileTypes.FILE_TYPE_DISK;
+
+        internal bool IsPipe => GetFileType() == Interop.Kernel32.FileTypes.FILE_TYPE_PIPE;
+
+        internal ThreadPoolBoundHandle? ThreadPoolBinding { get; set; }
 
-            _isAsync = null;
+        internal static unsafe SafeFileHandle Open(string fullPath, FileMode mode, FileAccess access, FileShare share, FileOptions options, long preallocationSize)
+        {
+            using (DisableMediaInsertionPrompt.Create())
+            {
+                // we don't use NtCreateFile as there is no public and reliable way
+                // of converting DOS to NT file paths (RtlDosPathNameToRelativeNtPathName_U_WithStatus is not documented)
+                SafeFileHandle fileHandle = CreateFile(fullPath, mode, access, share, options);
+
+                if (FileStreamHelpers.ShouldPreallocate(preallocationSize, access, mode))
+                {
+                    Preallocate(fullPath, preallocationSize, fileHandle);
+                }
+
+                fileHandle.InitThreadPoolBindingIfNeeded();
+
+                return fileHandle;
+            }
         }
 
-        internal bool? IsAsync
+        private static unsafe SafeFileHandle CreateFile(string fullPath, FileMode mode, FileAccess access, FileShare share, FileOptions options)
         {
-            get => _isAsync;
-            set => _isAsync = value;
+            Interop.Kernel32.SECURITY_ATTRIBUTES secAttrs = default;
+            if ((share & FileShare.Inheritable) != 0)
+            {
+                secAttrs = new Interop.Kernel32.SECURITY_ATTRIBUTES
+                {
+                    nLength = (uint)sizeof(Interop.Kernel32.SECURITY_ATTRIBUTES),
+                    bInheritHandle = Interop.BOOL.TRUE
+                };
+            }
+
+            int fAccess =
+                ((access & FileAccess.Read) == FileAccess.Read ? Interop.Kernel32.GenericOperations.GENERIC_READ : 0) |
+                ((access & FileAccess.Write) == FileAccess.Write ? Interop.Kernel32.GenericOperations.GENERIC_WRITE : 0);
+
+            // Our Inheritable bit was stolen from Windows, but should be set in
+            // the security attributes class.  Don't leave this bit set.
+            share &= ~FileShare.Inheritable;
+
+            // Must use a valid Win32 constant here...
+            if (mode == FileMode.Append)
+            {
+                mode = FileMode.OpenOrCreate;
+            }
+
+            int flagsAndAttributes = (int)options;
+
+            // For mitigating local elevation of privilege attack through named pipes
+            // make sure we always call CreateFile with SECURITY_ANONYMOUS so that the
+            // named pipe server can't impersonate a high privileged client security context
+            // (note that this is the effective default on CreateFile2)
+            flagsAndAttributes |= (Interop.Kernel32.SecurityOptions.SECURITY_SQOS_PRESENT | Interop.Kernel32.SecurityOptions.SECURITY_ANONYMOUS);
+
+            SafeFileHandle fileHandle = Interop.Kernel32.CreateFile(fullPath, fAccess, share, &secAttrs, mode, flagsAndAttributes, IntPtr.Zero);
+            if (fileHandle.IsInvalid)
+            {
+                // Return a meaningful exception with the full path.
+
+                // NT5 oddity - when trying to open "C:\" as a Win32FileStream,
+                // we usually get ERROR_PATH_NOT_FOUND from the OS.  We should
+                // probably be consistent w/ every other directory.
+                int errorCode = Marshal.GetLastPInvokeError();
+
+                if (errorCode == Interop.Errors.ERROR_PATH_NOT_FOUND && fullPath!.Length == PathInternal.GetRootLength(fullPath))
+                {
+                    errorCode = Interop.Errors.ERROR_ACCESS_DENIED;
+                }
+
+                throw Win32Marshal.GetExceptionForWin32Error(errorCode, fullPath);
+            }
+
+            fileHandle._fileOptions = options;
+            return fileHandle;
         }
 
-        internal ThreadPoolBoundHandle? ThreadPoolBinding { get; set; }
+        private static unsafe void Preallocate(string fullPath, long preallocationSize, SafeFileHandle fileHandle)
+        {
+            var allocationInfo = new Interop.Kernel32.FILE_ALLOCATION_INFO
+            {
+                AllocationSize = preallocationSize
+            };
+
+            if (!Interop.Kernel32.SetFileInformationByHandle(
+                fileHandle,
+                Interop.Kernel32.FileAllocationInfo,
+                &allocationInfo,
+                (uint)sizeof(Interop.Kernel32.FILE_ALLOCATION_INFO)))
+            {
+                int errorCode = Marshal.GetLastPInvokeError();
+
+                // we try to mimic the atomic NtCreateFile here:
+                // if preallocation fails, close the handle and delete the file
+                fileHandle.Dispose();
+                Interop.Kernel32.DeleteFile(fullPath);
+
+                switch (errorCode)
+                {
+                    case Interop.Errors.ERROR_DISK_FULL:
+                        throw new IOException(SR.Format(SR.IO_DiskFull_Path_AllocationSize, fullPath, preallocationSize));
+                    case Interop.Errors.ERROR_FILE_TOO_LARGE:
+                        throw new IOException(SR.Format(SR.IO_FileTooLarge_Path_AllocationSize, fullPath, preallocationSize));
+                    default:
+                        throw Win32Marshal.GetExceptionForWin32Error(errorCode, fullPath);
+                }
+            }
+        }
+
+        internal void InitThreadPoolBindingIfNeeded()
+        {
+            if (IsAsync == true && ThreadPoolBinding == null)
+            {
+                // This is necessary for async IO using IO Completion ports via our
+                // managed Threadpool API's.  This (theoretically) calls the OS's
+                // BindIoCompletionCallback method, and passes in a stub for the
+                // LPOVERLAPPED_COMPLETION_ROUTINE.  This stub looks at the Overlapped
+                // struct for this request and gets a delegate to a managed callback
+                // from there, which it then calls on a threadpool thread.  (We allocate
+                // our native OVERLAPPED structs 2 pointers too large and store EE state
+                // & GC handles there, one to an IAsyncResult, the other to a delegate.)
+                try
+                {
+                    ThreadPoolBinding = ThreadPoolBoundHandle.BindHandle(this);
+                }
+                catch (ArgumentException ex)
+                {
+                    if (OwnsHandle)
+                    {
+                        // We should close the handle so that the handle is not open until SafeFileHandle GC
+                        Dispose();
+                    }
+
+                    throw new IOException(SR.IO_BindHandleFailed, ex);
+                }
+            }
+        }
+
+        internal unsafe FileOptions GetFileOptions()
+        {
+            FileOptions fileOptions = _fileOptions;
+            if (fileOptions != (FileOptions)(-1))
+            {
+                return fileOptions;
+            }
 
-        protected override bool ReleaseHandle() =>
-            Interop.Kernel32.CloseHandle(handle);
+            Interop.NtDll.CreateOptions options;
+            int ntStatus = Interop.NtDll.NtQueryInformationFile(
+                FileHandle: this,
+                IoStatusBlock: out _,
+                FileInformation: &options,
+                Length: sizeof(uint),
+                FileInformationClass: Interop.NtDll.FileModeInformation);
+
+            if (ntStatus != Interop.StatusOptions.STATUS_SUCCESS)
+            {
+                int error = (int)Interop.NtDll.RtlNtStatusToDosError(ntStatus);
+                throw Win32Marshal.GetExceptionForWin32Error(error);
+            }
+
+            FileOptions result = FileOptions.None;
+
+            if ((options & (Interop.NtDll.CreateOptions.FILE_SYNCHRONOUS_IO_ALERT | Interop.NtDll.CreateOptions.FILE_SYNCHRONOUS_IO_NONALERT)) == 0)
+            {
+                result |= FileOptions.Asynchronous;
+            }
+            if ((options & Interop.NtDll.CreateOptions.FILE_WRITE_THROUGH) != 0)
+            {
+                result |= FileOptions.WriteThrough;
+            }
+            if ((options & Interop.NtDll.CreateOptions.FILE_RANDOM_ACCESS) != 0)
+            {
+                result |= FileOptions.RandomAccess;
+            }
+            if ((options & Interop.NtDll.CreateOptions.FILE_SEQUENTIAL_ONLY) != 0)
+            {
+                result |= FileOptions.SequentialScan;
+            }
+            if ((options & Interop.NtDll.CreateOptions.FILE_DELETE_ON_CLOSE) != 0)
+            {
+                result |= FileOptions.DeleteOnClose;
+            }
+            if ((options & Interop.NtDll.CreateOptions.FILE_NO_INTERMEDIATE_BUFFERING) != 0)
+            {
+                result |= NoBuffering;
+            }
+
+            return _fileOptions = result;
+        }
+
+        internal int GetFileType()
+        {
+            int fileType = _fileType;
+            if (fileType == -1)
+            {
+                _fileType = fileType = Interop.Kernel32.GetFileType(this);
+
+                Debug.Assert(fileType == Interop.Kernel32.FileTypes.FILE_TYPE_DISK
+                    || fileType == Interop.Kernel32.FileTypes.FILE_TYPE_PIPE
+                    || fileType == Interop.Kernel32.FileTypes.FILE_TYPE_CHAR,
+                    $"Unknown file type: {fileType}");
+            }
+
+            return fileType;
+        }
     }
 }
diff --git a/src/libraries/System.Private.CoreLib/src/Resources/Strings.resx b/src/libraries/System.Private.CoreLib/src/Resources/Strings.resx
index c64c59ae391363..7c80c23f632414 100644
--- a/src/libraries/System.Private.CoreLib/src/Resources/Strings.resx
+++ b/src/libraries/System.Private.CoreLib/src/Resources/Strings.resx
@@ -813,6 +813,9 @@
   <data name="Argument_AdjustmentRulesOutOfOrder" xml:space="preserve">
     <value>The elements of the AdjustmentRule array must be in chronological order and must not overlap.</value>
   </data>
+  <data name="Argument_AlignmentMustBePow2" xml:space="preserve">
+    <value>The alignment must be a power of two.</value>
+  </data>
   <data name="Argument_AlreadyACCW" xml:space="preserve">
     <value>The object already has a CCW associated with it.</value>
   </data>
@@ -3781,4 +3784,7 @@
   <data name="PlatformNotSupported_FileEncryption" xml:space="preserve">
     <value>File encryption is not supported on this platform.</value>
   </data>
-</root>
\ No newline at end of file
+  <data name="Arg_MemberInfoNotFound" xml:space="preserve">
+    <value>A MemberInfo that matches '{0}' could not be found.</value>
+  </data>
+</root>
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 22a9b4141336e2..2af41ff13424be 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
@@ -407,9 +407,11 @@
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\EnumerationOptions.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\EndOfStreamException.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\File.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\IO\File.netcoreapp.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\FileAccess.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\FileAttributes.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\FileInfo.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\IO\FileInfo.netcoreapp.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\FileLoadException.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\FileMode.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\FileNotFoundException.cs" />
@@ -429,6 +431,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\PathInternal.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\PathTooLongException.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\PinnedBufferMemoryStream.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\IO\RandomAccess.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\ReadLinesIterator.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\SearchOption.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\SearchTarget.cs" />
@@ -821,6 +824,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\InteropServices\MarshalAsAttribute.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\InteropServices\MarshalDirectiveException.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\InteropServices\MemoryMarshal.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\InteropServices\NativeMemory.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\InteropServices\UnmanagedCallConvAttribute.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\InteropServices\UnmanagedCallersOnlyAttribute.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\InteropServices\NativeLibrary.cs" />
@@ -967,6 +971,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)System\Text\Latin1Utility.Helpers.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Text\NormalizationForm.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Text\Rune.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\Text\SpanLineEnumerator.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Text\SpanRuneEnumerator.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Text\StringBuilder.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Text\StringBuilder.Debug.cs" Condition="'$(Configuration)' == 'Debug'" />
@@ -1421,6 +1426,9 @@
     <Compile Include="$(CommonPath)Interop\Windows\Kernel32\Interop.FILE_BASIC_INFO.cs">
       <Link>Common\Interop\Windows\Kernel32\Interop.FILE_BASIC_INFO.cs</Link>
     </Compile>
+    <Compile Include="$(CommonPath)Interop\Windows\Kernel32\Interop.FILE_ALLOCATION_INFO.cs">
+      <Link>Common\Interop\Windows\Kernel32\Interop.FILE_ALLOCATION_INFO.cs</Link>
+    </Compile>
     <Compile Include="$(CommonPath)Interop\Windows\Kernel32\Interop.FILE_END_OF_FILE_INFO.cs">
       <Link>Common\Interop\Windows\Kernel32\Interop.FILE_END_OF_FILE_INFO.cs</Link>
     </Compile>
@@ -1592,6 +1600,9 @@
     <Compile Include="$(CommonPath)Interop\Windows\Kernel32\Interop.ReadFile_SafeHandle_NativeOverlapped.cs">
       <Link>Common\Interop\Windows\Kernel32\Interop.ReadFile_SafeHandle_NativeOverlapped.cs</Link>
     </Compile>
+    <Compile Include="$(CommonPath)Interop\Windows\Kernel32\Interop.FileScatterGather.cs">
+      <Link>Common\Interop\Windows\Kernel32\Interop.FileScatterGather.cs</Link>
+    </Compile>
     <Compile Include="$(CommonPath)Interop\Windows\Kernel32\Interop.RemoveDirectory.cs">
       <Link>Common\Interop\Windows\Kernel32\Interop.RemoveDirectory.cs</Link>
     </Compile>
@@ -1604,15 +1615,15 @@
     <Compile Include="$(CommonPath)Interop\Windows\Interop.UNICODE_STRING.cs">
       <Link>Common\Interop\Windows\Interop.UNICODE_STRING.cs</Link>
     </Compile>
+    <Compile Include="$(CommonPath)Interop\Windows\Kernel32\Interop.SecurityOptions.cs">
+      <Link>Common\Interop\Windows\Kernel32\Interop.SecurityOptions.cs</Link>
+    </Compile>
     <Compile Include="$(CommonPath)Interop\Windows\Interop.SECURITY_QUALITY_OF_SERVICE.cs">
       <Link>Common\Interop\Windows\Interop.SECURITY_QUALITY_OF_SERVICE.cs</Link>
     </Compile>
     <Compile Include="$(CommonPath)Interop\Windows\Interop.OBJECT_ATTRIBUTES.cs">
       <Link>Common\Interop\Windows\Interop.OBJECT_ATTRIBUTES.cs</Link>
     </Compile>
-    <Compile Include="$(CommonPath)Interop\Windows\Kernel32\Interop.SecurityOptions.cs">
-      <Link>Common\Interop\Windows\Kernel32\Interop.SecurityOptions.cs</Link>
-    </Compile>
     <Compile Include="$(CommonPath)Interop\Windows\Kernel32\Interop.SetCurrentDirectory.cs">
       <Link>Common\Interop\Windows\Kernel32\Interop.SetCurrentDirectory.cs</Link>
     </Compile>
@@ -1721,6 +1732,9 @@
     <Compile Include="$(CommonPath)Interop\Windows\Shell32\Interop.SHGetKnownFolderPath.cs">
       <Link>Common\Interop\Windows\Shell32\Interop.SHGetKnownFolderPath.cs</Link>
     </Compile>
+    <Compile Include="$(CommonPath)Interop\Windows\Ucrtbase\Interop.MemAlloc.cs">
+      <Link>Common\Interop\Windows\Ucrtbase\Interop.MemAlloc.cs</Link>
+    </Compile>
     <Compile Include="$(CommonPath)Interop\Windows\User32\Interop.Constants.cs">
       <Link>Common\Interop\Windows\User32\Interop.Constants.cs</Link>
     </Compile>
@@ -1751,6 +1765,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)Internal\Console.Windows.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Internal\Win32\RegistryKey.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Microsoft\Win32\SafeHandles\SafeFileHandle.Windows.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Microsoft\Win32\SafeHandles\SafeFileHandle.ValueTaskSource.Windows.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Microsoft\Win32\SafeHandles\SafeFindHandle.Windows.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Microsoft\Win32\SafeHandles\SafeRegistryHandle.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Microsoft\Win32\SafeHandles\SafeRegistryHandle.Windows.cs" />
@@ -1777,11 +1792,11 @@
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\Path.Windows.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\PathHelper.Windows.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\PathInternal.Windows.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\IO\RandomAccess.Windows.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\Enumeration\FileSystemEntry.Windows.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\Enumeration\FileSystemEnumerator.Win32.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\Enumeration\FileSystemEnumerator.Windows.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\Strategies\AsyncWindowsFileStreamStrategy.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)System\IO\Strategies\AsyncWindowsFileStreamStrategy.ValueTaskSource.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\Strategies\FileStreamHelpers.Windows.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\Strategies\Net5CompatFileStreamStrategy.CompletionSource.Windows.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\Strategies\Net5CompatFileStreamStrategy.Windows.cs" />
@@ -1791,6 +1806,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\Loader\LibraryNameVariation.Windows.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\MemoryFailPoint.Windows.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\InteropServices\Marshal.Windows.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\InteropServices\NativeMemory.Windows.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\InteropServices\StandardOleMarshalObject.Windows.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Security\SecureString.Windows.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Threading\LowLevelMonitor.Windows.cs" />
@@ -1921,6 +1937,9 @@
     <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.GetUnixRelease.cs">
       <Link>Common\Interop\Unix\System.Native\Interop.GetUnixRelease.cs</Link>
     </Compile>
+    <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.IOVector.cs">
+      <Link>Common\Interop\Unix\System.Native\Interop.IOVector.cs</Link>
+    </Compile>
     <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.LChflags.cs">
       <Link>Common\Interop\Unix\System.Native\Interop.LChflags.cs</Link>
     </Compile>
@@ -1969,6 +1988,18 @@
     <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.PosixFAllocate.cs">
       <Link>Common\Interop\Unix\System.Native\Interop.PosixFAllocate.cs</Link>
     </Compile>
+    <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.PRead.cs">
+      <Link>Common\Interop\Unix\System.Native\Interop.PRead.cs</Link>
+    </Compile>
+    <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.PReadV.cs">
+      <Link>Common\Interop\Unix\System.Native\Interop.PReadV.cs</Link>
+    </Compile>
+    <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.PWrite.cs">
+      <Link>Common\Interop\Unix\System.Native\Interop.PWrite.cs</Link>
+    </Compile>
+    <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.PWriteV.cs">
+      <Link>Common\Interop\Unix\System.Native\Interop.PWriteV.cs</Link>
+    </Compile>
     <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.Read.cs">
       <Link>Common\Interop\Unix\System.Native\Interop.Read.cs</Link>
     </Compile>
@@ -2036,6 +2067,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\Path.Unix.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\PathInternal.Unix.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\PersistedFiles.Names.Unix.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\IO\RandomAccess.Unix.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\Enumeration\FileSystemEntry.Unix.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\Enumeration\FileSystemEnumerator.Unix.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\Strategies\FileStreamHelpers.Unix.cs" />
@@ -2046,6 +2078,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\Loader\LibraryNameVariation.Unix.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\MemoryFailPoint.Unix.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\InteropServices\Marshal.Unix.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\InteropServices\NativeMemory.Unix.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\InteropServices\StandardOleMarshalObject.Unix.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Security\SecureString.Unix.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Threading\LowLevelMonitor.Unix.cs" />
@@ -2166,9 +2199,10 @@
   <ItemGroup Condition="'$(FeaturePortableThreadPool)' == 'true'">
     <Compile Include="$(MSBuildThisFileDirectory)System\Threading\ThreadPool.Portable.cs" Condition="'$(FeatureCoreCLR)' != 'true'" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Threading\ThreadPoolBoundHandle.PlatformNotSupported.cs" Condition="'$(FeatureCoreCLR)' != 'true'" />
-    <Compile Include="$(MSBuildThisFileDirectory)System\Threading\PortableThreadPool.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Threading\NativeRuntimeEventSource.PortableThreadPool.cs" Condition="'$(FeatureCoreCLR)' != 'true' and '$(FeatureMono)' != 'true'" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Threading\NativeRuntimeEventSource.PortableThreadPool.NativeSinks.cs" Condition="'$(FeatureCoreCLR)' == 'true' or '$(FeatureMono)' == 'true'"/>
+    <Compile Include="$(MSBuildThisFileDirectory)System\Threading\PortableThreadPool.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\Threading\PortableThreadPool.Blocking.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Threading\PortableThreadPool.GateThread.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Threading\PortableThreadPool.HillClimbing.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Threading\PortableThreadPool.HillClimbing.Complex.cs" />
diff --git a/src/libraries/System.Private.CoreLib/src/System/BitConverter.cs b/src/libraries/System.Private.CoreLib/src/System/BitConverter.cs
index e063fa47fe6aa0..5945c6252dc384 100644
--- a/src/libraries/System.Private.CoreLib/src/System/BitConverter.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/BitConverter.cs
@@ -857,5 +857,59 @@ public static unsafe Half Int16BitsToHalf(short value)
         {
             return *(Half*)&value;
         }
+
+        /// <summary>
+        /// Converts the specified double-precision floating point number to a 64-bit unsigned integer.
+        /// </summary>
+        /// <param name="value">The number to convert.</param>
+        /// <returns>A 64-bit unsigned integer whose bits are identical to <paramref name="value"/>.</returns>
+        [CLSCompliant(false)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static unsafe ulong DoubleToUInt64Bits(double value) => (ulong)DoubleToInt64Bits(value);
+
+        /// <summary>
+        /// Converts the specified 64-bit unsigned integer to a double-precision floating point number.
+        /// </summary>
+        /// <param name="value">The number to convert.</param>
+        /// <returns>A double-precision floating point number whose bits are identical to <paramref name="value"/>.</returns>
+        [CLSCompliant(false)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static unsafe double UInt64BitsToDouble(ulong value) => Int64BitsToDouble((long)value);
+
+        /// <summary>
+        /// Converts the specified single-precision floating point number to a 32-bit unsigned integer.
+        /// </summary>
+        /// <param name="value">The number to convert.</param>
+        /// <returns>A 32-bit unsigned integer whose bits are identical to <paramref name="value"/>.</returns>
+        [CLSCompliant(false)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static unsafe uint SingleToUInt32Bits(float value) => (uint)SingleToInt32Bits(value);
+
+        /// <summary>
+        /// Converts the specified 32-bit unsigned integer to a single-precision floating point number.
+        /// </summary>
+        /// <param name="value">The number to convert.</param>
+        /// <returns>A single-precision floating point number whose bits are identical to <paramref name="value"/>.</returns>
+        [CLSCompliant(false)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static unsafe float UInt32BitsToSingle(uint value) => Int32BitsToSingle((int)value);
+
+        /// <summary>
+        /// Converts the specified half-precision floating point number to a 16-bit unsigned integer.
+        /// </summary>
+        /// <param name="value">The number to convert.</param>
+        /// <returns>A 16-bit unsigned integer whose bits are identical to <paramref name="value"/>.</returns>
+        [CLSCompliant(false)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static unsafe ushort HalfToUInt16Bits(Half value) => (ushort)HalfToInt16Bits(value);
+
+        /// <summary>
+        /// Converts the specified 16-bit unsigned integer to a half-precision floating point number.
+        /// </summary>
+        /// <param name="value">The number to convert.</param>
+        /// <returns>A half-precision floating point number whose bits are identical to <paramref name="value"/>.</returns>
+        [CLSCompliant(false)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static unsafe Half UInt16BitsToHalf(ushort value) => Int16BitsToHalf((short)value);
     }
 }
diff --git a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/CodeAnalysis/RequiresUnreferencedCodeAttribute.cs b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/CodeAnalysis/RequiresUnreferencedCodeAttribute.cs
index bcb31753c4084e..c2f1b5ef382e93 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/CodeAnalysis/RequiresUnreferencedCodeAttribute.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/CodeAnalysis/RequiresUnreferencedCodeAttribute.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.
 
+#nullable enable
+
 namespace System.Diagnostics.CodeAnalysis
 {
     /// <summary>
diff --git a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/CounterGroup.cs b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/CounterGroup.cs
index 5d85b20e7b6bf7..d60be1b83bdd89 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/CounterGroup.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/CounterGroup.cs
@@ -251,10 +251,9 @@ private void OnTimer()
                 lock (s_counterGroupLock)
                 {
                     _timeStampSinceCollectionStarted = now;
-                    do
-                    {
-                        _nextPollingTimeStamp += new TimeSpan(0, 0, 0, 0, _pollingIntervalInMilliseconds);
-                    } while (_nextPollingTimeStamp <= now);
+                    TimeSpan delta = now - _nextPollingTimeStamp;
+                    if (delta > TimeSpan.Zero && _pollingIntervalInMilliseconds > 0)
+                        _nextPollingTimeStamp += TimeSpan.FromMilliseconds(_pollingIntervalInMilliseconds * Math.Ceiling(delta.TotalMilliseconds / _pollingIntervalInMilliseconds));
                 }
             }
         }
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 321d60de739b32..d6093b4fb66bb3 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
@@ -495,6 +495,9 @@ public static void SendCommand(EventSource eventSource, EventCommand command, ID
         /// </summary>
         public override string ToString()
         {
+            if (!IsSupported)
+                return base.ToString()!;
+
             return SR.Format(SR.EventSource_ToString, Name, Guid);
         }
 
diff --git a/src/libraries/System.Private.CoreLib/src/System/Globalization/DateTimeFormatInfo.cs b/src/libraries/System.Private.CoreLib/src/System/Globalization/DateTimeFormatInfo.cs
index c91e7fa5c14352..a7b603ef859cbf 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Globalization/DateTimeFormatInfo.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Globalization/DateTimeFormatInfo.cs
@@ -2409,7 +2409,7 @@ internal bool Tokenize(TokenType TokenMask, out TokenType tokenType, out int tok
             if (isLetter)
             {
                 ch = Culture.TextInfo.ToLower(ch);
-                if (IsHebrewChar(ch) && TokenMask == TokenType.RegularTokenMask)
+                if (!GlobalizationMode.Invariant && IsHebrewChar(ch) && TokenMask == TokenType.RegularTokenMask)
                 {
                     if (TryParseHebrewNumber(ref str, out bool badFormat, out tokenValue))
                     {
diff --git a/src/libraries/System.Private.CoreLib/src/System/Globalization/DateTimeParse.cs b/src/libraries/System.Private.CoreLib/src/System/Globalization/DateTimeParse.cs
index e4b260885f8251..ce6e23b8c85609 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Globalization/DateTimeParse.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Globalization/DateTimeParse.cs
@@ -1050,6 +1050,12 @@ private static bool Lex(DS dps, ref __DTString str, ref DateTimeToken dtok, ref
                     }
                     break;
                 case TokenType.JapaneseEraToken:
+                    if (GlobalizationMode.Invariant)
+                    {
+                        Debug.Fail("Should never be reached");
+                        return false;
+                    }
+
                     // Special case for Japanese.  We allow Japanese era name to be used even if the calendar is not Japanese Calendar.
                     result.calendar = JapaneseCalendar.GetDefaultInstance();
                     dtfi = DateTimeFormatInfo.GetJapaneseCalendarDTFI();
@@ -1066,6 +1072,12 @@ private static bool Lex(DS dps, ref __DTString str, ref DateTimeToken dtok, ref
                     }
                     break;
                 case TokenType.TEraToken:
+                    if (GlobalizationMode.Invariant)
+                    {
+                        Debug.Fail("Should never be reached");
+                        return false;
+                    }
+
                     result.calendar = TaiwanCalendar.GetDefaultInstance();
                     dtfi = DateTimeFormatInfo.GetTaiwanCalendarDTFI();
                     if (result.era != -1)
diff --git a/src/libraries/System.Private.CoreLib/src/System/Globalization/GlobalizationMode.Unix.cs b/src/libraries/System.Private.CoreLib/src/System/Globalization/GlobalizationMode.Unix.cs
index 3ad23b92f4a1ba..2cc6fd74b8201c 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Globalization/GlobalizationMode.Unix.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Globalization/GlobalizationMode.Unix.cs
@@ -7,42 +7,49 @@ internal static partial class GlobalizationMode
     {
         private static partial class Settings
         {
-            internal static readonly bool Invariant = GetGlobalizationInvariantMode();
-        }
-
-        internal static bool Invariant => Settings.Invariant;
-
-        internal static bool UseNls => false;
+            /// <summary>
+            /// Load ICU (when not in Invariant mode) in a static cctor to ensure it is loaded early in the process.
+            /// Other places, e.g. CompareInfo.GetSortKey, rely on ICU already being loaded before they are called.
+            /// </summary>
+            static Settings()
+            {
+                if (!Invariant)
+                {
+                    if (TryGetAppLocalIcuSwitchValue(out string? icuSuffixAndVersion))
+                    {
+                        LoadAppLocalIcu(icuSuffixAndVersion);
+                    }
+                    else
+                    {
+                        int loaded = LoadICU();
+                        if (loaded == 0)
+                        {
+                            Environment.FailFast(GetIcuLoadFailureMessage());
+                        }
+                    }
+                }
+            }
 
-        private static bool GetGlobalizationInvariantMode()
-        {
-            bool invariantEnabled = GetInvariantSwitchValue();
-            if (!invariantEnabled)
+            private static string GetIcuLoadFailureMessage()
             {
-                if (TryGetAppLocalIcuSwitchValue(out string? icuSuffixAndVersion))
+                // These strings can't go into resources, because a resource lookup requires globalization, which requires ICU
+                if (OperatingSystem.IsBrowser() || OperatingSystem.IsAndroid() ||
+                    OperatingSystem.IsIOS() || OperatingSystem.IsTvOS() || OperatingSystem.IsWatchOS() || OperatingSystem.IsMacCatalyst())
                 {
-                    LoadAppLocalIcu(icuSuffixAndVersion);
+                    return "Unable to load required ICU Globalization data. Please see https://aka.ms/dotnet-missing-libicu for more information";
                 }
                 else
                 {
-                    int loaded = LoadICU();
-                    if (loaded == 0 && !OperatingSystem.IsBrowser())
-                    {
-                        // This can't go into resources, because a resource lookup requires globalization, which requires ICU
-                        string message = "Couldn't find a valid ICU package installed on the system. " +
-                                         "Please install libicu using your package manager and try again. " +
-                                         "Alternatively you can set the configuration flag System.Globalization.Invariant to true if you want to run with no globalization support. " +
-                                         "Please see https://aka.ms/dotnet-missing-libicu for more information.";
-                        Environment.FailFast(message);
-                    }
-
-                    // fallback to Invariant mode if LoadICU failed (Browser).
-                    return loaded == 0;
+                    return "Couldn't find a valid ICU package installed on the system. " +
+                        "Please install libicu using your package manager and try again. " +
+                        "Alternatively you can set the configuration flag System.Globalization.Invariant to true if you want to run with no globalization support. " +
+                        "Please see https://aka.ms/dotnet-missing-libicu for more information.";
                 }
             }
-            return invariantEnabled;
         }
 
+        internal static bool UseNls => false;
+
         private static void LoadAppLocalIcuCore(ReadOnlySpan<char> version, ReadOnlySpan<char> suffix)
         {
 
diff --git a/src/libraries/System.Private.CoreLib/src/System/Globalization/GlobalizationMode.Windows.cs b/src/libraries/System.Private.CoreLib/src/System/Globalization/GlobalizationMode.Windows.cs
index 590aae9b3bdc71..e81ef6234e7b9e 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Globalization/GlobalizationMode.Windows.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Globalization/GlobalizationMode.Windows.cs
@@ -5,10 +5,6 @@ namespace System.Globalization
 {
     internal static partial class GlobalizationMode
     {
-        // Order of these properties in Windows matter because GetUseIcuMode is dependent on Invariant.
-        // So we need Invariant to be initialized first.
-        internal static bool Invariant { get; } = GetInvariantSwitchValue();
-
         internal static bool UseNls { get; } = !Invariant &&
             (AppContextConfigHelper.GetBooleanConfig("System.Globalization.UseNls", "DOTNET_SYSTEM_GLOBALIZATION_USENLS") ||
                 !LoadIcu());
diff --git a/src/libraries/System.Private.CoreLib/src/System/Globalization/GlobalizationMode.cs b/src/libraries/System.Private.CoreLib/src/System/Globalization/GlobalizationMode.cs
index e68195ea569850..5afa2a4e2b9792 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Globalization/GlobalizationMode.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Globalization/GlobalizationMode.cs
@@ -8,11 +8,18 @@ namespace System.Globalization
 {
     internal static partial class GlobalizationMode
     {
+        // split from GlobalizationMode so the whole class can be trimmed when Invariant=true.
         private static partial class Settings
         {
             internal static readonly bool PredefinedCulturesOnly = AppContextConfigHelper.GetBooleanConfig("System.Globalization.PredefinedCulturesOnly", "DOTNET_SYSTEM_GLOBALIZATION_PREDEFINED_CULTURES_ONLY");
+            internal static bool Invariant { get; } = GetInvariantSwitchValue();
         }
 
+        // Note: Invariant=true and Invariant=false are substituted at different levels in the ILLink.Substitutions file.
+        // This allows for the whole Settings nested class to be trimmed when Invariant=true, and allows for the Settings
+        // static cctor (on Unix) to be preserved when Invariant=false.
+        internal static bool Invariant => Settings.Invariant;
+
         internal static bool PredefinedCulturesOnly => !Invariant && Settings.PredefinedCulturesOnly;
 
         private static bool GetInvariantSwitchValue() =>
diff --git a/src/libraries/System.Private.CoreLib/src/System/Half.cs b/src/libraries/System.Private.CoreLib/src/System/Half.cs
index 63d81ec68af8b1..c5c5b353581645 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Half.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Half.cs
@@ -491,7 +491,7 @@ public static explicit operator Half(float value)
         {
             const int SingleMaxExponent = 0xFF;
 
-            uint floatInt = (uint)BitConverter.SingleToInt32Bits(value);
+            uint floatInt = BitConverter.SingleToUInt32Bits(value);
             bool sign = (floatInt & float.SignMask) >> float.SignShift != 0;
             int exp = (int)(floatInt & float.ExponentMask) >> float.ExponentShift;
             uint sig = floatInt & float.SignificandMask;
@@ -519,7 +519,7 @@ public static explicit operator Half(double value)
         {
             const int DoubleMaxExponent = 0x7FF;
 
-            ulong doubleInt = (ulong)BitConverter.DoubleToInt64Bits(value);
+            ulong doubleInt = BitConverter.DoubleToUInt64Bits(value);
             bool sign = (doubleInt & double.SignMask) >> double.SignShift != 0;
             int exp = (int)((doubleInt & double.ExponentMask) >> double.ExponentShift);
             ulong sig = doubleInt & double.SignificandMask;
@@ -561,7 +561,7 @@ public static explicit operator float(Half value)
             {
                 if (sig == 0)
                 {
-                    return BitConverter.Int32BitsToSingle((int)(sign ? float.SignMask : 0)); // Positive / Negative zero
+                    return BitConverter.UInt32BitsToSingle(sign ? float.SignMask : 0); // Positive / Negative zero
                 }
                 (exp, sig) = NormSubnormalF16Sig(sig);
                 exp -= 1;
@@ -589,7 +589,7 @@ public static explicit operator double(Half value)
             {
                 if (sig == 0)
                 {
-                    return BitConverter.Int64BitsToDouble((long)(sign ? double.SignMask : 0)); // Positive / Negative zero
+                    return BitConverter.UInt64BitsToDouble(sign ? double.SignMask : 0); // Positive / Negative zero
                 }
                 (exp, sig) = NormSubnormalF16Sig(sig);
                 exp -= 1;
@@ -621,7 +621,7 @@ private static Half CreateHalfNaN(bool sign, ulong significand)
             uint signInt = (sign ? 1U : 0U) << SignShift;
             uint sigInt = (uint)(significand >> 54);
 
-            return BitConverter.Int16BitsToHalf((short)(signInt | NaNBits | sigInt));
+            return BitConverter.UInt16BitsToHalf((ushort)(signInt | NaNBits | sigInt));
         }
 
         private static ushort RoundPackToHalf(bool sign, short exp, ushort sig)
@@ -670,7 +670,7 @@ private static float CreateSingleNaN(bool sign, ulong significand)
             uint signInt = (sign ? 1U : 0U) << float.SignShift;
             uint sigInt = (uint)(significand >> 41);
 
-            return BitConverter.Int32BitsToSingle((int)(signInt | NaNBits | sigInt));
+            return BitConverter.UInt32BitsToSingle(signInt | NaNBits | sigInt);
         }
 
         private static double CreateDoubleNaN(bool sign, ulong significand)
@@ -680,14 +680,14 @@ private static double CreateDoubleNaN(bool sign, ulong significand)
             ulong signInt = (sign ? 1UL : 0UL) << double.SignShift;
             ulong sigInt = significand >> 12;
 
-            return BitConverter.Int64BitsToDouble((long)(signInt | NaNBits | sigInt));
+            return BitConverter.UInt64BitsToDouble(signInt | NaNBits | sigInt);
         }
 
         private static float CreateSingle(bool sign, byte exp, uint sig)
-            => BitConverter.Int32BitsToSingle((int)(((sign ? 1U : 0U) << float.SignShift) + ((uint)exp << float.ExponentShift) + sig));
+            => BitConverter.UInt32BitsToSingle(((sign ? 1U : 0U) << float.SignShift) + ((uint)exp << float.ExponentShift) + sig);
 
         private static double CreateDouble(bool sign, ushort exp, ulong sig)
-            => BitConverter.Int64BitsToDouble((long)(((sign ? 1UL : 0UL) << double.SignShift) + ((ulong)exp << double.ExponentShift) + sig));
+            => BitConverter.UInt64BitsToDouble(((sign ? 1UL : 0UL) << double.SignShift) + ((ulong)exp << double.ExponentShift) + sig);
 
         #endregion
     }
diff --git a/src/libraries/System.Private.CoreLib/src/System/HashCode.cs b/src/libraries/System.Private.CoreLib/src/System/HashCode.cs
index 7a87e99416aa1b..d9735f05b44348 100644
--- a/src/libraries/System.Private.CoreLib/src/System/HashCode.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/HashCode.cs
@@ -44,6 +44,8 @@ A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 using System.ComponentModel;
 using System.Numerics;
 using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using Internal.Runtime.CompilerServices;
 
 namespace System
 {
@@ -305,6 +307,32 @@ public void Add<T>(T value, IEqualityComparer<T>? comparer)
             Add(value is null ? 0 : (comparer?.GetHashCode(value) ?? value.GetHashCode()));
         }
 
+        /// <summary>Adds a span of bytes to the hash code.</summary>
+        /// <param name="value">The span.</param>
+        /// <remarks>
+        /// This method does not guarantee that the result of adding a span of bytes will match
+        /// the result of adding the same bytes individually.
+        /// </remarks>
+        public void AddBytes(ReadOnlySpan<byte> value)
+        {
+            ref byte pos = ref MemoryMarshal.GetReference(value);
+            ref byte end = ref Unsafe.Add(ref pos, value.Length);
+
+            // Add four bytes at a time until the input has fewer than four bytes remaining.
+            while ((nint)Unsafe.ByteOffset(ref pos, ref end) >= sizeof(int))
+            {
+                Add(Unsafe.ReadUnaligned<int>(ref pos));
+                pos = ref Unsafe.Add(ref pos, sizeof(int));
+            }
+
+            // Add the remaining bytes a single byte at a time.
+            while (Unsafe.IsAddressLessThan(ref pos, ref end))
+            {
+                Add((int)pos);
+                pos = ref Unsafe.Add(ref pos, 1);
+            }
+        }
+
         private void Add(int value)
         {
             // The original xxHash works as follows:
diff --git a/src/libraries/System.Private.CoreLib/src/System/IO/Enumeration/FileSystemEnumerator.Win32.cs b/src/libraries/System.Private.CoreLib/src/System/IO/Enumeration/FileSystemEnumerator.Win32.cs
index 22e990194f5d88..3b90d71120edaf 100644
--- a/src/libraries/System.Private.CoreLib/src/System/IO/Enumeration/FileSystemEnumerator.Win32.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/IO/Enumeration/FileSystemEnumerator.Win32.cs
@@ -20,12 +20,13 @@ private unsafe bool GetData()
         {
             Debug.Assert(_directoryHandle != (IntPtr)(-1) && _directoryHandle != IntPtr.Zero && !_lastEntryFound);
 
+            Interop.NtDll.IO_STATUS_BLOCK statusBlock;
             int status = Interop.NtDll.NtQueryDirectoryFile(
                 FileHandle: _directoryHandle,
                 Event: IntPtr.Zero,
                 ApcRoutine: IntPtr.Zero,
                 ApcContext: IntPtr.Zero,
-                IoStatusBlock: out Interop.NtDll.IO_STATUS_BLOCK statusBlock,
+                IoStatusBlock: &statusBlock,
                 FileInformation: _buffer,
                 Length: (uint)_bufferLength,
                 FileInformationClass: Interop.NtDll.FILE_INFORMATION_CLASS.FileFullDirectoryInformation,
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 4fbe87cc925869..626dc761e807b7 100644
--- a/src/libraries/System.Private.CoreLib/src/System/IO/File.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/IO/File.cs
@@ -1,12 +1,10 @@
 // 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.Buffers;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
-using System.IO;
 using System.Runtime.ExceptionServices;
 using System.Runtime.Versioning;
 using System.Text;
@@ -14,6 +12,9 @@
 using System.Threading.Tasks;
 
 #if MS_IO_REDIST
+using System;
+using System.IO;
+
 namespace Microsoft.IO
 #else
 namespace System.IO
@@ -21,7 +22,7 @@ namespace System.IO
 {
     // Class for creating FileStream objects, and some basic file management
     // routines such as Delete, etc.
-    public static class File
+    public static partial class File
     {
         // Don't use Array.MaxLength. MS.IO.Redist targets .NET Framework.
         private const int MaxByteArrayLength = 0x7FFFFFC7;
@@ -263,8 +264,7 @@ public static FileStream OpenRead(string path)
 
         public static FileStream OpenWrite(string path)
         {
-            return new FileStream(path, FileMode.OpenOrCreate,
-                                  FileAccess.Write, FileShare.None);
+            return new FileStream(path, FileMode.OpenOrCreate, FileAccess.Write, FileShare.None);
         }
 
         public static string ReadAllText(string path)
@@ -364,52 +364,6 @@ public static byte[] ReadAllBytes(string path)
             }
         }
 
-#if !MS_IO_REDIST
-        private static byte[] ReadAllBytesUnknownLength(FileStream fs)
-        {
-            byte[]? rentedArray = null;
-            Span<byte> buffer = stackalloc byte[512];
-            try
-            {
-                int bytesRead = 0;
-                while (true)
-                {
-                    if (bytesRead == buffer.Length)
-                    {
-                        uint newLength = (uint)buffer.Length * 2;
-                        if (newLength > MaxByteArrayLength)
-                        {
-                            newLength = (uint)Math.Max(MaxByteArrayLength, buffer.Length + 1);
-                        }
-
-                        byte[] tmp = ArrayPool<byte>.Shared.Rent((int)newLength);
-                        buffer.CopyTo(tmp);
-                        if (rentedArray != null)
-                        {
-                            ArrayPool<byte>.Shared.Return(rentedArray);
-                        }
-                        buffer = rentedArray = tmp;
-                    }
-
-                    Debug.Assert(bytesRead < buffer.Length);
-                    int n = fs.Read(buffer.Slice(bytesRead));
-                    if (n == 0)
-                    {
-                        return buffer.Slice(0, bytesRead).ToArray();
-                    }
-                    bytesRead += n;
-                }
-            }
-            finally
-            {
-                if (rentedArray != null)
-                {
-                    ArrayPool<byte>.Shared.Return(rentedArray);
-                }
-            }
-        }
-#endif
-
         public static void WriteAllBytes(string path, byte[] bytes)
         {
             if (path == null)
diff --git a/src/libraries/System.Private.CoreLib/src/System/IO/File.netcoreapp.cs b/src/libraries/System.Private.CoreLib/src/System/IO/File.netcoreapp.cs
new file mode 100644
index 00000000000000..b5502ff9926cb8
--- /dev/null
+++ b/src/libraries/System.Private.CoreLib/src/System/IO/File.netcoreapp.cs
@@ -0,0 +1,101 @@
+// 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 Microsoft.Win32.SafeHandles;
+
+namespace System.IO
+{
+    public static partial class File
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="FileStream" /> class with the specified path, creation mode, read/write and sharing permission, the access other FileStreams can have to the same file, the buffer size, additional file options and the allocation size.
+        /// </summary>
+        /// <remarks><see cref="FileStream(string,System.IO.FileStreamOptions)"/> for information about exceptions.</remarks>
+        public static FileStream Open(string path, FileStreamOptions options) => new FileStream(path, options);
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="Microsoft.Win32.SafeHandles.SafeFileHandle" /> class with the specified path, creation mode, read/write and sharing permission, the access other SafeFileHandles can have to the same file, additional file options and the allocation size.
+        /// </summary>
+        /// <param name="path">A relative or absolute path for the file that the current <see cref="Microsoft.Win32.SafeHandles.SafeFileHandle" /> instance will encapsulate.</param>
+        /// <param name="mode">One of the enumeration values that determines how to open or create the file. The default value is <see cref="FileMode.Open" /></param>
+        /// <param name="access">A bitwise combination of the enumeration values that determines how the file can be accessed. The default value is <see cref="FileAccess.Read" /></param>
+        /// <param name="share">A bitwise combination of the enumeration values that determines how the file will be shared by processes. The default value is <see cref="FileShare.Read" />.</param>
+        /// <param name="preallocationSize">The initial allocation size in bytes for the file. A positive value is effective only when a regular file is being created, overwritten, or replaced.
+        /// Negative values are not allowed. In other cases (including the default 0 value), it's ignored.</param>
+        /// <param name="options">An object that describes optional <see cref="Microsoft.Win32.SafeHandles.SafeFileHandle" /> parameters to use.</param>
+        /// <exception cref="T:System.ArgumentNullException"><paramref name="path" /> is <see langword="null" />.</exception>
+        /// <exception cref="T:System.ArgumentException"><paramref name="path" /> is an empty string (""), contains only white space, or contains one or more invalid characters.
+        /// -or-
+        /// <paramref name="path" /> refers to a non-file device, such as <c>CON:</c>, <c>COM1:</c>, <c>LPT1:</c>, etc. in an NTFS environment.</exception>
+        /// <exception cref="T:System.NotSupportedException"><paramref name="path" /> refers to a non-file device, such as <c>CON:</c>, <c>COM1:</c>, <c>LPT1:</c>, etc. in a non-NTFS environment.</exception>
+        /// <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="preallocationSize" /> is negative.
+        /// -or-
+        /// <paramref name="mode" />, <paramref name="access" />, or <paramref name="share" /> contain an invalid value.</exception>
+        /// <exception cref="T:System.IO.FileNotFoundException">The file cannot be found, such as when <paramref name="mode" /> is <see cref="FileMode.Truncate" /> or <see cref="FileMode.Open" />, and the file specified by <paramref name="path" /> does not exist. The file must already exist in these modes.</exception>
+        /// <exception cref="T:System.IO.IOException">An I/O error, such as specifying <see cref="FileMode.CreateNew" /> when the file specified by <paramref name="path" /> already exists, occurred.
+        ///  -or-
+        ///  The disk was full (when <paramref name="preallocationSize" /> was provided and <paramref name="path" /> was pointing to a regular file).
+        ///  -or-
+        ///  The file was too large (when <paramref name="preallocationSize" /> was provided and <paramref name="path" /> was pointing to a regular file).</exception>
+        /// <exception cref="T:System.Security.SecurityException">The caller does not have the required permission.</exception>
+        /// <exception cref="T:System.IO.DirectoryNotFoundException">The specified path is invalid, such as being on an unmapped drive.</exception>
+        /// <exception cref="T:System.UnauthorizedAccessException">The <paramref name="access" /> requested is not permitted by the operating system for the specified <paramref name="path" />, such as when <paramref name="access" />  is <see cref="FileAccess.Write" /> or <see cref="FileAccess.ReadWrite" /> and the file or directory is set for read-only access.
+        ///  -or-
+        /// <see cref="F:System.IO.FileOptions.Encrypted" /> is specified for <paramref name="options" />, but file encryption is not supported on the current platform.</exception>
+        /// <exception cref="T:System.IO.PathTooLongException">The specified path, file name, or both exceed the system-defined maximum length. </exception>
+        public static SafeFileHandle OpenHandle(string path, FileMode mode = FileMode.Open, FileAccess access = FileAccess.Read,
+            FileShare share = FileShare.Read, FileOptions options = FileOptions.None, long preallocationSize = 0)
+        {
+            Strategies.FileStreamHelpers.ValidateArguments(path, mode, access, share, bufferSize: 0, options, preallocationSize);
+
+            return SafeFileHandle.Open(Path.GetFullPath(path), mode, access, share, options, preallocationSize);
+        }
+
+        private static byte[] ReadAllBytesUnknownLength(FileStream fs)
+        {
+            byte[]? rentedArray = null;
+            Span<byte> buffer = stackalloc byte[512];
+            try
+            {
+                int bytesRead = 0;
+                while (true)
+                {
+                    if (bytesRead == buffer.Length)
+                    {
+                        uint newLength = (uint)buffer.Length * 2;
+                        if (newLength > Array.MaxLength)
+                        {
+                            newLength = (uint)Math.Max(Array.MaxLength, buffer.Length + 1);
+                        }
+
+                        byte[] tmp = ArrayPool<byte>.Shared.Rent((int)newLength);
+                        buffer.CopyTo(tmp);
+                        byte[]? oldRentedArray = rentedArray;
+                        buffer = rentedArray = tmp;
+                        if (oldRentedArray != null)
+                        {
+                            ArrayPool<byte>.Shared.Return(oldRentedArray);
+                        }
+                    }
+
+                    Debug.Assert(bytesRead < buffer.Length);
+                    int n = fs.Read(buffer.Slice(bytesRead));
+                    if (n == 0)
+                    {
+                        return buffer.Slice(0, bytesRead).ToArray();
+                    }
+                    bytesRead += n;
+                }
+            }
+            finally
+            {
+                if (rentedArray != null)
+                {
+                    ArrayPool<byte>.Shared.Return(rentedArray);
+                }
+            }
+        }
+    }
+}
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 fc391cdf814755..c7401018a83811 100644
--- a/src/libraries/System.Private.CoreLib/src/System/IO/FileInfo.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/IO/FileInfo.cs
@@ -122,7 +122,7 @@ public FileStream Open(FileMode mode, FileAccess access, FileShare share)
             => new FileStream(NormalizedPath, mode, access, share);
 
         public FileStream OpenRead()
-            => new FileStream(NormalizedPath, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, false);
+            => new FileStream(NormalizedPath, FileMode.Open, FileAccess.Read, FileShare.Read, File.DefaultBufferSize, false);
 
         public FileStream OpenWrite()
             => new FileStream(NormalizedPath, FileMode.OpenOrCreate, FileAccess.Write, FileShare.None);
diff --git a/src/libraries/System.Private.CoreLib/src/System/IO/FileInfo.netcoreapp.cs b/src/libraries/System.Private.CoreLib/src/System/IO/FileInfo.netcoreapp.cs
new file mode 100644
index 00000000000000..4c6c5f343e24fa
--- /dev/null
+++ b/src/libraries/System.Private.CoreLib/src/System/IO/FileInfo.netcoreapp.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.
+
+namespace System.IO
+{
+    public sealed partial class FileInfo : FileSystemInfo
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="System.IO.FileStream" /> class with the specified creation mode, read/write and sharing permission, the access other FileStreams can have to the same file, the buffer size, additional file options and the allocation size.
+        /// </summary>
+        /// <remarks><see cref="System.IO.FileStream(string,System.IO.FileStreamOptions)"/> for information about exceptions.</remarks>
+        public FileStream Open(FileStreamOptions options) => File.Open(NormalizedPath, options);
+    }
+}
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 7cbe9e32bcbd4e..9653bd057bac3a 100644
--- a/src/libraries/System.Private.CoreLib/src/System/IO/FileStream.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/IO/FileStream.cs
@@ -3,7 +3,6 @@
 
 using System.ComponentModel;
 using System.IO.Strategies;
-using System.Runtime.Serialization;
 using System.Runtime.Versioning;
 using System.Threading;
 using System.Threading.Tasks;
@@ -17,29 +16,26 @@ public class FileStream : Stream
         internal const FileShare DefaultShare = FileShare.Read;
         private const bool DefaultIsAsync = false;
 
-        /// <summary>Caches whether Serialization Guard has been disabled for file writes</summary>
-        private static int s_cachedSerializationSwitch;
-
         private readonly FileStreamStrategy _strategy;
 
         [EditorBrowsable(EditorBrowsableState.Never)]
         [Obsolete("This constructor has been deprecated.  Please use new FileStream(SafeFileHandle handle, FileAccess access) instead.  https://go.microsoft.com/fwlink/?linkid=14202")]
         public FileStream(IntPtr handle, FileAccess access)
-            : this(handle, access, true, DefaultBufferSize, false)
+            : this(handle, access, true, DefaultBufferSize, DefaultIsAsync)
         {
         }
 
         [EditorBrowsable(EditorBrowsableState.Never)]
         [Obsolete("This constructor has been deprecated.  Please use new FileStream(SafeFileHandle handle, FileAccess access) instead, and optionally make a new SafeFileHandle with ownsHandle=false if needed.  https://go.microsoft.com/fwlink/?linkid=14202")]
         public FileStream(IntPtr handle, FileAccess access, bool ownsHandle)
-            : this(handle, access, ownsHandle, DefaultBufferSize, false)
+            : this(handle, access, ownsHandle, DefaultBufferSize, DefaultIsAsync)
         {
         }
 
         [EditorBrowsable(EditorBrowsableState.Never)]
         [Obsolete("This constructor has been deprecated.  Please use new FileStream(SafeFileHandle handle, FileAccess access, int bufferSize) instead, and optionally make a new SafeFileHandle with ownsHandle=false if needed.  https://go.microsoft.com/fwlink/?linkid=14202")]
         public FileStream(IntPtr handle, FileAccess access, bool ownsHandle, int bufferSize)
-            : this(handle, access, ownsHandle, bufferSize, false)
+            : this(handle, access, ownsHandle, bufferSize, DefaultIsAsync)
         {
         }
 
@@ -68,7 +64,7 @@ public FileStream(IntPtr handle, FileAccess access, bool ownsHandle, int bufferS
             }
         }
 
-        private static void ValidateHandle(SafeFileHandle handle, FileAccess access, int bufferSize, bool isAsync)
+        private static void ValidateHandle(SafeFileHandle handle, FileAccess access, int bufferSize)
         {
             if (handle.IsInvalid)
             {
@@ -78,17 +74,27 @@ private static void ValidateHandle(SafeFileHandle handle, FileAccess access, int
             {
                 throw new ArgumentOutOfRangeException(nameof(access), SR.ArgumentOutOfRange_Enum);
             }
-            else if (bufferSize <= 0)
+            else if (bufferSize < 0)
             {
-                throw new ArgumentOutOfRangeException(nameof(bufferSize), SR.ArgumentOutOfRange_NeedPosNum);
+                ThrowHelper.ThrowArgumentOutOfRangeException_NeedNonNegNum(nameof(bufferSize));
             }
             else if (handle.IsClosed)
             {
                 ThrowHelper.ThrowObjectDisposedException_FileClosed();
             }
-            else if (handle.IsAsync.HasValue && isAsync != handle.IsAsync.GetValueOrDefault())
+        }
+
+        private static void ValidateHandle(SafeFileHandle handle, FileAccess access, int bufferSize, bool isAsync)
+        {
+            ValidateHandle(handle, access, bufferSize);
+
+            if (isAsync && !handle.IsAsync)
             {
-                throw new ArgumentException(SR.Arg_HandleNotAsync, nameof(handle));
+                ThrowHelper.ThrowArgumentException_HandleNotAsync(nameof(handle));
+            }
+            else if (!isAsync && handle.IsAsync)
+            {
+                ThrowHelper.ThrowArgumentException_HandleNotSync(nameof(handle));
             }
         }
 
@@ -98,8 +104,10 @@ public FileStream(SafeFileHandle handle, FileAccess access)
         }
 
         public FileStream(SafeFileHandle handle, FileAccess access, int bufferSize)
-            : this(handle, access, bufferSize, FileStreamHelpers.GetDefaultIsAsync(handle, DefaultIsAsync))
         {
+            ValidateHandle(handle, access, bufferSize);
+
+            _strategy = FileStreamHelpers.ChooseStrategy(this, handle, access, DefaultShare, bufferSize, handle.IsAsync);
         }
 
         public FileStream(SafeFileHandle handle, FileAccess access, int bufferSize, bool isAsync)
@@ -144,16 +152,11 @@ public FileStream(string path, FileMode mode, FileAccess access, FileShare share
         /// </summary>
         /// <param name="path">A relative or absolute path for the file that the current <see cref="System.IO.FileStream" /> instance will encapsulate.</param>
         /// <param name="options">An object that describes optional <see cref="System.IO.FileStream" /> parameters to use.</param>
-        /// <exception cref="T:System.ArgumentNullException"><paramref name="path" /> is <see langword="null" />.</exception>
+        /// <exception cref="T:System.ArgumentNullException"><paramref name="path" /> or <paramref name="options" /> is <see langword="null" />.</exception>
         /// <exception cref="T:System.ArgumentException"><paramref name="path" /> is an empty string (""), contains only white space, or contains one or more invalid characters.
         /// -or-
         /// <paramref name="path" /> refers to a non-file device, such as <c>CON:</c>, <c>COM1:</c>, <c>LPT1:</c>, etc. in an NTFS environment.</exception>
         /// <exception cref="T:System.NotSupportedException"><paramref name="path" /> refers to a non-file device, such as <c>CON:</c>, <c>COM1:</c>, <c>LPT1:</c>, etc. in a non-NTFS environment.</exception>
-        /// <exception cref="T:System.ArgumentOutOfRangeException"><see cref="System.IO.FileStreamOptions.BufferSize" /> is negative.
-        /// -or-
-        /// <see cref="System.IO.FileStreamOptions.PreallocationSize" /> is negative.
-        /// -or-
-        /// <see cref="System.IO.FileStreamOptions.Mode" />, <see cref="System.IO.FileStreamOptions.Access" />, or <see cref="System.IO.FileStreamOptions.Share" /> contain an invalid value.</exception>
         /// <exception cref="T:System.IO.FileNotFoundException">The file cannot be found, such as when <see cref="System.IO.FileStreamOptions.Mode" /> is <see langword="FileMode.Truncate" /> or <see langword="FileMode.Open" />, and the file specified by <paramref name="path" /> does not exist. The file must already exist in these modes.</exception>
         /// <exception cref="T:System.IO.IOException">An I/O error, such as specifying <see langword="FileMode.CreateNew" /> when the file specified by <paramref name="path" /> already exists, occurred.
         ///  -or-
@@ -169,13 +172,8 @@ public FileStream(string path, FileMode mode, FileAccess access, FileShare share
         /// <see cref="F:System.IO.FileOptions.Encrypted" /> is specified for <see cref="System.IO.FileStreamOptions.Options" /> , but file encryption is not supported on the current platform.</exception>
         /// <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)
-            : this(path, options.Mode, options.Access, options.Share, options.BufferSize, options.Options, options.PreallocationSize)
-        {
-        }
-
-        private FileStream(string path, FileMode mode, FileAccess access, FileShare share, int bufferSize, FileOptions options, long preallocationSize)
         {
-            if (path == null)
+            if (path is null)
             {
                 throw new ArgumentNullException(nameof(path), SR.ArgumentNull_Path);
             }
@@ -183,61 +181,31 @@ private FileStream(string path, FileMode mode, FileAccess access, FileShare shar
             {
                 throw new ArgumentException(SR.Argument_EmptyPath, nameof(path));
             }
-
-            // don't include inheritable in our bounds check for share
-            FileShare tempshare = share & ~FileShare.Inheritable;
-            string? badArg = null;
-
-            if (mode < FileMode.CreateNew || mode > FileMode.Append)
+            else if (options is null)
             {
-                badArg = nameof(mode);
+                throw new ArgumentNullException(nameof(options));
             }
-            else if (access < FileAccess.Read || access > FileAccess.ReadWrite)
+            else if ((options.Access & FileAccess.Read) != 0 && options.Mode == FileMode.Append)
             {
-                badArg = nameof(access);
+                throw new ArgumentException(SR.Argument_InvalidAppendMode, nameof(options));
             }
-            else if (tempshare < FileShare.None || tempshare > (FileShare.ReadWrite | FileShare.Delete))
+            else if ((options.Access & FileAccess.Write) == 0)
             {
-                badArg = nameof(share);
-            }
-
-            if (badArg != null)
-            {
-                throw new ArgumentOutOfRangeException(badArg, SR.ArgumentOutOfRange_Enum);
-            }
-
-            // NOTE: any change to FileOptions enum needs to be matched here in the error validation
-            if (options != FileOptions.None && (options & ~(FileOptions.WriteThrough | FileOptions.Asynchronous | FileOptions.RandomAccess | FileOptions.DeleteOnClose | FileOptions.SequentialScan | FileOptions.Encrypted | (FileOptions)0x20000000 /* NoBuffering */)) != 0)
-            {
-                throw new ArgumentOutOfRangeException(nameof(options), SR.ArgumentOutOfRange_Enum);
-            }
-            else if (bufferSize < 0)
-            {
-                throw new ArgumentOutOfRangeException(nameof(bufferSize), SR.ArgumentOutOfRange_NeedPosNum);
-            }
-            else if (preallocationSize < 0)
-            {
-                throw new ArgumentOutOfRangeException(nameof(preallocationSize), SR.ArgumentOutOfRange_NeedNonNegNum);
-            }
-
-            // Write access validation
-            if ((access & FileAccess.Write) == 0)
-            {
-                if (mode == FileMode.Truncate || mode == FileMode.CreateNew || mode == FileMode.Create || mode == FileMode.Append)
+                if (options.Mode == FileMode.Truncate || options.Mode == FileMode.CreateNew || options.Mode == FileMode.Create || options.Mode == FileMode.Append)
                 {
-                    // No write access, mode and access disagree but flag access since mode comes first
-                    throw new ArgumentException(SR.Format(SR.Argument_InvalidFileModeAndAccessCombo, mode, access), nameof(access));
+                    throw new ArgumentException(SR.Format(SR.Argument_InvalidFileModeAndAccessCombo, options.Mode, options.Access), nameof(options));
                 }
             }
 
-            if ((access & FileAccess.Read) != 0 && mode == FileMode.Append)
-            {
-                throw new ArgumentException(SR.Argument_InvalidAppendMode, nameof(access));
-            }
-            else if ((access & FileAccess.Write) == FileAccess.Write)
-            {
-                SerializationInfo.ThrowIfDeserializationInProgress("AllowFileWrites", ref s_cachedSerializationSwitch);
-            }
+            FileStreamHelpers.SerializationGuard(options.Access);
+
+            _strategy = FileStreamHelpers.ChooseStrategy(
+                this, path, options.Mode, options.Access, options.Share, options.BufferSize, options.Options, options.PreallocationSize);
+        }
+
+        private FileStream(string path, FileMode mode, FileAccess access, FileShare share, int bufferSize, FileOptions options, long preallocationSize)
+        {
+            FileStreamHelpers.ValidateArguments(path, mode, access, share, bufferSize, options, preallocationSize);
 
             _strategy = FileStreamHelpers.ChooseStrategy(this, path, mode, access, share, bufferSize, options, preallocationSize);
         }
@@ -253,7 +221,7 @@ public virtual void Lock(long position, long length)
         {
             if (position < 0 || length < 0)
             {
-                throw new ArgumentOutOfRangeException(position < 0 ? nameof(position) : nameof(length), SR.ArgumentOutOfRange_NeedNonNegNum);
+                ThrowHelper.ThrowArgumentOutOfRangeException_NeedNonNegNum(position < 0 ? nameof(position) : nameof(length));
             }
             else if (_strategy.IsClosed)
             {
@@ -271,7 +239,7 @@ public virtual void Unlock(long position, long length)
         {
             if (position < 0 || length < 0)
             {
-                throw new ArgumentOutOfRangeException(position < 0 ? nameof(position) : nameof(length), SR.ArgumentOutOfRange_NeedNonNegNum);
+                ThrowHelper.ThrowArgumentOutOfRangeException_NeedNonNegNum(position < 0 ? nameof(position) : nameof(length));
             }
             else if (_strategy.IsClosed)
             {
diff --git a/src/libraries/System.Private.CoreLib/src/System/IO/FileStreamOptions.cs b/src/libraries/System.Private.CoreLib/src/System/IO/FileStreamOptions.cs
index b2279d4c9256e1..491d739de40f5b 100644
--- a/src/libraries/System.Private.CoreLib/src/System/IO/FileStreamOptions.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/IO/FileStreamOptions.cs
@@ -5,32 +5,109 @@ namespace System.IO
 {
     public sealed class FileStreamOptions
     {
+        private FileMode _mode = FileMode.Open;
+        private FileAccess _access = FileAccess.Read;
+        private FileShare _share = FileStream.DefaultShare;
+        private FileOptions _options;
+        private long _preallocationSize;
+        private int _bufferSize = FileStream.DefaultBufferSize;
+
         /// <summary>
         /// One of the enumeration values that determines how to open or create the file.
         /// </summary>
-        public FileMode Mode { get; set; }
+        /// <exception cref="T:System.ArgumentOutOfRangeException">When <paramref name="value" /> contains an invalid value.</exception>
+        public FileMode Mode
+        {
+            get => _mode;
+            set
+            {
+                if (value < FileMode.CreateNew || value > FileMode.Append)
+                {
+                    ThrowHelper.ArgumentOutOfRangeException_Enum_Value();
+                }
+
+                _mode = value;
+            }
+        }
+
         /// <summary>
         /// A bitwise combination of the enumeration values that determines how the file can be accessed by the <see cref="FileStream" /> object. This also determines the values returned by the <see cref="System.IO.FileStream.CanRead" /> and <see cref="System.IO.FileStream.CanWrite" /> properties of the <see cref="FileStream" /> object.
         /// </summary>
-        public FileAccess Access { get; set; } = FileAccess.Read;
+        /// <exception cref="T:System.ArgumentOutOfRangeException">When <paramref name="value" /> contains an invalid value.</exception>
+        public FileAccess Access
+        {
+            get => _access;
+            set
+            {
+                if (value < FileAccess.Read || value > FileAccess.ReadWrite)
+                {
+                    ThrowHelper.ArgumentOutOfRangeException_Enum_Value();
+                }
+
+                _access = value;
+            }
+        }
+
         /// <summary>
         /// A bitwise combination of the enumeration values that determines how the file will be shared by processes. The default value is <see cref="System.IO.FileShare.Read" />.
         /// </summary>
-        public FileShare Share { get; set; } = FileStream.DefaultShare;
+        /// <exception cref="T:System.ArgumentOutOfRangeException">When <paramref name="value" /> contains an invalid value.</exception>
+        public FileShare Share
+        {
+            get => _share;
+            set
+            {
+                // don't include inheritable in our bounds check for share
+                FileShare tempshare = value & ~FileShare.Inheritable;
+                if (tempshare < FileShare.None || tempshare > (FileShare.ReadWrite | FileShare.Delete))
+                {
+                    ThrowHelper.ArgumentOutOfRangeException_Enum_Value();
+                }
+
+                _share = value;
+            }
+        }
+
         /// <summary>
         /// A bitwise combination of the enumeration values that specifies additional file options. The default value is <see cref="System.IO.FileOptions.None" />, which indicates synchronous IO.
         /// </summary>
-        public FileOptions Options { get; set; }
+        /// <exception cref="T:System.ArgumentOutOfRangeException">When <paramref name="value" /> contains an invalid value.</exception>
+        public FileOptions Options
+        {
+            get => _options;
+            set
+            {
+                // NOTE: any change to FileOptions enum needs to be matched here in the error validation
+                if (value != FileOptions.None && (value & ~(FileOptions.WriteThrough | FileOptions.Asynchronous | FileOptions.RandomAccess | FileOptions.DeleteOnClose | FileOptions.SequentialScan | FileOptions.Encrypted | (FileOptions)0x20000000 /* NoBuffering */)) != 0)
+                {
+                    ThrowHelper.ArgumentOutOfRangeException_Enum_Value();
+                }
+
+                _options = value;
+            }
+        }
+
         /// <summary>
         /// The initial allocation size in bytes for the file. A positive value is effective only when a regular file is being created, overwritten, or replaced.
-        /// When the value is negative, the <see cref="FileStream" /> constructor throws an <see cref="ArgumentOutOfRangeException" />.
+        /// Negative values are not allowed.
         /// In other cases (including the default 0 value), it's ignored.
         /// </summary>
-        public long PreallocationSize { get; set; }
+        /// <exception cref="T:System.ArgumentOutOfRangeException">When <paramref name="value" /> is negative.</exception>
+        public long PreallocationSize
+        {
+            get => _preallocationSize;
+            set => _preallocationSize = value >= 0 ? value : throw new ArgumentOutOfRangeException(nameof(value), SR.ArgumentOutOfRange_NeedNonNegNum);
+        }
+
         /// <summary>
         /// The size of the buffer used by <see cref="FileStream" /> for buffering. The default buffer size is 4096.
         /// 0 or 1 means that buffering should be disabled. Negative values are not allowed.
         /// </summary>
-        public int BufferSize { get; set; } = FileStream.DefaultBufferSize;
+        /// <exception cref="T:System.ArgumentOutOfRangeException">When <paramref name="value" /> is negative.</exception>
+        public int BufferSize
+        {
+            get => _bufferSize;
+            set => _bufferSize = value >= 0 ? value : throw new ArgumentOutOfRangeException(nameof(value), SR.ArgumentOutOfRange_NeedNonNegNum);
+        }
     }
 }
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 ecc990b07c6e1b..5a7f0c8d1bbe5b 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
@@ -129,17 +129,5 @@ public static ReadOnlySpan<char> GetPathRoot(ReadOnlySpan<char> path)
             return IsPathRooted(path) ? PathInternal.DirectorySeparatorCharAsString.AsSpan() : ReadOnlySpan<char>.Empty;
         }
 
-        /// <summary>Gets whether the system is case-sensitive.</summary>
-        internal static bool IsCaseSensitive
-        {
-            get
-            {
-                #if TARGET_OSX || TARGET_MACCATALYST || TARGET_IOS || TARGET_TVOS
-                    return false;
-                #else
-                    return true;
-                #endif
-            }
-        }
     }
 }
diff --git a/src/libraries/System.Private.CoreLib/src/System/IO/Path.Windows.cs b/src/libraries/System.Private.CoreLib/src/System/IO/Path.Windows.cs
index 5e641806926b88..5f4b8e11a19206 100644
--- a/src/libraries/System.Private.CoreLib/src/System/IO/Path.Windows.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/IO/Path.Windows.cs
@@ -230,9 +230,6 @@ public static ReadOnlySpan<char> GetPathRoot(ReadOnlySpan<char> path)
             return pathRoot <= 0 ? ReadOnlySpan<char>.Empty : path.Slice(0, pathRoot);
         }
 
-        /// <summary>Gets whether the system is case-sensitive.</summary>
-        internal static bool IsCaseSensitive => false;
-
         /// <summary>
         /// Returns the volume name for dos, UNC and device paths.
         /// </summary>
diff --git a/src/libraries/System.Private.CoreLib/src/System/IO/Path.cs b/src/libraries/System.Private.CoreLib/src/System/IO/Path.cs
index 7601e45e074d1d..104704de7b7154 100644
--- a/src/libraries/System.Private.CoreLib/src/System/IO/Path.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/IO/Path.cs
@@ -860,7 +860,7 @@ private static unsafe void Populate83FileNameFromRandomBytes(byte* bytes, int by
         /// <exception cref="ArgumentNullException">Thrown if <paramref name="relativeTo"/> or <paramref name="path"/> is <c>null</c> or an empty string.</exception>
         public static string GetRelativePath(string relativeTo, string path)
         {
-            return GetRelativePath(relativeTo, path, StringComparison);
+            return GetRelativePath(relativeTo, path, PathInternal.StringComparison);
         }
 
         private static string GetRelativePath(string relativeTo, string path, StringComparison comparisonType)
@@ -957,12 +957,6 @@ private static string GetRelativePath(string relativeTo, string path, StringComp
             return sb.ToString();
         }
 
-        /// <summary>Returns a comparison that can be used to compare file and directory names for equality.</summary>
-        internal static StringComparison StringComparison =>
-            IsCaseSensitive ?
-                StringComparison.Ordinal :
-                StringComparison.OrdinalIgnoreCase;
-
         /// <summary>
         /// Trims one trailing directory separator beyond the root of the path.
         /// </summary>
diff --git a/src/libraries/System.Private.CoreLib/src/System/IO/RandomAccess.Unix.cs b/src/libraries/System.Private.CoreLib/src/System/IO/RandomAccess.Unix.cs
new file mode 100644
index 00000000000000..22a3934fe4089e
--- /dev/null
+++ b/src/libraries/System.Private.CoreLib/src/System/IO/RandomAccess.Unix.cs
@@ -0,0 +1,153 @@
+// 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.Collections.Generic;
+using System.IO.Strategies;
+using System.Runtime.InteropServices;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Win32.SafeHandles;
+
+namespace System.IO
+{
+    public static partial class RandomAccess
+    {
+        // IovStackThreshold matches Linux's UIO_FASTIOV, which is the number of 'struct iovec'
+        // that get stackalloced in the Linux kernel.
+        private const int IovStackThreshold = 8;
+
+        internal static long GetFileLength(SafeFileHandle handle, string? path)
+        {
+            int result = Interop.Sys.FStat(handle, out Interop.Sys.FileStatus status);
+            FileStreamHelpers.CheckFileCall(result, path);
+            return status.Size;
+        }
+
+        private static unsafe int ReadAtOffset(SafeFileHandle handle, Span<byte> buffer, long fileOffset)
+        {
+            fixed (byte* bufPtr = &MemoryMarshal.GetReference(buffer))
+            {
+                int result = Interop.Sys.PRead(handle, bufPtr, buffer.Length, fileOffset);
+                FileStreamHelpers.CheckFileCall(result, path: null);
+                return result;
+            }
+        }
+
+        private static unsafe long ReadScatterAtOffset(SafeFileHandle handle, IReadOnlyList<Memory<byte>> buffers, long fileOffset)
+        {
+            MemoryHandle[] handles = new MemoryHandle[buffers.Count];
+            Span<Interop.Sys.IOVector> vectors = buffers.Count <= IovStackThreshold ? stackalloc Interop.Sys.IOVector[IovStackThreshold] : new Interop.Sys.IOVector[buffers.Count];
+
+            long result;
+            try
+            {
+                int buffersCount = buffers.Count;
+                for (int i = 0; i < buffersCount; i++)
+                {
+                    Memory<byte> buffer = buffers[i];
+                    MemoryHandle memoryHandle = buffer.Pin();
+                    vectors[i] = new Interop.Sys.IOVector { Base = (byte*)memoryHandle.Pointer, Count = (UIntPtr)buffer.Length };
+                    handles[i] = memoryHandle;
+                }
+
+                fixed (Interop.Sys.IOVector* pinnedVectors = &MemoryMarshal.GetReference(vectors))
+                {
+                    result = Interop.Sys.PReadV(handle, pinnedVectors, buffers.Count, fileOffset);
+                }
+            }
+            finally
+            {
+                foreach (MemoryHandle memoryHandle in handles)
+                {
+                    memoryHandle.Dispose();
+                }
+            }
+
+            return FileStreamHelpers.CheckFileCall(result, path: null);
+        }
+
+        private static ValueTask<int> ReadAtOffsetAsync(SafeFileHandle handle, Memory<byte> buffer, long fileOffset,
+            CancellationToken cancellationToken)
+        {
+            return new ValueTask<int>(Task.Factory.StartNew(static state =>
+            {
+                var args = ((SafeFileHandle handle, Memory<byte> buffer, long fileOffset))state!;
+                return ReadAtOffset(args.handle, args.buffer.Span, args.fileOffset);
+            }, (handle, buffer, fileOffset), cancellationToken, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default));
+        }
+
+        private static ValueTask<long> ReadScatterAtOffsetAsync(SafeFileHandle handle, IReadOnlyList<Memory<byte>> buffers,
+            long fileOffset, CancellationToken cancellationToken)
+        {
+            return new ValueTask<long>(Task.Factory.StartNew(static state =>
+            {
+                var args = ((SafeFileHandle handle, IReadOnlyList<Memory<byte>> buffers, long fileOffset))state!;
+                return ReadScatterAtOffset(args.handle, args.buffers, args.fileOffset);
+            }, (handle, buffers, fileOffset), cancellationToken, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default));
+        }
+
+        private static unsafe int WriteAtOffset(SafeFileHandle handle, ReadOnlySpan<byte> buffer, long fileOffset)
+        {
+            fixed (byte* bufPtr = &MemoryMarshal.GetReference(buffer))
+            {
+                int result = Interop.Sys.PWrite(handle, bufPtr, buffer.Length, fileOffset);
+                FileStreamHelpers.CheckFileCall(result, path: null);
+                return  result;
+            }
+        }
+
+        private static unsafe long WriteGatherAtOffset(SafeFileHandle handle, IReadOnlyList<ReadOnlyMemory<byte>> buffers, long fileOffset)
+        {
+            MemoryHandle[] handles = new MemoryHandle[buffers.Count];
+            Span<Interop.Sys.IOVector> vectors = buffers.Count <= IovStackThreshold ? stackalloc Interop.Sys.IOVector[IovStackThreshold] : new Interop.Sys.IOVector[buffers.Count ];
+
+            long result;
+            try
+            {
+                int buffersCount = buffers.Count;
+                for (int i = 0; i < buffersCount; i++)
+                {
+                    ReadOnlyMemory<byte> buffer = buffers[i];
+                    MemoryHandle memoryHandle = buffer.Pin();
+                    vectors[i] = new Interop.Sys.IOVector { Base = (byte*)memoryHandle.Pointer, Count = (UIntPtr)buffer.Length };
+                    handles[i] = memoryHandle;
+                }
+
+                fixed (Interop.Sys.IOVector* pinnedVectors = &MemoryMarshal.GetReference(vectors))
+                {
+                    result = Interop.Sys.PWriteV(handle, pinnedVectors, buffers.Count, fileOffset);
+                }
+            }
+            finally
+            {
+                foreach (MemoryHandle memoryHandle in handles)
+                {
+                    memoryHandle.Dispose();
+                }
+            }
+
+            return FileStreamHelpers.CheckFileCall(result, path: null);
+        }
+
+        private static ValueTask<int> WriteAtOffsetAsync(SafeFileHandle handle, ReadOnlyMemory<byte> buffer, long fileOffset,
+            CancellationToken cancellationToken)
+        {
+            return new ValueTask<int>(Task.Factory.StartNew(static state =>
+            {
+                var args = ((SafeFileHandle handle, ReadOnlyMemory<byte> buffer, long fileOffset))state!;
+                return WriteAtOffset(args.handle, args.buffer.Span, args.fileOffset);
+            }, (handle, buffer, fileOffset), cancellationToken, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default));
+        }
+
+        private static ValueTask<long> WriteGatherAtOffsetAsync(SafeFileHandle handle, IReadOnlyList<ReadOnlyMemory<byte>> buffers,
+            long fileOffset, CancellationToken cancellationToken)
+        {
+            return new ValueTask<long>(Task.Factory.StartNew(static state =>
+            {
+                var args = ((SafeFileHandle handle, IReadOnlyList<ReadOnlyMemory<byte>> buffers, long fileOffset))state!;
+                return WriteGatherAtOffset(args.handle, args.buffers, args.fileOffset);
+            }, (handle, buffers, fileOffset), cancellationToken, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default));
+        }
+    }
+}
diff --git a/src/libraries/System.Private.CoreLib/src/System/IO/RandomAccess.Windows.cs b/src/libraries/System.Private.CoreLib/src/System/IO/RandomAccess.Windows.cs
new file mode 100644
index 00000000000000..5d198ccb0785c5
--- /dev/null
+++ b/src/libraries/System.Private.CoreLib/src/System/IO/RandomAccess.Windows.cs
@@ -0,0 +1,558 @@
+// 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.Collections.Generic;
+using System.Diagnostics;
+using System.IO.Strategies;
+using System.Runtime.InteropServices;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Win32.SafeHandles;
+
+namespace System.IO
+{
+    public static partial class RandomAccess
+    {
+        internal static unsafe long GetFileLength(SafeFileHandle handle, string? path)
+        {
+            Interop.Kernel32.FILE_STANDARD_INFO info;
+
+            if (!Interop.Kernel32.GetFileInformationByHandleEx(handle, Interop.Kernel32.FileStandardInfo, &info, (uint)sizeof(Interop.Kernel32.FILE_STANDARD_INFO)))
+            {
+                throw Win32Marshal.GetExceptionForLastWin32Error(path);
+            }
+
+            return info.EndOfFile;
+        }
+
+        internal static unsafe int ReadAtOffset(SafeFileHandle handle, Span<byte> buffer, long fileOffset, string? path = null)
+        {
+            NativeOverlapped nativeOverlapped = GetNativeOverlapped(fileOffset);
+            int r = ReadFileNative(handle, buffer, syncUsingOverlapped: true, &nativeOverlapped, out int errorCode);
+
+            if (r == -1)
+            {
+                // For pipes, ERROR_BROKEN_PIPE is the normal end of the pipe.
+                if (errorCode == Interop.Errors.ERROR_BROKEN_PIPE)
+                {
+                    r = 0;
+                }
+                else
+                {
+                    if (errorCode == Interop.Errors.ERROR_INVALID_PARAMETER)
+                    {
+                        ThrowHelper.ThrowArgumentException_HandleNotSync(nameof(handle));
+                    }
+
+                    throw Win32Marshal.GetExceptionForWin32Error(errorCode, path);
+                }
+            }
+
+            return r;
+        }
+
+        internal static unsafe int WriteAtOffset(SafeFileHandle handle, ReadOnlySpan<byte> buffer, long fileOffset, string? path = null)
+        {
+            NativeOverlapped nativeOverlapped = GetNativeOverlapped(fileOffset);
+            int r = WriteFileNative(handle, buffer, true, &nativeOverlapped, out int errorCode);
+
+            if (r == -1)
+            {
+                // For pipes, ERROR_NO_DATA is not an error, but the pipe is closing.
+                if (errorCode == Interop.Errors.ERROR_NO_DATA)
+                {
+                    r = 0;
+                }
+                else
+                {
+                    // ERROR_INVALID_PARAMETER may be returned for writes
+                    // where the position is too large or for synchronous writes
+                    // to a handle opened asynchronously.
+                    if (errorCode == Interop.Errors.ERROR_INVALID_PARAMETER)
+                    {
+                        throw new IOException(SR.IO_FileTooLongOrHandleNotSync);
+                    }
+
+                    throw Win32Marshal.GetExceptionForWin32Error(errorCode, path);
+                }
+            }
+
+            return r;
+        }
+
+        internal static unsafe int ReadFileNative(SafeFileHandle handle, Span<byte> bytes, bool syncUsingOverlapped, NativeOverlapped* overlapped, out int errorCode)
+        {
+            Debug.Assert(handle != null, "handle != null");
+
+            int r;
+            int numBytesRead = 0;
+
+            fixed (byte* p = &MemoryMarshal.GetReference(bytes))
+            {
+                r = overlapped == null || syncUsingOverlapped ?
+                        Interop.Kernel32.ReadFile(handle, p, bytes.Length, out numBytesRead, overlapped) :
+                        Interop.Kernel32.ReadFile(handle, p, bytes.Length, IntPtr.Zero, overlapped);
+            }
+
+            if (r == 0)
+            {
+                errorCode = FileStreamHelpers.GetLastWin32ErrorAndDisposeHandleIfInvalid(handle);
+
+                if (syncUsingOverlapped && errorCode == Interop.Errors.ERROR_HANDLE_EOF)
+                {
+                    // https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-readfile#synchronization-and-file-position :
+                    // "If lpOverlapped is not NULL, then when a synchronous read operation reaches the end of a file,
+                    // ReadFile returns FALSE and GetLastError returns ERROR_HANDLE_EOF"
+                    return numBytesRead;
+                }
+
+                return -1;
+            }
+            else
+            {
+                errorCode = 0;
+                return numBytesRead;
+            }
+        }
+
+        internal static unsafe int WriteFileNative(SafeFileHandle handle, ReadOnlySpan<byte> buffer, bool syncUsingOverlapped, NativeOverlapped* overlapped, out int errorCode)
+        {
+            Debug.Assert(handle != null, "handle != null");
+
+            int numBytesWritten = 0;
+            int r;
+
+            fixed (byte* p = &MemoryMarshal.GetReference(buffer))
+            {
+                r = overlapped == null || syncUsingOverlapped ?
+                        Interop.Kernel32.WriteFile(handle, p, buffer.Length, out numBytesWritten, overlapped) :
+                        Interop.Kernel32.WriteFile(handle, p, buffer.Length, IntPtr.Zero, overlapped);
+            }
+
+            if (r == 0)
+            {
+                errorCode = FileStreamHelpers.GetLastWin32ErrorAndDisposeHandleIfInvalid(handle);
+                return -1;
+            }
+            else
+            {
+                errorCode = 0;
+                return numBytesWritten;
+            }
+        }
+
+        private static ValueTask<int> ReadAtOffsetAsync(SafeFileHandle handle, Memory<byte> buffer, long fileOffset, CancellationToken cancellationToken)
+            => Map(QueueAsyncReadFile(handle, buffer, fileOffset, cancellationToken));
+
+        private static ValueTask<int> Map((SafeFileHandle.ValueTaskSource? vts, int errorCode) tuple)
+            => tuple.vts != null
+                ? new ValueTask<int>(tuple.vts, tuple.vts.Version)
+                : tuple.errorCode == 0 ? ValueTask.FromResult(0) : ValueTask.FromException<int>(Win32Marshal.GetExceptionForWin32Error(tuple.errorCode));
+
+        internal static unsafe (SafeFileHandle.ValueTaskSource? vts, int errorCode) QueueAsyncReadFile(
+            SafeFileHandle handle, Memory<byte> buffer, long fileOffset, CancellationToken cancellationToken)
+        {
+            SafeFileHandle.ValueTaskSource vts = handle.GetValueTaskSource();
+            try
+            {
+                NativeOverlapped* nativeOverlapped = vts.PrepareForOperation(buffer, fileOffset);
+                Debug.Assert(vts._memoryHandle.Pointer != null);
+
+                // Queue an async ReadFile operation.
+                if (Interop.Kernel32.ReadFile(handle, (byte*)vts._memoryHandle.Pointer, buffer.Length, IntPtr.Zero, nativeOverlapped) == 0)
+                {
+                    // The operation failed, or it's pending.
+                    int errorCode = FileStreamHelpers.GetLastWin32ErrorAndDisposeHandleIfInvalid(handle);
+                    switch (errorCode)
+                    {
+                        case Interop.Errors.ERROR_IO_PENDING:
+                            // Common case: IO was initiated, completion will be handled by callback.
+                            // Register for cancellation now that the operation has been initiated.
+                            vts.RegisterForCancellation(cancellationToken);
+                            break;
+
+                        case Interop.Errors.ERROR_HANDLE_EOF: // logically success with 0 bytes read (read at end of file)
+                        case Interop.Errors.ERROR_BROKEN_PIPE:
+                            // EOF on a pipe. Callback will not be called.
+                            // We clear the overlapped status bit for this special case (failure
+                            // to do so looks like we are freeing a pending overlapped later).
+                            nativeOverlapped->InternalLow = IntPtr.Zero;
+                            vts.Dispose();
+                            return (null, 0);
+
+                        default:
+                            // Error. Callback will not be called.
+                            vts.Dispose();
+                            return (null, errorCode);
+                    }
+                }
+            }
+            catch
+            {
+                vts.Dispose();
+                throw;
+            }
+
+            // Completion handled by callback.
+            vts.FinishedScheduling();
+            return (vts, -1);
+        }
+
+        private static ValueTask<int> WriteAtOffsetAsync(SafeFileHandle handle, ReadOnlyMemory<byte> buffer, long fileOffset, CancellationToken cancellationToken)
+           => Map(QueueAsyncWriteFile(handle, buffer, fileOffset, cancellationToken));
+
+        internal static unsafe (SafeFileHandle.ValueTaskSource? vts, int errorCode) QueueAsyncWriteFile(
+            SafeFileHandle handle, ReadOnlyMemory<byte> buffer, long fileOffset, CancellationToken cancellationToken)
+        {
+            SafeFileHandle.ValueTaskSource vts = handle.GetValueTaskSource();
+            try
+            {
+                NativeOverlapped* nativeOverlapped = vts.PrepareForOperation(buffer, fileOffset);
+                Debug.Assert(vts._memoryHandle.Pointer != null);
+
+                // Queue an async WriteFile operation.
+                if (Interop.Kernel32.WriteFile(handle, (byte*)vts._memoryHandle.Pointer, buffer.Length, IntPtr.Zero, nativeOverlapped) == 0)
+                {
+                    // The operation failed, or it's pending.
+                    int errorCode = FileStreamHelpers.GetLastWin32ErrorAndDisposeHandleIfInvalid(handle);
+                    switch (errorCode)
+                    {
+                        case Interop.Errors.ERROR_IO_PENDING:
+                            // Common case: IO was initiated, completion will be handled by callback.
+                            // Register for cancellation now that the operation has been initiated.
+                            vts.RegisterForCancellation(cancellationToken);
+                            break;
+                        case Interop.Errors.ERROR_NO_DATA: // EOF on a pipe. IO callback will not be called.
+                            vts.Dispose();
+                            return (null, 0);
+                        default:
+                            // Error. Callback will not be invoked.
+                            vts.Dispose();
+                            return (null, errorCode);
+                    }
+                }
+            }
+            catch
+            {
+                vts.Dispose();
+                throw;
+            }
+
+            // Completion handled by callback.
+            vts.FinishedScheduling();
+            return (vts, -1);
+        }
+
+        private static long ReadScatterAtOffset(SafeFileHandle handle, IReadOnlyList<Memory<byte>> buffers, long fileOffset)
+        {
+            long total = 0;
+
+            // ReadFileScatter does not support sync handles, so we just call ReadFile in a loop
+            for (int i = 0; i < buffers.Count; i++)
+            {
+                Span<byte> span = buffers[i].Span;
+                int read = ReadAtOffset(handle, span, fileOffset + total);
+                total += read;
+
+                // We stop on the first incomplete read.
+                // Most probably there is no more data available and the next read is going to return 0 (EOF).
+                if (read != span.Length)
+                {
+                    break;
+                }
+            }
+
+            return total;
+        }
+
+        private static long WriteGatherAtOffset(SafeFileHandle handle, IReadOnlyList<ReadOnlyMemory<byte>> buffers, long fileOffset)
+        {
+            long total = 0;
+
+            // WriteFileGather does not support sync handles, so we just call WriteFile in a loop
+            for (int i = 0; i < buffers.Count; i++)
+            {
+                ReadOnlySpan<byte> span = buffers[i].Span;
+                int written = WriteAtOffset(handle, span, fileOffset + total);
+                total += written;
+
+                // We stop on the first incomplete write.
+                // Most probably the disk became full and the next write is going to throw.
+                if (written != span.Length)
+                {
+                    break;
+                }
+            }
+
+            return total;
+        }
+
+        private static ValueTask<long> ReadScatterAtOffsetAsync(SafeFileHandle handle, IReadOnlyList<Memory<byte>> buffers,
+            long fileOffset, CancellationToken cancellationToken)
+        {
+            if (CanUseScatterGatherWindowsAPIs(handle))
+            {
+                long totalBytes = 0;
+                for (int i = 0; i < buffers.Count; i++)
+                {
+                    totalBytes += buffers[i].Length;
+                }
+
+                if (totalBytes <= int.MaxValue) // the ReadFileScatter API uses int, not long
+                {
+                    return ReadScatterAtOffsetSingleSyscallAsync(handle, buffers, fileOffset, (int)totalBytes, cancellationToken);
+                }
+            }
+
+            return ReadScatterAtOffsetMultipleSyscallsAsync(handle, buffers, fileOffset, cancellationToken);
+        }
+
+        // From https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-readfilescatter:
+        // "The file handle must be created with the GENERIC_READ right, and the FILE_FLAG_OVERLAPPED and FILE_FLAG_NO_BUFFERING flags."
+        private static bool CanUseScatterGatherWindowsAPIs(SafeFileHandle handle)
+            => handle.IsAsync && ((handle.GetFileOptions() & SafeFileHandle.NoBuffering) != 0);
+
+        private static async ValueTask<long> ReadScatterAtOffsetSingleSyscallAsync(SafeFileHandle handle,
+            IReadOnlyList<Memory<byte>> buffers, long fileOffset, int totalBytes, CancellationToken cancellationToken)
+        {
+            if (buffers.Count == 1)
+            {
+                // we have to await it because we can't cast a VT<int> to VT<long>
+                return await ReadAtOffsetAsync(handle, buffers[0], fileOffset, cancellationToken).ConfigureAwait(false);
+            }
+
+            // "The array must contain enough elements to store nNumberOfBytesToWrite bytes of data, and one element for the terminating NULL. "
+            long[] fileSegments = new long[buffers.Count + 1];
+            fileSegments[buffers.Count] = 0;
+
+            MemoryHandle[] memoryHandles = new MemoryHandle[buffers.Count];
+            MemoryHandle pinnedSegments = fileSegments.AsMemory().Pin();
+
+            try
+            {
+                for (int i = 0; i < buffers.Count; i++)
+                {
+                    Memory<byte> buffer = buffers[i];
+                    MemoryHandle memoryHandle = buffer.Pin();
+                    memoryHandles[i] = memoryHandle;
+
+                    unsafe // awaits can't be in an unsafe context
+                    {
+                        fileSegments[i] = new IntPtr(memoryHandle.Pointer).ToInt64();
+                    }
+                }
+
+                return await ReadFileScatterAsync(handle, pinnedSegments, totalBytes, fileOffset, cancellationToken).ConfigureAwait(false);
+            }
+            finally
+            {
+                foreach (MemoryHandle memoryHandle in memoryHandles)
+                {
+                    memoryHandle.Dispose();
+                }
+                pinnedSegments.Dispose();
+            }
+        }
+
+        private static unsafe ValueTask<int> ReadFileScatterAsync(SafeFileHandle handle, MemoryHandle pinnedSegments,
+            int bytesToRead, long fileOffset, CancellationToken cancellationToken)
+        {
+            SafeFileHandle.ValueTaskSource vts = handle.GetValueTaskSource();
+            try
+            {
+                NativeOverlapped* nativeOverlapped = vts.PrepareForOperation(Memory<byte>.Empty, fileOffset);
+                Debug.Assert(pinnedSegments.Pointer != null);
+
+                if (Interop.Kernel32.ReadFileScatter(handle, (long*)pinnedSegments.Pointer, bytesToRead, IntPtr.Zero, nativeOverlapped) == 0)
+                {
+                    // The operation failed, or it's pending.
+                    int errorCode = FileStreamHelpers.GetLastWin32ErrorAndDisposeHandleIfInvalid(handle);
+                    switch (errorCode)
+                    {
+                        case Interop.Errors.ERROR_IO_PENDING:
+                            // Common case: IO was initiated, completion will be handled by callback.
+                            // Register for cancellation now that the operation has been initiated.
+                            vts.RegisterForCancellation(cancellationToken);
+                            break;
+
+                        case Interop.Errors.ERROR_HANDLE_EOF: // logically success with 0 bytes read (read at end of file)
+                        case Interop.Errors.ERROR_BROKEN_PIPE:
+                            // EOF on a pipe. Callback will not be called.
+                            // We clear the overlapped status bit for this special case (failure
+                            // to do so looks like we are freeing a pending overlapped later).
+                            nativeOverlapped->InternalLow = IntPtr.Zero;
+                            vts.Dispose();
+                            return ValueTask.FromResult(0);
+
+                        default:
+                            // Error. Callback will not be called.
+                            vts.Dispose();
+                            return ValueTask.FromException<int>(Win32Marshal.GetExceptionForWin32Error(errorCode));
+                    }
+                }
+            }
+            catch
+            {
+                vts.Dispose();
+                throw;
+            }
+
+            // Completion handled by callback.
+            vts.FinishedScheduling();
+            return new ValueTask<int>(vts, vts.Version);
+        }
+
+        private static async ValueTask<long> ReadScatterAtOffsetMultipleSyscallsAsync(SafeFileHandle handle, IReadOnlyList<Memory<byte>> buffers,
+            long fileOffset, CancellationToken cancellationToken)
+        {
+            long total = 0;
+
+            for (int i = 0; i < buffers.Count; i++)
+            {
+                Memory<byte> buffer = buffers[i];
+                int read = await ReadAtOffsetAsync(handle, buffer, fileOffset + total, cancellationToken).ConfigureAwait(false);
+                total += read;
+
+                if (read != buffer.Length)
+                {
+                    break;
+                }
+            }
+
+            return total;
+        }
+
+        private static ValueTask<long> WriteGatherAtOffsetAsync(SafeFileHandle handle, IReadOnlyList<ReadOnlyMemory<byte>> buffers,
+            long fileOffset, CancellationToken cancellationToken)
+        {
+            if (CanUseScatterGatherWindowsAPIs(handle))
+            {
+                long totalBytes = 0;
+                for (int i = 0; i < buffers.Count; i++)
+                {
+                    totalBytes += buffers[i].Length;
+                }
+
+                if (totalBytes <= int.MaxValue) // the ReadFileScatter API uses int, not long
+                {
+                    return WriteGatherAtOffsetSingleSyscallAsync(handle, buffers, fileOffset, (int)totalBytes, cancellationToken);
+                }
+            }
+
+            return WriteGatherAtOffsetMultipleSyscallsAsync(handle, buffers, fileOffset, cancellationToken);
+        }
+
+        private static async ValueTask<long> WriteGatherAtOffsetMultipleSyscallsAsync(SafeFileHandle handle, IReadOnlyList<ReadOnlyMemory<byte>> buffers,
+            long fileOffset, CancellationToken cancellationToken)
+        {
+            long total = 0;
+
+            for (int i = 0; i < buffers.Count; i++)
+            {
+                ReadOnlyMemory<byte> buffer = buffers[i];
+                int written = await WriteAtOffsetAsync(handle, buffer, fileOffset + total, cancellationToken).ConfigureAwait(false);
+                total += written;
+
+                if (written != buffer.Length)
+                {
+                    break;
+                }
+            }
+
+            return total;
+        }
+
+        private static async ValueTask<long> WriteGatherAtOffsetSingleSyscallAsync(SafeFileHandle handle, IReadOnlyList<ReadOnlyMemory<byte>> buffers,
+            long fileOffset, int totalBytes, CancellationToken cancellationToken)
+        {
+            if (buffers.Count == 1)
+            {
+                return await WriteAtOffsetAsync(handle, buffers[0], fileOffset, cancellationToken).ConfigureAwait(false);
+            }
+
+            // "The array must contain enough elements to store nNumberOfBytesToWrite bytes of data, and one element for the terminating NULL. "
+            long[] fileSegments = new long[buffers.Count + 1];
+            fileSegments[buffers.Count] = 0;
+
+            MemoryHandle[] memoryHandles = new MemoryHandle[buffers.Count];
+            MemoryHandle pinnedSegments = fileSegments.AsMemory().Pin();
+
+            try
+            {
+                for (int i = 0; i < buffers.Count; i++)
+                {
+                    ReadOnlyMemory<byte> buffer = buffers[i];
+                    MemoryHandle memoryHandle = buffer.Pin();
+                    memoryHandles[i] = memoryHandle;
+
+                    unsafe // awaits can't be in an unsafe context
+                    {
+                        fileSegments[i] = new IntPtr(memoryHandle.Pointer).ToInt64();
+                    }
+                }
+
+                return await WriteFileGatherAsync(handle, pinnedSegments, totalBytes, fileOffset, cancellationToken).ConfigureAwait(false);
+            }
+            finally
+            {
+                foreach (MemoryHandle memoryHandle in memoryHandles)
+                {
+                    memoryHandle.Dispose();
+                }
+                pinnedSegments.Dispose();
+            }
+        }
+
+        private static unsafe ValueTask<int> WriteFileGatherAsync(SafeFileHandle handle, MemoryHandle pinnedSegments,
+            int bytesToWrite, long fileOffset, CancellationToken cancellationToken)
+        {
+            SafeFileHandle.ValueTaskSource vts = handle.GetValueTaskSource();
+            try
+            {
+                NativeOverlapped* nativeOverlapped = vts.PrepareForOperation(ReadOnlyMemory<byte>.Empty, fileOffset);
+                Debug.Assert(pinnedSegments.Pointer != null);
+
+                // Queue an async WriteFile operation.
+                if (Interop.Kernel32.WriteFileGather(handle, (long*)pinnedSegments.Pointer, bytesToWrite, IntPtr.Zero, nativeOverlapped) == 0)
+                {
+                    // The operation failed, or it's pending.
+                    int errorCode = FileStreamHelpers.GetLastWin32ErrorAndDisposeHandleIfInvalid(handle);
+                    if (errorCode == Interop.Errors.ERROR_IO_PENDING)
+                    {
+                        // Common case: IO was initiated, completion will be handled by callback.
+                        // Register for cancellation now that the operation has been initiated.
+                        vts.RegisterForCancellation(cancellationToken);
+                    }
+                    else
+                    {
+                        // Error. Callback will not be invoked.
+                        vts.Dispose();
+                        return errorCode == Interop.Errors.ERROR_NO_DATA // EOF on a pipe. IO callback will not be called.
+                            ? ValueTask.FromResult<int>(0)
+                            : ValueTask.FromException<int>(SafeFileHandle.ValueTaskSource.GetIOError(errorCode, path: null));
+                    }
+                }
+            }
+            catch
+            {
+                vts.Dispose();
+                throw;
+            }
+
+            // Completion handled by callback.
+            vts.FinishedScheduling();
+            return new ValueTask<int>(vts, vts.Version);
+        }
+
+        private static NativeOverlapped GetNativeOverlapped(long fileOffset)
+        {
+            NativeOverlapped nativeOverlapped = default;
+            // For pipes the offsets are ignored by the OS
+            nativeOverlapped.OffsetLow = unchecked((int)fileOffset);
+            nativeOverlapped.OffsetHigh = (int)(fileOffset >> 32);
+
+            return nativeOverlapped;
+        }
+    }
+}
diff --git a/src/libraries/System.Private.CoreLib/src/System/IO/RandomAccess.cs b/src/libraries/System.Private.CoreLib/src/System/IO/RandomAccess.cs
new file mode 100644
index 00000000000000..199d0d4ea91c51
--- /dev/null
+++ b/src/libraries/System.Private.CoreLib/src/System/IO/RandomAccess.cs
@@ -0,0 +1,283 @@
+// 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.Threading;
+using System.Threading.Tasks;
+using Microsoft.Win32.SafeHandles;
+
+namespace System.IO
+{
+    public static partial class RandomAccess
+    {
+        /// <summary>
+        /// Gets the length of the file in bytes.
+        /// </summary>
+        /// <param name="handle">The file handle.</param>
+        /// <returns>A long value representing the length of the file in bytes.</returns>
+        /// <exception cref="T:System.ArgumentNullException"><paramref name="handle" /> is <see langword="null" />.</exception>
+        /// <exception cref="T:System.ArgumentException"><paramref name="handle" /> is invalid.</exception>
+        /// <exception cref="T:System.ObjectDisposedException">The file is closed.</exception>
+        /// <exception cref="T:System.NotSupportedException">The file does not support seeking (pipe or socket).</exception>
+        public static long GetLength(SafeFileHandle handle)
+        {
+            ValidateInput(handle, fileOffset: 0);
+
+            return GetFileLength(handle, path: null);
+        }
+
+        /// <summary>
+        /// Reads a sequence of bytes from given file at given offset.
+        /// </summary>
+        /// <param name="handle">The file handle.</param>
+        /// <param name="buffer">A region of memory. When this method returns, the contents of this region are replaced by the bytes read from the file.</param>
+        /// <param name="fileOffset">The file position to read from.</param>
+        /// <returns>The total number of bytes read into the buffer. This can be less than the number of bytes allocated in the buffer if that many bytes are not currently available, or zero (0) if the end of the file has been reached.</returns>
+        /// <exception cref="T:System.ArgumentNullException"><paramref name="handle" /> is <see langword="null" />.</exception>
+        /// <exception cref="T:System.ArgumentException"><paramref name="handle" /> is invalid.</exception>
+        /// <exception cref="T:System.ObjectDisposedException">The file is closed.</exception>
+        /// <exception cref="T:System.NotSupportedException">The file does not support seeking (pipe or socket).</exception>
+        /// <exception cref="T:System.ArgumentException"><paramref name="handle" /> was opened for async IO.</exception>
+        /// <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="fileOffset" /> is negative.</exception>
+        /// <exception cref="T:System.UnauthorizedAccessException"><paramref name="handle" /> was not opened for reading.</exception>
+        /// <exception cref="T:System.IO.IOException">An I/O error occurred.</exception>
+        /// <remarks>Position of the file is not advanced.</remarks>
+        public static int Read(SafeFileHandle handle, Span<byte> buffer, long fileOffset)
+        {
+            ValidateInput(handle, fileOffset, mustBeSync: OperatingSystem.IsWindows());
+
+            return ReadAtOffset(handle, buffer, fileOffset);
+        }
+
+        /// <summary>
+        /// Reads a sequence of bytes from given file at given offset.
+        /// </summary>
+        /// <param name="handle">The file handle.</param>
+        /// <param name="buffers">A list of memory buffers. When this method returns, the contents of the buffers are replaced by the bytes read from the file.</param>
+        /// <param name="fileOffset">The file position to read from.</param>
+        /// <returns>The total number of bytes read into the buffers. This can be less than the number of bytes allocated in the buffers if that many bytes are not currently available, or zero (0) if the end of the file has been reached.</returns>
+        /// <exception cref="T:System.ArgumentNullException"><paramref name="handle" /> or <paramref name="buffers" /> is <see langword="null" />.</exception>
+        /// <exception cref="T:System.ArgumentException"><paramref name="handle" /> is invalid.</exception>
+        /// <exception cref="T:System.ObjectDisposedException">The file is closed.</exception>
+        /// <exception cref="T:System.NotSupportedException">The file does not support seeking (pipe or socket).</exception>
+        /// <exception cref="T:System.ArgumentException"><paramref name="handle" /> was opened for async IO.</exception>
+        /// <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="fileOffset" /> is negative.</exception>
+        /// <exception cref="T:System.UnauthorizedAccessException"><paramref name="handle" /> was not opened for reading.</exception>
+        /// <exception cref="T:System.IO.IOException">An I/O error occurred.</exception>
+        /// <remarks>Position of the file is not advanced.</remarks>
+        public static long Read(SafeFileHandle handle, IReadOnlyList<Memory<byte>> buffers, long fileOffset)
+        {
+            ValidateInput(handle, fileOffset, mustBeSync: OperatingSystem.IsWindows());
+            ValidateBuffers(buffers);
+
+            return ReadScatterAtOffset(handle, buffers, fileOffset);
+        }
+
+        /// <summary>
+        /// Reads a sequence of bytes from given file at given offset.
+        /// </summary>
+        /// <param name="handle">The file handle.</param>
+        /// <param name="buffer">A region of memory. When this method returns, the contents of this region are replaced by the bytes read from the file.</param>
+        /// <param name="fileOffset">The file position to read from.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="P:System.Threading.CancellationToken.None" />.</param>
+        /// <returns>The total number of bytes read into the buffer. This can be less than the number of bytes allocated in the buffer if that many bytes are not currently available, or zero (0) if the end of the file has been reached.</returns>
+        /// <exception cref="T:System.ArgumentNullException"><paramref name="handle" /> is <see langword="null" />.</exception>
+        /// <exception cref="T:System.ArgumentException"><paramref name="handle" /> is invalid.</exception>
+        /// <exception cref="T:System.ObjectDisposedException">The file is closed.</exception>
+        /// <exception cref="T:System.NotSupportedException">The file does not support seeking (pipe or socket).</exception>
+        /// <exception cref="T:System.ArgumentException"><paramref name="handle" /> was not opened for async IO.</exception>
+        /// <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="fileOffset" /> is negative.</exception>
+        /// <exception cref="T:System.UnauthorizedAccessException"><paramref name="handle" /> was not opened for reading.</exception>
+        /// <exception cref="T:System.IO.IOException">An I/O error occurred.</exception>
+        /// <remarks>Position of the file is not advanced.</remarks>
+        public static ValueTask<int> ReadAsync(SafeFileHandle handle, Memory<byte> buffer, long fileOffset, CancellationToken cancellationToken = default)
+        {
+            ValidateInput(handle, fileOffset, mustBeAsync: OperatingSystem.IsWindows());
+
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return ValueTask.FromCanceled<int>(cancellationToken);
+            }
+
+            return ReadAtOffsetAsync(handle, buffer, fileOffset, cancellationToken);
+        }
+
+        /// <summary>
+        /// Reads a sequence of bytes from given file at given offset.
+        /// </summary>
+        /// <param name="handle">The file handle.</param>
+        /// <param name="buffers">A list of memory buffers. When this method returns, the contents of these buffers are replaced by the bytes read from the file.</param>
+        /// <param name="fileOffset">The file position to read from.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="P:System.Threading.CancellationToken.None" />.</param>
+        /// <returns>The total number of bytes read into the buffers. This can be less than the number of bytes allocated in the buffers if that many bytes are not currently available, or zero (0) if the end of the file has been reached.</returns>
+        /// <exception cref="T:System.ArgumentNullException"><paramref name="handle" /> or <paramref name="buffers" /> is <see langword="null" />.</exception>
+        /// <exception cref="T:System.ArgumentException"><paramref name="handle" /> is invalid.</exception>
+        /// <exception cref="T:System.ObjectDisposedException">The file is closed.</exception>
+        /// <exception cref="T:System.NotSupportedException">The file does not support seeking (pipe or socket).</exception>
+        /// <exception cref="T:System.ArgumentException"><paramref name="handle" /> was not opened for async IO.</exception>
+        /// <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="fileOffset" /> is negative.</exception>
+        /// <exception cref="T:System.UnauthorizedAccessException"><paramref name="handle" /> was not opened for reading.</exception>
+        /// <exception cref="T:System.IO.IOException">An I/O error occurred.</exception>
+        /// <remarks>Position of the file is not advanced.</remarks>
+        public static ValueTask<long> ReadAsync(SafeFileHandle handle, IReadOnlyList<Memory<byte>> buffers, long fileOffset, CancellationToken cancellationToken = default)
+        {
+            ValidateInput(handle, fileOffset, mustBeAsync: OperatingSystem.IsWindows());
+            ValidateBuffers(buffers);
+
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return ValueTask.FromCanceled<long>(cancellationToken);
+            }
+
+            return ReadScatterAtOffsetAsync(handle, buffers, fileOffset, cancellationToken);
+        }
+
+        /// <summary>
+        /// Writes a sequence of bytes from given buffer to given file at given offset.
+        /// </summary>
+        /// <param name="handle">The file handle.</param>
+        /// <param name="buffer">A region of memory. This method copies the contents of this region to the file.</param>
+        /// <param name="fileOffset">The file position to write to.</param>
+        /// <returns>The total number of bytes written into the file. This can be less than the number of bytes provided in the buffer and it's not an error.</returns>
+        /// <exception cref="T:System.ArgumentNullException"><paramref name="handle" /> is <see langword="null" />.</exception>
+        /// <exception cref="T:System.ArgumentException"><paramref name="handle" /> is invalid.</exception>
+        /// <exception cref="T:System.ObjectDisposedException">The file is closed.</exception>
+        /// <exception cref="T:System.NotSupportedException">The file does not support seeking (pipe or socket).</exception>
+        /// <exception cref="T:System.ArgumentException"><paramref name="handle" /> was opened for async IO.</exception>
+        /// <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="fileOffset" /> is negative.</exception>
+        /// <exception cref="T:System.UnauthorizedAccessException"><paramref name="handle" /> was not opened for writing.</exception>
+        /// <exception cref="T:System.IO.IOException">An I/O error occurred.</exception>
+        /// <remarks>Position of the file is not advanced.</remarks>
+        public static int Write(SafeFileHandle handle, ReadOnlySpan<byte> buffer, long fileOffset)
+        {
+            ValidateInput(handle, fileOffset, mustBeSync: OperatingSystem.IsWindows());
+
+            return WriteAtOffset(handle, buffer, fileOffset);
+        }
+
+        /// <summary>
+        /// Writes a sequence of bytes from given buffers to given file at given offset.
+        /// </summary>
+        /// <param name="handle">The file handle.</param>
+        /// <param name="buffers">A list of memory buffers. This method copies the contents of these buffers to the file.</param>
+        /// <param name="fileOffset">The file position to write to.</param>
+        /// <returns>The total number of bytes written into the file. This can be less than the number of bytes provided in the buffers and it's not an error.</returns>
+        /// <exception cref="T:System.ArgumentNullException"><paramref name="handle" /> or <paramref name="buffers" /> is <see langword="null" />.</exception>
+        /// <exception cref="T:System.ArgumentException"><paramref name="handle" /> is invalid.</exception>
+        /// <exception cref="T:System.ObjectDisposedException">The file is closed.</exception>
+        /// <exception cref="T:System.NotSupportedException">The file does not support seeking (pipe or socket).</exception>
+        /// <exception cref="T:System.ArgumentException"><paramref name="handle" /> was opened for async IO.</exception>
+        /// <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="fileOffset" /> is negative.</exception>
+        /// <exception cref="T:System.UnauthorizedAccessException"><paramref name="handle" /> was not opened for writing.</exception>
+        /// <exception cref="T:System.IO.IOException">An I/O error occurred.</exception>
+        /// <remarks>Position of the file is not advanced.</remarks>
+        public static long Write(SafeFileHandle handle, IReadOnlyList<ReadOnlyMemory<byte>> buffers, long fileOffset)
+        {
+            ValidateInput(handle, fileOffset, mustBeSync: OperatingSystem.IsWindows());
+            ValidateBuffers(buffers);
+
+            return WriteGatherAtOffset(handle, buffers, fileOffset);
+        }
+
+        /// <summary>
+        /// Writes a sequence of bytes from given buffer to given file at given offset.
+        /// </summary>
+        /// <param name="handle">The file handle.</param>
+        /// <param name="buffer">A region of memory. This method copies the contents of this region to the file.</param>
+        /// <param name="fileOffset">The file position to write to.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="P:System.Threading.CancellationToken.None" />.</param>
+        /// <returns>The total number of bytes written into the file. This can be less than the number of bytes provided in the buffer and it's not an error.</returns>
+        /// <exception cref="T:System.ArgumentNullException"><paramref name="handle" /> is <see langword="null" />.</exception>
+        /// <exception cref="T:System.ArgumentException"><paramref name="handle" /> is invalid.</exception>
+        /// <exception cref="T:System.ObjectDisposedException">The file is closed.</exception>
+        /// <exception cref="T:System.NotSupportedException">The file does not support seeking (pipe or socket).</exception>
+        /// <exception cref="T:System.ArgumentException"><paramref name="handle" /> was not opened for async IO.</exception>
+        /// <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="fileOffset" /> is negative.</exception>
+        /// <exception cref="T:System.UnauthorizedAccessException"><paramref name="handle" /> was not opened for writing.</exception>
+        /// <exception cref="T:System.IO.IOException">An I/O error occurred.</exception>
+        /// <remarks>Position of the file is not advanced.</remarks>
+        public static ValueTask<int> WriteAsync(SafeFileHandle handle, ReadOnlyMemory<byte> buffer, long fileOffset, CancellationToken cancellationToken = default)
+        {
+            ValidateInput(handle, fileOffset, mustBeAsync: OperatingSystem.IsWindows());
+
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return ValueTask.FromCanceled<int>(cancellationToken);
+            }
+
+            return WriteAtOffsetAsync(handle, buffer, fileOffset, cancellationToken);
+        }
+
+        /// <summary>
+        /// Writes a sequence of bytes from given buffers to given file at given offset.
+        /// </summary>
+        /// <param name="handle">The file handle.</param>
+        /// <param name="buffers">A list of memory buffers. This method copies the contents of these buffers to the file.</param>
+        /// <param name="fileOffset">The file position to write to.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="P:System.Threading.CancellationToken.None" />.</param>
+        /// <returns>The total number of bytes written into the file. This can be less than the number of bytes provided in the buffers and it's not an error.</returns>
+        /// <exception cref="T:System.ArgumentNullException"><paramref name="handle" /> or <paramref name="buffers"/> is <see langword="null" />.</exception>
+        /// <exception cref="T:System.ArgumentException"><paramref name="handle" /> is invalid.</exception>
+        /// <exception cref="T:System.ObjectDisposedException">The file is closed.</exception>
+        /// <exception cref="T:System.NotSupportedException">The file does not support seeking (pipe or socket).</exception>
+        /// <exception cref="T:System.ArgumentException"><paramref name="handle" /> was not opened for async IO.</exception>
+        /// <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="fileOffset" /> is negative.</exception>
+        /// <exception cref="T:System.UnauthorizedAccessException"><paramref name="handle" /> was not opened for writing.</exception>
+        /// <exception cref="T:System.IO.IOException">An I/O error occurred.</exception>
+        /// <remarks>Position of the file is not advanced.</remarks>
+        public static ValueTask<long> WriteAsync(SafeFileHandle handle, IReadOnlyList<ReadOnlyMemory<byte>> buffers, long fileOffset, CancellationToken cancellationToken = default)
+        {
+            ValidateInput(handle, fileOffset, mustBeAsync: OperatingSystem.IsWindows());
+            ValidateBuffers(buffers);
+
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return ValueTask.FromCanceled<long>(cancellationToken);
+            }
+
+            return WriteGatherAtOffsetAsync(handle, buffers, fileOffset, cancellationToken);
+        }
+
+        private static void ValidateInput(SafeFileHandle handle, long fileOffset, bool mustBeSync = false, bool mustBeAsync = false)
+        {
+            if (handle is null)
+            {
+                ThrowHelper.ThrowArgumentNullException(ExceptionArgument.handle);
+            }
+            else if (handle.IsInvalid)
+            {
+                ThrowHelper.ThrowArgumentException_InvalidHandle(nameof(handle));
+            }
+            else if (!handle.CanSeek)
+            {
+                // CanSeek calls IsClosed, we don't want to call it twice for valid handles
+                if (handle.IsClosed)
+                {
+                    ThrowHelper.ThrowObjectDisposedException_FileClosed();
+                }
+
+                ThrowHelper.ThrowNotSupportedException_UnseekableStream();
+            }
+            else if (mustBeSync && handle.IsAsync)
+            {
+                ThrowHelper.ThrowArgumentException_HandleNotSync(nameof(handle));
+            }
+            else if (mustBeAsync && !handle.IsAsync)
+            {
+                ThrowHelper.ThrowArgumentException_HandleNotAsync(nameof(handle));
+            }
+            else if (fileOffset < 0)
+            {
+                ThrowHelper.ThrowArgumentOutOfRangeException_NeedPosNum(nameof(fileOffset));
+            }
+        }
+
+        private static void ValidateBuffers<T>(IReadOnlyList<T> buffers)
+        {
+            if (buffers is null)
+            {
+                ThrowHelper.ThrowArgumentNullException(ExceptionArgument.buffers);
+            }
+        }
+    }
+}
diff --git a/src/libraries/System.Private.CoreLib/src/System/IO/Strategies/AsyncWindowsFileStreamStrategy.cs b/src/libraries/System.Private.CoreLib/src/System/IO/Strategies/AsyncWindowsFileStreamStrategy.cs
index 6719dd9389566a..a194c4802d15c1 100644
--- a/src/libraries/System.Private.CoreLib/src/System/IO/Strategies/AsyncWindowsFileStreamStrategy.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/IO/Strategies/AsyncWindowsFileStreamStrategy.cs
@@ -10,8 +10,6 @@ namespace System.IO.Strategies
 {
     internal sealed partial class AsyncWindowsFileStreamStrategy : WindowsFileStreamStrategy
     {
-        private ValueTaskSource? _reusableValueTaskSource; // reusable ValueTaskSource that is currently NOT being used
-
         internal AsyncWindowsFileStreamStrategy(SafeFileHandle handle, FileAccess access, FileShare share)
             : base(handle, access, share)
         {
@@ -24,94 +22,6 @@ internal AsyncWindowsFileStreamStrategy(string path, FileMode mode, FileAccess a
 
         internal override bool IsAsync => true;
 
-        public override ValueTask DisposeAsync()
-        {
-            // the base class must dispose ThreadPoolBinding and FileHandle
-            // before _preallocatedOverlapped is disposed
-            ValueTask result = base.DisposeAsync();
-            Debug.Assert(result.IsCompleted, "the method must be sync, as it performs no flushing");
-
-            Interlocked.Exchange(ref _reusableValueTaskSource, null)?.Dispose();
-
-            return result;
-        }
-
-        protected override void Dispose(bool disposing)
-        {
-            // the base class must dispose ThreadPoolBinding and FileHandle
-            // before _preallocatedOverlapped is disposed
-            base.Dispose(disposing);
-
-            Interlocked.Exchange(ref _reusableValueTaskSource, null)?.Dispose();
-        }
-
-        protected override void OnInitFromHandle(SafeFileHandle handle)
-        {
-            // This is necessary for async IO using IO Completion ports via our
-            // managed Threadpool API's.  This calls the OS's
-            // BindIoCompletionCallback method, and passes in a stub for the
-            // LPOVERLAPPED_COMPLETION_ROUTINE.  This stub looks at the Overlapped
-            // struct for this request and gets a delegate to a managed callback
-            // from there, which it then calls on a threadpool thread.  (We allocate
-            // our native OVERLAPPED structs 2 pointers too large and store EE
-            // state & a handle to a delegate there.)
-            //
-            // If, however, we've already bound this file handle to our completion port,
-            // don't try to bind it again because it will fail.  A handle can only be
-            // bound to a single completion port at a time.
-            if (handle.IsAsync != true)
-            {
-                try
-                {
-                    handle.ThreadPoolBinding = ThreadPoolBoundHandle.BindHandle(handle);
-                }
-                catch (Exception ex)
-                {
-                    // If you passed in a synchronous handle and told us to use
-                    // it asynchronously, throw here.
-                    throw new ArgumentException(SR.Arg_HandleNotAsync, nameof(handle), ex);
-                }
-            }
-        }
-
-        protected override void OnInit()
-        {
-            // This is necessary for async IO using IO Completion ports via our
-            // managed Threadpool API's.  This (theoretically) calls the OS's
-            // BindIoCompletionCallback method, and passes in a stub for the
-            // LPOVERLAPPED_COMPLETION_ROUTINE.  This stub looks at the Overlapped
-            // struct for this request and gets a delegate to a managed callback
-            // from there, which it then calls on a threadpool thread.  (We allocate
-            // our native OVERLAPPED structs 2 pointers too large and store EE state
-            // & GC handles there, one to an IAsyncResult, the other to a delegate.)
-            try
-            {
-                _fileHandle.ThreadPoolBinding = ThreadPoolBoundHandle.BindHandle(_fileHandle);
-            }
-            catch (ArgumentException ex)
-            {
-                throw new IOException(SR.IO_BindHandleFailed, ex);
-            }
-            finally
-            {
-                if (_fileHandle.ThreadPoolBinding == null)
-                {
-                    // We should close the handle so that the handle is not open until SafeFileHandle GC
-                    _fileHandle.Dispose();
-                }
-            }
-        }
-
-        private void TryToReuse(ValueTaskSource source)
-        {
-            source._source.Reset();
-
-            if (Interlocked.CompareExchange(ref _reusableValueTaskSource, source, null) is not null)
-            {
-                source._preallocatedOverlapped.Dispose();
-            }
-        }
-
         public override int Read(byte[] buffer, int offset, int count)
         {
             ValueTask<int> vt = ReadAsyncInternal(new Memory<byte>(buffer, offset, count), CancellationToken.None);
@@ -133,75 +43,27 @@ private unsafe ValueTask<int> ReadAsyncInternal(Memory<byte> destination, Cancel
                 ThrowHelper.ThrowNotSupportedException_UnreadableStream();
             }
 
-            // Rent the reusable ValueTaskSource, or create a new one to use if we couldn't get one (which
-            // should only happen on first use or if the FileStream is being used concurrently).
-            ValueTaskSource vts = Interlocked.Exchange(ref _reusableValueTaskSource, null) ?? new ValueTaskSource(this);
-            try
+            long positionBefore = _filePosition;
+            if (CanSeek)
             {
-                NativeOverlapped* nativeOverlapped = vts.PrepareForOperation(destination);
-                Debug.Assert(vts._memoryHandle.Pointer != null);
-
-                // Calculate position in the file we should be at after the read is done
-                long positionBefore = _filePosition;
-                if (CanSeek)
+                long len = Length;
+                if (positionBefore + destination.Length > len)
                 {
-                    long len = Length;
-
-                    if (positionBefore + destination.Length > len)
-                    {
-                        destination = positionBefore <= len ?
-                            destination.Slice(0, (int)(len - positionBefore)) :
-                            default;
-                    }
-
-                    // Now set the position to read from in the NativeOverlapped struct
-                    // For pipes, we should leave the offset fields set to 0.
-                    nativeOverlapped->OffsetLow = unchecked((int)positionBefore);
-                    nativeOverlapped->OffsetHigh = (int)(positionBefore >> 32);
-
-                    // When using overlapped IO, the OS is not supposed to
-                    // touch the file pointer location at all.  We will adjust it
-                    // ourselves, but only in memory. This isn't threadsafe.
-                    _filePosition += destination.Length;
+                    destination = positionBefore <= len ?
+                        destination.Slice(0, (int)(len - positionBefore)) :
+                        default;
                 }
 
-                // Queue an async ReadFile operation.
-                if (Interop.Kernel32.ReadFile(_fileHandle, (byte*)vts._memoryHandle.Pointer, destination.Length, IntPtr.Zero, nativeOverlapped) == 0)
-                {
-                    // The operation failed, or it's pending.
-                    int errorCode = FileStreamHelpers.GetLastWin32ErrorAndDisposeHandleIfInvalid(_fileHandle);
-                    switch (errorCode)
-                    {
-                        case Interop.Errors.ERROR_IO_PENDING:
-                            // Common case: IO was initiated, completion will be handled by callback.
-                            // Register for cancellation now that the operation has been initiated.
-                            vts.RegisterForCancellation(cancellationToken);
-                            break;
-
-                        case Interop.Errors.ERROR_BROKEN_PIPE:
-                            // EOF on a pipe. Callback will not be called.
-                            // We clear the overlapped status bit for this special case (failure
-                            // to do so looks like we are freeing a pending overlapped later).
-                            nativeOverlapped->InternalLow = IntPtr.Zero;
-                            vts.Dispose();
-                            return ValueTask.FromResult(0);
-
-                        default:
-                            // Error. Callback will not be called.
-                            vts.Dispose();
-                            return ValueTask.FromException<int>(HandleIOError(positionBefore, errorCode));
-                    }
-                }
-            }
-            catch
-            {
-                vts.Dispose();
-                throw;
+                // When using overlapped IO, the OS is not supposed to
+                // touch the file pointer location at all.  We will adjust it
+                // ourselves, but only in memory. This isn't threadsafe.
+                _filePosition += destination.Length;
             }
 
-            // Completion handled by callback.
-            vts.FinishedScheduling();
-            return new ValueTask<int>(vts, vts.Version);
+            (SafeFileHandle.ValueTaskSource? vts, int errorCode) = RandomAccess.QueueAsyncReadFile(_fileHandle, destination, positionBefore, cancellationToken);
+            return vts != null
+                ? new ValueTask<int>(vts, vts.Version)
+                : (errorCode == 0) ? ValueTask.FromResult(0) : ValueTask.FromException<int>(HandleIOError(positionBefore, errorCode));
         }
 
         public override void Write(byte[] buffer, int offset, int count)
@@ -220,59 +82,20 @@ private unsafe ValueTask WriteAsyncInternal(ReadOnlyMemory<byte> source, Cancell
                 ThrowHelper.ThrowNotSupportedException_UnwritableStream();
             }
 
-            // Rent the reusable ValueTaskSource, or create a new one to use if we couldn't get one (which
-            // should only happen on first use or if the FileStream is being used concurrently).
-            ValueTaskSource vts = Interlocked.Exchange(ref _reusableValueTaskSource, null) ?? new ValueTaskSource(this);
-            try
-            {
-                NativeOverlapped* nativeOverlapped = vts.PrepareForOperation(source);
-                Debug.Assert(vts._memoryHandle.Pointer != null);
-
-                long positionBefore = _filePosition;
-                if (CanSeek)
-                {
-                    // Now set the position to read from in the NativeOverlapped struct
-                    // For pipes, we should leave the offset fields set to 0.
-                    nativeOverlapped->OffsetLow = (int)positionBefore;
-                    nativeOverlapped->OffsetHigh = (int)(positionBefore >> 32);
-
-                    // When using overlapped IO, the OS is not supposed to
-                    // touch the file pointer location at all.  We will adjust it
-                    // ourselves, but only in memory.  This isn't threadsafe.
-                    _filePosition += source.Length;
-                    UpdateLengthOnChangePosition();
-                }
-
-                // Queue an async WriteFile operation.
-                if (Interop.Kernel32.WriteFile(_fileHandle, (byte*)vts._memoryHandle.Pointer, source.Length, IntPtr.Zero, nativeOverlapped) == 0)
-                {
-                    // The operation failed, or it's pending.
-                    int errorCode = FileStreamHelpers.GetLastWin32ErrorAndDisposeHandleIfInvalid(_fileHandle);
-                    if (errorCode == Interop.Errors.ERROR_IO_PENDING)
-                    {
-                        // Common case: IO was initiated, completion will be handled by callback.
-                        // Register for cancellation now that the operation has been initiated.
-                        vts.RegisterForCancellation(cancellationToken);
-                    }
-                    else
-                    {
-                        // Error. Callback will not be invoked.
-                        vts.Dispose();
-                        return errorCode == Interop.Errors.ERROR_NO_DATA ? // EOF on a pipe. IO callback will not be called.
-                            ValueTask.CompletedTask :
-                            ValueTask.FromException(HandleIOError(positionBefore, errorCode));
-                    }
-                }
-            }
-            catch
+            long positionBefore = _filePosition;
+            if (CanSeek)
             {
-                vts.Dispose();
-                throw;
+                // When using overlapped IO, the OS is not supposed to
+                // touch the file pointer location at all.  We will adjust it
+                // ourselves, but only in memory.  This isn't threadsafe.
+                _filePosition += source.Length;
+                UpdateLengthOnChangePosition();
             }
 
-            // Completion handled by callback.
-            vts.FinishedScheduling();
-            return new ValueTask(vts, vts.Version);
+            (SafeFileHandle.ValueTaskSource? vts, int errorCode) = RandomAccess.QueueAsyncWriteFile(_fileHandle, source, positionBefore, cancellationToken);
+            return vts != null
+                ? new ValueTask(vts, vts.Version)
+                : (errorCode == 0) ? ValueTask.CompletedTask : ValueTask.FromException(HandleIOError(positionBefore, errorCode));
         }
 
         private Exception HandleIOError(long positionBefore, int errorCode)
@@ -283,9 +106,7 @@ private Exception HandleIOError(long positionBefore, int errorCode)
                 _filePosition = positionBefore;
             }
 
-            return errorCode == Interop.Errors.ERROR_HANDLE_EOF ?
-                ThrowHelper.CreateEndOfFileException() :
-                Win32Marshal.GetExceptionForWin32Error(errorCode, _path);
+            return SafeFileHandle.ValueTaskSource.GetIOError(errorCode, _path);
         }
 
         public override Task FlushAsync(CancellationToken cancellationToken) => Task.CompletedTask; // no buffering = nothing to flush
diff --git a/src/libraries/System.Private.CoreLib/src/System/IO/Strategies/FileStreamHelpers.Unix.cs b/src/libraries/System.Private.CoreLib/src/System/IO/Strategies/FileStreamHelpers.Unix.cs
index 1fd6456f3eeb54..868ccb84fd7f21 100644
--- a/src/libraries/System.Private.CoreLib/src/System/IO/Strategies/FileStreamHelpers.Unix.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/IO/Strategies/FileStreamHelpers.Unix.cs
@@ -2,11 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using Microsoft.Win32.SafeHandles;
-using System.Diagnostics;
-using System.Runtime.InteropServices;
-using System.Runtime.Versioning;
-using System.Threading;
-using System.Threading.Tasks;
 
 namespace System.IO.Strategies
 {
@@ -20,88 +15,18 @@ private static FileStreamStrategy ChooseStrategyCore(SafeFileHandle handle, File
         private static FileStreamStrategy ChooseStrategyCore(string path, FileMode mode, FileAccess access, FileShare share, int bufferSize, FileOptions options, long preallocationSize)
             => new Net5CompatFileStreamStrategy(path, mode, access, share, bufferSize == 0 ? 1 : bufferSize, options, preallocationSize);
 
-        internal static SafeFileHandle OpenHandle(string path, FileMode mode, FileAccess access, FileShare share, FileOptions options, long preallocationSize)
+        internal static long CheckFileCall(long result, string? path, bool ignoreNotSupported = false)
         {
-            // Translate the arguments into arguments for an open call.
-            Interop.Sys.OpenFlags openFlags = PreOpenConfigurationFromOptions(mode, access, share, options);
-
-            // If the file gets created a new, we'll select the permissions for it.  Most Unix utilities by default use 666 (read and
-            // write for all), so we do the same (even though this doesn't match Windows, where by default it's possible to write out
-            // a file and then execute it). No matter what we choose, it'll be subject to the umask applied by the system, such that the
-            // actual permissions will typically be less than what we select here.
-            const Interop.Sys.Permissions OpenPermissions =
-                Interop.Sys.Permissions.S_IRUSR | Interop.Sys.Permissions.S_IWUSR |
-                Interop.Sys.Permissions.S_IRGRP | Interop.Sys.Permissions.S_IWGRP |
-                Interop.Sys.Permissions.S_IROTH | Interop.Sys.Permissions.S_IWOTH;
-
-            return SafeFileHandle.Open(path!, openFlags, (int)OpenPermissions);
-        }
-
-        internal static bool GetDefaultIsAsync(SafeFileHandle handle, bool defaultIsAsync) => handle.IsAsync ?? defaultIsAsync;
-
-        /// <summary>Translates the FileMode, FileAccess, and FileOptions values into flags to be passed when opening the file.</summary>
-        /// <param name="mode">The FileMode provided to the stream's constructor.</param>
-        /// <param name="access">The FileAccess provided to the stream's constructor</param>
-        /// <param name="share">The FileShare provided to the stream's constructor</param>
-        /// <param name="options">The FileOptions provided to the stream's constructor</param>
-        /// <returns>The flags value to be passed to the open system call.</returns>
-        private static Interop.Sys.OpenFlags PreOpenConfigurationFromOptions(FileMode mode, FileAccess access, FileShare share, FileOptions options)
-        {
-            // Translate FileMode.  Most of the values map cleanly to one or more options for open.
-            Interop.Sys.OpenFlags flags = default;
-            switch (mode)
-            {
-                default:
-                case FileMode.Open: // Open maps to the default behavior for open(...).  No flags needed.
-                case FileMode.Truncate: // We truncate the file after getting the lock
-                    break;
-
-                case FileMode.Append: // Append is the same as OpenOrCreate, except that we'll also separately jump to the end later
-                case FileMode.OpenOrCreate:
-                case FileMode.Create: // We truncate the file after getting the lock
-                    flags |= Interop.Sys.OpenFlags.O_CREAT;
-                    break;
-
-                case FileMode.CreateNew:
-                    flags |= (Interop.Sys.OpenFlags.O_CREAT | Interop.Sys.OpenFlags.O_EXCL);
-                    break;
-            }
-
-            // Translate FileAccess.  All possible values map cleanly to corresponding values for open.
-            switch (access)
-            {
-                case FileAccess.Read:
-                    flags |= Interop.Sys.OpenFlags.O_RDONLY;
-                    break;
-
-                case FileAccess.ReadWrite:
-                    flags |= Interop.Sys.OpenFlags.O_RDWR;
-                    break;
-
-                case FileAccess.Write:
-                    flags |= Interop.Sys.OpenFlags.O_WRONLY;
-                    break;
-            }
-
-            // Handle Inheritable, other FileShare flags are handled by Init
-            if ((share & FileShare.Inheritable) == 0)
-            {
-                flags |= Interop.Sys.OpenFlags.O_CLOEXEC;
-            }
-
-            // Translate some FileOptions; some just aren't supported, and others will be handled after calling open.
-            // - Asynchronous: Handled in ctor, setting _useAsync and SafeFileHandle.IsAsync to true
-            // - DeleteOnClose: Doesn't have a Unix equivalent, but we approximate it in Dispose
-            // - Encrypted: No equivalent on Unix and is ignored
-            // - RandomAccess: Implemented after open if posix_fadvise is available
-            // - SequentialScan: Implemented after open if posix_fadvise is available
-            // - WriteThrough: Handled here
-            if ((options & FileOptions.WriteThrough) != 0)
+            if (result < 0)
             {
-                flags |= Interop.Sys.OpenFlags.O_SYNC;
+                Interop.ErrorInfo errorInfo = Interop.Sys.GetLastErrorInfo();
+                if (!(ignoreNotSupported && errorInfo.Error == Interop.Error.ENOTSUP))
+                {
+                    throw Interop.GetExceptionForIoErrno(errorInfo, path, isDirectory: false);
+                }
             }
 
-            return flags;
+            return result;
         }
     }
 }
diff --git a/src/libraries/System.Private.CoreLib/src/System/IO/Strategies/FileStreamHelpers.Windows.cs b/src/libraries/System.Private.CoreLib/src/System/IO/Strategies/FileStreamHelpers.Windows.cs
index f9f22b4d698f02..39275721010fb1 100644
--- a/src/libraries/System.Private.CoreLib/src/System/IO/Strategies/FileStreamHelpers.Windows.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/IO/Strategies/FileStreamHelpers.Windows.cs
@@ -5,7 +5,6 @@
 using System.Diagnostics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
-using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.Win32.SafeHandles;
@@ -61,202 +60,6 @@ private static FileStreamStrategy ChooseStrategyCore(string path, FileMode mode,
         internal static FileStreamStrategy EnableBufferingIfNeeded(WindowsFileStreamStrategy strategy, int bufferSize)
             => bufferSize > 1 ? new BufferedFileStreamStrategy(strategy, bufferSize) : strategy;
 
-        internal static SafeFileHandle OpenHandle(string path, FileMode mode, FileAccess access, FileShare share, FileOptions options, long preallocationSize)
-            => CreateFileOpenHandle(path, mode, access, share, options, preallocationSize);
-
-        private static unsafe SafeFileHandle CreateFileOpenHandle(string path, FileMode mode, FileAccess access, FileShare share, FileOptions options, long preallocationSize)
-        {
-            using (DisableMediaInsertionPrompt.Create())
-            {
-                Debug.Assert(path != null);
-
-                if (ShouldPreallocate(preallocationSize, access, mode))
-                {
-                    IntPtr fileHandle = NtCreateFile(path, mode, access, share, options, preallocationSize);
-
-                    return ValidateFileHandle(new SafeFileHandle(fileHandle, ownsHandle: true), path, (options & FileOptions.Asynchronous) != 0);
-                }
-
-                Interop.Kernel32.SECURITY_ATTRIBUTES secAttrs = GetSecAttrs(share);
-
-                int fAccess =
-                    ((access & FileAccess.Read) == FileAccess.Read ? Interop.Kernel32.GenericOperations.GENERIC_READ : 0) |
-                    ((access & FileAccess.Write) == FileAccess.Write ? Interop.Kernel32.GenericOperations.GENERIC_WRITE : 0);
-
-                // Our Inheritable bit was stolen from Windows, but should be set in
-                // the security attributes class.  Don't leave this bit set.
-                share &= ~FileShare.Inheritable;
-
-                // Must use a valid Win32 constant here...
-                if (mode == FileMode.Append)
-                    mode = FileMode.OpenOrCreate;
-
-                int flagsAndAttributes = (int)options;
-
-                // For mitigating local elevation of privilege attack through named pipes
-                // make sure we always call CreateFile with SECURITY_ANONYMOUS so that the
-                // named pipe server can't impersonate a high privileged client security context
-                // (note that this is the effective default on CreateFile2)
-                flagsAndAttributes |= (Interop.Kernel32.SecurityOptions.SECURITY_SQOS_PRESENT | Interop.Kernel32.SecurityOptions.SECURITY_ANONYMOUS);
-
-                SafeFileHandle safeFileHandle = ValidateFileHandle(
-                    Interop.Kernel32.CreateFile(path, fAccess, share, &secAttrs, mode, flagsAndAttributes, IntPtr.Zero),
-                    path,
-                    (options & FileOptions.Asynchronous) != 0);
-
-                return safeFileHandle;
-            }
-        }
-
-        private static IntPtr NtCreateFile(string fullPath, FileMode mode, FileAccess access, FileShare share, FileOptions options, long preallocationSize)
-        {
-            uint ntStatus;
-            IntPtr fileHandle;
-
-            const string mandatoryNtPrefix = @"\??\";
-            if (fullPath.StartsWith(mandatoryNtPrefix, StringComparison.Ordinal))
-            {
-                (ntStatus, fileHandle) = Interop.NtDll.CreateFile(fullPath, mode, access, share, options, preallocationSize);
-            }
-            else
-            {
-                var vsb = new ValueStringBuilder(stackalloc char[1024]);
-                vsb.Append(mandatoryNtPrefix);
-
-                if (fullPath.StartsWith(@"\\?\", StringComparison.Ordinal)) // NtCreateFile does not support "\\?\" prefix, only "\??\"
-                {
-                    vsb.Append(fullPath.AsSpan(4));
-                }
-                else
-                {
-                    vsb.Append(fullPath);
-                }
-
-                (ntStatus, fileHandle) = Interop.NtDll.CreateFile(vsb.AsSpan(), mode, access, share, options, preallocationSize);
-                vsb.Dispose();
-            }
-
-            switch (ntStatus)
-            {
-                case 0:
-                    return fileHandle;
-                case Interop.NtDll.NT_ERROR_STATUS_DISK_FULL:
-                    throw new IOException(SR.Format(SR.IO_DiskFull_Path_AllocationSize, fullPath, preallocationSize));
-                // NtCreateFile has a bug and it reports STATUS_INVALID_PARAMETER for files
-                // that are too big for the current file system. Example: creating a 4GB+1 file on a FAT32 drive.
-                case Interop.NtDll.NT_STATUS_INVALID_PARAMETER:
-                case Interop.NtDll.NT_ERROR_STATUS_FILE_TOO_LARGE:
-                    throw new IOException(SR.Format(SR.IO_FileTooLarge_Path_AllocationSize, fullPath, preallocationSize));
-                default:
-                    int error = (int)Interop.NtDll.RtlNtStatusToDosError((int)ntStatus);
-                    throw Win32Marshal.GetExceptionForWin32Error(error, fullPath);
-            }
-        }
-
-        internal static bool GetDefaultIsAsync(SafeFileHandle handle, bool defaultIsAsync)
-        {
-            return handle.IsAsync ?? !IsHandleSynchronous(handle, ignoreInvalid: true) ?? defaultIsAsync;
-        }
-
-        internal static unsafe bool? IsHandleSynchronous(SafeFileHandle fileHandle, bool ignoreInvalid)
-        {
-            if (fileHandle.IsInvalid)
-                return null;
-
-            uint fileMode;
-
-            int status = Interop.NtDll.NtQueryInformationFile(
-                FileHandle: fileHandle,
-                IoStatusBlock: out _,
-                FileInformation: &fileMode,
-                Length: sizeof(uint),
-                FileInformationClass: Interop.NtDll.FileModeInformation);
-
-            switch (status)
-            {
-                case 0:
-                    // We were successful
-                    break;
-                case Interop.NtDll.STATUS_INVALID_HANDLE:
-                    if (!ignoreInvalid)
-                    {
-                        throw Win32Marshal.GetExceptionForWin32Error(Interop.Errors.ERROR_INVALID_HANDLE);
-                    }
-                    else
-                    {
-                        return null;
-                    }
-                default:
-                    // Something else is preventing access
-                    Debug.Fail("Unable to get the file mode information, status was" + status.ToString());
-                    return null;
-            }
-
-            // If either of these two flags are set, the file handle is synchronous (not overlapped)
-            return (fileMode & (uint)(Interop.NtDll.CreateOptions.FILE_SYNCHRONOUS_IO_ALERT | Interop.NtDll.CreateOptions.FILE_SYNCHRONOUS_IO_NONALERT)) > 0;
-        }
-
-        internal static void VerifyHandleIsSync(SafeFileHandle handle)
-        {
-            // As we can accurately check the handle type when we have access to NtQueryInformationFile we don't need to skip for
-            // any particular file handle type.
-
-            // If the handle was passed in without an explicit async setting, we already looked it up in GetDefaultIsAsync
-            if (!handle.IsAsync.HasValue)
-                return;
-
-            // If we can't check the handle, just assume it is ok.
-            if (!(IsHandleSynchronous(handle, ignoreInvalid: false) ?? true))
-                ThrowHelper.ThrowArgumentException_HandleNotSync(nameof(handle));
-        }
-
-        private static unsafe Interop.Kernel32.SECURITY_ATTRIBUTES GetSecAttrs(FileShare share)
-        {
-            Interop.Kernel32.SECURITY_ATTRIBUTES secAttrs = default;
-            if ((share & FileShare.Inheritable) != 0)
-            {
-                secAttrs = new Interop.Kernel32.SECURITY_ATTRIBUTES
-                {
-                    nLength = (uint)sizeof(Interop.Kernel32.SECURITY_ATTRIBUTES),
-                    bInheritHandle = Interop.BOOL.TRUE
-                };
-            }
-            return secAttrs;
-        }
-
-        private static SafeFileHandle ValidateFileHandle(SafeFileHandle fileHandle, string path, bool useAsyncIO)
-        {
-            if (fileHandle.IsInvalid)
-            {
-                // Return a meaningful exception with the full path.
-
-                // NT5 oddity - when trying to open "C:\" as a Win32FileStream,
-                // we usually get ERROR_PATH_NOT_FOUND from the OS.  We should
-                // probably be consistent w/ every other directory.
-                int errorCode = Marshal.GetLastPInvokeError();
-
-                if (errorCode == Interop.Errors.ERROR_PATH_NOT_FOUND && path!.Length == PathInternal.GetRootLength(path))
-                    errorCode = Interop.Errors.ERROR_ACCESS_DENIED;
-
-                throw Win32Marshal.GetExceptionForWin32Error(errorCode, path);
-            }
-
-            fileHandle.IsAsync = useAsyncIO;
-            return fileHandle;
-        }
-
-        internal static unsafe long GetFileLength(SafeFileHandle handle, string? path)
-        {
-            Interop.Kernel32.FILE_STANDARD_INFO info;
-
-            if (!Interop.Kernel32.GetFileInformationByHandleEx(handle, Interop.Kernel32.FileStandardInfo, &info, (uint)sizeof(Interop.Kernel32.FILE_STANDARD_INFO)))
-            {
-                throw Win32Marshal.GetExceptionForLastWin32Error(path);
-            }
-
-            return info.EndOfFile;
-        }
-
         internal static void FlushToDisk(SafeFileHandle handle, string? path)
         {
             if (!Interop.Kernel32.FlushFileBuffers(handle))
@@ -347,7 +150,7 @@ internal static void ValidateFileTypeForNonExtendedPaths(SafeFileHandle handle,
                 // we were explicitly passed a path that has \\?\. GetFullPath() will turn paths like C:\foo\con.txt into
                 // \\.\CON, so we'll only allow the \\?\ syntax.
 
-                int fileType = Interop.Kernel32.GetFileType(handle);
+                int fileType = handle.GetFileType();
                 if (fileType != Interop.Kernel32.FileTypes.FILE_TYPE_DISK)
                 {
                     int errorCode = fileType == Interop.Kernel32.FileTypes.FILE_TYPE_UNKNOWN
@@ -365,18 +168,6 @@ internal static void ValidateFileTypeForNonExtendedPaths(SafeFileHandle handle,
             }
         }
 
-        internal static void GetFileTypeSpecificInformation(SafeFileHandle handle, out bool canSeek, out bool isPipe)
-        {
-            int handleType = Interop.Kernel32.GetFileType(handle);
-            Debug.Assert(handleType == Interop.Kernel32.FileTypes.FILE_TYPE_DISK
-                || handleType == Interop.Kernel32.FileTypes.FILE_TYPE_PIPE
-                || handleType == Interop.Kernel32.FileTypes.FILE_TYPE_CHAR,
-                "FileStream was passed an unknown file type!");
-
-            canSeek = handleType == Interop.Kernel32.FileTypes.FILE_TYPE_DISK;
-            isPipe = handleType == Interop.Kernel32.FileTypes.FILE_TYPE_PIPE;
-        }
-
         internal static unsafe void SetFileLength(SafeFileHandle handle, string? path, long length)
         {
             var eofInfo = new Interop.Kernel32.FILE_END_OF_FILE_INFO
@@ -397,70 +188,7 @@ internal static unsafe void SetFileLength(SafeFileHandle handle, string? path, l
             }
         }
 
-        internal static unsafe int ReadFileNative(SafeFileHandle handle, Span<byte> bytes, bool syncUsingOverlapped, NativeOverlapped* overlapped, out int errorCode)
-        {
-            Debug.Assert(handle != null, "handle != null");
-
-            int r;
-            int numBytesRead = 0;
-
-            fixed (byte* p = &MemoryMarshal.GetReference(bytes))
-            {
-                r = overlapped != null ?
-                    (syncUsingOverlapped
-                        ? Interop.Kernel32.ReadFile(handle, p, bytes.Length, out numBytesRead, overlapped)
-                        : Interop.Kernel32.ReadFile(handle, p, bytes.Length, IntPtr.Zero, overlapped))
-                    : Interop.Kernel32.ReadFile(handle, p, bytes.Length, out numBytesRead, IntPtr.Zero);
-            }
-
-            if (r == 0)
-            {
-                errorCode = GetLastWin32ErrorAndDisposeHandleIfInvalid(handle);
-
-                if (syncUsingOverlapped && errorCode == Interop.Errors.ERROR_HANDLE_EOF)
-                {
-                    // https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-readfile#synchronization-and-file-position :
-                    // "If lpOverlapped is not NULL, then when a synchronous read operation reaches the end of a file,
-                    // ReadFile returns FALSE and GetLastError returns ERROR_HANDLE_EOF"
-                    return numBytesRead;
-                }
 
-                return -1;
-            }
-            else
-            {
-                errorCode = 0;
-                return numBytesRead;
-            }
-        }
-
-        internal static unsafe int WriteFileNative(SafeFileHandle handle, ReadOnlySpan<byte> buffer, bool syncUsingOverlapped, NativeOverlapped* overlapped, out int errorCode)
-        {
-            Debug.Assert(handle != null, "handle != null");
-
-            int numBytesWritten = 0;
-            int r;
-
-            fixed (byte* p = &MemoryMarshal.GetReference(buffer))
-            {
-                r = overlapped != null ?
-                    (syncUsingOverlapped
-                        ? Interop.Kernel32.WriteFile(handle, p, buffer.Length, out numBytesWritten, overlapped)
-                        : Interop.Kernel32.WriteFile(handle, p, buffer.Length, IntPtr.Zero, overlapped))
-                    : Interop.Kernel32.WriteFile(handle, p, buffer.Length, out numBytesWritten, IntPtr.Zero);
-            }
-
-            if (r == 0)
-            {
-                errorCode = GetLastWin32ErrorAndDisposeHandleIfInvalid(handle);
-                return -1;
-            }
-            else
-            {
-                errorCode = 0;
-                return numBytesWritten;
-            }
-        }
 
         internal static async Task AsyncModeCopyToAsync(SafeFileHandle handle, string? path, bool canSeek, long filePosition, Stream destination, int bufferSize, CancellationToken cancellationToken)
         {
@@ -537,7 +265,7 @@ internal static async Task AsyncModeCopyToAsync(SafeFileHandle handle, string? p
                             }
 
                             // Kick off the read.
-                            synchronousSuccess = ReadFileNative(handle, copyBuffer, false, readAwaitable._nativeOverlapped, out errorCode) >= 0;
+                            synchronousSuccess = RandomAccess.ReadFileNative(handle, copyBuffer, false, readAwaitable._nativeOverlapped, out errorCode) >= 0;
                         }
 
                         // If the operation did not synchronously succeed, it either failed or initiated the asynchronous operation.
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 7dfaf7fe52dc73..965e9c09f04e15 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
@@ -1,12 +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 System.Runtime.Serialization;
 using Microsoft.Win32.SafeHandles;
 
 namespace System.IO.Strategies
 {
     internal static partial class FileStreamHelpers
     {
+        /// <summary>Caches whether Serialization Guard has been disabled for file writes</summary>
+        private static int s_cachedSerializationSwitch;
+
         internal static bool UseNet5CompatStrategy { get; } = AppContextConfigHelper.GetBooleanConfig("System.IO.UseNet5CompatFileStream", "DOTNET_SYSTEM_IO_USENET5COMPATFILESTREAM");
 
         internal static FileStreamStrategy ChooseStrategy(FileStream fileStream, SafeFileHandle handle, FileAccess access, FileShare share, int bufferSize, bool isAsync)
@@ -39,7 +43,79 @@ e is NotSupportedException ||
         internal static bool ShouldPreallocate(long preallocationSize, FileAccess access, FileMode mode)
             => preallocationSize > 0
                && (access & FileAccess.Write) != 0
-               && mode != FileMode.Open && mode != FileMode.Append
-               && !OperatingSystem.IsBrowser(); // WASM limitation
+               && mode != FileMode.Open && mode != FileMode.Append;
+
+        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));
+            }
+
+            // don't include inheritable in our bounds check for share
+            FileShare tempshare = share & ~FileShare.Inheritable;
+            string? badArg = null;
+
+            if (mode < FileMode.CreateNew || mode > FileMode.Append)
+            {
+                badArg = nameof(mode);
+            }
+            else if (access < FileAccess.Read || access > FileAccess.ReadWrite)
+            {
+                badArg = nameof(access);
+            }
+            else if (tempshare < FileShare.None || tempshare > (FileShare.ReadWrite | FileShare.Delete))
+            {
+                badArg = nameof(share);
+            }
+
+            if (badArg != null)
+            {
+                throw new ArgumentOutOfRangeException(badArg, SR.ArgumentOutOfRange_Enum);
+            }
+
+            // NOTE: any change to FileOptions enum needs to be matched here in the error validation
+            if (options != FileOptions.None && (options & ~(FileOptions.WriteThrough | FileOptions.Asynchronous | FileOptions.RandomAccess | FileOptions.DeleteOnClose | FileOptions.SequentialScan | FileOptions.Encrypted | (FileOptions)0x20000000 /* NoBuffering */)) != 0)
+            {
+                throw new ArgumentOutOfRangeException(nameof(options), SR.ArgumentOutOfRange_Enum);
+            }
+            else if (bufferSize < 0)
+            {
+                ThrowHelper.ThrowArgumentOutOfRangeException_NeedNonNegNum(nameof(bufferSize));
+            }
+            else if (preallocationSize < 0)
+            {
+                ThrowHelper.ThrowArgumentOutOfRangeException_NeedNonNegNum(nameof(preallocationSize));
+            }
+
+            // Write access validation
+            if ((access & FileAccess.Write) == 0)
+            {
+                if (mode == FileMode.Truncate || mode == FileMode.CreateNew || mode == FileMode.Create || mode == FileMode.Append)
+                {
+                    // No write access, mode and access disagree but flag access since mode comes first
+                    throw new ArgumentException(SR.Format(SR.Argument_InvalidFileModeAndAccessCombo, mode, access), nameof(access));
+                }
+            }
+
+            if ((access & FileAccess.Read) != 0 && mode == FileMode.Append)
+            {
+                throw new ArgumentException(SR.Argument_InvalidAppendMode, nameof(access));
+            }
+
+            SerializationGuard(access);
+        }
+
+        internal static void SerializationGuard(FileAccess access)
+        {
+            if ((access & FileAccess.Write) == FileAccess.Write)
+            {
+                SerializationInfo.ThrowIfDeserializationInProgress("AllowFileWrites", ref s_cachedSerializationSwitch);
+            }
+        }
     }
 }
diff --git a/src/libraries/System.Private.CoreLib/src/System/IO/Strategies/Net5CompatFileStreamStrategy.Unix.cs b/src/libraries/System.Private.CoreLib/src/System/IO/Strategies/Net5CompatFileStreamStrategy.Unix.cs
index f039c020433812..5ee047869c9a68 100644
--- a/src/libraries/System.Private.CoreLib/src/System/IO/Strategies/Net5CompatFileStreamStrategy.Unix.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/IO/Strategies/Net5CompatFileStreamStrategy.Unix.cs
@@ -13,9 +13,6 @@ namespace System.IO.Strategies
     /// <summary>Provides an implementation of a file stream for Unix files.</summary>
     internal sealed partial class Net5CompatFileStreamStrategy : FileStreamStrategy
     {
-        /// <summary>File mode.</summary>
-        private FileMode _mode;
-
         /// <summary>Advanced options requested when opening the file.</summary>
         private FileOptions _options;
 
@@ -31,56 +28,16 @@ internal sealed partial class Net5CompatFileStreamStrategy : FileStreamStrategy
         /// </summary>
         private AsyncState? _asyncState;
 
-        /// <summary>Lazily-initialized value for whether the file supports seeking.</summary>
-        private bool? _canSeek;
-
-        /// <summary>Initializes a stream for reading or writing a Unix file.</summary>
-        /// <param name="mode">How the file should be opened.</param>
-        /// <param name="share">What other access to the file should be allowed.  This is currently ignored.</param>
-        /// <param name="originalPath">The original path specified for the FileStream.</param>
-        /// <param name="options">Options, passed via arguments as we have no guarantee that _options field was already set.</param>
-        /// <param name="preallocationSize">passed to posix_fallocate</param>
-        private void Init(FileMode mode, FileShare share, string originalPath, FileOptions options, long preallocationSize)
+        private void Init(FileMode mode, string originalPath, FileOptions options)
         {
             // FileStream performs most of the general argument validation.  We can assume here that the arguments
             // are all checked and consistent (e.g. non-null-or-empty path; valid enums in mode, access, share, and options; etc.)
             // Store the arguments
-            _mode = mode;
             _options = options;
 
             if (_useAsyncIO)
-                _asyncState = new AsyncState();
-
-            _fileHandle.IsAsync = _useAsyncIO;
-
-            // Lock the file if requested via FileShare.  This is only advisory locking. FileShare.None implies an exclusive
-            // lock on the file and all other modes use a shared lock.  While this is not as granular as Windows, not mandatory,
-            // and not atomic with file opening, it's better than nothing.
-            Interop.Sys.LockOperations lockOperation = (share == FileShare.None) ? Interop.Sys.LockOperations.LOCK_EX : Interop.Sys.LockOperations.LOCK_SH;
-            if (Interop.Sys.FLock(_fileHandle, lockOperation | Interop.Sys.LockOperations.LOCK_NB) < 0)
-            {
-                // The only error we care about is EWOULDBLOCK, which indicates that the file is currently locked by someone
-                // else and we would block trying to access it.  Other errors, such as ENOTSUP (locking isn't supported) or
-                // EACCES (the file system doesn't allow us to lock), will only hamper FileStream's usage without providing value,
-                // given again that this is only advisory / best-effort.
-                Interop.ErrorInfo errorInfo = Interop.Sys.GetLastErrorInfo();
-                if (errorInfo.Error == Interop.Error.EWOULDBLOCK)
-                {
-                    throw Interop.GetExceptionForIoErrno(errorInfo, _path, isDirectory: false);
-                }
-            }
-
-            // These provide hints around how the file will be accessed.  Specifying both RandomAccess
-            // and Sequential together doesn't make sense as they are two competing options on the same spectrum,
-            // so if both are specified, we prefer RandomAccess (behavior on Windows is unspecified if both are provided).
-            Interop.Sys.FileAdvice fadv =
-                (options & FileOptions.RandomAccess) != 0 ? Interop.Sys.FileAdvice.POSIX_FADV_RANDOM :
-                (options & FileOptions.SequentialScan) != 0 ? Interop.Sys.FileAdvice.POSIX_FADV_SEQUENTIAL :
-                0;
-            if (fadv != 0)
             {
-                CheckFileCall(Interop.Sys.PosixFAdvise(_fileHandle, 0, 0, fadv),
-                    ignoreNotSupported: true); // just a hint.
+                _asyncState = new AsyncState();
             }
 
             if (mode == FileMode.Append)
@@ -88,41 +45,8 @@ private void Init(FileMode mode, FileShare share, string originalPath, FileOptio
                 // Jump to the end of the file if opened as Append.
                 _appendStart = SeekCore(_fileHandle, 0, SeekOrigin.End);
             }
-            else if (mode == FileMode.Create || mode == FileMode.Truncate)
-            {
-                // Truncate the file now if the file mode requires it. This ensures that the file only will be truncated
-                // if opened successfully.
-                if (Interop.Sys.FTruncate(_fileHandle, 0) < 0)
-                {
-                    Interop.ErrorInfo errorInfo = Interop.Sys.GetLastErrorInfo();
-                    if (errorInfo.Error != Interop.Error.EBADF && errorInfo.Error != Interop.Error.EINVAL)
-                    {
-                        // We know the file descriptor is valid and we know the size argument to FTruncate is correct,
-                        // so if EBADF or EINVAL is returned, it means we're dealing with a special file that can't be
-                        // truncated.  Ignore the error in such cases; in all others, throw.
-                        throw Interop.GetExceptionForIoErrno(errorInfo, _path, isDirectory: false);
-                    }
-                }
-            }
-
-            // If preallocationSize has been provided for a creatable and writeable file
-            if (FileStreamHelpers.ShouldPreallocate(preallocationSize, _access, mode))
-            {
-                int fallocateResult = Interop.Sys.PosixFAllocate(_fileHandle, 0, preallocationSize);
-                if (fallocateResult != 0)
-                {
-                    _fileHandle.Dispose();
-                    Interop.Sys.Unlink(_path!); // remove the file to mimic Windows behaviour (atomic operation)
 
-                    if (fallocateResult == -1)
-                    {
-                        throw new IOException(SR.Format(SR.IO_DiskFull_Path_AllocationSize, _path, preallocationSize));
-                    }
-
-                    Debug.Assert(fallocateResult == -2);
-                    throw new IOException(SR.Format(SR.IO_FileTooLarge_Path_AllocationSize, _path, preallocationSize));
-                }
-            }
+            Debug.Assert(_fileHandle.IsAsync == _useAsyncIO);
         }
 
         /// <summary>Initializes a stream from an already open file handle (file descriptor).</summary>
@@ -131,42 +55,18 @@ private void InitFromHandle(SafeFileHandle handle, FileAccess access, bool useAs
             if (useAsyncIO)
                 _asyncState = new AsyncState();
 
-            if (CanSeekCore(handle)) // use non-virtual CanSeekCore rather than CanSeek to avoid making virtual call during ctor
+            if (handle.CanSeek)
                 SeekCore(handle, 0, SeekOrigin.Current);
         }
 
-        /// <summary>Gets a value indicating whether the current stream supports seeking.</summary>
-        public override bool CanSeek => CanSeekCore(_fileHandle);
-
-        /// <summary>Gets a value indicating whether the current stream supports seeking.</summary>
-        /// <remarks>
-        /// Separated out of CanSeek to enable making non-virtual call to this logic.
-        /// We also pass in the file handle to allow the constructor to use this before it stashes the handle.
-        /// </remarks>
-        private bool CanSeekCore(SafeFileHandle fileHandle)
-        {
-            if (fileHandle.IsClosed)
-            {
-                return false;
-            }
-
-            if (!_canSeek.HasValue)
-            {
-                // Lazily-initialize whether we're able to seek, tested by seeking to our current location.
-                _canSeek = Interop.Sys.LSeek(fileHandle, 0, Interop.Sys.SeekWhence.SEEK_CUR) >= 0;
-            }
-
-            return _canSeek.GetValueOrDefault();
-        }
+        public override bool CanSeek => _fileHandle.CanSeek;
 
         public override long Length
         {
             get
             {
                 // Get the length of the file as reported by the OS
-                Interop.Sys.FileStatus status;
-                CheckFileCall(Interop.Sys.FStat(_fileHandle, out status));
-                long length = status.Size;
+                long length = RandomAccess.GetFileLength(_fileHandle, _path);
 
                 // But we may have buffered some data to be written that puts our length
                 // beyond what the OS is aware of.  Update accordingly.
@@ -710,31 +610,18 @@ public override long Seek(long offset, SeekOrigin origin)
         /// <returns>The new position in the stream.</returns>
         private long SeekCore(SafeFileHandle fileHandle, long offset, SeekOrigin origin, bool closeInvalidHandle = false)
         {
-            Debug.Assert(!fileHandle.IsClosed && CanSeekCore(fileHandle));
+            Debug.Assert(!fileHandle.IsInvalid);
+            Debug.Assert(fileHandle.CanSeek);
             Debug.Assert(origin >= SeekOrigin.Begin && origin <= SeekOrigin.End);
 
-            long pos = CheckFileCall(Interop.Sys.LSeek(fileHandle, offset, (Interop.Sys.SeekWhence)(int)origin)); // SeekOrigin values are the same as Interop.libc.SeekWhence values
+            long pos = FileStreamHelpers.CheckFileCall(Interop.Sys.LSeek(fileHandle, offset, (Interop.Sys.SeekWhence)(int)origin), _path); // SeekOrigin values are the same as Interop.libc.SeekWhence values
             _filePosition = pos;
             return pos;
         }
 
-        private long CheckFileCall(long result, bool ignoreNotSupported = false)
-        {
-            if (result < 0)
-            {
-                Interop.ErrorInfo errorInfo = Interop.Sys.GetLastErrorInfo();
-                if (!(ignoreNotSupported && errorInfo.Error == Interop.Error.ENOTSUP))
-                {
-                    throw Interop.GetExceptionForIoErrno(errorInfo, _path, isDirectory: false);
-                }
-            }
-
-            return result;
-        }
-
         private int CheckFileCall(int result, bool ignoreNotSupported = false)
         {
-            CheckFileCall((long)result, ignoreNotSupported);
+            FileStreamHelpers.CheckFileCall(result, _path, ignoreNotSupported);
 
             return result;
         }
diff --git a/src/libraries/System.Private.CoreLib/src/System/IO/Strategies/Net5CompatFileStreamStrategy.Windows.cs b/src/libraries/System.Private.CoreLib/src/System/IO/Strategies/Net5CompatFileStreamStrategy.Windows.cs
index ceb9bcc6e40527..ec74ccf1ac497d 100644
--- a/src/libraries/System.Private.CoreLib/src/System/IO/Strategies/Net5CompatFileStreamStrategy.Windows.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/IO/Strategies/Net5CompatFileStreamStrategy.Windows.cs
@@ -38,48 +38,17 @@ namespace System.IO.Strategies
 {
     internal sealed partial class Net5CompatFileStreamStrategy : FileStreamStrategy
     {
-        private bool _canSeek;
-        private bool _isPipe;      // Whether to disable async buffering code.
         private long _appendStart; // When appending, prevent overwriting file.
 
         private Task _activeBufferOperation = Task.CompletedTask;    // tracks in-progress async ops using the buffer
         private PreAllocatedOverlapped? _preallocatedOverlapped;     // optimization for async ops to avoid per-op allocations
         private CompletionSource? _currentOverlappedOwner; // async op currently using the preallocated overlapped
 
-        private void Init(FileMode mode, FileShare share, string originalPath, FileOptions options, long preallocationSize)
+        private void Init(FileMode mode, string originalPath, FileOptions options)
         {
             FileStreamHelpers.ValidateFileTypeForNonExtendedPaths(_fileHandle, originalPath);
 
-            // This is necessary for async IO using IO Completion ports via our
-            // managed Threadpool API's.  This (theoretically) calls the OS's
-            // BindIoCompletionCallback method, and passes in a stub for the
-            // LPOVERLAPPED_COMPLETION_ROUTINE.  This stub looks at the Overlapped
-            // struct for this request and gets a delegate to a managed callback
-            // from there, which it then calls on a threadpool thread.  (We allocate
-            // our native OVERLAPPED structs 2 pointers too large and store EE state
-            // & GC handles there, one to an IAsyncResult, the other to a delegate.)
-            if (_useAsyncIO)
-            {
-                try
-                {
-                    _fileHandle.ThreadPoolBinding = ThreadPoolBoundHandle.BindHandle(_fileHandle);
-                }
-                catch (ArgumentException ex)
-                {
-                    throw new IOException(SR.IO_BindHandleFailed, ex);
-                }
-                finally
-                {
-                    if (_fileHandle.ThreadPoolBinding == null)
-                    {
-                        // We should close the handle so that the handle is not open until SafeFileHandle GC
-                        Debug.Assert(!_exposedHandle, "Are we closing handle that we exposed/not own, how?");
-                        _fileHandle.Dispose();
-                    }
-                }
-            }
-
-            _canSeek = true;
+            Debug.Assert(!_useAsyncIO || _fileHandle.ThreadPoolBinding != null);
 
             // For Append mode...
             if (mode == FileMode.Append)
@@ -113,39 +82,9 @@ private void InitFromHandle(SafeFileHandle handle, FileAccess access, bool useAs
 
         private void InitFromHandleImpl(SafeFileHandle handle, bool useAsyncIO)
         {
-            FileStreamHelpers.GetFileTypeSpecificInformation(handle, out _canSeek, out _isPipe);
-
-            // This is necessary for async IO using IO Completion ports via our
-            // managed Threadpool API's.  This calls the OS's
-            // BindIoCompletionCallback method, and passes in a stub for the
-            // LPOVERLAPPED_COMPLETION_ROUTINE.  This stub looks at the Overlapped
-            // struct for this request and gets a delegate to a managed callback
-            // from there, which it then calls on a threadpool thread.  (We allocate
-            // our native OVERLAPPED structs 2 pointers too large and store EE
-            // state & a handle to a delegate there.)
-            //
-            // If, however, we've already bound this file handle to our completion port,
-            // don't try to bind it again because it will fail.  A handle can only be
-            // bound to a single completion port at a time.
-            if (useAsyncIO && !(handle.IsAsync ?? false))
-            {
-                try
-                {
-                    handle.ThreadPoolBinding = ThreadPoolBoundHandle.BindHandle(handle);
-                }
-                catch (Exception ex)
-                {
-                    // If you passed in a synchronous handle and told us to use
-                    // it asynchronously, throw here.
-                    throw new ArgumentException(SR.Arg_HandleNotAsync, nameof(handle), ex);
-                }
-            }
-            else if (!useAsyncIO)
-            {
-                FileStreamHelpers.VerifyHandleIsSync(handle);
-            }
+            handle.InitThreadPoolBindingIfNeeded();
 
-            if (_canSeek)
+            if (handle.CanSeek)
                 SeekCore(handle, 0, SeekOrigin.Current);
             else
                 _filePosition = 0;
@@ -153,13 +92,13 @@ private void InitFromHandleImpl(SafeFileHandle handle, bool useAsyncIO)
 
         private bool HasActiveBufferOperation => !_activeBufferOperation.IsCompleted;
 
-        public override bool CanSeek => _canSeek;
+        public override bool CanSeek => _fileHandle.CanSeek;
 
         public unsafe override long Length
         {
             get
             {
-                long len = FileStreamHelpers.GetFileLength(_fileHandle, _path);
+                long len = RandomAccess.GetFileLength(_fileHandle, _path);
 
                 // If we're writing near the end of the file, we must include our
                 // internal buffer in our Length calculation.  Don't flush because
@@ -208,7 +147,6 @@ protected override void Dispose(bool disposing)
                 }
 
                 _preallocatedOverlapped?.Dispose();
-                _canSeek = false;
 
                 // Don't set the buffer to null, to avoid a NullReferenceException
                 // when users have a race condition in their code (i.e. they call
@@ -236,7 +174,6 @@ public override async ValueTask DisposeAsync()
                 }
 
                 _preallocatedOverlapped?.Dispose();
-                _canSeek = false;
                 GC.SuppressFinalize(this); // the handle is closed; nothing further for the finalizer to do
             }
         }
@@ -380,7 +317,7 @@ private int ReadSpan(Span<byte> destination)
 
             // If we are reading from a device with no clear EOF like a
             // serial port or a pipe, this will cause us to block incorrectly.
-            if (!_isPipe)
+            if (!_fileHandle.IsPipe)
             {
                 // If we hit the end of the buffer and didn't have enough bytes, we must
                 // read some more from the underlying stream.  However, if we got
@@ -533,7 +470,7 @@ public override long Seek(long offset, SeekOrigin origin)
         // internal position
         private long SeekCore(SafeFileHandle fileHandle, long offset, SeekOrigin origin, bool closeInvalidHandle = false)
         {
-            Debug.Assert(!fileHandle.IsClosed && _canSeek, "!fileHandle.IsClosed && _canSeek");
+            Debug.Assert(fileHandle.CanSeek, "fileHandle.CanSeek");
 
             return _filePosition = FileStreamHelpers.Seek(fileHandle, _path, offset, origin, closeInvalidHandle);
         }
@@ -655,7 +592,7 @@ private unsafe void WriteCore(ReadOnlySpan<byte> source)
 
             Debug.Assert((_readPos == 0 && _readLength == 0 && _writePos >= 0) || (_writePos == 0 && _readPos <= _readLength), "We're either reading or writing, but not both.");
 
-            if (_isPipe)
+            if (_fileHandle.IsPipe)
             {
                 // Pipes are tricky, at least when you have 2 different pipes
                 // that you want to use simultaneously.  When redirecting stdout
@@ -686,7 +623,7 @@ private unsafe void WriteCore(ReadOnlySpan<byte> source)
                 }
             }
 
-            Debug.Assert(!_isPipe, "Should not be a pipe.");
+            Debug.Assert(!_fileHandle.IsPipe, "Should not be a pipe.");
 
             // Handle buffering.
             if (_writePos > 0) FlushWriteBuffer();
@@ -865,12 +802,12 @@ private ValueTask WriteAsyncInternal(ReadOnlyMemory<byte> source, CancellationTo
         {
             Debug.Assert(_useAsyncIO);
             Debug.Assert((_readPos == 0 && _readLength == 0 && _writePos >= 0) || (_writePos == 0 && _readPos <= _readLength), "We're either reading or writing, but not both.");
-            Debug.Assert(!_isPipe || (_readPos == 0 && _readLength == 0), "Win32FileStream must not have buffered data here!  Pipes should be unidirectional.");
+            Debug.Assert(!_fileHandle.IsPipe || (_readPos == 0 && _readLength == 0), "Win32FileStream must not have buffered data here!  Pipes should be unidirectional.");
 
             if (!CanWrite) ThrowHelper.ThrowNotSupportedException_UnwritableStream();
 
             bool writeDataStoredInBuffer = false;
-            if (!_isPipe) // avoid async buffering with pipes, as doing so can lead to deadlocks (see comments in ReadInternalAsyncCore)
+            if (!_fileHandle.IsPipe) // avoid async buffering with pipes, as doing so can lead to deadlocks (see comments in ReadInternalAsyncCore)
             {
                 // Ensure the buffer is clear for writing
                 if (_writePos == 0)
@@ -1068,14 +1005,14 @@ private unsafe int ReadFileNative(SafeFileHandle handle, Span<byte> bytes, Nativ
         {
             Debug.Assert((_useAsyncIO && overlapped != null) || (!_useAsyncIO && overlapped == null), "Async IO and overlapped parameters inconsistent in call to ReadFileNative.");
 
-            return FileStreamHelpers.ReadFileNative(handle, bytes, false, overlapped, out errorCode);
+            return RandomAccess.ReadFileNative(handle, bytes, false, overlapped, out errorCode);
         }
 
         private unsafe int WriteFileNative(SafeFileHandle handle, ReadOnlySpan<byte> buffer, NativeOverlapped* overlapped, out int errorCode)
         {
             Debug.Assert((_useAsyncIO && overlapped != null) || (!_useAsyncIO && overlapped == null), "Async IO and overlapped parameters inconsistent in call to WriteFileNative.");
 
-            return FileStreamHelpers.WriteFileNative(handle, buffer, false, overlapped, out errorCode);
+            return RandomAccess.WriteFileNative(handle, buffer, false, overlapped, out errorCode);
         }
 
         public override Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken)
diff --git a/src/libraries/System.Private.CoreLib/src/System/IO/Strategies/Net5CompatFileStreamStrategy.cs b/src/libraries/System.Private.CoreLib/src/System/IO/Strategies/Net5CompatFileStreamStrategy.cs
index d257df97722da8..9a88f5a65d4894 100644
--- a/src/libraries/System.Private.CoreLib/src/System/IO/Strategies/Net5CompatFileStreamStrategy.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/IO/Strategies/Net5CompatFileStreamStrategy.cs
@@ -89,11 +89,11 @@ internal Net5CompatFileStreamStrategy(string path, FileMode mode, FileAccess acc
             if ((options & FileOptions.Asynchronous) != 0)
                 _useAsyncIO = true;
 
-            _fileHandle = FileStreamHelpers.OpenHandle(fullPath, mode, access, share, options, preallocationSize);
+            _fileHandle = SafeFileHandle.Open(fullPath, mode, access, share, options, preallocationSize);
 
             try
             {
-                Init(mode, share, path, options, preallocationSize);
+                Init(mode, path, options);
             }
             catch
             {
diff --git a/src/libraries/System.Private.CoreLib/src/System/IO/Strategies/SyncWindowsFileStreamStrategy.cs b/src/libraries/System.Private.CoreLib/src/System/IO/Strategies/SyncWindowsFileStreamStrategy.cs
index 30499b660ddf00..e3f111e2c71fa0 100644
--- a/src/libraries/System.Private.CoreLib/src/System/IO/Strategies/SyncWindowsFileStreamStrategy.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/IO/Strategies/SyncWindowsFileStreamStrategy.cs
@@ -22,20 +22,6 @@ internal SyncWindowsFileStreamStrategy(string path, FileMode mode, FileAccess ac
 
         internal override bool IsAsync => false;
 
-        protected override void OnInitFromHandle(SafeFileHandle handle)
-        {
-            // As we can accurately check the handle type when we have access to NtQueryInformationFile we don't need to skip for
-            // any particular file handle type.
-
-            // If the handle was passed in without an explicit async setting, we already looked it up in GetDefaultIsAsync
-            if (!handle.IsAsync.HasValue)
-                return;
-
-            // If we can't check the handle, just assume it is ok.
-            if (!(FileStreamHelpers.IsHandleSynchronous(handle, ignoreInvalid: false) ?? true))
-                ThrowHelper.ThrowArgumentException_HandleNotSync(nameof(handle));
-        }
-
         public override int Read(byte[] buffer, int offset, int count) => ReadSpan(new Span<byte>(buffer, offset, count));
 
         public override int Read(Span<byte> buffer) => ReadSpan(buffer);
@@ -104,25 +90,8 @@ private unsafe int ReadSpan(Span<byte> destination)
 
             Debug.Assert(!_fileHandle.IsClosed, "!_handle.IsClosed");
 
-            NativeOverlapped nativeOverlapped = GetNativeOverlappedForCurrentPosition();
-            int r = FileStreamHelpers.ReadFileNative(_fileHandle, destination, true, &nativeOverlapped, out int errorCode);
-
-            if (r == -1)
-            {
-                // For pipes, ERROR_BROKEN_PIPE is the normal end of the pipe.
-                if (errorCode == Interop.Errors.ERROR_BROKEN_PIPE)
-                {
-                    r = 0;
-                }
-                else
-                {
-                    if (errorCode == Interop.Errors.ERROR_INVALID_PARAMETER)
-                        ThrowHelper.ThrowArgumentException_HandleNotSync(nameof(_fileHandle));
-
-                    throw Win32Marshal.GetExceptionForWin32Error(errorCode, _path);
-                }
-            }
-            Debug.Assert(r >= 0, "FileStream's ReadNative is likely broken.");
+            int r = RandomAccess.ReadAtOffset(_fileHandle, destination, _filePosition, _path);
+            Debug.Assert(r >= 0, $"RandomAccess.ReadAtOffset returned {r}.");
             _filePosition += r;
 
             return r;
@@ -137,39 +106,11 @@ private unsafe void WriteSpan(ReadOnlySpan<byte> source)
 
             Debug.Assert(!_fileHandle.IsClosed, "!_handle.IsClosed");
 
-            NativeOverlapped nativeOverlapped = GetNativeOverlappedForCurrentPosition();
-            int r = FileStreamHelpers.WriteFileNative(_fileHandle, source, true, &nativeOverlapped, out int errorCode);
-
-            if (r == -1)
-            {
-                // For pipes, ERROR_NO_DATA is not an error, but the pipe is closing.
-                if (errorCode == Interop.Errors.ERROR_NO_DATA)
-                {
-                    r = 0;
-                }
-                else
-                {
-                    // ERROR_INVALID_PARAMETER may be returned for writes
-                    // where the position is too large or for synchronous writes
-                    // to a handle opened asynchronously.
-                    if (errorCode == Interop.Errors.ERROR_INVALID_PARAMETER)
-                        throw new IOException(SR.IO_FileTooLongOrHandleNotSync);
-                    throw Win32Marshal.GetExceptionForWin32Error(errorCode, _path);
-                }
-            }
-            Debug.Assert(r >= 0, "FileStream's WriteCore is likely broken.");
+            int r = RandomAccess.WriteAtOffset(_fileHandle, source, _filePosition, _path);
+            Debug.Assert(r >= 0, $"RandomAccess.WriteAtOffset returned {r}.");
             _filePosition += r;
-            UpdateLengthOnChangePosition();
-        }
-
-        private NativeOverlapped GetNativeOverlappedForCurrentPosition()
-        {
-            NativeOverlapped nativeOverlapped = default;
-            // For pipes the offsets are ignored by the OS
-            nativeOverlapped.OffsetLow = unchecked((int)_filePosition);
-            nativeOverlapped.OffsetHigh = (int)(_filePosition >> 32);
 
-            return nativeOverlapped;
+            UpdateLengthOnChangePosition();
         }
     }
 }
diff --git a/src/libraries/System.Private.CoreLib/src/System/IO/Strategies/WindowsFileStreamStrategy.cs b/src/libraries/System.Private.CoreLib/src/System/IO/Strategies/WindowsFileStreamStrategy.cs
index a5ebdd6f5da599..dee1c5a954857b 100644
--- a/src/libraries/System.Private.CoreLib/src/System/IO/Strategies/WindowsFileStreamStrategy.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/IO/Strategies/WindowsFileStreamStrategy.cs
@@ -14,8 +14,6 @@ internal abstract class WindowsFileStreamStrategy : FileStreamStrategy
         protected readonly string? _path; // The path to the opened file.
         private readonly FileAccess _access; // What file was opened for.
         private readonly FileShare _share;
-        private readonly bool _canSeek; // Whether can seek (file) or not (pipe).
-        private readonly bool _isPipe; // Whether to disable async buffering code.
 
         protected long _filePosition;
         private long _appendStart; // When appending, prevent overwriting file.
@@ -24,16 +22,23 @@ internal abstract class WindowsFileStreamStrategy : FileStreamStrategy
 
         internal WindowsFileStreamStrategy(SafeFileHandle handle, FileAccess access, FileShare share)
         {
-            InitFromHandle(handle, access, out _canSeek, out _isPipe);
-
-            // Note: Cleaner to set the following fields in ValidateAndInitFromHandle,
-            // but we can't as they're readonly.
             _access = access;
             _share = share;
             _exposedHandle = true;
 
-            // As the handle was passed in, we must set the handle field at the very end to
-            // avoid the finalizer closing the handle when we throw errors.
+            handle.InitThreadPoolBindingIfNeeded();
+
+            if (handle.CanSeek)
+            {
+                // given strategy was created out of existing handle, so we have to perform
+                // a syscall to get the current handle offset
+                _filePosition = FileStreamHelpers.Seek(handle, _path, 0, SeekOrigin.Current);
+            }
+            else
+            {
+                _filePosition = 0;
+            }
+
             _fileHandle = handle;
         }
 
@@ -45,12 +50,10 @@ internal WindowsFileStreamStrategy(string path, FileMode mode, FileAccess access
             _access = access;
             _share = share;
 
-            _fileHandle = FileStreamHelpers.OpenHandle(fullPath, mode, access, share, options, preallocationSize);
+            _fileHandle = SafeFileHandle.Open(fullPath, mode, access, share, options, preallocationSize);
 
             try
             {
-                _canSeek = true;
-
                 Init(mode, path);
             }
             catch
@@ -63,7 +66,7 @@ internal WindowsFileStreamStrategy(string path, FileMode mode, FileAccess access
             }
         }
 
-        public sealed override bool CanSeek => _canSeek;
+        public sealed override bool CanSeek => _fileHandle.CanSeek;
 
         public sealed override bool CanRead => !_fileHandle.IsClosed && (_access & FileAccess.Read) != 0;
 
@@ -77,12 +80,12 @@ public unsafe sealed override long Length
             {
                 if (_share > FileShare.Read || _exposedHandle)
                 {
-                    return FileStreamHelpers.GetFileLength(_fileHandle, _path);
+                    return RandomAccess.GetFileLength(_fileHandle, _path);
                 }
 
                 if (_length < 0)
                 {
-                    _length = FileStreamHelpers.GetFileLength(_fileHandle, _path);
+                    _length = RandomAccess.GetFileLength(_fileHandle, _path);
                 }
 
                 return _length;
@@ -116,7 +119,8 @@ public override long Position
 
         internal sealed override bool IsClosed => _fileHandle.IsClosed;
 
-        internal sealed override bool IsPipe => _isPipe;
+        internal sealed override bool IsPipe => _fileHandle.IsPipe;
+
         // Flushing is the responsibility of BufferedFileStreamStrategy
         internal sealed override SafeFileHandle SafeFileHandle
         {
@@ -226,16 +230,10 @@ public sealed override long Seek(long offset, SeekOrigin origin)
 
         internal sealed override void Unlock(long position, long length) => FileStreamHelpers.Unlock(_fileHandle, _path, position, length);
 
-        protected abstract void OnInitFromHandle(SafeFileHandle handle);
-
-        protected virtual void OnInit() { }
-
         private void Init(FileMode mode, string originalPath)
         {
             FileStreamHelpers.ValidateFileTypeForNonExtendedPaths(_fileHandle, originalPath);
 
-            OnInit();
-
             // For Append mode...
             if (mode == FileMode.Append)
             {
@@ -247,43 +245,6 @@ private void Init(FileMode mode, string originalPath)
             }
         }
 
-        private void InitFromHandle(SafeFileHandle handle, FileAccess access, out bool canSeek, out bool isPipe)
-        {
-#if DEBUG
-            bool hadBinding = handle.ThreadPoolBinding != null;
-
-            try
-            {
-#endif
-                InitFromHandleImpl(handle, out canSeek, out isPipe);
-#if DEBUG
-            }
-            catch
-            {
-                Debug.Assert(hadBinding || handle.ThreadPoolBinding == null, "We should never error out with a ThreadPoolBinding we've added");
-                throw;
-            }
-#endif
-        }
-
-        private void InitFromHandleImpl(SafeFileHandle handle, out bool canSeek, out bool isPipe)
-        {
-            FileStreamHelpers.GetFileTypeSpecificInformation(handle, out canSeek, out isPipe);
-
-            OnInitFromHandle(handle);
-
-            if (_canSeek)
-            {
-                // given strategy was created out of existing handle, so we have to perform
-                // a syscall to get the current handle offset
-                _filePosition = FileStreamHelpers.Seek(handle, _path, 0, SeekOrigin.Current);
-            }
-            else
-            {
-                _filePosition = 0;
-            }
-        }
-
         public sealed override void SetLength(long value)
         {
             if (_appendStart != -1 && value < _appendStart)
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 2e2821a2b17d6c..af35711a682d08 100644
--- a/src/libraries/System.Private.CoreLib/src/System/IO/StreamReader.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/IO/StreamReader.cs
@@ -193,12 +193,40 @@ public StreamReader(string path, Encoding encoding, bool detectEncodingFromByteO
         {
         }
 
-        public StreamReader(string path, Encoding encoding, bool detectEncodingFromByteOrderMarks, int bufferSize) :
-            this(ValidateArgsAndOpenPath(path, encoding, bufferSize), encoding, detectEncodingFromByteOrderMarks, bufferSize, leaveOpen: false)
+        public StreamReader(string path, Encoding encoding, bool detectEncodingFromByteOrderMarks, int bufferSize)
+            : this(ValidateArgsAndOpenPath(path, encoding, bufferSize), encoding, detectEncodingFromByteOrderMarks, bufferSize, leaveOpen: false)
         {
         }
 
+        public StreamReader(string path, FileStreamOptions options)
+            : this(path, Encoding.UTF8, true, options)
+        {
+        }
+
+        public StreamReader(string path, Encoding encoding, bool detectEncodingFromByteOrderMarks, FileStreamOptions options)
+            : this(ValidateArgsAndOpenPath(path, encoding, options), encoding, detectEncodingFromByteOrderMarks, DefaultBufferSize)
+        {
+        }
+
+        private static Stream ValidateArgsAndOpenPath(string path, Encoding encoding, FileStreamOptions options)
+        {
+            ValidateArgs(path, encoding);
+            if (options == null)
+                throw new ArgumentNullException(nameof(options));
+
+            return new FileStream(path, options);
+        }
+
         private static Stream ValidateArgsAndOpenPath(string path, Encoding encoding, int bufferSize)
+        {
+            ValidateArgs(path, 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));
@@ -206,10 +234,6 @@ private static Stream ValidateArgsAndOpenPath(string path, Encoding encoding, in
                 throw new ArgumentNullException(nameof(encoding));
             if (path.Length == 0)
                 throw new ArgumentException(SR.Argument_EmptyPath);
-            if (bufferSize <= 0)
-                throw new ArgumentOutOfRangeException(nameof(bufferSize), SR.ArgumentOutOfRange_NeedPosNum);
-
-            return new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read, DefaultFileStreamBufferSize, FileOptions.SequentialScan);
         }
 
         public override void Close()
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 875211723da6b6..96ac62fd51dd4e 100644
--- a/src/libraries/System.Private.CoreLib/src/System/IO/StreamWriter.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/IO/StreamWriter.cs
@@ -154,7 +154,35 @@ public StreamWriter(string path, bool append, Encoding encoding, int bufferSize)
         {
         }
 
+        public StreamWriter(string path, FileStreamOptions options)
+            : this(path, UTF8NoBOM, options)
+        {
+        }
+
+        public StreamWriter(string path, Encoding encoding, FileStreamOptions options)
+            : this(ValidateArgsAndOpenPath(path, encoding, options), encoding, DefaultFileStreamBufferSize)
+        {
+        }
+
+        private static Stream ValidateArgsAndOpenPath(string path, Encoding encoding, FileStreamOptions options)
+        {
+            ValidateArgs(path, encoding);
+            if (options == null)
+                throw new ArgumentNullException(nameof(options));
+
+            return new FileStream(path, options);
+        }
+
         private static Stream ValidateArgsAndOpenPath(string path, bool append, Encoding encoding, int bufferSize)
+        {
+            ValidateArgs(path, 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));
@@ -162,10 +190,6 @@ private static Stream ValidateArgsAndOpenPath(string path, bool append, Encoding
                 throw new ArgumentNullException(nameof(encoding));
             if (path.Length == 0)
                 throw new ArgumentException(SR.Argument_EmptyPath);
-            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, FileOptions.SequentialScan);
         }
 
         public override void Close()
diff --git a/src/libraries/System.Private.CoreLib/src/System/Int32.cs b/src/libraries/System.Private.CoreLib/src/System/Int32.cs
index 14822bac0d6b19..3c46f513dc5a83 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Int32.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Int32.cs
@@ -143,7 +143,7 @@ public static int Parse(ReadOnlySpan<char> s, NumberStyles style = NumberStyles.
         }
 
         // Parses an integer from a String. Returns false rather
-        // than throwing exceptin if input is invalid
+        // than throwing an exception if input is invalid.
         //
         public static bool TryParse([NotNullWhen(true)] string? s, out int result)
         {
@@ -162,7 +162,7 @@ public static bool TryParse(ReadOnlySpan<char> s, out int result)
         }
 
         // Parses an integer from a String in the given style. Returns false rather
-        // than throwing exceptin if input is invalid
+        // than throwing an exception if input is invalid.
         //
         public static bool TryParse([NotNullWhen(true)] string? s, NumberStyles style, IFormatProvider? provider, out int result)
         {
diff --git a/src/libraries/System.Private.CoreLib/src/System/Math.cs b/src/libraries/System.Private.CoreLib/src/System/Math.cs
index c215d7a68ef259..bb7fa0d4d3c8bb 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Math.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Math.cs
@@ -1175,7 +1175,7 @@ public static double Round(double a)
 
             // This is based on the 'Berkeley SoftFloat Release 3e' algorithm
 
-            ulong bits = (ulong)BitConverter.DoubleToInt64Bits(a);
+            ulong bits = BitConverter.DoubleToUInt64Bits(a);
             int exponent = double.ExtractExponentFromBits(bits);
 
             if (exponent <= 0x03FE)
@@ -1231,7 +1231,7 @@ public static double Round(double a)
                 bits &= ~roundBitsMask;
             }
 
-            return BitConverter.Int64BitsToDouble((long)bits);
+            return BitConverter.UInt64BitsToDouble(bits);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
diff --git a/src/libraries/System.Private.CoreLib/src/System/MathF.cs b/src/libraries/System.Private.CoreLib/src/System/MathF.cs
index 0050f5d43368cc..9d1b75c8b16172 100644
--- a/src/libraries/System.Private.CoreLib/src/System/MathF.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/MathF.cs
@@ -325,7 +325,7 @@ public static float Round(float x)
 
             // This is based on the 'Berkeley SoftFloat Release 3e' algorithm
 
-            uint bits = (uint)BitConverter.SingleToInt32Bits(x);
+            uint bits = BitConverter.SingleToUInt32Bits(x);
             int exponent = float.ExtractExponentFromBits(bits);
 
             if (exponent <= 0x7E)
@@ -381,7 +381,7 @@ public static float Round(float x)
                 bits &= ~roundBitsMask;
             }
 
-            return BitConverter.Int32BitsToSingle((int)bits);
+            return BitConverter.UInt32BitsToSingle(bits);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
diff --git a/src/libraries/System.Private.CoreLib/src/System/MemoryExtensions.Globalization.cs b/src/libraries/System.Private.CoreLib/src/System/MemoryExtensions.Globalization.cs
index ce136377a41608..9fd5bed5d6aea3 100644
--- a/src/libraries/System.Private.CoreLib/src/System/MemoryExtensions.Globalization.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/MemoryExtensions.Globalization.cs
@@ -380,5 +380,29 @@ public static SpanRuneEnumerator EnumerateRunes(this Span<char> span)
         {
             return new SpanRuneEnumerator(span);
         }
+
+        /// <summary>
+        /// Returns an enumeration of lines over the provided span.
+        /// </summary>
+        /// <remarks>
+        /// See the documentation for <see cref="string.ReplaceLineEndings"/> for more information
+        /// on how newline sequences are detected.
+        /// </remarks>
+        public static SpanLineEnumerator EnumerateLines(this ReadOnlySpan<char> span)
+        {
+            return new SpanLineEnumerator(span);
+        }
+
+        /// <summary>
+        /// Returns an enumeration of lines over the provided span.
+        /// </summary>
+        /// <remarks>
+        /// See the documentation for <see cref="string.ReplaceLineEndings"/> for more information
+        /// on how newline sequences are detected.
+        /// </remarks>
+        public static SpanLineEnumerator EnumerateLines(this Span<char> span)
+        {
+            return new SpanLineEnumerator(span);
+        }
     }
 }
diff --git a/src/libraries/System.Private.CoreLib/src/System/Number.Formatting.cs b/src/libraries/System.Private.CoreLib/src/System/Number.Formatting.cs
index be13d587923653..408c83cb050585 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Number.Formatting.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Number.Formatting.cs
@@ -2629,7 +2629,7 @@ private static uint Int64DivMod1E9(ref ulong value)
 
         private static ulong ExtractFractionAndBiasedExponent(double value, out int exponent)
         {
-            ulong bits = (ulong)(BitConverter.DoubleToInt64Bits(value));
+            ulong bits = BitConverter.DoubleToUInt64Bits(value);
             ulong fraction = (bits & 0xFFFFFFFFFFFFF);
             exponent = ((int)(bits >> 52) & 0x7FF);
 
@@ -2661,7 +2661,7 @@ private static ulong ExtractFractionAndBiasedExponent(double value, out int expo
 
         private static ushort ExtractFractionAndBiasedExponent(Half value, out int exponent)
         {
-            ushort bits = (ushort)BitConverter.HalfToInt16Bits(value);
+            ushort bits = BitConverter.HalfToUInt16Bits(value);
             ushort fraction = (ushort)(bits & 0x3FF);
             exponent = ((int)(bits >> 10) & 0x1F);
 
@@ -2693,7 +2693,7 @@ private static ushort ExtractFractionAndBiasedExponent(Half value, out int expon
 
         private static uint ExtractFractionAndBiasedExponent(float value, out int exponent)
         {
-            uint bits = (uint)(BitConverter.SingleToInt32Bits(value));
+            uint bits = BitConverter.SingleToUInt32Bits(value);
             uint fraction = (bits & 0x7FFFFF);
             exponent = ((int)(bits >> 23) & 0xFF);
 
diff --git a/src/libraries/System.Private.CoreLib/src/System/Number.NumberToFloatingPointBits.cs b/src/libraries/System.Private.CoreLib/src/System/Number.NumberToFloatingPointBits.cs
index 1c839aea90fc23..e6465da384e252 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Number.NumberToFloatingPointBits.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Number.NumberToFloatingPointBits.cs
@@ -388,7 +388,7 @@ private static ulong NumberToDoubleFloatingPointBits(ref NumberBuffer number, in
                     result *= scale;
                 }
 
-                return (ulong)(BitConverter.DoubleToInt64Bits(result));
+                return BitConverter.DoubleToUInt64Bits(result);
             }
 
             return NumberToFloatingPointBitsSlow(ref number, in info, positiveExponent, integerDigitsPresent, fractionalDigitsPresent);
@@ -450,7 +450,7 @@ private static ushort NumberToHalfFloatingPointBits(ref NumberBuffer number, in
                     result *= scale;
                 }
 
-                return (ushort)(BitConverter.HalfToInt16Bits((Half)result));
+                return BitConverter.HalfToUInt16Bits((Half)result);
             }
 
             if ((totalDigits <= 15) && (fastExponent <= 22))
@@ -467,7 +467,7 @@ private static ushort NumberToHalfFloatingPointBits(ref NumberBuffer number, in
                     result *= scale;
                 }
 
-                return (ushort)(BitConverter.HalfToInt16Bits((Half)(result)));
+                return BitConverter.HalfToUInt16Bits((Half)(result));
             }
 
             return (ushort)NumberToFloatingPointBitsSlow(ref number, in info, positiveExponent, integerDigitsPresent, fractionalDigitsPresent);
@@ -529,7 +529,7 @@ private static uint NumberToSingleFloatingPointBits(ref NumberBuffer number, in
                     result *= scale;
                 }
 
-                return (uint)(BitConverter.SingleToInt32Bits(result));
+                return BitConverter.SingleToUInt32Bits(result);
             }
 
             if ((totalDigits <= 15) && (fastExponent <= 22))
@@ -546,7 +546,7 @@ private static uint NumberToSingleFloatingPointBits(ref NumberBuffer number, in
                     result *= scale;
                 }
 
-                return (uint)(BitConverter.SingleToInt32Bits((float)(result)));
+                return BitConverter.SingleToUInt32Bits((float)(result));
             }
 
             return (uint)NumberToFloatingPointBitsSlow(ref number, in info, positiveExponent, integerDigitsPresent, fractionalDigitsPresent);
diff --git a/src/libraries/System.Private.CoreLib/src/System/Number.Parsing.cs b/src/libraries/System.Private.CoreLib/src/System/Number.Parsing.cs
index 382eb1ccf82a55..40e2fa9a76ee34 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Number.Parsing.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Number.Parsing.cs
@@ -2143,7 +2143,7 @@ internal static double NumberToDouble(ref NumberBuffer number)
             else
             {
                 ulong bits = NumberToDoubleFloatingPointBits(ref number, in FloatingPointInfo.Double);
-                result = BitConverter.Int64BitsToDouble((long)(bits));
+                result = BitConverter.UInt64BitsToDouble(bits);
             }
 
             return number.IsNegative ? -result : result;
@@ -2187,7 +2187,7 @@ internal static float NumberToSingle(ref NumberBuffer number)
             else
             {
                 uint bits = NumberToSingleFloatingPointBits(ref number, in FloatingPointInfo.Single);
-                result = BitConverter.Int32BitsToSingle((int)(bits));
+                result = BitConverter.UInt32BitsToSingle(bits);
             }
 
             return number.IsNegative ? -result : result;
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 826a129be7f854..b5ffd5e777d984 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Numerics/BitOperations.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Numerics/BitOperations.cs
@@ -71,18 +71,67 @@ public static class BitOperations
         [CLSCompliant(false)]
         public static bool IsPow2(ulong value) => (value & (value - 1)) == 0 && value != 0;
 
+        /// <summary>
+        /// Evaluate whether a given integral value is a power of 2.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static bool IsPow2(nint value) => (value & (value - 1)) == 0 && value > 0;
+
+        /// <summary>
+        /// Evaluate whether a given integral value is a power of 2.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static bool IsPow2(nuint value) => (value & (value - 1)) == 0 && value != 0;
+
         /// <summary>Round the given integral value up to a power of 2.</summary>
         /// <param name="value">The value.</param>
-        internal static uint RoundUpToPowerOf2(uint value)
+        /// <returns>
+        /// The smallest power of 2 which is greater than or equal to <paramref name="value"/>.
+        /// If <paramref name="value"/> is 0 or the result overflows, returns 0.
+        /// </returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [CLSCompliant(false)]
+        public static uint RoundUpToPowerOf2(uint value)
         {
-            // TODO: https://github.com/dotnet/runtime/issues/43135
-            // When this is exposed publicly, decide on the behavior for the boundary cases...
-            // the accelerated and fallback paths differ.
-            Debug.Assert(value > 0 && value <= (uint.MaxValue / 2) + 1);
-
             if (Lzcnt.IsSupported || ArmBase.IsSupported || X86Base.IsSupported)
             {
-                return 1u << (32 - LeadingZeroCount(value - 1));
+#if TARGET_64BIT
+                return (uint)(0x1_0000_0000ul >> LeadingZeroCount(value - 1));
+#else
+                int shift = 32 - LeadingZeroCount(value - 1);
+                return (1u ^ (uint)(shift >> 5)) << shift;
+#endif
+            }
+
+            // Based on https://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
+            --value;
+            value |= value >> 1;
+            value |= value >> 2;
+            value |= value >> 4;
+            value |= value >> 8;
+            value |= value >> 16;
+            return value + 1;
+        }
+
+
+        /// <summary>
+        /// Round the given integral value up to a power of 2.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        /// <returns>
+        /// The smallest power of 2 which is greater than or equal to <paramref name="value"/>.
+        /// If <paramref name="value"/> is 0 or the result overflows, returns 0.
+        /// </returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [CLSCompliant(false)]
+        public static ulong RoundUpToPowerOf2(ulong value)
+        {
+            if (Lzcnt.X64.IsSupported || ArmBase.Arm64.IsSupported)
+            {
+                int shift = 64 - LeadingZeroCount(value - 1);
+                return (1ul ^ (ulong)(shift >> 6)) << shift;
             }
 
             // Based on https://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
@@ -92,6 +141,7 @@ internal static uint RoundUpToPowerOf2(uint value)
             value |= value >> 4;
             value |= value >> 8;
             value |= value >> 16;
+            value |= value >> 32;
             return value + 1;
         }
 
diff --git a/src/libraries/System.Private.CoreLib/src/System/Numerics/Vector.cs b/src/libraries/System.Private.CoreLib/src/System/Numerics/Vector.cs
index c563a5d79404a9..c0464fe7715296 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Numerics/Vector.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Numerics/Vector.cs
@@ -1292,5 +1292,14 @@ public static Vector<TTo> As<TFrom, TTo>(this Vector<TFrom> vector)
 
             return Unsafe.As<Vector<TFrom>, Vector<TTo>>(ref vector);
         }
+
+        /// <summary>
+        /// Returns the sum of all elements inside the vector.
+        /// </summary>
+        [Intrinsic]
+        public static T Sum<T>(Vector<T> value) where T : struct
+        {
+            return Vector<T>.Sum(value);
+        }
     }
 }
diff --git a/src/libraries/System.Private.CoreLib/src/System/Numerics/Vector_1.cs b/src/libraries/System.Private.CoreLib/src/System/Numerics/Vector_1.cs
index 3bd503ac8f4b2d..054cf5ea19b138 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Numerics/Vector_1.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Numerics/Vector_1.cs
@@ -822,6 +822,19 @@ internal static T Dot(Vector<T> left, Vector<T> right)
             return product;
         }
 
+        [Intrinsic]
+        internal static T Sum(Vector<T> value)
+        {
+            T sum = default;
+
+            for (nint index = 0; index < Count; index++)
+            {
+                sum = ScalarAdd(sum, value.GetElement(index));
+            }
+
+            return sum;
+        }
+
         [Intrinsic]
         internal static unsafe Vector<T> SquareRoot(Vector<T> value)
         {
diff --git a/src/libraries/System.Private.CoreLib/src/System/Reflection/TypeDelegator.cs b/src/libraries/System.Private.CoreLib/src/System/Reflection/TypeDelegator.cs
index f09c20aa97b9ee..d9de5027ce0a20 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Reflection/TypeDelegator.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Reflection/TypeDelegator.cs
@@ -126,6 +126,8 @@ public TypeDelegator([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.
         [DynamicallyAccessedMembers(GetAllMembers)]
         public override MemberInfo[] GetMembers(BindingFlags bindingAttr) => typeImpl.GetMembers(bindingAttr);
 
+        public override MemberInfo GetMemberWithSameMetadataDefinitionAs(MemberInfo member) => typeImpl.GetMemberWithSameMetadataDefinitionAs(member);
+
         protected override TypeAttributes GetAttributeFlagsImpl() => typeImpl.Attributes;
 
         public override bool IsTypeDefinition => typeImpl.IsTypeDefinition;
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/CompilerServices/AsyncTaskMethodBuilderT.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/CompilerServices/AsyncTaskMethodBuilderT.cs
index 35c73e3400b87c..fdf9943aeb8218 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/CompilerServices/AsyncTaskMethodBuilderT.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/CompilerServices/AsyncTaskMethodBuilderT.cs
@@ -329,6 +329,11 @@ private void MoveNext(Thread? threadPoolThread)
                     }
                 }
 
+                if (IsCompleted)
+                {
+                    ClearStateUponCompletion();
+                }
+
                 if (loggingOn)
                 {
                     TplEventSource.Log.TraceSynchronousWorkEnd(CausalitySynchronousWork.Execution);
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/ExceptionServices/ExceptionDispatchInfo.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/ExceptionServices/ExceptionDispatchInfo.cs
index d89ef99c9ac7b3..1279da2d974fa7 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/ExceptionServices/ExceptionDispatchInfo.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/ExceptionServices/ExceptionDispatchInfo.cs
@@ -93,7 +93,10 @@ public static Exception SetCurrentStackTrace(Exception source)
         /// This method populates the <see cref="Exception.StackTrace"/> property from an arbitrary string value.
         /// The typical use case is the transmission of <see cref="Exception"/> objects across processes with high fidelity,
         /// allowing preservation of the exception object's stack trace information. .NET does not attempt to parse the
-        /// provided string value. The caller is responsible for normalizing line endings if required.
+        /// provided string value.
+        ///
+        /// The caller is responsible for canonicalizing line endings if required. <see cref="string.ReplaceLineEndings"/>
+        /// can be used to canonicalize line endings.
         /// </remarks>
         public static Exception SetRemoteStackTrace(Exception source, string stackTrace)
         {
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/GCSettings.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/GCSettings.cs
index 92ae76559932d1..6670c738f8bdd9 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/GCSettings.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/GCSettings.cs
@@ -37,7 +37,7 @@ public static GCLatencyMode LatencyMode
                 if ((value < GCLatencyMode.Batch) ||
                     (value > GCLatencyMode.SustainedLowLatency))
                 {
-                    throw new ArgumentOutOfRangeException(nameof(value), SR.ArgumentOutOfRange_Enum);
+                    ThrowHelper.ArgumentOutOfRangeException_Enum_Value();
                 }
 
                 SetLatencyModeStatus status = SetGCLatencyMode(value);
@@ -58,7 +58,7 @@ public static GCLargeObjectHeapCompactionMode LargeObjectHeapCompactionMode
                 if ((value < GCLargeObjectHeapCompactionMode.Default) ||
                     (value > GCLargeObjectHeapCompactionMode.CompactOnce))
                 {
-                    throw new ArgumentOutOfRangeException(nameof(value), SR.ArgumentOutOfRange_Enum);
+                    ThrowHelper.ArgumentOutOfRangeException_Enum_Value();
                 }
 
                 SetLOHCompactionMode(value);
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/Marshal.Unix.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/Marshal.Unix.cs
index 08ab87a390fffc..49ef8223c370f9 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/Marshal.Unix.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/Marshal.Unix.cs
@@ -62,73 +62,37 @@ internal static unsafe void GetAnsiStringBytes(ReadOnlySpan<char> chars, Span<by
             bytes[actualByteLength] = 0;
         }
 
-        public static IntPtr AllocHGlobal(IntPtr cb)
+        public static unsafe IntPtr AllocHGlobal(IntPtr cb)
         {
-            nuint cbNative = (nuint)(nint)cb;
-
-            // Avoid undefined malloc behavior by always allocating at least one byte
-            IntPtr pNewMem = Interop.Sys.MemAlloc((cbNative != 0) ? cbNative : 1);
-            if (pNewMem == IntPtr.Zero)
-            {
-                throw new OutOfMemoryException();
-            }
-
-            return pNewMem;
+            return (nint)NativeMemory.Alloc((nuint)(nint)cb);
         }
 
-        public static void FreeHGlobal(IntPtr hglobal)
+        public static unsafe void FreeHGlobal(IntPtr hglobal)
         {
-            if (hglobal != IntPtr.Zero)
-            {
-                Interop.Sys.MemFree(hglobal);
-            }
+            NativeMemory.Free((void*)(nint)hglobal);
         }
 
-        public static IntPtr ReAllocHGlobal(IntPtr pv, IntPtr cb)
+        public static unsafe IntPtr ReAllocHGlobal(IntPtr pv, IntPtr cb)
         {
-            nuint cbNative = (nuint)(nint)cb;
-
-            if (cbNative == 0)
-            {
-                // ReAllocHGlobal never returns null, even for 0 size (different from standard C/C++ realloc)
-
-                // Avoid undefined realloc behavior by always allocating at least one byte
-                cbNative = 1;
-            }
-
-            IntPtr pNewMem = Interop.Sys.MemReAlloc(pv, cbNative);
-            if (pNewMem == IntPtr.Zero)
-            {
-                throw new OutOfMemoryException();
-            }
-            return pNewMem;
+            return (nint)NativeMemory.Realloc((void*)(nint)pv, (nuint)(nint)cb);
         }
 
         public static IntPtr AllocCoTaskMem(int cb) => AllocHGlobal((nint)(uint)cb);
 
         public static void FreeCoTaskMem(IntPtr ptr) => FreeHGlobal(ptr);
 
-        public static IntPtr ReAllocCoTaskMem(IntPtr pv, int cb)
+        public static unsafe IntPtr ReAllocCoTaskMem(IntPtr pv, int cb)
         {
             nuint cbNative = (nuint)(uint)cb;
+            void* pvNative = (void*)(nint)pv;
 
-            if (cbNative == 0)
+            if ((cbNative == 0) && (pvNative != null))
             {
-                if (pv != IntPtr.Zero)
-                {
-                    Interop.Sys.MemFree(pv);
-                    return IntPtr.Zero;
-                }
-                // Avoid undefined realloc behavior by always allocating at least one byte
-                cbNative = 1;
+                Interop.Sys.Free(pvNative);
+                return IntPtr.Zero;
             }
 
-            IntPtr pNewMem = Interop.Sys.MemReAlloc(pv, cbNative);
-            if (pNewMem == IntPtr.Zero)
-            {
-                throw new OutOfMemoryException();
-            }
-            return pNewMem;
+            return (nint)NativeMemory.Realloc((void*)(nint)pv, cbNative);
         }
 
         internal static unsafe IntPtr AllocBSTR(int length)
@@ -137,22 +101,24 @@ internal static unsafe IntPtr AllocBSTR(int length)
             const nuint WIN32_ALLOC_ALIGN = 15;
 
             ulong cbNative = 2 * (ulong)(uint)length + (uint)sizeof(IntPtr) + (uint)sizeof(char) + WIN32_ALLOC_ALIGN;
+
             if (cbNative > uint.MaxValue)
             {
                 throw new OutOfMemoryException();
             }
 
-            IntPtr p = Interop.Sys.MemAlloc((nuint)cbNative & ~WIN32_ALLOC_ALIGN);
-            if (p == IntPtr.Zero)
+            void* p = Interop.Sys.Malloc((nuint)cbNative & ~WIN32_ALLOC_ALIGN);
+
+            if (p == null)
             {
                 throw new OutOfMemoryException();
             }
 
-            IntPtr s = p + sizeof(IntPtr);
+            void* s = (byte*)p + sizeof(nuint);
             *(((uint*)s) - 1) = (uint)(length * sizeof(char));
             ((char*)s)[length] = '\0';
 
-            return s;
+            return (nint)s;
         }
 
         internal static unsafe IntPtr AllocBSTRByteLen(uint length)
@@ -161,32 +127,36 @@ internal static unsafe IntPtr AllocBSTRByteLen(uint length)
             const nuint WIN32_ALLOC_ALIGN = 15;
 
             ulong cbNative = (ulong)(uint)length + (uint)sizeof(IntPtr) + (uint)sizeof(char) + WIN32_ALLOC_ALIGN;
+
             if (cbNative > uint.MaxValue)
             {
                 throw new OutOfMemoryException();
             }
 
-            IntPtr p = Interop.Sys.MemAlloc((nuint)cbNative & ~WIN32_ALLOC_ALIGN);
-            if (p == IntPtr.Zero)
+            void* p = Interop.Sys.Malloc((nuint)cbNative & ~WIN32_ALLOC_ALIGN);
+
+            if (p == null)
             {
                 throw new OutOfMemoryException();
             }
 
-            IntPtr s = p + sizeof(IntPtr);
+            void* s = (byte*)p + sizeof(nuint);
             *(((uint*)s) - 1) = (uint)length;
 
             // NULL-terminate with both a narrow and wide zero.
             *(byte*)((byte*)s + length) = (byte)'\0';
             *(short*)((byte*)s + ((length + 1) & ~1)) = 0;
 
-            return s;
+            return (nint)s;
         }
 
         public static unsafe void FreeBSTR(IntPtr ptr)
         {
-            if (ptr != IntPtr.Zero)
+            void* ptrNative = (void*)(nint)ptr;
+
+            if (ptrNative != null)
             {
-                Interop.Sys.MemFree(ptr - sizeof(IntPtr));
+                Interop.Sys.Free((byte*)ptr - sizeof(nuint));
             }
         }
 
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/NativeMemory.Unix.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/NativeMemory.Unix.cs
new file mode 100644
index 00000000000000..4dc1f1b7f5aa58
--- /dev/null
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/NativeMemory.Unix.cs
@@ -0,0 +1,210 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+
+namespace System.Runtime.InteropServices
+{
+    /// <summary>This class contains methods that are mainly used to manage native memory.</summary>
+    public static unsafe partial class NativeMemory
+    {
+        /// <summary>Allocates an aligned block of memory of the specified size and alignment, in bytes.</summary>
+        /// <param name="byteCount">The size, in bytes, of the block to allocate.</param>
+        /// <param name="alignment">The alignment, in bytes, of the block to allocate. This must be a power of <c>2</c>.</param>
+        /// <returns>A pointer to the allocated aligned block of memory.</returns>
+        /// <exception cref="ArgumentException"><paramref name="alignment" /> is not a power of two.</exception>
+        /// <exception cref="OutOfMemoryException">Allocating <paramref name="byteCount" /> of memory with <paramref name="alignment" /> failed.</exception>
+        /// <remarks>
+        ///     <para>This method allows <paramref name="byteCount" /> to be <c>0</c> and will return a valid pointer that should not be dereferenced and that should be passed to free to avoid memory leaks.</para>
+        ///     <para>This method is a thin wrapper over the C <c>aligned_alloc</c> API or a platform dependent aligned allocation API such as <c>_aligned_malloc</c> on Win32.</para>
+        ///     <para>This method is not compatible with <see cref="Free" /> or <see cref="Realloc" />, instead <see cref="AlignedFree" /> or <see cref="AlignedRealloc" /> should be called.</para>
+        /// </remarks>
+        [CLSCompliant(false)]
+        public static void* AlignedAlloc(nuint byteCount, nuint alignment)
+        {
+            if (!BitOperations.IsPow2(alignment))
+            {
+                // The C standard doesn't define what a valid alignment is, however Windows and POSIX requires a power of 2
+                ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_AlignmentMustBePow2);
+            }
+
+            // The C standard and POSIX requires size to be a multiple of alignment and we want an "empty" allocation for zero
+            // POSIX additionally requires alignment to be at least sizeof(void*)
+
+            // The adjustment for byteCount can overflow here, and such overflow is generally "harmless". This is because of the
+            // requirement that alignment be a power of two and that byteCount be a multiple of alignment. Given both of these
+            // constraints we should only overflow for byteCount > (nuint.MaxValue & ~(alignment - 1)). When such an overflow
+            // occurs we will get a result that is less than alignment which will cause the allocation to fail.
+            //
+            // However, posix_memalign differs from aligned_alloc in that it may return a valid pointer for zero and we need to
+            // ensure we OOM for this scenario (which can occur for `nuint.MaxValue`) and so we have to check the adjusted size.
+
+            nuint adjustedAlignment = Math.Max(alignment, (uint)sizeof(void*));
+            nuint adjustedByteCount = (byteCount != 0) ? (byteCount + (adjustedAlignment - 1)) & ~(adjustedAlignment - 1) : adjustedAlignment;
+
+            void* result = (adjustedByteCount < byteCount) ? null : Interop.Sys.AlignedAlloc(adjustedAlignment, adjustedByteCount);
+
+            if (result == null)
+            {
+                ThrowHelper.ThrowOutOfMemoryException();
+            }
+
+            return result;
+        }
+
+        /// <summary>Frees an aligned block of memory.</summary>
+        /// <param name="ptr">A pointer to the aligned block of memory that should be freed.</param>
+        /// <remarks>
+        ///    <para>This method does nothing if <paramref name="ptr" /> is <c>null</c>.</para>
+        ///    <para>This method is a thin wrapper over the C <c>free</c> API or a platform dependent aligned free API such as <c>_aligned_free</c> on Win32.</para>
+        /// </remarks>
+        [CLSCompliant(false)]
+        public static void AlignedFree(void* ptr)
+        {
+            if (ptr != null)
+            {
+                Interop.Sys.AlignedFree(ptr);
+            }
+        }
+
+        /// <summary>Reallocates an aligned block of memory of the specified size and alignment, in bytes.</summary>
+        /// <param name="ptr">The previously allocated block of memory.</param>
+        /// <param name="byteCount">The size, in bytes, of the block to allocate.</param>
+        /// <param name="alignment">The alignment, in bytes, of the block to allocate. This must be a power of <c>2</c>.</param>
+        /// <returns>A pointer to the reallocated aligned block of memory.</returns>
+        /// <exception cref="ArgumentException"><paramref name="alignment" /> is not a power of two.</exception>
+        /// <exception cref="OutOfMemoryException">Reallocating <paramref name="byteCount" /> of memory with <paramref name="alignment" /> failed.</exception>
+        /// <remarks>
+        ///     <para>This method acts as <see cref="AlignedAlloc" /> if <paramref name="ptr" /> is <c>null</c>.</para>
+        ///     <para>This method allows <paramref name="byteCount" /> to be <c>0</c> and will return a valid pointer that should not be dereferenced and that should be passed to free to avoid memory leaks.</para>
+        ///     <para>This method is a platform dependent aligned reallocation API such as <c>_aligned_realloc</c> on Win32.</para>
+        ///     <para>This method is not compatible with <see cref="Free" /> or <see cref="Realloc" />, instead <see cref="AlignedFree" /> or <see cref="AlignedRealloc" /> should be called.</para>
+        /// </remarks>
+        [CLSCompliant(false)]
+        public static void* AlignedRealloc(void* ptr, nuint byteCount, nuint alignment)
+        {
+            if (!BitOperations.IsPow2(alignment))
+            {
+                // The C standard doesn't define what a valid alignment is, however Windows and POSIX requires a power of 2
+                ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_AlignmentMustBePow2);
+            }
+
+            // The C standard and POSIX requires size to be a multiple of alignment and we want an "empty" allocation for zero
+            // POSIX additionally requires alignment to be at least sizeof(void*)
+
+            // The adjustment for byteCount can overflow here, and such overflow is generally "harmless". This is because of the
+            // requirement that alignment be a power of two and that byteCount be a multiple of alignment. Given both of these
+            // constraints we should only overflow for byteCount > (nuint.MaxValue & ~(alignment - 1)). When such an overflow
+            // occurs we will get a result that is less than alignment which will cause the allocation to fail.
+            //
+            // However, posix_memalign differs from aligned_alloc in that it may return a valid pointer for zero and we need to
+            // ensure we OOM for this scenario (which can occur for `nuint.MaxValue`) and so we have to check the adjusted size.
+
+            nuint adjustedAlignment = Math.Max(alignment, (uint)sizeof(void*));
+            nuint adjustedByteCount = (byteCount != 0) ? (byteCount + (adjustedAlignment - 1)) & ~(adjustedAlignment - 1) : adjustedAlignment;
+
+            void* result = (adjustedByteCount < byteCount) ? null : Interop.Sys.AlignedRealloc(ptr, adjustedAlignment, adjustedByteCount);
+
+            if (result == null)
+            {
+                ThrowHelper.ThrowOutOfMemoryException();
+            }
+
+            return result;
+        }
+
+        /// <summary>Allocates a block of memory of the specified size, in bytes.</summary>
+        /// <param name="byteCount">The size, in bytes, of the block to allocate.</param>
+        /// <returns>A pointer to the allocated block of memory.</returns>
+        /// <exception cref="OutOfMemoryException">Allocating <paramref name="byteCount" /> of memory failed.</exception>
+        /// <remarks>
+        ///     <para>This method allows <paramref name="byteCount" /> to be <c>0</c> and will return a valid pointer that should not be dereferenced and that should be passed to free to avoid memory leaks.</para>
+        ///     <para>This method is a thin wrapper over the C <c>malloc</c> API.</para>
+        /// </remarks>
+        [CLSCompliant(false)]
+        public static void* Alloc(nuint byteCount)
+        {
+            // The C standard does not define what happens when size == 0, we want an "empty" allocation
+            void* result = Interop.Sys.Malloc((byteCount != 0) ? byteCount : 1);
+
+            if (result == null)
+            {
+                ThrowHelper.ThrowOutOfMemoryException();
+            }
+
+            return result;
+        }
+
+        /// <summary>Allocates and zeroes a block of memory of the specified size, in elements.</summary>
+        /// <param name="elementCount">The count, in elements, of the block to allocate.</param>
+        /// <param name="elementSize">The size, in bytes, of each element in the allocation.</param>
+        /// <returns>A pointer to the allocated and zeroed block of memory.</returns>
+        /// <exception cref="OutOfMemoryException">Allocating <paramref name="elementCount" /> * <paramref name="elementSize" /> bytes of memory failed.</exception>
+        /// <remarks>
+        ///     <para>This method allows <paramref name="elementCount" /> and/or <paramref name="elementSize" /> to be <c>0</c> and will return a valid pointer that should not be dereferenced and that should be passed to free to avoid memory leaks.</para>
+        ///     <para>This method is a thin wrapper over the C <c>calloc</c> API.</para>
+        /// </remarks>
+        [CLSCompliant(false)]
+        public static void* AllocZeroed(nuint elementCount, nuint elementSize)
+        {
+            void* result = null;
+
+            if ((elementCount != 0) && (elementSize != 0))
+            {
+                result = Interop.Sys.Calloc(elementCount, elementSize);
+            }
+            else
+            {
+                // The C standard does not define what happens when num == 0 or size == 0, we want an "empty" allocation
+                result = Interop.Sys.Malloc(1);
+            }
+
+            if (result == null)
+            {
+                ThrowHelper.ThrowOutOfMemoryException();
+            }
+
+            return result;
+        }
+
+        /// <summary>Frees a block of memory.</summary>
+        /// <param name="ptr">A pointer to the block of memory that should be freed.</param>
+        /// <remarks>
+        ///    <para>This method does nothing if <paramref name="ptr" /> is <c>null</c>.</para>
+        ///    <para>This method is a thin wrapper over the C <c>free</c> API.</para>
+        /// </remarks>
+        [CLSCompliant(false)]
+        public static void Free(void* ptr)
+        {
+            if (ptr != null)
+            {
+                Interop.Sys.Free(ptr);
+            }
+        }
+
+        /// <summary>Reallocates a block of memory to be the specified size, in bytes.</summary>
+        /// <param name="ptr">The previously allocated block of memory.</param>
+        /// <param name="byteCount">The size, in bytes, of the reallocated block.</param>
+        /// <returns>A pointer to the reallocated block of memory.</returns>
+        /// <exception cref="OutOfMemoryException">Reallocating <paramref name="byteCount" /> of memory failed.</exception>
+        /// <remarks>
+        ///     <para>This method acts as <see cref="Alloc" /> if <paramref name="ptr" /> is <c>null</c>.</para>
+        ///     <para>This method allows <paramref name="byteCount" /> to be <c>0</c> and will return a valid pointer that should not be dereferenced and that should be passed to free to avoid memory leaks.</para>
+        ///     <para>This method is a thin wrapper over the C <c>realloc</c> API.</para>
+        /// </remarks>
+        [CLSCompliant(false)]
+        public static void* Realloc(void* ptr, nuint byteCount)
+        {
+            // The C standard does not define what happens when size == 0, we want an "empty" allocation
+            void* result = Interop.Sys.Realloc(ptr, (byteCount != 0) ? byteCount : 1);
+
+            if (result == null)
+            {
+                ThrowHelper.ThrowOutOfMemoryException();
+            }
+
+            return result;
+        }
+    }
+}
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/NativeMemory.Windows.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/NativeMemory.Windows.cs
new file mode 100644
index 00000000000000..7fbaf933ef924f
--- /dev/null
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/NativeMemory.Windows.cs
@@ -0,0 +1,175 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+
+namespace System.Runtime.InteropServices
+{
+    /// <summary>This class contains methods that are mainly used to manage native memory.</summary>
+    public static unsafe partial class NativeMemory
+    {
+        /// <summary>Allocates an aligned block of memory of the specified size and alignment, in bytes.</summary>
+        /// <param name="byteCount">The size, in bytes, of the block to allocate.</param>
+        /// <param name="alignment">The alignment, in bytes, of the block to allocate. This must be a power of <c>2</c>.</param>
+        /// <returns>A pointer to the allocated aligned block of memory.</returns>
+        /// <exception cref="ArgumentException"><paramref name="alignment" /> is not a power of two.</exception>
+        /// <exception cref="OutOfMemoryException">Allocating <paramref name="byteCount" /> of memory with <paramref name="alignment" /> failed.</exception>
+        /// <remarks>
+        ///     <para>This method allows <paramref name="byteCount" /> to be <c>0</c> and will return a valid pointer that should not be dereferenced and that should be passed to free to avoid memory leaks.</para>
+        ///     <para>This method is a thin wrapper over the C <c>aligned_alloc</c> API or a platform dependent aligned allocation API such as <c>_aligned_malloc</c> on Win32.</para>
+        ///     <para>This method is not compatible with <see cref="Free" /> or <see cref="Realloc" />, instead <see cref="AlignedFree" /> or <see cref="AlignedRealloc" /> should be called.</para>
+        /// </remarks>
+        [CLSCompliant(false)]
+        public static void* AlignedAlloc(nuint byteCount, nuint alignment)
+        {
+            if (!BitOperations.IsPow2(alignment))
+            {
+                // The C standard doesn't define what a valid alignment is, however Windows and POSIX The Windows implementation requires a power of 2
+                ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_AlignmentMustBePow2);
+            }
+
+            // Unlike the C standard and POSIX, Windows does not requires size to be a multiple of alignment. However, we do want an "empty" allocation for zero
+            void* result = Interop.Ucrtbase._aligned_malloc((byteCount != 0) ? byteCount : 1, alignment);
+
+            if (result == null)
+            {
+                ThrowHelper.ThrowOutOfMemoryException();
+            }
+
+            return result;
+        }
+
+        /// <summary>Frees an aligned block of memory.</summary>
+        /// <param name="ptr">A pointer to the aligned block of memory that should be freed.</param>
+        /// <remarks>
+        ///    <para>This method does nothing if <paramref name="ptr" /> is <c>null</c>.</para>
+        ///    <para>This method is a thin wrapper over the C <c>free</c> API or a platform dependent aligned free API such as <c>_aligned_free</c> on Win32.</para>
+        /// </remarks>
+        [CLSCompliant(false)]
+        public static void AlignedFree(void* ptr)
+        {
+            if (ptr != null)
+            {
+                Interop.Ucrtbase._aligned_free(ptr);
+            }
+        }
+
+        /// <summary>Reallocates an aligned block of memory of the specified size and alignment, in bytes.</summary>
+        /// <param name="ptr">The previously allocated block of memory.</param>
+        /// <param name="byteCount">The size, in bytes, of the block to allocate.</param>
+        /// <param name="alignment">The alignment, in bytes, of the block to allocate. This must be a power of <c>2</c>.</param>
+        /// <returns>A pointer to the reallocated aligned block of memory.</returns>
+        /// <exception cref="ArgumentException"><paramref name="alignment" /> is not a power of two.</exception>
+        /// <exception cref="OutOfMemoryException">Reallocating <paramref name="byteCount" /> of memory with <paramref name="alignment" /> failed.</exception>
+        /// <remarks>
+        ///     <para>This method acts as <see cref="AlignedAlloc" /> if <paramref name="ptr" /> is <c>null</c>.</para>
+        ///     <para>This method allows <paramref name="byteCount" /> to be <c>0</c> and will return a valid pointer that should not be dereferenced and that should be passed to free to avoid memory leaks.</para>
+        ///     <para>This method is a platform dependent aligned reallocation API such as <c>_aligned_realloc</c> on Win32.</para>
+        ///     <para>This method is not compatible with <see cref="Free" /> or <see cref="Realloc" />, instead <see cref="AlignedFree" /> or <see cref="AlignedRealloc" /> should be called.</para>
+        /// </remarks>
+        [CLSCompliant(false)]
+        public static void* AlignedRealloc(void* ptr, nuint byteCount, nuint alignment)
+        {
+            if (!BitOperations.IsPow2(alignment))
+            {
+                // The C standard doesn't define what a valid alignment is, however Windows and POSIX The Windows implementation requires a power of 2
+                ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_AlignmentMustBePow2);
+            }
+
+            // Unlike the C standard and POSIX, Windows does not requires size to be a multiple of alignment. However, we do want an "empty" allocation for zero
+            void* result = Interop.Ucrtbase._aligned_realloc(ptr, (byteCount != 0) ? byteCount : 1, alignment);
+
+            if (result == null)
+            {
+                ThrowHelper.ThrowOutOfMemoryException();
+            }
+
+            return result;
+        }
+
+        /// <summary>Allocates a block of memory of the specified size, in bytes.</summary>
+        /// <param name="byteCount">The size, in bytes, of the block to allocate.</param>
+        /// <returns>A pointer to the allocated block of memory.</returns>
+        /// <exception cref="OutOfMemoryException">Allocating <paramref name="byteCount" /> of memory failed.</exception>
+        /// <remarks>
+        ///     <para>This method allows <paramref name="byteCount" /> to be <c>0</c> and will return a valid pointer that should not be dereferenced and that should be passed to free to avoid memory leaks.</para>
+        ///     <para>This method is a thin wrapper over the C <c>malloc</c> API.</para>
+        /// </remarks>
+        [CLSCompliant(false)]
+        public static void* Alloc(nuint byteCount)
+        {
+            // The Windows implementation handles size == 0 as we expect
+            void* result = Interop.Ucrtbase.malloc(byteCount);
+
+            if (result == null)
+            {
+                ThrowHelper.ThrowOutOfMemoryException();
+            }
+
+            return result;
+        }
+
+        /// <summary>Allocates and zeroes a block of memory of the specified size, in elements.</summary>
+        /// <param name="elementCount">The count, in elements, of the block to allocate.</param>
+        /// <param name="elementSize">The size, in bytes, of each element in the allocation.</param>
+        /// <returns>A pointer to the allocated and zeroed block of memory.</returns>
+        /// <exception cref="OutOfMemoryException">Allocating <paramref name="elementCount" /> * <paramref name="elementSize" /> bytes of memory failed.</exception>
+        /// <remarks>
+        ///     <para>This method allows <paramref name="elementCount" /> and/or <paramref name="elementSize" /> to be <c>0</c> and will return a valid pointer that should not be dereferenced and that should be passed to free to avoid memory leaks.</para>
+        ///     <para>This method is a thin wrapper over the C <c>calloc</c> API.</para>
+        /// </remarks>
+        [CLSCompliant(false)]
+        public static void* AllocZeroed(nuint elementCount, nuint elementSize)
+        {
+            // The Windows implementation handles num == 0 && size == 0 as we expect
+            void* result = Interop.Ucrtbase.calloc(elementCount, elementSize);
+
+            if (result == null)
+            {
+                ThrowHelper.ThrowOutOfMemoryException();
+            }
+
+            return result;
+        }
+
+        /// <summary>Frees a block of memory.</summary>
+        /// <param name="ptr">A pointer to the block of memory that should be freed.</param>
+        /// <remarks>
+        ///    <para>This method does nothing if <paramref name="ptr" /> is <c>null</c>.</para>
+        ///    <para>This method is a thin wrapper over the C <c>free</c> API.</para>
+        /// </remarks>
+        [CLSCompliant(false)]
+        public static void Free(void* ptr)
+        {
+            if (ptr != null)
+            {
+                Interop.Ucrtbase.free(ptr);
+            }
+        }
+
+        /// <summary>Reallocates a block of memory to be the specified size, in bytes.</summary>
+        /// <param name="ptr">The previously allocated block of memory.</param>
+        /// <param name="byteCount">The size, in bytes, of the reallocated block.</param>
+        /// <returns>A pointer to the reallocated block of memory.</returns>
+        /// <exception cref="OutOfMemoryException">Reallocating <paramref name="byteCount" /> of memory failed.</exception>
+        /// <remarks>
+        ///     <para>This method acts as <see cref="Alloc" /> if <paramref name="ptr" /> is <c>null</c>.</para>
+        ///     <para>This method allows <paramref name="byteCount" /> to be <c>0</c> and will return a valid pointer that should not be dereferenced and that should be passed to free to avoid memory leaks.</para>
+        ///     <para>This method is a thin wrapper over the C <c>realloc</c> API.</para>
+        /// </remarks>
+        [CLSCompliant(false)]
+        public static void* Realloc(void* ptr, nuint byteCount)
+        {
+            // The Windows implementation treats size == 0 as Free, we want an "empty" allocation
+            void* result = Interop.Ucrtbase.realloc(ptr, (byteCount != 0) ? byteCount : 1);
+
+            if (result == null)
+            {
+                ThrowHelper.ThrowOutOfMemoryException();
+            }
+
+            return result;
+        }
+    }
+}
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/NativeMemory.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/NativeMemory.cs
new file mode 100644
index 00000000000000..b46655ec58c00a
--- /dev/null
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/NativeMemory.cs
@@ -0,0 +1,53 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+
+namespace System.Runtime.InteropServices
+{
+    public static unsafe partial class NativeMemory
+    {
+        /// <summary>Allocates a block of memory of the specified size, in elements.</summary>
+        /// <param name="elementCount">The count, in elements, of the block to allocate.</param>
+        /// <param name="elementSize">The size, in bytes, of each element in the allocation.</param>
+        /// <returns>A pointer to the allocated block of memory.</returns>
+        /// <exception cref="OutOfMemoryException">Allocating <paramref name="elementCount" /> * <paramref name="elementSize" /> bytes of memory failed.</exception>
+        /// <remarks>
+        ///     <para>This method allows <paramref name="elementCount" /> and/or <paramref name="elementSize" /> to be <c>0</c> and will return a valid pointer that should not be dereferenced and that should be passed to free to avoid memory leaks.</para>
+        ///     <para>This method is a thin wrapper over the C <c>malloc</c> API.</para>
+        /// </remarks>
+        [CLSCompliant(false)]
+        public static void* Alloc(nuint elementCount, nuint elementSize)
+        {
+            nuint byteCount = GetByteCount(elementCount, elementSize);
+            return Alloc(byteCount);
+        }
+
+        /// <summary>Allocates and zeroes a block of memory of the specified size, in bytes.</summary>
+        /// <param name="byteCount">The size, in bytes, of the block to allocate.</param>
+        /// <returns>A pointer to the allocated and zeroed block of memory.</returns>
+        /// <exception cref="OutOfMemoryException">Allocating <paramref name="byteCount" /> of memory failed.</exception>
+        /// <remarks>
+        ///     <para>This method allows <paramref name="byteCount" /> to be <c>0</c> and will return a valid pointer that should not be dereferenced and that should be passed to free to avoid memory leaks.</para>
+        ///     <para>This method is a thin wrapper over the C <c>calloc</c> API.</para>
+        /// </remarks>
+        [CLSCompliant(false)]
+        public static void* AllocZeroed(nuint byteCount)
+        {
+            return AllocZeroed(byteCount, elementSize: 1);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static nuint GetByteCount(nuint elementCount, nuint elementSize)
+        {
+            // This is based on the `mi_count_size_overflow` and `mi_mul_overflow` methods from microsoft/mimalloc.
+            // Original source is Copyright (c) 2019 Microsoft Corporation, Daan Leijen. Licensed under the MIT license
+
+            // sqrt(nuint.MaxValue)
+            nuint multiplyNoOverflow = (nuint)1 << (4 * sizeof(nuint));
+
+            return ((elementSize >= multiplyNoOverflow) || (elementCount >= multiplyNoOverflow)) && (elementSize > 0) && ((nuint.MaxValue / elementSize) < elementCount) ? nuint.MaxValue : (elementCount * elementSize);
+        }
+    }
+}
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/SafeHandle.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/SafeHandle.cs
index 6d1bbf831773a1..227dbf0641f5ee 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/SafeHandle.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/SafeHandle.cs
@@ -74,6 +74,8 @@ protected SafeHandle(IntPtr invalidHandleValue, bool ownsHandle)
         }
 #endif
 
+        internal bool OwnsHandle => _ownsHandle;
+
         protected internal void SetHandle(IntPtr handle) => this.handle = handle;
 
         public IntPtr DangerousGetHandle() => handle;
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 6c733ef6ca1506..2a5a3c1da07fb6 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
@@ -781,7 +781,7 @@ private static void OnAssemblyLoad(RuntimeAssembly assembly)
             string assemblyPath = Path.Combine(parentDirectory, assemblyName.CultureName!, $"{assemblyName.Name}.dll");
 
             bool exists = System.IO.FileSystem.FileExists(assemblyPath);
-            if (!exists && Path.IsCaseSensitive)
+            if (!exists && PathInternal.IsCaseSensitive)
             {
 #if CORECLR
                 if (AssemblyLoadContext.IsTracingEnabled())
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/MemoryFailPoint.Windows.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/MemoryFailPoint.Windows.cs
index 7c4a2da7babb10..d5d1952e7a1505 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/MemoryFailPoint.Windows.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/MemoryFailPoint.Windows.cs
@@ -17,7 +17,7 @@ private static unsafe bool CheckForAvailableMemory(out ulong availPageFile, out
         {
             Interop.Kernel32.MEMORYSTATUSEX memoryStatus = default;
             memoryStatus.dwLength = (uint)sizeof(Interop.Kernel32.MEMORYSTATUSEX);
-            if (!Interop.Kernel32.GlobalMemoryStatusEx(ref memoryStatus))
+            if (Interop.Kernel32.GlobalMemoryStatusEx(&memoryStatus) == Interop.BOOL.FALSE)
             {
                 availPageFile = default;
                 totalAddressSpaceFree = default;
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 0488572e9e3029..7bbbc51735d93a 100644
--- a/src/libraries/System.Private.CoreLib/src/System/String.Manipulation.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/String.Manipulation.cs
@@ -1152,6 +1152,139 @@ private string ReplaceHelper(int oldValueLength, string newValue, ReadOnlySpan<i
             return dst;
         }
 
+        /// <summary>
+        /// Replaces all newline sequences in the current string with <see cref="Environment.NewLine"/>.
+        /// </summary>
+        /// <returns>
+        /// A string whose contents match the current string, but with all newline sequences replaced
+        /// with <see cref="Environment.NewLine"/>.
+        /// </returns>
+        /// <remarks>
+        /// This method searches for all newline sequences within the string and canonicalizes them to match
+        /// the newline sequence for the current environment. For example, when running on Windows, all
+        /// occurrences of non-Windows newline sequences will be replaced with the sequence CRLF. When
+        /// running on Unix, all occurrences of non-Unix newline sequences will be replaced with
+        /// a single LF character.
+        ///
+        /// It is not recommended that protocol parsers utilize this API. Protocol specifications often
+        /// mandate specific newline sequences. For example, HTTP/1.1 (RFC 8615) mandates that the request
+        /// line, status line, and headers lines end with CRLF. Since this API operates over a wide range
+        /// of newline sequences, a protocol parser utilizing this API could exhibit behaviors unintended
+        /// by the protocol's authors.
+        ///
+        /// This overload is equivalent to calling <see cref="ReplaceLineEndings(string)"/>, passing
+        /// <see cref="Environment.NewLine"/> as the <em>replacementText</em> parameter.
+        ///
+        /// This method is guaranteed O(n) complexity, where <em>n</em> is the length of the input string.
+        /// </remarks>
+        public string ReplaceLineEndings() => ReplaceLineEndings(Environment.NewLineConst);
+
+        /// <summary>
+        /// Replaces all newline sequences in the current string with <paramref name="replacementText"/>.
+        /// </summary>
+        /// <returns>
+        /// A string whose contents match the current string, but with all newline sequences replaced
+        /// with <paramref name="replacementText"/>.
+        /// </returns>
+        /// <remarks>
+        /// This method searches for all newline sequences within the string and canonicalizes them to the
+        /// newline sequence provided by <paramref name="replacementText"/>. If <paramref name="replacementText"/>
+        /// is <see cref="string.Empty"/>, all newline sequences within the string will be removed.
+        ///
+        /// It is not recommended that protocol parsers utilize this API. Protocol specifications often
+        /// mandate specific newline sequences. For example, HTTP/1.1 (RFC 8615) mandates that the request
+        /// line, status line, and headers lines end with CRLF. Since this API operates over a wide range
+        /// of newline sequences, a protocol parser utilizing this API could exhibit behaviors unintended
+        /// by the protocol's authors.
+        ///
+        /// The list of recognized newline sequences is CR (U+000D), LF (U+000A), CRLF (U+000D U+000A),
+        /// NEL (U+0085), LS (U+2028), FF (U+000C), and PS (U+2029). This list is given by the Unicode
+        /// Standard, Sec. 5.8, Recommendation R4 and Table 5-2.
+        ///
+        /// This method is guaranteed O(n * r) complexity, where <em>n</em> is the length of the input string,
+        /// and where <em>r</em> is the length of <paramref name="replacementText"/>.
+        /// </remarks>
+        public string ReplaceLineEndings(string replacementText)
+        {
+            if (replacementText is null)
+            {
+                throw new ArgumentNullException(nameof(replacementText));
+            }
+
+            // Early-exit: do we need to do anything at all?
+            // If not, return this string as-is.
+
+            int idxOfFirstNewlineChar = IndexOfNewlineChar(this, out int stride);
+            if (idxOfFirstNewlineChar < 0)
+            {
+                return this;
+            }
+
+            // While writing to the builder, we don't bother memcpying the first
+            // or the last segment into the builder. We'll use the builder only
+            // for the intermediate segments, then we'll sandwich everything together
+            // with one final string.Concat call.
+
+            ReadOnlySpan<char> firstSegment = this.AsSpan(0, idxOfFirstNewlineChar);
+            ReadOnlySpan<char> remaining = this.AsSpan(idxOfFirstNewlineChar + stride);
+
+            ValueStringBuilder builder = new ValueStringBuilder(stackalloc char[256]);
+            while (true)
+            {
+                int idx = IndexOfNewlineChar(remaining, out stride);
+                if (idx < 0) { break; } // no more newline chars
+                builder.Append(replacementText);
+                builder.Append(remaining.Slice(0, idx));
+                remaining = remaining.Slice(idx + stride);
+            }
+
+            string retVal = Concat(firstSegment, builder.AsSpan(), replacementText, remaining);
+            builder.Dispose();
+            return retVal;
+        }
+
+        // Scans the input text, returning the index of the first newline char.
+        // Newline chars are given by the Unicode Standard, Sec. 5.8.
+        internal static int IndexOfNewlineChar(ReadOnlySpan<char> text, out int stride)
+        {
+            // !! IMPORTANT !!
+            //
+            // We expect this method may be called with untrusted input, which means we need to
+            // bound the worst-case runtime of this method. We rely on MemoryExtensions.IndexOfAny
+            // having worst-case runtime O(i), where i is the index of the first needle match within
+            // the haystack; or O(n) if no needle is found. This ensures that in the common case
+            // of this method being called within a loop, the worst-case runtime is O(n) rather than
+            // O(n^2), where n is the length of the input text.
+            //
+            // The Unicode Standard, Sec. 5.8, Recommendation R4 and Table 5-2 state that the CR, LF,
+            // CRLF, NEL, LS, FF, and PS sequences are considered newline functions. That section
+            // also specifically excludes VT from the list of newline functions, so we do not include
+            // it in the needle list.
+
+            const string needles = "\r\n\f\u0085\u2028\u2029";
+
+            stride = default;
+            int idx = text.IndexOfAny(needles);
+            if ((uint)idx < (uint)text.Length)
+            {
+                stride = 1; // needle found
+
+                // Did we match CR? If so, and if it's followed by LF, then we need
+                // to consume both chars as a single newline function match.
+
+                if (text[idx] == '\r')
+                {
+                    int nextCharIdx = idx + 1;
+                    if ((uint)nextCharIdx < (uint)text.Length && text[nextCharIdx] == '\n')
+                    {
+                        stride = 2;
+                    }
+                }
+            }
+
+            return idx;
+        }
+
         public string[] Split(char separator, StringSplitOptions options = StringSplitOptions.None)
         {
             return SplitInternal(new ReadOnlySpan<char>(ref separator, 1), int.MaxValue, options);
diff --git a/src/libraries/System.Private.CoreLib/src/System/Text/SpanLineEnumerator.cs b/src/libraries/System.Private.CoreLib/src/System/Text/SpanLineEnumerator.cs
new file mode 100644
index 00000000000000..99c8456656b858
--- /dev/null
+++ b/src/libraries/System.Private.CoreLib/src/System/Text/SpanLineEnumerator.cs
@@ -0,0 +1,68 @@
+// 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
+{
+    /// <summary>
+    /// Enumerates the lines of a <see cref="ReadOnlySpan{Char}"/>.
+    /// </summary>
+    /// <remarks>
+    /// To get an instance of this type, use <see cref="MemoryExtensions.EnumerateLines(ReadOnlySpan{char})"/>.
+    /// </remarks>
+    public ref struct SpanLineEnumerator
+    {
+        private ReadOnlySpan<char> _remaining;
+        private ReadOnlySpan<char> _current;
+        private bool _isEnumeratorActive;
+
+        internal SpanLineEnumerator(ReadOnlySpan<char> buffer)
+        {
+            _remaining = buffer;
+            _current = default;
+            _isEnumeratorActive = true;
+        }
+
+        /// <summary>
+        /// Gets the line at the current position of the enumerator.
+        /// </summary>
+        public ReadOnlySpan<char> Current => _current;
+
+        /// <summary>
+        /// Returns this instance as an enumerator.
+        /// </summary>
+        public SpanLineEnumerator GetEnumerator() => this;
+
+        /// <summary>
+        /// Advances the enumerator to the next line of the span.
+        /// </summary>
+        /// <returns>
+        /// True if the enumerator successfully advanced to the next line; false if
+        /// the enumerator has advanced past the end of the span.
+        /// </returns>
+        public bool MoveNext()
+        {
+            if (!_isEnumeratorActive)
+            {
+                return false; // EOF previously reached or enumerator was never initialized
+            }
+
+            int idx = string.IndexOfNewlineChar(_remaining, out int stride);
+            if (idx >= 0)
+            {
+                _current = _remaining.Slice(0, idx);
+                _remaining = _remaining.Slice(idx + stride);
+            }
+            else
+            {
+                // We've reached EOF, but we still need to return 'true' for this final
+                // iteration so that the caller can query the Current property once more.
+
+                _current = _remaining;
+                _remaining = default;
+                _isEnumeratorActive = false;
+            }
+
+            return true;
+        }
+    }
+}
diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/NativeRuntimeEventSource.PortableThreadPool.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/NativeRuntimeEventSource.PortableThreadPool.cs
index 2dcce9f59a0731..785000089bdaaf 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Threading/NativeRuntimeEventSource.PortableThreadPool.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Threading/NativeRuntimeEventSource.PortableThreadPool.cs
@@ -66,7 +66,8 @@ public enum ThreadAdjustmentReasonMap : uint
             ChangePoint,
             Stabilizing,
             Starvation,
-            ThreadTimedOut
+            ThreadTimedOut,
+            CooperativeBlocking,
         }
 
 #if !ES_BUILD_STANDALONE
diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/PortableThreadPool.Blocking.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/PortableThreadPool.Blocking.cs
new file mode 100644
index 00000000000000..1ac8ecb60c91d1
--- /dev/null
+++ b/src/libraries/System.Private.CoreLib/src/System/Threading/PortableThreadPool.Blocking.cs
@@ -0,0 +1,340 @@
+// 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;
+
+namespace System.Threading
+{
+    internal sealed partial class PortableThreadPool
+    {
+        public short MinThreadsGoal
+        {
+            get
+            {
+                _threadAdjustmentLock.VerifyIsLocked();
+                return Math.Min(_separated.numThreadsGoal, TargetThreadsGoalForBlockingAdjustment);
+            }
+        }
+
+        private short TargetThreadsGoalForBlockingAdjustment
+        {
+            get
+            {
+                _threadAdjustmentLock.VerifyIsLocked();
+
+                return
+                    _numBlockedThreads <= 0
+                        ? _minThreads
+                        : (short)Math.Min((ushort)(_minThreads + _numBlockedThreads), (ushort)_maxThreads);
+            }
+        }
+
+        public bool NotifyThreadBlocked()
+        {
+            if (!BlockingConfig.IsCooperativeBlockingEnabled || !Thread.CurrentThread.IsThreadPoolThread)
+            {
+                return false;
+            }
+
+            bool wakeGateThread = false;
+            _threadAdjustmentLock.Acquire();
+            try
+            {
+                _numBlockedThreads++;
+                Debug.Assert(_numBlockedThreads > 0);
+
+                if (_pendingBlockingAdjustment != PendingBlockingAdjustment.WithDelayIfNecessary &&
+                    _separated.numThreadsGoal < TargetThreadsGoalForBlockingAdjustment)
+                {
+                    if (_pendingBlockingAdjustment == PendingBlockingAdjustment.None)
+                    {
+                        wakeGateThread = true;
+                    }
+                    _pendingBlockingAdjustment = PendingBlockingAdjustment.WithDelayIfNecessary;
+                }
+            }
+            finally
+            {
+                _threadAdjustmentLock.Release();
+            }
+
+            if (wakeGateThread)
+            {
+                GateThread.Wake(this);
+            }
+            return true;
+        }
+
+        public void NotifyThreadUnblocked()
+        {
+            Debug.Assert(BlockingConfig.IsCooperativeBlockingEnabled);
+            Debug.Assert(Thread.CurrentThread.IsThreadPoolThread);
+
+            bool wakeGateThread = false;
+            _threadAdjustmentLock.Acquire();
+            try
+            {
+                Debug.Assert(_numBlockedThreads > 0);
+                _numBlockedThreads--;
+
+                if (_pendingBlockingAdjustment != PendingBlockingAdjustment.Immediately &&
+                    _numThreadsAddedDueToBlocking > 0 &&
+                    _separated.numThreadsGoal > TargetThreadsGoalForBlockingAdjustment)
+                {
+                    wakeGateThread = true;
+                    _pendingBlockingAdjustment = PendingBlockingAdjustment.Immediately;
+                }
+            }
+            finally
+            {
+                _threadAdjustmentLock.Release();
+            }
+
+            if (wakeGateThread)
+            {
+                GateThread.Wake(this);
+            }
+        }
+
+        private uint PerformBlockingAdjustment(bool previousDelayElapsed)
+        {
+            uint nextDelayMs;
+            bool addWorker;
+            _threadAdjustmentLock.Acquire();
+            try
+            {
+                nextDelayMs = PerformBlockingAdjustment(previousDelayElapsed, out addWorker);
+            }
+            finally
+            {
+                _threadAdjustmentLock.Release();
+            }
+
+            if (addWorker)
+            {
+                WorkerThread.MaybeAddWorkingWorker(this);
+            }
+            return nextDelayMs;
+        }
+
+        private uint PerformBlockingAdjustment(bool previousDelayElapsed, out bool addWorker)
+        {
+            _threadAdjustmentLock.VerifyIsLocked();
+            Debug.Assert(_pendingBlockingAdjustment != PendingBlockingAdjustment.None);
+
+            _pendingBlockingAdjustment = PendingBlockingAdjustment.None;
+            addWorker = false;
+
+            short targetThreadsGoal = TargetThreadsGoalForBlockingAdjustment;
+            short numThreadsGoal = _separated.numThreadsGoal;
+            if (numThreadsGoal == targetThreadsGoal)
+            {
+                return 0;
+            }
+
+            if (numThreadsGoal > targetThreadsGoal)
+            {
+                // The goal is only decreased by how much it was increased in total due to blocking adjustments. This is to
+                // allow blocking adjustments to play well with starvation and hill climbing, either of which may increase the
+                // goal independently for other reasons, and blocking adjustments should not undo those changes.
+                if (_numThreadsAddedDueToBlocking <= 0)
+                {
+                    return 0;
+                }
+
+                short toSubtract = Math.Min((short)(numThreadsGoal - targetThreadsGoal), _numThreadsAddedDueToBlocking);
+                _numThreadsAddedDueToBlocking -= toSubtract;
+                _separated.numThreadsGoal = numThreadsGoal -= toSubtract;
+                HillClimbing.ThreadPoolHillClimber.ForceChange(
+                    numThreadsGoal,
+                    HillClimbing.StateOrTransition.CooperativeBlocking);
+                return 0;
+            }
+
+            short configuredMaxThreadsWithoutDelay =
+                (short)Math.Min((ushort)(_minThreads + BlockingConfig.ThreadsToAddWithoutDelay), (ushort)_maxThreads);
+
+            do
+            {
+                // Calculate how many threads can be added without a delay. Threads that were already created but may be just
+                // waiting for work can be released for work without a delay, but creating a new thread may need a delay.
+                ThreadCounts counts = _separated.counts;
+                short maxThreadsGoalWithoutDelay =
+                    Math.Max(configuredMaxThreadsWithoutDelay, Math.Min(counts.NumExistingThreads, _maxThreads));
+                short targetThreadsGoalWithoutDelay = Math.Min(targetThreadsGoal, maxThreadsGoalWithoutDelay);
+                short newNumThreadsGoal;
+                if (numThreadsGoal < targetThreadsGoalWithoutDelay)
+                {
+                    newNumThreadsGoal = targetThreadsGoalWithoutDelay;
+                }
+                else if (previousDelayElapsed)
+                {
+                    newNumThreadsGoal = (short)(numThreadsGoal + 1);
+                }
+                else
+                {
+                    // Need to induce a delay before adding a thread
+                    break;
+                }
+
+                do
+                {
+                    if (newNumThreadsGoal <= counts.NumExistingThreads)
+                    {
+                        break;
+                    }
+
+                    //
+                    // Threads would likely need to be created to compensate for blocking, so check memory usage and limits
+                    //
+
+                    long memoryLimitBytes = _memoryLimitBytes;
+                    if (memoryLimitBytes <= 0)
+                    {
+                        break;
+                    }
+
+                    // Memory usage is updated after gen 2 GCs, and roughly represents how much physical memory was in use at
+                    // the time of the last gen 2 GC. When new threads are also blocking, they may not have used their typical
+                    // amount of stack space, and gen 2 GCs may not be happening to update the memory usage. Account for a bit
+                    // of extra stack space usage in the future for each thread.
+                    long memoryUsageBytes =
+                        _memoryUsageBytes +
+                        counts.NumExistingThreads * (long)WorkerThread.EstimatedAdditionalStackUsagePerThreadBytes;
+
+                    // The memory limit may already be less than the total amount of physical memory. We are only accounting for
+                    // thread pool worker threads above, and after fallback starvation may have to continue creating threads
+                    // slowly to prevent a deadlock, so calculate a threshold before falling back by giving the memory limit
+                    // some additional buffer.
+                    long memoryThresholdForFallbackBytes = memoryLimitBytes * 8 / 10;
+                    if (memoryUsageBytes >= memoryThresholdForFallbackBytes)
+                    {
+                        return 0;
+                    }
+
+                    // Determine how many threads can be added without exceeding the memory threshold
+                    long achievableNumThreadsGoal =
+                        counts.NumExistingThreads +
+                        (memoryThresholdForFallbackBytes - memoryUsageBytes) /
+                            WorkerThread.EstimatedAdditionalStackUsagePerThreadBytes;
+                    newNumThreadsGoal = (short)Math.Min(newNumThreadsGoal, achievableNumThreadsGoal);
+                    if (newNumThreadsGoal <= numThreadsGoal)
+                    {
+                        return 0;
+                    }
+                } while (false);
+
+                _numThreadsAddedDueToBlocking += (short)(newNumThreadsGoal - numThreadsGoal);
+                _separated.numThreadsGoal = newNumThreadsGoal;
+                HillClimbing.ThreadPoolHillClimber.ForceChange(
+                    newNumThreadsGoal,
+                    HillClimbing.StateOrTransition.CooperativeBlocking);
+                if (counts.NumProcessingWork >= numThreadsGoal && _separated.numRequestedWorkers > 0)
+                {
+                    addWorker = true;
+                }
+
+                numThreadsGoal = newNumThreadsGoal;
+                if (numThreadsGoal >= targetThreadsGoal)
+                {
+                    return 0;
+                }
+            } while (false);
+
+            // Calculate how much delay to induce before another thread is created. These operations don't overflow because of
+            // limits on max thread count and max delays.
+            _pendingBlockingAdjustment = PendingBlockingAdjustment.WithDelayIfNecessary;
+            int delayStepCount = 1 + (numThreadsGoal - configuredMaxThreadsWithoutDelay) / BlockingConfig.ThreadsPerDelayStep;
+            return Math.Min((uint)delayStepCount * BlockingConfig.DelayStepMs, BlockingConfig.MaxDelayMs);
+        }
+
+        private enum PendingBlockingAdjustment : byte
+        {
+            None,
+            Immediately,
+            WithDelayIfNecessary
+        }
+
+        private static class BlockingConfig
+        {
+            public static readonly bool IsCooperativeBlockingEnabled =
+                AppContextConfigHelper.GetBooleanConfig("System.Threading.ThreadPool.Blocking.CooperativeBlocking", true);
+
+            public static readonly short ThreadsToAddWithoutDelay;
+            public static readonly short ThreadsPerDelayStep;
+            public static readonly uint DelayStepMs;
+            public static readonly uint MaxDelayMs;
+
+#pragma warning disable CA1810 // remove the explicit static constructor
+            static BlockingConfig()
+            {
+                // Summary description of how blocking compensation works and how the config settings below are used:
+                // - After the thread count based on MinThreads is reached, up to ThreadsToAddWithoutDelay additional threads
+                //   may be created without a delay
+                // - After that, before each additional thread is created, a delay is induced, starting with DelayStepMs
+                // - For every ThreadsPerDelayStep threads that are added with a delay, an additional DelayStepMs is added to
+                //   the delay
+                // - The delay may not exceed MaxDelayMs
+                // - Delays are only induced before creating threads. If threads are already available, they would be released
+                //   without delay to compensate for cooperative blocking.
+                // - Physical memory usage and limits are also used and beyond a threshold, the system switches to fallback mode
+                //   where threads would be created if starvation is detected, typically with higher delays
+
+                // After the thread count based on MinThreads is reached, this value (after it is multiplied by the processor
+                // count) specifies how many additional threads may be created without a delay
+                int blocking_threadsToAddWithoutDelay_procCountFactor =
+                    AppContextConfigHelper.GetInt32Config(
+                        "System.Threading.ThreadPool.Blocking.ThreadsToAddWithoutDelay_ProcCountFactor",
+                        1,
+                        false);
+
+                // After the thread count based on ThreadsToAddWithoutDelay is reached, this value (after it is multiplied by
+                // the processor count) specifies after how many threads an additional DelayStepMs would be added to the delay
+                // before each new thread is created
+                int blocking_threadsPerDelayStep_procCountFactor =
+                    AppContextConfigHelper.GetInt32Config(
+                        "System.Threading.ThreadPool.Blocking.ThreadsPerDelayStep_ProcCountFactor",
+                        1,
+                        false);
+
+                // After the thread count based on ThreadsToAddWithoutDelay is reached, this value specifies how much additional
+                // delay to add per ThreadsPerDelayStep threads, which would be applied before each new thread is created
+                DelayStepMs =
+                    (uint)AppContextConfigHelper.GetInt32Config(
+                        "System.Threading.ThreadPool.Blocking.DelayStepMs",
+                        25,
+                        false);
+
+                // After the thread count based on ThreadsToAddWithoutDelay is reached, this value specifies the max delay to
+                // use before each new thread is created
+                MaxDelayMs =
+                    (uint)AppContextConfigHelper.GetInt32Config(
+                        "System.Threading.ThreadPool.Blocking.MaxDelayMs",
+                        250,
+                        false);
+
+                int processorCount = Environment.ProcessorCount;
+                ThreadsToAddWithoutDelay = (short)(processorCount * blocking_threadsToAddWithoutDelay_procCountFactor);
+                if (ThreadsToAddWithoutDelay > MaxPossibleThreadCount ||
+                    ThreadsToAddWithoutDelay / processorCount != blocking_threadsToAddWithoutDelay_procCountFactor)
+                {
+                    ThreadsToAddWithoutDelay = MaxPossibleThreadCount;
+                }
+
+                blocking_threadsPerDelayStep_procCountFactor = Math.Max(1, blocking_threadsPerDelayStep_procCountFactor);
+                short maxThreadsPerDelayStep = (short)(MaxPossibleThreadCount - ThreadsToAddWithoutDelay);
+                ThreadsPerDelayStep =
+                    (short)(processorCount * blocking_threadsPerDelayStep_procCountFactor);
+                if (ThreadsPerDelayStep > maxThreadsPerDelayStep ||
+                    ThreadsPerDelayStep / processorCount != blocking_threadsPerDelayStep_procCountFactor)
+                {
+                    ThreadsPerDelayStep = maxThreadsPerDelayStep;
+                }
+
+                MaxDelayMs = Math.Max(1, Math.Min(MaxDelayMs, GateThread.GateActivitiesPeriodMs));
+                DelayStepMs = Math.Max(1, Math.Min(DelayStepMs, MaxDelayMs));
+            }
+#pragma warning restore CA1810
+        }
+    }
+}
diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/PortableThreadPool.GateThread.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/PortableThreadPool.GateThread.cs
index eba5c66d7e0a3c..fefe16da418eb3 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Threading/PortableThreadPool.GateThread.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Threading/PortableThreadPool.GateThread.cs
@@ -12,14 +12,14 @@ internal sealed partial class PortableThreadPool
     {
         private static class GateThread
         {
-            private const int GateThreadDelayMs = 500;
-            private const int DequeueDelayThresholdMs = GateThreadDelayMs * 2;
+            public const uint GateActivitiesPeriodMs = 500;
+            private const uint DequeueDelayThresholdMs = GateActivitiesPeriodMs * 2;
             private const int GateThreadRunningMask = 0x4;
-
-            private static readonly AutoResetEvent s_runGateThreadEvent = new AutoResetEvent(initialState: true);
-
             private const int MaxRuns = 2;
 
+            private static readonly AutoResetEvent RunGateThreadEvent = new AutoResetEvent(initialState: true);
+            private static readonly AutoResetEvent DelayEvent = new AutoResetEvent(initialState: false);
+
             private static void GateThreadStart()
             {
                 bool disableStarvationDetection =
@@ -33,16 +33,68 @@ private static void GateThreadStart()
                 _ = cpuUtilizationReader.CurrentUtilization;
 
                 PortableThreadPool threadPoolInstance = ThreadPoolInstance;
-                LowLevelLock hillClimbingThreadAdjustmentLock = threadPoolInstance._hillClimbingThreadAdjustmentLock;
+                LowLevelLock threadAdjustmentLock = threadPoolInstance._threadAdjustmentLock;
+                DelayHelper delayHelper = default;
+
+                if (BlockingConfig.IsCooperativeBlockingEnabled)
+                {
+                    // Initialize memory usage and limits, and register to update them on gen 2 GCs
+                    threadPoolInstance.OnGen2GCCallback();
+                    Gen2GcCallback.Register(threadPoolInstance.OnGen2GCCallback);
+                }
 
                 while (true)
                 {
-                    s_runGateThreadEvent.WaitOne();
+                    RunGateThreadEvent.WaitOne();
+                    int currentTimeMs = Environment.TickCount;
+                    delayHelper.SetGateActivitiesTime(currentTimeMs);
 
-                    bool needGateThreadForRuntime;
-                    do
+                    while (true)
                     {
-                        Thread.Sleep(GateThreadDelayMs);
+                        bool wasSignaledToWake = DelayEvent.WaitOne((int)delayHelper.GetNextDelay(currentTimeMs));
+                        currentTimeMs = Environment.TickCount;
+
+                        // Thread count adjustment for cooperative blocking
+                        do
+                        {
+                            PendingBlockingAdjustment pendingBlockingAdjustment = threadPoolInstance._pendingBlockingAdjustment;
+                            if (pendingBlockingAdjustment == PendingBlockingAdjustment.None)
+                            {
+                                delayHelper.ClearBlockingAdjustmentDelay();
+                                break;
+                            }
+
+                            bool previousDelayElapsed = false;
+                            if (delayHelper.HasBlockingAdjustmentDelay)
+                            {
+                                previousDelayElapsed =
+                                    delayHelper.HasBlockingAdjustmentDelayElapsed(currentTimeMs, wasSignaledToWake);
+                                if (pendingBlockingAdjustment == PendingBlockingAdjustment.WithDelayIfNecessary &&
+                                    !previousDelayElapsed)
+                                {
+                                    break;
+                                }
+                            }
+
+                            uint nextDelayMs = threadPoolInstance.PerformBlockingAdjustment(previousDelayElapsed);
+                            if (nextDelayMs <= 0)
+                            {
+                                delayHelper.ClearBlockingAdjustmentDelay();
+                            }
+                            else
+                            {
+                                delayHelper.SetBlockingAdjustmentTimeAndDelay(currentTimeMs, nextDelayMs);
+                            }
+                        } while (false);
+
+                        //
+                        // Periodic gate activities
+                        //
+
+                        if (!delayHelper.ShouldPerformGateActivities(currentTimeMs, wasSignaledToWake))
+                        {
+                            continue;
+                        }
 
                         if (ThreadPool.EnableWorkerTracking && NativeRuntimeEventSource.Log.IsEnabled())
                         {
@@ -53,17 +105,17 @@ private static void GateThreadStart()
                         int cpuUtilization = cpuUtilizationReader.CurrentUtilization;
                         threadPoolInstance._cpuUtilization = cpuUtilization;
 
-                        needGateThreadForRuntime = ThreadPool.PerformRuntimeSpecificGateActivities(cpuUtilization);
+                        bool needGateThreadForRuntime = ThreadPool.PerformRuntimeSpecificGateActivities(cpuUtilization);
 
                         if (!disableStarvationDetection &&
+                            threadPoolInstance._pendingBlockingAdjustment == PendingBlockingAdjustment.None &&
                             threadPoolInstance._separated.numRequestedWorkers > 0 &&
                             SufficientDelaySinceLastDequeue(threadPoolInstance))
                         {
+                            bool addWorker = false;
+                            threadAdjustmentLock.Acquire();
                             try
                             {
-                                hillClimbingThreadAdjustmentLock.Acquire();
-                                ThreadCounts counts = threadPoolInstance._separated.counts.VolatileRead();
-
                                 // Don't add a thread if we're at max or if we are already in the process of adding threads.
                                 // This logic is slightly different from the native implementation in CoreCLR because there are
                                 // no retired threads. In the native implementation, when hill climbing reduces the thread count
@@ -73,61 +125,67 @@ private static void GateThreadStart()
                                 // stopped from working by hill climbing, so here the number of threads processing work, instead
                                 // of the number of existing threads, is compared with the goal. There may be alternative
                                 // solutions, for now this is only to maintain consistency in behavior.
-                                while (
-                                    counts.NumExistingThreads < threadPoolInstance._maxThreads &&
-                                    counts.NumProcessingWork >= counts.NumThreadsGoal)
+                                ThreadCounts counts = threadPoolInstance._separated.counts;
+                                if (counts.NumProcessingWork < threadPoolInstance._maxThreads &&
+                                    counts.NumProcessingWork >= threadPoolInstance._separated.numThreadsGoal)
                                 {
                                     if (debuggerBreakOnWorkStarvation)
                                     {
                                         Debugger.Break();
                                     }
 
-                                    ThreadCounts newCounts = counts;
                                     short newNumThreadsGoal = (short)(counts.NumProcessingWork + 1);
-                                    newCounts.NumThreadsGoal = newNumThreadsGoal;
-
-                                    ThreadCounts oldCounts = threadPoolInstance._separated.counts.InterlockedCompareExchange(newCounts, counts);
-                                    if (oldCounts == counts)
-                                    {
-                                        HillClimbing.ThreadPoolHillClimber.ForceChange(newNumThreadsGoal, HillClimbing.StateOrTransition.Starvation);
-                                        WorkerThread.MaybeAddWorkingWorker(threadPoolInstance);
-                                        break;
-                                    }
-
-                                    counts = oldCounts;
+                                    threadPoolInstance._separated.numThreadsGoal = newNumThreadsGoal;
+                                    HillClimbing.ThreadPoolHillClimber.ForceChange(
+                                        newNumThreadsGoal,
+                                        HillClimbing.StateOrTransition.Starvation);
+                                    addWorker = true;
                                 }
                             }
                             finally
                             {
-                                hillClimbingThreadAdjustmentLock.Release();
+                                threadAdjustmentLock.Release();
+                            }
+
+                            if (addWorker)
+                            {
+                                WorkerThread.MaybeAddWorkingWorker(threadPoolInstance);
                             }
                         }
-                    } while (
-                        needGateThreadForRuntime ||
-                        threadPoolInstance._separated.numRequestedWorkers > 0 ||
-                        Interlocked.Decrement(ref threadPoolInstance._separated.gateThreadRunningState) > GetRunningStateForNumRuns(0));
+
+                        if (!needGateThreadForRuntime &&
+                            threadPoolInstance._separated.numRequestedWorkers <= 0 &&
+                            threadPoolInstance._pendingBlockingAdjustment == PendingBlockingAdjustment.None &&
+                            Interlocked.Decrement(ref threadPoolInstance._separated.gateThreadRunningState) <= GetRunningStateForNumRuns(0))
+                        {
+                            break;
+                        }
+                    }
                 }
             }
 
+            public static void Wake(PortableThreadPool threadPoolInstance)
+            {
+                DelayEvent.Set();
+                EnsureRunning(threadPoolInstance);
+            }
+
             // called by logic to spawn new worker threads, return true if it's been too long
             // since the last dequeue operation - takes number of worker threads into account
             // in deciding "too long"
             private static bool SufficientDelaySinceLastDequeue(PortableThreadPool threadPoolInstance)
             {
-                int delay = Environment.TickCount - Volatile.Read(ref threadPoolInstance._separated.lastDequeueTime);
-
-                int minimumDelay;
-
+                uint delay = (uint)(Environment.TickCount - threadPoolInstance._separated.lastDequeueTime);
+                uint minimumDelay;
                 if (threadPoolInstance._cpuUtilization < CpuUtilizationLow)
                 {
-                    minimumDelay = GateThreadDelayMs;
+                    minimumDelay = GateActivitiesPeriodMs;
                 }
                 else
                 {
-                    ThreadCounts counts = threadPoolInstance._separated.counts.VolatileRead();
-                    int numThreads = counts.NumThreadsGoal;
-                    minimumDelay = numThreads * DequeueDelayThresholdMs;
+                    minimumDelay = (uint)threadPoolInstance._separated.numThreadsGoal * DequeueDelayThresholdMs;
                 }
+
                 return delay > minimumDelay;
             }
 
@@ -148,7 +206,7 @@ internal static void EnsureRunningSlow(PortableThreadPool threadPoolInstance)
                 int numRunsMask = Interlocked.Exchange(ref threadPoolInstance._separated.gateThreadRunningState, GetRunningStateForNumRuns(MaxRuns));
                 if (numRunsMask == GetRunningStateForNumRuns(0))
                 {
-                    s_runGateThreadEvent.Set();
+                    RunGateThreadEvent.Set();
                 }
                 else if ((numRunsMask & GateThreadRunningMask) == 0)
                 {
@@ -188,6 +246,82 @@ private static void CreateGateThread(PortableThreadPool threadPoolInstance)
                     }
                 }
             }
+
+            private struct DelayHelper
+            {
+                private int _previousGateActivitiesTimeMs;
+                private int _previousBlockingAdjustmentDelayStartTimeMs;
+                private uint _previousBlockingAdjustmentDelayMs;
+                private bool _runGateActivitiesAfterNextDelay;
+                private bool _adjustForBlockingAfterNextDelay;
+
+                public void SetGateActivitiesTime(int currentTimeMs)
+                {
+                    _previousGateActivitiesTimeMs = currentTimeMs;
+                }
+
+                public void SetBlockingAdjustmentTimeAndDelay(int currentTimeMs, uint delayMs)
+                {
+                    _previousBlockingAdjustmentDelayStartTimeMs = currentTimeMs;
+                    _previousBlockingAdjustmentDelayMs = delayMs;
+                }
+
+                public void ClearBlockingAdjustmentDelay() => _previousBlockingAdjustmentDelayMs = 0;
+                public bool HasBlockingAdjustmentDelay => _previousBlockingAdjustmentDelayMs != 0;
+
+                public uint GetNextDelay(int currentTimeMs)
+                {
+                    uint elapsedMsSincePreviousGateActivities = (uint)(currentTimeMs - _previousGateActivitiesTimeMs);
+                    uint nextDelayForGateActivities =
+                        elapsedMsSincePreviousGateActivities < GateActivitiesPeriodMs
+                            ? GateActivitiesPeriodMs - elapsedMsSincePreviousGateActivities
+                            : 1;
+                    if (_previousBlockingAdjustmentDelayMs == 0)
+                    {
+                        _runGateActivitiesAfterNextDelay = true;
+                        _adjustForBlockingAfterNextDelay = false;
+                        return nextDelayForGateActivities;
+                    }
+
+                    uint elapsedMsSincePreviousBlockingAdjustmentDelay =
+                        (uint)(currentTimeMs - _previousBlockingAdjustmentDelayStartTimeMs);
+                    uint nextDelayForBlockingAdjustment =
+                        elapsedMsSincePreviousBlockingAdjustmentDelay < _previousBlockingAdjustmentDelayMs
+                            ? _previousBlockingAdjustmentDelayMs - elapsedMsSincePreviousBlockingAdjustmentDelay
+                            : 1;
+                    uint nextDelay = Math.Min(nextDelayForGateActivities, nextDelayForBlockingAdjustment);
+                    _runGateActivitiesAfterNextDelay = nextDelay == nextDelayForGateActivities;
+                    _adjustForBlockingAfterNextDelay = nextDelay == nextDelayForBlockingAdjustment;
+                    Debug.Assert(nextDelay <= GateActivitiesPeriodMs);
+                    return nextDelay;
+                }
+
+                public bool ShouldPerformGateActivities(int currentTimeMs, bool wasSignaledToWake)
+                {
+                    bool result =
+                        (!wasSignaledToWake && _runGateActivitiesAfterNextDelay) ||
+                        (uint)(currentTimeMs - _previousGateActivitiesTimeMs) >= GateActivitiesPeriodMs;
+                    if (result)
+                    {
+                        SetGateActivitiesTime(currentTimeMs);
+                    }
+                    return result;
+                }
+
+                public bool HasBlockingAdjustmentDelayElapsed(int currentTimeMs, bool wasSignaledToWake)
+                {
+                    Debug.Assert(HasBlockingAdjustmentDelay);
+
+                    if (!wasSignaledToWake && _adjustForBlockingAfterNextDelay)
+                    {
+                        return true;
+                    }
+
+                    uint elapsedMsSincePreviousBlockingAdjustmentDelay =
+                        (uint)(currentTimeMs - _previousBlockingAdjustmentDelayStartTimeMs);
+                    return elapsedMsSincePreviousBlockingAdjustmentDelay >= _previousBlockingAdjustmentDelayMs;
+                }
+            }
         }
 
         internal static void EnsureGateThreadRunning() => GateThread.EnsureRunning(ThreadPoolInstance);
diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/PortableThreadPool.HillClimbing.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/PortableThreadPool.HillClimbing.cs
index aead56b38acabf..3a2b10096887d0 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Threading/PortableThreadPool.HillClimbing.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Threading/PortableThreadPool.HillClimbing.cs
@@ -33,6 +33,7 @@ public enum StateOrTransition
                 Stabilizing,
                 Starvation,
                 ThreadTimedOut,
+                CooperativeBlocking,
             }
 
             // SOS's ThreadPool command depends on the names of all fields
@@ -321,10 +322,12 @@ public HillClimbing()
                 newThreadWaveMagnitude = Math.Max(newThreadWaveMagnitude, 1);
 
                 //
-                // Make sure our control setting is within the ThreadPool's limits
+                // Make sure our control setting is within the ThreadPool's limits. When some threads are blocked due to
+                // cooperative blocking, ensure that hill climbing does not decrease the thread count below the expected
+                // minimum.
                 //
                 int maxThreads = threadPoolInstance._maxThreads;
-                int minThreads = threadPoolInstance._minThreads;
+                int minThreads = threadPoolInstance.MinThreadsGoal;
 
                 _currentControlSetting = Math.Min(maxThreads - newThreadWaveMagnitude, _currentControlSetting);
                 _currentControlSetting = Math.Max(minThreads, _currentControlSetting);
@@ -355,7 +358,11 @@ public HillClimbing()
                 // If all of this caused an actual change in thread count, log that as well.
                 //
                 if (newThreadCount != currentThreadCount)
+                {
                     ChangeThreadCount(newThreadCount, state);
+                    _secondsElapsedSinceLastChange = 0;
+                    _completionsSinceLastChange = 0;
+                }
 
                 //
                 // Return the new thread count and sample interval.  This is randomized to prevent correlations with other periodic
@@ -377,11 +384,14 @@ public HillClimbing()
             private void ChangeThreadCount(int newThreadCount, StateOrTransition state)
             {
                 _lastThreadCount = newThreadCount;
-                _currentSampleMs = _randomIntervalGenerator.Next(_sampleIntervalMsLow, _sampleIntervalMsHigh + 1);
+
+                if (state != StateOrTransition.CooperativeBlocking) // this can be noisy
+                {
+                    _currentSampleMs = _randomIntervalGenerator.Next(_sampleIntervalMsLow, _sampleIntervalMsHigh + 1);
+                }
+
                 double throughput = _secondsElapsedSinceLastChange > 0 ? _completionsSinceLastChange / _secondsElapsedSinceLastChange : 0;
                 LogTransition(newThreadCount, throughput, state);
-                _secondsElapsedSinceLastChange = 0;
-                _completionsSinceLastChange = 0;
             }
 
             private void LogTransition(int newThreadCount, double throughput, StateOrTransition stateOrTransition)
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 1c0c121847387c..d4673f5cd73296 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
@@ -16,15 +16,14 @@ private struct ThreadCounts
             // SOS's ThreadPool command depends on this layout
             private const byte NumProcessingWorkShift = 0;
             private const byte NumExistingThreadsShift = 16;
-            private const byte NumThreadsGoalShift = 32;
 
-            private ulong _data; // SOS's ThreadPool command depends on this name
+            private uint _data; // SOS's ThreadPool command depends on this name
 
-            private ThreadCounts(ulong data) => _data = data;
+            private ThreadCounts(uint data) => _data = data;
 
             private short GetInt16Value(byte shift) => (short)(_data >> shift);
             private void SetInt16Value(short value, byte shift) =>
-                _data = (_data & ~((ulong)ushort.MaxValue << shift)) | ((ulong)(ushort)value << shift);
+                _data = (_data & ~((uint)ushort.MaxValue << shift)) | ((uint)(ushort)value << shift);
 
             /// <summary>
             /// Number of threads processing work items.
@@ -44,7 +43,15 @@ public void SubtractNumProcessingWork(short value)
                 Debug.Assert(value >= 0);
                 Debug.Assert(value <= NumProcessingWork);
 
-                _data -= (ulong)(ushort)value << NumProcessingWorkShift;
+                _data -= (uint)(ushort)value << NumProcessingWorkShift;
+            }
+
+            public void InterlockedDecrementNumProcessingWork()
+            {
+                Debug.Assert(NumProcessingWorkShift == 0);
+
+                ThreadCounts counts = new ThreadCounts(Interlocked.Decrement(ref _data));
+                Debug.Assert(counts.NumProcessingWork >= 0);
             }
 
             /// <summary>
@@ -65,20 +72,7 @@ public void SubtractNumExistingThreads(short value)
                 Debug.Assert(value >= 0);
                 Debug.Assert(value <= NumExistingThreads);
 
-                _data -= (ulong)(ushort)value << NumExistingThreadsShift;
-            }
-
-            /// <summary>
-            /// Max possible thread pool threads we want to have.
-            /// </summary>
-            public short NumThreadsGoal
-            {
-                get => GetInt16Value(NumThreadsGoalShift);
-                set
-                {
-                    Debug.Assert(value > 0);
-                    SetInt16Value(value, NumThreadsGoalShift);
-                }
+                _data -= (uint)(ushort)value << NumExistingThreadsShift;
             }
 
             public ThreadCounts VolatileRead() => new ThreadCounts(Volatile.Read(ref _data));
@@ -90,7 +84,7 @@ public ThreadCounts InterlockedCompareExchange(ThreadCounts newCounts, ThreadCou
             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 int GetHashCode() => (int)_data + (int)(_data >> 32);
+            public override int GetHashCode() => (int)_data;
         }
     }
 }
diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/PortableThreadPool.WorkerThread.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/PortableThreadPool.WorkerThread.cs
index 917a1113f59630..8b1a44946d10f5 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Threading/PortableThreadPool.WorkerThread.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Threading/PortableThreadPool.WorkerThread.cs
@@ -12,6 +12,11 @@ internal sealed partial class PortableThreadPool
         /// </summary>
         private static class WorkerThread
         {
+            // This value represents an assumption of how much uncommited stack space a worker thread may use in the future.
+            // Used in calculations to estimate when to throttle the rate of thread injection to reduce the possibility of
+            // preexisting threads from running out of memory when using new stack space in low-memory situations.
+            public const int EstimatedAdditionalStackUsagePerThreadBytes = 64 << 10; // 64 KB
+
             /// <summary>
             /// Semaphore for controlling how many threads are currently working.
             /// </summary>
@@ -43,7 +48,7 @@ private static void WorkerThreadStart()
                         (uint)threadPoolInstance._separated.counts.VolatileRead().NumExistingThreads);
                 }
 
-                LowLevelLock hillClimbingThreadAdjustmentLock = threadPoolInstance._hillClimbingThreadAdjustmentLock;
+                LowLevelLock threadAdjustmentLock = threadPoolInstance._threadAdjustmentLock;
                 LowLevelLifoSemaphore semaphore = s_semaphore;
 
                 while (true)
@@ -54,7 +59,7 @@ private static void WorkerThreadStart()
                         bool alreadyRemovedWorkingWorker = false;
                         while (TakeActiveRequest(threadPoolInstance))
                         {
-                            Volatile.Write(ref threadPoolInstance._separated.lastDequeueTime, Environment.TickCount);
+                            threadPoolInstance._separated.lastDequeueTime = Environment.TickCount;
                             if (!ThreadPoolWorkQueue.Dispatch())
                             {
                                 // ShouldStopProcessingWorkNow() caused the thread to stop processing work, and it would have
@@ -96,14 +101,14 @@ private static void WorkerThreadStart()
                         }
                     }
 
-                    hillClimbingThreadAdjustmentLock.Acquire();
+                    threadAdjustmentLock.Acquire();
                     try
                     {
                         // At this point, the thread's wait timed out. We are shutting down this thread.
                         // We are going to decrement the number of exisiting threads to no longer include this one
                         // and then change the max number of threads in the thread pool to reflect that we don't need as many
                         // as we had. Finally, we are going to tell hill climbing that we changed the max number of threads.
-                        ThreadCounts counts = threadPoolInstance._separated.counts.VolatileRead();
+                        ThreadCounts counts = threadPoolInstance._separated.counts;
                         while (true)
                         {
                             // Since this thread is currently registered as an existing thread, if more work comes in meanwhile,
@@ -119,13 +124,21 @@ private static void WorkerThreadStart()
                             ThreadCounts newCounts = counts;
                             newCounts.SubtractNumExistingThreads(1);
                             short newNumExistingThreads = (short)(numExistingThreads - 1);
-                            short newNumThreadsGoal = Math.Max(threadPoolInstance._minThreads, Math.Min(newNumExistingThreads, newCounts.NumThreadsGoal));
-                            newCounts.NumThreadsGoal = newNumThreadsGoal;
 
                             ThreadCounts oldCounts = threadPoolInstance._separated.counts.InterlockedCompareExchange(newCounts, counts);
                             if (oldCounts == counts)
                             {
-                                HillClimbing.ThreadPoolHillClimber.ForceChange(newNumThreadsGoal, HillClimbing.StateOrTransition.ThreadTimedOut);
+                                short newNumThreadsGoal =
+                                    Math.Max(
+                                        threadPoolInstance.MinThreadsGoal,
+                                        Math.Min(newNumExistingThreads, threadPoolInstance._separated.numThreadsGoal));
+                                if (threadPoolInstance._separated.numThreadsGoal != newNumThreadsGoal)
+                                {
+                                    threadPoolInstance._separated.numThreadsGoal = newNumThreadsGoal;
+                                    HillClimbing.ThreadPoolHillClimber.ForceChange(
+                                        newNumThreadsGoal,
+                                        HillClimbing.StateOrTransition.ThreadTimedOut);
+                                }
 
                                 if (NativeRuntimeEventSource.Log.IsEnabled())
                                 {
@@ -139,7 +152,7 @@ private static void WorkerThreadStart()
                     }
                     finally
                     {
-                        hillClimbingThreadAdjustmentLock.Release();
+                        threadAdjustmentLock.Release();
                     }
                 }
             }
@@ -149,19 +162,7 @@ private static void WorkerThreadStart()
             /// </summary>
             private static void RemoveWorkingWorker(PortableThreadPool threadPoolInstance)
             {
-                ThreadCounts currentCounts = threadPoolInstance._separated.counts.VolatileRead();
-                while (true)
-                {
-                    ThreadCounts newCounts = currentCounts;
-                    newCounts.SubtractNumProcessingWork(1);
-                    ThreadCounts oldCounts = threadPoolInstance._separated.counts.InterlockedCompareExchange(newCounts, currentCounts);
-
-                    if (oldCounts == currentCounts)
-                    {
-                        break;
-                    }
-                    currentCounts = oldCounts;
-                }
+                threadPoolInstance._separated.counts.InterlockedDecrementNumProcessingWork();
 
                 // It's possible that we decided we had thread requests just before a request came in,
                 // but reduced the worker count *after* the request came in.  In this case, we might
@@ -175,12 +176,12 @@ private static void RemoveWorkingWorker(PortableThreadPool threadPoolInstance)
 
             internal static void MaybeAddWorkingWorker(PortableThreadPool threadPoolInstance)
             {
-                ThreadCounts counts = threadPoolInstance._separated.counts.VolatileRead();
+                ThreadCounts counts = threadPoolInstance._separated.counts;
                 short numExistingThreads, numProcessingWork, newNumExistingThreads, newNumProcessingWork;
                 while (true)
                 {
                     numProcessingWork = counts.NumProcessingWork;
-                    if (numProcessingWork >= counts.NumThreadsGoal)
+                    if (numProcessingWork >= threadPoolInstance._separated.numThreadsGoal)
                     {
                         return;
                     }
@@ -219,7 +220,7 @@ internal static void MaybeAddWorkingWorker(PortableThreadPool threadPoolInstance
                         continue;
                     }
 
-                    counts = threadPoolInstance._separated.counts.VolatileRead();
+                    counts = threadPoolInstance._separated.counts;
                     while (true)
                     {
                         ThreadCounts newCounts = counts;
@@ -245,17 +246,17 @@ internal static void MaybeAddWorkingWorker(PortableThreadPool threadPoolInstance
             /// <returns>Whether or not this thread should stop processing work even if there is still work in the queue.</returns>
             internal static bool ShouldStopProcessingWorkNow(PortableThreadPool threadPoolInstance)
             {
-                ThreadCounts counts = threadPoolInstance._separated.counts.VolatileRead();
+                ThreadCounts counts = threadPoolInstance._separated.counts;
                 while (true)
                 {
-                    // When there are more threads processing work than the thread count goal, hill climbing must have decided
+                    // When there are more threads processing work than the thread count goal, it may have been decided
                     // to decrease the number of threads. Stop processing if the counts can be updated. We may have more
                     // threads existing than the thread count goal and that is ok, the cold ones will eventually time out if
                     // the thread count goal is not increased again. This logic is a bit different from the original CoreCLR
                     // code from which this implementation was ported, which turns a processing thread into a retired thread
                     // and checks for pending requests like RemoveWorkingWorker. In this implementation there are
                     // no retired threads, so only the count of threads processing work is considered.
-                    if (counts.NumProcessingWork <= counts.NumThreadsGoal)
+                    if (counts.NumProcessingWork <= threadPoolInstance._separated.numThreadsGoal)
                     {
                         return false;
                     }
diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/PortableThreadPool.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/PortableThreadPool.cs
index b18e963f360662..8c6163fa2f7d2d 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Threading/PortableThreadPool.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Threading/PortableThreadPool.cs
@@ -28,8 +28,10 @@ internal sealed partial class PortableThreadPool
         private const int CpuUtilizationHigh = 95;
         private const int CpuUtilizationLow = 80;
 
-        private static readonly short s_forcedMinWorkerThreads = AppContextConfigHelper.GetInt16Config("System.Threading.ThreadPool.MinThreads", 0, false);
-        private static readonly short s_forcedMaxWorkerThreads = AppContextConfigHelper.GetInt16Config("System.Threading.ThreadPool.MaxThreads", 0, false);
+        private static readonly short ForcedMinWorkerThreads =
+            AppContextConfigHelper.GetInt16Config("System.Threading.ThreadPool.MinThreads", 0, false);
+        private static readonly short ForcedMaxWorkerThreads =
+            AppContextConfigHelper.GetInt16Config("System.Threading.ThreadPool.MaxThreads", 0, false);
 
         [ThreadStatic]
         private static object? t_completionCountObject;
@@ -43,43 +45,55 @@ internal sealed partial class PortableThreadPool
         private int _cpuUtilization; // SOS's ThreadPool command depends on this name
         private short _minThreads;
         private short _maxThreads;
-        private readonly LowLevelLock _maxMinThreadLock = new LowLevelLock();
 
         [StructLayout(LayoutKind.Explicit, Size = Internal.PaddingHelpers.CACHE_LINE_SIZE * 6)]
         private struct CacheLineSeparated
         {
             [FieldOffset(Internal.PaddingHelpers.CACHE_LINE_SIZE * 1)]
             public ThreadCounts counts; // SOS's ThreadPool command depends on this name
+            [FieldOffset(Internal.PaddingHelpers.CACHE_LINE_SIZE * 1 + sizeof(uint))]
+            public short numThreadsGoal;
+
             [FieldOffset(Internal.PaddingHelpers.CACHE_LINE_SIZE * 2)]
             public int lastDequeueTime;
+
             [FieldOffset(Internal.PaddingHelpers.CACHE_LINE_SIZE * 3)]
             public int priorCompletionCount;
             [FieldOffset(Internal.PaddingHelpers.CACHE_LINE_SIZE * 3 + sizeof(int))]
             public int priorCompletedWorkRequestsTime;
             [FieldOffset(Internal.PaddingHelpers.CACHE_LINE_SIZE * 3 + sizeof(int) * 2)]
             public int nextCompletedWorkRequestsTime;
+
             [FieldOffset(Internal.PaddingHelpers.CACHE_LINE_SIZE * 4)]
             public volatile int numRequestedWorkers;
-            [FieldOffset(Internal.PaddingHelpers.CACHE_LINE_SIZE * 5)]
+            [FieldOffset(Internal.PaddingHelpers.CACHE_LINE_SIZE * 4 + sizeof(int))]
             public int gateThreadRunningState;
         }
 
-        private CacheLineSeparated _separated; // SOS's ThreadPool command depends on this name
         private long _currentSampleStartTime;
         private readonly ThreadInt64PersistentCounter _completionCounter = new ThreadInt64PersistentCounter();
         private int _threadAdjustmentIntervalMs;
 
-        private readonly LowLevelLock _hillClimbingThreadAdjustmentLock = new LowLevelLock();
+        private short _numBlockedThreads;
+        private short _numThreadsAddedDueToBlocking;
+        private PendingBlockingAdjustment _pendingBlockingAdjustment;
+
+        private long _memoryUsageBytes;
+        private long _memoryLimitBytes;
+
+        private readonly LowLevelLock _threadAdjustmentLock = new LowLevelLock();
+
+        private CacheLineSeparated _separated; // SOS's ThreadPool command depends on this name
 
         private PortableThreadPool()
         {
-            _minThreads = s_forcedMinWorkerThreads > 0 ? s_forcedMinWorkerThreads : (short)Environment.ProcessorCount;
+            _minThreads = ForcedMinWorkerThreads > 0 ? ForcedMinWorkerThreads : (short)Environment.ProcessorCount;
             if (_minThreads > MaxPossibleThreadCount)
             {
                 _minThreads = MaxPossibleThreadCount;
             }
 
-            _maxThreads = s_forcedMaxWorkerThreads > 0 ? s_forcedMaxWorkerThreads : DefaultMaxWorkerThreadCount;
+            _maxThreads = ForcedMaxWorkerThreads > 0 ? ForcedMaxWorkerThreads : DefaultMaxWorkerThreadCount;
             if (_maxThreads > MaxPossibleThreadCount)
             {
                 _maxThreads = MaxPossibleThreadCount;
@@ -89,13 +103,7 @@ private PortableThreadPool()
                 _maxThreads = _minThreads;
             }
 
-            _separated = new CacheLineSeparated
-            {
-                counts = new ThreadCounts
-                {
-                    NumThreadsGoal = _minThreads
-                }
-            };
+            _separated.numThreadsGoal = _minThreads;
         }
 
         public bool SetMinThreads(int workerThreads, int ioCompletionThreads)
@@ -105,7 +113,10 @@ public bool SetMinThreads(int workerThreads, int ioCompletionThreads)
                 return false;
             }
 
-            _maxMinThreadLock.Acquire();
+            bool addWorker = false;
+            bool wakeGateThread = false;
+
+            _threadAdjustmentLock.Acquire();
             try
             {
                 if (workerThreads > _maxThreads || !ThreadPool.CanSetMinIOCompletionThreads(ioCompletionThreads))
@@ -115,39 +126,45 @@ public bool SetMinThreads(int workerThreads, int ioCompletionThreads)
 
                 ThreadPool.SetMinIOCompletionThreads(ioCompletionThreads);
 
-                if (s_forcedMinWorkerThreads != 0)
+                if (ForcedMinWorkerThreads != 0)
                 {
                     return true;
                 }
 
                 short newMinThreads = (short)Math.Max(1, Math.Min(workerThreads, MaxPossibleThreadCount));
                 _minThreads = newMinThreads;
-
-                ThreadCounts counts = _separated.counts.VolatileRead();
-                while (counts.NumThreadsGoal < newMinThreads)
+                if (_numBlockedThreads > 0)
                 {
-                    ThreadCounts newCounts = counts;
-                    newCounts.NumThreadsGoal = newMinThreads;
-
-                    ThreadCounts oldCounts = _separated.counts.InterlockedCompareExchange(newCounts, counts);
-                    if (oldCounts == counts)
+                    // Blocking adjustment will adjust the goal according to its heuristics
+                    if (_pendingBlockingAdjustment != PendingBlockingAdjustment.Immediately)
                     {
-                        if (_separated.numRequestedWorkers > 0)
-                        {
-                            WorkerThread.MaybeAddWorkingWorker(this);
-                        }
-                        break;
+                        _pendingBlockingAdjustment = PendingBlockingAdjustment.Immediately;
+                        wakeGateThread = true;
+                    }
+                }
+                else if (_separated.numThreadsGoal < newMinThreads)
+                {
+                    _separated.numThreadsGoal = newMinThreads;
+                    if (_separated.numRequestedWorkers > 0)
+                    {
+                        addWorker = true;
                     }
-
-                    counts = oldCounts;
                 }
-
-                return true;
             }
             finally
             {
-                _maxMinThreadLock.Release();
+                _threadAdjustmentLock.Release();
             }
+
+            if (addWorker)
+            {
+                WorkerThread.MaybeAddWorkingWorker(this);
+            }
+            else if (wakeGateThread)
+            {
+                GateThread.Wake(this);
+            }
+            return true;
         }
 
         public int GetMinThreads() => Volatile.Read(ref _minThreads);
@@ -159,7 +176,7 @@ public bool SetMaxThreads(int workerThreads, int ioCompletionThreads)
                 return false;
             }
 
-            _maxMinThreadLock.Acquire();
+            _threadAdjustmentLock.Acquire();
             try
             {
                 if (workerThreads < _minThreads || !ThreadPool.CanSetMaxIOCompletionThreads(ioCompletionThreads))
@@ -169,34 +186,22 @@ public bool SetMaxThreads(int workerThreads, int ioCompletionThreads)
 
                 ThreadPool.SetMaxIOCompletionThreads(ioCompletionThreads);
 
-                if (s_forcedMaxWorkerThreads != 0)
+                if (ForcedMaxWorkerThreads != 0)
                 {
                     return true;
                 }
 
                 short newMaxThreads = (short)Math.Min(workerThreads, MaxPossibleThreadCount);
                 _maxThreads = newMaxThreads;
-
-                ThreadCounts counts = _separated.counts.VolatileRead();
-                while (counts.NumThreadsGoal > newMaxThreads)
+                if (_separated.numThreadsGoal > newMaxThreads)
                 {
-                    ThreadCounts newCounts = counts;
-                    newCounts.NumThreadsGoal = newMaxThreads;
-
-                    ThreadCounts oldCounts = _separated.counts.InterlockedCompareExchange(newCounts, counts);
-                    if (oldCounts == counts)
-                    {
-                        break;
-                    }
-
-                    counts = oldCounts;
+                    _separated.numThreadsGoal = newMaxThreads;
                 }
-
                 return true;
             }
             finally
             {
-                _maxMinThreadLock.Release();
+                _threadAdjustmentLock.Release();
             }
         }
 
@@ -232,7 +237,7 @@ private object CreateThreadLocalCompletionCountObject()
         private void NotifyWorkItemProgress(object threadLocalCompletionCountObject, int currentTimeMs)
         {
             ThreadInt64PersistentCounter.Increment(threadLocalCompletionCountObject);
-            Volatile.Write(ref _separated.lastDequeueTime, Environment.TickCount);
+            _separated.lastDequeueTime = currentTimeMs;
 
             if (ShouldAdjustMaxWorkersActive(currentTimeMs))
             {
@@ -257,15 +262,23 @@ internal bool NotifyWorkItemComplete(object? threadLocalCompletionCountObject, i
         //
         private void AdjustMaxWorkersActive()
         {
-            LowLevelLock hillClimbingThreadAdjustmentLock = _hillClimbingThreadAdjustmentLock;
-            if (!hillClimbingThreadAdjustmentLock.TryAcquire())
+            LowLevelLock threadAdjustmentLock = _threadAdjustmentLock;
+            if (!threadAdjustmentLock.TryAcquire())
             {
                 // The lock is held by someone else, they will take care of this for us
                 return;
             }
 
+            bool addWorker = false;
             try
             {
+                // Skip hill climbing when there is a pending blocking adjustment. Hill climbing may otherwise bypass the
+                // blocking adjustment heuristics and increase the thread count too quickly.
+                if (_pendingBlockingAdjustment != PendingBlockingAdjustment.None)
+                {
+                    return;
+                }
+
                 long startTime = _currentSampleStartTime;
                 long endTime = Stopwatch.GetTimestamp();
                 long freq = Stopwatch.Frequency;
@@ -278,39 +291,24 @@ private void AdjustMaxWorkersActive()
                     int totalNumCompletions = (int)_completionCounter.Count;
                     int numCompletions = totalNumCompletions - _separated.priorCompletionCount;
 
-                    ThreadCounts currentCounts = _separated.counts.VolatileRead();
-                    int newMax;
-                    (newMax, _threadAdjustmentIntervalMs) = HillClimbing.ThreadPoolHillClimber.Update(currentCounts.NumThreadsGoal, elapsedSeconds, numCompletions);
-
-                    while (newMax != currentCounts.NumThreadsGoal)
+                    int newNumThreadsGoal;
+                    (newNumThreadsGoal, _threadAdjustmentIntervalMs) =
+                        HillClimbing.ThreadPoolHillClimber.Update(_separated.numThreadsGoal, elapsedSeconds, numCompletions);
+                    short oldNumThreadsGoal = _separated.numThreadsGoal;
+                    if (oldNumThreadsGoal != (short)newNumThreadsGoal)
                     {
-                        ThreadCounts newCounts = currentCounts;
-                        newCounts.NumThreadsGoal = (short)newMax;
-
-                        ThreadCounts oldCounts = _separated.counts.InterlockedCompareExchange(newCounts, currentCounts);
-                        if (oldCounts == currentCounts)
-                        {
-                            //
-                            // If we're increasing the max, inject a thread.  If that thread finds work, it will inject
-                            // another thread, etc., until nobody finds work or we reach the new maximum.
-                            //
-                            // If we're reducing the max, whichever threads notice this first will sleep and timeout themselves.
-                            //
-                            if (newMax > oldCounts.NumThreadsGoal)
-                            {
-                                WorkerThread.MaybeAddWorkingWorker(this);
-                            }
-                            break;
-                        }
-
-                        if (oldCounts.NumThreadsGoal > currentCounts.NumThreadsGoal && oldCounts.NumThreadsGoal >= newMax)
+                        _separated.numThreadsGoal = (short)newNumThreadsGoal;
+
+                        //
+                        // If we're increasing the goal, inject a thread.  If that thread finds work, it will inject
+                        // another thread, etc., until nobody finds work or we reach the new goal.
+                        //
+                        // If we're reducing the goal, whichever threads notice this first will sleep and timeout themselves.
+                        //
+                        if (newNumThreadsGoal > oldNumThreadsGoal)
                         {
-                            // someone (probably the gate thread) increased the thread count more than
-                            // we are about to do.  Don't interfere.
-                            break;
+                            addWorker = true;
                         }
-
-                        currentCounts = oldCounts;
                     }
 
                     _separated.priorCompletionCount = totalNumCompletions;
@@ -321,12 +319,22 @@ private void AdjustMaxWorkersActive()
             }
             finally
             {
-                hillClimbingThreadAdjustmentLock.Release();
+                threadAdjustmentLock.Release();
+            }
+
+            if (addWorker)
+            {
+                WorkerThread.MaybeAddWorkingWorker(this);
             }
         }
 
         private bool ShouldAdjustMaxWorkersActive(int currentTimeMs)
         {
+            if (HillClimbing.IsDisabled)
+            {
+                return false;
+            }
+
             // We need to subtract by prior time because Environment.TickCount can wrap around, making a comparison of absolute
             // times unreliable. Intervals are unsigned to avoid wrapping around on the subtract after enough time elapses, and
             // this also prevents the initial elapsed interval from being negative due to the prior and next times being
@@ -334,19 +342,26 @@ private bool ShouldAdjustMaxWorkersActive(int currentTimeMs)
             int priorTime = Volatile.Read(ref _separated.priorCompletedWorkRequestsTime);
             uint requiredInterval = (uint)(_separated.nextCompletedWorkRequestsTime - priorTime);
             uint elapsedInterval = (uint)(currentTimeMs - priorTime);
-            if (elapsedInterval >= requiredInterval)
+            if (elapsedInterval < requiredInterval)
+            {
+                return false;
+            }
+
+            // Avoid trying to adjust the thread count goal if there are already more threads than the thread count goal.
+            // In that situation, hill climbing must have previously decided to decrease the thread count goal, so let's
+            // wait until the system responds to that change before calling into hill climbing again. This condition should
+            // be the opposite of the condition in WorkerThread.ShouldStopProcessingWorkNow that causes
+            // threads processing work to stop in response to a decreased thread count goal. The logic here is a bit
+            // different from the original CoreCLR code from which this implementation was ported because in this
+            // implementation there are no retired threads, so only the count of threads processing work is considered.
+            if (_separated.counts.NumProcessingWork > _separated.numThreadsGoal)
             {
-                // Avoid trying to adjust the thread count goal if there are already more threads than the thread count goal.
-                // In that situation, hill climbing must have previously decided to decrease the thread count goal, so let's
-                // wait until the system responds to that change before calling into hill climbing again. This condition should
-                // be the opposite of the condition in WorkerThread.ShouldStopProcessingWorkNow that causes
-                // threads processing work to stop in response to a decreased thread count goal. The logic here is a bit
-                // different from the original CoreCLR code from which this implementation was ported because in this
-                // implementation there are no retired threads, so only the count of threads processing work is considered.
-                ThreadCounts counts = _separated.counts.VolatileRead();
-                return counts.NumProcessingWork <= counts.NumThreadsGoal && !HillClimbing.IsDisabled;
+                return false;
             }
-            return false;
+
+            // Skip hill climbing when there is a pending blocking adjustment. Hill climbing may otherwise bypass the
+            // blocking adjustment heuristics and increase the thread count too quickly.
+            return _pendingBlockingAdjustment == PendingBlockingAdjustment.None;
         }
 
         internal void RequestWorker()
@@ -357,5 +372,16 @@ internal void RequestWorker()
             WorkerThread.MaybeAddWorkingWorker(this);
             GateThread.EnsureRunning(this);
         }
+
+        private bool OnGen2GCCallback()
+        {
+            // Gen 2 GCs may be very infrequent in some cases. If it becomes an issue, consider updating the memory usage more
+            // frequently. The memory usage is only used for fallback purposes in blocking adjustment, so an artifically higher
+            // memory usage may cause blocking adjustment to fall back to slower adjustments sooner than necessary.
+            GCMemoryInfo gcMemoryInfo = GC.GetGCMemoryInfo();
+            _memoryLimitBytes = gcMemoryInfo.HighMemoryLoadThresholdBytes;
+            _memoryUsageBytes = Math.Min(gcMemoryInfo.MemoryLoadBytes, gcMemoryInfo.HighMemoryLoadThresholdBytes);
+            return true; // continue receiving gen 2 GC callbacks
+        }
     }
 }
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 53f0aebf2db204..923c4cf71bcf4d 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
@@ -2973,14 +2973,36 @@ private bool SpinThenBlockingWait(int millisecondsTimeout, CancellationToken can
 #pragma warning disable CA1416 // Validate platform compatibility, issue: https://github.com/dotnet/runtime/issues/44622
                     if (infiniteWait)
                     {
-                        returnValue = mres.Wait(Timeout.Infinite, cancellationToken);
+                        bool notifyWhenUnblocked = ThreadPool.NotifyThreadBlocked();
+                        try
+                        {
+                            returnValue = mres.Wait(Timeout.Infinite, cancellationToken);
+                        }
+                        finally
+                        {
+                            if (notifyWhenUnblocked)
+                            {
+                                ThreadPool.NotifyThreadUnblocked();
+                            }
+                        }
                     }
                     else
                     {
                         uint elapsedTimeTicks = ((uint)Environment.TickCount) - startTimeTicks;
                         if (elapsedTimeTicks < millisecondsTimeout)
                         {
-                            returnValue = mres.Wait((int)(millisecondsTimeout - elapsedTimeTicks), cancellationToken);
+                            bool notifyWhenUnblocked = ThreadPool.NotifyThreadBlocked();
+                            try
+                            {
+                                returnValue = mres.Wait((int)(millisecondsTimeout - elapsedTimeTicks), cancellationToken);
+                            }
+                            finally
+                            {
+                                if (notifyWhenUnblocked)
+                                {
+                                    ThreadPool.NotifyThreadUnblocked();
+                                }
+                            }
                         }
                     }
 #pragma warning restore CA1416
diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/ThreadPool.Portable.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/ThreadPool.Portable.cs
index 08067113171c0e..70ac108e32d748 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Threading/ThreadPool.Portable.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Threading/ThreadPool.Portable.cs
@@ -100,6 +100,9 @@ public static void GetAvailableThreads(out int workerThreads, out int completion
         internal static bool NotifyWorkItemComplete(object? threadLocalCompletionCountObject, int currentTimeMs) =>
             PortableThreadPool.ThreadPoolInstance.NotifyWorkItemComplete(threadLocalCompletionCountObject, currentTimeMs);
 
+        internal static bool NotifyThreadBlocked() => PortableThreadPool.ThreadPoolInstance.NotifyThreadBlocked();
+        internal static void NotifyThreadUnblocked() => PortableThreadPool.ThreadPoolInstance.NotifyThreadUnblocked();
+
         internal static object GetOrCreateThreadLocalCompletionCountObject() =>
             PortableThreadPool.ThreadPoolInstance.GetOrCreateThreadLocalCompletionCountObject();
 
diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/ThreadPoolWorkQueue.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/ThreadPoolWorkQueue.cs
index f08e4ba4d7fe0a..e0dfdc951cf87f 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Threading/ThreadPoolWorkQueue.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Threading/ThreadPoolWorkQueue.cs
@@ -725,7 +725,12 @@ internal static bool Dispatch()
                     //
                     int currentTickCount = Environment.TickCount;
                     if (!ThreadPool.NotifyWorkItemComplete(threadLocalCompletionCountObject, currentTickCount))
+                    {
+                        // This thread is being parked and may remain inactive for a while. Transfer any thread-local work items
+                        // to ensure that they would not be heavily delayed.
+                        tl.TransferLocalWork();
                         return false;
+                    }
 
                     // Check if the dispatch quantum has expired
                     if ((uint)(currentTickCount - startTickCount) < DispatchQuantumMs)
@@ -824,21 +829,20 @@ public ThreadPoolWorkQueueThreadLocals(ThreadPoolWorkQueue tpq)
             threadLocalCompletionCountObject = ThreadPool.GetOrCreateThreadLocalCompletionCountObject();
         }
 
+        public void TransferLocalWork()
+        {
+            while (workStealingQueue.LocalPop() is object cb)
+            {
+                workQueue.Enqueue(cb, forceGlobal: true);
+            }
+        }
+
         ~ThreadPoolWorkQueueThreadLocals()
         {
             // Transfer any pending workitems into the global queue so that they will be executed by another thread
             if (null != workStealingQueue)
             {
-                if (null != workQueue)
-                {
-                    object? cb;
-                    while ((cb = workStealingQueue.LocalPop()) != null)
-                    {
-                        Debug.Assert(null != cb);
-                        workQueue.Enqueue(cb, forceGlobal: true);
-                    }
-                }
-
+                TransferLocalWork();
                 ThreadPoolWorkQueue.WorkStealingQueueList.Remove(workStealingQueue);
             }
         }
diff --git a/src/libraries/System.Private.CoreLib/src/System/ThrowHelper.cs b/src/libraries/System.Private.CoreLib/src/System/ThrowHelper.cs
index d061bddce9cab6..9a5ef787d7c788 100644
--- a/src/libraries/System.Private.CoreLib/src/System/ThrowHelper.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/ThrowHelper.cs
@@ -231,6 +231,12 @@ internal static void ThrowArgumentException_HandleNotSync(string paramName)
             throw new ArgumentException(SR.Arg_HandleNotSync, paramName);
         }
 
+        [DoesNotReturn]
+        internal static void ThrowArgumentException_HandleNotAsync(string paramName)
+        {
+            throw new ArgumentException(SR.Arg_HandleNotAsync, paramName);
+        }
+
         [DoesNotReturn]
         internal static void ThrowArgumentNullException(ExceptionArgument argument)
         {
@@ -396,6 +402,12 @@ internal static void ThrowArgumentException_Argument_InvalidArrayType()
             throw new ArgumentException(SR.Argument_InvalidArrayType);
         }
 
+        [DoesNotReturn]
+        internal static void ThrowArgumentException_InvalidHandle(string? paramName)
+        {
+            throw new ArgumentException(SR.Arg_InvalidHandle, paramName);
+        }
+
         [DoesNotReturn]
         internal static void ThrowInvalidOperationException_InvalidOperation_EnumNotStarted()
         {
@@ -474,6 +486,24 @@ internal static void ThrowArgumentOutOfRangeException_SymbolDoesNotFit()
             throw new ArgumentOutOfRangeException("symbol", SR.Argument_BadFormatSpecifier);
         }
 
+        [DoesNotReturn]
+        internal static void ThrowArgumentOutOfRangeException_NeedPosNum(string? paramName)
+        {
+            throw new ArgumentOutOfRangeException(paramName, SR.ArgumentOutOfRange_NeedPosNum);
+        }
+
+        [DoesNotReturn]
+        internal static void ThrowArgumentOutOfRangeException_NeedNonNegNum(string paramName)
+        {
+            throw new ArgumentOutOfRangeException(paramName, SR.ArgumentOutOfRange_NeedNonNegNum);
+        }
+
+        [DoesNotReturn]
+        internal static void ArgumentOutOfRangeException_Enum_Value()
+        {
+            throw new ArgumentOutOfRangeException("value", SR.ArgumentOutOfRange_Enum);
+        }
+
         private static Exception GetArraySegmentCtorValidationFailedException(Array? array, int offset, int count)
         {
             if (array == null)
@@ -733,6 +763,8 @@ private static string GetArgumentName(ExceptionArgument argument)
                     return "destinationArray";
                 case ExceptionArgument.pHandle:
                     return "pHandle";
+                case ExceptionArgument.handle:
+                    return "handle";
                 case ExceptionArgument.other:
                     return "other";
                 case ExceptionArgument.newSize:
@@ -779,6 +811,8 @@ private static string GetArgumentName(ExceptionArgument argument)
                     return "suffix";
                 case ExceptionArgument.buffer:
                     return "buffer";
+                case ExceptionArgument.buffers:
+                    return "buffers";
                 case ExceptionArgument.offset:
                     return "offset";
                 case ExceptionArgument.stream:
@@ -941,6 +975,8 @@ private static string GetResourceString(ExceptionResource resource)
                     return SR.Argument_InvalidFlag;
                 case ExceptionResource.CancellationTokenSource_Disposed:
                     return SR.CancellationTokenSource_Disposed;
+                case ExceptionResource.Argument_AlignmentMustBePow2:
+                    return SR.Argument_AlignmentMustBePow2;
                 default:
                     Debug.Fail("The enum value is not defined, please check the ExceptionResource Enum.");
                     return "";
@@ -1022,6 +1058,7 @@ internal enum ExceptionArgument
         destinationIndex,
         destinationArray,
         pHandle,
+        handle,
         other,
         newSize,
         lowerBounds,
@@ -1045,6 +1082,7 @@ internal enum ExceptionArgument
         prefix,
         suffix,
         buffer,
+        buffers,
         offset,
         stream
     }
@@ -1122,5 +1160,6 @@ internal enum ExceptionResource
         Argument_SpansMustHaveSameLength,
         Argument_InvalidFlag,
         CancellationTokenSource_Disposed,
+        Argument_AlignmentMustBePow2,
     }
 }
diff --git a/src/libraries/System.Private.CoreLib/src/System/Type.cs b/src/libraries/System.Private.CoreLib/src/System/Type.cs
index ca57ed53988aa1..3c1a1783a6e767 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Type.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Type.cs
@@ -226,6 +226,38 @@ public ConstructorInfo? TypeInitializer
             DynamicallyAccessedMemberTypes.PublicNestedTypes)]
         public MemberInfo[] GetMembers() => GetMembers(Type.DefaultLookup);
 
+        /// <summary>
+        /// Searches for the <see cref="MemberInfo"/> on the current <see cref="Type"/> that matches the specified <see cref="MemberInfo"/>.
+        /// </summary>
+        /// <param name="member">
+        /// The <see cref="MemberInfo"/> to find on the current <see cref="Type"/>.
+        /// </param>
+        /// <returns>An object representing the member on the current <see cref="Type"/> that matches the specified member.</returns>
+        /// <remarks>This method can be used to find a constructed generic member given a member from a generic type definition.</remarks>
+        /// <exception cref="ArgumentNullException"><paramref name="member"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentException"><paramref name="member"/> does not match a member on the current <see cref="Type"/>.</exception>
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2085:UnrecognizedReflectionPattern",
+            Justification = "This is finding the MemberInfo with the same MetadataToken as specified MemberInfo. If the specified MemberInfo " +
+                            "exists and wasn't trimmed, then the current Type's MemberInfo couldn't have been trimmed.")]
+        public virtual MemberInfo GetMemberWithSameMetadataDefinitionAs(MemberInfo member)
+        {
+            if (member is null) throw new ArgumentNullException(nameof(member));
+
+            const BindingFlags all = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance;
+            foreach (MemberInfo myMemberInfo in GetMembers(all))
+            {
+                if (myMemberInfo.HasSameMetadataDefinitionAs(member))
+                {
+                    return myMemberInfo;
+                }
+            }
+
+            throw CreateGetMemberWithSameMetadataDefinitionAsNotFoundException(member);
+        }
+
+        private protected static ArgumentException CreateGetMemberWithSameMetadataDefinitionAsNotFoundException(MemberInfo member) =>
+            new ArgumentException(SR.Format(SR.Arg_MemberInfoNotFound, member.Name), nameof(member));
+
         [DynamicallyAccessedMembers(GetAllMembers)]
         public abstract MemberInfo[] GetMembers(BindingFlags bindingAttr);
 
diff --git a/src/libraries/System.Private.Xml.Linq/tests/TreeManipulation/SaveWithFileName.cs b/src/libraries/System.Private.Xml.Linq/tests/TreeManipulation/SaveWithFileName.cs
index a69fde9f481490..d6784b0ddd90ad 100644
--- a/src/libraries/System.Private.Xml.Linq/tests/TreeManipulation/SaveWithFileName.cs
+++ b/src/libraries/System.Private.Xml.Linq/tests/TreeManipulation/SaveWithFileName.cs
@@ -256,11 +256,6 @@ private static string StripOffXmlDeclaration(string s)
             return s;
         }
 
-        private static string NormalizeNewLines(string s)
-        {
-            s = s.Replace("\n", "");
-            s = s.Replace("\r", "");
-            return s;
-        }
+        private static string NormalizeNewLines(string s) => s.ReplaceLineEndings("");
     }
 }
diff --git a/src/libraries/System.Private.Xml/src/System/Xml/Core/XsdValidatingReader.cs b/src/libraries/System.Private.Xml/src/System/Xml/Core/XsdValidatingReader.cs
index 294b174638b79c..a42e0fef36c26e 100644
--- a/src/libraries/System.Private.Xml/src/System/Xml/Core/XsdValidatingReader.cs
+++ b/src/libraries/System.Private.Xml/src/System/Xml/Core/XsdValidatingReader.cs
@@ -2015,12 +2015,12 @@ private void ProcessReaderEvent()
 
                 case XmlNodeType.Whitespace:
                 case XmlNodeType.SignificantWhitespace:
-                    _validator.ValidateWhitespace(GetStringValue);
+                    _validator.ValidateWhitespace(_valueGetter);
                     break;
 
                 case XmlNodeType.Text:          // text inside a node
                 case XmlNodeType.CDATA:         // <![CDATA[...]]>
-                    _validator.ValidateText(GetStringValue);
+                    _validator.ValidateText(_valueGetter);
                     break;
 
                 case XmlNodeType.EndElement:
@@ -2543,12 +2543,12 @@ private object InternalReadContentAsObject(bool unwrapTypedValue, out string ori
 
                         case XmlNodeType.Text:
                         case XmlNodeType.CDATA:
-                            _validator.ValidateText(GetStringValue);
+                            _validator.ValidateText(_valueGetter);
                             break;
 
                         case XmlNodeType.Whitespace:
                         case XmlNodeType.SignificantWhitespace:
-                            _validator.ValidateWhitespace(GetStringValue);
+                            _validator.ValidateWhitespace(_valueGetter);
                             break;
 
                         case XmlNodeType.Comment:
@@ -2611,12 +2611,12 @@ private void ReadAheadForMemberType()
 
                     case XmlNodeType.Text:
                     case XmlNodeType.CDATA:
-                        _validator.ValidateText(GetStringValue);
+                        _validator.ValidateText(_valueGetter);
                         break;
 
                     case XmlNodeType.Whitespace:
                     case XmlNodeType.SignificantWhitespace:
-                        _validator.ValidateWhitespace(GetStringValue);
+                        _validator.ValidateWhitespace(_valueGetter);
                         break;
 
                     case XmlNodeType.Comment:
@@ -2672,12 +2672,12 @@ private void GetIsDefault()
 
                             case XmlNodeType.Text:
                             case XmlNodeType.CDATA:
-                                _validator.ValidateText(GetStringValue);
+                                _validator.ValidateText(_valueGetter);
                                 break;
 
                             case XmlNodeType.Whitespace:
                             case XmlNodeType.SignificantWhitespace:
-                                _validator.ValidateWhitespace(GetStringValue);
+                                _validator.ValidateWhitespace(_valueGetter);
                                 break;
 
                             case XmlNodeType.Comment:
diff --git a/src/libraries/System.Private.Xml/src/System/Xml/Dom/XmlNode.cs b/src/libraries/System.Private.Xml/src/System/Xml/Dom/XmlNode.cs
index f1ccbfc0273228..8ac69732b433de 100644
--- a/src/libraries/System.Private.Xml/src/System/Xml/Dom/XmlNode.cs
+++ b/src/libraries/System.Private.Xml/src/System/Xml/Dom/XmlNode.cs
@@ -48,9 +48,17 @@ internal XmlNode(XmlDocument doc)
         // Selects the first node that matches the xpath expression
         public XmlNode? SelectSingleNode(string xpath)
         {
-            XmlNodeList? list = SelectNodes(xpath);
-            // SelectNodes returns null for certain node types
-            return list != null ? list[0] : null;
+            if (CreateNavigator() is XPathNavigator navigator)
+            {
+                XPathNodeIterator nodeIterator = navigator.Select(xpath);
+                if (nodeIterator.MoveNext())
+                {
+                    Debug.Assert(nodeIterator.Current != null);
+                    return ((IHasXmlNode)nodeIterator.Current).GetNode();
+                }
+            }
+
+            return null;
         }
 
         // Selects the first node that matches the xpath expression and given namespace context.
diff --git a/src/libraries/System.Private.Xml/src/System/Xml/Schema/ValidationState.cs b/src/libraries/System.Private.Xml/src/System/Xml/Schema/ValidationState.cs
index c7860253a5858f..aa60c108b5c906 100644
--- a/src/libraries/System.Private.Xml/src/System/Xml/Schema/ValidationState.cs
+++ b/src/libraries/System.Private.Xml/src/System/Xml/Schema/ValidationState.cs
@@ -42,7 +42,8 @@ internal sealed class ValidationState
         public bool HasMatched;       // whether the element has been verified correctly
 
         //For NFAs
-        public BitSet[] CurPos = new BitSet[2];
+        private BitSet[]? _curPos;
+        public BitSet[] CurPos => _curPos ??= new BitSet[2];
 
         //For all
         public BitSet? AllElementsSet;
diff --git a/src/libraries/System.Private.Xml/src/System/Xml/XPath/Internal/XPathParser.cs b/src/libraries/System.Private.Xml/src/System/Xml/XPath/Internal/XPathParser.cs
index 9f1c1f1a6ea8b2..cad844bf45885f 100644
--- a/src/libraries/System.Private.Xml/src/System/Xml/XPath/Internal/XPathParser.cs
+++ b/src/libraries/System.Private.Xml/src/System/Xml/XPath/Internal/XPathParser.cs
@@ -9,35 +9,34 @@
 
 namespace MS.Internal.Xml.XPath
 {
-    internal sealed class XPathParser
+    internal struct XPathParser
     {
-        private readonly XPathScanner _scanner;
+        private XPathScanner _scanner;
 
-        private XPathParser(XPathScanner scanner)
+        private XPathParser(string xpathExpr)
         {
-            _scanner = scanner;
+            _scanner = new XPathScanner(xpathExpr);
+            _parseDepth = 0;
         }
 
         public static AstNode ParseXPathExpression(string xpathExpression)
         {
-            XPathScanner scanner = new XPathScanner(xpathExpression);
-            XPathParser parser = new XPathParser(scanner);
+            XPathParser parser = new XPathParser(xpathExpression);
             AstNode result = parser.ParseExpression(null);
-            if (scanner.Kind != XPathScanner.LexKind.Eof)
+            if (parser._scanner.Kind != XPathScanner.LexKind.Eof)
             {
-                throw XPathException.Create(SR.Xp_InvalidToken, scanner.SourceText);
+                throw XPathException.Create(SR.Xp_InvalidToken, parser._scanner.SourceText);
             }
             return result;
         }
 
         public static AstNode ParseXPathPattern(string xpathPattern)
         {
-            XPathScanner scanner = new XPathScanner(xpathPattern);
-            XPathParser parser = new XPathParser(scanner);
+            XPathParser parser = new XPathParser(xpathPattern);
             AstNode result = parser.ParsePattern();
-            if (scanner.Kind != XPathScanner.LexKind.Eof)
+            if (parser._scanner.Kind != XPathScanner.LexKind.Eof)
             {
-                throw XPathException.Create(SR.Xp_InvalidToken, scanner.SourceText);
+                throw XPathException.Create(SR.Xp_InvalidToken, parser._scanner.SourceText);
             }
             return result;
         }
@@ -224,17 +223,12 @@ private AstNode ParseUnionExpr(AstNode? qyInput)
             } while (true);
         }
 
-        private static bool IsNodeType(XPathScanner scaner)
-        {
-            return (
-                scaner.Prefix.Length == 0 && (
-                    scaner.Name == "node" ||
-                    scaner.Name == "text" ||
-                    scaner.Name == "processing-instruction" ||
-                    scaner.Name == "comment"
-                )
-            );
-        }
+        private bool IsNodeType =>
+            _scanner.Prefix.Length == 0 &&
+            (_scanner.Name == "node" ||
+             _scanner.Name == "text" ||
+             _scanner.Name == "processing-instruction" ||
+             _scanner.Name == "comment");
 
         //>> PathOp   ::= '/' | '//'
         //>> PathExpr ::= LocationPath |
@@ -242,7 +236,7 @@ private static bool IsNodeType(XPathScanner scaner)
         private AstNode ParsePathExpr(AstNode? qyInput)
         {
             AstNode opnd;
-            if (IsPrimaryExpr(_scanner))
+            if (IsPrimaryExpr)
             { // in this moment we should distinct LocationPas vs FilterExpr (which starts from is PrimaryExpr)
                 opnd = ParseFilterExpr(qyInput);
                 if (_scanner.Kind == XPathScanner.LexKind.Slash)
@@ -407,7 +401,7 @@ private AstNode ParseNodeTest(AstNode? qyInput, Axis.AxisType axisType, XPathNod
             switch (_scanner.Kind)
             {
                 case XPathScanner.LexKind.Name:
-                    if (_scanner.CanBeFunction && IsNodeType(_scanner))
+                    if (_scanner.CanBeFunction && IsNodeType)
                     {
                         nodePrefix = string.Empty;
                         nodeName = string.Empty;
@@ -457,21 +451,17 @@ private AstNode ParseNodeTest(AstNode? qyInput, Axis.AxisType axisType, XPathNod
             return new Axis(axisType, qyInput, nodePrefix, nodeName, nodeType);
         }
 
-        private static bool IsPrimaryExpr(XPathScanner scanner)
-        {
-            return (
-                scanner.Kind == XPathScanner.LexKind.String ||
-                scanner.Kind == XPathScanner.LexKind.Number ||
-                scanner.Kind == XPathScanner.LexKind.Dollar ||
-                scanner.Kind == XPathScanner.LexKind.LParens ||
-                scanner.Kind == XPathScanner.LexKind.Name && scanner.CanBeFunction && !IsNodeType(scanner)
-            );
-        }
+        private bool IsPrimaryExpr =>
+            _scanner.Kind == XPathScanner.LexKind.String ||
+            _scanner.Kind == XPathScanner.LexKind.Number ||
+            _scanner.Kind == XPathScanner.LexKind.Dollar ||
+            _scanner.Kind == XPathScanner.LexKind.LParens ||
+            _scanner.Kind == XPathScanner.LexKind.Name && _scanner.CanBeFunction && !IsNodeType;
 
         //>> PrimaryExpr ::= Literal | Number | VariableReference | '(' Expr ')' | FunctionCall
         private AstNode ParsePrimaryExpr(AstNode? qyInput)
         {
-            Debug.Assert(IsPrimaryExpr(_scanner));
+            Debug.Assert(IsPrimaryExpr);
             AstNode? opnd = null;
             switch (_scanner.Kind)
             {
@@ -499,7 +489,7 @@ private AstNode ParsePrimaryExpr(AstNode? qyInput)
                     PassToken(XPathScanner.LexKind.RParens);
                     break;
                 case XPathScanner.LexKind.Name:
-                    if (_scanner.CanBeFunction && !IsNodeType(_scanner))
+                    if (_scanner.CanBeFunction && !IsNodeType)
                     {
                         opnd = ParseMethod(null);
                     }
diff --git a/src/libraries/System.Private.Xml/src/System/Xml/XPath/Internal/XPathScanner.cs b/src/libraries/System.Private.Xml/src/System/Xml/XPath/Internal/XPathScanner.cs
index 0cc53a08704259..cfe089ba53ffce 100644
--- a/src/libraries/System.Private.Xml/src/System/Xml/XPath/Internal/XPathScanner.cs
+++ b/src/libraries/System.Private.Xml/src/System/Xml/XPath/Internal/XPathScanner.cs
@@ -4,12 +4,13 @@
 using System;
 using System.Diagnostics;
 using System.Globalization;
+using System.Runtime.CompilerServices;
 using System.Xml;
 using System.Xml.XPath;
 
 namespace MS.Internal.Xml.XPath
 {
-    internal sealed class XPathScanner
+    internal struct XPathScanner
     {
         private readonly string _xpathExpr;
         private int _xpathExprIndex;
@@ -18,16 +19,17 @@ internal sealed class XPathScanner
         private string? _name;
         private string? _prefix;
         private string? _stringValue;
-        private double _numberValue = double.NaN;
+        private double _numberValue;
         private bool _canBeFunction;
 
-        public XPathScanner(string xpathExpr)
+        public XPathScanner(string xpathExpr) : this()
         {
             if (xpathExpr == null)
             {
                 throw XPathException.Create(SR.Xp_ExprExpected, string.Empty);
             }
             _xpathExpr = xpathExpr;
+            _numberValue = double.NaN;
             NextChar();
             NextLex();
         }
@@ -39,16 +41,18 @@ public XPathScanner(string xpathExpr)
         private bool NextChar()
         {
             Debug.Assert(0 <= _xpathExprIndex && _xpathExprIndex <= _xpathExpr.Length);
-            if (_xpathExprIndex < _xpathExpr.Length)
+
+            string expr = _xpathExpr;
+            int index = _xpathExprIndex;
+            if ((uint)index < (uint)expr.Length)
             {
-                _currentChar = _xpathExpr[_xpathExprIndex++];
+                _currentChar = expr[index];
+                _xpathExprIndex = index + 1;
                 return true;
             }
-            else
-            {
-                _currentChar = '\0';
-                return false;
-            }
+
+            _currentChar = '\0';
+            return false;
         }
 
         public LexKind Kind { get { return _kind; } }
@@ -104,9 +108,19 @@ public bool CanBeFunction
             }
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private void SkipSpace()
         {
-            while (XmlCharType.IsWhiteSpace(CurrentChar) && NextChar()) ;
+            if (XmlCharType.IsWhiteSpace(CurrentChar))
+            {
+                SkipKnownSpace();
+            }
+        }
+
+        private void SkipKnownSpace()
+        {
+            Debug.Assert(XmlCharType.IsWhiteSpace(CurrentChar));
+            while (NextChar() && XmlCharType.IsWhiteSpace(CurrentChar));
         }
 
         public bool NextLex()
@@ -312,23 +326,26 @@ private string ScanString()
 
         private string ScanName()
         {
-            Debug.Assert(XmlCharType.IsStartNCNameSingleChar(CurrentChar));
-            int start = _xpathExprIndex - 1;
-            int len = 0;
+            ReadOnlySpan<char> span = _xpathExpr.AsSpan(_xpathExprIndex - 1);
 
-            while (true)
+            Debug.Assert(!span.IsEmpty);
+            Debug.Assert(span[0] == CurrentChar);
+            Debug.Assert(XmlCharType.IsStartNCNameSingleChar(span[0]));
+            Debug.Assert(XmlCharType.IsNCNameSingleChar(span[0]));
+
+            int i;
+            for (i = 1; i < span.Length && XmlCharType.IsNCNameSingleChar(span[i]); i++);
+
+            if ((uint)i < (uint)span.Length)
             {
-                if (XmlCharType.IsNCNameSingleChar(CurrentChar))
-                {
-                    NextChar();
-                    len++;
-                }
-                else
-                {
-                    break;
-                }
+                _currentChar = span[i];
+                _xpathExprIndex += i;
+                return span.Slice(0, i).ToString();
             }
-            return _xpathExpr.Substring(start, len);
+
+            _currentChar = '\0';
+            _xpathExprIndex += i - 1;
+            return span.ToString();
         }
 
         public enum LexKind
diff --git a/src/libraries/System.Private.Xml/src/System/Xml/Xsl/XPathConvert.cs b/src/libraries/System.Private.Xml/src/System/Xml/Xsl/XPathConvert.cs
index ed6d5cc482e4eb..c6de12ea8bbaf7 100644
--- a/src/libraries/System.Private.Xml/src/System/Xml/Xsl/XPathConvert.cs
+++ b/src/libraries/System.Private.Xml/src/System/Xml/Xsl/XPathConvert.cs
@@ -21,12 +21,12 @@ internal static class XPathConvert
     {
         public static uint DblHi(double dbl)
         {
-            return (uint)(BitConverter.DoubleToInt64Bits(dbl) >> 32);
+            return (uint)(BitConverter.DoubleToUInt64Bits(dbl) >> 32);
         }
 
         public static uint DblLo(double dbl)
         {
-            return unchecked((uint)BitConverter.DoubleToInt64Bits(dbl));
+            return unchecked((uint)BitConverter.DoubleToUInt64Bits(dbl));
         }
 
         // Returns true if value is infinite or NaN (exponent bits are all ones)
@@ -659,7 +659,7 @@ public static explicit operator double(BigNumber bn)
                         AddU(ref dblHi, 1);
                     }
                 }
-                return BitConverter.Int64BitsToDouble((long)dblHi << 32 | dblLo);
+                return BitConverter.UInt64BitsToDouble((ulong)dblHi << 32 | dblLo);
             }
 
             // Lop off the integer part and return it.
@@ -1112,7 +1112,7 @@ public static void DblToRgbPrecise(double dbl, byte[] mantissa, out int exponent
                     dblHi = DblHi(dblT);
                     dblHi &= 0x000FFFFF;
                     dblHi |= 0x3FF00000;
-                    dblT = BitConverter.Int64BitsToDouble((long)dblHi << 32 | DblLo(dblT));
+                    dblT = BitConverter.UInt64BitsToDouble((ulong)dblHi << 32 | DblLo(dblT));
 
                     // Adjust wExp2 because we don't have the implicit bit.
                     wExp2++;
@@ -1123,7 +1123,7 @@ public static void DblToRgbPrecise(double dbl, byte[] mantissa, out int exponent
                     // First multiply by a power of 2 to get a normalized value.
                     dblHi &= 0x000FFFFF;
                     dblHi |= 0x3FF00000;
-                    dblT = BitConverter.Int64BitsToDouble((long)dblHi << 32 | dblLo);
+                    dblT = BitConverter.UInt64BitsToDouble((ulong)dblHi << 32 | dblLo);
 
                     // This is the power of 2.
                     w1 = wExp2 + 52;
@@ -2307,7 +2307,7 @@ public static explicit operator double(BigInteger bi) {
                         }
                     }
                 }
-                return BitConverter.Int64BitsToDouble((long)dblHi << 32 | dblLo);
+                return BitConverter.UInt64BitsToDouble((ulong)dblHi << 32 | dblLo);
             }
 #endif
         };
diff --git a/src/libraries/System.Private.Xml/tests/Writers/XmlWriterApi/EndOfLineHandlingTests.cs b/src/libraries/System.Private.Xml/tests/Writers/XmlWriterApi/EndOfLineHandlingTests.cs
index cc59961e185708..471ec72f5e0571 100644
--- a/src/libraries/System.Private.Xml/tests/Writers/XmlWriterApi/EndOfLineHandlingTests.cs
+++ b/src/libraries/System.Private.Xml/tests/Writers/XmlWriterApi/EndOfLineHandlingTests.cs
@@ -9,7 +9,6 @@
 
 namespace System.Xml.Tests
 {
-    [ActiveIssue("https://github.com/dotnet/runtime/issues/49365", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
     public partial class TCEOFHandling
     {
         private static NewLineHandling[] s_nlHandlingMembers = { NewLineHandling.Entitize, NewLineHandling.Replace, NewLineHandling.None };
diff --git a/src/libraries/System.Private.Xml/tests/Writers/XmlWriterApi/ErrorCondition.cs b/src/libraries/System.Private.Xml/tests/Writers/XmlWriterApi/ErrorCondition.cs
index b2bcfbb3cabc31..2fdf0402819265 100644
--- a/src/libraries/System.Private.Xml/tests/Writers/XmlWriterApi/ErrorCondition.cs
+++ b/src/libraries/System.Private.Xml/tests/Writers/XmlWriterApi/ErrorCondition.cs
@@ -10,7 +10,6 @@
 
 namespace System.Xml.Tests
 {
-    [ActiveIssue("https://github.com/dotnet/runtime/issues/49365", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
     public partial class TCErrorConditionWriter// : XmlWriterTestCaseBase
     {
         public static string file = "writerErr.out";
diff --git a/src/libraries/System.Private.Xml/tests/Writers/XmlWriterApi/WriteEndDocumentOnCloseTest.cs b/src/libraries/System.Private.Xml/tests/Writers/XmlWriterApi/WriteEndDocumentOnCloseTest.cs
index bcb77b319f4bc9..17cdd255b89d47 100644
--- a/src/libraries/System.Private.Xml/tests/Writers/XmlWriterApi/WriteEndDocumentOnCloseTest.cs
+++ b/src/libraries/System.Private.Xml/tests/Writers/XmlWriterApi/WriteEndDocumentOnCloseTest.cs
@@ -7,7 +7,6 @@
 
 namespace System.Xml.Tests
 {
-    [ActiveIssue("https://github.com/dotnet/runtime/issues/49365", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
     public partial class TCWriteEndDocumentOnCloseTest
     {
         [Theory]
diff --git a/src/libraries/System.Private.Xml/tests/XmlReader/Tests/AsyncReaderLateInitTests.cs b/src/libraries/System.Private.Xml/tests/XmlReader/Tests/AsyncReaderLateInitTests.cs
index eeb087178f0248..4ae64a408c6e8d 100644
--- a/src/libraries/System.Private.Xml/tests/XmlReader/Tests/AsyncReaderLateInitTests.cs
+++ b/src/libraries/System.Private.Xml/tests/XmlReader/Tests/AsyncReaderLateInitTests.cs
@@ -93,6 +93,7 @@ public static void InitializationWithUriOnNonAsyncReaderThrows()
         }
 
         [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsThreadingSupported))]
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/53987", TestRuntimes.Mono)]
         public static void SynchronizationContextCurrent_NotUsedForAsyncOperations()
         {
             Task.Run(() =>
diff --git a/src/libraries/System.Private.Xml/tests/Xslt/XsltCompiler/CommonScenarios/XsltcTestCaseBase.cs b/src/libraries/System.Private.Xml/tests/Xslt/XsltCompiler/CommonScenarios/XsltcTestCaseBase.cs
index 4c469be1b3e7d7..fba4559896cc56 100644
--- a/src/libraries/System.Private.Xml/tests/Xslt/XsltCompiler/CommonScenarios/XsltcTestCaseBase.cs
+++ b/src/libraries/System.Private.Xml/tests/Xslt/XsltCompiler/CommonScenarios/XsltcTestCaseBase.cs
@@ -72,11 +72,6 @@ protected static void CompareOutput(string expected, Stream actualStream)
             }
         }
 
-        private static string NormalizeLineEndings(string s)
-        {
-            return s.Replace("\r\n", "\n").Replace("\r", "\n");
-        }
-
         protected static void CompareOutput(Stream expectedStream, Stream actualStream, int count = 0)
         {
             actualStream.Seek(0, SeekOrigin.Begin);
@@ -90,8 +85,8 @@ protected static void CompareOutput(Stream expectedStream, Stream actualStream,
                     expectedReader.ReadLine();
                 }
 
-                string actual = NormalizeLineEndings(actualReader.ReadToEnd());
-                string expected = NormalizeLineEndings(expectedReader.ReadToEnd());
+                string actual = actualReader.ReadToEnd().ReplaceLineEndings();
+                string expected = expectedReader.ReadToEnd().ReplaceLineEndings();
 
                 if (actual.Equals(expected))
                 {
diff --git a/src/libraries/System.Reflection.Metadata/src/System.Reflection.Metadata.csproj b/src/libraries/System.Reflection.Metadata/src/System.Reflection.Metadata.csproj
index b07bbd75ebac27..654ed3f9062797 100644
--- a/src/libraries/System.Reflection.Metadata/src/System.Reflection.Metadata.csproj
+++ b/src/libraries/System.Reflection.Metadata/src/System.Reflection.Metadata.csproj
@@ -4,7 +4,6 @@
     <DefaultLanguage>en-US</DefaultLanguage>
     <CLSCompliant>false</CLSCompliant>
     <TargetFrameworks>$(NetCoreAppCurrent);netstandard2.0;net461</TargetFrameworks>
-    <ExcludeCurrentNetCoreAppFromPackage>true</ExcludeCurrentNetCoreAppFromPackage>
     <Nullable>enable</Nullable>
   </PropertyGroup>
   <!-- DesignTimeBuild requires all the TargetFramework Derived Properties to not be present in the first property group. -->
@@ -15,10 +14,10 @@
   <ItemGroup>
     <Compile Include="$(CommonPath)Interop\Windows\Interop.Libraries.cs"
              Link="Common\Interop\Windows\Interop.Libraries.cs"
-             Condition="'$(TargetFrameworkIdentifier)' != '.NETCoreApp' "/>
+             Condition="'$(TargetFrameworkIdentifier)' != '.NETCoreApp'" />
     <Compile Include="$(CommonPath)Interop\Windows\Kernel32\Interop.ReadFile_SafeHandle_IntPtr.cs"
              Link="Common\Interop\Windows\kernel32\Interop.ReadFile_SafeHandle_IntPtr.cs"
-             Condition="'$(TargetFrameworkIdentifier)' != '.NETCoreApp' "/>
+             Condition="'$(TargetFrameworkIdentifier)' != '.NETCoreApp'" />
     <Compile Include="System\Reflection\Internal\Utilities\PinnedObject.cs" />
     <Compile Include="System\Reflection\Internal\Utilities\CriticalDisposableObject.cs" />
     <Compile Include="System\Reflection\Internal\Utilities\ExceptionUtilities.cs" />
diff --git a/src/libraries/System.Reflection.MetadataLoadContext/ref/System.Reflection.MetadataLoadContext.csproj b/src/libraries/System.Reflection.MetadataLoadContext/ref/System.Reflection.MetadataLoadContext.csproj
index c065d83b357a6e..fe4145d630c001 100644
--- a/src/libraries/System.Reflection.MetadataLoadContext/ref/System.Reflection.MetadataLoadContext.csproj
+++ b/src/libraries/System.Reflection.MetadataLoadContext/ref/System.Reflection.MetadataLoadContext.csproj
@@ -1,9 +1,15 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFrameworks>netstandard2.0;net461</TargetFrameworks>
+    <TargetFrameworks>$(NetCoreAppCurrent);netcoreapp3.1;netstandard2.0;net461</TargetFrameworks>
     <Nullable>enable</Nullable>
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="System.Reflection.MetadataLoadContext.cs" />
   </ItemGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == '$(NetCoreAppCurrent)'">
+    <ProjectReference Include="$(LibrariesProjectRoot)System.Runtime\ref\System.Runtime.csproj" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == 'netcoreapp3.1'">
+    <Reference Include="System.Runtime" />
+  </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/src/libraries/System.Reflection.MetadataLoadContext/src/System.Reflection.MetadataLoadContext.csproj b/src/libraries/System.Reflection.MetadataLoadContext/src/System.Reflection.MetadataLoadContext.csproj
index 2ef7aa05aedc33..2052687cb978e5 100644
--- a/src/libraries/System.Reflection.MetadataLoadContext/src/System.Reflection.MetadataLoadContext.csproj
+++ b/src/libraries/System.Reflection.MetadataLoadContext/src/System.Reflection.MetadataLoadContext.csproj
@@ -4,7 +4,6 @@
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <!-- Only the netcoreapp version supports the new reflection apis (IsSZArray, etc.) -->
     <TargetFrameworks>$(NetCoreAppCurrent);netcoreapp3.1;netstandard2.0;net461</TargetFrameworks>
-    <ExcludeCurrentNetCoreAppFromPackage>true</ExcludeCurrentNetCoreAppFromPackage>
     <Nullable>enable</Nullable>
   </PropertyGroup>
   <ItemGroup>
@@ -150,6 +149,7 @@
     <ProjectReference Include="$(LibrariesProjectRoot)System.Reflection.Metadata\src\System.Reflection.Metadata.csproj" />
   </ItemGroup>
   <ItemGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp'">
+    <Reference Include="netstandard" Condition="'$(TargetFramework)' == 'netcoreapp3.1'" />
     <Reference Include="System.Collections" />
     <Reference Include="System.Collections.Concurrent" />
     <Reference Include="System.Diagnostics.Debug" />
diff --git a/src/libraries/System.Reflection.TypeExtensions/src/System.Reflection.TypeExtensions.csproj b/src/libraries/System.Reflection.TypeExtensions/src/System.Reflection.TypeExtensions.csproj
index 8668954a3efb49..3e598d9015c00a 100644
--- a/src/libraries/System.Reflection.TypeExtensions/src/System.Reflection.TypeExtensions.csproj
+++ b/src/libraries/System.Reflection.TypeExtensions/src/System.Reflection.TypeExtensions.csproj
@@ -3,7 +3,6 @@
     <IsPartialFacadeAssembly>true</IsPartialFacadeAssembly>
     <Nullable>enable</Nullable>
     <TargetFrameworks>$(NetCoreAppCurrent)</TargetFrameworks>
-    <ExcludeCurrentNetCoreAppFromPackage>true</ExcludeCurrentNetCoreAppFromPackage>
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="System\Reflection\Requires.cs" />
diff --git a/src/libraries/System.Reflection/tests/TypeInfoTests.cs b/src/libraries/System.Reflection/tests/TypeInfoTests.cs
index 4e3603c2f3aa9c..f3b9240505c69b 100644
--- a/src/libraries/System.Reflection/tests/TypeInfoTests.cs
+++ b/src/libraries/System.Reflection/tests/TypeInfoTests.cs
@@ -5,6 +5,8 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Reflection.Emit;
+using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using Xunit;
 
@@ -1565,6 +1567,70 @@ public void IsSZArray(Type type, bool expected)
             Assert.Equal(expected, type.GetTypeInfo().IsSZArray);
         }
 
+        public static IEnumerable<object[]> GetMemberWithSameMetadataDefinitionAsData()
+        {
+            yield return new object[] { typeof(TI_GenericTypeWithAllMembers<>), typeof(TI_GenericTypeWithAllMembers<int>), true };
+            yield return new object[] { typeof(TI_GenericTypeWithAllMembers<>), typeof(TI_GenericTypeWithAllMembers<ClassWithMultipleConstructors>), true};
+
+            yield return new object[] { typeof(TI_GenericTypeWithAllMembers<>), typeof(TI_TypeDerivedFromGenericTypeWithAllMembers<int>), false };
+            yield return new object[] { typeof(TI_GenericTypeWithAllMembers<>), typeof(TI_TypeDerivedFromGenericTypeWithAllMembers<ClassWithMultipleConstructors>), false };
+
+            yield return new object[] { typeof(TI_GenericTypeWithAllMembers<>), typeof(TI_TypeDerivedFromGenericTypeWithAllMembersClosed), false };
+
+            static TypeInfo GetTypeDelegator(Type t) => new TypeDelegator(t);
+            yield return new object[] { GetTypeDelegator(typeof(TI_GenericTypeWithAllMembers<>)), typeof(TI_GenericTypeWithAllMembers<ClassWithMultipleConstructors>), true };
+            yield return new object[] { typeof(TI_GenericTypeWithAllMembers<>), GetTypeDelegator(typeof(TI_GenericTypeWithAllMembers<ClassWithMultipleConstructors>)), true };
+            yield return new object[] { GetTypeDelegator(typeof(TI_GenericTypeWithAllMembers<>)), GetTypeDelegator(typeof(TI_GenericTypeWithAllMembers<ClassWithMultipleConstructors>)), true };
+
+            if (RuntimeFeature.IsDynamicCodeSupported)
+            {
+                (Type generatedType1, Type generatedType2) = CreateGeneratedTypes();
+
+                yield return new object[] { generatedType1, generatedType2, true };
+                yield return new object[] { generatedType2, generatedType1, true };
+            }
+        }
+
+        private static (Type, Type) CreateGeneratedTypes()
+        {
+            AssemblyBuilder assembly = AssemblyBuilder.DefineDynamicAssembly(new AssemblyName("GetMemberWithSameMetadataDefinitionAsGeneratedAssembly"), AssemblyBuilderAccess.Run);
+            ModuleBuilder module = assembly.DefineDynamicModule("GetMemberWithSameMetadataDefinitionAsGeneratedModule");
+            TypeBuilder genericType = module.DefineType("GenericGeneratedType");
+            genericType.DefineGenericParameters("T0");
+            genericType.DefineField("_int", typeof(int), FieldAttributes.Private);
+            genericType.DefineProperty("Prop", PropertyAttributes.None, typeof(string), null);
+
+            Type builtGenericType = genericType.CreateType();
+            Type closedType = builtGenericType.MakeGenericType(typeof(int));
+
+            return (genericType, closedType);
+        }
+
+        [Theory, MemberData(nameof(GetMemberWithSameMetadataDefinitionAsData))]
+        public void GetMemberWithSameMetadataDefinitionAs(Type openGenericType, Type closedGenericType, bool checkDeclaringType)
+        {
+            BindingFlags all = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance | BindingFlags.DeclaredOnly;
+            foreach (MemberInfo openGenericMember in openGenericType.GetMembers(all))
+            {
+                MemberInfo closedGenericMember = closedGenericType.GetMemberWithSameMetadataDefinitionAs(openGenericMember);
+                Assert.True(closedGenericMember != null, $"'{openGenericMember.Name}' was not found");
+                Assert.True(closedGenericMember.HasSameMetadataDefinitionAs(openGenericMember));
+                Assert.Equal(closedGenericMember.Name, openGenericMember.Name);
+                if (checkDeclaringType && openGenericMember is not Type)
+                {
+                    Assert.True(closedGenericMember.DeclaringType.Equals(closedGenericType), $"'{closedGenericMember.Name}' doesn't have the right DeclaringType");
+                }
+            }
+
+            MemberInfo toString = closedGenericType.GetMemberWithSameMetadataDefinitionAs(typeof(object).GetMethod("ToString"));
+            Assert.NotNull(toString);
+            Assert.IsAssignableFrom<MethodInfo>(toString);
+            Assert.Equal("ToString", toString.Name);
+
+            Assert.Throws<ArgumentNullException>(() => openGenericType.GetMemberWithSameMetadataDefinitionAs(null));
+            Assert.Throws<ArgumentException>(() => openGenericType.GetMemberWithSameMetadataDefinitionAs(typeof(string).GetMethod("get_Length")));
+        }
+
 #pragma warning disable 0067, 0169
         public static class ClassWithStaticConstructor
         {
@@ -1815,6 +1881,54 @@ public abstract class AbstractBaseClass { }
         public abstract class AbstractSubClass : AbstractBaseClass { }
         public class AbstractSubSubClass : AbstractSubClass { }
     }
+
+    public class TI_GenericTypeWithAllMembers<T>
+    {
+        private static event EventHandler<T> PrivateStaticEvent;
+        private static T PrivateStaticField;
+        private static T PrivateStaticProperty { get; set; }
+        private static T PrivateStaticMethod(T t) => default;
+        private static T PrivateStaticMethod(T t, T t2) => default;
+
+        public static event EventHandler<T> PublicStaticEvent;
+        public static T PublicStaticField;
+        public static T PublicStaticProperty { get; set; }
+        public static T PublicStaticMethod(T t) => default;
+        public static T PublicStaticMethod(T t, T t2) => default;
+
+        static TI_GenericTypeWithAllMembers() { }
+
+        public TI_GenericTypeWithAllMembers(T t) { }
+        private TI_GenericTypeWithAllMembers() { }
+
+        public event EventHandler<T> PublicInstanceEvent;
+        public T PublicInstanceField;
+        public T PublicInstanceProperty { get; set; }
+        public T PublicInstanceMethod(T t) => default;
+        public T PublicInstanceMethod(T t, T t2) => default;
+
+        private event EventHandler<T> PrivateInstanceEvent;
+        private T PrivateInstanceField;
+        private T PrivateInstanceProperty { get; set; }
+        private T PrivateInstanceMethod(T t) => default;
+        private T PrivateInstanceMethod(T t1, T t2) => default;
+
+        public class Nested
+        {
+            public T NestedField;
+        }
+    }
+
+    public class TI_TypeDerivedFromGenericTypeWithAllMembers<T> : TI_GenericTypeWithAllMembers<T>
+    {
+        public TI_TypeDerivedFromGenericTypeWithAllMembers(T t) : base(t) { }
+    }
+
+    public class TI_TypeDerivedFromGenericTypeWithAllMembersClosed : TI_TypeDerivedFromGenericTypeWithAllMembers<int>
+    {
+        public TI_TypeDerivedFromGenericTypeWithAllMembersClosed(int t) : base(t) { }
+    }
+
 #pragma warning restore 0067, 0169
 
     public class OutsideTypeInfoTests
diff --git a/src/libraries/System.Runtime.Caching/Directory.Build.props b/src/libraries/System.Runtime.Caching/Directory.Build.props
index 826e3102fb1e63..749494404d83e9 100644
--- a/src/libraries/System.Runtime.Caching/Directory.Build.props
+++ b/src/libraries/System.Runtime.Caching/Directory.Build.props
@@ -6,6 +6,7 @@
          to a different assembly. -->
     <AssemblyVersion>4.0.0.0</AssemblyVersion>
     <StrongNameKeyId>Microsoft</StrongNameKeyId>
+    <IncludePlatformAttributes>true</IncludePlatformAttributes>
     <PackageDescription>Provides classes to use caching facilities.
 
 Commonly Used Types:
diff --git a/src/libraries/System.Runtime.Caching/ref/System.Runtime.Caching.csproj b/src/libraries/System.Runtime.Caching/ref/System.Runtime.Caching.csproj
index 32f5458551f673..2823f200169089 100644
--- a/src/libraries/System.Runtime.Caching/ref/System.Runtime.Caching.csproj
+++ b/src/libraries/System.Runtime.Caching/ref/System.Runtime.Caching.csproj
@@ -1,10 +1,14 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFrameworks>netcoreapp3.1;netstandard2.0</TargetFrameworks>
+    <TargetFrameworks>$(NetCoreAppCurrent);netcoreapp3.1;netstandard2.0</TargetFrameworks>
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="System.Runtime.Caching.cs" />
   </ItemGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == '$(NetCoreAppCurrent)'">
+    <ProjectReference Include="$(LibrariesProjectRoot)System.ComponentModel\ref\System.ComponentModel.csproj" />
+    <ProjectReference Include="$(LibrariesProjectRoot)System.Collections.Specialized\ref\System.Collections.Specialized.csproj" />
+  </ItemGroup>
   <ItemGroup Condition="'$(TargetFramework)' == 'netcoreapp3.1'">
     <Reference Include="System.Collections" />
     <Reference Include="System.Collections.Specialized" />
diff --git a/src/libraries/System.Runtime.Caching/src/System.Runtime.Caching.csproj b/src/libraries/System.Runtime.Caching/src/System.Runtime.Caching.csproj
index 8d6b815161d0d6..0c059eae7c103b 100644
--- a/src/libraries/System.Runtime.Caching/src/System.Runtime.Caching.csproj
+++ b/src/libraries/System.Runtime.Caching/src/System.Runtime.Caching.csproj
@@ -1,32 +1,8 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <TargetFrameworks>netcoreapp3.1;netcoreapp3.1-windows;netstandard2.0;netstandard2.0-windows</TargetFrameworks>
-    <IncludePlatformAttributes>true</IncludePlatformAttributes>
+    <TargetFrameworks>$(NetCoreAppCurrent)-windows;$(NetCoreAppCurrent);netcoreapp3.1-windows;netcoreapp3.1;netstandard2.0-windows;netstandard2.0</TargetFrameworks>
   </PropertyGroup>
-  <ItemGroup Condition="'$(TargetFramework)' == 'netcoreapp3.1' or '$(TargetFramework)' == 'netcoreapp3.1-windows'">
-    <Reference Include="System.Collections" />
-    <Reference Include="System.Collections.NonGeneric" />
-    <Reference Include="System.Collections.Specialized" />
-    <Reference Include="System.ComponentModel" />
-    <Reference Include="System.ComponentModel.Primitives" />
-    <Reference Include="System.ComponentModel.TypeConverter" />
-    <Reference Include="System.Data.Common" />
-    <Reference Include="System.Diagnostics.Debug" />
-    <Reference Include="System.Diagnostics.Tracing" />
-    <Reference Include="System.IO.FileSystem" />
-    <Reference Include="System.IO.FileSystem.Watcher" />
-    <Reference Include="System.ObjectModel" />
-    <Reference Include="System.Resources.ResourceManager" />
-    <Reference Include="System.Runtime" />
-    <Reference Include="System.Runtime.Extensions" />
-    <Reference Include="System.Runtime.InteropServices" />
-    <Reference Include="System.Runtime.InteropServices.RuntimeInformation" />
-    <Reference Include="System.Text.RegularExpressions" />
-    <Reference Include="System.Threading" />
-    <Reference Include="System.Threading.Thread" />
-    <Reference Include="System.Threading.Timer" />
-  </ItemGroup>
   <ItemGroup>
     <Compile Include="System\Runtime\Caching\Counters.cs" />
     <Compile Include="System\Runtime\Caching\CacheEntryChangeMonitor.cs" />
@@ -75,6 +51,7 @@
   <ItemGroup Condition="'$(TargetsWindows)' == 'true'">
     <Compile Include="System\Runtime\Caching\MemoryMonitor.Windows.cs" />
     <Compile Include="System\Runtime\Caching\PhysicalMemoryMonitor.Windows.cs" />
+    <Compile Include="$(CommonPath)Interop\Windows\Interop.BOOL.cs" Link="Common\Interop\Windows\Interop.BOOL.cs" />
     <Compile Include="$(CommonPath)Interop\Windows\Kernel32\Interop.GlobalMemoryStatusEx.cs" Link="Common\Interop\Windows\Kernel32\Interop.GlobalMemoryStatusEx.cs" />
     <Compile Include="$(CommonPath)Interop\Windows\Kernel32\Interop.MEMORYSTATUSEX.cs" Link="Common\Interop\Windows\Kernel32\Interop.MEMORYSTATUSEX.cs" />
     <Compile Include="$(CommonPath)Interop\Windows\Interop.Libraries.cs" Link="Common\Interop\Windows\Interop.Libraries.cs" />
@@ -82,7 +59,31 @@
   <ItemGroup Condition="'$(TargetsWindows)' != 'true'">
     <Compile Include="System\Runtime\Caching\PhysicalMemoryMonitor.Unix.cs" />
   </ItemGroup>
+  <ItemGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp'">
+    <Reference Include="netstandard" Condition="$(TargetFramework.StartsWith('netcoreapp3.1'))" />
+    <Reference Include="System.Collections" />
+    <Reference Include="System.Collections.NonGeneric" />
+    <Reference Include="System.Collections.Specialized" />
+    <Reference Include="System.ComponentModel" />
+    <Reference Include="System.ComponentModel.Primitives" />
+    <Reference Include="System.ComponentModel.TypeConverter" />
+    <Reference Include="System.Data.Common" />
+    <Reference Include="System.Diagnostics.Debug" />
+    <Reference Include="System.Diagnostics.Tracing" />
+    <Reference Include="System.IO.FileSystem" />
+    <Reference Include="System.IO.FileSystem.Watcher" />
+    <Reference Include="System.ObjectModel" />
+    <Reference Include="System.Resources.ResourceManager" />
+    <Reference Include="System.Runtime" />
+    <Reference Include="System.Runtime.Extensions" />
+    <Reference Include="System.Runtime.InteropServices" />
+    <Reference Include="System.Runtime.InteropServices.RuntimeInformation" />
+    <Reference Include="System.Text.RegularExpressions" />
+    <Reference Include="System.Threading" />
+    <Reference Include="System.Threading.Thread" />
+    <Reference Include="System.Threading.Timer" />
+  </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="$(LibrariesProjectRoot)System.Configuration.ConfigurationManager\src\System.Configuration.ConfigurationManager.csproj" />
   </ItemGroup>
-</Project>
\ No newline at end of file
+</Project>
diff --git a/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/Configuration/CachingSectionGroup.cs b/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/Configuration/CachingSectionGroup.cs
index 3452f76c6ee743..02f8559b06f9ee 100644
--- a/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/Configuration/CachingSectionGroup.cs
+++ b/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/Configuration/CachingSectionGroup.cs
@@ -3,9 +3,13 @@
 
 using System;
 using System.Configuration;
+using System.Runtime.Versioning;
 
 namespace System.Runtime.Caching.Configuration
 {
+#if NET5_0_OR_GREATER
+    [UnsupportedOSPlatform("browser")]
+#endif
     internal sealed class CachingSectionGroup : ConfigurationSectionGroup
     {
         public CachingSectionGroup()
diff --git a/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/Configuration/MemoryCacheElement.cs b/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/Configuration/MemoryCacheElement.cs
index 26d0880d0ea291..cf798f20416bf7 100644
--- a/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/Configuration/MemoryCacheElement.cs
+++ b/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/Configuration/MemoryCacheElement.cs
@@ -4,9 +4,13 @@
 using System;
 using System.ComponentModel;
 using System.Configuration;
+using System.Runtime.Versioning;
 
 namespace System.Runtime.Caching.Configuration
 {
+#if NET5_0_OR_GREATER
+    [UnsupportedOSPlatform("browser")]
+#endif
     internal sealed class MemoryCacheElement : ConfigurationElement
     {
         private static readonly ConfigurationProperty s_propName =
diff --git a/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/Configuration/MemoryCacheSection.cs b/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/Configuration/MemoryCacheSection.cs
index 563f3ccfa4eee2..df535cd6bc4a88 100644
--- a/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/Configuration/MemoryCacheSection.cs
+++ b/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/Configuration/MemoryCacheSection.cs
@@ -5,6 +5,7 @@
 using System.Collections.Specialized;
 using System.Configuration;
 using System.Runtime.Caching.Resources;
+using System.Runtime.Versioning;
 
 namespace System.Runtime.Caching.Configuration
 {
@@ -20,6 +21,9 @@ namespace System.Runtime.Caching.Configuration
        </system.caching>
     */
 
+#if NET5_0_OR_GREATER
+    [UnsupportedOSPlatform("browser")]
+#endif
     internal sealed class MemoryCacheSection : ConfigurationSection
     {
         private static readonly ConfigurationProperty s_propNamedCaches = new ConfigurationProperty("namedCaches",
diff --git a/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/Configuration/MemoryCacheSettingsCollection.cs b/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/Configuration/MemoryCacheSettingsCollection.cs
index 7a34adf7b07782..8c08a0bfcda7e1 100644
--- a/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/Configuration/MemoryCacheSettingsCollection.cs
+++ b/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/Configuration/MemoryCacheSettingsCollection.cs
@@ -3,9 +3,13 @@
 
 using System;
 using System.Configuration;
+using System.Runtime.Versioning;
 
 namespace System.Runtime.Caching.Configuration
 {
+#if NET5_0_OR_GREATER
+    [UnsupportedOSPlatform("browser")]
+#endif
     [ConfigurationCollection(typeof(MemoryCacheElement),
     CollectionType = ConfigurationElementCollectionType.AddRemoveClearMap)]
     internal sealed class MemoryCacheSettingsCollection : ConfigurationElementCollection
diff --git a/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/Counters.cs b/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/Counters.cs
index a6845ec85cb6a2..5e8a3712054f9b 100644
--- a/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/Counters.cs
+++ b/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/Counters.cs
@@ -5,9 +5,13 @@
 using System.Collections.Generic;
 using System.Diagnostics.Tracing;
 using System.Threading;
+using System.Runtime.Versioning;
 
 namespace System.Runtime.Caching
 {
+#if NET5_0_OR_GREATER
+    [UnsupportedOSPlatform("browser")]
+#endif
     internal sealed class Counters : EventSource
     {
 #if NETCOREAPP3_1_OR_GREATER
diff --git a/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/FileChangeNotificationSystem.cs b/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/FileChangeNotificationSystem.cs
index 339169a4c45ed5..497017c14e7352 100644
--- a/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/FileChangeNotificationSystem.cs
+++ b/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/FileChangeNotificationSystem.cs
@@ -7,9 +7,13 @@
 using System.Collections;
 using System.IO;
 using System.Security;
+using System.Runtime.Versioning;
 
 namespace System.Runtime.Caching
 {
+#if NET5_0_OR_GREATER
+    [UnsupportedOSPlatform("browser")]
+#endif
     internal sealed class FileChangeNotificationSystem : IFileChangeNotificationSystem
     {
         private readonly Hashtable _dirMonitors;
diff --git a/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/HostFileChangeMonitor.cs b/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/HostFileChangeMonitor.cs
index c354604ea89c7b..c80daaac7a8f38 100644
--- a/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/HostFileChangeMonitor.cs
+++ b/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/HostFileChangeMonitor.cs
@@ -97,6 +97,13 @@ private static void InitFCN()
                 }
                 if (fcn == null)
                 {
+#if NET5_0_OR_GREATER
+                    if (OperatingSystem.IsBrowser())
+                    {
+                        throw new PlatformNotSupportedException();
+                    }
+#endif
+
                     fcn = new FileChangeNotificationSystem();
                 }
                 Interlocked.CompareExchange(ref s_fcn, fcn, null);
diff --git a/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/MemoryCache.cs b/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/MemoryCache.cs
index 31d3db6e697a35..72d92119acd795 100644
--- a/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/MemoryCache.cs
+++ b/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/MemoryCache.cs
@@ -13,6 +13,7 @@
 using System.Security;
 using System.Threading;
 using System.Diagnostics;
+using System.Runtime.Versioning;
 
 namespace System.Runtime.Caching
 {
@@ -38,6 +39,12 @@ public class MemoryCache : ObjectCache, IEnumerable, IDisposable
         private bool _useMemoryCacheManager = true;
         private EventHandler _onAppDomainUnload;
         private UnhandledExceptionEventHandler _onUnhandledException;
+#if NET5_0_OR_GREATER
+        [UnsupportedOSPlatformGuard("browser")]
+        private static bool _countersSupported => !OperatingSystem.IsBrowser();
+#else
+        private static bool _countersSupported => true;
+#endif
 
         private bool IsDisposed { get { return (_disposed == 1); } }
         internal bool ConfigLess { get { return _configLess; } }
@@ -196,7 +203,10 @@ private void InitDisposableMembers(NameValueCollection config)
             {
                 try
                 {
-                    _perfCounters = new Counters(_name);
+                    if (_countersSupported)
+                    {
+                        _perfCounters = new Counters(_name);
+                    }
                 }
                 catch
                 {
@@ -481,7 +491,10 @@ public void Dispose()
                 }
                 if (_perfCounters != null)
                 {
-                    _perfCounters.Dispose();
+                    if (_countersSupported)
+                    {
+                        _perfCounters.Dispose();
+                    }
                 }
                 GC.SuppressFinalize(this);
             }
diff --git a/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/MemoryCacheStatistics.cs b/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/MemoryCacheStatistics.cs
index b5cb20db3924e9..107c46f0158c9c 100644
--- a/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/MemoryCacheStatistics.cs
+++ b/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/MemoryCacheStatistics.cs
@@ -8,6 +8,7 @@
 using System.Globalization;
 using System.Runtime.Caching.Configuration;
 using System.Runtime.InteropServices;
+using System.Runtime.Versioning;
 using System.Security;
 using System.Threading;
 
@@ -36,6 +37,12 @@ internal sealed class MemoryCacheStatistics : IDisposable
         private CacheMemoryMonitor _cacheMemoryMonitor;
         private readonly MemoryCache _memoryCache;
         private readonly PhysicalMemoryMonitor _physicalMemoryMonitor;
+#if NET5_0_OR_GREATER
+        [UnsupportedOSPlatformGuard("browser")]
+        private static bool _configSupported => !OperatingSystem.IsBrowser();
+#else
+        private static bool _configSupported => true;
+#endif
 
         // private
 
@@ -117,7 +124,7 @@ private int GetPercentToTrim()
         private void InitializeConfiguration(NameValueCollection config)
         {
             MemoryCacheElement element = null;
-            if (!_memoryCache.ConfigLess)
+            if (!_memoryCache.ConfigLess && _configSupported)
             {
                 MemoryCacheSection section = ConfigurationManager.GetSection("system.runtime.caching/memoryCache") as MemoryCacheSection;
                 if (section != null)
@@ -126,7 +133,7 @@ private void InitializeConfiguration(NameValueCollection config)
                 }
             }
 
-            if (element != null)
+            if (element != null && _configSupported)
             {
                 _configCacheMemoryLimitMegabytes = element.CacheMemoryLimitMegabytes;
                 _configPhysicalMemoryLimitPercentage = element.PhysicalMemoryLimitPercentage;
diff --git a/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/MemoryCacheStore.cs b/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/MemoryCacheStore.cs
index 47e5de9926241f..047bc8fd80e4f7 100644
--- a/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/MemoryCacheStore.cs
+++ b/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/MemoryCacheStore.cs
@@ -8,6 +8,7 @@
 using System.Diagnostics;
 using System.Security;
 using System.Diagnostics.CodeAnalysis;
+using System.Runtime.Versioning;
 
 namespace System.Runtime.Caching
 {
@@ -25,6 +26,12 @@ internal sealed class MemoryCacheStore : IDisposable
         private volatile bool _useInsertBlock;
         private readonly MemoryCache _cache;
         private readonly Counters _perfCounters;
+#if NET5_0_OR_GREATER
+        [UnsupportedOSPlatformGuard("browser")]
+        private static bool _countersSupported => !OperatingSystem.IsBrowser();
+#else
+        private static bool _countersSupported => true;
+#endif
 
         internal MemoryCacheStore(MemoryCache cache, Counters perfCounters)
         {
@@ -73,7 +80,7 @@ private void AddToCache(MemoryCacheEntry entry)
             }
 
             entry.CallNotifyOnChanged();
-            if (_perfCounters != null)
+            if (_perfCounters != null && _countersSupported)
             {
                 _perfCounters.Increment(CounterName.Entries);
                 _perfCounters.Increment(CounterName.Turnover);
@@ -108,7 +115,7 @@ private void RemoveFromCache(MemoryCacheEntry entry, CacheEntryRemovedReason rea
                 {
                     entry.Release(_cache, reason);
                 }
-                if (_perfCounters != null)
+                if (_perfCounters != null && _countersSupported)
                 {
                     _perfCounters.Decrement(CounterName.Entries);
                     _perfCounters.Increment(CounterName.Turnover);
@@ -136,7 +143,7 @@ internal void UpdateExpAndUsage(MemoryCacheEntry entry, bool updatePerfCounters
                 // keep the sentinel from expiring, which in turn would force a removal of this entry from the cache.
                 entry.UpdateSlidingExpForUpdateSentinel();
 
-                if (updatePerfCounters && _perfCounters != null)
+                if (updatePerfCounters && _perfCounters != null && _countersSupported)
                 {
                     _perfCounters.Increment(CounterName.Hits);
                     _perfCounters.Increment(CounterName.HitRatio);
@@ -145,7 +152,7 @@ internal void UpdateExpAndUsage(MemoryCacheEntry entry, bool updatePerfCounters
             }
             else
             {
-                if (updatePerfCounters && _perfCounters != null)
+                if (updatePerfCounters && _perfCounters != null && _countersSupported)
                 {
                     _perfCounters.Increment(CounterName.Misses);
                     _perfCounters.Increment(CounterName.HitRatioBase);
@@ -404,7 +411,7 @@ internal long TrimInternal(int percent)
                 trimmedOrExpired += trimmed;
             }
 
-            if (trimmed > 0 && _perfCounters != null)
+            if (trimmed > 0 && _perfCounters != null && _countersSupported)
             {
                 // Update values for perfcounters
                 _perfCounters.IncrementBy(CounterName.Trims, trimmed);
diff --git a/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/MemoryMonitor.Windows.cs b/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/MemoryMonitor.Windows.cs
index 189a9460d32c56..acb8bb0f42290b 100644
--- a/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/MemoryMonitor.Windows.cs
+++ b/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/MemoryMonitor.Windows.cs
@@ -16,7 +16,7 @@ static unsafe MemoryMonitor()
         {
             Interop.Kernel32.MEMORYSTATUSEX memoryStatus = default;
             memoryStatus.dwLength = (uint)sizeof(Interop.Kernel32.MEMORYSTATUSEX);
-            if (Interop.Kernel32.GlobalMemoryStatusEx(ref memoryStatus))
+            if (Interop.Kernel32.GlobalMemoryStatusEx(&memoryStatus) != Interop.BOOL.FALSE)
             {
                 s_totalPhysical = (long)memoryStatus.ullTotalPhys;
                 s_totalVirtual = (long)memoryStatus.ullTotalVirtual;
diff --git a/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/PhysicalMemoryMonitor.Windows.cs b/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/PhysicalMemoryMonitor.Windows.cs
index 078bf9ed3794ee..6aff99b66b19d3 100644
--- a/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/PhysicalMemoryMonitor.Windows.cs
+++ b/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/PhysicalMemoryMonitor.Windows.cs
@@ -14,7 +14,7 @@ protected override unsafe int GetCurrentPressure()
         {
             Interop.Kernel32.MEMORYSTATUSEX memoryStatus = default;
             memoryStatus.dwLength = (uint)sizeof(Interop.Kernel32.MEMORYSTATUSEX);
-            if (!Interop.Kernel32.GlobalMemoryStatusEx(ref memoryStatus))
+            if (Interop.Kernel32.GlobalMemoryStatusEx(&memoryStatus) == Interop.BOOL.FALSE)
             {
                 return 0;
             }
diff --git a/src/libraries/System.Runtime.CompilerServices.Unsafe/ref/System.Runtime.CompilerServices.Unsafe.csproj b/src/libraries/System.Runtime.CompilerServices.Unsafe/ref/System.Runtime.CompilerServices.Unsafe.csproj
index 50264a40f84c38..766ea9a8ae7fec 100644
--- a/src/libraries/System.Runtime.CompilerServices.Unsafe/ref/System.Runtime.CompilerServices.Unsafe.csproj
+++ b/src/libraries/System.Runtime.CompilerServices.Unsafe/ref/System.Runtime.CompilerServices.Unsafe.csproj
@@ -3,9 +3,15 @@
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <CLSCompliant>false</CLSCompliant>
     <Nullable>enable</Nullable>
-    <TargetFrameworks>netstandard2.1;netstandard2.0;net461</TargetFrameworks>
+    <TargetFrameworks>$(NetCoreAppCurrent);netcoreapp3.1;netstandard2.1;netstandard2.0;net461</TargetFrameworks>
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="System.Runtime.CompilerServices.Unsafe.cs" />
   </ItemGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == '$(NetCoreAppCurrent)'">
+    <ProjectReference Include="$(LibrariesProjectRoot)System.Runtime\ref\System.Runtime.csproj" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == 'netcoreapp3.1'">
+    <Reference Include="System.Runtime" />
+  </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/src/libraries/System.Runtime.CompilerServices.Unsafe/src/System.Runtime.CompilerServices.Unsafe.ilproj b/src/libraries/System.Runtime.CompilerServices.Unsafe/src/System.Runtime.CompilerServices.Unsafe.ilproj
index 6c22cf9c866068..d742a0bf2d1dce 100644
--- a/src/libraries/System.Runtime.CompilerServices.Unsafe/src/System.Runtime.CompilerServices.Unsafe.ilproj
+++ b/src/libraries/System.Runtime.CompilerServices.Unsafe/src/System.Runtime.CompilerServices.Unsafe.ilproj
@@ -1,7 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk.IL">
   <PropertyGroup>
     <TargetFrameworks>$(NetCoreAppCurrent);netcoreapp3.1;netstandard2.0;net461</TargetFrameworks>
-    <ExcludeCurrentNetCoreAppFromPackage>true</ExcludeCurrentNetCoreAppFromPackage>
     <!-- Make sure that the DebuggableAttribute is set properly. -->
     <DebugOptimization>IMPL</DebugOptimization>
     <DebugOptimization Condition="'$(Configuration)' == 'Release'">OPT</DebugOptimization>
diff --git a/src/libraries/System.Runtime.Extensions/tests/System/AppDomainTests.cs b/src/libraries/System.Runtime.Extensions/tests/System/AppDomainTests.cs
index b3b056df5ec951..7360975078abae 100644
--- a/src/libraries/System.Runtime.Extensions/tests/System/AppDomainTests.cs
+++ b/src/libraries/System.Runtime.Extensions/tests/System/AppDomainTests.cs
@@ -45,7 +45,6 @@ public void RelativeSearchPath_Is_Null()
 
         [Fact]
         [SkipOnPlatform(TestPlatforms.Browser, "throws pNSE")]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
         [ActiveIssue("https://github.com/dotnet/runtime/issues/49868", TestPlatforms.Android)]
         [ActiveIssue("https://github.com/dotnet/runtime/issues/36896", TestPlatforms.iOS | TestPlatforms.tvOS | TestPlatforms.MacCatalyst)]
         public void TargetFrameworkTest()
@@ -212,7 +211,6 @@ public void ProcessExit_Add_Remove()
         }
 
         [ConditionalFact(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
         public void ProcessExit_Called()
         {
             string path = GetTestFilePath();
diff --git a/src/libraries/System.Runtime.Extensions/tests/System/BitConverter.cs b/src/libraries/System.Runtime.Extensions/tests/System/BitConverter.cs
index bfc9d6950fce94..420de69f5474b9 100644
--- a/src/libraries/System.Runtime.Extensions/tests/System/BitConverter.cs
+++ b/src/libraries/System.Runtime.Extensions/tests/System/BitConverter.cs
@@ -295,5 +295,35 @@ public static void HalfToInt16Bits()
             Half roundtripped = BitConverter.Int16BitsToHalf(result);
             Assert.Equal(input, roundtripped);
         }
+
+        [Fact]
+        public static void DoubleToUInt64Bits()
+        {
+            double input = 123456.3234;
+            ulong result = BitConverter.DoubleToUInt64Bits(input);
+            Assert.Equal(4683220267154373240UL, result);
+            double roundtripped = BitConverter.UInt64BitsToDouble(result);
+            Assert.Equal(input, roundtripped);
+        }
+
+        [Fact]
+        public static void SingleToUInt32Bits()
+        {
+            float input = 12345.63f;
+            uint result = BitConverter.SingleToUInt32Bits(input);
+            Assert.Equal(1178658437U, result);
+            float roundtripped = BitConverter.UInt32BitsToSingle(result);
+            Assert.Equal(input, roundtripped);
+        }
+
+        [Fact]
+        public static void HalfToUInt16Bits()
+        {
+            Half input = (Half)12.34;
+            ushort result = BitConverter.HalfToUInt16Bits(input);
+            Assert.Equal((ushort)18988, result);
+            Half roundtripped = BitConverter.UInt16BitsToHalf(result);
+            Assert.Equal(input, roundtripped);
+        }
     }
 }
diff --git a/src/libraries/System.Runtime.Extensions/tests/System/Environment.Exit.cs b/src/libraries/System.Runtime.Extensions/tests/System/Environment.Exit.cs
index 626aa3ac8ee057..f6ef6cef9f4637 100644
--- a/src/libraries/System.Runtime.Extensions/tests/System/Environment.Exit.cs
+++ b/src/libraries/System.Runtime.Extensions/tests/System/Environment.Exit.cs
@@ -22,7 +22,6 @@ public class Environment_Exit
 
         [ConditionalTheory(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))]
         [MemberData(nameof(ExitCodeValues))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
         public static void CheckExitCode(int expectedExitCode)
         {
             RemoteExecutor.Invoke(s => int.Parse(s), expectedExitCode.ToString(), new RemoteInvokeOptions { ExpectedExitCode = expectedExitCode }).Dispose();
@@ -43,7 +42,6 @@ public static void ExitCode_Roundtrips(int exitCode)
         [InlineData(2)] // setting ExitCode both from Main and from an Unloading event handler.
         [InlineData(3)] // using Exit(exitCode)
         [SkipOnPlatform(TestPlatforms.Browser | TestPlatforms.iOS | TestPlatforms.MacCatalyst | TestPlatforms.tvOS, "Not supported on Browser, iOS, MacCatalyst, or tvOS.")]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
         [ActiveIssue("https://github.com/dotnet/runtime/issues/49868", TestPlatforms.Android)]
         public static void ExitCode_VoidMainAppReturnsSetValue(int mode)
         {
diff --git a/src/libraries/System.Runtime.Extensions/tests/System/Environment.GetCommandLineArgs.cs b/src/libraries/System.Runtime.Extensions/tests/System/Environment.GetCommandLineArgs.cs
index ae0d4a68e1f180..695af6b8f2567a 100644
--- a/src/libraries/System.Runtime.Extensions/tests/System/Environment.GetCommandLineArgs.cs
+++ b/src/libraries/System.Runtime.Extensions/tests/System/Environment.GetCommandLineArgs.cs
@@ -23,7 +23,6 @@ public static IEnumerable<object[]> GetCommandLineArgs_TestData()
 
         [ConditionalTheory(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))]
         [MemberData(nameof(GetCommandLineArgs_TestData))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
         public void GetCommandLineArgs_Invoke_ReturnsExpected(string[] args)
         {
             switch (args.Length)
diff --git a/src/libraries/System.Runtime.Extensions/tests/System/Environment.StackTrace.cs b/src/libraries/System.Runtime.Extensions/tests/System/Environment.StackTrace.cs
index e3fa2c36d28f77..255d03483505f2 100644
--- a/src/libraries/System.Runtime.Extensions/tests/System/Environment.StackTrace.cs
+++ b/src/libraries/System.Runtime.Extensions/tests/System/Environment.StackTrace.cs
@@ -68,6 +68,7 @@ public TestClass()
         }
 
         [Fact]
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/50957", typeof(PlatformDetection), nameof(PlatformDetection.IsBrowser), nameof(PlatformDetection.IsMonoAOT))]
         public void StackTraceDoesNotStartWithInternalFrame()
         {
              string stackTrace = Environment.StackTrace;
diff --git a/src/libraries/System.Runtime.Extensions/tests/System/EnvironmentTests.cs b/src/libraries/System.Runtime.Extensions/tests/System/EnvironmentTests.cs
index b192b0900acd03..ed12573ab7d988 100644
--- a/src/libraries/System.Runtime.Extensions/tests/System/EnvironmentTests.cs
+++ b/src/libraries/System.Runtime.Extensions/tests/System/EnvironmentTests.cs
@@ -83,7 +83,6 @@ public void ProcessId_Idempotent()
         }
 
         [ConditionalFact(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
         public void ProcessId_MatchesExpectedValue()
         {
             using RemoteInvokeHandle handle = RemoteExecutor.Invoke(() => Console.WriteLine(Environment.ProcessId), new RemoteInvokeOptions { StartInfo = new ProcessStartInfo { RedirectStandardOutput = true } });
@@ -97,7 +96,6 @@ public void ProcessPath_Idempotent()
         }
 
         [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
         public void ProcessPath_MatchesExpectedValue()
         {
             string expectedProcessPath = PlatformDetection.IsBrowser ? null : Process.GetCurrentProcess().MainModule.FileName;
@@ -268,7 +266,6 @@ public void FailFast_ExpectFailureExitCode()
 
         [Trait(XunitConstants.Category, XunitConstants.IgnoreForCI)] // fail fast crashes the process
         [ConditionalFact(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
         public void FailFast_ExceptionStackTrace_ArgumentException()
         {
             var psi = new ProcessStartInfo();
@@ -290,7 +287,6 @@ public void FailFast_ExceptionStackTrace_ArgumentException()
 
         [Trait(XunitConstants.Category, XunitConstants.IgnoreForCI)] // fail fast crashes the process
         [ConditionalFact(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
         public void FailFast_ExceptionStackTrace_StackOverflowException()
         {
             // Test using another type of exception
@@ -313,7 +309,6 @@ public void FailFast_ExceptionStackTrace_StackOverflowException()
 
         [Trait(XunitConstants.Category, XunitConstants.IgnoreForCI)] // fail fast crashes the process
         [ConditionalFact(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
         public void FailFast_ExceptionStackTrace_InnerException()
         {
             // Test if inner exception details are also logged
diff --git a/src/libraries/System.Runtime.Extensions/tests/System/Numerics/BitOperationsTests.cs b/src/libraries/System.Runtime.Extensions/tests/System/Numerics/BitOperationsTests.cs
index f59d90b7c51450..7836538dbe7480 100644
--- a/src/libraries/System.Runtime.Extensions/tests/System/Numerics/BitOperationsTests.cs
+++ b/src/libraries/System.Runtime.Extensions/tests/System/Numerics/BitOperationsTests.cs
@@ -388,5 +388,53 @@ public static void BitOps_RotateRight_ulong()
             Assert.Equal(value, BitOperations.RotateRight(value, int.MinValue)); // % 64 = 0
             Assert.Equal(BitOperations.RotateLeft(value, 63), BitOperations.RotateRight(value, int.MaxValue)); // % 64 = 63
         }
+
+        [Theory]
+        [InlineData(0u, 0u)]
+        [InlineData(1u, 1u)]
+        [InlineData(2u, 2u)]
+        [InlineData(0x0096u, 0x0100u)]
+        [InlineData(0x05CDu, 0x0800u)]
+        [InlineData(0x0932u, 0x1000u)]
+        [InlineData(0x0004_C911u, 0x0008_0000u)]
+        [InlineData(0x00E0_A2E2u, 0x0100_0000u)]
+        [InlineData(0x0988_0713u, 0x1000_0000u)]
+        [InlineData(0x30A4_9649u, 0x4000_0000u)]
+        [InlineData(0x7FFF_FFFFu, 0x8000_0000u)]
+        [InlineData(0x8000_0000u, 0x8000_0000u)]
+        [InlineData(0x8000_0001u, 0ul)]
+        [InlineData(0xFFFF_FFFFu, 0ul)]
+        public static void BitOps_RoundUpToPow2_uint(uint value, uint expected)
+        {
+            Assert.Equal(expected, BitOperations.RoundUpToPowerOf2(value));
+        }
+
+        [Theory]
+        [InlineData(0ul, 0ul)]
+        [InlineData(1ul, 1ul)]
+        [InlineData(2ul, 2ul)]
+        [InlineData(0x0096ul, 0x0100ul)]
+        [InlineData(0x05cdul, 0x0800ul)]
+        [InlineData(0x0932ul, 0x1000ul)]
+        [InlineData(0x0004_c911ul, 0x0008_0000ul)]
+        [InlineData(0x00e0_a2b2ul, 0x0100_0000ul)]
+        [InlineData(0x0988_0713ul, 0x1000_0000ul)]
+        [InlineData(0x30a4_9649ul, 0x4000_0000ul)]
+        [InlineData(0x7FFF_FFFFul, 0x8000_0000ul)]
+        [InlineData(0x8000_0000ul, 0x8000_0000ul)]
+        [InlineData(0x8000_0001ul, 0x1_0000_0000ul)]
+        [InlineData(0xFFFF_FFFFul, 0x1_0000_0000ul)]
+        [InlineData(0x0000_0003_343B_0D81ul, 0x0000_0004_0000_0000ul)]
+        [InlineData(0x0000_0D87_5EE2_8F19ul, 0x0000_1000_0000_0000ul)]
+        [InlineData(0x0006_2A08_4A7A_3A2Dul, 0x0008_0000_0000_0000ul)]
+        [InlineData(0x0101_BF76_4398_F791ul, 0x0200_0000_0000_0000ul)]
+        [InlineData(0x7FFF_FFFF_FFFF_FFFFul, 0x8000_0000_0000_0000ul)]
+        [InlineData(0x8000_0000_0000_0000ul, 0x8000_0000_0000_0000ul)]
+        [InlineData(0x8000_0000_0000_0001ul, 0ul)]
+        [InlineData(0xFFFF_FFFF_FFFF_FFFFul, 0ul)]
+        public static void BitOps_RoundUpToPow2_ulong(ulong value, ulong expected)
+        {
+            Assert.Equal(expected, BitOperations.RoundUpToPowerOf2(value));
+        }
     }
 }
diff --git a/src/libraries/System.Runtime.Extensions/tests/System/Runtime/ProfileOptimization.cs b/src/libraries/System.Runtime.Extensions/tests/System/Runtime/ProfileOptimization.cs
index 7f980ffc9ff574..530661c9762ea2 100644
--- a/src/libraries/System.Runtime.Extensions/tests/System/Runtime/ProfileOptimization.cs
+++ b/src/libraries/System.Runtime.Extensions/tests/System/Runtime/ProfileOptimization.cs
@@ -14,7 +14,6 @@ public class ProfileOptimizationTest : FileCleanupTestBase
         [InlineData(false)]
         [InlineData(true)]
         [ActiveIssue("https://github.com/dotnet/runtime/issues/31853", TestRuntimes.Mono)]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
         public void ProfileOptimization_CheckFileExists(bool stopProfile)
         {
             string profileFile = GetTestFileName();
diff --git a/src/libraries/System.Runtime.Extensions/tests/System/UnloadingAndProcessExitTests.cs b/src/libraries/System.Runtime.Extensions/tests/System/UnloadingAndProcessExitTests.cs
index 7e37f41de4739d..577b5262d7bc36 100644
--- a/src/libraries/System.Runtime.Extensions/tests/System/UnloadingAndProcessExitTests.cs
+++ b/src/libraries/System.Runtime.Extensions/tests/System/UnloadingAndProcessExitTests.cs
@@ -12,7 +12,6 @@ namespace System.Tests
     public class UnloadingAndProcessExitTests : FileCleanupTestBase
     {
         [ConditionalFact(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
         public void UnloadingEventMustHappenBeforeProcessExitEvent()
         {
             string fileName = GetTestFilePath();
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 0cf9affe8da760..02e739ad731733 100644
--- a/src/libraries/System.Runtime.InteropServices/ref/System.Runtime.InteropServices.cs
+++ b/src/libraries/System.Runtime.InteropServices/ref/System.Runtime.InteropServices.cs
@@ -760,6 +760,27 @@ public static void SetDllImportResolver(System.Reflection.Assembly assembly, Sys
         public static bool TryLoad(string libraryPath, out System.IntPtr handle) { throw null; }
         public static bool TryLoad(string libraryName, System.Reflection.Assembly assembly, System.Runtime.InteropServices.DllImportSearchPath? searchPath, out System.IntPtr handle) { throw null; }
     }
+    public static unsafe partial class NativeMemory
+    {
+        [System.CLSCompliantAttribute(false)]
+        public static void* AlignedAlloc(nuint byteCount, nuint alignment) { throw null; }
+        [System.CLSCompliantAttribute(false)]
+        public static void AlignedFree(void* ptr) { }
+        [System.CLSCompliantAttribute(false)]
+        public static void* AlignedRealloc(void* ptr, nuint byteCount, nuint alignment) { throw null; }
+        [System.CLSCompliantAttribute(false)]
+        public static void* Alloc(nuint byteCount) { throw null; }
+        [System.CLSCompliantAttribute(false)]
+        public static void* Alloc(nuint elementCount, nuint elementSize) { throw null; }
+        [System.CLSCompliantAttribute(false)]
+        public static void* AllocZeroed(nuint byteCount) { throw null; }
+        [System.CLSCompliantAttribute(false)]
+        public static void* AllocZeroed(nuint elementCount, nuint elementSize) { throw null; }
+        [System.CLSCompliantAttribute(false)]
+        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 NFloat(float value) { }
diff --git a/src/libraries/System.Runtime.InteropServices/tests/System.Runtime.InteropServices.Tests.csproj b/src/libraries/System.Runtime.InteropServices/tests/System.Runtime.InteropServices.Tests.csproj
index e04dab6046036c..9ed8c6ff8a776f 100644
--- a/src/libraries/System.Runtime.InteropServices/tests/System.Runtime.InteropServices.Tests.csproj
+++ b/src/libraries/System.Runtime.InteropServices/tests/System.Runtime.InteropServices.Tests.csproj
@@ -14,6 +14,7 @@
     <Compile Include="System\Runtime\InteropServices\BStrWrapperTests.cs" />
     <Compile Include="System\Runtime\InteropServices\CallingConventionTests.cs" />
     <Compile Include="System\Runtime\InteropServices\ClassInterfaceAttributeTests.cs" />
+    <Compile Include="System\Runtime\InteropServices\NativeMemoryTests.cs" />
     <Compile Include="System\Runtime\InteropServices\NFloatTests.cs" />
     <Compile Include="System\Runtime\InteropServices\CULongTests.cs" />
     <Compile Include="System\Runtime\InteropServices\CLongTests.cs" />
diff --git a/src/libraries/System.Runtime.InteropServices/tests/System/Runtime/InteropServices/NativeMemoryTests.cs b/src/libraries/System.Runtime.InteropServices/tests/System/Runtime/InteropServices/NativeMemoryTests.cs
new file mode 100644
index 00000000000000..9787751d87ae24
--- /dev/null
+++ b/src/libraries/System.Runtime.InteropServices/tests/System/Runtime/InteropServices/NativeMemoryTests.cs
@@ -0,0 +1,439 @@
+// 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.Runtime.InteropServices.Tests
+{
+    public unsafe class NativeMemoryTests
+    {
+        [Theory]
+        [InlineData(1)]
+        [InlineData(2)]
+        [InlineData(4)]
+        [InlineData(8)]
+        [InlineData(16)]
+        [InlineData(32)]
+        [InlineData(64)]
+        [InlineData(128)]
+        [InlineData(256)]
+        [InlineData(512)]
+        [InlineData(1 * 1024)]
+        [InlineData(2 * 1024)]
+        [InlineData(4 * 1024)]
+        [InlineData(8 * 1024)]
+        [InlineData(16 * 1024)]
+        [InlineData(64 * 1024)]
+        [InlineData(1 * 1024 * 1024)]
+        [InlineData(2 * 1024 * 1024)]
+        [InlineData(4 * 1024 * 1024)]
+        public void AlignedAllocTest(uint alignment)
+        {
+            void* ptr = NativeMemory.AlignedAlloc(1, alignment);
+
+            Assert.True(ptr != null);
+            Assert.True((nuint)ptr % alignment == 0);
+
+            NativeMemory.AlignedFree(ptr);
+        }
+
+        [Fact]
+        public void AlignedAllocLessThanVoidPtrAlignmentTest()
+        {
+            void* ptr = NativeMemory.AlignedAlloc(1, 1);
+            Assert.True(ptr != null);
+            NativeMemory.AlignedFree(ptr);
+        }
+
+        [Fact]
+        public void AlignedAllocOOMTest()
+        {
+            Assert.Throws<OutOfMemoryException>(() => NativeMemory.AlignedAlloc(nuint.MaxValue - ((uint)sizeof(nuint) - 1), (uint)sizeof(nuint)));
+        }
+
+        [Fact]
+        public void AlignedAllocZeroAlignmentTest()
+        {
+            Assert.Throws<ArgumentException>(() => NativeMemory.AlignedAlloc((uint)sizeof(nuint), 0));
+        }
+
+        [Fact]
+        public void AlignedAllocNonPowerOfTwoAlignmentTest()
+        {
+            Assert.Throws<ArgumentException>(() => NativeMemory.AlignedAlloc((uint)sizeof(nuint), (uint)sizeof(nuint) + 1));
+            Assert.Throws<ArgumentException>(() => NativeMemory.AlignedAlloc((uint)sizeof(nuint), (uint)sizeof(nuint) * 3));
+        }
+
+        [Fact]
+        public void AlignedAllocOverflowByteCountTest()
+        {
+            // POSIX requires byteCount to be a multiple of alignment and so we will internally upsize.
+            // This upsizing can overflow for certain values since we do (byteCount + (alignment - 1)) & ~(alignment - 1)
+            //
+            // However, this overflow is "harmless" since it will result in a value that is less than alignment
+            // given that alignment is a power of two and will ultimately be a value less than alignment which
+            // will be treated as invalid and result in OOM.
+            //
+            // Take for example a 64-bit system where the max power of two is (1UL << 63): 9223372036854775808
+            // * 9223372036854775808 + 9223372036854775807 == ulong.MaxValue, so no overflow
+            // * 9223372036854775809 + 9223372036854775807 == 0, so overflows and is less than alignment
+            // *      ulong.MaxValue + 9223372036854775807 == 9223372036854775806, so overflows and is less than alignment
+            //
+            // Likewise, for small alignments such as 8 (which is the smallest on a 64-bit system for POSIX):
+            // * 18446744073709551608 + 7 == ulong.MaxValue, so no overflow
+            // * 18446744073709551609 + 7 == 0, so overflows and is less than alignment
+            // *       ulong.MaxValue + 7 == 6, so overflows and is less than alignment
+
+            nuint maxAlignment = (nuint)1 << ((sizeof(nuint) * 8) - 1);
+            Assert.Throws<OutOfMemoryException>(() => NativeMemory.AlignedAlloc(maxAlignment + 1, maxAlignment));
+
+            Assert.Throws<OutOfMemoryException>(() => NativeMemory.AlignedAlloc(nuint.MaxValue, (uint)sizeof(nuint)));
+        }
+
+        [Fact]
+        public void AlignedAllocZeroSizeTest()
+        {
+            void* ptr = NativeMemory.AlignedAlloc(0, (uint)sizeof(nuint));
+
+            Assert.True(ptr != null);
+            Assert.True((nuint)ptr % (uint)sizeof(nuint) == 0);
+
+            NativeMemory.AlignedFree(ptr);
+        }
+
+        [Fact]
+        public void AlignedFreeTest()
+        {
+            // This should not throw
+            NativeMemory.AlignedFree(null);
+        }
+
+        [Theory]
+        [InlineData(1)]
+        [InlineData(2)]
+        [InlineData(4)]
+        [InlineData(8)]
+        [InlineData(16)]
+        [InlineData(32)]
+        [InlineData(64)]
+        [InlineData(128)]
+        [InlineData(256)]
+        [InlineData(512)]
+        [InlineData(1 * 1024)]
+        [InlineData(2 * 1024)]
+        [InlineData(4 * 1024)]
+        [InlineData(8 * 1024)]
+        [InlineData(16 * 1024)]
+        [InlineData(64 * 1024)]
+        [InlineData(1 * 1024 * 1024)]
+        [InlineData(2 * 1024 * 1024)]
+        [InlineData(4 * 1024 * 1024)]
+        public void AlignedReallocTest(uint alignment)
+        {
+            void* ptr = NativeMemory.AlignedAlloc(1, alignment);
+
+            Assert.True(ptr != null);
+            Assert.True((nuint)ptr % alignment == 0);
+
+            void* newPtr = NativeMemory.AlignedRealloc(ptr, 1, alignment);
+
+            Assert.True(newPtr != null);
+            Assert.True((nuint)newPtr % alignment == 0);
+
+            NativeMemory.AlignedFree(newPtr);
+        }
+
+        [Fact]
+        public void AlignedReallocLessThanVoidPtrAlignmentTest()
+        {
+            void* ptr = NativeMemory.AlignedAlloc(1, 1);
+            Assert.True(ptr != null);
+
+            void* newPtr = NativeMemory.AlignedRealloc(ptr, 1, 1);
+            Assert.True(newPtr != null);
+            NativeMemory.AlignedFree(newPtr);
+        }
+
+        [Fact]
+        public void AlignedReallocNullPtrTest()
+        {
+            void* ptr = NativeMemory.AlignedRealloc(null, 1, (uint)sizeof(nuint));
+
+            Assert.True(ptr != null);
+            Assert.True((nuint)ptr % (uint)sizeof(nuint) == 0);
+
+            NativeMemory.AlignedFree(ptr);
+        }
+
+        [Fact]
+        public void AlignedReallocNullPtrOOMTest()
+        {
+            Assert.Throws<OutOfMemoryException>(() => NativeMemory.AlignedRealloc(null, nuint.MaxValue, (uint)sizeof(nuint)));
+        }
+
+        [Fact]
+        public void AlignedReallocNullPtrZeroSizeTest()
+        {
+            void* ptr = NativeMemory.AlignedRealloc(null, 0, (uint)sizeof(nuint));
+
+            Assert.True(ptr != null);
+            Assert.True((nuint)ptr % (uint)sizeof(nuint) == 0);
+
+            NativeMemory.AlignedFree(ptr);
+        }
+
+        [Fact]
+        public void AlignedReallocZeroAlignmentTest()
+        {
+            void* ptr = NativeMemory.AlignedAlloc(1, (uint)sizeof(nuint));
+
+            Assert.True(ptr != null);
+            Assert.True((nuint)ptr % (uint)sizeof(nuint) == 0);
+
+            Assert.Throws<ArgumentException>(() => NativeMemory.AlignedRealloc(ptr, (uint)sizeof(nuint), 0));
+            NativeMemory.AlignedFree(ptr);
+        }
+
+        [Fact]
+        public void AlignedReallocNonPowerOfTwoAlignmentTest()
+        {
+            void* ptr = NativeMemory.AlignedAlloc(1, (uint)sizeof(nuint));
+
+            Assert.True(ptr != null);
+            Assert.True((nuint)ptr % (uint)sizeof(nuint) == 0);
+
+            Assert.Throws<ArgumentException>(() => NativeMemory.AlignedRealloc(ptr, (uint)sizeof(nuint), (uint)sizeof(nuint) + 1));
+            Assert.Throws<ArgumentException>(() => NativeMemory.AlignedRealloc(ptr, (uint)sizeof(nuint), (uint)sizeof(nuint) * 3));
+            NativeMemory.AlignedFree(ptr);
+        }
+
+        [Fact]
+        public void AlignedReallocZeroSizeTest()
+        {
+            void* ptr = NativeMemory.AlignedAlloc(1, (uint)sizeof(nuint));
+
+            Assert.True(ptr != null);
+            Assert.True((nuint)ptr % (uint)sizeof(nuint) == 0);
+
+            void* newPtr = NativeMemory.AlignedRealloc(ptr, 0, (uint)sizeof(nuint));
+
+            Assert.True(newPtr != null);
+            Assert.True((nuint)newPtr % (uint)sizeof(nuint) == 0);
+
+            NativeMemory.AlignedFree(newPtr);
+        }
+
+        [Fact]
+        public void AlignedReallocSmallerToLargerTest()
+        {
+            void* ptr = NativeMemory.AlignedAlloc(16, 16);
+
+            Assert.True(ptr != null);
+            Assert.True((nuint)ptr % 16 == 0);
+
+            for (int i = 0; i < 16; i++)
+            {
+                ((byte*)ptr)[i] = (byte)i;
+            }
+
+            void* newPtr = NativeMemory.AlignedRealloc(ptr, 32, 16);
+
+            Assert.True(newPtr != null);
+            Assert.True((nuint)newPtr % 16 == 0);
+
+            for (int i = 0; i < 16; i++)
+            {
+                Assert.True(((byte*)newPtr)[i] == i);
+            }
+
+            NativeMemory.AlignedFree(newPtr);
+        }
+
+        [Fact]
+        public void AllocByteCountTest()
+        {
+            void* ptr = NativeMemory.Alloc(1);
+            Assert.True(ptr != null);
+            NativeMemory.Free(ptr);
+        }
+
+        [Fact]
+        public void AllocElementCountTest()
+        {
+            void* ptr = NativeMemory.Alloc(1, 1);
+            Assert.True(ptr != null);
+            NativeMemory.Free(ptr);
+        }
+
+        [Fact]
+        public void AllocByteCountOOMTest()
+        {
+            Assert.Throws<OutOfMemoryException>(() => NativeMemory.Alloc(nuint.MaxValue));
+        }
+
+        [Fact]
+        public void AllocElementCountOOMTest()
+        {
+            Assert.Throws<OutOfMemoryException>(() => NativeMemory.Alloc(1, nuint.MaxValue));
+            Assert.Throws<OutOfMemoryException>(() => NativeMemory.Alloc(nuint.MaxValue, 1));
+            Assert.Throws<OutOfMemoryException>(() => NativeMemory.Alloc(nuint.MaxValue, nuint.MaxValue));
+        }
+
+        [Fact]
+        public void AllocZeroByteCountTest()
+        {
+            void* ptr = NativeMemory.Alloc(0);
+            Assert.True(ptr != null);
+            NativeMemory.Free(ptr);
+        }
+
+        [Fact]
+        public void AllocZeroElementCountTest()
+        {
+            void* ptr = NativeMemory.Alloc(0, 1);
+            Assert.True(ptr != null);
+            NativeMemory.Free(ptr);
+        }
+
+        [Fact]
+        public void AllocZeroElementSizeTest()
+        {
+            void* ptr = NativeMemory.Alloc(1, 0);
+            Assert.True(ptr != null);
+            NativeMemory.Free(ptr);
+        }
+
+        [Fact]
+        public void AllocZeroedByteCountTest()
+        {
+            void* ptr = NativeMemory.AllocZeroed(1);
+
+            Assert.True(ptr != null);
+            Assert.Equal(expected: 0, actual: ((byte*)ptr)[0]);
+
+            NativeMemory.Free(ptr);
+        }
+
+        [Fact]
+        public void AllocZeroedElementCountTest()
+        {
+            void* ptr = NativeMemory.AllocZeroed(1, 1);
+
+            Assert.True(ptr != null);
+            Assert.Equal(expected: 0, actual: ((byte*)ptr)[0]);
+
+            NativeMemory.Free(ptr);
+        }
+
+        [Fact]
+        public void AllocZeroedByteCountOOMTest()
+        {
+            Assert.Throws<OutOfMemoryException>(() => NativeMemory.AllocZeroed(nuint.MaxValue));
+        }
+
+        [Fact]
+        public void AllocZeroedElementCountOOMTest()
+        {
+            Assert.Throws<OutOfMemoryException>(() => NativeMemory.AllocZeroed(1, nuint.MaxValue));
+            Assert.Throws<OutOfMemoryException>(() => NativeMemory.AllocZeroed(nuint.MaxValue, 1));
+            Assert.Throws<OutOfMemoryException>(() => NativeMemory.AllocZeroed(nuint.MaxValue, nuint.MaxValue));
+        }
+
+        [Fact]
+        public void AllocZeroedZeroByteCountTest()
+        {
+            void* ptr = NativeMemory.AllocZeroed(0);
+            Assert.True(ptr != null);
+            NativeMemory.Free(ptr);
+        }
+
+        [Fact]
+        public void AllocZeroedZeroElementCountTest()
+        {
+            void* ptr = NativeMemory.AllocZeroed(0, 1);
+            Assert.True(ptr != null);
+            NativeMemory.Free(ptr);
+        }
+
+        [Fact]
+        public void AllocZeroedZeroElementSizeTest()
+        {
+            void* ptr = NativeMemory.AllocZeroed(1, 0);
+            Assert.True(ptr != null);
+            NativeMemory.Free(ptr);
+        }
+
+        [Fact]
+        public void FreeTest()
+        {
+            // This should not throw
+            NativeMemory.Free(null);
+        }
+
+        [Fact]
+        public void ReallocTest()
+        {
+            void* ptr = NativeMemory.Alloc(1);
+            Assert.True(ptr != null);
+
+            void* newPtr = NativeMemory.Realloc(ptr, 1);
+            Assert.True(newPtr != null);
+            NativeMemory.Free(newPtr);
+        }
+
+        [Fact]
+        public void ReallocNullPtrTest()
+        {
+            void* ptr = NativeMemory.Realloc(null, 1);
+            Assert.True(ptr != null);
+            NativeMemory.Free(ptr);
+        }
+
+        [Fact]
+        public void ReallocNullPtrOOMTest()
+        {
+            Assert.Throws<OutOfMemoryException>(() => NativeMemory.Realloc(null, nuint.MaxValue));
+        }
+
+        [Fact]
+        public void ReallocNullPtrZeroSizeTest()
+        {
+            void* ptr = NativeMemory.Realloc(null, 0);
+            Assert.True(ptr != null);
+            NativeMemory.Free(ptr);
+        }
+
+        [Fact]
+        public void ReallocZeroSizeTest()
+        {
+            void* ptr = NativeMemory.Alloc(1);
+            Assert.True(ptr != null);
+
+            void* newPtr = NativeMemory.Realloc(ptr, 0);
+            Assert.True(newPtr != null);
+            NativeMemory.Free(newPtr);
+        }
+
+        [Fact]
+        public void ReallocSmallerToLargerTest()
+        {
+            void* ptr = NativeMemory.Alloc(16);
+            Assert.True(ptr != null);
+
+            for (int i = 0; i < 16; i++)
+            {
+                ((byte*)ptr)[i] = (byte)i;
+            }
+
+            void* newPtr = NativeMemory.Realloc(ptr, 32);
+            Assert.True(newPtr != null);
+
+            for (int i = 0; i < 16; i++)
+            {
+                Assert.True(((byte*)newPtr)[i] == i);
+            }
+
+            NativeMemory.Free(newPtr);
+        }
+    }
+}
diff --git a/src/libraries/System.Runtime.Serialization.Formatters/src/System/Runtime/Serialization/ObjectManager.cs b/src/libraries/System.Runtime.Serialization.Formatters/src/System/Runtime/Serialization/ObjectManager.cs
index d9eba9228f1fb0..9398d93fb1f424 100644
--- a/src/libraries/System.Runtime.Serialization.Formatters/src/System/Runtime/Serialization/ObjectManager.cs
+++ b/src/libraries/System.Runtime.Serialization.Formatters/src/System/Runtime/Serialization/ObjectManager.cs
@@ -16,6 +16,8 @@ public class ObjectManager
 
         private const string ObjectManagerUnreferencedCodeMessage = "ObjectManager is not trim compatible because the Type of objects being managed cannot be statically discovered.";
 
+        private static readonly FieldInfo s_nullableValueField = typeof(Nullable<>).GetField("value", BindingFlags.NonPublic | BindingFlags.Instance)!;
+
         private DeserializationEventHandler? _onDeserializationHandler;
         private SerializationEventHandler? _onDeserializedHandler;
 
@@ -383,14 +385,11 @@ private bool DoValueTypeFixup(FieldInfo? memberToFix, ObjectHolder holder, objec
             return true;
         }
 
-        [DynamicDependency("value", typeof(Nullable<>))]
-        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2070:UnrecognizedReflectionPattern",
-            Justification = "The Nullable<T>.value field will be preserved by the DynamicDependency.")]
         private static FieldInfo? GetNullableValueField(Type type)
         {
             if (Nullable.GetUnderlyingType(type) != null)
             {
-                return type.GetField("value", BindingFlags.NonPublic | BindingFlags.Instance)!;
+                return (FieldInfo)type.GetMemberWithSameMetadataDefinitionAs(s_nullableValueField);
             }
 
             return null;
diff --git a/src/libraries/System.Runtime.Serialization.Formatters/tests/BinaryFormatterEventSourceTests.cs b/src/libraries/System.Runtime.Serialization.Formatters/tests/BinaryFormatterEventSourceTests.cs
index d955b831e45a6e..805b1ad4df4815 100644
--- a/src/libraries/System.Runtime.Serialization.Formatters/tests/BinaryFormatterEventSourceTests.cs
+++ b/src/libraries/System.Runtime.Serialization.Formatters/tests/BinaryFormatterEventSourceTests.cs
@@ -12,7 +12,6 @@
 namespace System.Runtime.Serialization.Formatters.Tests
 {
     [ConditionalClass(typeof(PlatformDetection), nameof(PlatformDetection.IsBinaryFormatterSupported))]
-    [ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
     public static class BinaryFormatterEventSourceTests
     {
         private const string BinaryFormatterEventSourceName = "System.Runtime.Serialization.Formatters.Binary.BinaryFormatterEventSource";
diff --git a/src/libraries/System.Runtime.Serialization.Formatters/tests/BinaryFormatterTests.cs b/src/libraries/System.Runtime.Serialization.Formatters/tests/BinaryFormatterTests.cs
index b4076482fcb8f0..7bd5ede42c51b9 100644
--- a/src/libraries/System.Runtime.Serialization.Formatters/tests/BinaryFormatterTests.cs
+++ b/src/libraries/System.Runtime.Serialization.Formatters/tests/BinaryFormatterTests.cs
@@ -19,7 +19,6 @@
 namespace System.Runtime.Serialization.Formatters.Tests
 {
     [ConditionalClass(typeof(PlatformDetection), nameof(PlatformDetection.IsBinaryFormatterSupported))]
-    [ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
     public partial class BinaryFormatterTests : FileCleanupTestBase
     {
         // On 32-bit we can't test these high inputs as they cause OutOfMemoryExceptions.
diff --git a/src/libraries/System.Runtime.Serialization.Formatters/tests/FormatterServicesTests.cs b/src/libraries/System.Runtime.Serialization.Formatters/tests/FormatterServicesTests.cs
index 6d2bca0f366602..0a04f250a3f8af 100644
--- a/src/libraries/System.Runtime.Serialization.Formatters/tests/FormatterServicesTests.cs
+++ b/src/libraries/System.Runtime.Serialization.Formatters/tests/FormatterServicesTests.cs
@@ -9,7 +9,6 @@
 
 namespace System.Runtime.Serialization.Formatters.Tests
 {
-    [ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
     public partial class FormatterServicesTests
     {
         [Fact]
diff --git a/src/libraries/System.Runtime.Serialization.Formatters/tests/FormatterTests.cs b/src/libraries/System.Runtime.Serialization.Formatters/tests/FormatterTests.cs
index e1195cd5908e74..68ca34ee79d6a8 100644
--- a/src/libraries/System.Runtime.Serialization.Formatters/tests/FormatterTests.cs
+++ b/src/libraries/System.Runtime.Serialization.Formatters/tests/FormatterTests.cs
@@ -8,7 +8,6 @@
 
 namespace System.Runtime.Serialization.Formatters.Tests
 {
-    [ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
     public class FormatterTests
     {
         [Fact]
diff --git a/src/libraries/System.Runtime.Serialization.Formatters/tests/SerializationInfoTests.cs b/src/libraries/System.Runtime.Serialization.Formatters/tests/SerializationInfoTests.cs
index e135157920a7b8..30b72ce09fc54e 100644
--- a/src/libraries/System.Runtime.Serialization.Formatters/tests/SerializationInfoTests.cs
+++ b/src/libraries/System.Runtime.Serialization.Formatters/tests/SerializationInfoTests.cs
@@ -6,7 +6,6 @@
 
 namespace System.Runtime.Serialization.Formatters.Tests
 {
-    [ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
     public class SerializationInfoTests
     {
         [Fact]
diff --git a/src/libraries/System.Runtime.Serialization.Xml/tests/DataContractSerializer.cs b/src/libraries/System.Runtime.Serialization.Xml/tests/DataContractSerializer.cs
index d1ce413b3dfac0..a576fcf1c872a5 100644
--- a/src/libraries/System.Runtime.Serialization.Xml/tests/DataContractSerializer.cs
+++ b/src/libraries/System.Runtime.Serialization.Xml/tests/DataContractSerializer.cs
@@ -21,7 +21,6 @@
 using System.Runtime.Serialization.Tests;
 
 
-[ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
 public static partial class DataContractSerializerTests
 {
 #if ReflectionOnly
diff --git a/src/libraries/System.Runtime/ref/System.Runtime.cs b/src/libraries/System.Runtime/ref/System.Runtime.cs
index ba30ccf66a0aa9..39a1cfc4b816c3 100644
--- a/src/libraries/System.Runtime/ref/System.Runtime.cs
+++ b/src/libraries/System.Runtime/ref/System.Runtime.cs
@@ -21,6 +21,7 @@ public sealed partial class SafeFileHandle : Microsoft.Win32.SafeHandles.SafeHan
         public SafeFileHandle() : base (default(bool)) { }
         public SafeFileHandle(System.IntPtr preexistingHandle, bool ownsHandle) : base (default(bool)) { }
         public override bool IsInvalid { get { throw null; } }
+        public bool IsAsync { get { throw null; } }
         protected override bool ReleaseHandle() { throw null; }
     }
     public abstract partial class SafeHandleMinusOneIsInvalid : System.Runtime.InteropServices.SafeHandle
@@ -600,6 +601,18 @@ public static partial class BitConverter
         public static float Int32BitsToSingle(int value) { throw null; }
         public static double Int64BitsToDouble(long value) { throw null; }
         public static int SingleToInt32Bits(float value) { throw null; }
+        [System.CLSCompliantAttribute(false)]
+        public static ulong DoubleToUInt64Bits(double value) { throw null; }
+        [System.CLSCompliantAttribute(false)]
+        public static double UInt64BitsToDouble(ulong value) { throw null; }
+        [System.CLSCompliantAttribute(false)]
+        public static uint SingleToUInt32Bits(float value) { throw null; }
+        [System.CLSCompliantAttribute(false)]
+        public static float UInt32BitsToSingle(uint value) { throw null; }
+        [System.CLSCompliantAttribute(false)]
+        public static ushort HalfToUInt16Bits(System.Half value) { throw null; }
+        [System.CLSCompliantAttribute(false)]
+        public static System.Half UInt16BitsToHalf(ushort value) { throw null; }
         public static bool ToBoolean(byte[] value, int startIndex) { throw null; }
         public static bool ToBoolean(System.ReadOnlySpan<byte> value) { throw null; }
         public static char ToChar(byte[] value, int startIndex) { throw null; }
@@ -2343,6 +2356,7 @@ public partial struct HashCode
         private int _dummyPrimitive;
         public void Add<T>(T value) { }
         public void Add<T>(T value, System.Collections.Generic.IEqualityComparer<T>? comparer) { }
+        public void AddBytes(System.ReadOnlySpan<byte> value) { }
         public static int Combine<T1>(T1 value1) { throw null; }
         public static int Combine<T1, T2>(T1 value1, T2 value2) { throw null; }
         public static int Combine<T1, T2, T3>(T1 value1, T2 value2, T3 value3) { throw null; }
@@ -3717,6 +3731,8 @@ public void CopyTo(System.Span<char> destination) { }
         public System.String Replace(System.String oldValue, System.String? newValue) { throw null; }
         public System.String Replace(System.String oldValue, System.String? newValue, bool ignoreCase, System.Globalization.CultureInfo? culture) { throw null; }
         public System.String Replace(System.String oldValue, System.String? newValue, System.StringComparison comparisonType) { throw null; }
+        public System.String ReplaceLineEndings() { throw null; }
+        public System.String ReplaceLineEndings(System.String replacementText) { throw null; }
         public string[] Split(char separator, int count, System.StringSplitOptions options = System.StringSplitOptions.None) { throw null; }
         public string[] Split(char separator, System.StringSplitOptions options = System.StringSplitOptions.None) { throw null; }
         public string[] Split(params char[]? separator) { throw null; }
@@ -4470,6 +4486,7 @@ protected Type() { }
         public virtual System.Reflection.MemberInfo[] GetMember(string name, System.Reflection.BindingFlags bindingAttr) { throw null; }
         [System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembersAttribute(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicConstructors | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicEvents | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicFields | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicMethods | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicNestedTypes | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicProperties | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicConstructors | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicEvents | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicFields | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicMethods | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicNestedTypes | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicProperties)]
         public virtual System.Reflection.MemberInfo[] GetMember(string name, System.Reflection.MemberTypes type, System.Reflection.BindingFlags bindingAttr) { throw null; }
+        public virtual System.Reflection.MemberInfo GetMemberWithSameMetadataDefinitionAs(System.Reflection.MemberInfo member) { throw null; }
         [System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembersAttribute(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicConstructors | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicEvents | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicFields | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicMethods | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicNestedTypes | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicProperties)]
         public System.Reflection.MemberInfo[] GetMembers() { throw null; }
         [System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembersAttribute(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicConstructors | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicEvents | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicFields | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicMethods | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicNestedTypes | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicProperties | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicConstructors | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicEvents | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicFields | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicMethods | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicNestedTypes | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicProperties)]
@@ -7564,6 +7581,8 @@ public static void Move(string sourceFileName, string destFileName, bool overwri
         public static System.IO.FileStream Open(string path, System.IO.FileMode mode) { throw null; }
         public static System.IO.FileStream Open(string path, System.IO.FileMode mode, System.IO.FileAccess access) { throw null; }
         public static System.IO.FileStream Open(string path, System.IO.FileMode mode, System.IO.FileAccess access, System.IO.FileShare share) { throw null; }
+        public static System.IO.FileStream Open(string path, System.IO.FileStreamOptions options) { throw null; }
+        public static Microsoft.Win32.SafeHandles.SafeFileHandle OpenHandle(string path, System.IO.FileMode mode = System.IO.FileMode.Open, System.IO.FileAccess access = System.IO.FileAccess.Read, System.IO.FileShare share = System.IO.FileShare.Read, System.IO.FileOptions options = System.IO.FileOptions.None, long preallocationSize = 0) { throw null; }
         public static System.IO.FileStream OpenRead(string path) { throw null; }
         public static System.IO.StreamReader OpenText(string path) { throw null; }
         public static System.IO.FileStream OpenWrite(string path) { throw null; }
@@ -7625,6 +7644,7 @@ public void MoveTo(string destFileName, bool overwrite) { }
         public System.IO.FileStream Open(System.IO.FileMode mode) { throw null; }
         public System.IO.FileStream Open(System.IO.FileMode mode, System.IO.FileAccess access) { throw null; }
         public System.IO.FileStream Open(System.IO.FileMode mode, System.IO.FileAccess access, System.IO.FileShare share) { throw null; }
+        public System.IO.FileStream Open(System.IO.FileStreamOptions options) { throw null; }
         public System.IO.FileStream OpenRead() { throw null; }
         public System.IO.StreamReader OpenText() { throw null; }
         public System.IO.FileStream OpenWrite() { throw null; }
@@ -7821,10 +7841,12 @@ public StreamReader(System.IO.Stream stream, System.Text.Encoding encoding, bool
         public StreamReader(System.IO.Stream stream, System.Text.Encoding encoding, bool detectEncodingFromByteOrderMarks, int bufferSize) { }
         public StreamReader(System.IO.Stream stream, System.Text.Encoding? encoding = null, bool detectEncodingFromByteOrderMarks = true, int bufferSize = -1, bool leaveOpen = false) { }
         public StreamReader(string path) { }
+        public StreamReader(string path, System.IO.FileStreamOptions options) { }
         public StreamReader(string path, bool detectEncodingFromByteOrderMarks) { }
         public StreamReader(string path, System.Text.Encoding encoding) { }
         public StreamReader(string path, System.Text.Encoding encoding, bool detectEncodingFromByteOrderMarks) { }
         public StreamReader(string path, System.Text.Encoding encoding, bool detectEncodingFromByteOrderMarks, int bufferSize) { }
+        public StreamReader(string path, System.Text.Encoding encoding, bool detectEncodingFromByteOrderMarks, System.IO.FileStreamOptions options) { }
         public virtual System.IO.Stream BaseStream { get { throw null; } }
         public virtual System.Text.Encoding CurrentEncoding { get { throw null; } }
         public bool EndOfStream { get { throw null; } }
@@ -7854,9 +7876,11 @@ public StreamWriter(System.IO.Stream stream, System.Text.Encoding encoding) { }
         public StreamWriter(System.IO.Stream stream, System.Text.Encoding encoding, int bufferSize) { }
         public StreamWriter(System.IO.Stream stream, System.Text.Encoding? encoding = null, int bufferSize = -1, bool leaveOpen = false) { }
         public StreamWriter(string path) { }
+        public StreamWriter(string path, System.IO.FileStreamOptions options) { }
         public StreamWriter(string path, bool append) { }
         public StreamWriter(string path, bool append, System.Text.Encoding encoding) { }
         public StreamWriter(string path, bool append, System.Text.Encoding encoding, int bufferSize) { }
+        public StreamWriter(string path, System.Text.Encoding encoding, System.IO.FileStreamOptions options) { }
         public virtual bool AutoFlush { get { throw null; } set { } }
         public virtual System.IO.Stream BaseStream { get { throw null; } }
         public override System.Text.Encoding Encoding { get { throw null; } }
@@ -8072,6 +8096,18 @@ public override void Write(System.ReadOnlySpan<byte> buffer) { }
         public override System.Threading.Tasks.ValueTask WriteAsync(System.ReadOnlyMemory<byte> buffer, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
         public override void WriteByte(byte value) { }
     }
+    public static partial class RandomAccess
+    {
+        public static long GetLength(Microsoft.Win32.SafeHandles.SafeFileHandle handle) { throw null; }
+        public static int Read(Microsoft.Win32.SafeHandles.SafeFileHandle handle, System.Span<byte> buffer, long fileOffset) { throw null; }
+        public static long Read(Microsoft.Win32.SafeHandles.SafeFileHandle handle, System.Collections.Generic.IReadOnlyList<System.Memory<byte>> buffers, long fileOffset) { throw null; }
+        public static System.Threading.Tasks.ValueTask<int> ReadAsync(Microsoft.Win32.SafeHandles.SafeFileHandle handle, System.Memory<byte> buffer, long fileOffset, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
+        public static System.Threading.Tasks.ValueTask<long> ReadAsync(Microsoft.Win32.SafeHandles.SafeFileHandle handle, System.Collections.Generic.IReadOnlyList<System.Memory<byte>> buffers, long fileOffset, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
+        public static int Write(Microsoft.Win32.SafeHandles.SafeFileHandle handle, System.ReadOnlySpan<byte> buffer, long fileOffset) { throw null; }
+        public static long Write(Microsoft.Win32.SafeHandles.SafeFileHandle handle, System.Collections.Generic.IReadOnlyList<System.ReadOnlyMemory<byte>> buffers, long fileOffset) { throw null; }
+        public static System.Threading.Tasks.ValueTask<int> WriteAsync(Microsoft.Win32.SafeHandles.SafeFileHandle handle, System.ReadOnlyMemory<byte> buffer, long fileOffset, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
+        public static System.Threading.Tasks.ValueTask<long> WriteAsync(Microsoft.Win32.SafeHandles.SafeFileHandle handle, System.Collections.Generic.IReadOnlyList<System.ReadOnlyMemory<byte>> buffers, long fileOffset, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
+    }
 }
 namespace System.IO.Enumeration
 {
@@ -8176,6 +8212,10 @@ public static partial class BitOperations
         public static uint RotateRight(uint value, int offset) { throw null; }
         [System.CLSCompliantAttribute(false)]
         public static ulong RotateRight(ulong value, int offset) { throw null; }
+        [System.CLSCompliantAttribute(false)]
+        public static uint RoundUpToPowerOf2(uint value) { throw null; }
+        [System.CLSCompliantAttribute(false)]
+        public static ulong RoundUpToPowerOf2(ulong value) { throw null; }
         public static int TrailingZeroCount(int value) { throw null; }
         public static int TrailingZeroCount(long value) { throw null; }
         [System.CLSCompliantAttribute(false)]
diff --git a/src/libraries/System.Runtime/tests/System.Runtime.Tests.csproj b/src/libraries/System.Runtime/tests/System.Runtime.Tests.csproj
index 2a68cc12651e18..2ca6739e9c6c13 100644
--- a/src/libraries/System.Runtime/tests/System.Runtime.Tests.csproj
+++ b/src/libraries/System.Runtime/tests/System.Runtime.Tests.csproj
@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <NoWarn>$(NoWarn),1718,SYSLIB0013</NoWarn>
@@ -282,6 +282,7 @@
   </ItemGroup>
   <ItemGroup>
     <PackageReference Include="Moq" Version="$(MoqVersion)" />
+    <PackageReference Include="System.Runtime.Numerics.TestData" Version="$(SystemRuntimeNumericsTestDataVersion)" GeneratePathProperty="true"/>
     <ProjectReference Include="TestLoadAssembly\TestLoadAssembly.csproj" />
     <ProjectReference Include="TestCollectibleAssembly\TestCollectibleAssembly.csproj" />
     <ProjectReference Include="TestModule\System.Reflection.TestModule.ilproj" />
diff --git a/src/libraries/System.Runtime/tests/System/Diagnostics/StackTraceHiddenAttributeTests.cs b/src/libraries/System.Runtime/tests/System/Diagnostics/StackTraceHiddenAttributeTests.cs
index 5fb2f317ee6a34..90371c32bd2453 100644
--- a/src/libraries/System.Runtime/tests/System/Diagnostics/StackTraceHiddenAttributeTests.cs
+++ b/src/libraries/System.Runtime/tests/System/Diagnostics/StackTraceHiddenAttributeTests.cs
@@ -7,6 +7,7 @@
 
 namespace System.Tests
 {
+    [ActiveIssue("https://github.com/dotnet/runtime/issues/50957", typeof(PlatformDetection), nameof(PlatformDetection.IsBrowser), nameof(PlatformDetection.IsMonoAOT))]
     public class StackTraceHiddenAttributeTests
     {
         [Fact]
diff --git a/src/libraries/System.Runtime/tests/System/DoubleTests.cs b/src/libraries/System.Runtime/tests/System/DoubleTests.cs
index 2a0ba4a217c095..a80eb05598c7ed 100644
--- a/src/libraries/System.Runtime/tests/System/DoubleTests.cs
+++ b/src/libraries/System.Runtime/tests/System/DoubleTests.cs
@@ -3,6 +3,7 @@
 
 using System.Collections.Generic;
 using System.Globalization;
+using System.IO;
 using Xunit;
 
 #pragma warning disable xUnit1025 // reporting duplicate test cases due to not distinguishing 0.0 from -0.0, NaN from -NaN
@@ -13,11 +14,6 @@ public class DoubleTests
     {
         // NOTE: Consider duplicating any tests added here in SingleTests.cs
 
-        private static ulong DoubleToUInt64Bits(double value)
-        {
-            return (ulong)(BitConverter.DoubleToInt64Bits(value));
-        }
-
         [Theory]
         [InlineData("a")]
         [InlineData(234.0f)]
@@ -103,7 +99,7 @@ public static void Ctor_Value()
         public static void Epsilon()
         {
             Assert.Equal(4.9406564584124654E-324, double.Epsilon);
-            Assert.Equal(0x00000000_00000001u, DoubleToUInt64Bits(double.Epsilon));
+            Assert.Equal(0x00000000_00000001u, BitConverter.DoubleToUInt64Bits(double.Epsilon));
         }
 
         [Theory]
@@ -221,28 +217,28 @@ public static void IsPositiveInfinity(double d, bool expected)
         public static void MaxValue()
         {
             Assert.Equal(1.7976931348623157E+308, double.MaxValue);
-            Assert.Equal(0x7FEFFFFF_FFFFFFFFu, DoubleToUInt64Bits(double.MaxValue));
+            Assert.Equal(0x7FEFFFFF_FFFFFFFFu, BitConverter.DoubleToUInt64Bits(double.MaxValue));
         }
 
         [Fact]
         public static void MinValue()
         {
             Assert.Equal(-1.7976931348623157E+308, double.MinValue);
-            Assert.Equal(0xFFEFFFFF_FFFFFFFFu, DoubleToUInt64Bits(double.MinValue));
+            Assert.Equal(0xFFEFFFFF_FFFFFFFFu, BitConverter.DoubleToUInt64Bits(double.MinValue));
         }
 
         [Fact]
         public static void NaN()
         {
             Assert.Equal(0.0 / 0.0, double.NaN);
-            Assert.Equal(0xFFF80000_00000000u, DoubleToUInt64Bits(double.NaN));
+            Assert.Equal(0xFFF80000_00000000u, BitConverter.DoubleToUInt64Bits(double.NaN));
         }
 
         [Fact]
         public static void NegativeInfinity()
         {
             Assert.Equal(-1.0 / 0.0, double.NegativeInfinity);
-            Assert.Equal(0xFFF00000_00000000u, DoubleToUInt64Bits(double.NegativeInfinity));
+            Assert.Equal(0xFFF00000_00000000u, BitConverter.DoubleToUInt64Bits(double.NegativeInfinity));
         }
 
         public static IEnumerable<object[]> Parse_Valid_TestData()
@@ -351,6 +347,70 @@ public static void Parse(string value, NumberStyles style, IFormatProvider provi
             }
         }
 
+        internal static string SplitPairs(string input)
+        {
+            string[] splitPairs = input.Split('-');
+            string ret = "";
+            foreach (var pair in splitPairs)
+            {
+                string reversedPair = Reverse(pair);
+                ret += reversedPair;
+            }
+
+            return ret;
+        }
+
+        internal static string Reverse(string s)
+        {
+            char[] charArray = s.ToCharArray();
+            Array.Reverse(charArray);
+            return new string(charArray);
+        }
+
+        [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNotBrowser))]
+        public static void ParsePatterns()
+        {
+            string path = Directory.GetCurrentDirectory();
+            using (FileStream file = new FileStream(Path.Combine(path, "ibm-fpgen.txt"), FileMode.Open))
+            {
+                using (var streamReader = new StreamReader(file))
+                {
+                    string line = streamReader.ReadLine();
+                    while (line != null)
+                    {
+                        string[] data = line.Split(' ');
+                        string inputHalfBytes = data[0];
+                        string inputFloatBytes = data[1];
+                        string inputDoubleBytes = data[2];
+                        string correctValue = data[3];
+
+                        double doubleValue = double.Parse(correctValue, NumberFormatInfo.InvariantInfo);
+                        string doubleBytes = BitConverter.ToString(BitConverter.GetBytes(doubleValue));
+                        float floatValue = float.Parse(correctValue, NumberFormatInfo.InvariantInfo);
+                        string floatBytes = BitConverter.ToString(BitConverter.GetBytes(floatValue));
+                        Half halfValue = Half.Parse(correctValue, NumberFormatInfo.InvariantInfo);
+                        string halfBytes = BitConverter.ToString(BitConverter.GetBytes(halfValue));
+
+                        doubleBytes = SplitPairs(doubleBytes);
+                        floatBytes = SplitPairs(floatBytes);
+                        halfBytes = SplitPairs(halfBytes);
+
+                        if (BitConverter.IsLittleEndian)
+                        {
+                            doubleBytes = Reverse(doubleBytes);
+                            floatBytes = Reverse(floatBytes);
+                            halfBytes = Reverse(halfBytes);
+                        }
+
+                        Assert.Equal(doubleBytes, inputDoubleBytes);
+                        Assert.Equal(floatBytes, inputFloatBytes);
+                        Assert.Equal(halfBytes, inputHalfBytes);
+                        line = streamReader.ReadLine();
+                    }
+                }
+            }
+        }
+
         public static IEnumerable<object[]> Parse_Invalid_TestData()
         {
             NumberStyles defaultStyle = NumberStyles.Float;
@@ -474,7 +534,7 @@ public static void Parse_Span_Invalid(string value, NumberStyles style, IFormatP
         public static void PositiveInfinity()
         {
             Assert.Equal(1.0 / 0.0, double.PositiveInfinity);
-            Assert.Equal(0x7FF00000_00000000u, DoubleToUInt64Bits(double.PositiveInfinity));
+            Assert.Equal(0x7FF00000_00000000u, BitConverter.DoubleToUInt64Bits(double.PositiveInfinity));
         }
 
         public static IEnumerable<object[]> ToString_TestData()
diff --git a/src/libraries/System.Runtime/tests/System/ExceptionTests.cs b/src/libraries/System.Runtime/tests/System/ExceptionTests.cs
index 3db490e293f547..ffc9c36636e89d 100644
--- a/src/libraries/System.Runtime/tests/System/ExceptionTests.cs
+++ b/src/libraries/System.Runtime/tests/System/ExceptionTests.cs
@@ -92,6 +92,7 @@ static void RethrowException()
         }
 
         [Fact]
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/50957", typeof(PlatformDetection), nameof(PlatformDetection.IsBrowser), nameof(PlatformDetection.IsMonoAOT))]
         public static void Exception_TargetSite_OtherMethod()
         {
             Exception ex = Assert.ThrowsAny<Exception>(() => ThrowException());
@@ -99,6 +100,7 @@ public static void Exception_TargetSite_OtherMethod()
         }
 
         [Fact]
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/50957", typeof(PlatformDetection), nameof(PlatformDetection.IsBrowser), nameof(PlatformDetection.IsMonoAOT))]
         public static void Exception_TargetSite_Rethrow()
         {
             Exception ex = Assert.ThrowsAny<Exception>(() => RethrowException());
diff --git a/src/libraries/System.Runtime/tests/System/HalfTests.cs b/src/libraries/System.Runtime/tests/System/HalfTests.cs
index ebc04c2727470c..eac2d5b6a7e0e2 100644
--- a/src/libraries/System.Runtime/tests/System/HalfTests.cs
+++ b/src/libraries/System.Runtime/tests/System/HalfTests.cs
@@ -10,74 +10,64 @@ namespace System.Tests
 {
     public partial class HalfTests
     {
-        private static ushort HalfToUInt16Bits(Half value)
-        {
-            return (ushort)BitConverter.HalfToInt16Bits(value);
-        }
-
-        private static Half UInt16BitsToHalf(ushort value)
-        {
-            return BitConverter.Int16BitsToHalf((short)value);
-        }
-
         [Fact]
         public static void Epsilon()
         {
-            Assert.Equal(0x0001u, HalfToUInt16Bits(Half.Epsilon));
+            Assert.Equal(0x0001u, BitConverter.HalfToUInt16Bits(Half.Epsilon));
         }
 
         [Fact]
         public static void PositiveInfinity()
         {
-            Assert.Equal(0x7C00u, HalfToUInt16Bits(Half.PositiveInfinity));
+            Assert.Equal(0x7C00u, BitConverter.HalfToUInt16Bits(Half.PositiveInfinity));
         }
 
         [Fact]
         public static void NegativeInfinity()
         {
-            Assert.Equal(0xFC00u, HalfToUInt16Bits(Half.NegativeInfinity));
+            Assert.Equal(0xFC00u, BitConverter.HalfToUInt16Bits(Half.NegativeInfinity));
         }
 
         [Fact]
         public static void NaN()
         {
-            Assert.Equal(0xFE00u, HalfToUInt16Bits(Half.NaN));
+            Assert.Equal(0xFE00u, BitConverter.HalfToUInt16Bits(Half.NaN));
         }
 
         [Fact]
         public static void MinValue()
         {
-            Assert.Equal(0xFBFFu, HalfToUInt16Bits(Half.MinValue));
+            Assert.Equal(0xFBFFu, BitConverter.HalfToUInt16Bits(Half.MinValue));
         }
 
         [Fact]
         public static void MaxValue()
         {
-            Assert.Equal(0x7BFFu, HalfToUInt16Bits(Half.MaxValue));
+            Assert.Equal(0x7BFFu, BitConverter.HalfToUInt16Bits(Half.MaxValue));
         }
 
         [Fact]
         public static void Ctor_Empty()
         {
             var value = new Half();
-            Assert.Equal(0x0000, HalfToUInt16Bits(value));
+            Assert.Equal(0x0000, BitConverter.HalfToUInt16Bits(value));
         }
 
         public static IEnumerable<object[]> IsFinite_TestData()
         {
-            yield return new object[] { Half.NegativeInfinity, false };     // Negative Infinity
-            yield return new object[] { Half.MinValue, true };              // Min Negative Normal
-            yield return new object[] { UInt16BitsToHalf(0x8400), true };   // Max Negative Normal
-            yield return new object[] { UInt16BitsToHalf(0x83FF), true };   // Min Negative Subnormal
-            yield return new object[] { UInt16BitsToHalf(0x8001), true };   // Max Negative Subnormal
-            yield return new object[] { UInt16BitsToHalf(0x8000), true };   // Negative Zero
-            yield return new object[] { Half.NaN, false };                  // NaN
-            yield return new object[] { UInt16BitsToHalf(0x0000), true };   // Positive Zero
-            yield return new object[] { Half.Epsilon, true };               // Min Positive Subnormal
-            yield return new object[] { UInt16BitsToHalf(0x03FF), true };   // Max Positive Subnormal
-            yield return new object[] { UInt16BitsToHalf(0x0400), true };   // Min Positive Normal
-            yield return new object[] { Half.MaxValue, true };              // Max Positive Normal
-            yield return new object[] { Half.PositiveInfinity, false };     // Positive Infinity
+            yield return new object[] { Half.NegativeInfinity, false };                  // Negative Infinity
+            yield return new object[] { Half.MinValue, true };                           // Min Negative Normal
+            yield return new object[] { BitConverter.UInt16BitsToHalf(0x8400), true };   // Max Negative Normal
+            yield return new object[] { BitConverter.UInt16BitsToHalf(0x83FF), true };   // Min Negative Subnormal
+            yield return new object[] { BitConverter.UInt16BitsToHalf(0x8001), true };   // Max Negative Subnormal
+            yield return new object[] { BitConverter.UInt16BitsToHalf(0x8000), true };   // Negative Zero
+            yield return new object[] { Half.NaN, false };                               // NaN
+            yield return new object[] { BitConverter.UInt16BitsToHalf(0x0000), true };   // Positive Zero
+            yield return new object[] { Half.Epsilon, true };                            // Min Positive Subnormal
+            yield return new object[] { BitConverter.UInt16BitsToHalf(0x03FF), true };   // Max Positive Subnormal
+            yield return new object[] { BitConverter.UInt16BitsToHalf(0x0400), true };   // Min Positive Normal
+            yield return new object[] { Half.MaxValue, true };                           // Max Positive Normal
+            yield return new object[] { Half.PositiveInfinity, false };                  // Positive Infinity
         }
 
         [Theory]
@@ -89,19 +79,19 @@ public static void IsFinite(Half value, bool expected)
 
         public static IEnumerable<object[]> IsInfinity_TestData()
         {
-            yield return new object[] { Half.NegativeInfinity, true };      // Negative Infinity
-            yield return new object[] { Half.MinValue, false };             // Min Negative Normal
-            yield return new object[] { UInt16BitsToHalf(0x8400), false };  // Max Negative Normal
-            yield return new object[] { UInt16BitsToHalf(0x83FF), false };  // Min Negative Subnormal
-            yield return new object[] { UInt16BitsToHalf(0x8001), false };  // Max Negative Subnormal (Negative Epsilon)
-            yield return new object[] { UInt16BitsToHalf(0x8000), false };  // Negative Zero
-            yield return new object[] { Half.NaN, false };                  // NaN
-            yield return new object[] { UInt16BitsToHalf(0x0000), false };  // Positive Zero
-            yield return new object[] { Half.Epsilon, false };              // Min Positive Subnormal (Positive Epsilon)
-            yield return new object[] { UInt16BitsToHalf(0x03FF), false };  // Max Positive Subnormal
-            yield return new object[] { UInt16BitsToHalf(0x0400), false };  // Min Positive Normal
-            yield return new object[] { Half.MaxValue, false };             // Max Positive Normal
-            yield return new object[] { Half.PositiveInfinity, true };      // Positive Infinity
+            yield return new object[] { Half.NegativeInfinity, true };                   // Negative Infinity
+            yield return new object[] { Half.MinValue, false };                          // Min Negative Normal
+            yield return new object[] { BitConverter.UInt16BitsToHalf(0x8400), false };  // Max Negative Normal
+            yield return new object[] { BitConverter.UInt16BitsToHalf(0x83FF), false };  // Min Negative Subnormal
+            yield return new object[] { BitConverter.UInt16BitsToHalf(0x8001), false };  // Max Negative Subnormal (Negative Epsilon)
+            yield return new object[] { BitConverter.UInt16BitsToHalf(0x8000), false };  // Negative Zero
+            yield return new object[] { Half.NaN, false };                               // NaN
+            yield return new object[] { BitConverter.UInt16BitsToHalf(0x0000), false };  // Positive Zero
+            yield return new object[] { Half.Epsilon, false };                           // Min Positive Subnormal (Positive Epsilon)
+            yield return new object[] { BitConverter.UInt16BitsToHalf(0x03FF), false };  // Max Positive Subnormal
+            yield return new object[] { BitConverter.UInt16BitsToHalf(0x0400), false };  // Min Positive Normal
+            yield return new object[] { Half.MaxValue, false };                          // Max Positive Normal
+            yield return new object[] { Half.PositiveInfinity, true };                   // Positive Infinity
         }
 
         [Theory]
@@ -113,19 +103,19 @@ public static void IsInfinity(Half value, bool expected)
 
         public static IEnumerable<object[]> IsNaN_TestData()
         {
-            yield return new object[] { Half.NegativeInfinity, false };     // Negative Infinity
-            yield return new object[] { Half.MinValue, false };             // Min Negative Normal
-            yield return new object[] { UInt16BitsToHalf(0x8400), false };  // Max Negative Normal
-            yield return new object[] { UInt16BitsToHalf(0x83FF), false };  // Min Negative Subnormal
-            yield return new object[] { UInt16BitsToHalf(0x8001), false };  // Max Negative Subnormal (Negative Epsilon)
-            yield return new object[] { UInt16BitsToHalf(0x8000), false };  // Negative Zero
-            yield return new object[] { Half.NaN, true };                   // NaN
-            yield return new object[] { UInt16BitsToHalf(0x0000), false };  // Positive Zero
-            yield return new object[] { Half.Epsilon, false };              // Min Positive Subnormal (Positive Epsilon)
-            yield return new object[] { UInt16BitsToHalf(0x03FF), false };  // Max Positive Subnormal
-            yield return new object[] { UInt16BitsToHalf(0x0400), false };  // Min Positive Normal
-            yield return new object[] { Half.MaxValue, false };             // Max Positive Normal
-            yield return new object[] { Half.PositiveInfinity, false };     // Positive Infinity
+            yield return new object[] { Half.NegativeInfinity, false };                  // Negative Infinity
+            yield return new object[] { Half.MinValue, false };                          // Min Negative Normal
+            yield return new object[] { BitConverter.UInt16BitsToHalf(0x8400), false };  // Max Negative Normal
+            yield return new object[] { BitConverter.UInt16BitsToHalf(0x83FF), false };  // Min Negative Subnormal
+            yield return new object[] { BitConverter.UInt16BitsToHalf(0x8001), false };  // Max Negative Subnormal (Negative Epsilon)
+            yield return new object[] { BitConverter.UInt16BitsToHalf(0x8000), false };  // Negative Zero
+            yield return new object[] { Half.NaN, true };                                // NaN
+            yield return new object[] { BitConverter.UInt16BitsToHalf(0x0000), false };  // Positive Zero
+            yield return new object[] { Half.Epsilon, false };                           // Min Positive Subnormal (Positive Epsilon)
+            yield return new object[] { BitConverter.UInt16BitsToHalf(0x03FF), false };  // Max Positive Subnormal
+            yield return new object[] { BitConverter.UInt16BitsToHalf(0x0400), false };  // Min Positive Normal
+            yield return new object[] { Half.MaxValue, false };                          // Max Positive Normal
+            yield return new object[] { Half.PositiveInfinity, false };                  // Positive Infinity
         }
 
         [Theory]
@@ -137,19 +127,19 @@ public static void IsNaN(Half value, bool expected)
 
         public static IEnumerable<object[]> IsNegative_TestData()
         {
-            yield return new object[] { Half.NegativeInfinity, true };      // Negative Infinity
-            yield return new object[] { Half.MinValue, true };              // Min Negative Normal
-            yield return new object[] { UInt16BitsToHalf(0x8400), true };   // Max Negative Normal
-            yield return new object[] { UInt16BitsToHalf(0x83FF), true };   // Min Negative Subnormal
-            yield return new object[] { UInt16BitsToHalf(0x8001), true };   // Max Negative Subnormal
-            yield return new object[] { UInt16BitsToHalf(0x8000), true };   // Negative Zero
-            yield return new object[] { Half.NaN, true };                   // NaN
-            yield return new object[] { UInt16BitsToHalf(0x0000), false };  // Positive Zero
-            yield return new object[] { Half.Epsilon, false };              // Min Positive Subnormal
-            yield return new object[] { UInt16BitsToHalf(0x03FF), false };  // Max Positive Subnormal
-            yield return new object[] { UInt16BitsToHalf(0x0400), false };  // Min Positive Normal
-            yield return new object[] { Half.MaxValue, false };             // Max Positive Normal
-            yield return new object[] { Half.PositiveInfinity, false };     // Positive Infinity
+            yield return new object[] { Half.NegativeInfinity, true };                   // Negative Infinity
+            yield return new object[] { Half.MinValue, true };                           // Min Negative Normal
+            yield return new object[] { BitConverter.UInt16BitsToHalf(0x8400), true };   // Max Negative Normal
+            yield return new object[] { BitConverter.UInt16BitsToHalf(0x83FF), true };   // Min Negative Subnormal
+            yield return new object[] { BitConverter.UInt16BitsToHalf(0x8001), true };   // Max Negative Subnormal
+            yield return new object[] { BitConverter.UInt16BitsToHalf(0x8000), true };   // Negative Zero
+            yield return new object[] { Half.NaN, true };                                // NaN
+            yield return new object[] { BitConverter.UInt16BitsToHalf(0x0000), false };  // Positive Zero
+            yield return new object[] { Half.Epsilon, false };                           // Min Positive Subnormal
+            yield return new object[] { BitConverter.UInt16BitsToHalf(0x03FF), false };  // Max Positive Subnormal
+            yield return new object[] { BitConverter.UInt16BitsToHalf(0x0400), false };  // Min Positive Normal
+            yield return new object[] { Half.MaxValue, false };                          // Max Positive Normal
+            yield return new object[] { Half.PositiveInfinity, false };                  // Positive Infinity
         }
 
         [Theory]
@@ -161,19 +151,19 @@ public static void IsNegative(Half value, bool expected)
 
         public static IEnumerable<object[]> IsNegativeInfinity_TestData()
         {
-            yield return new object[] { Half.NegativeInfinity, true };      // Negative Infinity
-            yield return new object[] { Half.MinValue, false };             // Min Negative Normal
-            yield return new object[] { UInt16BitsToHalf(0x8400), false };  // Max Negative Normal
-            yield return new object[] { UInt16BitsToHalf(0x83FF), false };  // Min Negative Subnormal
-            yield return new object[] { UInt16BitsToHalf(0x8001), false };  // Max Negative Subnormal (Negative Epsilon)
-            yield return new object[] { UInt16BitsToHalf(0x8000), false };  // Negative Zero
-            yield return new object[] { Half.NaN, false };                  // NaN
-            yield return new object[] { UInt16BitsToHalf(0x0000), false };  // Positive Zero
-            yield return new object[] { Half.Epsilon, false };              // Min Positive Subnormal (Positive Epsilon)
-            yield return new object[] { UInt16BitsToHalf(0x03FF), false };  // Max Positive Subnormal
-            yield return new object[] { UInt16BitsToHalf(0x0400), false };  // Min Positive Normal
-            yield return new object[] { Half.MaxValue, false };             // Max Positive Normal
-            yield return new object[] { Half.PositiveInfinity, false };     // Positive Infinity
+            yield return new object[] { Half.NegativeInfinity, true };                   // Negative Infinity
+            yield return new object[] { Half.MinValue, false };                          // Min Negative Normal
+            yield return new object[] { BitConverter.UInt16BitsToHalf(0x8400), false };  // Max Negative Normal
+            yield return new object[] { BitConverter.UInt16BitsToHalf(0x83FF), false };  // Min Negative Subnormal
+            yield return new object[] { BitConverter.UInt16BitsToHalf(0x8001), false };  // Max Negative Subnormal (Negative Epsilon)
+            yield return new object[] { BitConverter.UInt16BitsToHalf(0x8000), false };  // Negative Zero
+            yield return new object[] { Half.NaN, false };                               // NaN
+            yield return new object[] { BitConverter.UInt16BitsToHalf(0x0000), false };  // Positive Zero
+            yield return new object[] { Half.Epsilon, false };                           // Min Positive Subnormal (Positive Epsilon)
+            yield return new object[] { BitConverter.UInt16BitsToHalf(0x03FF), false };  // Max Positive Subnormal
+            yield return new object[] { BitConverter.UInt16BitsToHalf(0x0400), false };  // Min Positive Normal
+            yield return new object[] { Half.MaxValue, false };                          // Max Positive Normal
+            yield return new object[] { Half.PositiveInfinity, false };                  // Positive Infinity
         }
 
         [Theory]
@@ -185,19 +175,19 @@ public static void IsNegativeInfinity(Half value, bool expected)
 
         public static IEnumerable<object[]> IsNormal_TestData()
         {
-            yield return new object[] { Half.NegativeInfinity, false };     // Negative Infinity
-            yield return new object[] { Half.MinValue, true };              // Min Negative Normal
-            yield return new object[] { UInt16BitsToHalf(0x8400), true };   // Max Negative Normal
-            yield return new object[] { UInt16BitsToHalf(0x83FF), false };  // Min Negative Subnormal
-            yield return new object[] { UInt16BitsToHalf(0x8001), false };  // Max Negative Subnormal
-            yield return new object[] { UInt16BitsToHalf(0x8000), false };  // Negative Zero
-            yield return new object[] { Half.NaN, false };                  // NaN
-            yield return new object[] { UInt16BitsToHalf(0x0000), false };  // Positive Zero
-            yield return new object[] { Half.Epsilon, false };              // Min Positive Subnormal
-            yield return new object[] { UInt16BitsToHalf(0x03FF), false };  // Max Positive Subnormal
-            yield return new object[] { UInt16BitsToHalf(0x0400), true };   // Min Positive Normal
-            yield return new object[] { Half.MaxValue, true };              // Max Positive Normal
-            yield return new object[] { Half.PositiveInfinity, false };     // Positive Infinity
+            yield return new object[] { Half.NegativeInfinity, false };                  // Negative Infinity
+            yield return new object[] { Half.MinValue, true };                           // Min Negative Normal
+            yield return new object[] { BitConverter.UInt16BitsToHalf(0x8400), true };   // Max Negative Normal
+            yield return new object[] { BitConverter.UInt16BitsToHalf(0x83FF), false };  // Min Negative Subnormal
+            yield return new object[] { BitConverter.UInt16BitsToHalf(0x8001), false };  // Max Negative Subnormal
+            yield return new object[] { BitConverter.UInt16BitsToHalf(0x8000), false };  // Negative Zero
+            yield return new object[] { Half.NaN, false };                               // NaN
+            yield return new object[] { BitConverter.UInt16BitsToHalf(0x0000), false };  // Positive Zero
+            yield return new object[] { Half.Epsilon, false };                           // Min Positive Subnormal
+            yield return new object[] { BitConverter.UInt16BitsToHalf(0x03FF), false };  // Max Positive Subnormal
+            yield return new object[] { BitConverter.UInt16BitsToHalf(0x0400), true };   // Min Positive Normal
+            yield return new object[] { Half.MaxValue, true };                           // Max Positive Normal
+            yield return new object[] { Half.PositiveInfinity, false };                  // Positive Infinity
         }
 
         [Theory]
@@ -209,19 +199,19 @@ public static void IsNormal(Half value, bool expected)
 
         public static IEnumerable<object[]> IsPositiveInfinity_TestData()
         {
-            yield return new object[] { Half.NegativeInfinity, false };     // Negative Infinity
-            yield return new object[] { Half.MinValue, false };             // Min Negative Normal
-            yield return new object[] { UInt16BitsToHalf(0x8400), false };  // Max Negative Normal
-            yield return new object[] { UInt16BitsToHalf(0x83FF), false };  // Min Negative Subnormal
-            yield return new object[] { UInt16BitsToHalf(0x8001), false };  // Max Negative Subnormal (Negative Epsilon)
-            yield return new object[] { UInt16BitsToHalf(0x8000), false };  // Negative Zero
-            yield return new object[] { Half.NaN, false };                  // NaN
-            yield return new object[] { UInt16BitsToHalf(0x0000), false };  // Positive Zero
-            yield return new object[] { Half.Epsilon, false };              // Min Positive Subnormal (Positive Epsilon)
-            yield return new object[] { UInt16BitsToHalf(0x03FF), false };  // Max Positive Subnormal
-            yield return new object[] { UInt16BitsToHalf(0x0400), false };  // Min Positive Normal
-            yield return new object[] { Half.MaxValue, false };             // Max Positive Normal
-            yield return new object[] { Half.PositiveInfinity, true };      // Positive Infinity
+            yield return new object[] { Half.NegativeInfinity, false };                  // Negative Infinity
+            yield return new object[] { Half.MinValue, false };                          // Min Negative Normal
+            yield return new object[] { BitConverter.UInt16BitsToHalf(0x8400), false };  // Max Negative Normal
+            yield return new object[] { BitConverter.UInt16BitsToHalf(0x83FF), false };  // Min Negative Subnormal
+            yield return new object[] { BitConverter.UInt16BitsToHalf(0x8001), false };  // Max Negative Subnormal (Negative Epsilon)
+            yield return new object[] { BitConverter.UInt16BitsToHalf(0x8000), false };  // Negative Zero
+            yield return new object[] { Half.NaN, false };                               // NaN
+            yield return new object[] { BitConverter.UInt16BitsToHalf(0x0000), false };  // Positive Zero
+            yield return new object[] { Half.Epsilon, false };                           // Min Positive Subnormal (Positive Epsilon)
+            yield return new object[] { BitConverter.UInt16BitsToHalf(0x03FF), false };  // Max Positive Subnormal
+            yield return new object[] { BitConverter.UInt16BitsToHalf(0x0400), false };  // Min Positive Normal
+            yield return new object[] { Half.MaxValue, false };                          // Max Positive Normal
+            yield return new object[] { Half.PositiveInfinity, true };                   // Positive Infinity
         }
 
         [Theory]
@@ -233,19 +223,19 @@ public static void IsPositiveInfinity(Half value, bool expected)
 
         public static IEnumerable<object[]> IsSubnormal_TestData()
         {
-            yield return new object[] { Half.NegativeInfinity, false };     // Negative Infinity
-            yield return new object[] { Half.MinValue, false };             // Min Negative Normal
-            yield return new object[] { UInt16BitsToHalf(0x8400), false };  // Max Negative Normal
-            yield return new object[] { UInt16BitsToHalf(0x83FF), true };   // Min Negative Subnormal
-            yield return new object[] { UInt16BitsToHalf(0x8001), true };   // Max Negative Subnormal
-            yield return new object[] { UInt16BitsToHalf(0x8000), false };  // Negative Zero
-            yield return new object[] { Half.NaN, false };                  // NaN
-            yield return new object[] { UInt16BitsToHalf(0x0000), false };  // Positive Zero
-            yield return new object[] { Half.Epsilon, true };               // Min Positive Subnormal
-            yield return new object[] { UInt16BitsToHalf(0x03FF), true };   // Max Positive Subnormal
-            yield return new object[] { UInt16BitsToHalf(0x0400), false };  // Min Positive Normal
-            yield return new object[] { Half.MaxValue, false };             // Max Positive Normal
-            yield return new object[] { Half.PositiveInfinity, false };     // Positive Infinity
+            yield return new object[] { Half.NegativeInfinity, false };                  // Negative Infinity
+            yield return new object[] { Half.MinValue, false };                          // Min Negative Normal
+            yield return new object[] { BitConverter.UInt16BitsToHalf(0x8400), false };  // Max Negative Normal
+            yield return new object[] { BitConverter.UInt16BitsToHalf(0x83FF), true };   // Min Negative Subnormal
+            yield return new object[] { BitConverter.UInt16BitsToHalf(0x8001), true };   // Max Negative Subnormal
+            yield return new object[] { BitConverter.UInt16BitsToHalf(0x8000), false };  // Negative Zero
+            yield return new object[] { Half.NaN, false };                               // NaN
+            yield return new object[] { BitConverter.UInt16BitsToHalf(0x0000), false };  // Positive Zero
+            yield return new object[] { Half.Epsilon, true };                            // Min Positive Subnormal
+            yield return new object[] { BitConverter.UInt16BitsToHalf(0x03FF), true };   // Max Positive Subnormal
+            yield return new object[] { BitConverter.UInt16BitsToHalf(0x0400), false };  // Min Positive Normal
+            yield return new object[] { Half.MaxValue, false };                          // Max Positive Normal
+            yield return new object[] { Half.PositiveInfinity, false };                  // Positive Infinity
         }
 
         [Theory]
@@ -272,19 +262,19 @@ public static IEnumerable<object[]> CompareTo_TestData()
         {
             yield return new object[] { Half.MaxValue, Half.MaxValue, 0 };
             yield return new object[] { Half.MaxValue, Half.MinValue, 1 };
-            yield return new object[] { Half.Epsilon, UInt16BitsToHalf(0x8001), 1 };
-            yield return new object[] { Half.MaxValue, UInt16BitsToHalf(0x0000), 1 };
+            yield return new object[] { Half.Epsilon, BitConverter.UInt16BitsToHalf(0x8001), 1 };
+            yield return new object[] { Half.MaxValue, BitConverter.UInt16BitsToHalf(0x0000), 1 };
             yield return new object[] { Half.MaxValue, Half.Epsilon, 1 };
             yield return new object[] { Half.MaxValue, Half.PositiveInfinity, -1 };
             yield return new object[] { Half.MinValue, Half.MaxValue, -1 };
             yield return new object[] { Half.MaxValue, Half.NaN, 1 };
             yield return new object[] { Half.NaN, Half.NaN, 0 };
-            yield return new object[] { Half.NaN, UInt16BitsToHalf(0x0000), -1 };
+            yield return new object[] { Half.NaN, BitConverter.UInt16BitsToHalf(0x0000), -1 };
             yield return new object[] { Half.MaxValue, null, 1 };
             yield return new object[] { Half.MinValue, Half.NegativeInfinity, 1 };
             yield return new object[] { Half.NegativeInfinity, Half.MinValue, -1 };
-            yield return new object[] { UInt16BitsToHalf(0x8000), Half.NegativeInfinity, 1 }; // Negative zero
-            yield return new object[] { Half.NegativeInfinity, UInt16BitsToHalf(0x8000), -1 }; // Negative zero
+            yield return new object[] { BitConverter.UInt16BitsToHalf(0x8000), Half.NegativeInfinity, 1 }; // Negative zero
+            yield return new object[] { Half.NegativeInfinity, BitConverter.UInt16BitsToHalf(0x8000), -1 }; // Negative zero
         }
 
         [Theory]
@@ -334,7 +324,7 @@ public static IEnumerable<object[]> Equals_TestData()
         {
             yield return new object[] { Half.MaxValue, Half.MaxValue, true };
             yield return new object[] { Half.MaxValue, Half.MinValue, false };
-            yield return new object[] { Half.MaxValue, UInt16BitsToHalf(0x0000), false };
+            yield return new object[] { Half.MaxValue, BitConverter.UInt16BitsToHalf(0x0000), false };
             yield return new object[] { Half.NaN, Half.NaN, true };
             yield return new object[] { Half.MaxValue, 789.0f, false };
             yield return new object[] { Half.MaxValue, "789", false };
@@ -351,41 +341,41 @@ public static IEnumerable<object[]> ExplicitConversion_ToSingle_TestData()
         {
             (Half Original, float Expected)[] data = // Fraction is shifted left by 42, Exponent is -15 then +127 = +112
             {
-                (UInt16BitsToHalf(0b0_01111_0000000000), 1f), // 1
-                (UInt16BitsToHalf(0b1_01111_0000000000), -1f), // -1
+                (BitConverter.UInt16BitsToHalf(0b0_01111_0000000000), 1f), // 1
+                (BitConverter.UInt16BitsToHalf(0b1_01111_0000000000), -1f), // -1
                 (Half.MaxValue, 65504f), // 65500
                 (Half.MinValue, -65504f), // -65500
-                (UInt16BitsToHalf(0b0_01011_1001100110), 0.0999755859375f), // 0.1ish
-                (UInt16BitsToHalf(0b1_01011_1001100110), -0.0999755859375f), // -0.1ish
-                (UInt16BitsToHalf(0b0_10100_0101000000), 42f), // 42
-                (UInt16BitsToHalf(0b1_10100_0101000000), -42f), // -42
+                (BitConverter.UInt16BitsToHalf(0b0_01011_1001100110), 0.0999755859375f), // 0.1ish
+                (BitConverter.UInt16BitsToHalf(0b1_01011_1001100110), -0.0999755859375f), // -0.1ish
+                (BitConverter.UInt16BitsToHalf(0b0_10100_0101000000), 42f), // 42
+                (BitConverter.UInt16BitsToHalf(0b1_10100_0101000000), -42f), // -42
                 (Half.PositiveInfinity, float.PositiveInfinity), // PosInfinity
                 (Half.NegativeInfinity, float.NegativeInfinity), // NegInfinity
-                (UInt16BitsToHalf(0b0_11111_1000000000), BitConverter.Int32BitsToSingle(0x7FC00000)), // Positive Quiet NaN
+                (BitConverter.UInt16BitsToHalf(0b0_11111_1000000000), BitConverter.Int32BitsToSingle(0x7FC00000)), // Positive Quiet NaN
                 (Half.NaN, float.NaN), // Negative Quiet NaN
-                (UInt16BitsToHalf(0b0_11111_1010101010), BitConverter.Int32BitsToSingle(0x7FD54000)), // Positive Signalling NaN - Should preserve payload
-                (UInt16BitsToHalf(0b1_11111_1010101010), BitConverter.Int32BitsToSingle(unchecked((int)0xFFD54000))), // Negative Signalling NaN - Should preserve payload
+                (BitConverter.UInt16BitsToHalf(0b0_11111_1010101010), BitConverter.Int32BitsToSingle(0x7FD54000)), // Positive Signalling NaN - Should preserve payload
+                (BitConverter.UInt16BitsToHalf(0b1_11111_1010101010), BitConverter.Int32BitsToSingle(unchecked((int)0xFFD54000))), // Negative Signalling NaN - Should preserve payload
                 (Half.Epsilon, 1/16777216f), // PosEpsilon = 0.000000059605...
-                (UInt16BitsToHalf(0), 0), // 0
-                (UInt16BitsToHalf(0b1_00000_0000000000), -0f), // -0
-                (UInt16BitsToHalf(0b0_10000_1001001000), 3.140625f), // 3.140625
-                (UInt16BitsToHalf(0b1_10000_1001001000), -3.140625f), // -3.140625
-                (UInt16BitsToHalf(0b0_10000_0101110000), 2.71875f), // 2.71875
-                (UInt16BitsToHalf(0b1_10000_0101110000), -2.71875f), // -2.71875
-                (UInt16BitsToHalf(0b0_01111_1000000000), 1.5f), // 1.5
-                (UInt16BitsToHalf(0b1_01111_1000000000), -1.5f), // -1.5
-                (UInt16BitsToHalf(0b0_01111_1000000001), 1.5009765625f), // 1.5009765625
-                (UInt16BitsToHalf(0b1_01111_1000000001), -1.5009765625f), // -1.5009765625
-                (UInt16BitsToHalf(0b0_00001_0000000000), BitConverter.Int32BitsToSingle(0x38800000)), // smallest normal
-                (UInt16BitsToHalf(0b0_00000_1111111111), BitConverter.Int32BitsToSingle(0x387FC000)), // largest subnormal
-                (UInt16BitsToHalf(0b0_00000_1000000000), BitConverter.Int32BitsToSingle(0x38000000)), // middle subnormal
-                (UInt16BitsToHalf(0b0_00000_0111111111), BitConverter.Int32BitsToSingle(0x37FF8000)), // just below middle subnormal
-                (UInt16BitsToHalf(0b0_00000_0000000001), BitConverter.Int32BitsToSingle(0x33800000)), // smallest subnormal
-                (UInt16BitsToHalf(0b1_00000_0000000001), BitConverter.Int32BitsToSingle(unchecked((int)0xB3800000))), // highest negative subnormal
-                (UInt16BitsToHalf(0b1_00000_0111111111), BitConverter.Int32BitsToSingle(unchecked((int)0xB7FF8000))), // just above negative middle subnormal
-                (UInt16BitsToHalf(0b1_00000_1000000000), BitConverter.Int32BitsToSingle(unchecked((int)0xB8000000))), // negative middle subnormal
-                (UInt16BitsToHalf(0b1_00000_1111111111), BitConverter.Int32BitsToSingle(unchecked((int)0xB87FC000))), // lowest negative subnormal
-                (UInt16BitsToHalf(0b1_00001_0000000000), BitConverter.Int32BitsToSingle(unchecked((int)0xB8800000))) // highest negative normal
+                (BitConverter.UInt16BitsToHalf(0), 0), // 0
+                (BitConverter.UInt16BitsToHalf(0b1_00000_0000000000), -0f), // -0
+                (BitConverter.UInt16BitsToHalf(0b0_10000_1001001000), 3.140625f), // 3.140625
+                (BitConverter.UInt16BitsToHalf(0b1_10000_1001001000), -3.140625f), // -3.140625
+                (BitConverter.UInt16BitsToHalf(0b0_10000_0101110000), 2.71875f), // 2.71875
+                (BitConverter.UInt16BitsToHalf(0b1_10000_0101110000), -2.71875f), // -2.71875
+                (BitConverter.UInt16BitsToHalf(0b0_01111_1000000000), 1.5f), // 1.5
+                (BitConverter.UInt16BitsToHalf(0b1_01111_1000000000), -1.5f), // -1.5
+                (BitConverter.UInt16BitsToHalf(0b0_01111_1000000001), 1.5009765625f), // 1.5009765625
+                (BitConverter.UInt16BitsToHalf(0b1_01111_1000000001), -1.5009765625f), // -1.5009765625
+                (BitConverter.UInt16BitsToHalf(0b0_00001_0000000000), BitConverter.Int32BitsToSingle(0x38800000)), // smallest normal
+                (BitConverter.UInt16BitsToHalf(0b0_00000_1111111111), BitConverter.Int32BitsToSingle(0x387FC000)), // largest subnormal
+                (BitConverter.UInt16BitsToHalf(0b0_00000_1000000000), BitConverter.Int32BitsToSingle(0x38000000)), // middle subnormal
+                (BitConverter.UInt16BitsToHalf(0b0_00000_0111111111), BitConverter.Int32BitsToSingle(0x37FF8000)), // just below middle subnormal
+                (BitConverter.UInt16BitsToHalf(0b0_00000_0000000001), BitConverter.Int32BitsToSingle(0x33800000)), // smallest subnormal
+                (BitConverter.UInt16BitsToHalf(0b1_00000_0000000001), BitConverter.Int32BitsToSingle(unchecked((int)0xB3800000))), // highest negative subnormal
+                (BitConverter.UInt16BitsToHalf(0b1_00000_0111111111), BitConverter.Int32BitsToSingle(unchecked((int)0xB7FF8000))), // just above negative middle subnormal
+                (BitConverter.UInt16BitsToHalf(0b1_00000_1000000000), BitConverter.Int32BitsToSingle(unchecked((int)0xB8000000))), // negative middle subnormal
+                (BitConverter.UInt16BitsToHalf(0b1_00000_1111111111), BitConverter.Int32BitsToSingle(unchecked((int)0xB87FC000))), // lowest negative subnormal
+                (BitConverter.UInt16BitsToHalf(0b1_00001_0000000000), BitConverter.Int32BitsToSingle(unchecked((int)0xB8800000))) // highest negative normal
             };
 
             foreach ((Half original, float expected) in data)
@@ -406,41 +396,41 @@ public static IEnumerable<object[]> ExplicitConversion_ToDouble_TestData()
         {
             (Half Original, double Expected)[] data = // Fraction is shifted left by 42, Exponent is -15 then +127 = +112
             {
-                (UInt16BitsToHalf(0b0_01111_0000000000), 1d), // 1
-                (UInt16BitsToHalf(0b1_01111_0000000000), -1d), // -1
+                (BitConverter.UInt16BitsToHalf(0b0_01111_0000000000), 1d), // 1
+                (BitConverter.UInt16BitsToHalf(0b1_01111_0000000000), -1d), // -1
                 (Half.MaxValue, 65504d), // 65500
                 (Half.MinValue, -65504d), // -65500
-                (UInt16BitsToHalf(0b0_01011_1001100110), 0.0999755859375d), // 0.1ish
-                (UInt16BitsToHalf(0b1_01011_1001100110), -0.0999755859375d), // -0.1ish
-                (UInt16BitsToHalf(0b0_10100_0101000000), 42d), // 42
-                (UInt16BitsToHalf(0b1_10100_0101000000), -42d), // -42
+                (BitConverter.UInt16BitsToHalf(0b0_01011_1001100110), 0.0999755859375d), // 0.1ish
+                (BitConverter.UInt16BitsToHalf(0b1_01011_1001100110), -0.0999755859375d), // -0.1ish
+                (BitConverter.UInt16BitsToHalf(0b0_10100_0101000000), 42d), // 42
+                (BitConverter.UInt16BitsToHalf(0b1_10100_0101000000), -42d), // -42
                 (Half.PositiveInfinity, double.PositiveInfinity), // PosInfinity
                 (Half.NegativeInfinity, double.NegativeInfinity), // NegInfinity
-                (UInt16BitsToHalf(0b0_11111_1000000000), BitConverter.Int64BitsToDouble(0x7FF80000_00000000)), // Positive Quiet NaN
+                (BitConverter.UInt16BitsToHalf(0b0_11111_1000000000), BitConverter.Int64BitsToDouble(0x7FF80000_00000000)), // Positive Quiet NaN
                 (Half.NaN, double.NaN), // Negative Quiet NaN
-                (UInt16BitsToHalf(0b0_11111_1010101010), BitConverter.Int64BitsToDouble(0x7FFAA800_00000000)), // Positive Signalling NaN - Should preserve payload
-                (UInt16BitsToHalf(0b1_11111_1010101010), BitConverter.Int64BitsToDouble(unchecked((long)0xFFFAA800_00000000))), // Negative Signalling NaN - Should preserve payload
+                (BitConverter.UInt16BitsToHalf(0b0_11111_1010101010), BitConverter.Int64BitsToDouble(0x7FFAA800_00000000)), // Positive Signalling NaN - Should preserve payload
+                (BitConverter.UInt16BitsToHalf(0b1_11111_1010101010), BitConverter.Int64BitsToDouble(unchecked((long)0xFFFAA800_00000000))), // Negative Signalling NaN - Should preserve payload
                 (Half.Epsilon, 1/16777216d), // PosEpsilon = 0.000000059605...
-                (UInt16BitsToHalf(0), 0d), // 0
-                (UInt16BitsToHalf(0b1_00000_0000000000), -0d), // -0
-                (UInt16BitsToHalf(0b0_10000_1001001000), 3.140625d), // 3.140625
-                (UInt16BitsToHalf(0b1_10000_1001001000), -3.140625d), // -3.140625
-                (UInt16BitsToHalf(0b0_10000_0101110000), 2.71875d), // 2.71875
-                (UInt16BitsToHalf(0b1_10000_0101110000), -2.71875d), // -2.71875
-                (UInt16BitsToHalf(0b0_01111_1000000000), 1.5d), // 1.5
-                (UInt16BitsToHalf(0b1_01111_1000000000), -1.5d), // -1.5
-                (UInt16BitsToHalf(0b0_01111_1000000001), 1.5009765625d), // 1.5009765625
-                (UInt16BitsToHalf(0b1_01111_1000000001), -1.5009765625d), // -1.5009765625
-                (UInt16BitsToHalf(0b0_00001_0000000000), BitConverter.Int64BitsToDouble(0x3F10000000000000)), // smallest normal
-                (UInt16BitsToHalf(0b0_00000_1111111111), BitConverter.Int64BitsToDouble(0x3F0FF80000000000)), // largest subnormal
-                (UInt16BitsToHalf(0b0_00000_1000000000), BitConverter.Int64BitsToDouble(0x3F00000000000000)), // middle subnormal
-                (UInt16BitsToHalf(0b0_00000_0111111111), BitConverter.Int64BitsToDouble(0x3EFFF00000000000)), // just below middle subnormal
-                (UInt16BitsToHalf(0b0_00000_0000000001), BitConverter.Int64BitsToDouble(0x3E70000000000000)), // smallest subnormal
-                (UInt16BitsToHalf(0b1_00000_0000000001), BitConverter.Int64BitsToDouble(unchecked((long)0xBE70000000000000))), // highest negative subnormal
-                (UInt16BitsToHalf(0b1_00000_0111111111), BitConverter.Int64BitsToDouble(unchecked((long)0xBEFFF00000000000))), // just above negative middle subnormal
-                (UInt16BitsToHalf(0b1_00000_1000000000), BitConverter.Int64BitsToDouble(unchecked((long)0xBF00000000000000))), // negative middle subnormal
-                (UInt16BitsToHalf(0b1_00000_1111111111), BitConverter.Int64BitsToDouble(unchecked((long)0xBF0FF80000000000))), // lowest negative subnormal
-                (UInt16BitsToHalf(0b1_00001_0000000000), BitConverter.Int64BitsToDouble(unchecked((long)0xBF10000000000000))) // highest negative normal
+                (BitConverter.UInt16BitsToHalf(0), 0d), // 0
+                (BitConverter.UInt16BitsToHalf(0b1_00000_0000000000), -0d), // -0
+                (BitConverter.UInt16BitsToHalf(0b0_10000_1001001000), 3.140625d), // 3.140625
+                (BitConverter.UInt16BitsToHalf(0b1_10000_1001001000), -3.140625d), // -3.140625
+                (BitConverter.UInt16BitsToHalf(0b0_10000_0101110000), 2.71875d), // 2.71875
+                (BitConverter.UInt16BitsToHalf(0b1_10000_0101110000), -2.71875d), // -2.71875
+                (BitConverter.UInt16BitsToHalf(0b0_01111_1000000000), 1.5d), // 1.5
+                (BitConverter.UInt16BitsToHalf(0b1_01111_1000000000), -1.5d), // -1.5
+                (BitConverter.UInt16BitsToHalf(0b0_01111_1000000001), 1.5009765625d), // 1.5009765625
+                (BitConverter.UInt16BitsToHalf(0b1_01111_1000000001), -1.5009765625d), // -1.5009765625
+                (BitConverter.UInt16BitsToHalf(0b0_00001_0000000000), BitConverter.Int64BitsToDouble(0x3F10000000000000)), // smallest normal
+                (BitConverter.UInt16BitsToHalf(0b0_00000_1111111111), BitConverter.Int64BitsToDouble(0x3F0FF80000000000)), // largest subnormal
+                (BitConverter.UInt16BitsToHalf(0b0_00000_1000000000), BitConverter.Int64BitsToDouble(0x3F00000000000000)), // middle subnormal
+                (BitConverter.UInt16BitsToHalf(0b0_00000_0111111111), BitConverter.Int64BitsToDouble(0x3EFFF00000000000)), // just below middle subnormal
+                (BitConverter.UInt16BitsToHalf(0b0_00000_0000000001), BitConverter.Int64BitsToDouble(0x3E70000000000000)), // smallest subnormal
+                (BitConverter.UInt16BitsToHalf(0b1_00000_0000000001), BitConverter.Int64BitsToDouble(unchecked((long)0xBE70000000000000))), // highest negative subnormal
+                (BitConverter.UInt16BitsToHalf(0b1_00000_0111111111), BitConverter.Int64BitsToDouble(unchecked((long)0xBEFFF00000000000))), // just above negative middle subnormal
+                (BitConverter.UInt16BitsToHalf(0b1_00000_1000000000), BitConverter.Int64BitsToDouble(unchecked((long)0xBF00000000000000))), // negative middle subnormal
+                (BitConverter.UInt16BitsToHalf(0b1_00000_1111111111), BitConverter.Int64BitsToDouble(unchecked((long)0xBF0FF80000000000))), // lowest negative subnormal
+                (BitConverter.UInt16BitsToHalf(0b1_00001_0000000000), BitConverter.Int64BitsToDouble(unchecked((long)0xBF10000000000000))) // highest negative normal
             };
 
             foreach ((Half original, double expected) in data)
@@ -462,73 +452,73 @@ public static IEnumerable<object[]> ExplicitConversion_FromSingle_TestData()
         {
             (float, Half)[] data =
             {
-                (MathF.PI, UInt16BitsToHalf(0b0_10000_1001001000)), // 3.140625
-                (MathF.E, UInt16BitsToHalf(0b0_10000_0101110000)), // 2.71875
-                (-MathF.PI, UInt16BitsToHalf(0b1_10000_1001001000)), // -3.140625
-                (-MathF.E, UInt16BitsToHalf(0b1_10000_0101110000)), // -2.71875
+                (MathF.PI, BitConverter.UInt16BitsToHalf(0b0_10000_1001001000)), // 3.140625
+                (MathF.E, BitConverter.UInt16BitsToHalf(0b0_10000_0101110000)), // 2.71875
+                (-MathF.PI, BitConverter.UInt16BitsToHalf(0b1_10000_1001001000)), // -3.140625
+                (-MathF.E, BitConverter.UInt16BitsToHalf(0b1_10000_0101110000)), // -2.71875
                 (float.MaxValue, Half.PositiveInfinity), // Overflow
                 (float.MinValue, Half.NegativeInfinity), // Overflow
                 (float.PositiveInfinity, Half.PositiveInfinity), // Overflow
                 (float.NegativeInfinity, Half.NegativeInfinity), // Overflow
                 (float.NaN, Half.NaN), // Quiet Negative NaN
-                (BitConverter.Int32BitsToSingle(0x7FC00000), UInt16BitsToHalf(0b0_11111_1000000000)), // Quiet Positive NaN
+                (BitConverter.Int32BitsToSingle(0x7FC00000), BitConverter.UInt16BitsToHalf(0b0_11111_1000000000)), // Quiet Positive NaN
                 (BitConverter.Int32BitsToSingle(unchecked((int)0xFFD55555)),
-                    UInt16BitsToHalf(0b1_11111_1010101010)), // Signalling Negative NaN
-                (BitConverter.Int32BitsToSingle(0x7FD55555), UInt16BitsToHalf(0b0_11111_1010101010)), // Signalling Positive NaN
-                (float.Epsilon, UInt16BitsToHalf(0)), // Underflow
-                (-float.Epsilon, UInt16BitsToHalf(0b1_00000_0000000000)), // Underflow
-                (1f, UInt16BitsToHalf(0b0_01111_0000000000)), // 1
-                (-1f, UInt16BitsToHalf(0b1_01111_0000000000)), // -1
-                (0f, UInt16BitsToHalf(0)), // 0
-                (-0f, UInt16BitsToHalf(0b1_00000_0000000000)), // -0
-                (42f, UInt16BitsToHalf(0b0_10100_0101000000)), // 42
-                (-42f, UInt16BitsToHalf(0b1_10100_0101000000)), // -42
-                (0.1f, UInt16BitsToHalf(0b0_01011_1001100110)), // 0.0999755859375
-                (-0.1f, UInt16BitsToHalf(0b1_01011_1001100110)), // -0.0999755859375
-                (1.5f, UInt16BitsToHalf(0b0_01111_1000000000)), // 1.5
-                (-1.5f, UInt16BitsToHalf(0b1_01111_1000000000)), // -1.5
-                (1.5009765625f, UInt16BitsToHalf(0b0_01111_1000000001)), // 1.5009765625
-                (-1.5009765625f, UInt16BitsToHalf(0b1_01111_1000000001)), // -1.5009765625
-                (BitConverter.Int32BitsToSingle(0x38800000), UInt16BitsToHalf(0b0_00001_0000000000)), // smallest normal
-                (BitConverter.Int32BitsToSingle(0x387FC000), UInt16BitsToHalf(0b0_00000_1111111111)), // largest subnormal
-                (BitConverter.Int32BitsToSingle(0x38000000), UInt16BitsToHalf(0b0_00000_1000000000)), // middle subnormal
-                (BitConverter.Int32BitsToSingle(0x37FF8000), UInt16BitsToHalf(0b0_00000_0111111111)), // just below middle subnormal
-                (BitConverter.Int32BitsToSingle(0x33800000), UInt16BitsToHalf(0b0_00000_0000000001)), // smallest subnormal
+                    BitConverter.UInt16BitsToHalf(0b1_11111_1010101010)), // Signalling Negative NaN
+                (BitConverter.Int32BitsToSingle(0x7FD55555), BitConverter.UInt16BitsToHalf(0b0_11111_1010101010)), // Signalling Positive NaN
+                (float.Epsilon, BitConverter.UInt16BitsToHalf(0)), // Underflow
+                (-float.Epsilon, BitConverter.UInt16BitsToHalf(0b1_00000_0000000000)), // Underflow
+                (1f, BitConverter.UInt16BitsToHalf(0b0_01111_0000000000)), // 1
+                (-1f, BitConverter.UInt16BitsToHalf(0b1_01111_0000000000)), // -1
+                (0f, BitConverter.UInt16BitsToHalf(0)), // 0
+                (-0f, BitConverter.UInt16BitsToHalf(0b1_00000_0000000000)), // -0
+                (42f, BitConverter.UInt16BitsToHalf(0b0_10100_0101000000)), // 42
+                (-42f, BitConverter.UInt16BitsToHalf(0b1_10100_0101000000)), // -42
+                (0.1f, BitConverter.UInt16BitsToHalf(0b0_01011_1001100110)), // 0.0999755859375
+                (-0.1f, BitConverter.UInt16BitsToHalf(0b1_01011_1001100110)), // -0.0999755859375
+                (1.5f, BitConverter.UInt16BitsToHalf(0b0_01111_1000000000)), // 1.5
+                (-1.5f, BitConverter.UInt16BitsToHalf(0b1_01111_1000000000)), // -1.5
+                (1.5009765625f, BitConverter.UInt16BitsToHalf(0b0_01111_1000000001)), // 1.5009765625
+                (-1.5009765625f, BitConverter.UInt16BitsToHalf(0b1_01111_1000000001)), // -1.5009765625
+                (BitConverter.Int32BitsToSingle(0x38800000), BitConverter.UInt16BitsToHalf(0b0_00001_0000000000)), // smallest normal
+                (BitConverter.Int32BitsToSingle(0x387FC000), BitConverter.UInt16BitsToHalf(0b0_00000_1111111111)), // largest subnormal
+                (BitConverter.Int32BitsToSingle(0x38000000), BitConverter.UInt16BitsToHalf(0b0_00000_1000000000)), // middle subnormal
+                (BitConverter.Int32BitsToSingle(0x37FF8000), BitConverter.UInt16BitsToHalf(0b0_00000_0111111111)), // just below middle subnormal
+                (BitConverter.Int32BitsToSingle(0x33800000), BitConverter.UInt16BitsToHalf(0b0_00000_0000000001)), // smallest subnormal
                 (BitConverter.Int32BitsToSingle(unchecked((int)0xB3800000)),
-                    UInt16BitsToHalf(0b1_00000_0000000001)), // highest negative subnormal
+                    BitConverter.UInt16BitsToHalf(0b1_00000_0000000001)), // highest negative subnormal
                 (BitConverter.Int32BitsToSingle(unchecked((int)0xB7FF8000)),
-                    UInt16BitsToHalf(0b1_00000_0111111111)), // just above negative middle subnormal
+                    BitConverter.UInt16BitsToHalf(0b1_00000_0111111111)), // just above negative middle subnormal
                 (BitConverter.Int32BitsToSingle(unchecked((int)0xB8000000)),
-                    UInt16BitsToHalf(0b1_00000_1000000000)), // negative middle subnormal
+                    BitConverter.UInt16BitsToHalf(0b1_00000_1000000000)), // negative middle subnormal
                 (BitConverter.Int32BitsToSingle(unchecked((int)0xB87FC000)),
-                    UInt16BitsToHalf(0b1_00000_1111111111)), // lowest negative subnormal
+                    BitConverter.UInt16BitsToHalf(0b1_00000_1111111111)), // lowest negative subnormal
                 (BitConverter.Int32BitsToSingle(unchecked((int)0xB8800000)),
-                    UInt16BitsToHalf(0b1_00001_0000000000)), // highest negative normal
+                    BitConverter.UInt16BitsToHalf(0b1_00001_0000000000)), // highest negative normal
                 (BitConverter.Int32BitsToSingle(0b0_10001001_00000000111000000000001),
-                                  UInt16BitsToHalf(0b0_11001_0000000100)), // 1027.5+ULP rounds up
+                                  BitConverter.UInt16BitsToHalf(0b0_11001_0000000100)), // 1027.5+ULP rounds up
                 (BitConverter.Int32BitsToSingle(0b0_10001001_00000000111000000000000),
-                                  UInt16BitsToHalf(0b0_11001_0000000100)), // 1027.5 rounds to even
+                                  BitConverter.UInt16BitsToHalf(0b0_11001_0000000100)), // 1027.5 rounds to even
                 (BitConverter.Int32BitsToSingle(0b0_10001001_00000000110111111111111),
-                                  UInt16BitsToHalf(0b0_11001_0000000011)), // 1027.5-ULP rounds down
+                                  BitConverter.UInt16BitsToHalf(0b0_11001_0000000011)), // 1027.5-ULP rounds down
                 (BitConverter.Int32BitsToSingle(unchecked((int)0b1_10001001_00000000110111111111111)),
-                                                 UInt16BitsToHalf(0b1_11001_0000000011)), // -1027.5+ULP rounds towards zero
+                                                 BitConverter.UInt16BitsToHalf(0b1_11001_0000000011)), // -1027.5+ULP rounds towards zero
                 (BitConverter.Int32BitsToSingle(unchecked((int)0b1_10001001_00000000111000000000000)),
-                                                 UInt16BitsToHalf(0b1_11001_0000000100)), // -1027.5 rounds to even
+                                                 BitConverter.UInt16BitsToHalf(0b1_11001_0000000100)), // -1027.5 rounds to even
                 (BitConverter.Int32BitsToSingle(unchecked((int)0b1_10001001_00000000111000000000001)),
-                                                 UInt16BitsToHalf(0b1_11001_0000000100)), // -1027.5-ULP rounds away from zero
+                                                 BitConverter.UInt16BitsToHalf(0b1_11001_0000000100)), // -1027.5-ULP rounds away from zero
                 (BitConverter.Int32BitsToSingle(0b0_01110000_00000001110000000000001),
-                                 UInt16BitsToHalf(0b0_00000_1000000100)), // subnormal + ULP rounds up
+                                 BitConverter.UInt16BitsToHalf(0b0_00000_1000000100)), // subnormal + ULP rounds up
                 (BitConverter.Int32BitsToSingle(0b0_01110000_00000001110000000000000),
-                                 UInt16BitsToHalf(0b0_00000_1000000100)), // subnormal rounds to even
+                                 BitConverter.UInt16BitsToHalf(0b0_00000_1000000100)), // subnormal rounds to even
                 (BitConverter.Int32BitsToSingle(0b0_01110000_00000001101111111111111),
-                                 UInt16BitsToHalf(0b0_00000_1000000011)), // subnormal - ULP rounds down
+                                 BitConverter.UInt16BitsToHalf(0b0_00000_1000000011)), // subnormal - ULP rounds down
                 (BitConverter.Int32BitsToSingle(unchecked((int)0b1_01110000_00000001101111111111111)),
-                                                UInt16BitsToHalf(0b1_00000_1000000011)), // neg subnormal + ULP rounds higher
+                                                BitConverter.UInt16BitsToHalf(0b1_00000_1000000011)), // neg subnormal + ULP rounds higher
                 (BitConverter.Int32BitsToSingle(unchecked((int)0b1_01110000_00000001110000000000000)),
-                                                UInt16BitsToHalf(0b1_00000_1000000100)), // neg subnormal rounds to even
+                                                BitConverter.UInt16BitsToHalf(0b1_00000_1000000100)), // neg subnormal rounds to even
                 (BitConverter.Int32BitsToSingle(unchecked((int)0b1_01110000_00000001101111111111111)),
-                                                UInt16BitsToHalf(0b1_00000_1000000011)), // neg subnormal - ULP rounds lower,
-                (BitConverter.Int32BitsToSingle(0x33000000), UInt16BitsToHalf(0b0_00000_000000000)), // (half-precision minimum subnormal / 2) should underflow to zero
+                                                BitConverter.UInt16BitsToHalf(0b1_00000_1000000011)), // neg subnormal - ULP rounds lower,
+                (BitConverter.Int32BitsToSingle(0x33000000), BitConverter.UInt16BitsToHalf(0b0_00000_000000000)), // (half-precision minimum subnormal / 2) should underflow to zero
             };
 
             foreach ((float original, Half expected) in data)
@@ -542,87 +532,87 @@ public static IEnumerable<object[]> ExplicitConversion_FromSingle_TestData()
         public static void ExplicitConversion_FromSingle(float f, Half expected) // Check the underlying bits for verifying NaNs
         {
             Half h = (Half)f;
-            Assert.Equal(HalfToUInt16Bits(expected), HalfToUInt16Bits(h));
+            Assert.Equal(BitConverter.HalfToUInt16Bits(expected), BitConverter.HalfToUInt16Bits(h));
         }
 
         public static IEnumerable<object[]> ExplicitConversion_FromDouble_TestData()
         {
             (double, Half)[] data =
             {
-                (Math.PI, UInt16BitsToHalf(0b0_10000_1001001000)), // 3.140625
-                (Math.E, UInt16BitsToHalf(0b0_10000_0101110000)), // 2.71875
-                (-Math.PI, UInt16BitsToHalf(0b1_10000_1001001000)), // -3.140625
-                (-Math.E, UInt16BitsToHalf(0b1_10000_0101110000)), // -2.71875
+                (Math.PI, BitConverter.UInt16BitsToHalf(0b0_10000_1001001000)), // 3.140625
+                (Math.E, BitConverter.UInt16BitsToHalf(0b0_10000_0101110000)), // 2.71875
+                (-Math.PI, BitConverter.UInt16BitsToHalf(0b1_10000_1001001000)), // -3.140625
+                (-Math.E, BitConverter.UInt16BitsToHalf(0b1_10000_0101110000)), // -2.71875
                 (double.MaxValue, Half.PositiveInfinity), // Overflow
                 (double.MinValue, Half.NegativeInfinity), // Overflow
                 (double.PositiveInfinity, Half.PositiveInfinity), // Overflow
                 (double.NegativeInfinity, Half.NegativeInfinity), // Overflow
                 (double.NaN, Half.NaN), // Quiet Negative NaN
                 (BitConverter.Int64BitsToDouble(0x7FF80000_00000000),
-                    UInt16BitsToHalf(0b0_11111_1000000000)), // Quiet Positive NaN
+                    BitConverter.UInt16BitsToHalf(0b0_11111_1000000000)), // Quiet Positive NaN
                 (BitConverter.Int64BitsToDouble(unchecked((long)0xFFFAAAAA_AAAAAAAA)),
-                    UInt16BitsToHalf(0b1_11111_1010101010)), // Signalling Negative NaN
+                    BitConverter.UInt16BitsToHalf(0b1_11111_1010101010)), // Signalling Negative NaN
                 (BitConverter.Int64BitsToDouble(0x7FFAAAAA_AAAAAAAA),
-                    UInt16BitsToHalf(0b0_11111_1010101010)), // Signalling Positive NaN
-                (double.Epsilon, UInt16BitsToHalf(0)), // Underflow
-                (-double.Epsilon, UInt16BitsToHalf(0b1_00000_0000000000)), // Underflow
-                (1d, UInt16BitsToHalf(0b0_01111_0000000000)), // 1
-                (-1d, UInt16BitsToHalf(0b1_01111_0000000000)), // -1
-                (0d, UInt16BitsToHalf(0)), // 0
-                (-0d, UInt16BitsToHalf(0b1_00000_0000000000)), // -0
-                (42d, UInt16BitsToHalf(0b0_10100_0101000000)), // 42
-                (-42d, UInt16BitsToHalf(0b1_10100_0101000000)), // -42
-                (0.1d, UInt16BitsToHalf(0b0_01011_1001100110)), // 0.0999755859375
-                (-0.1d, UInt16BitsToHalf(0b1_01011_1001100110)), // -0.0999755859375
-                (1.5d, UInt16BitsToHalf(0b0_01111_1000000000)), // 1.5
-                (-1.5d, UInt16BitsToHalf(0b1_01111_1000000000)), // -1.5
-                (1.5009765625d, UInt16BitsToHalf(0b0_01111_1000000001)), // 1.5009765625
-                (-1.5009765625d, UInt16BitsToHalf(0b1_01111_1000000001)), // -1.5009765625
+                    BitConverter.UInt16BitsToHalf(0b0_11111_1010101010)), // Signalling Positive NaN
+                (double.Epsilon, BitConverter.UInt16BitsToHalf(0)), // Underflow
+                (-double.Epsilon, BitConverter.UInt16BitsToHalf(0b1_00000_0000000000)), // Underflow
+                (1d, BitConverter.UInt16BitsToHalf(0b0_01111_0000000000)), // 1
+                (-1d, BitConverter.UInt16BitsToHalf(0b1_01111_0000000000)), // -1
+                (0d, BitConverter.UInt16BitsToHalf(0)), // 0
+                (-0d, BitConverter.UInt16BitsToHalf(0b1_00000_0000000000)), // -0
+                (42d, BitConverter.UInt16BitsToHalf(0b0_10100_0101000000)), // 42
+                (-42d, BitConverter.UInt16BitsToHalf(0b1_10100_0101000000)), // -42
+                (0.1d, BitConverter.UInt16BitsToHalf(0b0_01011_1001100110)), // 0.0999755859375
+                (-0.1d, BitConverter.UInt16BitsToHalf(0b1_01011_1001100110)), // -0.0999755859375
+                (1.5d, BitConverter.UInt16BitsToHalf(0b0_01111_1000000000)), // 1.5
+                (-1.5d, BitConverter.UInt16BitsToHalf(0b1_01111_1000000000)), // -1.5
+                (1.5009765625d, BitConverter.UInt16BitsToHalf(0b0_01111_1000000001)), // 1.5009765625
+                (-1.5009765625d, BitConverter.UInt16BitsToHalf(0b1_01111_1000000001)), // -1.5009765625
                 (BitConverter.Int64BitsToDouble(0x3F10000000000000),
-                    UInt16BitsToHalf(0b0_00001_0000000000)), // smallest normal
+                    BitConverter.UInt16BitsToHalf(0b0_00001_0000000000)), // smallest normal
                 (BitConverter.Int64BitsToDouble(0x3F0FF80000000000),
-                    UInt16BitsToHalf(0b0_00000_1111111111)), // largest subnormal
+                    BitConverter.UInt16BitsToHalf(0b0_00000_1111111111)), // largest subnormal
                 (BitConverter.Int64BitsToDouble(0x3f00000000000000),
-                    UInt16BitsToHalf(0b0_00000_1000000000)), // middle subnormal
+                    BitConverter.UInt16BitsToHalf(0b0_00000_1000000000)), // middle subnormal
                 (BitConverter.Int64BitsToDouble(0x3EFFF00000000000),
-                    UInt16BitsToHalf(0b0_00000_0111111111)), // just below middle subnormal
+                    BitConverter.UInt16BitsToHalf(0b0_00000_0111111111)), // just below middle subnormal
                 (BitConverter.Int64BitsToDouble(0x3E70000000000000),
-                    UInt16BitsToHalf(0b0_00000_0000000001)), // smallest subnormal
+                    BitConverter.UInt16BitsToHalf(0b0_00000_0000000001)), // smallest subnormal
                 (BitConverter.Int64BitsToDouble(unchecked((long)0xBE70000000000000)),
-                    UInt16BitsToHalf(0b1_00000_0000000001)), // highest negative subnormal
+                    BitConverter.UInt16BitsToHalf(0b1_00000_0000000001)), // highest negative subnormal
                 (BitConverter.Int64BitsToDouble(unchecked((long)0xBEFFF00000000000)),
-                    UInt16BitsToHalf(0b1_00000_0111111111)), // just above negative middle subnormal
+                    BitConverter.UInt16BitsToHalf(0b1_00000_0111111111)), // just above negative middle subnormal
                 (BitConverter.Int64BitsToDouble(unchecked((long)0xBF00000000000000)),
-                    UInt16BitsToHalf(0b1_00000_1000000000)), // negative middle subnormal
+                    BitConverter.UInt16BitsToHalf(0b1_00000_1000000000)), // negative middle subnormal
                 (BitConverter.Int64BitsToDouble(unchecked((long)0xBF0FF80000000000)),
-                    UInt16BitsToHalf(0b1_00000_1111111111)), // lowest negative subnormal
+                    BitConverter.UInt16BitsToHalf(0b1_00000_1111111111)), // lowest negative subnormal
                 (BitConverter.Int64BitsToDouble(unchecked((long)0xBF10000000000000)),
-                    UInt16BitsToHalf(0b1_00001_0000000000)), // highest negative normal
+                    BitConverter.UInt16BitsToHalf(0b1_00001_0000000000)), // highest negative normal
                 (BitConverter.Int64BitsToDouble(0x40900E0000000001),
-                    UInt16BitsToHalf(0b0_11001_0000000100)), // 1027.5+ULP rounds up
+                    BitConverter.UInt16BitsToHalf(0b0_11001_0000000100)), // 1027.5+ULP rounds up
                 (BitConverter.Int64BitsToDouble(0x40900E0000000000),
-                    UInt16BitsToHalf(0b0_11001_0000000100)), // 1027.5 rounds to even
+                    BitConverter.UInt16BitsToHalf(0b0_11001_0000000100)), // 1027.5 rounds to even
                 (BitConverter.Int64BitsToDouble(0x40900DFFFFFFFFFF),
-                    UInt16BitsToHalf(0b0_11001_0000000011)), // 1027.5-ULP rounds down
+                    BitConverter.UInt16BitsToHalf(0b0_11001_0000000011)), // 1027.5-ULP rounds down
                 (BitConverter.Int64BitsToDouble(unchecked((long)0xC0900DFFFFFFFFFF)),
-                    UInt16BitsToHalf(0b1_11001_0000000011)), // -1027.5+ULP rounds towards zero
+                    BitConverter.UInt16BitsToHalf(0b1_11001_0000000011)), // -1027.5+ULP rounds towards zero
                 (BitConverter.Int64BitsToDouble(unchecked((long)0xC0900E0000000000)),
-                    UInt16BitsToHalf(0b1_11001_0000000100)), // -1027.5 rounds to even
+                    BitConverter.UInt16BitsToHalf(0b1_11001_0000000100)), // -1027.5 rounds to even
                 (BitConverter.Int64BitsToDouble(unchecked((long)0xC0900E0000000001)),
-                    UInt16BitsToHalf(0b1_11001_0000000100)), // -1027.5-ULP rounds away from zero
+                    BitConverter.UInt16BitsToHalf(0b1_11001_0000000100)), // -1027.5-ULP rounds away from zero
                 (BitConverter.Int64BitsToDouble(0x3F001C0000000001),
-                    UInt16BitsToHalf(0b0_00000_1000000100)), // subnormal + ULP rounds up
+                    BitConverter.UInt16BitsToHalf(0b0_00000_1000000100)), // subnormal + ULP rounds up
                 (BitConverter.Int64BitsToDouble(0x3F001C0000000001),
-                    UInt16BitsToHalf(0b0_00000_1000000100)), // subnormal rounds to even
+                    BitConverter.UInt16BitsToHalf(0b0_00000_1000000100)), // subnormal rounds to even
                 (BitConverter.Int64BitsToDouble(0x3F001BFFFFFFFFFF),
-                    UInt16BitsToHalf(0b0_00000_1000000011)), // subnormal - ULP rounds down
+                    BitConverter.UInt16BitsToHalf(0b0_00000_1000000011)), // subnormal - ULP rounds down
                 (BitConverter.Int64BitsToDouble(unchecked((long)0xBF001BFFFFFFFFFF)),
-                    UInt16BitsToHalf(0b1_00000_1000000011)), // neg subnormal + ULP rounds higher
+                    BitConverter.UInt16BitsToHalf(0b1_00000_1000000011)), // neg subnormal + ULP rounds higher
                 (BitConverter.Int64BitsToDouble(unchecked((long)0xBF001C0000000000)),
-                    UInt16BitsToHalf(0b1_00000_1000000100)), // neg subnormal rounds to even
+                    BitConverter.UInt16BitsToHalf(0b1_00000_1000000100)), // neg subnormal rounds to even
                 (BitConverter.Int64BitsToDouble(unchecked((long)0xBF001C0000000001)),
-                    UInt16BitsToHalf(0b1_00000_1000000100)), // neg subnormal - ULP rounds lower
-                (BitConverter.Int64BitsToDouble(0x3E60000000000000), UInt16BitsToHalf(0b0_00000_000000000)), // (half-precision minimum subnormal / 2) should underflow to zero
+                    BitConverter.UInt16BitsToHalf(0b1_00000_1000000100)), // neg subnormal - ULP rounds lower
+                (BitConverter.Int64BitsToDouble(0x3E60000000000000), BitConverter.UInt16BitsToHalf(0b0_00000_000000000)), // (half-precision minimum subnormal / 2) should underflow to zero
             };
 
             foreach ((double original, Half expected) in data)
@@ -636,7 +626,7 @@ public static IEnumerable<object[]> ExplicitConversion_FromDouble_TestData()
         public static void ExplicitConversion_FromDouble(double d, Half expected) // Check the underlying bits for verifying NaNs
         {
             Half h = (Half)d;
-            Assert.Equal(HalfToUInt16Bits(expected), HalfToUInt16Bits(h));
+            Assert.Equal(BitConverter.HalfToUInt16Bits(expected), BitConverter.HalfToUInt16Bits(h));
         }
 
         public static IEnumerable<object[]> Parse_Valid_TestData()
@@ -1033,16 +1023,16 @@ public static IEnumerable<object[]> ToStringRoundtrip_TestData()
             yield return new object[] { Half.MaxValue };
             yield return new object[] { Half.PositiveInfinity };
 
-            yield return new object[] { (UInt16BitsToHalf(0b0_00001_0000000000)) }; // smallest normal
-            yield return new object[] { (UInt16BitsToHalf(0b0_00000_1111111111)) }; // largest subnormal
-            yield return new object[] { (UInt16BitsToHalf(0b0_00000_1000000000)) }; // middle subnormal
-            yield return new object[] { (UInt16BitsToHalf(0b0_00000_0111111111)) }; // just below middle subnormal
-            yield return new object[] { (UInt16BitsToHalf(0b0_00000_0000000001)) }; // smallest subnormal
-            yield return new object[] { (UInt16BitsToHalf(0b1_00000_0000000001)) }; // highest negative subnormal
-            yield return new object[] { (UInt16BitsToHalf(0b1_00000_0111111111)) }; // just above negative middle subnormal
-            yield return new object[] { (UInt16BitsToHalf(0b1_00000_1000000000)) }; // negative middle subnormal
-            yield return new object[] { (UInt16BitsToHalf(0b1_00000_1111111111)) }; // lowest negative subnormal
-            yield return new object[] { (UInt16BitsToHalf(0b1_00001_0000000000)) }; // highest negative normal
+            yield return new object[] { (BitConverter.UInt16BitsToHalf(0b0_00001_0000000000)) }; // smallest normal
+            yield return new object[] { (BitConverter.UInt16BitsToHalf(0b0_00000_1111111111)) }; // largest subnormal
+            yield return new object[] { (BitConverter.UInt16BitsToHalf(0b0_00000_1000000000)) }; // middle subnormal
+            yield return new object[] { (BitConverter.UInt16BitsToHalf(0b0_00000_0111111111)) }; // just below middle subnormal
+            yield return new object[] { (BitConverter.UInt16BitsToHalf(0b0_00000_0000000001)) }; // smallest subnormal
+            yield return new object[] { (BitConverter.UInt16BitsToHalf(0b1_00000_0000000001)) }; // highest negative subnormal
+            yield return new object[] { (BitConverter.UInt16BitsToHalf(0b1_00000_0111111111)) }; // just above negative middle subnormal
+            yield return new object[] { (BitConverter.UInt16BitsToHalf(0b1_00000_1000000000)) }; // negative middle subnormal
+            yield return new object[] { (BitConverter.UInt16BitsToHalf(0b1_00000_1111111111)) }; // lowest negative subnormal
+            yield return new object[] { (BitConverter.UInt16BitsToHalf(0b1_00001_0000000000)) }; // highest negative normal
         }
 
         [Theory]
@@ -1051,7 +1041,7 @@ public static void ToStringRoundtrip(object o_value)
         {
             float value = o_value is float floatValue ? floatValue : (float)(Half)o_value;
             Half result = Half.Parse(value.ToString());
-            Assert.Equal(HalfToUInt16Bits((Half)value), HalfToUInt16Bits(result));
+            Assert.Equal(BitConverter.HalfToUInt16Bits((Half)value), BitConverter.HalfToUInt16Bits(result));
         }
 
         [Theory]
@@ -1060,7 +1050,7 @@ public static void ToStringRoundtrip_R(object o_value)
         {
             float value = o_value is float floatValue ? floatValue : (float)(Half)o_value;
             Half result = Half.Parse(value.ToString("R"));
-            Assert.Equal(HalfToUInt16Bits((Half)value), HalfToUInt16Bits(result));
+            Assert.Equal(BitConverter.HalfToUInt16Bits((Half)value), BitConverter.HalfToUInt16Bits(result));
         }
 
         public static IEnumerable<object[]> RoundTripFloat_CornerCases()
diff --git a/src/libraries/System.Runtime/tests/System/HashCodeTests.cs b/src/libraries/System.Runtime/tests/System/HashCodeTests.cs
index de2610f121c554..a8162363fc3026 100644
--- a/src/libraries/System.Runtime/tests/System/HashCodeTests.cs
+++ b/src/libraries/System.Runtime/tests/System/HashCodeTests.cs
@@ -3,6 +3,8 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
 using Xunit;
 
 public static class HashCodeTests
@@ -121,6 +123,70 @@ public static void HashCode_Add_NullEqualityComparer()
         Assert.Equal(expected.ToHashCode(), hc.ToHashCode());
     }
 
+    [Fact]
+    public static void HashCode_AddBytes_AllValuesHashed()
+    {
+        // This code depends on HashCode having a private _length field that maps to the number
+        // of Int32 values Add'd, as well as exactly how AddBytes partitions the incoming bytes.
+        // If the implementation changes, this test may need to be updated accordingly.
+
+        FieldInfo lengthField = typeof(HashCode).GetField("_length", BindingFlags.Instance | BindingFlags.NonPublic);
+        int expectedLength = 0;
+        HashCode hc = default;
+        for (int i = 1; i < 100; i++)
+        {
+            hc.AddBytes(Enumerable.Range(1, i).Select(i => (byte)i).ToArray());
+            expectedLength += Math.DivRem(i, 4, out int remainder) + remainder;
+            Assert.Equal(expectedLength, (int)(uint)lengthField.GetValue(hc));
+        }
+    }
+
+    [Fact]
+    public static void HashCode_AddBytes_VariousLengthsHashed()
+    {
+        static void Populate(ref HashCode hc)
+        {
+            hc.AddBytes(new byte[0]);
+            hc.AddBytes(new byte[] { 1 });
+            hc.AddBytes(new byte[] { 1, 2 });
+            hc.AddBytes(new byte[] { 1, 2, 3 });
+            hc.AddBytes(new byte[] { 1, 2, 3, 4 });
+            hc.AddBytes(new byte[] { 1, 2, 3, 4, 5 });
+            hc.AddBytes(Enumerable.Range(0, 10_000).Select(i => (byte)i).ToArray());
+        }
+
+        var hc1 = new HashCode();
+        Populate(ref hc1);
+
+        var hc2 = new HashCode();
+        Populate(ref hc2);
+
+        Assert.Equal(hc1.ToHashCode(), hc2.ToHashCode());
+    }
+
+    [Fact]
+    public static void HashCode_AddBytes_AlignmentDoesntImpactResult()
+    {
+        byte[] data = Enumerable.Range(0, 32).Select(_ => (byte)42).ToArray();
+        for (int length = 1; length < 10; length++)
+        {
+            int? result = null;
+            for (int i = 0; i < data.Length - length; i++)
+            {
+                var hc = new HashCode();
+                hc.AddBytes(new ReadOnlySpan<byte>(data, i, length));
+                if (result is null)
+                {
+                    result = hc.ToHashCode();
+                }
+                else
+                {
+                    Assert.Equal(result.Value, hc.ToHashCode());
+                }
+            }
+        }
+    }
+
     [Fact]
     public static void HashCode_Combine()
     {
diff --git a/src/libraries/System.Runtime/tests/System/Reflection/ModuleTests.cs b/src/libraries/System.Runtime/tests/System/Reflection/ModuleTests.cs
index a481ee253a55e4..29fe532e6c0eb8 100644
--- a/src/libraries/System.Runtime/tests/System/Reflection/ModuleTests.cs
+++ b/src/libraries/System.Runtime/tests/System/Reflection/ModuleTests.cs
@@ -232,6 +232,7 @@ public void GetMethod()
 
         [Fact]
         [ActiveIssue("https://github.com/dotnet/runtime/issues/51912", typeof(PlatformDetection), nameof(PlatformDetection.IsBuiltWithAggressiveTrimming), nameof(PlatformDetection.IsBrowser))]
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/50831")]
         public void GetMethods()
         {
             var methodNames = TestModule.GetMethods().Select(m => m.Name).ToArray();
diff --git a/src/libraries/System.Runtime/tests/System/Runtime/ExceptionServices/ExceptionDispatchInfoTests.cs b/src/libraries/System.Runtime/tests/System/Runtime/ExceptionServices/ExceptionDispatchInfoTests.cs
index e293a1814f29e5..6029e99c1b836f 100644
--- a/src/libraries/System.Runtime/tests/System/Runtime/ExceptionServices/ExceptionDispatchInfoTests.cs
+++ b/src/libraries/System.Runtime/tests/System/Runtime/ExceptionServices/ExceptionDispatchInfoTests.cs
@@ -53,6 +53,7 @@ public static void SetCurrentOrRemoteStackTrace_Invalid_Throws()
         }
 
         [Fact]
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/50957", typeof(PlatformDetection), nameof(PlatformDetection.IsBrowser), nameof(PlatformDetection.IsMonoAOT))]
         public static void SetCurrentStackTrace_IncludedInExceptionStackTrace()
         {
             Exception e;
diff --git a/src/libraries/System.Runtime/tests/System/SingleTests.cs b/src/libraries/System.Runtime/tests/System/SingleTests.cs
index aa850e453cda56..21e07410544ea6 100644
--- a/src/libraries/System.Runtime/tests/System/SingleTests.cs
+++ b/src/libraries/System.Runtime/tests/System/SingleTests.cs
@@ -15,11 +15,6 @@ public partial class SingleTests
     {
         // NOTE: Consider duplicating any tests added here in DoubleTests.cs
 
-        private static uint SingleToUInt32Bits(float value)
-        {
-            return Unsafe.As<float, uint>(ref value);
-        }
-
         [Theory]
         [InlineData("a")]
         [InlineData(234.0)]
@@ -105,7 +100,7 @@ public static void Ctor_Value()
         public static void Epsilon()
         {
             Assert.Equal(1.40129846E-45f, float.Epsilon);
-            Assert.Equal(0x00000001u, SingleToUInt32Bits(float.Epsilon));
+            Assert.Equal(0x00000001u, BitConverter.SingleToUInt32Bits(float.Epsilon));
         }
 
         [Theory]
@@ -223,28 +218,28 @@ public static void IsPositiveInfinity(float d, bool expected)
         public static void MaxValue()
         {
             Assert.Equal(3.40282347E+38f, float.MaxValue);
-            Assert.Equal(0x7F7FFFFFu, SingleToUInt32Bits(float.MaxValue));
+            Assert.Equal(0x7F7FFFFFu, BitConverter.SingleToUInt32Bits(float.MaxValue));
         }
 
         [Fact]
         public static void MinValue()
         {
             Assert.Equal(-3.40282347E+38f, float.MinValue);
-            Assert.Equal(0xFF7FFFFFu, SingleToUInt32Bits(float.MinValue));
+            Assert.Equal(0xFF7FFFFFu, BitConverter.SingleToUInt32Bits(float.MinValue));
         }
 
         [Fact]
         public static void NaN()
         {
             Assert.Equal(0.0f / 0.0f, float.NaN);
-            Assert.Equal(0xFFC00000u, SingleToUInt32Bits(float.NaN));
+            Assert.Equal(0xFFC00000u, BitConverter.SingleToUInt32Bits(float.NaN));
         }
 
         [Fact]
         public static void NegativeInfinity()
         {
             Assert.Equal(-1.0f / 0.0f, float.NegativeInfinity);
-            Assert.Equal(0xFF800000u, SingleToUInt32Bits(float.NegativeInfinity));
+            Assert.Equal(0xFF800000u, BitConverter.SingleToUInt32Bits(float.NegativeInfinity));
         }
 
         public static IEnumerable<object[]> Parse_Valid_TestData()
@@ -479,7 +474,7 @@ public static void Parse_Span_Invalid(string value, NumberStyles style, IFormatP
         public static void PositiveInfinity()
         {
             Assert.Equal(1.0f / 0.0f, float.PositiveInfinity);
-            Assert.Equal(0x7F800000u, SingleToUInt32Bits(float.PositiveInfinity));
+            Assert.Equal(0x7F800000u, BitConverter.SingleToUInt32Bits(float.PositiveInfinity));
         }
 
         public static IEnumerable<object[]> ToString_TestData()
diff --git a/src/libraries/System.Runtime/tests/System/StringTests.cs b/src/libraries/System.Runtime/tests/System/StringTests.cs
index 58a58b2d257fbd..aa311ff6d7d0f5 100644
--- a/src/libraries/System.Runtime/tests/System/StringTests.cs
+++ b/src/libraries/System.Runtime/tests/System/StringTests.cs
@@ -10,7 +10,6 @@
 using System.Runtime.InteropServices;
 using System.Text;
 using System.Threading.Tasks;
-using Microsoft.DotNet.RemoteExecutor;
 using Xunit;
 
 namespace System.Tests
@@ -508,6 +507,69 @@ public static void EnumerateRunes(char[] chars, int[] expected)
             Assert.Equal(expected, enumeratedValues);
         }
 
+        [Fact]
+        public static void ReplaceLineEndings_NullReplacementText_Throws()
+        {
+            Assert.Throws<ArgumentNullException>("replacementText", () => "Hello!".ReplaceLineEndings(null));
+        }
+
+        [Theory]
+        [InlineData("", new[] { "" })]
+        [InlineData("abc", new[] { "abc" })]
+        [InlineData("<CR>", new[] { "", "" })] // empty sequences before and after the CR
+        [InlineData("<CR><CR>", new[] { "", "", "" })] // empty sequences before and after the CR (CR doesn't consume CR)
+        [InlineData("<CR><LF>", new[] { "", "" })] // CR should swallow any LF which follows
+        [InlineData("a<CR><LF><LF>z", new[] { "a", "", "z" })] // CR should swallow only a single LF which follows
+        [InlineData("a<CR>b<LF>c", new[] { "a", "b", "c" })] // CR shouldn't swallow anything other than LF
+        [InlineData("aa<CR>bb<LF><CR>cc", new[] { "aa", "bb", "", "cc" })] // LF shouldn't swallow CR which follows
+        [InlineData("a<CR>b<VT>c<LF>d<NEL>e<FF>f<PS>g<LS>h", new[] { "a", "b<VT>c", "d", "e", "f", "g", "h" })] // VT not recognized as NLF
+        [InlineData("xyz<NEL>", new[] { "xyz", "" })] // sequence at end produces empty string
+        [InlineData("<NEL>xyz", new[] { "", "xyz" })] // sequence at beginning produces empty string
+        [InlineData("abc<NAK>%def", new[] { "abc<NAK>%def" })] // we don't recognize EBCDIC encodings for LF (see Unicode Standard, Sec. 5.8, Table 5-1)
+        public static void ReplaceLineEndings(string input, string[] expectedSegments)
+        {
+            input = FixupSequences(input);
+            expectedSegments = Array.ConvertAll(expectedSegments, FixupSequences);
+
+            // Try Environment.NewLine (and parameterless ctor)
+
+            string expectedEnvNewLineConcat = string.Join(Environment.NewLine, expectedSegments);
+            Assert.Equal(expectedEnvNewLineConcat, input.ReplaceLineEndings());
+            Assert.Equal(expectedEnvNewLineConcat, input.ReplaceLineEndings(Environment.NewLine));
+
+            // Try removing newlines entirely
+
+            Assert.Equal(string.Concat(expectedSegments) /* no joiner */, input.ReplaceLineEndings(""));
+
+            // And try using a custom separator
+
+            Assert.Equal(string.Join("<SEPARATOR>", expectedSegments), input.ReplaceLineEndings("<SEPARATOR>"));
+
+            if (expectedSegments.Length == 1)
+            {
+                // If no newline sequences at all, we should return the original string instance as an optimization
+                Assert.Same(input, input.ReplaceLineEndings());
+                Assert.Same(input, input.ReplaceLineEndings(Environment.NewLine));
+                Assert.Same(input, input.ReplaceLineEndings(""));
+                Assert.Same(input, input.ReplaceLineEndings("<SEPARATOR>"));
+            }
+
+            static string FixupSequences(string input)
+            {
+                // We use <XYZ> markers so that the original strings show up better in the xunit test runner
+                // <VT> is included as a negative test; we *do not* want ReplaceLineEndings to honor it
+
+                return input.Replace("<CR>", "\r")
+                    .Replace("<LF>", "\n")
+                    .Replace("<VT>", "\v")
+                    .Replace("<FF>", "\f")
+                    .Replace("<NAK>", "\u0015")
+                    .Replace("<NEL>", "\u0085")
+                    .Replace("<LS>", "\u2028")
+                    .Replace("<PS>", "\u2029");
+            }
+        }
+
         [Theory]
         [InlineData("Hello", 'H', true)]
         [InlineData("Hello", 'h', false)]
diff --git a/src/libraries/System.Runtime/tests/System/Type/TypeTests.cs b/src/libraries/System.Runtime/tests/System/Type/TypeTests.cs
index 1464db6d4e8244..8f2d1415825afe 100644
--- a/src/libraries/System.Runtime/tests/System/Type/TypeTests.cs
+++ b/src/libraries/System.Runtime/tests/System/Type/TypeTests.cs
@@ -937,6 +937,16 @@ public static IEnumerable<object[]> GetInterfaceMap_TestData()
                 }
             };
             yield return new object[]
+            {
+                typeof(ISimpleInterface),
+                typeof(AbstractSimpleType),
+                new Tuple<MethodInfo, MethodInfo>[]
+                {
+                    new Tuple<MethodInfo, MethodInfo>(typeof(ISimpleInterface).GetMethod("Method"), typeof(AbstractSimpleType).GetMethod("Method")),
+                    new Tuple<MethodInfo, MethodInfo>(typeof(ISimpleInterface).GetMethod("GenericMethod"), typeof(AbstractSimpleType).GetMethod("GenericMethod"))
+                }
+            };
+            yield return new object[]
             {
                 typeof(IGenericInterface<object>),
                 typeof(DerivedType),
@@ -954,12 +964,64 @@ public static IEnumerable<object[]> GetInterfaceMap_TestData()
                     new Tuple<MethodInfo, MethodInfo>(typeof(IGenericInterface<string>).GetMethod("Method"), typeof(DerivedType).GetMethod("Method", new Type[] { typeof(string) })),
                 }
             };
+            yield return new object[]
+            {
+                typeof(DIMs.I1),
+                typeof(DIMs.C1),
+                new Tuple<MethodInfo, MethodInfo>[]
+                {
+                    new Tuple<MethodInfo, MethodInfo>(typeof(DIMs.I1).GetMethod("M"), typeof(DIMs.I1).GetMethod("M"))
+                }
+            };
+            yield return new object[]
+            {
+                typeof(DIMs.I2),
+                typeof(DIMs.C2),
+                new Tuple<MethodInfo, MethodInfo>[]
+                {
+                    new Tuple<MethodInfo, MethodInfo>(typeof(DIMs.I2).GetMethod("System.Tests.TypeTestsExtended.DIMs.I1.M", BindingFlags.Instance | BindingFlags.NonPublic), null)
+                }
+            };
+            yield return new object[]
+            {
+                typeof(DIMs.I1),
+                typeof(DIMs.C2),
+                new Tuple<MethodInfo, MethodInfo>[]
+                {
+                    new Tuple<MethodInfo, MethodInfo>(typeof(DIMs.I1).GetMethod("M"), typeof(DIMs.C2).GetMethod("M"))
+                }
+            };
+            yield return new object[]
+            {
+                typeof(DIMs.I3),
+                typeof(DIMs.C3),
+                new Tuple<MethodInfo, MethodInfo>[]
+                {
+                    new Tuple<MethodInfo, MethodInfo>(typeof(DIMs.I3).GetMethod("System.Tests.TypeTestsExtended.DIMs.I1.M", BindingFlags.Instance | BindingFlags.NonPublic), typeof(DIMs.I3).GetMethod("System.Tests.TypeTestsExtended.DIMs.I1.M", BindingFlags.Instance | BindingFlags.NonPublic))
+                }
+            };
+            yield return new object[]
+            {
+                typeof(DIMs.I4),
+                typeof(DIMs.C4),
+                new Tuple<MethodInfo, MethodInfo>[]
+                {
+                    new Tuple<MethodInfo, MethodInfo>(typeof(DIMs.I4).GetMethod("System.Tests.TypeTestsExtended.DIMs.I1.M", BindingFlags.Instance | BindingFlags.NonPublic), null)
+                }
+            };
+            yield return new object[]
+            {
+                typeof(DIMs.I2),
+                typeof(DIMs.C4),
+                new Tuple<MethodInfo, MethodInfo>[]
+                {
+                    new Tuple<MethodInfo, MethodInfo>(typeof(DIMs.I2).GetMethod("System.Tests.TypeTestsExtended.DIMs.I1.M", BindingFlags.Instance | BindingFlags.NonPublic), null)
+                }
+            };
         }
 
         [Theory]
         [MemberData(nameof(GetInterfaceMap_TestData))]
-        // Android-only, change to TestPlatforms.Android once arcade dependency is updated
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/36653", TestRuntimes.Mono)]
         public void GetInterfaceMap(Type interfaceType, Type classType, Tuple<MethodInfo, MethodInfo>[] expectedMap)
         {
             InterfaceMapping actualMapping = classType.GetInterfaceMap(interfaceType);
@@ -991,6 +1053,12 @@ public void Method() { }
             public void GenericMethod<T>() { }
         }
 
+        abstract class AbstractSimpleType : ISimpleInterface
+        {
+            public abstract void Method();
+            public abstract void GenericMethod<T>();
+        }
+
         interface IGenericInterface<T>
         {
             void Method(T arg);
@@ -1005,6 +1073,47 @@ class DerivedType : GenericBaseType<object>, IGenericInterface<string>
         {
             public void Method(string arg) { }
         }
+
+        static class DIMs
+        {
+            
+            internal interface I1
+            {
+                void M() { throw new Exception("e"); }
+            }
+
+            internal class C1 : I1 { }
+
+            internal interface I2 : I1
+            {
+                abstract void I1.M(); // reabstracted
+            }
+
+            internal abstract class C2 : I2
+            {
+                public abstract void M();
+            }
+
+            internal interface I3 : I2
+            {
+                void I1.M()
+                { // unabstacted
+                    throw new Exception ("e");
+                }
+            }
+
+            internal class C3 : I3 { }
+
+            internal interface I4 : I3
+            {
+                abstract void I1.M(); // reabstracted again
+            }
+
+            internal abstract class C4 : I4
+            {
+                public abstract void M();
+            }
+        }
 #endregion
     }
 
diff --git a/src/libraries/System.Runtime/tests/TrimmingTests/InvariantGlobalizationFalse.cs b/src/libraries/System.Runtime/tests/TrimmingTests/InvariantGlobalizationFalse.cs
new file mode 100644
index 00000000000000..fbdafa45922afc
--- /dev/null
+++ b/src/libraries/System.Runtime/tests/TrimmingTests/InvariantGlobalizationFalse.cs
@@ -0,0 +1,26 @@
+// 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.Threading;
+
+/// <summary>
+/// Ensures setting InvariantGlobalization = false still works in a trimmed app.
+/// </summary>
+class Program
+{
+    static int Main(string[] args)
+    {
+        // since we are using Invariant GlobalizationMode = false, setting the culture matters.
+        // The app will always use the current culture, so in the Turkish culture, 'i' ToUpper will NOT be "I"
+        Thread.CurrentThread.CurrentCulture = new CultureInfo("tr-TR");
+        if ("i".ToUpper() == "I")
+        {
+            // 'i' ToUpper was "I", but shouldn't be in the Turkish culture, so fail
+            return -1;
+        }
+
+        return 100;
+    }
+}
diff --git a/src/libraries/System.Runtime/tests/TrimmingTests/InvariantGlobalizationTrue.cs b/src/libraries/System.Runtime/tests/TrimmingTests/InvariantGlobalizationTrue.cs
new file mode 100644
index 00000000000000..7daa557239f3d6
--- /dev/null
+++ b/src/libraries/System.Runtime/tests/TrimmingTests/InvariantGlobalizationTrue.cs
@@ -0,0 +1,55 @@
+// 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.Reflection;
+using System.Threading;
+
+/// <summary>
+/// Ensures setting InvariantGlobalization = true still works in a trimmed app.
+/// </summary>
+class Program
+{
+    static int Main(string[] args)
+    {
+        // since we are using Invariant GlobalizationMode = true, setting the culture doesn't matter.
+        // The app will always use Invariant mode, so even in the Turkish culture, 'i' ToUpper will be "I"
+        Thread.CurrentThread.CurrentCulture = new CultureInfo("tr-TR");
+        if ("i".ToUpper() != "I")
+        {
+            // 'i' ToUpper was not "I", so fail
+            return -1;
+        }
+
+        // Ensure the internal GlobalizationMode class is trimmed correctly
+        Type globalizationMode = GetCoreLibType("System.Globalization.GlobalizationMode");
+        const BindingFlags allStatics = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static;
+        foreach (MemberInfo member in globalizationMode.GetMembers(allStatics))
+        {
+            // properties and their backing getter methods are OK
+            if (member is PropertyInfo || member.Name.StartsWith("get_"))
+            {
+                continue;
+            }
+
+            if (OperatingSystem.IsWindows())
+            {
+                // Windows still contains a static cctor and a backing field for UseNls
+                if (member is ConstructorInfo || (member is FieldInfo field && field.Name.Contains("UseNls")))
+                {
+                    continue;
+                }
+            }
+
+            // Some unexpected member was left on GlobalizationMode, fail
+            Console.WriteLine($"Member '{member.Name}' was not trimmed from GlobalizationMode, but should have been.");
+            return -2;
+        }
+
+        return 100;
+    }
+
+    private static Type GetCoreLibType(string name) =>
+        typeof(object).Assembly.GetType(name, throwOnError: true);
+}
diff --git a/src/libraries/System.Runtime/tests/TrimmingTests/System.Runtime.TrimmingTests.proj b/src/libraries/System.Runtime/tests/TrimmingTests/System.Runtime.TrimmingTests.proj
index fd556a37d675ac..02b4882782e967 100644
--- a/src/libraries/System.Runtime/tests/TrimmingTests/System.Runtime.TrimmingTests.proj
+++ b/src/libraries/System.Runtime/tests/TrimmingTests/System.Runtime.TrimmingTests.proj
@@ -11,6 +11,12 @@
     <TestConsoleAppSourceFiles Include="GenericArraySortHelperTest.cs" />
     <TestConsoleAppSourceFiles Include="InheritedAttributeTests.cs" />
     <TestConsoleAppSourceFiles Include="InterfacesOnArrays.cs" />
+    <TestConsoleAppSourceFiles Include="InvariantGlobalizationFalse.cs">
+      <ExtraTrimmerArgs>--feature System.Globalization.Invariant false</ExtraTrimmerArgs>
+    </TestConsoleAppSourceFiles>
+    <TestConsoleAppSourceFiles Include="InvariantGlobalizationTrue.cs">
+      <ExtraTrimmerArgs>--feature System.Globalization.Invariant true</ExtraTrimmerArgs>
+    </TestConsoleAppSourceFiles>
     <TestConsoleAppSourceFiles Include="StackFrameHelperTest.cs">
       <!-- There is a bug with the linker where it is corrupting the pdbs while trimming
       causing the framework to not be able to get source line info any longer. This
diff --git a/src/libraries/System.Security.AccessControl/Directory.Build.props b/src/libraries/System.Security.AccessControl/Directory.Build.props
index 8ea1b05c85d43a..709a22a7537088 100644
--- a/src/libraries/System.Security.AccessControl/Directory.Build.props
+++ b/src/libraries/System.Security.AccessControl/Directory.Build.props
@@ -2,15 +2,6 @@
   <Import Project="..\Directory.Build.props" />
   <PropertyGroup>
     <StrongNameKeyId>Microsoft</StrongNameKeyId>
-    <IsAspNetCoreApp>true</IsAspNetCoreApp>
     <SupportedOSPlatforms>windows</SupportedOSPlatforms>
-    <PackageDescription>Provides base classes that enable managing access and audit control lists on securable objects.
-
-Commonly Used Types:
-System.Security.AccessControl.AccessRule
-System.Security.AccessControl.AuditRule
-System.Security.AccessControl.ObjectAccessRule
-System.Security.AccessControl.ObjectAuditRule
-System.Security.AccessControl.ObjectSecurity</PackageDescription>
   </PropertyGroup>
 </Project>
\ No newline at end of file
diff --git a/src/libraries/System.Security.AccessControl/NuGet.config b/src/libraries/System.Security.AccessControl/NuGet.config
deleted file mode 100644
index a66b7f9b013241..00000000000000
--- a/src/libraries/System.Security.AccessControl/NuGet.config
+++ /dev/null
@@ -1,12 +0,0 @@
-<configuration>
-  <!-- This disables restore in VS for projects that target platform specific target frameworks older than net5.0. -->
-  <packageRestore>
-    <!-- The 'automatic' key is set to True when the "Automatically check for missing packages during
-         build in Visual Studio" checkbox is set. Clearing the box sets this to False and disables
-         automatic restore. -->
-    <add key="automatic" value="False" />
-    <!-- The 'enabled' key is True when the "Allow NuGet to download missing packages" checkbox is set.
-         Clearing the box sets this to False, disabling command-line, automatic, and MSBuild-integrated restore. -->
-    <add key="enabled" value="False" />
-  </packageRestore>
-</configuration>
\ No newline at end of file
diff --git a/src/libraries/System.Security.AccessControl/pkg/System.Security.AccessControl.pkgproj b/src/libraries/System.Security.AccessControl/pkg/System.Security.AccessControl.pkgproj
deleted file mode 100644
index 6f398d889dd7fc..00000000000000
--- a/src/libraries/System.Security.AccessControl/pkg/System.Security.AccessControl.pkgproj
+++ /dev/null
@@ -1,12 +0,0 @@
-<Project DefaultTargets="Build">
-  <Import Project="$([MSBuild]::GetPathOfFileAbove(Directory.Build.props))" />
-  <ItemGroup>
-    <ProjectReference Include="..\ref\System.Security.AccessControl.csproj">
-      <SupportedFramework>net461;netcoreapp2.0;uap10.0.16299;$(AllXamarinFrameworks)</SupportedFramework>
-    </ProjectReference>
-    <ProjectReference Include="..\src\System.Security.AccessControl.csproj" />
-    <!-- Exclude TFMs that aren't supported by the package anymore from validation. -->
-    <ExcludeHarvestedSupportedFramework Include="netcoreapp1.0;netcoreapp1.1;netcore50;uap10.0;net46" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetPathOfFileAbove(Directory.Build.targets))" />
-</Project>
\ No newline at end of file
diff --git a/src/libraries/System.Security.AccessControl/ref/System.Security.AccessControl.Evidence.cs b/src/libraries/System.Security.AccessControl/ref/System.Security.AccessControl.Evidence.cs
new file mode 100644
index 00000000000000..2fa98a6f032305
--- /dev/null
+++ b/src/libraries/System.Security.AccessControl/ref/System.Security.AccessControl.Evidence.cs
@@ -0,0 +1,48 @@
+// 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.
+// ------------------------------------------------------------------------------
+
+#nullable enable
+
+namespace System.Security.Policy
+{
+    public sealed partial class Evidence : System.Collections.ICollection, System.Collections.IEnumerable
+    {
+        public Evidence() { }
+        [System.ObsoleteAttribute("This constructor is obsolete. Please use the constructor which takes arrays of EvidenceBase instead.")]
+        public Evidence(object[] hostEvidence, object[] assemblyEvidence) { }
+        public Evidence(System.Security.Policy.Evidence evidence) { }
+        public Evidence(System.Security.Policy.EvidenceBase[] hostEvidence, System.Security.Policy.EvidenceBase[] assemblyEvidence) { }
+        [System.ObsoleteAttribute("Evidence should not be treated as an ICollection. Please use GetHostEnumerator and GetAssemblyEnumerator to iterate over the evidence to collect a count.")]
+        public int Count { get { throw null; } }
+        public bool IsReadOnly { get { throw null; } }
+        public bool IsSynchronized { get { throw null; } }
+        public bool Locked { get { throw null; } set { } }
+        public object SyncRoot { get { throw null; } }
+        [System.ObsoleteAttribute("This method is obsolete. Please use AddAssemblyEvidence instead.")]
+        public void AddAssembly(object id) { }
+        public void AddAssemblyEvidence<T>(T evidence) where T : System.Security.Policy.EvidenceBase { }
+        [System.ObsoleteAttribute("This method is obsolete. Please use AddHostEvidence instead.")]
+        public void AddHost(object id) { }
+        public void AddHostEvidence<T>(T evidence) where T : System.Security.Policy.EvidenceBase { }
+        public void Clear() { }
+        public System.Security.Policy.Evidence? Clone() { throw null; }
+        [System.ObsoleteAttribute("Evidence should not be treated as an ICollection. Please use the GetHostEnumerator and GetAssemblyEnumerator methods rather than using CopyTo.")]
+        public void CopyTo(System.Array array, int index) { }
+        public System.Collections.IEnumerator GetAssemblyEnumerator() { throw null; }
+        public T? GetAssemblyEvidence<T>() where T : System.Security.Policy.EvidenceBase { throw null; }
+        [System.ObsoleteAttribute("GetEnumerator is obsolete. Please use GetAssemblyEnumerator and GetHostEnumerator instead.")]
+        public System.Collections.IEnumerator GetEnumerator() { throw null; }
+        public System.Collections.IEnumerator GetHostEnumerator() { throw null; }
+        public T? GetHostEvidence<T>() where T : System.Security.Policy.EvidenceBase { throw null; }
+        public void Merge(System.Security.Policy.Evidence evidence) { }
+        public void RemoveType(System.Type t) { }
+    }
+    public abstract partial class EvidenceBase
+    {
+        protected EvidenceBase() { }
+        public virtual System.Security.Policy.EvidenceBase? Clone() { throw null; }
+    }
+}
\ No newline at end of file
diff --git a/src/libraries/System.Security.AccessControl/ref/System.Security.AccessControl.cs b/src/libraries/System.Security.AccessControl/ref/System.Security.AccessControl.cs
index f6bef32dfdbd45..b47ecfdc101652 100644
--- a/src/libraries/System.Security.AccessControl/ref/System.Security.AccessControl.cs
+++ b/src/libraries/System.Security.AccessControl/ref/System.Security.AccessControl.cs
@@ -530,44 +530,3 @@ public void SetAudit(System.Security.AccessControl.AuditFlags auditFlags, System
         public void SetAudit(System.Security.Principal.SecurityIdentifier sid, System.Security.AccessControl.ObjectAuditRule rule) { }
     }
 }
-
-namespace System.Security.Policy
-{
-    public sealed partial class Evidence : System.Collections.ICollection, System.Collections.IEnumerable
-    {
-        public Evidence() { }
-        [System.ObsoleteAttribute("This constructor is obsolete. Please use the constructor which takes arrays of EvidenceBase instead.")]
-        public Evidence(object[] hostEvidence, object[] assemblyEvidence) { }
-        public Evidence(System.Security.Policy.Evidence evidence) { }
-        public Evidence(System.Security.Policy.EvidenceBase[] hostEvidence, System.Security.Policy.EvidenceBase[] assemblyEvidence) { }
-        [System.ObsoleteAttribute("Evidence should not be treated as an ICollection. Please use GetHostEnumerator and GetAssemblyEnumerator to iterate over the evidence to collect a count.")]
-        public int Count { get { throw null; } }
-        public bool IsReadOnly { get { throw null; } }
-        public bool IsSynchronized { get { throw null; } }
-        public bool Locked { get { throw null; } set { } }
-        public object SyncRoot { get { throw null; } }
-        [System.ObsoleteAttribute("This method is obsolete. Please use AddAssemblyEvidence instead.")]
-        public void AddAssembly(object id) { }
-        public void AddAssemblyEvidence<T>(T evidence) where T : System.Security.Policy.EvidenceBase { }
-        [System.ObsoleteAttribute("This method is obsolete. Please use AddHostEvidence instead.")]
-        public void AddHost(object id) { }
-        public void AddHostEvidence<T>(T evidence) where T : System.Security.Policy.EvidenceBase { }
-        public void Clear() { }
-        public System.Security.Policy.Evidence? Clone() { throw null; }
-        [System.ObsoleteAttribute("Evidence should not be treated as an ICollection. Please use the GetHostEnumerator and GetAssemblyEnumerator methods rather than using CopyTo.")]
-        public void CopyTo(System.Array array, int index) { }
-        public System.Collections.IEnumerator GetAssemblyEnumerator() { throw null; }
-        public T? GetAssemblyEvidence<T>() where T : System.Security.Policy.EvidenceBase { throw null; }
-        [System.ObsoleteAttribute("GetEnumerator is obsolete. Please use GetAssemblyEnumerator and GetHostEnumerator instead.")]
-        public System.Collections.IEnumerator GetEnumerator() { throw null; }
-        public System.Collections.IEnumerator GetHostEnumerator() { throw null; }
-        public T? GetHostEvidence<T>() where T : System.Security.Policy.EvidenceBase { throw null; }
-        public void Merge(System.Security.Policy.Evidence evidence) { }
-        public void RemoveType(System.Type t) { }
-    }
-    public abstract partial class EvidenceBase
-    {
-        protected EvidenceBase() { }
-        public virtual System.Security.Policy.EvidenceBase? Clone() { throw null; }
-    }
-}
\ No newline at end of file
diff --git a/src/libraries/System.Security.AccessControl/ref/System.Security.AccessControl.csproj b/src/libraries/System.Security.AccessControl/ref/System.Security.AccessControl.csproj
index 403a6436ed2bdd..348ff2fe1971ed 100644
--- a/src/libraries/System.Security.AccessControl/ref/System.Security.AccessControl.csproj
+++ b/src/libraries/System.Security.AccessControl/ref/System.Security.AccessControl.csproj
@@ -1,18 +1,13 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFrameworks>$(NetCoreAppCurrent);netstandard2.0;net461</TargetFrameworks>
-    <ExcludeCurrentNetCoreAppFromPackage>true</ExcludeCurrentNetCoreAppFromPackage>
+    <TargetFrameworks>$(NetCoreAppCurrent)</TargetFrameworks>
     <Nullable>enable</Nullable>
   </PropertyGroup>
   <ItemGroup>
-    <Compile Condition="'$(TargetFramework)' != 'net461'" Include="System.Security.AccessControl.cs" />
-    <Compile Condition="'$(TargetFramework)' == 'net461'" Include="System.Security.AccessControl.net461.cs" />
+    <Compile Include="System.Security.AccessControl.cs" />
+    <Compile Include="System.Security.AccessControl.Evidence.cs" />
   </ItemGroup>
-  <ItemGroup Condition="'$(TargetFramework)' != 'net461'">
+  <ItemGroup>
     <ProjectReference Include="$(LibrariesProjectRoot)System.Security.Principal.Windows\ref\System.Security.Principal.Windows.csproj" />
   </ItemGroup>
-  <ItemGroup Condition="'$(TargetFramework)' == '$(NetCoreAppCurrent)'">
-    <ProjectReference Include="$(LibrariesProjectRoot)System.Runtime\ref\System.Runtime.csproj" />
-    <ProjectReference Include="$(LibrariesProjectRoot)System.Collections.NonGeneric\ref\System.Collections.NonGeneric.csproj" />
-  </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/src/libraries/System.Security.AccessControl/ref/System.Security.AccessControl.net461.cs b/src/libraries/System.Security.AccessControl/ref/System.Security.AccessControl.net461.cs
deleted file mode 100644
index 9fa292c50bbb76..00000000000000
--- a/src/libraries/System.Security.AccessControl/ref/System.Security.AccessControl.net461.cs
+++ /dev/null
@@ -1,52 +0,0 @@
-// 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.
-// ------------------------------------------------------------------------------
-
-using System.Runtime.CompilerServices;
-
-[assembly: TypeForwardedTo(typeof(System.Security.AccessControl.AccessControlActions))]
-[assembly: TypeForwardedTo(typeof(System.Security.AccessControl.AccessControlModification))]
-[assembly: TypeForwardedTo(typeof(System.Security.AccessControl.AccessControlSections))]
-[assembly: TypeForwardedTo(typeof(System.Security.AccessControl.AccessControlType))]
-[assembly: TypeForwardedTo(typeof(System.Security.AccessControl.AccessRule))]
-[assembly: TypeForwardedTo(typeof(System.Security.AccessControl.AccessRule<>))]
-[assembly: TypeForwardedTo(typeof(System.Security.AccessControl.AceEnumerator))]
-[assembly: TypeForwardedTo(typeof(System.Security.AccessControl.AceFlags))]
-[assembly: TypeForwardedTo(typeof(System.Security.AccessControl.AceQualifier))]
-[assembly: TypeForwardedTo(typeof(System.Security.AccessControl.AceType))]
-[assembly: TypeForwardedTo(typeof(System.Security.AccessControl.AuditFlags))]
-[assembly: TypeForwardedTo(typeof(System.Security.AccessControl.AuditRule))]
-[assembly: TypeForwardedTo(typeof(System.Security.AccessControl.AuditRule<>))]
-[assembly: TypeForwardedTo(typeof(System.Security.AccessControl.AuthorizationRule))]
-[assembly: TypeForwardedTo(typeof(System.Security.AccessControl.AuthorizationRuleCollection))]
-[assembly: TypeForwardedTo(typeof(System.Security.AccessControl.CommonAce))]
-[assembly: TypeForwardedTo(typeof(System.Security.AccessControl.CommonAcl))]
-[assembly: TypeForwardedTo(typeof(System.Security.AccessControl.CommonObjectSecurity))]
-[assembly: TypeForwardedTo(typeof(System.Security.AccessControl.CommonSecurityDescriptor))]
-[assembly: TypeForwardedTo(typeof(System.Security.AccessControl.CompoundAce))]
-[assembly: TypeForwardedTo(typeof(System.Security.AccessControl.CompoundAceType))]
-[assembly: TypeForwardedTo(typeof(System.Security.AccessControl.ControlFlags))]
-[assembly: TypeForwardedTo(typeof(System.Security.AccessControl.CustomAce))]
-[assembly: TypeForwardedTo(typeof(System.Security.AccessControl.DiscretionaryAcl))]
-[assembly: TypeForwardedTo(typeof(System.Security.AccessControl.GenericAce))]
-[assembly: TypeForwardedTo(typeof(System.Security.AccessControl.GenericAcl))]
-[assembly: TypeForwardedTo(typeof(System.Security.AccessControl.GenericSecurityDescriptor))]
-[assembly: TypeForwardedTo(typeof(System.Security.AccessControl.InheritanceFlags))]
-[assembly: TypeForwardedTo(typeof(System.Security.AccessControl.KnownAce))]
-[assembly: TypeForwardedTo(typeof(System.Security.AccessControl.NativeObjectSecurity))]
-[assembly: TypeForwardedTo(typeof(System.Security.AccessControl.ObjectAccessRule))]
-[assembly: TypeForwardedTo(typeof(System.Security.AccessControl.ObjectAce))]
-[assembly: TypeForwardedTo(typeof(System.Security.AccessControl.ObjectAceFlags))]
-[assembly: TypeForwardedTo(typeof(System.Security.AccessControl.ObjectAuditRule))]
-[assembly: TypeForwardedTo(typeof(System.Security.AccessControl.ObjectSecurity))]
-[assembly: TypeForwardedTo(typeof(System.Security.AccessControl.ObjectSecurity<>))]
-[assembly: TypeForwardedTo(typeof(System.Security.AccessControl.PrivilegeNotHeldException))]
-[assembly: TypeForwardedTo(typeof(System.Security.AccessControl.PropagationFlags))]
-[assembly: TypeForwardedTo(typeof(System.Security.AccessControl.QualifiedAce))]
-[assembly: TypeForwardedTo(typeof(System.Security.AccessControl.RawAcl))]
-[assembly: TypeForwardedTo(typeof(System.Security.AccessControl.RawSecurityDescriptor))]
-[assembly: TypeForwardedTo(typeof(System.Security.AccessControl.ResourceType))]
-[assembly: TypeForwardedTo(typeof(System.Security.AccessControl.SecurityInfos))]
-[assembly: TypeForwardedTo(typeof(System.Security.AccessControl.SystemAcl))]
diff --git a/src/libraries/System.Security.AccessControl/src/System.Security.AccessControl.csproj b/src/libraries/System.Security.AccessControl/src/System.Security.AccessControl.csproj
index 4f1fd6cd42513e..ae2bd9f64570a4 100644
--- a/src/libraries/System.Security.AccessControl/src/System.Security.AccessControl.csproj
+++ b/src/libraries/System.Security.AccessControl/src/System.Security.AccessControl.csproj
@@ -1,16 +1,14 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <TargetFrameworks>$(NetCoreAppCurrent)-windows;net461-windows;netstandard2.0-windows;netstandard2.0</TargetFrameworks>
-    <ExcludeCurrentNetCoreAppFromPackage>true</ExcludeCurrentNetCoreAppFromPackage>
+    <TargetFrameworks>$(NetCoreAppCurrent)-windows;$(NetCoreAppCurrent)</TargetFrameworks>
     <Nullable>enable</Nullable>
   </PropertyGroup>
   <!-- DesignTimeBuild requires all the TargetFramework Derived Properties to not be present in the first property group. -->
   <PropertyGroup>
-    <IsPartialFacadeAssembly Condition="$(TargetFramework.StartsWith('net4'))">true</IsPartialFacadeAssembly>
     <GeneratePlatformNotSupportedAssemblyMessage Condition="'$(TargetsWindows)' != 'true'">SR.PlatformNotSupported_AccessControl</GeneratePlatformNotSupportedAssemblyMessage>
   </PropertyGroup>
-  <ItemGroup Condition="!$(TargetFramework.StartsWith('net4')) and '$(TargetsWindows)' == 'true'">
+  <ItemGroup Condition="'$(TargetsWindows)' == 'true'">
     <Compile Include="System\Security\AccessControl\ACE.cs" />
     <Compile Include="System\Security\AccessControl\ACL.cs" />
     <Compile Include="System\Security\AccessControl\CommonObjectSecurity.cs" />
@@ -80,7 +78,8 @@
     <Compile Include="$(CommonPath)Interop\Windows\Advapi32\Interop.DuplicateTokenEx_SafeTokenHandle.cs"
              Link="Common\Interop\Interop.DuplicateTokenEx_SafeTokenHandle.cs" />
   </ItemGroup>
-  <ItemGroup Condition="$(TargetFramework.StartsWith('$(NetCoreAppCurrent)'))">
+  <ItemGroup>
+    <ProjectReference Include="$(LibrariesProjectRoot)System.Security.Principal.Windows\src\System.Security.Principal.Windows.csproj" />
     <Reference Include="System.Collections" />
     <Reference Include="System.Collections.NonGeneric" />
     <Reference Include="System.Diagnostics.Debug" />
@@ -92,7 +91,4 @@
     <Reference Include="System.Threading.Thread" />
     <Reference Include="Microsoft.Win32.Primitives" />
   </ItemGroup>
-  <ItemGroup Condition="!$(TargetFramework.StartsWith('net4'))">
-    <ProjectReference Include="$(LibrariesProjectRoot)System.Security.Principal.Windows\src\System.Security.Principal.Windows.csproj" />
-  </ItemGroup>
 </Project>
diff --git a/src/libraries/System.Security.AccessControl/src/System/Security/Policy/Evidence.cs b/src/libraries/System.Security.AccessControl/src/System/Security/Policy/Evidence.cs
index dfeaff878b84a7..ca197afd2f1bc4 100644
--- a/src/libraries/System.Security.AccessControl/src/System/Security/Policy/Evidence.cs
+++ b/src/libraries/System.Security.AccessControl/src/System/Security/Policy/Evidence.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.
 
+#nullable enable
+
 using System.Collections;
 
 namespace System.Security.Policy
diff --git a/src/libraries/System.Security.AccessControl/src/System/Security/Policy/EvidenceBase.cs b/src/libraries/System.Security.AccessControl/src/System/Security/Policy/EvidenceBase.cs
index b2790af0cd1f5f..12073ea4564f67 100644
--- a/src/libraries/System.Security.AccessControl/src/System/Security/Policy/EvidenceBase.cs
+++ b/src/libraries/System.Security.AccessControl/src/System/Security/Policy/EvidenceBase.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.
 
+#nullable enable
+
 namespace System.Security.Policy
 {
     public abstract partial class EvidenceBase
diff --git a/src/libraries/System.Security.AccessControl/tests/System.Security.AccessControl.Tests.csproj b/src/libraries/System.Security.AccessControl/tests/System.Security.AccessControl.Tests.csproj
index 0d9a67a1f32977..ef48b56e4d81af 100644
--- a/src/libraries/System.Security.AccessControl/tests/System.Security.AccessControl.Tests.csproj
+++ b/src/libraries/System.Security.AccessControl/tests/System.Security.AccessControl.Tests.csproj
@@ -1,6 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFrameworks>$(NetCoreAppCurrent)-windows;net461-windows</TargetFrameworks>
+    <TargetFrameworks>$(NetCoreAppCurrent)-windows</TargetFrameworks>
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="Ace\Ace.Common.Tests.cs" />
diff --git a/src/libraries/System.Security.Cryptography.Algorithms/ref/System.Security.Cryptography.Algorithms.cs b/src/libraries/System.Security.Cryptography.Algorithms/ref/System.Security.Cryptography.Algorithms.cs
index a12fae41849625..323966899bc0ac 100644
--- a/src/libraries/System.Security.Cryptography.Algorithms/ref/System.Security.Cryptography.Algorithms.cs
+++ b/src/libraries/System.Security.Cryptography.Algorithms/ref/System.Security.Cryptography.Algorithms.cs
@@ -469,8 +469,12 @@ public HMACMD5(byte[] key) { }
         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(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; }
         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; }
         protected override bool TryHashFinal(System.Span<byte> destination, out int bytesWritten) { throw null; }
     }
     [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("browser")]
@@ -484,8 +488,12 @@ public HMACSHA1(byte[] key, bool useManagedSha1) { }
         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(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; }
         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; }
         protected override bool TryHashFinal(System.Span<byte> destination, out int bytesWritten) { throw null; }
     }
     [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("browser")]
@@ -497,8 +505,12 @@ public HMACSHA256(byte[] key) { }
         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(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; }
         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; }
         protected override bool TryHashFinal(System.Span<byte> destination, out int bytesWritten) { throw null; }
     }
     [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("browser")]
@@ -511,8 +523,12 @@ public HMACSHA384(byte[] key) { }
         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(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; }
         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; }
         protected override bool TryHashFinal(System.Span<byte> destination, out int bytesWritten) { throw null; }
     }
     [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("browser")]
@@ -525,8 +541,12 @@ public HMACSHA512(byte[] key) { }
         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(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; }
         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; }
         protected override bool TryHashFinal(System.Span<byte> destination, out int bytesWritten) { throw null; }
     }
     public sealed partial class IncrementalHash : System.IDisposable
diff --git a/src/libraries/System.Security.Cryptography.Algorithms/src/Internal/Cryptography/HashProviderDispenser.Browser.cs b/src/libraries/System.Security.Cryptography.Algorithms/src/Internal/Cryptography/HashProviderDispenser.Browser.cs
index 17d2292f45362f..cc0dc6f57319f8 100644
--- a/src/libraries/System.Security.Cryptography.Algorithms/src/Internal/Cryptography/HashProviderDispenser.Browser.cs
+++ b/src/libraries/System.Security.Cryptography.Algorithms/src/Internal/Cryptography/HashProviderDispenser.Browser.cs
@@ -26,6 +26,15 @@ public static HashProvider CreateHashProvider(string hashAlgorithmId)
 
         public static class OneShotHashProvider
         {
+            public static unsafe int MacData(
+                string hashAlgorithmId,
+                ReadOnlySpan<byte> key,
+                ReadOnlySpan<byte> source,
+                Span<byte> destination)
+            {
+                throw new PlatformNotSupportedException(SR.SystemSecurityCryptographyAlgorithms_PlatformNotSupported);
+            }
+
             public static int HashData(string hashAlgorithmId, ReadOnlySpan<byte> source, Span<byte> destination)
             {
                 HashProvider provider = HashProviderDispenser.CreateHashProvider(hashAlgorithmId);
diff --git a/src/libraries/System.Security.Cryptography.Algorithms/src/Internal/Cryptography/HashProviderDispenser.OSX.cs b/src/libraries/System.Security.Cryptography.Algorithms/src/Internal/Cryptography/HashProviderDispenser.OSX.cs
index bb14bc8b868ee0..3bc72d0e62deb2 100644
--- a/src/libraries/System.Security.Cryptography.Algorithms/src/Internal/Cryptography/HashProviderDispenser.OSX.cs
+++ b/src/libraries/System.Security.Cryptography.Algorithms/src/Internal/Cryptography/HashProviderDispenser.OSX.cs
@@ -33,6 +33,40 @@ public static HashProvider CreateMacProvider(string hashAlgorithmId, ReadOnlySpa
 
         internal static class OneShotHashProvider
         {
+            public static unsafe int MacData(
+                string hashAlgorithmId,
+                ReadOnlySpan<byte> key,
+                ReadOnlySpan<byte> source,
+                Span<byte> destination)
+            {
+                Interop.AppleCrypto.PAL_HashAlgorithm algorithm = HashAlgorithmToPal(hashAlgorithmId);
+
+                fixed (byte* pKey = key)
+                fixed (byte* pSource = source)
+                fixed (byte* pDestination = destination)
+                {
+                    int ret = Interop.AppleCrypto.HmacOneShot(
+                        algorithm,
+                        pKey,
+                        key.Length,
+                        pSource,
+                        source.Length,
+                        pDestination,
+                        destination.Length,
+                        out int digestSize);
+
+                    if (ret != 1)
+                    {
+                        Debug.Fail($"MacData return value {ret} was not 1");
+                        throw new CryptographicException();
+                    }
+
+                    Debug.Assert(digestSize <= destination.Length);
+
+                    return digestSize;
+                }
+            }
+
             public static unsafe int HashData(string hashAlgorithmId, ReadOnlySpan<byte> source, Span<byte> destination)
             {
                 Interop.AppleCrypto.PAL_HashAlgorithm algorithm = HashAlgorithmToPal(hashAlgorithmId);
diff --git a/src/libraries/System.Security.Cryptography.Algorithms/src/Internal/Cryptography/HashProviderDispenser.Unix.cs b/src/libraries/System.Security.Cryptography.Algorithms/src/Internal/Cryptography/HashProviderDispenser.Unix.cs
index af984e5344557b..3a7b7974455df4 100644
--- a/src/libraries/System.Security.Cryptography.Algorithms/src/Internal/Cryptography/HashProviderDispenser.Unix.cs
+++ b/src/libraries/System.Security.Cryptography.Algorithms/src/Internal/Cryptography/HashProviderDispenser.Unix.cs
@@ -25,6 +25,28 @@ internal static HashProvider CreateMacProvider(string hashAlgorithmId, ReadOnlyS
 
         internal static class OneShotHashProvider
         {
+            public static int MacData(
+                string hashAlgorithmId,
+                ReadOnlySpan<byte> key,
+                ReadOnlySpan<byte> source,
+                Span<byte> destination)
+            {
+                IntPtr evpType = Interop.Crypto.HashAlgorithmToEvp(hashAlgorithmId);
+                Debug.Assert(evpType != IntPtr.Zero);
+
+                int hashSize = Interop.Crypto.EvpMdSize(evpType);
+
+                if (hashSize <= 0 || destination.Length < hashSize)
+                {
+                    Debug.Fail("Destination length or hash size not valid.");
+                    throw new CryptographicException();
+                }
+
+                int written = Interop.Crypto.HmacOneShot(evpType, key, source, destination);
+                Debug.Assert(written == hashSize);
+                return written;
+            }
+
             public static unsafe int HashData(string hashAlgorithmId, ReadOnlySpan<byte> source, Span<byte> destination)
             {
                 IntPtr evpType = Interop.Crypto.HashAlgorithmToEvp(hashAlgorithmId);
diff --git a/src/libraries/System.Security.Cryptography.Algorithms/src/Internal/Cryptography/HashProviderDispenser.Windows.cs b/src/libraries/System.Security.Cryptography.Algorithms/src/Internal/Cryptography/HashProviderDispenser.Windows.cs
index 4fa960795c46ed..88dd4da404679f 100644
--- a/src/libraries/System.Security.Cryptography.Algorithms/src/Internal/Cryptography/HashProviderDispenser.Windows.cs
+++ b/src/libraries/System.Security.Cryptography.Algorithms/src/Internal/Cryptography/HashProviderDispenser.Windows.cs
@@ -30,14 +30,48 @@ public static HashProvider CreateMacProvider(string hashAlgorithmId, ReadOnlySpa
 
         public static class OneShotHashProvider
         {
+            public static unsafe int MacData(
+                string hashAlgorithmId,
+                ReadOnlySpan<byte> key,
+                ReadOnlySpan<byte> source,
+                Span<byte> destination)
+            {
+                int hashSize; // in bytes
+
+                // Use a pseudo-handle if available.
+                if (Interop.BCrypt.PseudoHandlesSupported)
+                {
+                    HashDataUsingPseudoHandle(hashAlgorithmId, source, key, isHmac: true, destination, out hashSize);
+                    return hashSize;
+                }
+                else
+                {
+                    // Pseudo-handle not available. Fall back to a shared handle with no using or dispose.
+                    SafeBCryptAlgorithmHandle cachedAlgorithmHandle = BCryptAlgorithmCache.GetCachedBCryptAlgorithmHandle(
+                        hashAlgorithmId,
+                        BCryptOpenAlgorithmProviderFlags.BCRYPT_ALG_HANDLE_HMAC_FLAG,
+                        out hashSize);
+
+                    if (destination.Length < hashSize)
+                    {
+                        Debug.Fail("Caller should have checked length.");
+                        throw new CryptographicException();
+                    }
+
+                    HashUpdateAndFinish(cachedAlgorithmHandle, hashSize, key, source, destination);
+
+                    return hashSize;
+                }
+            }
+
             public static unsafe int HashData(string hashAlgorithmId, ReadOnlySpan<byte> source, Span<byte> destination)
             {
                 int hashSize; // in bytes
 
-                // Try using a pseudo-handle if available.
+                // Use a pseudo-handle if available.
                 if (Interop.BCrypt.PseudoHandlesSupported)
                 {
-                    HashDataUsingPseudoHandle(hashAlgorithmId, source, destination, out hashSize);
+                    HashDataUsingPseudoHandle(hashAlgorithmId, source, key: default, isHmac : false, destination, out hashSize);
                     return hashSize;
                 }
                 else
@@ -54,42 +88,60 @@ public static unsafe int HashData(string hashAlgorithmId, ReadOnlySpan<byte> sou
                         throw new CryptographicException();
                     }
 
-                    HashUpdateAndFinish(cachedAlgorithmHandle, hashSize, source, destination);
+                    HashUpdateAndFinish(cachedAlgorithmHandle, hashSize, key: default, source, destination);
 
                     return hashSize;
                 }
             }
 
-            private static unsafe void HashDataUsingPseudoHandle(string hashAlgorithmId, ReadOnlySpan<byte> source, Span<byte> destination, out int hashSize)
+            private static unsafe void HashDataUsingPseudoHandle(
+                string hashAlgorithmId,
+                ReadOnlySpan<byte> source,
+                ReadOnlySpan<byte> key,
+                bool isHmac,
+                Span<byte> destination,
+                out int hashSize)
             {
                 hashSize = default;
 
+                Debug.Assert(isHmac ? true : key.IsEmpty);
+
                 Interop.BCrypt.BCryptAlgPseudoHandle algHandle;
                 int digestSizeInBytes;
 
                 if (hashAlgorithmId == HashAlgorithmNames.MD5)
                 {
-                    algHandle = Interop.BCrypt.BCryptAlgPseudoHandle.BCRYPT_MD5_ALG_HANDLE;
+                    algHandle = isHmac ?
+                        Interop.BCrypt.BCryptAlgPseudoHandle.BCRYPT_HMAC_MD5_ALG_HANDLE :
+                        Interop.BCrypt.BCryptAlgPseudoHandle.BCRYPT_MD5_ALG_HANDLE;
                     digestSizeInBytes = 128 / 8;
                 }
                 else if (hashAlgorithmId == HashAlgorithmNames.SHA1)
                 {
-                    algHandle = Interop.BCrypt.BCryptAlgPseudoHandle.BCRYPT_SHA1_ALG_HANDLE;
+                    algHandle = isHmac ?
+                        Interop.BCrypt.BCryptAlgPseudoHandle.BCRYPT_HMAC_SHA1_ALG_HANDLE :
+                        Interop.BCrypt.BCryptAlgPseudoHandle.BCRYPT_SHA1_ALG_HANDLE;
                     digestSizeInBytes = 160 / 8;
                 }
                 else if (hashAlgorithmId == HashAlgorithmNames.SHA256)
                 {
-                    algHandle = Interop.BCrypt.BCryptAlgPseudoHandle.BCRYPT_SHA256_ALG_HANDLE;
+                    algHandle = isHmac ?
+                        Interop.BCrypt.BCryptAlgPseudoHandle.BCRYPT_HMAC_SHA256_ALG_HANDLE :
+                        Interop.BCrypt.BCryptAlgPseudoHandle.BCRYPT_SHA256_ALG_HANDLE;
                     digestSizeInBytes = 256 / 8;
                 }
                 else if (hashAlgorithmId == HashAlgorithmNames.SHA384)
                 {
-                    algHandle = Interop.BCrypt.BCryptAlgPseudoHandle.BCRYPT_SHA384_ALG_HANDLE;
+                    algHandle = isHmac ?
+                        Interop.BCrypt.BCryptAlgPseudoHandle.BCRYPT_HMAC_SHA384_ALG_HANDLE :
+                        Interop.BCrypt.BCryptAlgPseudoHandle.BCRYPT_SHA384_ALG_HANDLE;
                     digestSizeInBytes = 384 / 8;
                 }
                 else if (hashAlgorithmId == HashAlgorithmNames.SHA512)
                 {
-                    algHandle = Interop.BCrypt.BCryptAlgPseudoHandle.BCRYPT_SHA512_ALG_HANDLE;
+                    algHandle = isHmac ?
+                        Interop.BCrypt.BCryptAlgPseudoHandle.BCRYPT_HMAC_SHA512_ALG_HANDLE :
+                        Interop.BCrypt.BCryptAlgPseudoHandle.BCRYPT_SHA512_ALG_HANDLE;
                     digestSizeInBytes = 512 / 8;
                 }
                 else
@@ -104,10 +156,11 @@ private static unsafe void HashDataUsingPseudoHandle(string hashAlgorithmId, Rea
                     throw new CryptographicException();
                 }
 
+                fixed (byte* pKey = &MemoryMarshal.GetReference(key))
                 fixed (byte* pSrc = &MemoryMarshal.GetReference(source))
                 fixed (byte* pDest = &MemoryMarshal.GetReference(destination))
                 {
-                    NTSTATUS ntStatus = Interop.BCrypt.BCryptHash((uint)algHandle, pbSecret: null, cbSecret: 0, pSrc, source.Length, pDest, digestSizeInBytes);
+                    NTSTATUS ntStatus = Interop.BCrypt.BCryptHash((uint)algHandle, pKey, key.Length, pSrc, source.Length, pDest, digestSizeInBytes);
 
                     if (ntStatus != NTSTATUS.STATUS_SUCCESS)
                     {
@@ -121,6 +174,7 @@ private static unsafe void HashDataUsingPseudoHandle(string hashAlgorithmId, Rea
             private static void HashUpdateAndFinish(
                 SafeBCryptAlgorithmHandle algHandle,
                 int hashSize,
+                ReadOnlySpan<byte> key,
                 ReadOnlySpan<byte> source,
                 Span<byte> destination)
             {
@@ -129,8 +183,8 @@ private static void HashUpdateAndFinish(
                     out SafeBCryptHashHandle hHash,
                     IntPtr.Zero,
                     0,
-                    default,
-                    0,
+                    key,
+                    key.Length,
                     BCryptCreateHashFlags.None);
 
                 if (ntStatus != NTSTATUS.STATUS_SUCCESS)
diff --git a/src/libraries/System.Security.Cryptography.Algorithms/src/System.Security.Cryptography.Algorithms.csproj b/src/libraries/System.Security.Cryptography.Algorithms/src/System.Security.Cryptography.Algorithms.csproj
index 566656df50a0b7..fd8d0a8b88b716 100644
--- a/src/libraries/System.Security.Cryptography.Algorithms/src/System.Security.Cryptography.Algorithms.csproj
+++ b/src/libraries/System.Security.Cryptography.Algorithms/src/System.Security.Cryptography.Algorithms.csproj
@@ -126,6 +126,8 @@
              Link="Common\System\Security\Cryptography\EccKeyFormatHelper.cs" />
     <Compile Include="$(CommonPath)System\Security\Cryptography\KeyBlobHelpers.cs"
              Link="Common\System\Security\Cryptography\KeyBlobHelpers.cs" />
+    <Compile Include="$(CommonPath)System\Security\Cryptography\HashOneShotHelpers.cs"
+             Link="Common\System\Security\Cryptography\HashOneShotHelpers.cs" />
     <Compile Include="$(CommonPath)System\Security\Cryptography\KeyFormatHelper.cs"
              Link="Common\System\Security\Cryptography\KeyFormatHelper.cs" />
     <Compile Include="$(CommonPath)System\Security\Cryptography\KeySizeHelpers.cs"
diff --git a/src/libraries/System.Security.Cryptography.Algorithms/src/System/Security/Cryptography/HKDF.cs b/src/libraries/System.Security.Cryptography.Algorithms/src/System/Security/Cryptography/HKDF.cs
index 3982e6597dbf44..418bfd2fa25ffe 100644
--- a/src/libraries/System.Security.Cryptography.Algorithms/src/System/Security/Cryptography/HKDF.cs
+++ b/src/libraries/System.Security.Cryptography.Algorithms/src/System/Security/Cryptography/HKDF.cs
@@ -67,12 +67,8 @@ public static int Extract(HashAlgorithmName hashAlgorithmName, ReadOnlySpan<byte
         private static void Extract(HashAlgorithmName hashAlgorithmName, int hashLength, ReadOnlySpan<byte> ikm, ReadOnlySpan<byte> salt, Span<byte> prk)
         {
             Debug.Assert(HashLength(hashAlgorithmName) == hashLength);
-
-            using (IncrementalHash hmac = IncrementalHash.CreateHMAC(hashAlgorithmName, salt))
-            {
-                hmac.AppendData(ikm);
-                GetHashAndReset(hmac, prk);
-            }
+            int written = HashOneShotHelpers.MacData(hashAlgorithmName, salt, ikm, prk);
+            Debug.Assert(written == prk.Length, $"Bytes written is {written} bytes which does not match output length ({prk.Length} bytes)");
         }
 
         /// <summary>
diff --git a/src/libraries/System.Security.Cryptography.Algorithms/src/System/Security/Cryptography/HMACMD5.cs b/src/libraries/System.Security.Cryptography.Algorithms/src/System/Security/Cryptography/HMACMD5.cs
index ad652572ead976..c66fcaab601cf2 100644
--- a/src/libraries/System.Security.Cryptography.Algorithms/src/System/Security/Cryptography/HMACMD5.cs
+++ b/src/libraries/System.Security.Cryptography.Algorithms/src/System/Security/Cryptography/HMACMD5.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 System.Runtime.Versioning;
 using Internal.Cryptography;
 
@@ -14,6 +15,9 @@ namespace System.Security.Cryptography
     [UnsupportedOSPlatform("browser")]
     public class HMACMD5 : HMAC
     {
+        private const int HmacSizeBits = 128;
+        private const int HmacSizeBytes = HmacSizeBits / 8;
+
         public HMACMD5()
             : this(RandomNumberGenerator.GetBytes(BlockSize))
         {
@@ -33,6 +37,7 @@ public HMACMD5(byte[] key)
             // we just want to be explicit in all HMAC extended classes
             BlockSizeValue = BlockSize;
             HashSizeValue = _hMacCommon.HashSizeInBits;
+            Debug.Assert(HashSizeValue == HmacSizeBits);
         }
 
         public override byte[] Key
@@ -67,6 +72,89 @@ protected override bool TryHashFinal(Span<byte> destination, out int bytesWritte
 
         public override void Initialize() => _hMacCommon.Reset();
 
+        /// <summary>
+        /// Computes the HMAC of data using the MD5 algorithm.
+        /// </summary>
+        /// <param name="key">The HMAC key.</param>
+        /// <param name="source">The data 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>
+        public static byte[] HashData(byte[] key, byte[] source)
+        {
+            if (key is null)
+                throw new ArgumentNullException(nameof(key));
+            if (source is null)
+                throw new ArgumentNullException(nameof(source));
+
+            return HashData(new ReadOnlySpan<byte>(key), new ReadOnlySpan<byte>(source));
+        }
+
+        /// <summary>
+        /// Computes the HMAC of data using the MD5 algorithm.
+        /// </summary>
+        /// <param name="key">The HMAC key.</param>
+        /// <param name="source">The data to HMAC.</param>
+        /// <returns>The HMAC of the data.</returns>
+        public static byte[] HashData(ReadOnlySpan<byte> key, ReadOnlySpan<byte> source)
+        {
+            byte[] buffer = new byte[HmacSizeBytes];
+
+            int written = HashData(key, source, buffer.AsSpan());
+            Debug.Assert(written == buffer.Length);
+
+            return buffer;
+        }
+
+        /// <summary>
+        /// Computes the HMAC of data using the MD5 algorithm.
+        /// </summary>
+        /// <param name="key">The HMAC key.</param>
+        /// <param name="source">The data 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="ArgumentException">
+        /// The buffer in <paramref name="destination"/> is too small to hold the calculated hash
+        /// size. The MD5 algorithm always produces a 128-bit HMAC, or 16 bytes.
+        /// </exception>
+        public static int HashData(ReadOnlySpan<byte> key, ReadOnlySpan<byte> source, Span<byte> destination)
+        {
+            if (!TryHashData(key, source, destination, out int bytesWritten))
+            {
+                throw new ArgumentException(SR.Argument_DestinationTooShort, nameof(destination));
+            }
+
+            return bytesWritten;
+        }
+
+        /// <summary>
+        /// Attempts to compute the HMAC of data using the MD5 algorithm.
+        /// </summary>
+        /// <param name="key">The HMAC key.</param>
+        /// <param name="source">The data to HMAC.</param>
+        /// <param name="destination">The buffer to receive the HMAC value.</param>
+        /// <param name="bytesWritten">
+        /// When this method returns, the total number of bytes written into <paramref name="destination"/>.
+        /// </param>
+        /// <returns>
+        /// <see langword="false"/> if <paramref name="destination"/> is too small to hold the
+        /// calculated hash, <see langword="true"/> otherwise.
+        /// </returns>
+        public static bool TryHashData(ReadOnlySpan<byte> key, ReadOnlySpan<byte> source, Span<byte> destination, out int bytesWritten)
+        {
+            if (destination.Length < HmacSizeBytes)
+            {
+                bytesWritten = 0;
+                return false;
+            }
+
+            bytesWritten = HashProviderDispenser.OneShotHashProvider.MacData(HashAlgorithmNames.MD5, key, source, destination);
+            Debug.Assert(bytesWritten == HmacSizeBytes);
+
+            return true;
+        }
+
         protected override void Dispose(bool disposing)
         {
             if (disposing)
diff --git a/src/libraries/System.Security.Cryptography.Algorithms/src/System/Security/Cryptography/HMACSHA1.cs b/src/libraries/System.Security.Cryptography.Algorithms/src/System/Security/Cryptography/HMACSHA1.cs
index 1d090d1b8f33a7..39e57c3fe72199 100644
--- a/src/libraries/System.Security.Cryptography.Algorithms/src/System/Security/Cryptography/HMACSHA1.cs
+++ b/src/libraries/System.Security.Cryptography.Algorithms/src/System/Security/Cryptography/HMACSHA1.cs
@@ -3,6 +3,7 @@
 
 using Internal.Cryptography;
 using System.ComponentModel;
+using System.Diagnostics;
 using System.Runtime.Versioning;
 
 namespace System.Security.Cryptography
@@ -15,6 +16,9 @@ namespace System.Security.Cryptography
     [UnsupportedOSPlatform("browser")]
     public class HMACSHA1 : HMAC
     {
+        private const int HmacSizeBits = 160;
+        private const int HmacSizeBytes = HmacSizeBits / 8;
+
         public HMACSHA1()
             : this(RandomNumberGenerator.GetBytes(BlockSize))
         {
@@ -34,6 +38,7 @@ public HMACSHA1(byte[] key)
             // we just want to be explicit in all HMAC extended classes
             BlockSizeValue = BlockSize;
             HashSizeValue = _hMacCommon.HashSizeInBits;
+            Debug.Assert(HashSizeValue == HmacSizeBits);
         }
 
         [EditorBrowsable(EditorBrowsableState.Never)]
@@ -74,6 +79,89 @@ protected override bool TryHashFinal(Span<byte> destination, out int bytesWritte
 
         public override void Initialize() => _hMacCommon.Reset();
 
+        /// <summary>
+        /// Computes the HMAC of data using the SHA1 algorithm.
+        /// </summary>
+        /// <param name="key">The HMAC key.</param>
+        /// <param name="source">The data 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>
+        public static byte[] HashData(byte[] key, byte[] source)
+        {
+            if (key is null)
+                throw new ArgumentNullException(nameof(key));
+            if (source is null)
+                throw new ArgumentNullException(nameof(source));
+
+            return HashData(new ReadOnlySpan<byte>(key), new ReadOnlySpan<byte>(source));
+        }
+
+        /// <summary>
+        /// Computes the HMAC of data using the SHA1 algorithm.
+        /// </summary>
+        /// <param name="key">The HMAC key.</param>
+        /// <param name="source">The data to HMAC.</param>
+        /// <returns>The HMAC of the data.</returns>
+        public static byte[] HashData(ReadOnlySpan<byte> key, ReadOnlySpan<byte> source)
+        {
+            byte[] buffer = new byte[HmacSizeBytes];
+
+            int written = HashData(key, source, buffer.AsSpan());
+            Debug.Assert(written == buffer.Length);
+
+            return buffer;
+        }
+
+        /// <summary>
+        /// Computes the HMAC of data using the SHA1 algorithm.
+        /// </summary>
+        /// <param name="key">The HMAC key.</param>
+        /// <param name="source">The data 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="ArgumentException">
+        /// The buffer in <paramref name="destination"/> is too small to hold the calculated hash
+        /// size. The SHA1 algorithm always produces a 160-bit HMAC, or 20 bytes.
+        /// </exception>
+        public static int HashData(ReadOnlySpan<byte> key, ReadOnlySpan<byte> source, Span<byte> destination)
+        {
+            if (!TryHashData(key, source, destination, out int bytesWritten))
+            {
+                throw new ArgumentException(SR.Argument_DestinationTooShort, nameof(destination));
+            }
+
+            return bytesWritten;
+        }
+
+        /// <summary>
+        /// Attempts to compute the HMAC of data using the SHA1 algorithm.
+        /// </summary>
+        /// <param name="key">The HMAC key.</param>
+        /// <param name="source">The data to HMAC.</param>
+        /// <param name="destination">The buffer to receive the HMAC value.</param>
+        /// <param name="bytesWritten">
+        /// When this method returns, the total number of bytes written into <paramref name="destination"/>.
+        /// </param>
+        /// <returns>
+        /// <see langword="false"/> if <paramref name="destination"/> is too small to hold the
+        /// calculated hash, <see langword="true"/> otherwise.
+        /// </returns>
+        public static bool TryHashData(ReadOnlySpan<byte> key, ReadOnlySpan<byte> source, Span<byte> destination, out int bytesWritten)
+        {
+            if (destination.Length < HmacSizeBytes)
+            {
+                bytesWritten = 0;
+                return false;
+            }
+
+            bytesWritten = HashProviderDispenser.OneShotHashProvider.MacData(HashAlgorithmNames.SHA1, key, source, destination);
+            Debug.Assert(bytesWritten == HmacSizeBytes);
+
+            return true;
+        }
+
         protected override void Dispose(bool disposing)
         {
             if (disposing)
diff --git a/src/libraries/System.Security.Cryptography.Algorithms/src/System/Security/Cryptography/HMACSHA256.cs b/src/libraries/System.Security.Cryptography.Algorithms/src/System/Security/Cryptography/HMACSHA256.cs
index 0bc11095fc7044..598c4c2a6ffa36 100644
--- a/src/libraries/System.Security.Cryptography.Algorithms/src/System/Security/Cryptography/HMACSHA256.cs
+++ b/src/libraries/System.Security.Cryptography.Algorithms/src/System/Security/Cryptography/HMACSHA256.cs
@@ -1,11 +1,10 @@
 // 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 Internal.Cryptography;
 using System.Diagnostics;
 using System.Runtime.Versioning;
 using System.Security.Cryptography;
-using Internal.Cryptography;
 
 namespace System.Security.Cryptography
 {
@@ -17,6 +16,9 @@ namespace System.Security.Cryptography
     [UnsupportedOSPlatform("browser")]
     public class HMACSHA256 : HMAC
     {
+        private const int HmacSizeBits = 256;
+        private const int HmacSizeBytes = HmacSizeBits / 8;
+
         public HMACSHA256()
             : this(RandomNumberGenerator.GetBytes(BlockSize))
         {
@@ -36,6 +38,7 @@ public HMACSHA256(byte[] key)
             // we just want to be explicit in all HMAC extended classes
             BlockSizeValue = BlockSize;
             HashSizeValue = _hMacCommon.HashSizeInBits;
+            Debug.Assert(HashSizeValue == HmacSizeBits);
         }
 
         public override byte[] Key
@@ -70,6 +73,89 @@ protected override bool TryHashFinal(Span<byte> destination, out int bytesWritte
 
         public override void Initialize() => _hMacCommon.Reset();
 
+        /// <summary>
+        /// Computes the HMAC of data using the SHA256 algorithm.
+        /// </summary>
+        /// <param name="key">The HMAC key.</param>
+        /// <param name="source">The data 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>
+        public static byte[] HashData(byte[] key, byte[] source)
+        {
+            if (key is null)
+                throw new ArgumentNullException(nameof(key));
+            if (source is null)
+                throw new ArgumentNullException(nameof(source));
+
+            return HashData(new ReadOnlySpan<byte>(key), new ReadOnlySpan<byte>(source));
+        }
+
+        /// <summary>
+        /// Computes the HMAC of data using the SHA256 algorithm.
+        /// </summary>
+        /// <param name="key">The HMAC key.</param>
+        /// <param name="source">The data to HMAC.</param>
+        /// <returns>The HMAC of the data.</returns>
+        public static byte[] HashData(ReadOnlySpan<byte> key, ReadOnlySpan<byte> source)
+        {
+            byte[] buffer = new byte[HmacSizeBytes];
+
+            int written = HashData(key, source, buffer.AsSpan());
+            Debug.Assert(written == buffer.Length);
+
+            return buffer;
+        }
+
+        /// <summary>
+        /// Computes the HMAC of data using the SHA256 algorithm.
+        /// </summary>
+        /// <param name="key">The HMAC key.</param>
+        /// <param name="source">The data 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="ArgumentException">
+        /// The buffer in <paramref name="destination"/> is too small to hold the calculated hash
+        /// size. The SHA256 algorithm always produces a 256-bit HMAC, or 32 bytes.
+        /// </exception>
+        public static int HashData(ReadOnlySpan<byte> key, ReadOnlySpan<byte> source, Span<byte> destination)
+        {
+            if (!TryHashData(key, source, destination, out int bytesWritten))
+            {
+                throw new ArgumentException(SR.Argument_DestinationTooShort, nameof(destination));
+            }
+
+            return bytesWritten;
+        }
+
+        /// <summary>
+        /// Attempts to compute the HMAC of data using the SHA256 algorithm.
+        /// </summary>
+        /// <param name="key">The HMAC key.</param>
+        /// <param name="source">The data to HMAC.</param>
+        /// <param name="destination">The buffer to receive the HMAC value.</param>
+        /// <param name="bytesWritten">
+        /// When this method returns, the total number of bytes written into <paramref name="destination"/>.
+        /// </param>
+        /// <returns>
+        /// <see langword="false"/> if <paramref name="destination"/> is too small to hold the
+        /// calculated hash, <see langword="true"/> otherwise.
+        /// </returns>
+        public static bool TryHashData(ReadOnlySpan<byte> key, ReadOnlySpan<byte> source, Span<byte> destination, out int bytesWritten)
+        {
+            if (destination.Length < HmacSizeBytes)
+            {
+                bytesWritten = 0;
+                return false;
+            }
+
+            bytesWritten = HashProviderDispenser.OneShotHashProvider.MacData(HashAlgorithmNames.SHA256, key, source, destination);
+            Debug.Assert(bytesWritten == HmacSizeBytes);
+
+            return true;
+        }
+
         protected override void Dispose(bool disposing)
         {
             if (disposing)
diff --git a/src/libraries/System.Security.Cryptography.Algorithms/src/System/Security/Cryptography/HMACSHA384.cs b/src/libraries/System.Security.Cryptography.Algorithms/src/System/Security/Cryptography/HMACSHA384.cs
index 05548b082885db..bf167162e4c0af 100644
--- a/src/libraries/System.Security.Cryptography.Algorithms/src/System/Security/Cryptography/HMACSHA384.cs
+++ b/src/libraries/System.Security.Cryptography.Algorithms/src/System/Security/Cryptography/HMACSHA384.cs
@@ -1,11 +1,10 @@
 // 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 Internal.Cryptography;
 using System.Diagnostics;
 using System.Runtime.Versioning;
 using System.Security.Cryptography;
-using Internal.Cryptography;
 
 namespace System.Security.Cryptography
 {
@@ -17,6 +16,9 @@ namespace System.Security.Cryptography
     [UnsupportedOSPlatform("browser")]
     public class HMACSHA384 : HMAC
     {
+        private const int HmacSizeBits = 384;
+        private const int HmacSizeBytes = HmacSizeBits / 8;
+
         public HMACSHA384()
             : this(RandomNumberGenerator.GetBytes(BlockSize))
         {
@@ -35,6 +37,7 @@ public HMACSHA384(byte[] key)
             // change the default value of BlockSizeValue to 128 instead of 64
             BlockSizeValue = BlockSize;
             HashSizeValue = _hMacCommon.HashSizeInBits;
+            Debug.Assert(HashSizeValue == HmacSizeBits);
         }
 
         public bool ProduceLegacyHmacValues
@@ -86,6 +89,89 @@ protected override bool TryHashFinal(Span<byte> destination, out int bytesWritte
 
         public override void Initialize() => _hMacCommon.Reset();
 
+        /// <summary>
+        /// Computes the HMAC of data using the SHA384 algorithm.
+        /// </summary>
+        /// <param name="key">The HMAC key.</param>
+        /// <param name="source">The data 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>
+        public static byte[] HashData(byte[] key, byte[] source)
+        {
+            if (key is null)
+                throw new ArgumentNullException(nameof(key));
+            if (source is null)
+                throw new ArgumentNullException(nameof(source));
+
+            return HashData(new ReadOnlySpan<byte>(key), new ReadOnlySpan<byte>(source));
+        }
+
+        /// <summary>
+        /// Computes the HMAC of data using the SHA384 algorithm.
+        /// </summary>
+        /// <param name="key">The HMAC key.</param>
+        /// <param name="source">The data to HMAC.</param>
+        /// <returns>The HMAC of the data.</returns>
+        public static byte[] HashData(ReadOnlySpan<byte> key, ReadOnlySpan<byte> source)
+        {
+            byte[] buffer = new byte[HmacSizeBytes];
+
+            int written = HashData(key, source, buffer.AsSpan());
+            Debug.Assert(written == buffer.Length);
+
+            return buffer;
+        }
+
+        /// <summary>
+        /// Computes the HMAC of data using the SHA384 algorithm.
+        /// </summary>
+        /// <param name="key">The HMAC key.</param>
+        /// <param name="source">The data 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="ArgumentException">
+        /// The buffer in <paramref name="destination"/> is too small to hold the calculated hash
+        /// size. The SHA384 algorithm always produces a 384-bit HMAC, or 48 bytes.
+        /// </exception>
+        public static int HashData(ReadOnlySpan<byte> key, ReadOnlySpan<byte> source, Span<byte> destination)
+        {
+            if (!TryHashData(key, source, destination, out int bytesWritten))
+            {
+                throw new ArgumentException(SR.Argument_DestinationTooShort, nameof(destination));
+            }
+
+            return bytesWritten;
+        }
+
+        /// <summary>
+        /// Attempts to compute the HMAC of data using the SHA384 algorithm.
+        /// </summary>
+        /// <param name="key">The HMAC key.</param>
+        /// <param name="source">The data to HMAC.</param>
+        /// <param name="destination">The buffer to receive the HMAC value.</param>
+        /// <param name="bytesWritten">
+        /// When this method returns, the total number of bytes written into <paramref name="destination"/>.
+        /// </param>
+        /// <returns>
+        /// <see langword="false"/> if <paramref name="destination"/> is too small to hold the
+        /// calculated hash, <see langword="true"/> otherwise.
+        /// </returns>
+        public static bool TryHashData(ReadOnlySpan<byte> key, ReadOnlySpan<byte> source, Span<byte> destination, out int bytesWritten)
+        {
+            if (destination.Length < HmacSizeBytes)
+            {
+                bytesWritten = 0;
+                return false;
+            }
+
+            bytesWritten = HashProviderDispenser.OneShotHashProvider.MacData(HashAlgorithmNames.SHA384, key, source, destination);
+            Debug.Assert(bytesWritten == HmacSizeBytes);
+
+            return true;
+        }
+
         protected override void Dispose(bool disposing)
         {
             if (disposing)
diff --git a/src/libraries/System.Security.Cryptography.Algorithms/src/System/Security/Cryptography/HMACSHA512.cs b/src/libraries/System.Security.Cryptography.Algorithms/src/System/Security/Cryptography/HMACSHA512.cs
index 556dd54f392887..9b25cdca959a74 100644
--- a/src/libraries/System.Security.Cryptography.Algorithms/src/System/Security/Cryptography/HMACSHA512.cs
+++ b/src/libraries/System.Security.Cryptography.Algorithms/src/System/Security/Cryptography/HMACSHA512.cs
@@ -1,11 +1,10 @@
 // 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 Internal.Cryptography;
 using System.Diagnostics;
 using System.Runtime.Versioning;
 using System.Security.Cryptography;
-using Internal.Cryptography;
 
 namespace System.Security.Cryptography
 {
@@ -17,6 +16,9 @@ namespace System.Security.Cryptography
     [UnsupportedOSPlatform("browser")]
     public class HMACSHA512 : HMAC
     {
+        private const int HmacSizeBits = 512;
+        private const int HmacSizeBytes = HmacSizeBits / 8;
+
         public HMACSHA512()
             : this(RandomNumberGenerator.GetBytes(BlockSize))
         {
@@ -84,6 +86,89 @@ protected override bool TryHashFinal(Span<byte> destination, out int bytesWritte
 
         public override void Initialize() => _hMacCommon.Reset();
 
+        /// <summary>
+        /// Computes the HMAC of data using the SHA512 algorithm.
+        /// </summary>
+        /// <param name="key">The HMAC key.</param>
+        /// <param name="source">The data 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>
+        public static byte[] HashData(byte[] key, byte[] source)
+        {
+            if (key is null)
+                throw new ArgumentNullException(nameof(key));
+            if (source is null)
+                throw new ArgumentNullException(nameof(source));
+
+            return HashData(new ReadOnlySpan<byte>(key), new ReadOnlySpan<byte>(source));
+        }
+
+        /// <summary>
+        /// Computes the HMAC of data using the SHA512 algorithm.
+        /// </summary>
+        /// <param name="key">The HMAC key.</param>
+        /// <param name="source">The data to HMAC.</param>
+        /// <returns>The HMAC of the data.</returns>
+        public static byte[] HashData(ReadOnlySpan<byte> key, ReadOnlySpan<byte> source)
+        {
+            byte[] buffer = new byte[HmacSizeBytes];
+
+            int written = HashData(key, source, buffer.AsSpan());
+            Debug.Assert(written == buffer.Length);
+
+            return buffer;
+        }
+
+        /// <summary>
+        /// Computes the HMAC of data using the SHA512 algorithm.
+        /// </summary>
+        /// <param name="key">The HMAC key.</param>
+        /// <param name="source">The data 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="ArgumentException">
+        /// The buffer in <paramref name="destination"/> is too small to hold the calculated hash
+        /// size. The SHA512 algorithm always produces a 512-bit HMAC, or 64 bytes.
+        /// </exception>
+        public static int HashData(ReadOnlySpan<byte> key, ReadOnlySpan<byte> source, Span<byte> destination)
+        {
+            if (!TryHashData(key, source, destination, out int bytesWritten))
+            {
+                throw new ArgumentException(SR.Argument_DestinationTooShort, nameof(destination));
+            }
+
+            return bytesWritten;
+        }
+
+        /// <summary>
+        /// Attempts to compute the HMAC of data using the SHA512 algorithm.
+        /// </summary>
+        /// <param name="key">The HMAC key.</param>
+        /// <param name="source">The data to HMAC.</param>
+        /// <param name="destination">The buffer to receive the HMAC value.</param>
+        /// <param name="bytesWritten">
+        /// When this method returns, the total number of bytes written into <paramref name="destination"/>.
+        /// </param>
+        /// <returns>
+        /// <see langword="false"/> if <paramref name="destination"/> is too small to hold the
+        /// calculated hash, <see langword="true"/> otherwise.
+        /// </returns>
+        public static bool TryHashData(ReadOnlySpan<byte> key, ReadOnlySpan<byte> source, Span<byte> destination, out int bytesWritten)
+        {
+            if (destination.Length < HmacSizeBytes)
+            {
+                bytesWritten = 0;
+                return false;
+            }
+
+            bytesWritten = HashProviderDispenser.OneShotHashProvider.MacData(HashAlgorithmNames.SHA512, key, source, destination);
+            Debug.Assert(bytesWritten == HmacSizeBytes);
+
+            return true;
+        }
+
         protected override void Dispose(bool disposing)
         {
             if (disposing)
diff --git a/src/libraries/System.Security.Cryptography.Algorithms/tests/HmacMD5Tests.cs b/src/libraries/System.Security.Cryptography.Algorithms/tests/HmacMD5Tests.cs
index c3cc9ea115e0c3..0c6cb580d09da4 100644
--- a/src/libraries/System.Security.Cryptography.Algorithms/tests/HmacMD5Tests.cs
+++ b/src/libraries/System.Security.Cryptography.Algorithms/tests/HmacMD5Tests.cs
@@ -21,63 +21,80 @@ public class HmacMD5Tests : Rfc2202HmacTests
             ByteUtils.RepeatByte(0xaa, 80),
         };
 
-        public HmacMD5Tests()
-            : base(s_testKeys2202)
+        private static readonly byte[][] s_testMacs2202 =
         {
-        }
+            null,
+            ByteUtils.HexToByteArray("9294727a3638bb1c13f48ef8158bfc9d"),
+            ByteUtils.HexToByteArray("750c783e6ab0b503eaa86e310a5db738"),
+            ByteUtils.HexToByteArray("56be34521d144c88dbb8c733f0e8b3f6"),
+            ByteUtils.HexToByteArray("697eaf0aca3a3aea3a75164746ffaa79"),
+            ByteUtils.HexToByteArray("56461ef2342edc00f9bab995690efd4c"),
+            ByteUtils.HexToByteArray("6b1ab7fe4bd7bf8f0b62e6ce61b9d0cd"),
+            ByteUtils.HexToByteArray("6f630fad67cda0ee1fb1f562db3aa53e"),
+        };
 
-        protected override HMAC Create()
+        public HmacMD5Tests()
+            : base(s_testKeys2202, s_testMacs2202)
         {
-            return new HMACMD5();
         }
 
-        protected override HashAlgorithm CreateHashAlgorithm()
-        {
-            return MD5.Create();
-        }
+        protected override int BlockSize => 64;
+        protected override int MacSize => 16;
+
+        protected override HMAC Create() => new HMACMD5();
+        protected override HashAlgorithm CreateHashAlgorithm() => MD5.Create();
+        protected override byte[] HashDataOneShot(byte[] key, byte[] source) =>
+            HMACMD5.HashData(key, source);
+
+        protected override byte[] HashDataOneShot(ReadOnlySpan<byte> key, ReadOnlySpan<byte> source) =>
+            HMACMD5.HashData(key, source);
+
+        protected override int HashDataOneShot(ReadOnlySpan<byte> key, ReadOnlySpan<byte> source, Span<byte> destination) =>
+            HMACMD5.HashData(key, source, destination);
 
-        protected override int BlockSize { get { return 64; } }
+        protected override bool TryHashDataOneShot(ReadOnlySpan<byte> key, ReadOnlySpan<byte> source, Span<byte> destination, out int written) =>
+            HMACMD5.TryHashData(key, source, destination, out written);
 
         [Fact]
         public void HmacMD5_Rfc2202_1()
         {
-            VerifyHmac(1, "9294727a3638bb1c13f48ef8158bfc9d");
+            VerifyHmac(1, s_testMacs2202[1]);
         }
 
         [Fact]
         public void HmacMD5_Rfc2202_2()
         {
-            VerifyHmac(2, "750c783e6ab0b503eaa86e310a5db738");
+            VerifyHmac(2, s_testMacs2202[2]);
         }
 
         [Fact]
         public void HmacMD5_Rfc2202_3()
         {
-            VerifyHmac(3, "56be34521d144c88dbb8c733f0e8b3f6");
+            VerifyHmac(3, s_testMacs2202[3]);
         }
 
         [Fact]
         public void HmacMD5_Rfc2202_4()
         {
-            VerifyHmac(4, "697eaf0aca3a3aea3a75164746ffaa79");
+            VerifyHmac(4, s_testMacs2202[4]);
         }
 
         [Fact]
         public void HmacMD5_Rfc2202_5()
         {
-            VerifyHmac(5, "56461ef2342edc00f9bab995690efd4c");
+            VerifyHmac(5, s_testMacs2202[5]);
         }
 
         [Fact]
         public void HmacMD5_Rfc2202_6()
         {
-            VerifyHmac(6, "6b1ab7fe4bd7bf8f0b62e6ce61b9d0cd");
+            VerifyHmac(6, s_testMacs2202[6]);
         }
 
         [Fact]
         public void HmacMD5_Rfc2202_7()
         {
-            VerifyHmac(7, "6f630fad67cda0ee1fb1f562db3aa53e");
+            VerifyHmac(7, s_testMacs2202[7]);
         }
 
         [Fact]
diff --git a/src/libraries/System.Security.Cryptography.Algorithms/tests/HmacSha1Tests.cs b/src/libraries/System.Security.Cryptography.Algorithms/tests/HmacSha1Tests.cs
index 4cda1cc1eb2c59..49a9d6de1bb03a 100644
--- a/src/libraries/System.Security.Cryptography.Algorithms/tests/HmacSha1Tests.cs
+++ b/src/libraries/System.Security.Cryptography.Algorithms/tests/HmacSha1Tests.cs
@@ -21,22 +21,39 @@ public class HmacSha1Tests : Rfc2202HmacTests
             ByteUtils.RepeatByte(0xaa, 80),
         };
 
-        public HmacSha1Tests()
-            : base(s_testKeys2202)
+        private static readonly byte[][] s_testMacs2202 =
         {
-        }
+            null,
+            ByteUtils.HexToByteArray("b617318655057264e28bc0b6fb378c8ef146be00"),
+            ByteUtils.HexToByteArray("effcdf6ae5eb2fa2d27416d5f184df9c259a7c79"),
+            ByteUtils.HexToByteArray("125d7342b9ac11cd91a39af48aa17b4f63f175d3"),
+            ByteUtils.HexToByteArray("4c9007f4026250c6bc8414f9bf50c86c2d7235da"),
+            ByteUtils.HexToByteArray("4c1a03424b55e07fe7f27be1d58bb9324a9a5a04"),
+            ByteUtils.HexToByteArray("aa4ae5e15272d00e95705637ce8a3b55ed402112"),
+            ByteUtils.HexToByteArray("e8e99d0f45237d786d6bbaa7965c7808bbff1a91"),
+        };
 
-        protected override HMAC Create()
+        public HmacSha1Tests()
+            : base(s_testKeys2202, s_testMacs2202)
         {
-            return new HMACSHA1();
         }
 
-        protected override HashAlgorithm CreateHashAlgorithm()
-        {
-            return SHA1.Create();
-        }
+        protected override int BlockSize => 64;
+        protected override int MacSize => 20;
+
+        protected override HMAC Create() => new HMACSHA1();
+        protected override HashAlgorithm CreateHashAlgorithm() => SHA1.Create();
+        protected override byte[] HashDataOneShot(byte[] key, byte[] source) =>
+            HMACSHA1.HashData(key, source);
+
+        protected override byte[] HashDataOneShot(ReadOnlySpan<byte> key, ReadOnlySpan<byte> source) =>
+            HMACSHA1.HashData(key, source);
+
+        protected override int HashDataOneShot(ReadOnlySpan<byte> key, ReadOnlySpan<byte> source, Span<byte> destination) =>
+            HMACSHA1.HashData(key, source, destination);
 
-        protected override int BlockSize { get { return 64; } }
+        protected override bool TryHashDataOneShot(ReadOnlySpan<byte> key, ReadOnlySpan<byte> source, Span<byte> destination, out int written) =>
+            HMACSHA1.TryHashData(key, source, destination, out written);
 
         [Fact]
         public void HmacSha1_Byte_Constructors()
@@ -69,43 +86,43 @@ public void HmacSha1_ThrowsArgumentNullForNullConstructorKey()
         [Fact]
         public void HmacSha1_Rfc2202_1()
         {
-            VerifyHmac(1, "b617318655057264e28bc0b6fb378c8ef146be00");
+            VerifyHmac(1, s_testMacs2202[1]);
         }
 
         [Fact]
         public void HmacSha1_Rfc2202_2()
         {
-            VerifyHmac(2, "effcdf6ae5eb2fa2d27416d5f184df9c259a7c79");
+            VerifyHmac(2, s_testMacs2202[2]);
         }
 
         [Fact]
         public void HmacSha1_Rfc2202_3()
         {
-            VerifyHmac(3, "125d7342b9ac11cd91a39af48aa17b4f63f175d3");
+            VerifyHmac(3, s_testMacs2202[3]);
         }
 
         [Fact]
         public void HmacSha1_Rfc2202_4()
         {
-            VerifyHmac(4, "4c9007f4026250c6bc8414f9bf50c86c2d7235da");
+            VerifyHmac(4, s_testMacs2202[4]);
         }
 
         [Fact]
         public void HmacSha1_Rfc2202_5()
         {
-            VerifyHmac(5, "4c1a03424b55e07fe7f27be1d58bb9324a9a5a04");
+            VerifyHmac(5, s_testMacs2202[5]);
         }
 
         [Fact]
         public void HmacSha1_Rfc2202_6()
         {
-            VerifyHmac(6, "aa4ae5e15272d00e95705637ce8a3b55ed402112");
+            VerifyHmac(6, s_testMacs2202[6]);
         }
 
         [Fact]
         public void HmacSha1_Rfc2202_7()
         {
-            VerifyHmac(7, "e8e99d0f45237d786d6bbaa7965c7808bbff1a91");
+            VerifyHmac(7, s_testMacs2202[7]);
         }
 
         [Fact]
diff --git a/src/libraries/System.Security.Cryptography.Algorithms/tests/HmacSha256Tests.cs b/src/libraries/System.Security.Cryptography.Algorithms/tests/HmacSha256Tests.cs
index a9d12e55a9c2d6..ae9004e12f5aff 100644
--- a/src/libraries/System.Security.Cryptography.Algorithms/tests/HmacSha256Tests.cs
+++ b/src/libraries/System.Security.Cryptography.Algorithms/tests/HmacSha256Tests.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 Test.Cryptography;
 using Xunit;
 
 namespace System.Security.Cryptography.Hashing.Algorithms.Tests
@@ -8,59 +9,80 @@ namespace System.Security.Cryptography.Hashing.Algorithms.Tests
     [SkipOnPlatform(TestPlatforms.Browser, "Not supported on Browser")]
     public class HmacSha256Tests : Rfc4231HmacTests
     {
-        protected override HMAC Create()
+        protected override int BlockSize => 64;
+        protected override int MacSize => 32;
+
+        protected override HMAC Create() => new HMACSHA256();
+        protected override HashAlgorithm CreateHashAlgorithm() => SHA256.Create();
+        protected override byte[] HashDataOneShot(byte[] key, byte[] source) =>
+            HMACSHA256.HashData(key, source);
+
+        protected override byte[] HashDataOneShot(ReadOnlySpan<byte> key, ReadOnlySpan<byte> source) =>
+            HMACSHA256.HashData(key, source);
+
+        protected override int HashDataOneShot(ReadOnlySpan<byte> key, ReadOnlySpan<byte> source, Span<byte> destination) =>
+            HMACSHA256.HashData(key, source, destination);
+
+        protected override bool TryHashDataOneShot(ReadOnlySpan<byte> key, ReadOnlySpan<byte> source, Span<byte> destination, out int written) =>
+            HMACSHA256.TryHashData(key, source, destination, out written);
+
+        private static byte[][] s_testMacs4231 =
         {
-            return new HMACSHA256();
-        }
+            null,
+            ByteUtils.HexToByteArray("b0344c61d8db38535ca8afceaf0bf12b881dc200c9833da726e9376c2e32cff7"),
+            ByteUtils.HexToByteArray("5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843"),
+            ByteUtils.HexToByteArray("773ea91e36800e46854db8ebd09181a72959098b3ef8c122d9635514ced565fe"),
+            ByteUtils.HexToByteArray("82558a389a443c0ea4cc819899f2083a85f0faa3e578f8077a2e3ff46729665b"),
+            // RFC 4231 only defines the first 128 bits of this value.
+            ByteUtils.HexToByteArray("a3b6167473100ee06e0c796c2955552b"),
+            ByteUtils.HexToByteArray("60e431591ee0b67f0d8a26aacbf5b77f8e0bc6213728c5140546040f0ee37f54"),
+            ByteUtils.HexToByteArray("9b09ffa71b942fcb27635fbcd5b0e944bfdc63644f0713938a7f51535c3a35e2"),
+        };
 
-        protected override HashAlgorithm CreateHashAlgorithm()
+        public HmacSha256Tests() : base(s_testMacs4231)
         {
-            return SHA256.Create();
         }
 
-        protected override int BlockSize { get { return 64; } }
-
         [Fact]
         public void HmacSha256_Rfc4231_1()
         {
-            VerifyHmac(1, "b0344c61d8db38535ca8afceaf0bf12b881dc200c9833da726e9376c2e32cff7");
+            VerifyHmac(1, s_testMacs4231[1]);
         }
 
         [Fact]
         public void HmacSha256_Rfc4231_2()
         {
-            VerifyHmac(2, "5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843");
+            VerifyHmac(2, s_testMacs4231[2]);
         }
 
         [Fact]
         public void HmacSha256_Rfc4231_3()
         {
-            VerifyHmac(3, "773ea91e36800e46854db8ebd09181a72959098b3ef8c122d9635514ced565fe");
+            VerifyHmac(3, s_testMacs4231[3]);
         }
 
         [Fact]
         public void HmacSha256_Rfc4231_4()
         {
-            VerifyHmac(4, "82558a389a443c0ea4cc819899f2083a85f0faa3e578f8077a2e3ff46729665b");
+            VerifyHmac(4, s_testMacs4231[4]);
         }
 
         [Fact]
         public void HmacSha256_Rfc4231_5()
         {
-            // RFC 4231 only defines the first 128 bits of this value.
-            VerifyHmac(5, "a3b6167473100ee06e0c796c2955552b", 128 / 8);
+            VerifyHmac(5, s_testMacs4231[5]);
         }
 
         [Fact]
         public void HmacSha256_Rfc4231_6()
         {
-            VerifyHmac(6, "60e431591ee0b67f0d8a26aacbf5b77f8e0bc6213728c5140546040f0ee37f54");
+            VerifyHmac(6, s_testMacs4231[6]);
         }
 
         [Fact]
         public void HmacSha256_Rfc4231_7()
         {
-            VerifyHmac(7, "9b09ffa71b942fcb27635fbcd5b0e944bfdc63644f0713938a7f51535c3a35e2");
+            VerifyHmac(7, s_testMacs4231[7]);
         }
 
         [Fact]
diff --git a/src/libraries/System.Security.Cryptography.Algorithms/tests/HmacSha384Tests.cs b/src/libraries/System.Security.Cryptography.Algorithms/tests/HmacSha384Tests.cs
index 5a5f0699a2a952..76325f1ba65545 100644
--- a/src/libraries/System.Security.Cryptography.Algorithms/tests/HmacSha384Tests.cs
+++ b/src/libraries/System.Security.Cryptography.Algorithms/tests/HmacSha384Tests.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 Test.Cryptography;
 using Xunit;
 
 namespace System.Security.Cryptography.Hashing.Algorithms.Tests
@@ -8,18 +9,40 @@ namespace System.Security.Cryptography.Hashing.Algorithms.Tests
     [SkipOnPlatform(TestPlatforms.Browser, "Not supported on Browser")]
     public class HmacSha384Tests : Rfc4231HmacTests
     {
-        protected override HMAC Create()
+        protected override int BlockSize => 128;
+        protected override int MacSize => 48;
+
+        protected override HMAC Create() => new HMACSHA384();
+        protected override HashAlgorithm CreateHashAlgorithm() => SHA384.Create();
+        protected override byte[] HashDataOneShot(byte[] key, byte[] source) =>
+            HMACSHA384.HashData(key, source);
+
+        protected override byte[] HashDataOneShot(ReadOnlySpan<byte> key, ReadOnlySpan<byte> source) =>
+            HMACSHA384.HashData(key, source);
+
+        protected override int HashDataOneShot(ReadOnlySpan<byte> key, ReadOnlySpan<byte> source, Span<byte> destination) =>
+            HMACSHA384.HashData(key, source, destination);
+
+        protected override bool TryHashDataOneShot(ReadOnlySpan<byte> key, ReadOnlySpan<byte> source, Span<byte> destination, out int written) =>
+            HMACSHA384.TryHashData(key, source, destination, out written);
+
+        private static byte[][] s_testMacs4231 =
         {
-            return new HMACSHA384();
-        }
+            null,
+            ByteUtils.HexToByteArray("afd03944d84895626b0825f4ab46907f15f9dadbe4101ec682aa034c7cebc59cfaea9ea9076ede7f4af152e8b2fa9cb6"),
+            ByteUtils.HexToByteArray("af45d2e376484031617f78d2b58a6b1b9c7ef464f5a01b47e42ec3736322445e8e2240ca5e69e2c78b3239ecfab21649"),
+            ByteUtils.HexToByteArray("88062608d3e6ad8a0aa2ace014c8a86f0aa635d947ac9febe83ef4e55966144b2a5ab39dc13814b94e3ab6e101a34f27"),
+            ByteUtils.HexToByteArray("3e8a69b7783c25851933ab6290af6ca77a9981480850009cc5577c6e1f573b4e6801dd23c4a7d679ccf8a386c674cffb"),
+            // RFC 4231 only defines the first 128 bits of this value.
+            ByteUtils.HexToByteArray("3abf34c3503b2a23a46efc619baef897"),
+            ByteUtils.HexToByteArray("4ece084485813e9088d2c63a041bc5b44f9ef1012a2b588f3cd11f05033ac4c60c2ef6ab4030fe8296248df163f44952"),
+            ByteUtils.HexToByteArray("6617178e941f020d351e2f254e8fd32c602420feb0b8fb9adccebb82461e99c5a678cc31e799176d3860e6110c46523e"),
+        };
 
-        protected override HashAlgorithm CreateHashAlgorithm()
+        public HmacSha384Tests() : base(s_testMacs4231)
         {
-            return SHA384.Create();
         }
 
-        protected override int BlockSize { get { return 128; } }
-
         [Fact]
         public void ProduceLegacyHmacValues()
         {
@@ -34,44 +57,43 @@ public void ProduceLegacyHmacValues()
         [Fact]
         public void HmacSha384_Rfc4231_1()
         {
-            VerifyHmac(1, "afd03944d84895626b0825f4ab46907f15f9dadbe4101ec682aa034c7cebc59cfaea9ea9076ede7f4af152e8b2fa9cb6");
+            VerifyHmac(1, s_testMacs4231[1]);
         }
 
         [Fact]
         public void HmacSha384_Rfc4231_2()
         {
-            VerifyHmac(2, "af45d2e376484031617f78d2b58a6b1b9c7ef464f5a01b47e42ec3736322445e8e2240ca5e69e2c78b3239ecfab21649");
+            VerifyHmac(2, s_testMacs4231[2]);
         }
 
         [Fact]
         public void HmacSha384_Rfc4231_3()
         {
-            VerifyHmac(3, "88062608d3e6ad8a0aa2ace014c8a86f0aa635d947ac9febe83ef4e55966144b2a5ab39dc13814b94e3ab6e101a34f27");
+            VerifyHmac(3, s_testMacs4231[3]);
         }
 
         [Fact]
         public void HmacSha384_Rfc4231_4()
         {
-            VerifyHmac(4, "3e8a69b7783c25851933ab6290af6ca77a9981480850009cc5577c6e1f573b4e6801dd23c4a7d679ccf8a386c674cffb");
+            VerifyHmac(4, s_testMacs4231[4]);
         }
 
         [Fact]
         public void HmacSha384_Rfc4231_5()
         {
-            // RFC 4231 only defines the first 128 bits of this value.
-            VerifyHmac(5, "3abf34c3503b2a23a46efc619baef897", 128 / 8);
+            VerifyHmac(5, s_testMacs4231[5]);
         }
 
         [Fact]
         public void HmacSha384_Rfc4231_6()
         {
-            VerifyHmac(6, "4ece084485813e9088d2c63a041bc5b44f9ef1012a2b588f3cd11f05033ac4c60c2ef6ab4030fe8296248df163f44952");
+            VerifyHmac(6, s_testMacs4231[6]);
         }
 
         [Fact]
         public void HmacSha384_Rfc4231_7()
         {
-            VerifyHmac(7, "6617178e941f020d351e2f254e8fd32c602420feb0b8fb9adccebb82461e99c5a678cc31e799176d3860e6110c46523e");
+            VerifyHmac(7, s_testMacs4231[7]);
         }
 
         [Fact]
diff --git a/src/libraries/System.Security.Cryptography.Algorithms/tests/HmacSha512Tests.cs b/src/libraries/System.Security.Cryptography.Algorithms/tests/HmacSha512Tests.cs
index 3136ffd5af0084..4da18847fd993e 100644
--- a/src/libraries/System.Security.Cryptography.Algorithms/tests/HmacSha512Tests.cs
+++ b/src/libraries/System.Security.Cryptography.Algorithms/tests/HmacSha512Tests.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 Test.Cryptography;
 using Xunit;
 
 namespace System.Security.Cryptography.Hashing.Algorithms.Tests
@@ -8,18 +9,40 @@ namespace System.Security.Cryptography.Hashing.Algorithms.Tests
     [SkipOnPlatform(TestPlatforms.Browser, "Not supported on Browser")]
     public class HmacSha512Tests : Rfc4231HmacTests
     {
-        protected override HMAC Create()
+        protected override int BlockSize => 128;
+        protected override int MacSize => 64;
+
+        protected override HMAC Create() => new HMACSHA512();
+        protected override HashAlgorithm CreateHashAlgorithm() => SHA512.Create();
+        protected override byte[] HashDataOneShot(byte[] key, byte[] source) =>
+            HMACSHA512.HashData(key, source);
+
+        protected override byte[] HashDataOneShot(ReadOnlySpan<byte> key, ReadOnlySpan<byte> source) =>
+            HMACSHA512.HashData(key, source);
+
+        protected override int HashDataOneShot(ReadOnlySpan<byte> key, ReadOnlySpan<byte> source, Span<byte> destination) =>
+            HMACSHA512.HashData(key, source, destination);
+
+        protected override bool TryHashDataOneShot(ReadOnlySpan<byte> key, ReadOnlySpan<byte> source, Span<byte> destination, out int written) =>
+            HMACSHA512.TryHashData(key, source, destination, out written);
+
+        private static byte[][] s_testMacs4231 =
         {
-            return new HMACSHA512();
-        }
+            null,
+            ByteUtils.HexToByteArray("87aa7cdea5ef619d4ff0b4241a1d6cb02379f4e2ce4ec2787ad0b30545e17cdedaa833b7d6b8a702038b274eaea3f4e4be9d914eeb61f1702e696c203a126854"),
+            ByteUtils.HexToByteArray("164b7a7bfcf819e2e395fbe73b56e0a387bd64222e831fd610270cd7ea2505549758bf75c05a994a6d034f65f8f0e6fdcaeab1a34d4a6b4b636e070a38bce737"),
+            ByteUtils.HexToByteArray("fa73b0089d56a284efb0f0756c890be9b1b5dbdd8ee81a3655f83e33b2279d39bf3e848279a722c806b485a47e67c807b946a337bee8942674278859e13292fb"),
+            ByteUtils.HexToByteArray("b0ba465637458c6990e5a8c5f61d4af7e576d97ff94b872de76f8050361ee3dba91ca5c11aa25eb4d679275cc5788063a5f19741120c4f2de2adebeb10a298dd"),
+            // RFC 4231 only defines the first 128 bits of this value.
+            ByteUtils.HexToByteArray("415fad6271580a531d4179bc891d87a6"),
+            ByteUtils.HexToByteArray("80b24263c7c1a3ebb71493c1dd7be8b49b46d1f41b4aeec1121b013783f8f3526b56d037e05f2598bd0fd2215d6a1e5295e64f73f63f0aec8b915a985d786598"),
+            ByteUtils.HexToByteArray("e37b6a775dc87dbaa4dfa9f96e5e3ffddebd71f8867289865df5a32d20cdc944b6022cac3c4982b10d5eeb55c3e4de15134676fb6de0446065c97440fa8c6a58"),
+        };
 
-        protected override HashAlgorithm CreateHashAlgorithm()
+        public HmacSha512Tests() : base(s_testMacs4231)
         {
-            return SHA512.Create();
         }
 
-        protected override int BlockSize { get { return 128; } }
-
         [Fact]
         public void ProduceLegacyHmacValues()
         {
@@ -34,44 +57,43 @@ public void ProduceLegacyHmacValues()
         [Fact]
         public void HmacSha512_Rfc4231_1()
         {
-            VerifyHmac(1, "87aa7cdea5ef619d4ff0b4241a1d6cb02379f4e2ce4ec2787ad0b30545e17cdedaa833b7d6b8a702038b274eaea3f4e4be9d914eeb61f1702e696c203a126854");
+            VerifyHmac(1, s_testMacs4231[1]);
         }
 
         [Fact]
         public void HmacSha512_Rfc4231_2()
         {
-            VerifyHmac(2, "164b7a7bfcf819e2e395fbe73b56e0a387bd64222e831fd610270cd7ea2505549758bf75c05a994a6d034f65f8f0e6fdcaeab1a34d4a6b4b636e070a38bce737");
+            VerifyHmac(2, s_testMacs4231[2]);
         }
 
         [Fact]
         public void HmacSha512_Rfc4231_3()
         {
-            VerifyHmac(3, "fa73b0089d56a284efb0f0756c890be9b1b5dbdd8ee81a3655f83e33b2279d39bf3e848279a722c806b485a47e67c807b946a337bee8942674278859e13292fb");
+            VerifyHmac(3, s_testMacs4231[3]);
         }
 
         [Fact]
         public void HmacSha512_Rfc4231_4()
         {
-            VerifyHmac(4, "b0ba465637458c6990e5a8c5f61d4af7e576d97ff94b872de76f8050361ee3dba91ca5c11aa25eb4d679275cc5788063a5f19741120c4f2de2adebeb10a298dd");
+            VerifyHmac(4, s_testMacs4231[4]);
         }
 
         [Fact]
         public void HmacSha512_Rfc4231_5()
         {
-            // RFC 4231 only defines the first 128 bits of this value.
-            VerifyHmac(5, "415fad6271580a531d4179bc891d87a6", 128 / 8);
+            VerifyHmac(5, s_testMacs4231[5]);
         }
 
         [Fact]
         public void HmacSha512_Rfc4231_6()
         {
-            VerifyHmac(6, "80b24263c7c1a3ebb71493c1dd7be8b49b46d1f41b4aeec1121b013783f8f3526b56d037e05f2598bd0fd2215d6a1e5295e64f73f63f0aec8b915a985d786598");
+            VerifyHmac(6, s_testMacs4231[6]);
         }
 
         [Fact]
         public void HmacSha512_Rfc4231_7()
         {
-            VerifyHmac(7, "e37b6a775dc87dbaa4dfa9f96e5e3ffddebd71f8867289865df5a32d20cdc944b6022cac3c4982b10d5eeb55c3e4de15134676fb6de0446065c97440fa8c6a58");
+            VerifyHmac(7, s_testMacs4231[7]);
         }
 
         [Fact]
diff --git a/src/libraries/System.Security.Cryptography.Algorithms/tests/HmacTests.cs b/src/libraries/System.Security.Cryptography.Algorithms/tests/HmacTests.cs
index 13a24682867722..510f58d88ee7d8 100644
--- a/src/libraries/System.Security.Cryptography.Algorithms/tests/HmacTests.cs
+++ b/src/libraries/System.Security.Cryptography.Algorithms/tests/HmacTests.cs
@@ -15,31 +15,36 @@ public abstract class HmacTests
         // They share the same datasets for cases 1-5, but cases 6 and 7 differ.
         private readonly byte[][] _testKeys;
         private readonly byte[][] _testData;
+        private readonly byte[][] _testMacs;
 
-        protected HmacTests(byte[][] testKeys, byte[][] testData)
+        protected HmacTests(byte[][] testKeys, byte[][] testData, byte[][] testMacs)
         {
             _testKeys = testKeys;
             _testData = testData;
+            _testMacs = testMacs;
         }
 
         protected abstract HMAC Create();
 
         protected abstract HashAlgorithm CreateHashAlgorithm();
+        protected abstract byte[] HashDataOneShot(byte[] key, byte[] source);
+        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 int BlockSize { get; }
+        protected abstract int MacSize { get; }
 
-        protected void VerifyHmac(
-            int testCaseId,
-            string digest,
-            int truncateSize = -1)
+        protected void VerifyHmac(int testCaseId, byte[] digestBytes)
         {
-            byte[] digestBytes = ByteUtils.HexToByteArray(digest);
             byte[] data = _testData[testCaseId];
             byte[] computedDigest;
+            int truncateSize = digestBytes.Length;
+            AssertExtensions.LessThanOrEqualTo(truncateSize, MacSize);
 
             using (HMAC hmac = Create())
             {
-                Assert.True(hmac.HashSize > 0);
+                Assert.Equal(MacSize, hmac.HashSize / 8);
 
                 byte[] key = (byte[])_testKeys[testCaseId].Clone();
                 hmac.Key = key;
@@ -55,13 +60,7 @@ protected void VerifyHmac(
                 computedDigest = hmac.ComputeHash(data);
             }
 
-            if (truncateSize != -1)
-            {
-                byte[] tmp = new byte[truncateSize];
-                Array.Copy(computedDigest, tmp, truncateSize);
-                computedDigest = tmp;
-            }
-
+            computedDigest = Truncate(computedDigest, truncateSize);
             Assert.Equal(digestBytes, computedDigest);
 
             using (HMAC hmac = Create())
@@ -76,14 +75,22 @@ protected void VerifyHmac(
                 computedDigest = hmac.Hash;
             }
 
-            if (truncateSize != -1)
-            {
-                byte[] tmp = new byte[truncateSize];
-                Array.Copy(computedDigest, tmp, truncateSize);
-                computedDigest = tmp;
-            }
+            computedDigest = Truncate(computedDigest, truncateSize);
+            Assert.Equal(digestBytes, computedDigest);
+
+            // One shot - allocating and byte array inputs
+            computedDigest = HashDataOneShot(_testKeys[testCaseId], data);
 
+            computedDigest = Truncate(computedDigest, truncateSize);
             Assert.Equal(digestBytes, computedDigest);
+
+            static byte[] Truncate(byte[] digest, int truncateSize)
+            {
+                if (truncateSize == -1)
+                    return digest;
+
+                return digest.AsSpan(0, truncateSize).ToArray();
+            }
         }
 
         protected void VerifyHmac_KeyAlreadySet(
@@ -232,5 +239,152 @@ public void InvalidKey_ThrowArgumentNullException()
                 AssertExtensions.Throws<ArgumentNullException>("value", () => hash.Key = null);
             }
         }
+
+        [Fact]
+        public void OneShot_NullKey_ArgumentNullException()
+        {
+            AssertExtensions.Throws<ArgumentNullException>("key", () =>
+                HashDataOneShot(key: (byte[])null, source: Array.Empty<byte>()));
+        }
+
+        [Fact]
+        public void OneShot_NullSource_ArgumentNullException()
+        {
+            AssertExtensions.Throws<ArgumentNullException>("source", () =>
+                HashDataOneShot(key: Array.Empty<byte>(), source: (byte[])null));
+        }
+
+        [Fact]
+        public void OneShot_ExistingBuffer_TooSmall()
+        {
+            byte[] buffer = new byte[MacSize - 1];
+            byte[] key = _testKeys[1];
+            byte[] data = _testData[1];
+
+            AssertExtensions.Throws<ArgumentException>("destination", () =>
+                HashDataOneShot(key, data, buffer));
+
+            AssertExtensions.FilledWith<byte>(0, buffer);
+        }
+
+        [Fact]
+        public void OneShot_TryExistingBuffer_TooSmall()
+        {
+            byte[] buffer = new byte[MacSize - 1];
+            byte[] key = _testKeys[1];
+            byte[] data = _testData[1];
+
+            Assert.False(TryHashDataOneShot(key, data, buffer, out int written));
+            Assert.Equal(0, written);
+            AssertExtensions.FilledWith<byte>(0, buffer);
+        }
+
+        [Fact]
+        public void OneShot_TryExistingBuffer_Exact()
+        {
+            for (int caseId = 1; caseId <= 7; caseId++)
+            {
+                byte[] buffer = new byte[MacSize];
+                byte[] key = _testKeys[caseId];
+                byte[] data = _testData[caseId];
+
+                Assert.True(TryHashDataOneShot(key, data, buffer, out int written));
+                Assert.Equal(MacSize, written);
+
+                ReadOnlySpan<byte> expectedMac = _testMacs[caseId];
+                Span<byte> truncatedBuffer = buffer.AsSpan(0, expectedMac.Length);
+                AssertExtensions.SequenceEqual(expectedMac, truncatedBuffer);
+            }
+        }
+
+        [Fact]
+        public void OneShot_TryExistingBuffer_Larger()
+        {
+            for (int caseId = 1; caseId <= 7; caseId++)
+            {
+                Span<byte> buffer = new byte[MacSize + 20];
+                byte[] key = _testKeys[caseId];
+                byte[] data = _testData[caseId];
+
+                buffer.Fill(0xCC);
+                Span<byte> writeBuffer = buffer.Slice(10, MacSize);
+
+                Assert.True(TryHashDataOneShot(key, data, writeBuffer, out int written));
+                Assert.Equal(MacSize, written);
+
+                ReadOnlySpan<byte> expectedMac = _testMacs[caseId];
+                Span<byte> truncatedWriteBuffer = writeBuffer.Slice(0, expectedMac.Length);
+                AssertExtensions.SequenceEqual(expectedMac, truncatedWriteBuffer);
+                AssertExtensions.FilledWith<byte>(0xCC, buffer[..10]);
+                AssertExtensions.FilledWith<byte>(0xCC, buffer[^10..]);
+            }
+        }
+
+        [Theory]
+        [InlineData(0, 10)]
+        [InlineData(10, 10)]
+        [InlineData(10, 0)]
+        [InlineData(10, 20)]
+        public void OneShot_TryExistingBuffer_OverlapsKey(int keyOffset, int bufferOffset)
+        {
+            for (int caseId = 1; caseId <= 7; caseId++)
+            {
+                byte[] key = _testKeys[caseId];
+                byte[] data = _testData[caseId];
+                Span<byte> buffer = new byte[Math.Max(key.Length, MacSize) + Math.Max(keyOffset, bufferOffset)];
+
+                Span<byte> writeBuffer = buffer.Slice(bufferOffset, MacSize);
+                Span<byte> keyBuffer = buffer.Slice(keyOffset, key.Length);
+                key.AsSpan().CopyTo(keyBuffer);
+
+                Assert.True(TryHashDataOneShot(keyBuffer, data, writeBuffer, out int written));
+                Assert.Equal(MacSize, written);
+
+                ReadOnlySpan<byte> expectedMac = _testMacs[caseId];
+                Span<byte> truncatedWriteBuffer = writeBuffer.Slice(0, expectedMac.Length);
+                AssertExtensions.SequenceEqual(expectedMac, truncatedWriteBuffer);
+            }
+        }
+
+        [Theory]
+        [InlineData(0, 10)]
+        [InlineData(10, 10)]
+        [InlineData(10, 0)]
+        [InlineData(10, 20)]
+        public void OneShot_TryExistingBuffer_OverlapsSource(int sourceOffset, int bufferOffset)
+        {
+            for (int caseId = 1; caseId <= 7; caseId++)
+            {
+                byte[] key = _testKeys[caseId];
+                byte[] data = _testData[caseId];
+                Span<byte> buffer = new byte[Math.Max(data.Length, MacSize) + Math.Max(sourceOffset, bufferOffset)];
+
+                Span<byte> writeBuffer = buffer.Slice(bufferOffset, MacSize);
+                Span<byte> dataBuffer = buffer.Slice(sourceOffset, data.Length);
+                data.AsSpan().CopyTo(dataBuffer);
+
+                Assert.True(TryHashDataOneShot(key, dataBuffer, writeBuffer, out int written));
+                Assert.Equal(MacSize, written);
+
+                ReadOnlySpan<byte> expectedMac = _testMacs[caseId];
+                Span<byte> truncatedWriteBuffer = writeBuffer.Slice(0, expectedMac.Length);
+                AssertExtensions.SequenceEqual(expectedMac, truncatedWriteBuffer);
+            }
+        }
+
+        [Theory]
+        [InlineData(new byte[0], new byte[] { 1 })]
+        [InlineData(new byte[] { 1 }, new byte[0])]
+        public void OneShot_Empty_Matches_Instances(byte[] key, byte[] source)
+        {
+            using (HMAC hash = Create())
+            {
+                hash.Key = key;
+                byte[] mac = hash.ComputeHash(source, 0, source.Length);
+
+                byte[] oneShot = HashDataOneShot(key, source);
+                Assert.Equal(mac, oneShot);
+            }
+        }
     }
 }
diff --git a/src/libraries/System.Security.Cryptography.Algorithms/tests/Rfc2202HmacTests.cs b/src/libraries/System.Security.Cryptography.Algorithms/tests/Rfc2202HmacTests.cs
index e66cd896d8bb42..84864861c92d9f 100644
--- a/src/libraries/System.Security.Cryptography.Algorithms/tests/Rfc2202HmacTests.cs
+++ b/src/libraries/System.Security.Cryptography.Algorithms/tests/Rfc2202HmacTests.cs
@@ -24,8 +24,8 @@ public abstract class Rfc2202HmacTests : HmacTests
         // The keys for test cases 1, 3, and 5 for RFC2202 are sized to match the
         // algorithm (16 bytes for MD5, 20 for SHA-1), so they need to be provided by
         // the more derived type.
-        protected Rfc2202HmacTests(byte[][] testKeys) :
-            base(testKeys, s_testData2202)
+        protected Rfc2202HmacTests(byte[][] testKeys, byte[][] testMacs) :
+            base(testKeys, s_testData2202, testMacs)
         {
         }
     }
diff --git a/src/libraries/System.Security.Cryptography.Algorithms/tests/Rfc4231HmacTests.cs b/src/libraries/System.Security.Cryptography.Algorithms/tests/Rfc4231HmacTests.cs
index af8e3e61684477..771973a029328f 100644
--- a/src/libraries/System.Security.Cryptography.Algorithms/tests/Rfc4231HmacTests.cs
+++ b/src/libraries/System.Security.Cryptography.Algorithms/tests/Rfc4231HmacTests.cs
@@ -33,8 +33,8 @@ public abstract class Rfc4231HmacTests : HmacTests
             ByteUtils.AsciiBytes("This is a test using a larger than block-size key and a larger than block-size data. The key needs to be hashed before being used by the HMAC algorithm."),
         };
 
-        protected Rfc4231HmacTests() :
-            base(s_testKeys4231, s_testData4231)
+        protected Rfc4231HmacTests(byte[][] testMacs) :
+            base(s_testKeys4231, s_testData4231, testMacs)
         {
         }
     }
diff --git a/src/libraries/System.Security.Cryptography.Cng/Directory.Build.props b/src/libraries/System.Security.Cryptography.Cng/Directory.Build.props
index 7bdd796606be8c..709a22a7537088 100644
--- a/src/libraries/System.Security.Cryptography.Cng/Directory.Build.props
+++ b/src/libraries/System.Security.Cryptography.Cng/Directory.Build.props
@@ -2,7 +2,6 @@
   <Import Project="..\Directory.Build.props" />
   <PropertyGroup>
     <StrongNameKeyId>Microsoft</StrongNameKeyId>
-    <IsAspNetCoreApp>true</IsAspNetCoreApp>
     <SupportedOSPlatforms>windows</SupportedOSPlatforms>
   </PropertyGroup>
 </Project>
\ No newline at end of file
diff --git a/src/libraries/System.Security.Cryptography.Encoding/tests/Base64TransformsTests.cs b/src/libraries/System.Security.Cryptography.Encoding/tests/Base64TransformsTests.cs
index d2e813670f29d9..aab283c32c543e 100644
--- a/src/libraries/System.Security.Cryptography.Encoding/tests/Base64TransformsTests.cs
+++ b/src/libraries/System.Security.Cryptography.Encoding/tests/Base64TransformsTests.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.IO;
 using Xunit;
 
@@ -123,7 +124,7 @@ private static void ValidateCryptoStream(string expected, string data, ICryptoTr
             using (var ms = new MemoryStream(inputBytes))
             using (var cs = new CryptoStream(ms, transform, CryptoStreamMode.Read))
             {
-                int bytesRead = cs.Read(outputBytes, 0, outputBytes.Length);
+                int bytesRead = ReadAll(cs, outputBytes);
                 string outputString = Text.Encoding.ASCII.GetString(outputBytes, 0, bytesRead);
                 Assert.Equal(expected, outputString);
             }
@@ -195,7 +196,7 @@ public static void ValidateFromBase64_NoPadding(string data)
                 using (var ms = new MemoryStream(inputBytes))
                 using (var cs = new CryptoStream(ms, transform, CryptoStreamMode.Read))
                 {
-                    int bytesRead = cs.Read(outputBytes, 0, outputBytes.Length);
+                    int bytesRead = ReadAll(cs, outputBytes);
 
                     // Missing padding bytes not supported (no exception, however)
                     Assert.NotEqual(inputBytes.Length, bytesRead);
@@ -230,7 +231,7 @@ public static void ValidateWhitespace(string expected, string data)
             using (var ms = new MemoryStream(inputBytes))
             using (var cs = new CryptoStream(ms, base64Transform, CryptoStreamMode.Read))
             {
-                int bytesRead = cs.Read(outputBytes, 0, outputBytes.Length);
+                int bytesRead = ReadAll(cs, outputBytes);
                 string outputString = Text.Encoding.ASCII.GetString(outputBytes, 0, bytesRead);
                 Assert.Equal(expected, outputString);
             }
@@ -240,7 +241,7 @@ public static void ValidateWhitespace(string expected, string data)
             using (var ms = new MemoryStream(inputBytes))
             using (var cs = new CryptoStream(ms, base64Transform, CryptoStreamMode.Read))
             {
-                int bytesRead = cs.Read(outputBytes, 0, outputBytes.Length);
+                int bytesRead = ReadAll(cs, outputBytes);
                 string outputString = Text.Encoding.ASCII.GetString(outputBytes, 0, bytesRead);
                 Assert.Equal(expected, outputString);
             }
@@ -293,5 +294,22 @@ public void TransformUsageFlags_FromBase64Transform()
                 Assert.True(transform.CanReuseTransform);
             }
         }
+
+        private static int ReadAll(Stream stream, Span<byte> buffer)
+        {
+            int totalRead = 0;
+            while (totalRead < buffer.Length)
+            {
+                int bytesRead = stream.Read(buffer.Slice(totalRead));
+                if (bytesRead == 0)
+                {
+                    break;
+                }
+
+                totalRead += bytesRead;
+            }
+
+            return totalRead;
+        }
     }
 }
diff --git a/src/libraries/System.Security.Cryptography.Pkcs/ref/System.Security.Cryptography.Pkcs.csproj b/src/libraries/System.Security.Cryptography.Pkcs/ref/System.Security.Cryptography.Pkcs.csproj
index 07d10f8f66edb6..c3816073efa468 100644
--- a/src/libraries/System.Security.Cryptography.Pkcs/ref/System.Security.Cryptography.Pkcs.csproj
+++ b/src/libraries/System.Security.Cryptography.Pkcs/ref/System.Security.Cryptography.Pkcs.csproj
@@ -1,7 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <TargetFrameworks>$(NetCoreAppCurrent);netcoreapp3.1;netstandard2.1;netstandard2.0;net461</TargetFrameworks>
-    <ExcludeCurrentNetCoreAppFromPackage>true</ExcludeCurrentNetCoreAppFromPackage>
     <Nullable>enable</Nullable>
   </PropertyGroup>
   <ItemGroup>
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 832bd3447c1d38..88bce55ee444b9 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
@@ -5,12 +5,11 @@
     <NoWarn>$(NoWarn);CA5384</NoWarn>
     <Nullable>enable</Nullable>
     <TargetFrameworks>$(NetCoreAppCurrent)-windows;$(NetCoreAppCurrent);netcoreapp3.1-windows;netcoreapp3.1;netstandard2.1-windows;netstandard2.1;netstandard2.0-windows;netstandard2.0;net461-windows</TargetFrameworks>
-    <ExcludeCurrentNetCoreAppFromPackage>true</ExcludeCurrentNetCoreAppFromPackage>
   </PropertyGroup>
   <!-- DesignTimeBuild requires all the TargetFramework Derived Properties to not be present in the first property group. -->
   <PropertyGroup>
-    <IsPartialFacadeAssembly Condition="$(TargetFramework.StartsWith('net4'))">true</IsPartialFacadeAssembly>
-    <OmitResources Condition="$(TargetFramework.StartsWith('net4'))">true</OmitResources>
+    <IsPartialFacadeAssembly Condition="$([MSBuild]::GetTargetFrameworkIdentifier('$(TargetFramework)')) == '.NETFramework'">true</IsPartialFacadeAssembly>
+    <OmitResources Condition="'$(IsPartialFacadeAssembly)' == 'true'">true</OmitResources>
     <UsePackageTargetRuntimeDefaults Condition="'$(IsPartialFacadeAssembly)' != 'true'">true</UsePackageTargetRuntimeDefaults>
   </PropertyGroup>
   <Import Project="$(CommonPath)System\Security\Cryptography\Asn1\AsnXml.targets" Condition="'$(IsPartialFacadeAssembly)' != 'true'" />
@@ -639,13 +638,14 @@
     <PackageReference Include="System.Memory" Version="$(SystemMemoryVersion)" />
     <ProjectReference Include="$(LibrariesProjectRoot)System.Runtime.CompilerServices.Unsafe\src\System.Runtime.CompilerServices.Unsafe.ilproj" />
   </ItemGroup>
-  <ItemGroup Condition="!$(TargetFramework.StartsWith('$(NetCoreAppCurrent)'))">
+  <ItemGroup Condition="!$(TargetFramework.StartsWith('$(NetCoreAppCurrent)')) and '$(IsPartialFacadeAssembly)' != 'true'">
     <PackageReference Include="System.Security.Cryptography.Cng" Version="$(SystemSecurityCryptographyCngVersion)" />
   </ItemGroup>
   <ItemGroup Condition="$(TargetFramework.StartsWith('$(NetCoreAppCurrent)'))">
     <ProjectReference Include="$(LibrariesProjectRoot)System.Security.Cryptography.Cng\src\System.Security.Cryptography.Cng.csproj" />
   </ItemGroup>
   <ItemGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp'">
+    <Reference Include="netstandard" Condition="$(TargetFramework.StartsWith('netcoreapp3.1'))" />
     <Reference Include="System.Buffers" />
     <Reference Include="System.Collections" />
     <Reference Include="System.Collections.Concurrent" />
diff --git a/src/libraries/System.Security.Cryptography.Pkcs/tests/Pkcs12/Pkcs12SafeContentsTests.cs b/src/libraries/System.Security.Cryptography.Pkcs/tests/Pkcs12/Pkcs12SafeContentsTests.cs
index 9acecd8c695caf..1e1bf33769ff18 100644
--- a/src/libraries/System.Security.Cryptography.Pkcs/tests/Pkcs12/Pkcs12SafeContentsTests.cs
+++ b/src/libraries/System.Security.Cryptography.Pkcs/tests/Pkcs12/Pkcs12SafeContentsTests.cs
@@ -74,7 +74,7 @@ public static void AddCertificateDisallowsNull(bool forReadOnly)
         public static void AddCertificateDisallowedInReadOnly()
         {
             Pkcs12SafeContents contents = MakeReadonly(new Pkcs12SafeContents());
-            X509Certificate2 cert = new X509Certificate2();
+            X509Certificate2 cert = new X509Certificate2(stackalloc byte[0]);
 
             Assert.Throws<InvalidOperationException>(() => contents.AddCertificate(cert));
         }
diff --git a/src/libraries/System.Security.Cryptography.Primitives/src/System/Security/Cryptography/CryptoStream.cs b/src/libraries/System.Security.Cryptography.Primitives/src/System/Security/Cryptography/CryptoStream.cs
index c023c9068f51ae..afe137dda9b969 100644
--- a/src/libraries/System.Security.Cryptography.Primitives/src/System/Security/Cryptography/CryptoStream.cs
+++ b/src/libraries/System.Security.Cryptography.Primitives/src/System/Security/Cryptography/CryptoStream.cs
@@ -16,10 +16,10 @@ public class CryptoStream : Stream, IDisposable
         // Member variables
         private readonly Stream _stream;
         private readonly ICryptoTransform _transform;
-        private byte[]? _inputBuffer;  // read from _stream before _Transform
+        private byte[] _inputBuffer;  // read from _stream before _Transform
         private int _inputBufferIndex;
         private int _inputBlockSize;
-        private byte[]? _outputBuffer; // buffered output of _Transform
+        private byte[] _outputBuffer; // buffered output of _Transform
         private int _outputBufferIndex;
         private int _outputBlockSize;
         private bool _canRead;
@@ -37,24 +37,41 @@ public CryptoStream(Stream stream, ICryptoTransform transform, CryptoStreamMode
 
         public CryptoStream(Stream stream, ICryptoTransform transform, CryptoStreamMode mode, bool leaveOpen)
         {
+            if (transform is null)
+            {
+                throw new ArgumentNullException(nameof(transform));
+            }
 
             _stream = stream;
             _transform = transform;
             _leaveOpen = leaveOpen;
+
             switch (mode)
             {
                 case CryptoStreamMode.Read:
-                    if (!(_stream.CanRead)) throw new ArgumentException(SR.Format(SR.Argument_StreamNotReadable, nameof(stream)));
+                    if (!_stream.CanRead)
+                    {
+                        throw new ArgumentException(SR.Format(SR.Argument_StreamNotReadable, nameof(stream)));
+                    }
                     _canRead = true;
                     break;
+
                 case CryptoStreamMode.Write:
-                    if (!(_stream.CanWrite)) throw new ArgumentException(SR.Format(SR.Argument_StreamNotWritable, nameof(stream)));
+                    if (!_stream.CanWrite)
+                    {
+                        throw new ArgumentException(SR.Format(SR.Argument_StreamNotWritable, nameof(stream)));
+                    }
                     _canWrite = true;
                     break;
+
                 default:
-                    throw new ArgumentException(SR.Argument_InvalidValue);
+                    throw new ArgumentException(SR.Argument_InvalidValue, nameof(mode));
             }
-            InitializeBuffer();
+
+            _inputBlockSize = _transform.InputBlockSize;
+            _inputBuffer = new byte[_inputBlockSize];
+            _outputBlockSize = _transform.OutputBlockSize;
+            _outputBuffer = new byte[_outputBlockSize];
         }
 
         public override bool CanRead
@@ -293,198 +310,149 @@ private void CheckReadArguments(byte[] buffer, int offset, int count)
 
         private async ValueTask<int> ReadAsyncCore(Memory<byte> buffer, CancellationToken cancellationToken, bool useAsync)
         {
-            // read <= count bytes from the input stream, transforming as we go.
-            // Basic idea: first we deliver any bytes we already have in the
-            // _OutputBuffer, because we know they're good.  Then, if asked to deliver
-            // more bytes, we read & transform a block at a time until either there are
-            // no bytes ready or we've delivered enough.
-            int bytesToDeliver = buffer.Length;
-            int currentOutputIndex = 0;
-            Debug.Assert(_outputBuffer != null);
-            if (_outputBufferIndex != 0)
+            while (true)
             {
-                // we have some already-transformed bytes in the output buffer
-                if (_outputBufferIndex <= buffer.Length)
+                // If there are currently any bytes stored in the output buffer, hand back as many as we can.
+                if (_outputBufferIndex != 0)
                 {
-                    _outputBuffer.AsSpan(0, _outputBufferIndex).CopyTo(buffer.Span);
-                    bytesToDeliver -= _outputBufferIndex;
-                    currentOutputIndex += _outputBufferIndex;
-                    int toClear = _outputBuffer.Length - _outputBufferIndex;
-                    CryptographicOperations.ZeroMemory(new Span<byte>(_outputBuffer, _outputBufferIndex, toClear));
-                    _outputBufferIndex = 0;
+                    int bytesToCopy = Math.Min(_outputBufferIndex, buffer.Length);
+                    if (bytesToCopy != 0)
+                    {
+                        // Copy as many bytes as we can, then shift down the remaining bytes.
+                        new ReadOnlySpan<byte>(_outputBuffer, 0, bytesToCopy).CopyTo(buffer.Span);
+                        _outputBufferIndex -= bytesToCopy;
+                        _outputBuffer.AsSpan(bytesToCopy).CopyTo(_outputBuffer);
+                        CryptographicOperations.ZeroMemory(_outputBuffer.AsSpan(_outputBufferIndex, bytesToCopy));
+                    }
+                    return bytesToCopy;
                 }
-                else
-                {
-                    _outputBuffer.AsSpan(0, buffer.Length).CopyTo(buffer.Span);
-                    Buffer.BlockCopy(_outputBuffer, buffer.Length, _outputBuffer, 0, _outputBufferIndex - buffer.Length);
-                    _outputBufferIndex -= buffer.Length;
 
-                    int toClear = _outputBuffer.Length - _outputBufferIndex;
-                    CryptographicOperations.ZeroMemory(new Span<byte>(_outputBuffer, _outputBufferIndex, toClear));
-
-                    return buffer.Length;
+                // If we've already hit the end of the stream, there's nothing more to do.
+                Debug.Assert(_outputBufferIndex == 0);
+                if (_finalBlockTransformed)
+                {
+                    Debug.Assert(_inputBufferIndex == 0);
+                    return 0;
                 }
-            }
-            // _finalBlockTransformed == true implies we're at the end of the input stream
-            // if we got through the previous if block then _OutputBufferIndex = 0, meaning
-            // we have no more transformed bytes to give
-            // so return count-bytesToDeliver, the amount we were able to hand back
-            // eventually, we'll just always return 0 here because there's no more to read
-            if (_finalBlockTransformed)
-            {
-                return buffer.Length - bytesToDeliver;
-            }
-            // ok, now loop until we've delivered enough or there's nothing available
-            int amountRead = 0;
-            int numOutputBytes;
 
-            // OK, see first if it's a multi-block transform and we can speed up things
-            int blocksToProcess = bytesToDeliver / _outputBlockSize;
+                int bytesRead = 0;
+                bool eof = false;
 
-            Debug.Assert(_inputBuffer != null);
-            if (blocksToProcess > 1 && _transform.CanTransformMultipleBlocks)
-            {
-                int numWholeBlocksInBytes = blocksToProcess * _inputBlockSize;
-
-                // Use ArrayPool.Shared instead of CryptoPool because the array is passed out.
-                byte[]? tempInputBuffer = ArrayPool<byte>.Shared.Rent(numWholeBlocksInBytes);
-                byte[]? tempOutputBuffer = null;
-
-                try
+                // If the transform supports transforming multiple blocks, try to read as large a chunk as would yield
+                // data to fill the output buffer and do the appropriate transform directly into the output buffer.
+                int blocksToProcess = buffer.Length / _outputBlockSize;
+                if (blocksToProcess > 1 && _transform.CanTransformMultipleBlocks)
                 {
-                    amountRead = useAsync ?
-                        await _stream.ReadAsync(new Memory<byte>(tempInputBuffer, _inputBufferIndex, numWholeBlocksInBytes - _inputBufferIndex), cancellationToken).ConfigureAwait(false) :
-                        _stream.Read(tempInputBuffer, _inputBufferIndex, numWholeBlocksInBytes - _inputBufferIndex);
-
-                    int totalInput = _inputBufferIndex + amountRead;
-
-                    // If there's still less than a block, copy the new data into the hold buffer and move to the slow read.
-                    if (totalInput < _inputBlockSize)
-                    {
-                        Buffer.BlockCopy(tempInputBuffer, _inputBufferIndex, _inputBuffer, _inputBufferIndex, amountRead);
-                        _inputBufferIndex = totalInput;
-                    }
-                    else
+                    // Use ArrayPool.Shared instead of CryptoPool because the array is passed out.
+                    int numWholeBlocksInBytes = blocksToProcess * _inputBlockSize;
+                    byte[] tempInputBuffer = ArrayPool<byte>.Shared.Rent(numWholeBlocksInBytes);
+                    try
                     {
-                        // Copy any held data into tempInputBuffer now that we know we're proceeding
-                        Buffer.BlockCopy(_inputBuffer, 0, tempInputBuffer, 0, _inputBufferIndex);
-                        CryptographicOperations.ZeroMemory(new Span<byte>(_inputBuffer, 0, _inputBufferIndex));
-                        amountRead += _inputBufferIndex;
-                        _inputBufferIndex = 0;
-
-                        // Make amountRead an integral multiple of _InputBlockSize
-                        int numWholeReadBlocks = amountRead / _inputBlockSize;
-                        int numWholeReadBlocksInBytes = numWholeReadBlocks * _inputBlockSize;
-                        int numIgnoredBytes = amountRead - numWholeReadBlocksInBytes;
-
-                        if (numIgnoredBytes != 0)
+                        // Read into our temporary input buffer, leaving enough room at the beginning for any existing data
+                        // we have in _inputBuffer.
+                        bytesRead = useAsync ?
+                            await _stream.ReadAsync(new Memory<byte>(tempInputBuffer, _inputBufferIndex, numWholeBlocksInBytes - _inputBufferIndex), cancellationToken).ConfigureAwait(false) :
+                            _stream.Read(tempInputBuffer, _inputBufferIndex, numWholeBlocksInBytes - _inputBufferIndex);
+                        eof = bytesRead == 0;
+
+                        // If we got enough data to form at least one block, transform as much as we can.
+                        int totalInput = _inputBufferIndex + bytesRead;
+                        if (totalInput >= _inputBlockSize)
                         {
-                            _inputBufferIndex = numIgnoredBytes;
-                            Buffer.BlockCopy(tempInputBuffer, numWholeReadBlocksInBytes, _inputBuffer, 0, numIgnoredBytes);
-                        }
-
-                        // Use ArrayPool.Shared instead of CryptoPool because the array is passed out.
-                        tempOutputBuffer = ArrayPool<byte>.Shared.Rent(numWholeReadBlocks * _outputBlockSize);
-                        numOutputBytes = _transform.TransformBlock(tempInputBuffer, 0, numWholeReadBlocksInBytes, tempOutputBuffer, 0);
-                        tempOutputBuffer.AsSpan(0, numOutputBytes).CopyTo(buffer.Span.Slice(currentOutputIndex));
-
-                        // Clear what was written while we know how much that was
-                        CryptographicOperations.ZeroMemory(new Span<byte>(tempOutputBuffer, 0, numOutputBytes));
-                        ArrayPool<byte>.Shared.Return(tempOutputBuffer);
-                        tempOutputBuffer = null;
+                            // Copy any held data into tempInputBuffer now that we know we're proceeding to handle
+                            // decrypting all the received data.
+                            Buffer.BlockCopy(_inputBuffer, 0, tempInputBuffer, 0, _inputBufferIndex);
+                            CryptographicOperations.ZeroMemory(new Span<byte>(_inputBuffer, 0, _inputBufferIndex));
+                            bytesRead += _inputBufferIndex;
+
+                            // Determine how many entire blocks worth of data we read.
+                            int numWholeReadBlocks = bytesRead / _inputBlockSize;
+                            int numWholeReadBlocksInBytes = numWholeReadBlocks * _inputBlockSize;
+
+                            // If there's anything left over, copy that back into _inputBuffer for a later read.
+                            _inputBufferIndex = bytesRead - numWholeReadBlocksInBytes;
+                            if (_inputBufferIndex != 0)
+                            {
+                                Buffer.BlockCopy(tempInputBuffer, numWholeReadBlocksInBytes, _inputBuffer, 0, _inputBufferIndex);
+                            }
 
-                        bytesToDeliver -= numOutputBytes;
-                        currentOutputIndex += numOutputBytes;
-                    }
+                            // Transform the read data into the caller's buffer.
+                            int numOutputBytes;
+                            if (MemoryMarshal.TryGetArray(buffer, out ArraySegment<byte> bufferArray))
+                            {
+                                // Because TransformBlock is based on arrays, we can only write directly into the output
+                                // buffer if it's backed by an array; otherwise, we need to rent from the pool.
+                                numOutputBytes = _transform.TransformBlock(tempInputBuffer, 0, numWholeReadBlocksInBytes, bufferArray.Array!, bufferArray.Offset);
+                            }
+                            else
+                            {
+                                // Otherwise, we need to rent a temporary from the pool.
+                                byte[] tempOutputBuffer = ArrayPool<byte>.Shared.Rent(numWholeReadBlocks * _outputBlockSize);
+                                numOutputBytes = numWholeReadBlocks * _outputBlockSize;
+                                try
+                                {
+                                    numOutputBytes = _transform.TransformBlock(tempInputBuffer, 0, numWholeReadBlocksInBytes, tempOutputBuffer, 0);
+                                    tempOutputBuffer.AsSpan(0, numOutputBytes).CopyTo(buffer.Span);
+                                }
+                                finally
+                                {
+                                    CryptographicOperations.ZeroMemory(new Span<byte>(tempOutputBuffer, 0, numOutputBytes));
+                                    ArrayPool<byte>.Shared.Return(tempOutputBuffer);
+                                }
+                            }
 
-                    CryptographicOperations.ZeroMemory(new Span<byte>(tempInputBuffer, 0, numWholeBlocksInBytes));
-                    ArrayPool<byte>.Shared.Return(tempInputBuffer);
-                    tempInputBuffer = null;
-                }
-                catch
-                {
-                    // If we rented and then an exception happened we don't know how much was written to,
-                    // clear the whole thing and let it get reclaimed by the GC.
-                    if (tempOutputBuffer != null)
-                    {
-                        CryptographicOperations.ZeroMemory(tempOutputBuffer);
-                        tempOutputBuffer = null;
+                            // Return anything we've got at this point.
+                            if (numOutputBytes != 0)
+                            {
+                                return numOutputBytes;
+                            }
+                        }
+                        else
+                        {
+                            // We have less than a block's worth of data.  Copy the new data back into the _inputBuffer
+                            // and fall back to using the single block code path.
+                            Buffer.BlockCopy(tempInputBuffer, _inputBufferIndex, _inputBuffer, _inputBufferIndex, bytesRead);
+                            _inputBufferIndex = totalInput;
+                        }
                     }
-
-                    // For the input buffer we know how much was written, so clear that.
-                    // But still let it get reclaimed by the GC.
-                    if (tempInputBuffer != null)
+                    finally
                     {
                         CryptographicOperations.ZeroMemory(new Span<byte>(tempInputBuffer, 0, numWholeBlocksInBytes));
-                        tempInputBuffer = null;
+                        ArrayPool<byte>.Shared.Return(tempInputBuffer);
                     }
-
-                    throw;
                 }
-            }
 
-            // try to fill _InputBuffer so we have something to transform
-            while (bytesToDeliver > 0)
-            {
-                while (_inputBufferIndex < _inputBlockSize)
+                // Read enough to fill one input block, as anything less won't be able to be transformed to produce output.
+                if (!eof)
                 {
-                    amountRead = useAsync ?
-                        await _stream.ReadAsync(new Memory<byte>(_inputBuffer, _inputBufferIndex, _inputBlockSize - _inputBufferIndex), cancellationToken).ConfigureAwait(false) :
-                        _stream.Read(_inputBuffer, _inputBufferIndex, _inputBlockSize - _inputBufferIndex);
+                    while (_inputBufferIndex < _inputBlockSize)
+                    {
+                        bytesRead = useAsync ?
+                            await _stream.ReadAsync(new Memory<byte>(_inputBuffer, _inputBufferIndex, _inputBlockSize - _inputBufferIndex), cancellationToken).ConfigureAwait(false) :
+                            _stream.Read(_inputBuffer, _inputBufferIndex, _inputBlockSize - _inputBufferIndex);
+                        if (bytesRead <= 0)
+                        {
+                            break;
+                        }
 
-                    // first, check to see if we're at the end of the input stream
-                    if (amountRead == 0) goto ProcessFinalBlock;
-                    _inputBufferIndex += amountRead;
+                        _inputBufferIndex += bytesRead;
+                    }
                 }
 
-                numOutputBytes = _transform.TransformBlock(_inputBuffer, 0, _inputBlockSize, _outputBuffer, 0);
-                _inputBufferIndex = 0;
-
-                if (bytesToDeliver >= numOutputBytes)
+                // Transform the received data.
+                if (bytesRead <= 0)
                 {
-                    _outputBuffer.AsSpan(0, numOutputBytes).CopyTo(buffer.Span.Slice(currentOutputIndex));
-                    CryptographicOperations.ZeroMemory(new Span<byte>(_outputBuffer, 0, numOutputBytes));
-                    currentOutputIndex += numOutputBytes;
-                    bytesToDeliver -= numOutputBytes;
+                    _outputBuffer = _transform.TransformFinalBlock(_inputBuffer, 0, _inputBufferIndex);
+                    _outputBufferIndex = _outputBuffer.Length;
+                    _finalBlockTransformed = true;
                 }
                 else
                 {
-                    _outputBuffer.AsSpan(0, bytesToDeliver).CopyTo(buffer.Span.Slice(currentOutputIndex));
-                    _outputBufferIndex = numOutputBytes - bytesToDeliver;
-                    Buffer.BlockCopy(_outputBuffer, bytesToDeliver, _outputBuffer, 0, _outputBufferIndex);
-                    int toClear = _outputBuffer.Length - _outputBufferIndex;
-                    CryptographicOperations.ZeroMemory(new Span<byte>(_outputBuffer, _outputBufferIndex, toClear));
-                    return buffer.Length;
+                    _outputBufferIndex = _transform.TransformBlock(_inputBuffer, 0, _inputBufferIndex, _outputBuffer, 0);
                 }
-            }
-            return buffer.Length;
-
-        ProcessFinalBlock:
-            // if so, then call TransformFinalBlock to get whatever is left
-            byte[] finalBytes = _transform.TransformFinalBlock(_inputBuffer, 0, _inputBufferIndex);
-            // now, since _OutputBufferIndex must be 0 if we're in the while loop at this point,
-            // reset it to be what we just got back
-            _outputBuffer = finalBytes;
-            _outputBufferIndex = finalBytes.Length;
-            // set the fact that we've transformed the final block
-            _finalBlockTransformed = true;
-            // now, return either everything we just got or just what's asked for, whichever is smaller
-            if (bytesToDeliver < _outputBufferIndex)
-            {
-                _outputBuffer.AsSpan(0, bytesToDeliver).CopyTo(buffer.Span.Slice(currentOutputIndex));
-                _outputBufferIndex -= bytesToDeliver;
-                Buffer.BlockCopy(_outputBuffer, bytesToDeliver, _outputBuffer, 0, _outputBufferIndex);
-                int toClear = _outputBuffer.Length - _outputBufferIndex;
-                CryptographicOperations.ZeroMemory(new Span<byte>(_outputBuffer, _outputBufferIndex, toClear));
-                return buffer.Length;
-            }
-            else
-            {
-                _outputBuffer.AsSpan(0, _outputBufferIndex).CopyTo(buffer.Span.Slice(currentOutputIndex));
-                bytesToDeliver -= _outputBufferIndex;
-                _outputBufferIndex = 0;
-                CryptographicOperations.ZeroMemory(_outputBuffer);
-                return buffer.Length - bytesToDeliver;
+
+                // All input data has been processed.
+                _inputBufferIndex = 0;
             }
         }
 
@@ -807,8 +775,8 @@ protected override void Dispose(bool disposing)
                     if (_outputBuffer != null)
                         Array.Clear(_outputBuffer);
 
-                    _inputBuffer = null;
-                    _outputBuffer = null;
+                    _inputBuffer = null!;
+                    _outputBuffer = null!;
                     _canRead = false;
                     _canWrite = false;
                 }
@@ -858,30 +826,13 @@ private async ValueTask DisposeAsyncCore()
                     Array.Clear(_outputBuffer);
                 }
 
-                _inputBuffer = null;
-                _outputBuffer = null;
+                _inputBuffer = null!;
+                _outputBuffer = null!;
                 _canRead = false;
                 _canWrite = false;
             }
         }
 
-        // Private methods
-
-        private void InitializeBuffer()
-        {
-            if (_transform != null)
-            {
-                _inputBlockSize = _transform.InputBlockSize;
-                _inputBuffer = new byte[_inputBlockSize];
-                _outputBlockSize = _transform.OutputBlockSize;
-                _outputBuffer = new byte[_outputBlockSize];
-            }
-            else
-            {
-                throw new ArgumentNullException(nameof(_transform));
-            }
-        }
-
         [MemberNotNull(nameof(_lazyAsyncActiveSemaphore))]
         private SemaphoreSlim AsyncActiveSemaphore
         {
diff --git a/src/libraries/System.Security.Cryptography.Primitives/tests/CryptoStream.cs b/src/libraries/System.Security.Cryptography.Primitives/tests/CryptoStream.cs
index ea43dc8ca10a2b..86fa12306f8ae8 100644
--- a/src/libraries/System.Security.Cryptography.Primitives/tests/CryptoStream.cs
+++ b/src/libraries/System.Security.Cryptography.Primitives/tests/CryptoStream.cs
@@ -27,6 +27,7 @@ protected override Task<StreamPair> CreateWrappedConnectedStreamsAsync(StreamPai
         }
 
         protected override Type UnsupportedConcurrentExceptionType => null;
+        protected override bool BlocksOnZeroByteReads => true;
 
         [ActiveIssue("https://github.com/dotnet/runtime/issues/45080")]
         [Theory]
@@ -37,7 +38,7 @@ protected override Task<StreamPair> CreateWrappedConnectedStreamsAsync(StreamPai
         public static void Ctor()
         {
             var transform = new IdentityTransform(1, 1, true);
-            AssertExtensions.Throws<ArgumentException>(null, () => new CryptoStream(new MemoryStream(), transform, (CryptoStreamMode)12345));
+            AssertExtensions.Throws<ArgumentException>("mode", () => new CryptoStream(new MemoryStream(), transform, (CryptoStreamMode)12345));
             AssertExtensions.Throws<ArgumentException>(null, "stream", () => new CryptoStream(new MemoryStream(new byte[0], writable: false), transform, CryptoStreamMode.Write));
             AssertExtensions.Throws<ArgumentException>(null, "stream", () => new CryptoStream(new CryptoStream(new MemoryStream(new byte[0]), transform, CryptoStreamMode.Write), transform, CryptoStreamMode.Read));
         }
diff --git a/src/libraries/System.Security.Cryptography.ProtectedData/ref/System.Security.Cryptography.ProtectedData.csproj b/src/libraries/System.Security.Cryptography.ProtectedData/ref/System.Security.Cryptography.ProtectedData.csproj
index 96113201a7a080..7b9702905467cc 100644
--- a/src/libraries/System.Security.Cryptography.ProtectedData/ref/System.Security.Cryptography.ProtectedData.csproj
+++ b/src/libraries/System.Security.Cryptography.ProtectedData/ref/System.Security.Cryptography.ProtectedData.csproj
@@ -1,6 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFrameworks>netstandard2.0;net461</TargetFrameworks>
+    <TargetFrameworks>$(NetCoreAppCurrent);netstandard2.0;net461</TargetFrameworks>
     <Nullable>enable</Nullable>
   </PropertyGroup>
   <ItemGroup>
@@ -10,4 +10,7 @@
   <ItemGroup Condition="'$(TargetFramework)' == 'net461'">
     <Reference Include="System.Security" />
   </ItemGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == '$(NetCoreAppCurrent)'">
+    <ProjectReference Include="$(LibrariesProjectRoot)System.Runtime\ref\System.Runtime.csproj" />
+  </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/src/libraries/System.Security.Cryptography.ProtectedData/src/System.Security.Cryptography.ProtectedData.csproj b/src/libraries/System.Security.Cryptography.ProtectedData/src/System.Security.Cryptography.ProtectedData.csproj
index 58751f82564713..7a10f1803b3f87 100644
--- a/src/libraries/System.Security.Cryptography.ProtectedData/src/System.Security.Cryptography.ProtectedData.csproj
+++ b/src/libraries/System.Security.Cryptography.ProtectedData/src/System.Security.Cryptography.ProtectedData.csproj
@@ -1,16 +1,16 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <TargetFrameworks>netstandard2.0-windows;net461-windows;netstandard2.0</TargetFrameworks>
+    <TargetFrameworks>$(NetCoreAppCurrent)-windows;$(NetCoreAppCurrent);netstandard2.0-windows;netstandard2.0;net461-windows</TargetFrameworks>
     <Nullable>enable</Nullable>
   </PropertyGroup>
   <!-- DesignTimeBuild requires all the TargetFramework Derived Properties to not be present in the first property group. -->
   <PropertyGroup>
     <IsPartialFacadeAssembly Condition="$(TargetFramework.StartsWith('net4'))">true</IsPartialFacadeAssembly>
     <OmitResources Condition="$(TargetFramework.StartsWith('net4'))">true</OmitResources>
-    <GeneratePlatformNotSupportedAssemblyMessage Condition="$(TargetFramework.StartsWith('netstandard')) and '$(TargetsWindows)' != 'true'">SR.PlatformNotSupported_CryptographyProtectedData</GeneratePlatformNotSupportedAssemblyMessage>
+    <GeneratePlatformNotSupportedAssemblyMessage Condition="'$(TargetsWindows)' != 'true'">SR.PlatformNotSupported_CryptographyProtectedData</GeneratePlatformNotSupportedAssemblyMessage>
   </PropertyGroup>
-  <ItemGroup Condition="'$(IsPartialFacadeAssembly)' != 'true' and (!$(TargetFramework.StartsWith('netstandard')) or '$(TargetsWindows)' == 'true')">
+  <ItemGroup Condition="'$(IsPartialFacadeAssembly)' != 'true' and '$(TargetsWindows)' == 'true'">
     <Compile Include="System\Security\Cryptography\DataProtectionScope.cs" />
     <Compile Include="System\Security\Cryptography\ProtectedData.cs" />
     <Compile Include="$(CommonPath)Interop\Windows\Crypt32\Interop.CryptProtectData.cs"
@@ -32,10 +32,15 @@
     <Compile Include="$(CommonPath)System\HResults.cs"
              Link="Common\System\HResults.cs" />
   </ItemGroup>
-  <ItemGroup Condition="$(TargetFramework.StartsWith('net4'))">
+  <ItemGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETFramework'">
     <Reference Include="System.Security" />
   </ItemGroup>
-  <ItemGroup Condition="$(TargetFramework.StartsWith('netstandard2.0'))">
+  <ItemGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp'">
+    <Reference Include="System.Resources.ResourceManager" />
+    <Reference Include="System.Runtime" />
+    <Reference Include="System.Runtime.InteropServices" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETStandard'">
     <PackageReference Include="System.Memory" Version="$(SystemMemoryVersion)" />
     <ProjectReference Include="$(LibrariesProjectRoot)System.Runtime.CompilerServices.Unsafe\src\System.Runtime.CompilerServices.Unsafe.ilproj" />
   </ItemGroup>
diff --git a/src/libraries/System.Security.Cryptography.X509Certificates/ref/System.Security.Cryptography.X509Certificates.cs b/src/libraries/System.Security.Cryptography.X509Certificates/ref/System.Security.Cryptography.X509Certificates.cs
index 6c4e307da94fa3..e3ade1a368c510 100644
--- a/src/libraries/System.Security.Cryptography.X509Certificates/ref/System.Security.Cryptography.X509Certificates.cs
+++ b/src/libraries/System.Security.Cryptography.X509Certificates/ref/System.Security.Cryptography.X509Certificates.cs
@@ -147,6 +147,7 @@ public override void CopyFrom(System.Security.Cryptography.AsnEncodedData asnEnc
     }
     public partial class X509Certificate : System.IDisposable, System.Runtime.Serialization.IDeserializationCallback, System.Runtime.Serialization.ISerializable
     {
+        [System.ObsoleteAttribute("X509Certificate and X509Certificate2 are immutable. Use the appropriate constructor to create a new certificate.", DiagnosticId = "SYSLIB0026", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
         public X509Certificate() { }
         public X509Certificate(byte[] data) { }
         [System.CLSCompliantAttribute(false)]
@@ -200,13 +201,19 @@ protected virtual void Dispose(bool disposing) { }
         public virtual string GetRawCertDataString() { throw null; }
         public virtual byte[] GetSerialNumber() { throw null; }
         public virtual string GetSerialNumberString() { throw null; }
+        [System.ObsoleteAttribute("X509Certificate and X509Certificate2 are immutable. Use the appropriate constructor to create a new certificate.", DiagnosticId = "SYSLIB0026", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
         public virtual void Import(byte[] rawData) { }
         [System.CLSCompliantAttribute(false)]
+        [System.ObsoleteAttribute("X509Certificate and X509Certificate2 are immutable. Use the appropriate constructor to create a new certificate.", DiagnosticId = "SYSLIB0026", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
         public virtual void Import(byte[] rawData, System.Security.SecureString? password, System.Security.Cryptography.X509Certificates.X509KeyStorageFlags keyStorageFlags) { }
+        [System.ObsoleteAttribute("X509Certificate and X509Certificate2 are immutable. Use the appropriate constructor to create a new certificate.", DiagnosticId = "SYSLIB0026", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
         public virtual void Import(byte[] rawData, string? password, System.Security.Cryptography.X509Certificates.X509KeyStorageFlags keyStorageFlags) { }
+        [System.ObsoleteAttribute("X509Certificate and X509Certificate2 are immutable. Use the appropriate constructor to create a new certificate.", DiagnosticId = "SYSLIB0026", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
         public virtual void Import(string fileName) { }
         [System.CLSCompliantAttribute(false)]
+        [System.ObsoleteAttribute("X509Certificate and X509Certificate2 are immutable. Use the appropriate constructor to create a new certificate.", DiagnosticId = "SYSLIB0026", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
         public virtual void Import(string fileName, System.Security.SecureString? password, System.Security.Cryptography.X509Certificates.X509KeyStorageFlags keyStorageFlags) { }
+        [System.ObsoleteAttribute("X509Certificate and X509Certificate2 are immutable. Use the appropriate constructor to create a new certificate.", DiagnosticId = "SYSLIB0026", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
         public virtual void Import(string fileName, string? password, System.Security.Cryptography.X509Certificates.X509KeyStorageFlags keyStorageFlags) { }
         public virtual void Reset() { }
         void System.Runtime.Serialization.IDeserializationCallback.OnDeserialization(object? sender) { }
@@ -217,6 +224,7 @@ void System.Runtime.Serialization.ISerializable.GetObjectData(System.Runtime.Ser
     }
     public partial class X509Certificate2 : System.Security.Cryptography.X509Certificates.X509Certificate
     {
+        [System.ObsoleteAttribute("X509Certificate and X509Certificate2 are immutable. Use the appropriate constructor to create a new certificate.", DiagnosticId = "SYSLIB0026", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
         public X509Certificate2() { }
         public X509Certificate2(byte[] rawData) { }
         [System.CLSCompliantAttribute(false)]
@@ -238,9 +246,9 @@ public X509Certificate2(string fileName, System.Security.SecureString? password)
         public X509Certificate2(string fileName, System.Security.SecureString? password, System.Security.Cryptography.X509Certificates.X509KeyStorageFlags keyStorageFlags) { }
         public X509Certificate2(string fileName, string? password) { }
         public X509Certificate2(string fileName, string? password, System.Security.Cryptography.X509Certificates.X509KeyStorageFlags keyStorageFlags) { }
-        public bool Archived { get { throw null; } set { } }
+        public bool Archived { get { throw null; } [System.Runtime.Versioning.SupportedOSPlatformAttribute("windows")] set { } }
         public System.Security.Cryptography.X509Certificates.X509ExtensionCollection Extensions { get { throw null; } }
-        public string FriendlyName { get { throw null; } set { } }
+        public string FriendlyName { get { throw null; } [System.Runtime.Versioning.SupportedOSPlatformAttribute("windows")] set { } }
         public bool HasPrivateKey { get { throw null; } }
         public System.Security.Cryptography.X509Certificates.X500DistinguishedName IssuerName { get { throw null; } }
         public System.DateTime NotAfter { get { throw null; } }
@@ -265,13 +273,19 @@ public X509Certificate2(string fileName, string? password, System.Security.Crypt
         public System.Security.Cryptography.ECDiffieHellman? GetECDiffieHellmanPrivateKey() { throw null; }
         public System.Security.Cryptography.ECDiffieHellman? GetECDiffieHellmanPublicKey() { throw null; }
         public string GetNameInfo(System.Security.Cryptography.X509Certificates.X509NameType nameType, bool forIssuer) { throw null; }
+        [System.ObsoleteAttribute("X509Certificate and X509Certificate2 are immutable. Use the appropriate constructor to create a new certificate.", DiagnosticId = "SYSLIB0026", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
         public override void Import(byte[] rawData) { }
         [System.CLSCompliantAttribute(false)]
+        [System.ObsoleteAttribute("X509Certificate and X509Certificate2 are immutable. Use the appropriate constructor to create a new certificate.", DiagnosticId = "SYSLIB0026", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
         public override void Import(byte[] rawData, System.Security.SecureString? password, System.Security.Cryptography.X509Certificates.X509KeyStorageFlags keyStorageFlags) { }
+        [System.ObsoleteAttribute("X509Certificate and X509Certificate2 are immutable. Use the appropriate constructor to create a new certificate.", DiagnosticId = "SYSLIB0026", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
         public override void Import(byte[] rawData, string? password, System.Security.Cryptography.X509Certificates.X509KeyStorageFlags keyStorageFlags) { }
+        [System.ObsoleteAttribute("X509Certificate and X509Certificate2 are immutable. Use the appropriate constructor to create a new certificate.", DiagnosticId = "SYSLIB0026", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
         public override void Import(string fileName) { }
         [System.CLSCompliantAttribute(false)]
+        [System.ObsoleteAttribute("X509Certificate and X509Certificate2 are immutable. Use the appropriate constructor to create a new certificate.", DiagnosticId = "SYSLIB0026", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
         public override void Import(string fileName, System.Security.SecureString? password, System.Security.Cryptography.X509Certificates.X509KeyStorageFlags keyStorageFlags) { }
+        [System.ObsoleteAttribute("X509Certificate and X509Certificate2 are immutable. Use the appropriate constructor to create a new certificate.", DiagnosticId = "SYSLIB0026", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
         public override void Import(string fileName, string? password, System.Security.Cryptography.X509Certificates.X509KeyStorageFlags keyStorageFlags) { }
         public override void Reset() { }
         public override string ToString() { throw null; }
diff --git a/src/libraries/System.Security.Cryptography.X509Certificates/ref/System.Security.Cryptography.X509Certificates.csproj b/src/libraries/System.Security.Cryptography.X509Certificates/ref/System.Security.Cryptography.X509Certificates.csproj
index d670fc85a01e43..66188cc890c48f 100644
--- a/src/libraries/System.Security.Cryptography.X509Certificates/ref/System.Security.Cryptography.X509Certificates.csproj
+++ b/src/libraries/System.Security.Cryptography.X509Certificates/ref/System.Security.Cryptography.X509Certificates.csproj
@@ -2,6 +2,7 @@
   <PropertyGroup>
     <TargetFrameworks>$(NetCoreAppCurrent)</TargetFrameworks>
     <Nullable>enable</Nullable>
+    <NoWarn>$(NoWarn);SYSLIB0026</NoWarn>
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="System.Security.Cryptography.X509Certificates.cs" />
@@ -15,4 +16,4 @@
     <ProjectReference Include="..\..\System.Security.Cryptography.Encoding\ref\System.Security.Cryptography.Encoding.csproj" />
     <ProjectReference Include="..\..\System.Security.Cryptography.Primitives\ref\System.Security.Cryptography.Primitives.csproj" />
   </ItemGroup>
-</Project>
\ No newline at end of file
+</Project>
diff --git a/src/libraries/System.Security.Cryptography.X509Certificates/src/Internal/Cryptography/Pal.OSX/AppleCertificatePal.cs b/src/libraries/System.Security.Cryptography.X509Certificates/src/Internal/Cryptography/Pal.OSX/AppleCertificatePal.cs
index cb949b8a93f7ad..07959c3e77b5ac 100644
--- a/src/libraries/System.Security.Cryptography.X509Certificates/src/Internal/Cryptography/Pal.OSX/AppleCertificatePal.cs
+++ b/src/libraries/System.Security.Cryptography.X509Certificates/src/Internal/Cryptography/Pal.OSX/AppleCertificatePal.cs
@@ -399,7 +399,26 @@ private void EnsureCertData()
                 return;
 
             Debug.Assert(!_certHandle.IsInvalid);
-            _certData = new CertificateData(Interop.AppleCrypto.X509GetRawData(_certHandle));
+            string? subjectSummary = Interop.AppleCrypto.X509GetSubjectSummary(_certHandle);
+
+            try
+            {
+                _certData = new CertificateData(Interop.AppleCrypto.X509GetRawData(_certHandle));
+            }
+            catch (CryptographicException e)
+            {
+                if (subjectSummary is null)
+                {
+                    throw;
+                }
+
+                string message = SR.Format(
+                    SR.Cryptography_X509_CertificateCorrupted,
+                    subjectSummary);
+
+                throw new CryptographicException(message, e);
+            }
+
             _readCertData = true;
         }
     }
diff --git a/src/libraries/System.Security.Cryptography.X509Certificates/src/Internal/Cryptography/Pal.Unix/UnixExportProvider.cs b/src/libraries/System.Security.Cryptography.X509Certificates/src/Internal/Cryptography/Pal.Unix/UnixExportProvider.cs
index f353cf2855b5ff..0ad2762dd94579 100644
--- a/src/libraries/System.Security.Cryptography.X509Certificates/src/Internal/Cryptography/Pal.Unix/UnixExportProvider.cs
+++ b/src/libraries/System.Security.Cryptography.X509Certificates/src/Internal/Cryptography/Pal.Unix/UnixExportProvider.cs
@@ -475,44 +475,35 @@ private static ArraySegment<byte> EncodeAuthSafe(
             return new ArraySegment<byte>(authSafe, 0, authSafeLength);
         }
 
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Security", "CA5350", Justification = "HMACSHA1 is required for compat with other platforms")]
         private static unsafe byte[] MacAndEncode(
             AsnWriter tmpWriter,
             ReadOnlyMemory<byte> encodedAuthSafe,
             ReadOnlySpan<char> passwordSpan)
         {
-            // Windows/macOS compatibility: Use HMAC-SHA-1,
-            // other algorithms may not be understood
-            byte[] macKey = new byte[20];
-            Span<byte> macSalt = stackalloc byte[20];
-            Span<byte> macSpan = stackalloc byte[20];
-            HashAlgorithmName hashAlgorithm = HashAlgorithmName.SHA1;
+            const int MacSize = 160 / 8; // HMAC-SHA1 is 160 bits.
+            Span<byte> macKey = stackalloc byte[MacSize];
+            Span<byte> macSalt = stackalloc byte[MacSize];
+            Span<byte> macSpan = stackalloc byte[MacSize];
             RandomNumberGenerator.Fill(macSalt);
 
-            fixed (byte* macKeyPtr = macKey)
-            {
-                Span<byte> macKeySpan = macKey;
-
-                Pkcs12Kdf.DeriveMacKey(
-                    passwordSpan,
-                    hashAlgorithm,
-                    s_windowsPbe.IterationCount,
-                    macSalt,
-                    macKeySpan);
-
-                using (IncrementalHash mac = IncrementalHash.CreateHMAC(hashAlgorithm, macKey))
-                {
-                    mac.AppendData(encodedAuthSafe.Span);
+            Pkcs12Kdf.DeriveMacKey(
+                passwordSpan,
+                HashAlgorithmName.SHA1,
+                s_windowsPbe.IterationCount,
+                macSalt,
+                macKey);
 
-                    if (!mac.TryGetHashAndReset(macSpan, out int bytesWritten) || bytesWritten != macSpan.Length)
-                    {
-                        Debug.Fail($"TryGetHashAndReset wrote {bytesWritten} of {macSpan.Length} bytes");
-                        throw new CryptographicException();
-                    }
-                }
+            int bytesWritten = HMACSHA1.HashData(macKey, encodedAuthSafe.Span, macSpan);
 
-                CryptographicOperations.ZeroMemory(macKeySpan);
+            if (bytesWritten != MacSize)
+            {
+                Debug.Fail($"HMACSHA1.HashData wrote {bytesWritten} of {MacSize} bytes");
+                throw new CryptographicException();
             }
 
+            CryptographicOperations.ZeroMemory(macKey);
+
             // https://tools.ietf.org/html/rfc7292#section-4
             //
             // PFX ::= SEQUENCE {
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 a5c33a43b40b88..322e2bab91d0c4 100644
--- a/src/libraries/System.Security.Cryptography.X509Certificates/src/Resources/Strings.resx
+++ b/src/libraries/System.Security.Cryptography.X509Certificates/src/Resources/Strings.resx
@@ -331,6 +331,9 @@
   <data name="Cryptography_X509_NoOrMismatchedPemKey" xml:space="preserve">
     <value>The key contents do not contain a PEM, the content is malformed, or the key does not match the certificate.</value>
   </data>
+  <data name="Cryptography_X509_CertificateCorrupted" xml:space="preserve">
+    <value>Certificate '{0}' is corrupted.</value>
+  </data>
   <data name="InvalidOperation_EnumNotStarted" xml:space="preserve">
     <value>Enumeration has not started. Call MoveNext.</value>
   </data>
diff --git a/src/libraries/System.Security.Cryptography.X509Certificates/src/System.Security.Cryptography.X509Certificates.csproj b/src/libraries/System.Security.Cryptography.X509Certificates/src/System.Security.Cryptography.X509Certificates.csproj
index 458fa92770709a..2c0921f9fcd93c 100644
--- a/src/libraries/System.Security.Cryptography.X509Certificates/src/System.Security.Cryptography.X509Certificates.csproj
+++ b/src/libraries/System.Security.Cryptography.X509Certificates/src/System.Security.Cryptography.X509Certificates.csproj
@@ -6,7 +6,7 @@
     <Nullable>enable</Nullable>
   </PropertyGroup>
   <PropertyGroup Condition="'$(TargetsAnyOS)' == 'true'">
-    <NoWarn>$(NoWarn);CS8769</NoWarn>
+    <NoWarn>$(NoWarn);CS8769;SYSLIB0026</NoWarn>
     <GeneratePlatformNotSupportedAssemblyMessage>SR.SystemSecurityCryptographyX509Certificates_PlatformNotSupported</GeneratePlatformNotSupportedAssemblyMessage>
   </PropertyGroup>
   <PropertyGroup>
@@ -22,6 +22,8 @@
              Link="Common\Microsoft\Win32\SafeHandles\SafeHandleCache.cs" />
     <Compile Include="$(CommonPath)System\Memory\PointerMemoryManager.cs"
              Link="Common\System\Memory\PointerMemoryManager.cs" />
+    <Compile Include="$(CommonPath)System\Obsoletions.cs"
+             Link="Common\System\Obsoletions.cs" />
     <Compile Include="$(CommonPath)System\Security\Cryptography\CryptoPool.cs"
              Link="Common\System\Security\Cryptography\CryptoPool.cs" />
     <Compile Include="$(CommonPath)System\Security\Cryptography\Oids.cs"
diff --git a/src/libraries/System.Security.Cryptography.X509Certificates/src/System/Security/Cryptography/X509Certificates/X509Certificate.cs b/src/libraries/System.Security.Cryptography.X509Certificates/src/System/Security/Cryptography/X509Certificates/X509Certificate.cs
index 285ce520854bb9..3ae1211e6a7c5c 100644
--- a/src/libraries/System.Security.Cryptography.X509Certificates/src/System/Security/Cryptography/X509Certificates/X509Certificate.cs
+++ b/src/libraries/System.Security.Cryptography.X509Certificates/src/System/Security/Cryptography/X509Certificates/X509Certificate.cs
@@ -4,6 +4,7 @@
 using Internal.Cryptography;
 using Internal.Cryptography.Pal;
 using Microsoft.Win32.SafeHandles;
+using System;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
@@ -44,6 +45,7 @@ public virtual void Reset()
             }
         }
 
+        [Obsolete(Obsoletions.X509CertificateImmutableMessage, DiagnosticId = Obsoletions.X509CertificateImmutableDiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
         public X509Certificate()
         {
         }
@@ -171,7 +173,9 @@ private protected X509Certificate(string fileName, ReadOnlySpan<char> password,
         }
 
         [System.CLSCompliantAttribute(false)]
+#pragma warning disable SYSLIB0026
         public X509Certificate(string fileName, SecureString? password, X509KeyStorageFlags keyStorageFlags) : this()
+#pragma warning restore SYSLIB0026
         {
             if (fileName == null)
                 throw new ArgumentNullException(nameof(fileName));
@@ -195,7 +199,9 @@ public X509Certificate(X509Certificate cert)
             }
         }
 
+#pragma warning disable SYSLIB0026
         public X509Certificate(SerializationInfo info, StreamingContext context) : this()
+#pragma warning restore SYSLIB0026
         {
             throw new PlatformNotSupportedException();
         }
@@ -569,33 +575,39 @@ public virtual string ToString(bool fVerbose)
             return sb.ToString();
         }
 
+        [Obsolete(Obsoletions.X509CertificateImmutableMessage, DiagnosticId = Obsoletions.X509CertificateImmutableDiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
         public virtual void Import(byte[] rawData)
         {
             throw new PlatformNotSupportedException(SR.NotSupported_ImmutableX509Certificate);
         }
 
+        [Obsolete(Obsoletions.X509CertificateImmutableMessage, DiagnosticId = Obsoletions.X509CertificateImmutableDiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
         public virtual void Import(byte[] rawData, string? password, X509KeyStorageFlags keyStorageFlags)
         {
             throw new PlatformNotSupportedException(SR.NotSupported_ImmutableX509Certificate);
         }
 
         [System.CLSCompliantAttribute(false)]
+        [Obsolete(Obsoletions.X509CertificateImmutableMessage, DiagnosticId = Obsoletions.X509CertificateImmutableDiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
         public virtual void Import(byte[] rawData, SecureString? password, X509KeyStorageFlags keyStorageFlags)
         {
             throw new PlatformNotSupportedException(SR.NotSupported_ImmutableX509Certificate);
         }
 
+        [Obsolete(Obsoletions.X509CertificateImmutableMessage, DiagnosticId = Obsoletions.X509CertificateImmutableDiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
         public virtual void Import(string fileName)
         {
             throw new PlatformNotSupportedException(SR.NotSupported_ImmutableX509Certificate);
         }
 
+        [Obsolete(Obsoletions.X509CertificateImmutableMessage, DiagnosticId = Obsoletions.X509CertificateImmutableDiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
         public virtual void Import(string fileName, string? password, X509KeyStorageFlags keyStorageFlags)
         {
             throw new PlatformNotSupportedException(SR.NotSupported_ImmutableX509Certificate);
         }
 
         [System.CLSCompliantAttribute(false)]
+        [Obsolete(Obsoletions.X509CertificateImmutableMessage, DiagnosticId = Obsoletions.X509CertificateImmutableDiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
         public virtual void Import(string fileName, SecureString? password, X509KeyStorageFlags keyStorageFlags)
         {
             throw new PlatformNotSupportedException(SR.NotSupported_ImmutableX509Certificate);
diff --git a/src/libraries/System.Security.Cryptography.X509Certificates/src/System/Security/Cryptography/X509Certificates/X509Certificate2.cs b/src/libraries/System.Security.Cryptography.X509Certificates/src/System/Security/Cryptography/X509Certificates/X509Certificate2.cs
index 76022ec91b6abb..d4ef8220853cdf 100644
--- a/src/libraries/System.Security.Cryptography.X509Certificates/src/System/Security/Cryptography/X509Certificates/X509Certificate2.cs
+++ b/src/libraries/System.Security.Cryptography.X509Certificates/src/System/Security/Cryptography/X509Certificates/X509Certificate2.cs
@@ -8,6 +8,7 @@
 using System.Formats.Asn1;
 using System.IO;
 using System.Runtime.Serialization;
+using System.Runtime.Versioning;
 using System.Security;
 using System.Security.Cryptography.X509Certificates.Asn1;
 using System.Text;
@@ -42,6 +43,7 @@ public override void Reset()
             base.Reset();
         }
 
+        [Obsolete(Obsoletions.X509CertificateImmutableMessage, DiagnosticId = Obsoletions.X509CertificateImmutableDiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
         public X509Certificate2()
             : base()
         {
@@ -170,6 +172,7 @@ public bool Archived
                 return Pal.Archived;
             }
 
+            [SupportedOSPlatform("windows")]
             set
             {
                 ThrowIfInvalid();
@@ -216,6 +219,7 @@ public string FriendlyName
                 return Pal.FriendlyName;
             }
 
+            [SupportedOSPlatform("windows")]
             set
             {
                 ThrowIfInvalid();
@@ -630,33 +634,39 @@ public override string ToString(bool verbose)
             return sb.ToString();
         }
 
+        [Obsolete(Obsoletions.X509CertificateImmutableMessage, DiagnosticId = Obsoletions.X509CertificateImmutableDiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
         public override void Import(byte[] rawData)
         {
             base.Import(rawData);
         }
 
+        [Obsolete(Obsoletions.X509CertificateImmutableMessage, DiagnosticId = Obsoletions.X509CertificateImmutableDiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
         public override void Import(byte[] rawData, string? password, X509KeyStorageFlags keyStorageFlags)
         {
             base.Import(rawData, password, keyStorageFlags);
         }
 
         [System.CLSCompliantAttribute(false)]
+        [Obsolete(Obsoletions.X509CertificateImmutableMessage, DiagnosticId = Obsoletions.X509CertificateImmutableDiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
         public override void Import(byte[] rawData, SecureString? password, X509KeyStorageFlags keyStorageFlags)
         {
             base.Import(rawData, password, keyStorageFlags);
         }
 
+        [Obsolete(Obsoletions.X509CertificateImmutableMessage, DiagnosticId = Obsoletions.X509CertificateImmutableDiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
         public override void Import(string fileName)
         {
             base.Import(fileName);
         }
 
+        [Obsolete(Obsoletions.X509CertificateImmutableMessage, DiagnosticId = Obsoletions.X509CertificateImmutableDiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
         public override void Import(string fileName, string? password, X509KeyStorageFlags keyStorageFlags)
         {
             base.Import(fileName, password, keyStorageFlags);
         }
 
         [System.CLSCompliantAttribute(false)]
+        [Obsolete(Obsoletions.X509CertificateImmutableMessage, DiagnosticId = Obsoletions.X509CertificateImmutableDiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
         public override void Import(string fileName, SecureString? password, X509KeyStorageFlags keyStorageFlags)
         {
             base.Import(fileName, password, keyStorageFlags);
diff --git a/src/libraries/System.Security.Cryptography.X509Certificates/tests/System.Security.Cryptography.X509Certificates.Tests.csproj b/src/libraries/System.Security.Cryptography.X509Certificates/tests/System.Security.Cryptography.X509Certificates.Tests.csproj
index a3ecd6dbeaaf8b..ee68bbc75bcc31 100644
--- a/src/libraries/System.Security.Cryptography.X509Certificates/tests/System.Security.Cryptography.X509Certificates.Tests.csproj
+++ b/src/libraries/System.Security.Cryptography.X509Certificates/tests/System.Security.Cryptography.X509Certificates.Tests.csproj
@@ -4,6 +4,7 @@
     <DefineConstants>$(DefineConstants);HAVE_THUMBPRINT_OVERLOADS</DefineConstants>
     <DefineConstants Condition="'$(TargetsUnix)' == 'true'">$(DefineConstants);Unix</DefineConstants>
     <IncludeRemoteExecutor>true</IncludeRemoteExecutor>
+    <NoWarn>$(NoWarn);SYSLIB0026</NoWarn>
     <TargetFrameworks>$(NetCoreAppCurrent)-windows;$(NetCoreAppCurrent)-Unix;$(NetCoreAppCurrent)-Android;$(NetCoreAppCurrent)-Browser;$(NetCoreAppCurrent)-OSX;$(NetCoreAppCurrent)-iOS;$(NetCoreAppCurrent)-tvOS</TargetFrameworks>
   </PropertyGroup>
   <PropertyGroup>
diff --git a/src/libraries/System.Security.Cryptography.Xml/ref/System.Security.Cryptography.Xml.csproj b/src/libraries/System.Security.Cryptography.Xml/ref/System.Security.Cryptography.Xml.csproj
index a20d226ba0f1cc..dca38dde22bf8b 100644
--- a/src/libraries/System.Security.Cryptography.Xml/ref/System.Security.Cryptography.Xml.csproj
+++ b/src/libraries/System.Security.Cryptography.Xml/ref/System.Security.Cryptography.Xml.csproj
@@ -1,15 +1,21 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFrameworks>netstandard2.0;net461</TargetFrameworks>
+    <TargetFrameworks>$(NetCoreAppCurrent);netstandard2.0;net461</TargetFrameworks>
   </PropertyGroup>
-  <ItemGroup Condition="'$(TargetFramework)' != 'net461'">
-    <ProjectReference Include="..\..\System.Security.AccessControl\ref\System.Security.AccessControl.csproj" />
-  </ItemGroup>
-  <ItemGroup Condition="'$(TargetFramework)' == 'net461'">
-    <Reference Include="System.Security" />
-  </ItemGroup>
   <ItemGroup>
     <Compile Condition="'$(TargetFramework)' != 'net461'" Include="System.Security.Cryptography.Xml.cs" />
     <Compile Condition="'$(TargetFramework)' == 'net461'" Include="System.Security.Cryptography.Xml.net461.cs" />
   </ItemGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == '$(NetCoreAppCurrent)'">
+    <ProjectReference Include="$(LibrariesProjectRoot)System.Security.AccessControl\ref\System.Security.AccessControl.csproj" />
+    <ProjectReference Include="$(LibrariesProjectRoot)System.Security.Cryptography.Primitives\ref\System.Security.Cryptography.Primitives.csproj" />
+    <ProjectReference Include="$(LibrariesProjectRoot)System.Security.Cryptography.X509Certificates\ref\System.Security.Cryptography.X509Certificates.csproj" />
+    <ProjectReference Include="$(LibrariesProjectRoot)System.Xml.ReaderWriter\ref\System.Xml.ReaderWriter.csproj" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">
+    <ProjectReference Include="$(LibrariesProjectRoot)System.Security.Permissions\ref\System.Security.Permissions.csproj" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == 'net461'">
+    <Reference Include="System.Security" />
+  </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/src/libraries/System.Security.Cryptography.Xml/src/MatchingRefApiCompatBaseline.netstandard2.0.txt b/src/libraries/System.Security.Cryptography.Xml/src/MatchingRefApiCompatBaseline.txt
similarity index 100%
rename from src/libraries/System.Security.Cryptography.Xml/src/MatchingRefApiCompatBaseline.netstandard2.0.txt
rename to src/libraries/System.Security.Cryptography.Xml/src/MatchingRefApiCompatBaseline.txt
diff --git a/src/libraries/System.Security.Cryptography.Xml/src/System.Security.Cryptography.Xml.csproj b/src/libraries/System.Security.Cryptography.Xml/src/System.Security.Cryptography.Xml.csproj
index 1f9a8ba6b4d842..0f93321b0748df 100644
--- a/src/libraries/System.Security.Cryptography.Xml/src/System.Security.Cryptography.Xml.csproj
+++ b/src/libraries/System.Security.Cryptography.Xml/src/System.Security.Cryptography.Xml.csproj
@@ -1,11 +1,11 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <TargetFrameworks>netstandard2.0;net461</TargetFrameworks>
+    <TargetFrameworks>$(NetCoreAppCurrent);netstandard2.0;net461</TargetFrameworks>
   </PropertyGroup>
   <!-- DesignTimeBuild requires all the TargetFramework Derived Properties to not be present in the first property group. -->
   <PropertyGroup>
-    <IsPartialFacadeAssembly Condition="$(TargetFramework.StartsWith('net4'))">true</IsPartialFacadeAssembly>
+    <IsPartialFacadeAssembly Condition="'$(TargetFramework)' == 'net461'">true</IsPartialFacadeAssembly>
   </PropertyGroup>
   <ItemGroup Condition="'$(IsPartialFacadeAssembly)' != 'true'">
     <Compile Include="System\Security\Cryptography\Xml\AncestralNamespaceContextManager.cs" />
@@ -87,11 +87,32 @@
     <Compile Include="$(CommonPath)System\HexConverter.cs"
              Link="Common\System\HexConverter.cs" />
   </ItemGroup>
-  <ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">
-    <PackageReference Include="System.Memory" Version="$(SystemMemoryVersion)" />
+  <ItemGroup Condition="'$(IsPartialFacadeAssembly)' != 'true'">
     <ProjectReference Include="$(LibrariesProjectRoot)System.Security.Cryptography.Pkcs\src\System.Security.Cryptography.Pkcs.csproj" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == '$(NetCoreAppCurrent)'">
+    <Reference Include="System.Collections" />
+    <Reference Include="System.Collections.NonGeneric" />
+    <Reference Include="System.Diagnostics.TraceSource" />
+    <Reference Include="System.Net.Requests" />
+    <Reference Include="System.Runtime" />
+    <Reference Include="System.Runtime.Numerics" />
+    <Reference Include="System.Security.AccessControl" />
+    <Reference Include="System.Security.Cryptography.Algorithms" />
+    <Reference Include="System.Security.Cryptography.Csp" />
+    <Reference Include="System.Security.Cryptography.Encoding" />
+    <Reference Include="System.Security.Cryptography.Primitives" />
+    <Reference Include="System.Security.Cryptography.X509Certificates" />
+    <Reference Include="System.Text.Encoding.Extensions" />
+    <Reference Include="System.Xml.ReaderWriter" />
+    <Reference Include="System.Xml.XPath" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">
+    <ProjectReference Include="$(LibrariesProjectRoot)System.Security.Permissions\src\System.Security.Permissions.csproj" />
     <ProjectReference Include="$(LibrariesProjectRoot)System.Runtime.CompilerServices.Unsafe\src\System.Runtime.CompilerServices.Unsafe.ilproj" />
-    <ProjectReference Include="$(LibrariesProjectRoot)System.Security.AccessControl\src\System.Security.AccessControl.csproj" />
+    <!-- Manually reference the transitive dependency to make NuGet pick the package over the transitive project: https://github.com/NuGet/Home/issues/10368 -->
+    <PackageReference Include="System.Memory" Version="$(SystemMemoryVersion)" />
+    <PackageReference Include="System.Numerics.Vectors" Version="$(SystemNumericsVectorsVersion)" />
   </ItemGroup>
   <ItemGroup Condition="'$(IsPartialFacadeAssembly)' == 'true'">
     <Reference Include="System.Security" />
diff --git a/src/libraries/System.Security.Cryptography.Xml/src/System/Security/Cryptography/Xml/CryptoHelpers.cs b/src/libraries/System.Security.Cryptography.Xml/src/System/Security/Cryptography/Xml/CryptoHelpers.cs
index fb86b4c4b82847..0f9365f9e01642 100644
--- a/src/libraries/System.Security.Cryptography.Xml/src/System/Security/Cryptography/Xml/CryptoHelpers.cs
+++ b/src/libraries/System.Security.Cryptography.Xml/src/System/Security/Cryptography/Xml/CryptoHelpers.cs
@@ -22,7 +22,9 @@ public static object CreateFromKnownName(string name) =>
                 "urn:mpeg:mpeg21:2003:01-REL-R-NS:licenseTransform" => new XmlLicenseTransform(),
                 "http://www.w3.org/2000/09/xmldsig# X509Data" => new KeyInfoX509Data(),
                 "http://www.w3.org/2000/09/xmldsig# KeyName" => new KeyInfoName(),
+#pragma warning disable CA1416 // This call site is reachable on all platforms. 'DSAKeyValue' is unsupported on: 'ios', 'maccatalyst', 'tvos'
                 "http://www.w3.org/2000/09/xmldsig# KeyValue/DSAKeyValue" => new DSAKeyValue(),
+#pragma warning restore CA1416
                 "http://www.w3.org/2000/09/xmldsig# KeyValue/RSAKeyValue" => new RSAKeyValue(),
                 "http://www.w3.org/2000/09/xmldsig# RetrievalMethod" => new KeyInfoRetrievalMethod(),
                 "http://www.w3.org/2001/04/xmlenc# EncryptedKey" => new KeyInfoEncryptedKey(),
diff --git a/src/libraries/System.Security.Cryptography.Xml/src/System/Security/Cryptography/Xml/EncryptedXml.cs b/src/libraries/System.Security.Cryptography.Xml/src/System/Security/Cryptography/Xml/EncryptedXml.cs
index 7762ff97c7f5aa..78786591c25c50 100644
--- a/src/libraries/System.Security.Cryptography.Xml/src/System/Security/Cryptography/Xml/EncryptedXml.cs
+++ b/src/libraries/System.Security.Cryptography.Xml/src/System/Security/Cryptography/Xml/EncryptedXml.cs
@@ -546,13 +546,15 @@ public EncryptedData Encrypt(XmlElement inputElement, X509Certificate2 certifica
                 ek.KeyInfo.AddClause(new KeyInfoX509Data(certificate));
 
                 // Create a random AES session key and encrypt it with the public key associated with the certificate.
-                RijndaelManaged rijn = new RijndaelManaged();
-                ek.CipherData.CipherValue = EncryptedXml.EncryptKey(rijn.Key, rsaPublicKey, false);
+                using (Aes aes = Aes.Create())
+                {
+                    ek.CipherData.CipherValue = EncryptedXml.EncryptKey(aes.Key, rsaPublicKey, false);
 
-                // Encrypt the input element with the random session key that we've created above.
-                KeyInfoEncryptedKey kek = new KeyInfoEncryptedKey(ek);
-                ed.KeyInfo.AddClause(kek);
-                ed.CipherData.CipherValue = EncryptData(inputElement, rijn, false);
+                    // Encrypt the input element with the random session key that we've created above.
+                    KeyInfoEncryptedKey kek = new KeyInfoEncryptedKey(ek);
+                    ed.KeyInfo.AddClause(kek);
+                    ed.CipherData.CipherValue = EncryptData(inputElement, aes, false);
+                }
 
                 return ed;
             }
@@ -595,7 +597,9 @@ public EncryptedData Encrypt(XmlElement inputElement, string keyName)
                 // CMS Triple DES Key Wrap
                 encryptionMethod = EncryptedXml.XmlEncTripleDESKeyWrapUrl;
             }
+#pragma warning disable SYSLIB0022 // Rijndael types are obsolete
             else if (symKey is Rijndael || symKey is Aes)
+#pragma warning restore SYSLIB0022
             {
                 // FIPS AES Key Wrap
                 switch (symKey.KeySize)
@@ -621,13 +625,15 @@ public EncryptedData Encrypt(XmlElement inputElement, string keyName)
             ek.KeyInfo.AddClause(new KeyInfoName(keyName));
 
             // Create a random AES session key and encrypt it with the public key associated with the certificate.
-            RijndaelManaged rijn = new RijndaelManaged();
-            ek.CipherData.CipherValue = (symKey == null ? EncryptedXml.EncryptKey(rijn.Key, rsa, false) : EncryptedXml.EncryptKey(rijn.Key, symKey));
+            using (Aes aes = Aes.Create())
+            {
+                ek.CipherData.CipherValue = (symKey == null ? EncryptedXml.EncryptKey(aes.Key, rsa, false) : EncryptedXml.EncryptKey(aes.Key, symKey));
 
-            // Encrypt the input element with the random session key that we've created above.
-            KeyInfoEncryptedKey kek = new KeyInfoEncryptedKey(ek);
-            ed.KeyInfo.AddClause(kek);
-            ed.CipherData.CipherValue = EncryptData(inputElement, rijn, false);
+                // Encrypt the input element with the random session key that we've created above.
+                KeyInfoEncryptedKey kek = new KeyInfoEncryptedKey(ek);
+                ed.KeyInfo.AddClause(kek);
+                ed.CipherData.CipherValue = EncryptData(inputElement, aes, false);
+            }
 
             return ed;
         }
@@ -868,7 +874,9 @@ public static byte[] EncryptKey(byte[] keyData, SymmetricAlgorithm symmetricAlgo
                 // CMS Triple DES Key Wrap
                 return SymmetricKeyWrap.TripleDESKeyWrapEncrypt(symmetricAlgorithm.Key, keyData);
             }
+#pragma warning disable SYSLIB0022 // Rijndael types are obsolete
             else if (symmetricAlgorithm is Rijndael || symmetricAlgorithm is Aes)
+#pragma warning restore SYSLIB0022
             {
                 // FIPS AES Key Wrap
                 return SymmetricKeyWrap.AESKeyWrapEncrypt(symmetricAlgorithm.Key, keyData);
@@ -912,7 +920,9 @@ public static byte[] DecryptKey(byte[] keyData, SymmetricAlgorithm symmetricAlgo
                 // CMS Triple DES Key Wrap
                 return SymmetricKeyWrap.TripleDESKeyWrapDecrypt(symmetricAlgorithm.Key, keyData);
             }
+#pragma warning disable SYSLIB0022 // Rijndael types are obsolete
             else if (symmetricAlgorithm is Rijndael || symmetricAlgorithm is Aes)
+#pragma warning restore SYSLIB0022
             {
                 // FIPS AES Key Wrap
                 return SymmetricKeyWrap.AESKeyWrapDecrypt(symmetricAlgorithm.Key, keyData);
diff --git a/src/libraries/System.Security.Cryptography.Xml/src/System/Security/Cryptography/Xml/SignedXmlDebugLog.cs b/src/libraries/System.Security.Cryptography.Xml/src/System/Security/Cryptography/Xml/SignedXmlDebugLog.cs
index 88333153fd4e73..5f7a5090097e92 100644
--- a/src/libraries/System.Security.Cryptography.Xml/src/System/Security/Cryptography/Xml/SignedXmlDebugLog.cs
+++ b/src/libraries/System.Security.Cryptography.Xml/src/System/Security/Cryptography/Xml/SignedXmlDebugLog.cs
@@ -220,10 +220,12 @@ private static string GetKeyName(object key)
             //
 
             string keyName = null;
+#pragma warning disable CA1416 // This call site is reachable on all platforms. 'CspKeyContainerInfo.KeyContainerName' is supported on: 'windows'.
             if (cspKey != null && cspKey.CspKeyContainerInfo.KeyContainerName != null)
             {
                 keyName = "\"" + cspKey.CspKeyContainerInfo.KeyContainerName + "\"";
             }
+#pragma warning restore CA1416
             else if (certificate2 != null)
             {
                 keyName = "\"" + certificate2.GetNameInfo(X509NameType.SimpleName, false) + "\"";
diff --git a/src/libraries/System.Security.Permissions/ref/System.Security.Permissions.Forwards.cs b/src/libraries/System.Security.Permissions/ref/System.Security.Permissions.Forwards.cs
index 4d9a824761f533..ef7cb3ac3f7348 100644
--- a/src/libraries/System.Security.Permissions/ref/System.Security.Permissions.Forwards.cs
+++ b/src/libraries/System.Security.Permissions/ref/System.Security.Permissions.Forwards.cs
@@ -13,8 +13,10 @@
 [assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Security.Permissions.SecurityAttribute))]
 [assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Security.Permissions.SecurityPermissionAttribute))]
 [assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Security.Permissions.SecurityPermissionFlag))]
+#if NET6_0_OR_GREATER
 [assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Security.Policy.Evidence))]
 [assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Security.Policy.EvidenceBase))]
+#endif
 #if NETCOREAPP
 [assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Security.IStackWalk))]
 [assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Security.PermissionSet))]
diff --git a/src/libraries/System.Security.Permissions/ref/System.Security.Permissions.csproj b/src/libraries/System.Security.Permissions/ref/System.Security.Permissions.csproj
index 48ec64222b7aab..278fb397b8d095 100644
--- a/src/libraries/System.Security.Permissions/ref/System.Security.Permissions.csproj
+++ b/src/libraries/System.Security.Permissions/ref/System.Security.Permissions.csproj
@@ -1,11 +1,12 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFrameworks>net5.0;netcoreapp3.1;netstandard2.0;net461</TargetFrameworks>
+    <TargetFrameworks>$(NetCoreAppCurrent);net5.0;netcoreapp3.1;netstandard2.0;net461</TargetFrameworks>
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="System.Security.Permissions.cs" Condition="'$(TargetFramework)' != 'net461'" />
     <Compile Include="System.Security.Permissions.Forwards.cs" Condition="'$(TargetFramework)' != 'net461'" />
     <Compile Include="System.Security.Permissions.netcoreapp.cs" Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp'" />
+    <Compile Include="$(LibrariesProjectRoot)System.Security.AccessControl\ref\System.Security.AccessControl.Evidence.cs" Condition="'$(TargetFramework)' != 'net461' and !$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net6.0'))" />
     <Compile Include="System.Security.Permissions.net461.cs" Condition="'$(TargetFramework)' == 'net461'" />
   </ItemGroup>
   <ItemGroup Condition="'$(TargetFramework)' == 'net461'">
@@ -18,26 +19,21 @@
     <Reference Include="System.Xaml" />
     <Reference Include="WindowsBase" />
   </ItemGroup>
-  <ItemGroup Condition="'$(TargetFramework)' != 'net461'">
-    <ProjectReference Include="$(LibrariesProjectRoot)System.Security.AccessControl\ref\System.Security.AccessControl.csproj" />
+  <ItemGroup Condition="'$(TargetFramework)' != 'net461' and !$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net6.0'))">
+    <PackageReference Include="System.Security.AccessControl" Version="$(SystemSecurityAccessControlVersion)" />
+    <!-- Manually reference the transitive dependency to make NuGet pick the package over the transitive project. -->
+    <PackageReference Include="System.Security.Principal.Windows" Version="$(SystemSecurityPrincipalWindowsVersion)" />
   </ItemGroup>
   <ItemGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp'">
     <ProjectReference Include="$(LibrariesProjectRoot)System.Windows.Extensions\ref\System.Windows.Extensions.csproj" />
   </ItemGroup>
   <ItemGroup Condition="'$(TargetFramework)' == '$(NetCoreAppCurrent)'">
-    <ProjectReference Include="$(LibrariesProjectRoot)System.Collections.NonGeneric\ref\System.Collections.NonGeneric.csproj" />
-    <ProjectReference Include="$(LibrariesProjectRoot)System.ComponentModel.Primitives\ref\System.ComponentModel.Primitives.csproj" />
     <ProjectReference Include="$(LibrariesProjectRoot)System.Data.Common\ref\System.Data.Common.csproj" />
-    <ProjectReference Include="$(LibrariesProjectRoot)System.Runtime\ref\System.Runtime.csproj" />
-    <ProjectReference Include="$(LibrariesProjectRoot)System.Runtime.Extensions\ref\System.Runtime.Extensions.csproj" />
-    <ProjectReference Include="$(LibrariesProjectRoot)System.Security.Cryptography.Algorithms\ref\System.Security.Cryptography.Algorithms.csproj" />
+    <ProjectReference Include="$(LibrariesProjectRoot)System.Security.AccessControl\ref\System.Security.AccessControl.csproj" />
     <ProjectReference Include="$(LibrariesProjectRoot)System.Security.Cryptography.Csp\ref\System.Security.Cryptography.Csp.csproj" />
-    <ProjectReference Include="$(LibrariesProjectRoot)System.Security.Cryptography.Primitives\ref\System.Security.Cryptography.Primitives.csproj" />
-    <ProjectReference Include="$(LibrariesProjectRoot)System.Security.Cryptography.X509Certificates\ref\System.Security.Cryptography.X509Certificates.csproj" />
     <ProjectReference Include="$(LibrariesProjectRoot)System.Text.RegularExpressions\ref\System.Text.RegularExpressions.csproj" />
-    <ProjectReference Include="$(LibrariesProjectRoot)System.Threading\ref\System.Threading.csproj" />
   </ItemGroup>
-  <ItemGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp'">
+  <ItemGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp' and '$(TargetFramework)' != '$(NetCoreAppCurrent)'">
     <Reference Include="netstandard" />
     <Reference Include="System.Collections.NonGeneric" />
     <Reference Include="System.ComponentModel.Primitives" />
diff --git a/src/libraries/System.Security.Permissions/src/System.Security.Permissions.csproj b/src/libraries/System.Security.Permissions/src/System.Security.Permissions.csproj
index 9fc55eece247cf..9b52b0725b35a6 100644
--- a/src/libraries/System.Security.Permissions/src/System.Security.Permissions.csproj
+++ b/src/libraries/System.Security.Permissions/src/System.Security.Permissions.csproj
@@ -2,7 +2,6 @@
   <PropertyGroup>
     <IsPartialFacadeAssembly>true</IsPartialFacadeAssembly>
     <TargetFrameworks>$(NetCoreAppCurrent);net5.0;netcoreapp3.1;netstandard2.0;net461</TargetFrameworks>
-    <ExcludeCurrentNetCoreAppFromPackage>true</ExcludeCurrentNetCoreAppFromPackage>
   </PropertyGroup>
   <ItemGroup Condition="'$(TargetFramework)' != 'net461'">
     <Compile Include="System\ApplicationIdentity.cs" />
@@ -131,6 +130,8 @@
     <Compile Include="System\Security\Policy\ApplicationVersionMatch.cs" />
     <Compile Include="System\Security\Policy\CodeConnectAccess.cs" />
     <Compile Include="System\Security\Policy\CodeGroup.cs" />
+    <Compile Include="$(LibrariesProjectRoot)System.Security.AccessControl\src\System\Security\Policy\Evidence.cs" Condition="!$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net6.0'))" />
+    <Compile Include="$(LibrariesProjectRoot)System.Security.AccessControl\src\System\Security\Policy\EvidenceBase.cs" Condition="!$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net6.0'))" />
     <Compile Include="System\Security\Policy\FileCodeGroup.cs" />
     <Compile Include="System\Security\Policy\FirstMatchCodeGroup.cs" />
     <Compile Include="System\Security\Policy\GacInstalled.cs" />
@@ -199,11 +200,12 @@
     <Reference Include="System.Xaml" />
     <Reference Include="WindowsBase" />
   </ItemGroup>
-  <ItemGroup Condition="'$(TargetFramework)' != 'net461'">
-    <ProjectReference Include="$(LibrariesProjectRoot)System.Security.AccessControl\src\System.Security.AccessControl.csproj" />
+  <ItemGroup Condition="'$(TargetFramework)' != 'net461' and !$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net6.0'))">
+    <PackageReference Include="System.Security.AccessControl" Version="$(SystemSecurityAccessControlVersion)" />
   </ItemGroup>
   <ItemGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp'">
     <ProjectReference Include="$(LibrariesProjectRoot)System.Windows.Extensions\src\System.Windows.Extensions.csproj" />
+    <Reference Include="netstandard" Condition="'$(TargetFramework)' != '$(NetCoreAppCurrent)'" />
     <Reference Include="System.Collections" />
     <Reference Include="System.Collections.NonGeneric" />
     <Reference Include="System.ComponentModel.Primitives" />
@@ -211,6 +213,7 @@
     <Reference Include="System.Resources.ResourceManager" />
     <Reference Include="System.Runtime" />
     <Reference Include="System.Runtime.Extensions" />
+    <Reference Include="System.Security.AccessControl" Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net6.0'))" />
     <Reference Include="System.Security.Cryptography.Algorithms" />
     <Reference Include="System.Security.Cryptography.Csp" />
     <Reference Include="System.Security.Cryptography.Primitives" />
diff --git a/src/libraries/System.Security.Permissions/tests/MembershipConditionTests.cs b/src/libraries/System.Security.Permissions/tests/MembershipConditionTests.cs
index d2714f5a3b6037..62703d868cc338 100644
--- a/src/libraries/System.Security.Permissions/tests/MembershipConditionTests.cs
+++ b/src/libraries/System.Security.Permissions/tests/MembershipConditionTests.cs
@@ -82,7 +82,7 @@ public static void HashMembershipConditionCallMethods()
         [SkipOnPlatform(TestPlatforms.Browser, "System.Security.Cryptography.X509Certificates is not supported on this platform.")]
         public static void PublisherMembershipConditionCallMethods()
         {
-            PublisherMembershipCondition pmc = new PublisherMembershipCondition(new System.Security.Cryptography.X509Certificates.X509Certificate());
+            PublisherMembershipCondition pmc = new PublisherMembershipCondition(new System.Security.Cryptography.X509Certificates.X509Certificate2(stackalloc byte[0]));
             bool check = pmc.Check(new Evidence());
             IMembershipCondition obj = pmc.Copy();
             check = pmc.Equals(new object());
diff --git a/src/libraries/System.Security.Permissions/tests/PermissionTests.cs b/src/libraries/System.Security.Permissions/tests/PermissionTests.cs
index af714344d0dbd2..daa9d8ac55ae60 100644
--- a/src/libraries/System.Security.Permissions/tests/PermissionTests.cs
+++ b/src/libraries/System.Security.Permissions/tests/PermissionTests.cs
@@ -213,7 +213,7 @@ public static void PrincipalPermissionCallMethods()
         [SkipOnPlatform(TestPlatforms.Browser, "System.Security.Cryptography.X509Certificates is not supported on this platform.")]
         public static void PublisherIdentityPermissionCallMethods()
         {
-            PublisherIdentityPermission pip = new PublisherIdentityPermission(new System.Security.Cryptography.X509Certificates.X509Certificate());
+            PublisherIdentityPermission pip = new PublisherIdentityPermission(new System.Security.Cryptography.X509Certificates.X509Certificate2(stackalloc byte[0]));
             PublisherIdentityPermission pip2 = new PublisherIdentityPermission(new Permissions.PermissionState());
             IPermission ip = pip.Copy();
             IPermission ip2 = pip.Intersect(ip);
diff --git a/src/libraries/System.Security.Principal.Windows/Directory.Build.props b/src/libraries/System.Security.Principal.Windows/Directory.Build.props
index b08e4ac5e46c1e..709a22a7537088 100644
--- a/src/libraries/System.Security.Principal.Windows/Directory.Build.props
+++ b/src/libraries/System.Security.Principal.Windows/Directory.Build.props
@@ -2,18 +2,6 @@
   <Import Project="..\Directory.Build.props" />
   <PropertyGroup>
     <StrongNameKeyId>Microsoft</StrongNameKeyId>
-    <IsAspNetCoreApp>true</IsAspNetCoreApp>
     <SupportedOSPlatforms>windows</SupportedOSPlatforms>
-    <PackageDescription>Provides classes for retrieving the current Windows user and for interacting with Windows users and groups.
-
-Commonly Used Types:
-System.Security.Principal.WindowsIdentity
-System.Security.Principal.SecurityIdentifier
-System.Security.Principal.NTAccount
-System.Security.Principal.WindowsPrincipal
-System.Security.Principal.IdentityReference
-System.Security.Principal.IdentityNotMappedException
-System.Security.Principal.WindowsBuiltInRole
-System.Security.Principal.WellKnownSidType</PackageDescription>
   </PropertyGroup>
 </Project>
\ No newline at end of file
diff --git a/src/libraries/System.Security.Principal.Windows/NuGet.config b/src/libraries/System.Security.Principal.Windows/NuGet.config
deleted file mode 100644
index a66b7f9b013241..00000000000000
--- a/src/libraries/System.Security.Principal.Windows/NuGet.config
+++ /dev/null
@@ -1,12 +0,0 @@
-<configuration>
-  <!-- This disables restore in VS for projects that target platform specific target frameworks older than net5.0. -->
-  <packageRestore>
-    <!-- The 'automatic' key is set to True when the "Automatically check for missing packages during
-         build in Visual Studio" checkbox is set. Clearing the box sets this to False and disables
-         automatic restore. -->
-    <add key="automatic" value="False" />
-    <!-- The 'enabled' key is True when the "Allow NuGet to download missing packages" checkbox is set.
-         Clearing the box sets this to False, disabling command-line, automatic, and MSBuild-integrated restore. -->
-    <add key="enabled" value="False" />
-  </packageRestore>
-</configuration>
\ No newline at end of file
diff --git a/src/libraries/System.Security.Principal.Windows/pkg/System.Security.Principal.Windows.pkgproj b/src/libraries/System.Security.Principal.Windows/pkg/System.Security.Principal.Windows.pkgproj
deleted file mode 100644
index 51b8f66f72d9ac..00000000000000
--- a/src/libraries/System.Security.Principal.Windows/pkg/System.Security.Principal.Windows.pkgproj
+++ /dev/null
@@ -1,13 +0,0 @@
-<Project DefaultTargets="Build">
-  <Import Project="$([MSBuild]::GetPathOfFileAbove(Directory.Build.props))" />
-  <ItemGroup>
-    <ProjectReference Include="..\ref\System.Security.Principal.Windows.csproj">
-      <SupportedFramework>net461;netcoreapp2.0;uap10.0.16299;$(AllXamarinFrameworks)</SupportedFramework>
-    </ProjectReference>
-    <ProjectReference Include="..\src\System.Security.Principal.Windows.csproj" />
-    <!-- Exclude TFMs that aren't supported by the package anymore from validation. -->
-    <ExcludeHarvestedSupportedFramework Include="netcoreapp1.0;netcoreapp1.1;netcore50;uap10.0;net46" />
-    <NETStandardCompatError Include="netcoreapp2.0" Supported="netcoreapp3.1" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetPathOfFileAbove(Directory.Build.targets))" />
-</Project>
\ No newline at end of file
diff --git a/src/libraries/System.Security.Principal.Windows/ref/System.Security.Principal.Windows.csproj b/src/libraries/System.Security.Principal.Windows/ref/System.Security.Principal.Windows.csproj
index 401c7aecccd53b..955e29d0da1ff5 100644
--- a/src/libraries/System.Security.Principal.Windows/ref/System.Security.Principal.Windows.csproj
+++ b/src/libraries/System.Security.Principal.Windows/ref/System.Security.Principal.Windows.csproj
@@ -1,21 +1,14 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFrameworks>$(NetCoreAppCurrent);netcoreapp3.1;netstandard2.0;net461</TargetFrameworks>
-    <ExcludeCurrentNetCoreAppFromPackage>true</ExcludeCurrentNetCoreAppFromPackage>
+    <TargetFrameworks>$(NetCoreAppCurrent)</TargetFrameworks>
     <Nullable>enable</Nullable>
   </PropertyGroup>
   <ItemGroup>
-    <Compile Include="System.Security.Principal.Windows.cs" Condition="'$(TargetFramework)' != 'net461'" />
-    <Compile Include="System.Security.Principal.Windows.net461.cs" Condition="'$(TargetFramework)' == 'net461'" />
+    <Compile Include="System.Security.Principal.Windows.cs" />
   </ItemGroup>
-  <ItemGroup Condition="'$(TargetFramework)' == '$(NetCoreAppCurrent)'">
+  <ItemGroup>
     <ProjectReference Include="$(LibrariesProjectRoot)System.Runtime\ref\System.Runtime.csproj" />
     <ProjectReference Include="$(LibrariesProjectRoot)System.Security.Claims\ref\System.Security.Claims.csproj" />
     <ProjectReference Include="$(LibrariesProjectRoot)System.Security.Principal\ref\System.Security.Principal.csproj" />
   </ItemGroup>
-  <ItemGroup Condition="'$(TargetFramework)' == 'netcoreapp3.1'">
-    <Reference Include="System.Runtime" />
-    <Reference Include="System.Security.Claims" />
-    <Reference Include="System.Security.Principal" />
-  </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/src/libraries/System.Security.Principal.Windows/ref/System.Security.Principal.Windows.net461.cs b/src/libraries/System.Security.Principal.Windows/ref/System.Security.Principal.Windows.net461.cs
deleted file mode 100644
index d29b0e76555c83..00000000000000
--- a/src/libraries/System.Security.Principal.Windows/ref/System.Security.Principal.Windows.net461.cs
+++ /dev/null
@@ -1,20 +0,0 @@
-// 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.
-// ------------------------------------------------------------------------------
-
-using System.Runtime.CompilerServices;
-
-[assembly: TypeForwardedTo(typeof(System.Security.Principal.IdentityNotMappedException))]
-[assembly: TypeForwardedTo(typeof(System.Security.Principal.IdentityReference))]
-[assembly: TypeForwardedTo(typeof(System.Security.Principal.IdentityReferenceCollection))]
-[assembly: TypeForwardedTo(typeof(System.Security.Principal.NTAccount))]
-[assembly: TypeForwardedTo(typeof(System.Security.Principal.SecurityIdentifier))]
-[assembly: TypeForwardedTo(typeof(System.Security.Principal.TokenAccessLevels))]
-[assembly: TypeForwardedTo(typeof(System.Security.Principal.WellKnownSidType))]
-[assembly: TypeForwardedTo(typeof(System.Security.Principal.WindowsAccountType))]
-[assembly: TypeForwardedTo(typeof(System.Security.Principal.WindowsBuiltInRole))]
-[assembly: TypeForwardedTo(typeof(System.Security.Principal.WindowsIdentity))]
-[assembly: TypeForwardedTo(typeof(System.Security.Principal.WindowsPrincipal))]
-[assembly: TypeForwardedTo(typeof(Microsoft.Win32.SafeHandles.SafeAccessTokenHandle))]
diff --git a/src/libraries/System.Security.Principal.Windows/src/System.Security.Principal.Windows.csproj b/src/libraries/System.Security.Principal.Windows/src/System.Security.Principal.Windows.csproj
index 9cd81f55f9fa20..60b6dfd35510bc 100644
--- a/src/libraries/System.Security.Principal.Windows/src/System.Security.Principal.Windows.csproj
+++ b/src/libraries/System.Security.Principal.Windows/src/System.Security.Principal.Windows.csproj
@@ -1,16 +1,11 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <TargetFrameworks>$(NetCoreAppCurrent)-windows;$(NetCoreAppCurrent)-Unix;netcoreapp3.1-windows;netcoreapp3.1-Unix;netstandard2.0-windows;netstandard2.0-Unix;netstandard2.0;net461-windows</TargetFrameworks>
-    <ExcludeCurrentNetCoreAppFromPackage>true</ExcludeCurrentNetCoreAppFromPackage>
+    <TargetFrameworks>$(NetCoreAppCurrent)-windows;$(NetCoreAppCurrent)-Unix;$(NetCoreAppCurrent)</TargetFrameworks>
     <Nullable>enable</Nullable>
   </PropertyGroup>
-  <!-- DesignTimeBuild requires all the TargetFramework Derived Properties to not be present in the first property group. -->
-  <PropertyGroup>
-    <IsPartialFacadeAssembly Condition="$(TargetFramework.StartsWith('net4'))">true</IsPartialFacadeAssembly>
-    <OmitResources Condition="$(TargetFramework.StartsWith('net4'))">true</OmitResources>
-  </PropertyGroup>
 
+  <!-- DesignTimeBuild requires all the TargetFramework Derived Properties to not be present in the first property group. -->
   <PropertyGroup Condition="'$(TargetsWindows)' != 'true'">
     <GeneratePlatformNotSupportedAssemblyMessage>SR.PlatformNotSupported_Principal</GeneratePlatformNotSupportedAssemblyMessage>
     <!-- Work around 'notsupported.cs' source generation of explicit interface implementations issue -->
@@ -18,7 +13,7 @@
     <Nullable>annotations</Nullable>
   </PropertyGroup>
 
-  <ItemGroup Condition="'$(IsPartialFacadeAssembly)' != 'true' and '$(TargetsWindows)' == 'true'">
+  <ItemGroup Condition="'$(TargetsWindows)' == 'true'">
     <Compile Include="Microsoft\Win32\SafeHandles\SafeAccessTokenHandle.cs" />
     <Compile Include="System\Security\Principal\IdentityNotMappedException.cs" />
     <Compile Include="System\Security\Principal\IdentityReference.cs" />
@@ -136,7 +131,7 @@
     <Compile Include="$(CommonPath)Interop\Windows\Advapi32\Interop.CheckTokenMembership.cs"
              Link="Common\Interop\Interop.CheckTokenMembership.cs" />
   </ItemGroup>
-  <ItemGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp'">
+  <ItemGroup>
     <Reference Include="Microsoft.Win32.Primitives" />
     <Reference Include="System.Collections" />
     <Reference Include="System.Diagnostics.Debug" />
diff --git a/src/libraries/System.Security.Principal.Windows/src/System/Security/Principal/SID.cs b/src/libraries/System.Security.Principal.Windows/src/System/Security/Principal/SID.cs
index 63906bad4dbc2a..025e1c8ef1c7b8 100644
--- a/src/libraries/System.Security.Principal.Windows/src/System/Security/Principal/SID.cs
+++ b/src/libraries/System.Security.Principal.Windows/src/System/Security/Principal/SID.cs
@@ -314,11 +314,7 @@ public sealed class SecurityIdentifier : IdentityReference, IComparable<Security
 
         [MemberNotNull(nameof(_binaryForm))]
         [MemberNotNull(nameof(_subAuthorities))]
-#if NETSTANDARD2_0
-        private void CreateFromParts(IdentifierAuthority identifierAuthority, int[] subAuthorities)
-#else
         private void CreateFromParts(IdentifierAuthority identifierAuthority, ReadOnlySpan<int> subAuthorities)
-#endif
         {
             //
             // Check the number of subauthorities passed in
@@ -350,11 +346,7 @@ private void CreateFromParts(IdentifierAuthority identifierAuthority, ReadOnlySp
             //
 
             _identifierAuthority = identifierAuthority;
-#if NETSTANDARD2_0
-            _subAuthorities = (int[])subAuthorities.Clone();
-#else
             _subAuthorities = subAuthorities.ToArray();
-#endif
 
             //
             // Compute and store the binary form
@@ -462,12 +454,7 @@ private void CreateFromBinaryForm(byte[] binaryForm, int offset)
                 throw new ArgumentException(SR.ArgumentOutOfRange_ArrayTooSmall, nameof(binaryForm));
             }
 
-#if NETSTANDARD2_0
-            int[] subAuthorities = new int[subAuthoritiesLength];
-#else
             Span<int> subAuthorities = stackalloc int[MaxSubAuthorities];
-#endif
-
             IdentifierAuthority authority = (IdentifierAuthority)(
                 (((long)binaryForm[offset + 2]) << 40) +
                 (((long)binaryForm[offset + 3]) << 32) +
@@ -494,11 +481,7 @@ private void CreateFromBinaryForm(byte[] binaryForm, int offset)
 
             CreateFromParts(
                 authority,
-#if NETSTANDARD2_0
-                subAuthorities
-#else
                 subAuthorities.Slice(0, subAuthoritiesLength)
-#endif
             );
 
             return;
@@ -657,11 +640,7 @@ public SecurityIdentifier(WellKnownSidType sidType, SecurityIdentifier? domainSi
             CreateFromBinaryForm(resultSid!, 0);
         }
 
-#if NETSTANDARD2_0
-        internal SecurityIdentifier(IdentifierAuthority identifierAuthority, int[] subAuthorities)
-#else
         internal SecurityIdentifier(IdentifierAuthority identifierAuthority, ReadOnlySpan<int> subAuthorities)
-#endif
         {
             CreateFromParts(identifierAuthority, subAuthorities);
         }
@@ -748,15 +727,6 @@ public override string ToString()
                 // otherwise you would see this: "S-1-NTAuthority-32-544"
                 //
 
-#if NETSTANDARD2_0
-                StringBuilder result = new StringBuilder();
-                result.Append("S-1-").Append((ulong)_identifierAuthority);
-                for (int i = 0; i < SubAuthorityCount; i++)
-                {
-                    result.Append('-').Append((uint)(_subAuthorities[i]));
-                }
-                _sddlForm = result.ToString();
-#else
                 // length of buffer calculation
                 // prefix = "S-1-".Length: 4;
                 // authority: ulong.MaxValue.ToString("D") : 20;
@@ -779,7 +749,6 @@ public override string ToString()
                     length += written;
                 }
                 _sddlForm = result.Slice(0, length).ToString();
-#endif
             }
 
             return _sddlForm;
diff --git a/src/libraries/System.Security.Principal.Windows/src/System/Security/Principal/WindowsPrincipal.cs b/src/libraries/System.Security.Principal.Windows/src/System/Security/Principal/WindowsPrincipal.cs
index 4c76142ed362ac..ea6011b3f443c1 100644
--- a/src/libraries/System.Security.Principal.Windows/src/System/Security/Principal/WindowsPrincipal.cs
+++ b/src/libraries/System.Security.Principal.Windows/src/System/Security/Principal/WindowsPrincipal.cs
@@ -121,11 +121,7 @@ public virtual bool IsInRole(int rid)
             return IsInRole(
                 new SecurityIdentifier(
                     IdentifierAuthority.NTAuthority,
-#if NETSTANDARD2_0
-                    new
-#else
                     stackalloc
-#endif
                     int[] { Interop.SecurityIdentifier.SECURITY_BUILTIN_DOMAIN_RID, rid }
                 )
             );
diff --git a/src/libraries/System.Security.Principal.Windows/tests/System.Security.Principal.Windows.Tests.csproj b/src/libraries/System.Security.Principal.Windows/tests/System.Security.Principal.Windows.Tests.csproj
index a416eb154f72d7..aa42c6a8dcd2f1 100644
--- a/src/libraries/System.Security.Principal.Windows/tests/System.Security.Principal.Windows.Tests.csproj
+++ b/src/libraries/System.Security.Principal.Windows/tests/System.Security.Principal.Windows.Tests.csproj
@@ -1,13 +1,13 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <IncludeRemoteExecutor>true</IncludeRemoteExecutor>
-    <TargetFrameworks>$(NetCoreAppCurrent)-windows;net461-windows</TargetFrameworks>
+    <TargetFrameworks>$(NetCoreAppCurrent)-windows</TargetFrameworks>
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="NTAccount.cs" />
     <Compile Include="SecurityIdentifierTests.cs" />
     <Compile Include="WindowsIdentityTests.cs" />
-    <Compile Include="WindowsIdentityImpersonatedTests.netcoreapp.cs" Condition="$(TargetFramework.StartsWith('$(NetCoreAppCurrent)'))" />
+    <Compile Include="WindowsIdentityImpersonatedTests.netcoreapp.cs" />
     <Compile Include="WindowsPrincipalTests.cs" />
     <Compile Include="WellKnownSidTypeTests.cs" />
   </ItemGroup>
diff --git a/src/libraries/System.Security.Principal.Windows/tests/WellKnownSidTypeTests.cs b/src/libraries/System.Security.Principal.Windows/tests/WellKnownSidTypeTests.cs
index 045b4143285a64..3bea9267ff4b2d 100644
--- a/src/libraries/System.Security.Principal.Windows/tests/WellKnownSidTypeTests.cs
+++ b/src/libraries/System.Security.Principal.Windows/tests/WellKnownSidTypeTests.cs
@@ -85,7 +85,6 @@ public void CanCreateSecurityIdentifierFromWellKnownSidType(WellKnownSidType sid
         }
     }
 
-#if NETCOREAPP
     [ConditionalTheory(nameof(AccountIsDomainJoined))]
     [InlineData(WellKnownSidType.WinBuiltinDCOMUsersSid)]
     [InlineData(WellKnownSidType.WinBuiltinIUsersSid)]
@@ -144,7 +143,6 @@ public void CreatingSecurityIdentifierOutsideWellKnownSidTypeDefinedRangeThrowsE
         var currentDomainSid = WindowsIdentity.GetCurrent().Owner.AccountDomainSid;
         AssertExtensions.Throws<ArgumentException>("sidType", () => new SecurityIdentifier(sidType, currentDomainSid));
     }
-    #endif
 
     [Fact]
     public void MaxDefinedHasLegacyValue()
diff --git a/src/libraries/System.ServiceModel.Syndication/ref/System.ServiceModel.Syndication.csproj b/src/libraries/System.ServiceModel.Syndication/ref/System.ServiceModel.Syndication.csproj
index 67f51b77a86242..9826a5f94e9ba5 100644
--- a/src/libraries/System.ServiceModel.Syndication/ref/System.ServiceModel.Syndication.csproj
+++ b/src/libraries/System.ServiceModel.Syndication/ref/System.ServiceModel.Syndication.csproj
@@ -1,7 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <TargetFrameworks>$(NetCoreAppCurrent);netcoreapp3.1;netstandard2.0;net461</TargetFrameworks>
-    <ExcludeCurrentNetCoreAppFromPackage>true</ExcludeCurrentNetCoreAppFromPackage>
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="System.ServiceModel.Syndication.cs" Condition="'$(TargetFramework)' != 'net461'"/>
diff --git a/src/libraries/System.ServiceModel.Syndication/src/System.ServiceModel.Syndication.csproj b/src/libraries/System.ServiceModel.Syndication/src/System.ServiceModel.Syndication.csproj
index 86a03a3f7c2ec9..ecbd3de0f473c0 100644
--- a/src/libraries/System.ServiceModel.Syndication/src/System.ServiceModel.Syndication.csproj
+++ b/src/libraries/System.ServiceModel.Syndication/src/System.ServiceModel.Syndication.csproj
@@ -1,7 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <TargetFrameworks>$(NetCoreAppCurrent);netcoreapp3.1;netstandard2.0;net461-windows</TargetFrameworks>
-    <ExcludeCurrentNetCoreAppFromPackage>true</ExcludeCurrentNetCoreAppFromPackage>
     <IncludePlatformAttributes>true</IncludePlatformAttributes>
   </PropertyGroup>
   <!-- DesignTimeBuild requires all the TargetFramework Derived Properties to not be present in the first property group. -->
diff --git a/src/libraries/System.ServiceProcess.ServiceController/ref/System.ServiceProcess.ServiceController.csproj b/src/libraries/System.ServiceProcess.ServiceController/ref/System.ServiceProcess.ServiceController.csproj
index 57dffa178d8ea1..d9255a57f8a812 100644
--- a/src/libraries/System.ServiceProcess.ServiceController/ref/System.ServiceProcess.ServiceController.csproj
+++ b/src/libraries/System.ServiceProcess.ServiceController/ref/System.ServiceProcess.ServiceController.csproj
@@ -1,16 +1,25 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFrameworks>netstandard2.0;net461</TargetFrameworks>
+    <TargetFrameworks>$(NetCoreAppCurrent);netcoreapp3.1;netstandard2.0;net461</TargetFrameworks>
     <Nullable>enable</Nullable>
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="System.ServiceProcess.ServiceController.cs" Condition="'$(TargetFramework)' != 'net461'" />
     <Compile Include="System.ServiceProcess.ServiceController.net461.cs" Condition="'$(TargetFramework)' == 'net461'" />
+    <Compile Include="System.ServiceProcess.ServiceController.netcoreapp.cs" Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp'" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="$(LibrariesProjectRoot)System.Diagnostics.EventLog\ref\System.Diagnostics.EventLog.csproj" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == 'netcoreapp3.1'">
+    <Reference Include="System.Runtime" />
+    <Reference Include="System.ComponentModel.TypeConverter" />
+    <Reference Include="System.ComponentModel.Primitives" />
   </ItemGroup>
   <ItemGroup Condition="'$(TargetFramework)' == 'net461'">
     <Reference Include="System.ServiceProcess" />
   </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="..\..\System.Diagnostics.EventLog\ref\System.Diagnostics.EventLog.csproj" />
+  <ItemGroup Condition="'$(TargetFramework)' == '$(NetCoreAppCurrent)'">
+    <ProjectReference Include="$(LibrariesProjectRoot)System.ComponentModel.TypeConverter\ref\System.ComponentModel.TypeConverter.csproj" />
   </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/src/libraries/System.IO.Pipes.AccessControl/ref/System.IO.Pipes.AccessControl.net461.cs b/src/libraries/System.ServiceProcess.ServiceController/ref/System.ServiceProcess.ServiceController.netcoreapp.cs
similarity index 54%
rename from src/libraries/System.IO.Pipes.AccessControl/ref/System.IO.Pipes.AccessControl.net461.cs
rename to src/libraries/System.ServiceProcess.ServiceController/ref/System.ServiceProcess.ServiceController.netcoreapp.cs
index 1268f736387ed0..3fd806b0f56492 100644
--- a/src/libraries/System.IO.Pipes.AccessControl/ref/System.IO.Pipes.AccessControl.net461.cs
+++ b/src/libraries/System.ServiceProcess.ServiceController/ref/System.ServiceProcess.ServiceController.netcoreapp.cs
@@ -4,9 +4,10 @@
 // Changes to this file must follow the https://aka.ms/api-review process.
 // ------------------------------------------------------------------------------
 
-using System.Runtime.CompilerServices;
-
-[assembly: TypeForwardedTo(typeof(System.IO.Pipes.PipeAccessRights))]
-[assembly: TypeForwardedTo(typeof(System.IO.Pipes.PipeAccessRule))]
-[assembly: TypeForwardedTo(typeof(System.IO.Pipes.PipeAuditRule))]
-[assembly: TypeForwardedTo(typeof(System.IO.Pipes.PipeSecurity))]
+namespace System.ServiceProcess
+{
+    public partial class ServiceController : System.ComponentModel.Component
+    {
+        public void Stop(bool stopDependentServices) { }
+    }
+}
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 7cf866982fc86f..6f4e10d2e6ca8e 100644
--- a/src/libraries/System.ServiceProcess.ServiceController/src/System.ServiceProcess.ServiceController.csproj
+++ b/src/libraries/System.ServiceProcess.ServiceController/src/System.ServiceProcess.ServiceController.csproj
@@ -1,18 +1,17 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <TargetFrameworks>$(NetCoreAppCurrent)-windows;netstandard2.0;netstandard2.0-windows;net461-windows</TargetFrameworks>
-    <ExcludeCurrentNetCoreAppFromPackage>true</ExcludeCurrentNetCoreAppFromPackage>
+    <TargetFrameworks>$(NetCoreAppCurrent)-windows;$(NetCoreAppCurrent);netcoreapp3.1-windows;netcoreapp3.1;netstandard2.0-windows;netstandard2.0;net461-windows</TargetFrameworks>
     <NoWarn>$(NoWarn);CA2249</NoWarn>
     <Nullable>enable</Nullable>
   </PropertyGroup>
   <!-- DesignTimeBuild requires all the TargetFramework Derived Properties to not be present in the first property group. -->
   <PropertyGroup>
-    <IsPartialFacadeAssembly Condition="$(TargetFramework.StartsWith('net4'))">true</IsPartialFacadeAssembly>
-    <OmitResources Condition="$(TargetFramework.StartsWith('net4'))">true</OmitResources>
-    <GeneratePlatformNotSupportedAssemblyMessage Condition="$(TargetFramework.StartsWith('netstandard')) and '$(TargetsWindows)' != 'true'">SR.PlatformNotSupported_ServiceController</GeneratePlatformNotSupportedAssemblyMessage>
+    <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>
   </PropertyGroup>
-  <ItemGroup Condition="$(TargetFramework.StartsWith('$(NetCoreAppCurrent)')) or ($(TargetFramework.StartsWith('netstandard')) and '$(TargetsWindows)' == 'true')">
+  <ItemGroup Condition="'$(IsPartialFacadeAssembly)' != 'true' and '$(TargetsWindows)' == 'true'">
     <Compile Include="$(CommonPath)System\Text\ValueStringBuilder.cs"
              Link="Common\System\Text\ValueStringBuilder.cs" />
     <Compile Include="$(CommonPath)Interop\Windows\Interop.Libraries.cs"
@@ -73,8 +72,7 @@
     <Compile Include="System\ServiceProcess\SessionChangeReason.cs" />
     <Compile Include="System\ServiceProcess\TimeoutException.cs" />
   </ItemGroup>
-  <ItemGroup Condition="$(TargetFramework.StartsWith('$(NetCoreAppCurrent)')) and
-                        '$(TargetsWindows)' == 'true'">
+  <ItemGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp'">
     <Reference Include="Microsoft.Win32.Primitives" />
     <Reference Include="System.Buffers" />
     <Reference Include="System.Collections" />
@@ -91,13 +89,16 @@
     <Reference Include="System.Threading.Thread" />
     <Reference Include="System.Threading.ThreadPool" />
   </ItemGroup>
-  <ItemGroup Condition="$(TargetFramework.StartsWith('net4'))">
+  <ItemGroup Condition="$(TargetFramework.StartsWith('netcoreapp3.1'))">
+    <Reference Include="System.ComponentModel.TypeConverter" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(IsPartialFacadeAssembly)' == 'true'">
     <Reference Include="System.ServiceProcess" />
   </ItemGroup>
-  <ItemGroup Condition="$(TargetFramework.StartsWith('$(NetCoreAppCurrent)')) or $(TargetFramework.StartsWith('netstandard2.0'))">
+  <ItemGroup Condition="'$(IsPartialFacadeAssembly)' != 'true'">
     <ProjectReference Include="$(LibrariesProjectRoot)System.Diagnostics.EventLog\src\System.Diagnostics.EventLog.csproj" />
   </ItemGroup>
-  <ItemGroup Condition="$(TargetFramework.StartsWith('netstandard2.0'))">
+  <ItemGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETStandard'">
     <PackageReference Include="System.Buffers" Version="$(SystemBuffersVersion)" />
     <PackageReference Include="System.Memory" Version="$(SystemMemoryVersion)" />
     <ProjectReference Include="$(LibrariesProjectRoot)System.Runtime.CompilerServices.Unsafe\src\System.Runtime.CompilerServices.Unsafe.ilproj" />
diff --git a/src/libraries/System.ServiceProcess.ServiceController/src/System/ServiceProcess/ServiceController.cs b/src/libraries/System.ServiceProcess.ServiceController/src/System/ServiceProcess/ServiceController.cs
index 7f1ca65ed1e5c9..64725f9f910cf8 100644
--- a/src/libraries/System.ServiceProcess.ServiceController/src/System/ServiceProcess/ServiceController.cs
+++ b/src/libraries/System.ServiceProcess.ServiceController/src/System/ServiceProcess/ServiceController.cs
@@ -912,19 +912,42 @@ public void Start(string[] args)
         /// they will be stopped first. The DependentServices property lists this set
         /// of services.
         /// </summary>
-        public unsafe void Stop()
+        public void Stop()
+        {
+            Stop(stopDependentServices: true);
+        }
+
+        /// <summary>
+        /// Stops the service and optionally any services that are dependent on this service.
+        /// </summary>
+        /// <remarks>
+        /// If any other services depend on this one, you need to either pass <c>true</c> for
+        /// <paramref name="stopDependentServices"/> or stop them manually before calling this method.
+        /// </remarks>
+        /// <param name="stopDependentServices">
+        /// <c>true</c> to stop all running dependent services together with the service; <c>false</c> to stop only the service.
+        /// </param>
+#if NETCOREAPP3_1_OR_GREATER
+        public
+#else
+        private
+#endif
+            unsafe void Stop(bool stopDependentServices)
         {
             using SafeServiceHandle serviceHandle = GetServiceHandle(Interop.Advapi32.ServiceOptions.SERVICE_STOP);
-            // Before stopping this service, stop all the dependent services that are running.
-            // (It's OK not to cache the result of getting the DependentServices property because it caches on its own.)
-            for (int i = 0; i < DependentServices.Length; i++)
+            if (stopDependentServices)
             {
-                ServiceController currentDependent = DependentServices[i];
-                currentDependent.Refresh();
-                if (currentDependent.Status != ServiceControllerStatus.Stopped)
+                // Before stopping this service, stop all the dependent services that are running.
+                // (It's OK not to cache the result of getting the DependentServices property because it caches on its own.)
+                for (int i = 0; i < DependentServices.Length; i++)
                 {
-                    currentDependent.Stop();
-                    currentDependent.WaitForStatus(ServiceControllerStatus.Stopped, new TimeSpan(0, 0, 30));
+                    ServiceController currentDependent = DependentServices[i];
+                    currentDependent.Refresh();
+                    if (currentDependent.Status != ServiceControllerStatus.Stopped)
+                    {
+                        currentDependent.Stop();
+                        currentDependent.WaitForStatus(ServiceControllerStatus.Stopped, new TimeSpan(0, 0, 30));
+                    }
                 }
             }
 
diff --git a/src/libraries/System.ServiceProcess.ServiceController/tests/ServiceControllerTests.cs b/src/libraries/System.ServiceProcess.ServiceController/tests/ServiceControllerTests.cs
index f03e424788988d..1f0ead84e8753d 100644
--- a/src/libraries/System.ServiceProcess.ServiceController/tests/ServiceControllerTests.cs
+++ b/src/libraries/System.ServiceProcess.ServiceController/tests/ServiceControllerTests.cs
@@ -7,7 +7,7 @@ namespace System.ServiceProcess.Tests
 {
     [OuterLoop(/* Modifies machine state */)]
     [SkipOnTargetFramework(TargetFrameworkMonikers.NetFramework, "Persistent issues starting test service on NETFX")]
-    public class ServiceControllerTests : IDisposable
+    public partial class ServiceControllerTests : IDisposable
     {
         private const int connectionTimeout = 30000;
         private readonly TestServiceProvider _testService;
diff --git a/src/libraries/System.ServiceProcess.ServiceController/tests/ServiceControllerTests.netcoreapp.cs b/src/libraries/System.ServiceProcess.ServiceController/tests/ServiceControllerTests.netcoreapp.cs
new file mode 100644
index 00000000000000..9b78dfe61a4703
--- /dev/null
+++ b/src/libraries/System.ServiceProcess.ServiceController/tests/ServiceControllerTests.netcoreapp.cs
@@ -0,0 +1,50 @@
+// 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.ServiceProcess.Tests
+{
+    [OuterLoop(/* Modifies machine state */)]
+    public partial class ServiceControllerTests : IDisposable
+    {
+        [ConditionalFact(nameof(IsProcessElevated))]
+        public void Stop_FalseArg_WithDependentServices_ThrowsInvalidOperationException()
+        {
+            var controller = new ServiceController(_testService.TestServiceName);
+            controller.WaitForStatus(ServiceControllerStatus.Running, _testService.ControlTimeout);
+            Assert.Throws<InvalidOperationException>(() => controller.Stop(stopDependentServices: false));
+        }
+
+        [ConditionalFact(nameof(IsProcessElevated))]
+        public void Stop_TrueArg_WithDependentServices_StopsTheServiceAndItsDependents()
+        {
+            var controller = new ServiceController(_testService.TestServiceName);
+            controller.WaitForStatus(ServiceControllerStatus.Running, _testService.ControlTimeout);
+
+            controller.Stop(stopDependentServices: true);
+            controller.WaitForStatus(ServiceControllerStatus.Stopped, _testService.ControlTimeout);
+
+            Assert.Equal(ServiceControllerStatus.Stopped, controller.Status);
+            Assert.All(controller.DependentServices, service => Assert.Equal(ServiceControllerStatus.Stopped, service.Status));
+        }
+
+        [ConditionalFact(nameof(IsProcessElevated))]
+        public void StopTheServiceAndItsDependentsManually()
+        {
+            var controller = new ServiceController(_testService.TestServiceName);
+            controller.WaitForStatus(ServiceControllerStatus.Running, _testService.ControlTimeout);
+
+            foreach (var dependentService in controller.DependentServices)
+            {
+                dependentService.Stop(stopDependentServices: false);
+                dependentService.WaitForStatus(ServiceControllerStatus.Stopped, _testService.ControlTimeout);
+            }
+            controller.Stop(stopDependentServices: false);
+            controller.WaitForStatus(ServiceControllerStatus.Stopped, _testService.ControlTimeout);
+
+            Assert.Equal(ServiceControllerStatus.Stopped, controller.Status);
+            Assert.All(controller.DependentServices, service => Assert.Equal(ServiceControllerStatus.Stopped, service.Status));
+        }
+    }
+}
diff --git a/src/libraries/System.ServiceProcess.ServiceController/tests/System.ServiceProcess.ServiceController.Tests.csproj b/src/libraries/System.ServiceProcess.ServiceController/tests/System.ServiceProcess.ServiceController.Tests.csproj
index f09c00f50cb83c..ca07717ba52e94 100644
--- a/src/libraries/System.ServiceProcess.ServiceController/tests/System.ServiceProcess.ServiceController.Tests.csproj
+++ b/src/libraries/System.ServiceProcess.ServiceController/tests/System.ServiceProcess.ServiceController.Tests.csproj
@@ -9,6 +9,9 @@
     <Compile Include="ServiceControllerTests.cs" />
     <Compile Include="ServiceProcessDescriptionAttributeTests.cs" />
   </ItemGroup>
+  <ItemGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp'">
+    <Compile Include="ServiceControllerTests.netcoreapp.cs" />
+  </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="System.ServiceProcess.ServiceController.TestService\System.ServiceProcess.ServiceController.TestService.csproj" />
   </ItemGroup>
diff --git a/src/libraries/System.Speech/ref/System.Speech.csproj b/src/libraries/System.Speech/ref/System.Speech.csproj
index c8543d1332372b..47a37eb580cbfd 100644
--- a/src/libraries/System.Speech/ref/System.Speech.csproj
+++ b/src/libraries/System.Speech/ref/System.Speech.csproj
@@ -1,8 +1,19 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFrameworks>netstandard2.0</TargetFrameworks>
+    <TargetFrameworks>$(NetCoreAppCurrent);netcoreapp3.1;netstandard2.0</TargetFrameworks>
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="System.Speech.cs" />
   </ItemGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == '$(NetCoreAppCurrent)'">
+    <ProjectReference Include="$(LibrariesProjectRoot)System.ComponentModel.EventBasedAsync\ref\System.ComponentModel.EventBasedAsync.csproj" />
+    <ProjectReference Include="$(LibrariesProjectRoot)System.Xml.ReaderWriter\ref\System.Xml.ReaderWriter.csproj" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == 'netcoreapp3.1'">
+    <Reference Include="System.ComponentModel.EventBasedAsync" />
+    <Reference Include="System.ComponentModel.Primitives" />
+    <Reference Include="System.ObjectModel" />
+    <Reference Include="System.Runtime" />
+    <Reference Include="System.Xml.ReaderWriter" />
+  </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/src/libraries/System.Speech/src/System.Speech.csproj b/src/libraries/System.Speech/src/System.Speech.csproj
index 00b2c99d3a6a91..8493864d2f6d68 100644
--- a/src/libraries/System.Speech/src/System.Speech.csproj
+++ b/src/libraries/System.Speech/src/System.Speech.csproj
@@ -1,28 +1,19 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <TargetFrameworks>$(NetCoreAppCurrent)-windows;netcoreapp3.1-windows;netstandard2.0</TargetFrameworks>
-    <ExcludeCurrentNetCoreAppFromPackage>true</ExcludeCurrentNetCoreAppFromPackage>
+    <TargetFrameworks>$(NetCoreAppCurrent)-windows;$(NetCoreAppCurrent);netcoreapp3.1-windows;netcoreapp3.1;netstandard2.0</TargetFrameworks>
     <!-- CS0649: uninitialized interop type fields -->
     <!-- SA1129: https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/3277 -->
-    <NoWarn>$(NoWarn);CS0649;SA1129</NoWarn>
+    <NoWarn>$(NoWarn);CS0649;SA1129;CA1847</NoWarn>
     <SetIsTrimmable>false</SetIsTrimmable>
   </PropertyGroup>
   <PropertyGroup>
-    <GeneratePlatformNotSupportedAssemblyMessage Condition="'$(TargetFramework)' == 'netstandard2.0'">SR.PlatformNotSupported_SystemSpeech</GeneratePlatformNotSupportedAssemblyMessage>
+    <!-- System.Speech has its own SR scheme in which resource ID's are mapped to SAPI error codes. So we disable our default SR.cs generation and include resources explicitly -->
+    <OmitResources Condition="'$(TargetsWindows)' == 'true'">true</OmitResources>
+    <GeneratePlatformNotSupportedAssemblyMessage Condition="'$(TargetsWindows)' != 'true'">SR.PlatformNotSupported_SystemSpeech</GeneratePlatformNotSupportedAssemblyMessage>
     <!-- On older TFM's we needed to disable obsoletion warnings about Marshalling VARIANTs -->
     <NoWarn Condition="'$(TargetFramework)' == '$(NetCoreAppCurrent)-windows'">$(NoWarn);IDE0079</NoWarn>
   </PropertyGroup>
-  <!-- System.Speech has its own SR scheme in which resource ID's are mapped to SAPI error codes. So we disable our default SR.cs generation and include resources explicitly -->
-  <PropertyGroup Condition="'$(TargetsWindows)' == 'true'">
-    <OmitResources>true</OmitResources>
-  </PropertyGroup>
-  <ItemGroup Condition="'$(TargetsWindows)' == 'true'">
-    <EmbeddedResource Include="Resources\Strings.resx">
-      <Visible>true</Visible>
-      <ManifestResourceName>ExceptionStringTable</ManifestResourceName>
-    </EmbeddedResource>
-  </ItemGroup>
   <ItemGroup Condition="'$(TargetsWindows)' == 'true'">
     <Compile Include="SR.cs" />
     <Compile Include="SRID.cs" />
@@ -201,6 +192,12 @@
     <Compile Include="Synthesis\TTSEngine\SAPIEngineTypes.cs" />
     <Compile Include="Synthesis\TTSEngine\TTSEngineTypes.cs" />
   </ItemGroup>
+  <ItemGroup Condition="'$(TargetsWindows)' == 'true'">
+    <EmbeddedResource Include="Resources\Strings.resx">
+      <Visible>true</Visible>
+      <ManifestResourceName>ExceptionStringTable</ManifestResourceName>
+    </EmbeddedResource>
+  </ItemGroup>
   <ItemGroup>
     <EmbeddedResource Include="upstable_chs.upsmap">
       <LogicalName>upstable_chs.upsmap</LogicalName>
@@ -224,10 +221,12 @@
       <LogicalName>upstable_jpn.upsmap</LogicalName>
     </EmbeddedResource>
   </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="$(LibrariesProjectRoot)Microsoft.Win32.Registry\src\Microsoft.Win32.Registry.csproj" />
+  <ItemGroup Condition="!$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net6.0'))">
+    <PackageReference Include="Microsoft.Win32.Registry" Version="$(MicrosoftWin32RegistryVersion)" />
   </ItemGroup>
   <ItemGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp'">
+    <Reference Include="netstandard" Condition="$(TargetFramework.StartsWith('netcoreapp3.1'))" />
+    <Reference Include="Microsoft.Win32.Registry" Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net6.0'))" />
     <Reference Include="System.Collections" />
     <Reference Include="System.Collections.NonGeneric" />
     <Reference Include="System.Collections.Specialized" />
diff --git a/src/libraries/System.Text.Encoding.CodePages/ref/System.Text.Encoding.CodePages.csproj b/src/libraries/System.Text.Encoding.CodePages/ref/System.Text.Encoding.CodePages.csproj
index 532f6e7ebe4359..d37062131e3652 100644
--- a/src/libraries/System.Text.Encoding.CodePages/ref/System.Text.Encoding.CodePages.csproj
+++ b/src/libraries/System.Text.Encoding.CodePages/ref/System.Text.Encoding.CodePages.csproj
@@ -1,13 +1,16 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <Nullable>enable</Nullable>
-    <TargetFrameworks>$(NetCoreAppCurrent);netstandard2.0;net461</TargetFrameworks>
+    <TargetFrameworks>$(NetCoreAppCurrent);netcoreapp3.1;netstandard2.0;net461</TargetFrameworks>
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="System.Text.Encoding.CodePages.cs" />
-    <Compile Include="System.Text.Encoding.CodePages.netcoreapp.cs" Condition="'$(TargetFramework)' == '$(NetCoreAppCurrent)'" />
+    <Compile Include="System.Text.Encoding.CodePages.netcoreapp.cs" Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net5.0'))" />
   </ItemGroup>
   <ItemGroup Condition="'$(TargetFramework)' == '$(NetCoreAppCurrent)'">
     <ProjectReference Include="$(LibrariesProjectRoot)System.Runtime/ref/System.Runtime.csproj" />
   </ItemGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == 'netcoreapp3.1'">
+    <Reference Include="System.Runtime" />
+  </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/src/libraries/System.Text.Encoding.CodePages/src/System.Text.Encoding.CodePages.csproj b/src/libraries/System.Text.Encoding.CodePages/src/System.Text.Encoding.CodePages.csproj
index 232b1cb17ef84a..4128a65f4de871 100644
--- a/src/libraries/System.Text.Encoding.CodePages/src/System.Text.Encoding.CodePages.csproj
+++ b/src/libraries/System.Text.Encoding.CodePages/src/System.Text.Encoding.CodePages.csproj
@@ -2,8 +2,7 @@
   <PropertyGroup>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <Nullable>enable</Nullable>
-    <TargetFrameworks>$(NetCoreAppCurrent)-windows;$(NetCoreAppCurrent);netcoreapp3.1-windows;netstandard2.0-windows;netstandard2.0;net461-windows</TargetFrameworks>
-    <ExcludeCurrentNetCoreAppFromPackage>true</ExcludeCurrentNetCoreAppFromPackage>
+    <TargetFrameworks>$(NetCoreAppCurrent)-windows;$(NetCoreAppCurrent);netcoreapp3.1-windows;netcoreapp3.1;netstandard2.0-windows;netstandard2.0;net461-windows</TargetFrameworks>
     <IncludePlatformAttributes>true</IncludePlatformAttributes>
   </PropertyGroup>
   <!-- Generator for code mapping table, target to invoke is GenerateEncodingSource -->
diff --git a/src/libraries/System.Text.Encodings.Web/ref/System.Text.Encodings.Web.csproj b/src/libraries/System.Text.Encodings.Web/ref/System.Text.Encodings.Web.csproj
index 51fc45949ef508..1f72a389249355 100644
--- a/src/libraries/System.Text.Encodings.Web/ref/System.Text.Encodings.Web.csproj
+++ b/src/libraries/System.Text.Encodings.Web/ref/System.Text.Encodings.Web.csproj
@@ -1,7 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <TargetFrameworks>$(NetCoreAppCurrent);netcoreapp3.1;netstandard2.0;net461</TargetFrameworks>
-    <ExcludeCurrentNetCoreAppFromPackage>true</ExcludeCurrentNetCoreAppFromPackage>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <!-- Only CLS-compliant members can be abstract -->
     <NoWarn>$(NoWarn);CS3011</NoWarn>
diff --git a/src/libraries/System.Text.Encodings.Web/src/System.Text.Encodings.Web.csproj b/src/libraries/System.Text.Encodings.Web/src/System.Text.Encodings.Web.csproj
index a4c22190c26287..679e381a7eb0c1 100644
--- a/src/libraries/System.Text.Encodings.Web/src/System.Text.Encodings.Web.csproj
+++ b/src/libraries/System.Text.Encodings.Web/src/System.Text.Encodings.Web.csproj
@@ -1,8 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <TargetFrameworks>$(NetCoreAppCurrent);$(NetCoreAppCurrent)-Browser;netcoreapp3.1;netstandard2.0;net461</TargetFrameworks>
-    <ExcludeCurrentNetCoreAppFromPackage>true</ExcludeCurrentNetCoreAppFromPackage>
+    <TargetFrameworks>$(NetCoreAppCurrent)-Browser;$(NetCoreAppCurrent);netcoreapp3.1;netstandard2.0;net461</TargetFrameworks>
     <Nullable>enable</Nullable>
     <!-- CS3011: Only CLS-compliant members can be abstract -->
     <!-- CS3019: CLS attributes on internal types. Some shared source files are internal in this project. -->
@@ -38,21 +37,23 @@
     <Compile Include="$(CommonPath)System\HexConverter.cs" Link="Common\System\HexConverter.cs" />
     <Compile Include="$(CommonPath)System\Text\ValueStringBuilder.cs" Link="Common\System\Text\ValueStringBuilder.cs" />
   </ItemGroup>
-  <ItemGroup Condition="$(TargetFramework.StartsWith('$(NetCoreAppCurrent)')) or '$(TargetFramework)' == 'netcoreapp3.1'">
+  <ItemGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp'">
     <Compile Include="System\Text\Encodings\Web\OptimizedInboxTextEncoder.Ssse3.cs" />
   </ItemGroup>
   <ItemGroup Condition="$(TargetFramework.StartsWith('$(NetCoreAppCurrent)'))">
     <Compile Include="System\Text\Encodings\Web\OptimizedInboxTextEncoder.AdvSimd64.cs" />
   </ItemGroup>
-  <ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0' or '$(TargetFramework)' == 'net461'">
+  <ItemGroup Condition="'$(TargetFrameworkIdentifier)' != '.NETCoreApp'">
     <Compile Include="Polyfills\System.Numerics.BitOperations.netstandard20.cs" />
     <Compile Include="Polyfills\System.Text.Rune.netstandard20.cs" />
   </ItemGroup>
-  <ItemGroup Condition="$(TargetFramework.StartsWith('$(NetCoreAppCurrent)')) or '$(TargetFramework)' == 'netcoreapp3.1'">
+  <ItemGroup>
+    <ProjectReference Include="$(LibrariesProjectRoot)System.Runtime.CompilerServices.Unsafe\src\System.Runtime.CompilerServices.Unsafe.ilproj" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp'">
     <Reference Include="System.Memory" />
     <Reference Include="System.Numerics.Vectors" />
     <Reference Include="System.Runtime" />
-    <Reference Include="System.Runtime.CompilerServices.Unsafe" />
     <Reference Include="System.Runtime.Intrinsics" />
     <Reference Include="System.Threading" />
   </ItemGroup>
@@ -62,9 +63,8 @@
     <Reference Include="System.Resources.ResourceManager" />
     <Reference Include="System.Runtime.Extensions" />
   </ItemGroup>
-  <ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0' or '$(TargetFramework)' == 'net461'">
+  <ItemGroup Condition="'$(TargetFrameworkIdentifier)' != '.NETCoreApp'">
     <PackageReference Include="System.Buffers" Version="$(SystemBuffersVersion)" />
     <PackageReference Include="System.Memory" Version="$(SystemMemoryVersion)" />
-    <PackageReference Include="System.Runtime.CompilerServices.Unsafe" Version="$(SystemRuntimeCompilerServicesUnsafeVersion)" />
   </ItemGroup>
 </Project>
diff --git a/src/libraries/System.Text.Encodings.Web/tests/EncoderCommonTests.cs b/src/libraries/System.Text.Encodings.Web/tests/EncoderCommonTests.cs
index 8169576630ae3a..239a6299d407ff 100644
--- a/src/libraries/System.Text.Encodings.Web/tests/EncoderCommonTests.cs
+++ b/src/libraries/System.Text.Encodings.Web/tests/EncoderCommonTests.cs
@@ -13,7 +13,6 @@ public class EncoderCommonTests
         [InlineData(5000, 3, 15000)] // haven't exceeded the 16k cap
         [InlineData(40000, 3, 40000)] // if we spill over the LOH, we still allocate an output buffer equivalent in length to the input buffer
         [InlineData(512, int.MaxValue, 16 * 1024)] // make sure we can handle numeric overflow
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
         public void GetCapacityOfOutputStringBuilder(int numCharsToEncode, int worstCaseOutputCharsPerInputChar, int expectedResult)
         {
             Assert.Equal(expectedResult, EncoderCommon.GetCapacityOfOutputStringBuilder(numCharsToEncode, worstCaseOutputCharsPerInputChar));
diff --git a/src/libraries/System.Text.Encodings.Web/tests/HtmlEncoderTests.cs b/src/libraries/System.Text.Encodings.Web/tests/HtmlEncoderTests.cs
index 0621653036a484..4321a99e2c03d9 100644
--- a/src/libraries/System.Text.Encodings.Web/tests/HtmlEncoderTests.cs
+++ b/src/libraries/System.Text.Encodings.Web/tests/HtmlEncoderTests.cs
@@ -16,7 +16,6 @@ public class HtmlEncoderTests
         [InlineData("&#x1F602; 21", "\U0001F602 21")]
         [InlineData("x&#x1F602;y", "x\U0001F602y")]
         [InlineData("&#x1F602;x&#x1F602;y", "\U0001F602x\U0001F602y")]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
         public void TestSurrogate(string expected, string actual)
         {
             Assert.Equal(expected, HtmlEncoder.Default.Encode(actual));
@@ -96,7 +95,6 @@ public void Default_EquivalentToBasicLatin()
         [InlineData("'", "&#x27;")]
         [InlineData("\"", "&quot;")]
         [InlineData("+", "&#x2B;")]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
         public void HtmlEncode_AllRangesAllowed_StillEncodesForbiddenChars_Simple(string input, string expected)
         {
             // Arrange
diff --git a/src/libraries/System.Text.Encodings.Web/tests/JavaScriptEncoderTests.cs b/src/libraries/System.Text.Encodings.Web/tests/JavaScriptEncoderTests.cs
index 161ba615ae244d..c57a84e0af3d03 100644
--- a/src/libraries/System.Text.Encodings.Web/tests/JavaScriptEncoderTests.cs
+++ b/src/libraries/System.Text.Encodings.Web/tests/JavaScriptEncoderTests.cs
@@ -11,7 +11,6 @@
 
 namespace System.Text.Encodings.Web.Tests
 {
-    [ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
     public partial class JavaScriptEncoderTests
     {
         [Fact]
diff --git a/src/libraries/System.Text.Encodings.Web/tests/TextEncoderTests.cs b/src/libraries/System.Text.Encodings.Web/tests/TextEncoderTests.cs
index 35166fb19c13c3..cb26b483e7ce3e 100644
--- a/src/libraries/System.Text.Encodings.Web/tests/TextEncoderTests.cs
+++ b/src/libraries/System.Text.Encodings.Web/tests/TextEncoderTests.cs
@@ -53,7 +53,6 @@ public void EncodeIntoBuffer_SurrogatePairs()
         [InlineData(10, 10)]
         [InlineData(11, 11)]
         [InlineData(12, 11)]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
         public void EncodeUtf8_WellFormedInput_DoesNotRequireEncoding_CopiedToDestinationCorrectly(int destinationSize, int expectedBytesCopied)
         {
             // This test considers input which is well-formed and doesn't need to be encoded.
@@ -258,7 +257,6 @@ public void FindFirstCharToEncodeUtf8_WellFormedData_SomeCharsDisallowed()
         [InlineData(new byte[] { 0xF1, 0x80, 0x80 }, 0)]
         [InlineData(new byte[] { 0xF1, 0x80, 0x80, 0x80, 0xFF }, 4)]
         [InlineData(new byte[] { 0xFF, 0x80, 0x80, 0x80, 0xFF }, 0)]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
         public void FindFirstCharToEncodeUtf8_IllFormedData_ReturnsIndexOfIllFormedSubsequence(byte[] utf8Data, int expectedIndex)
         {
             // Arrange
diff --git a/src/libraries/System.Text.Encodings.Web/tests/UnicodeRangeTests.cs b/src/libraries/System.Text.Encodings.Web/tests/UnicodeRangeTests.cs
index c54b770e7df93e..51d1d9adc4b3f5 100644
--- a/src/libraries/System.Text.Encodings.Web/tests/UnicodeRangeTests.cs
+++ b/src/libraries/System.Text.Encodings.Web/tests/UnicodeRangeTests.cs
@@ -12,7 +12,6 @@ public class UnicodeRangeTests
         [Theory]
         [InlineData(-1, 16)]
         [InlineData(0x10000, 16)]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
         public void Ctor_FailureCase_FirstCodePoint(int firstCodePoint, int rangeSize)
         {
             AssertExtensions.Throws<ArgumentOutOfRangeException>("firstCodePoint", () => new UnicodeRange(firstCodePoint, rangeSize));
@@ -21,7 +20,6 @@ public void Ctor_FailureCase_FirstCodePoint(int firstCodePoint, int rangeSize)
         [Theory]
         [InlineData(0x0100, -1)]
         [InlineData(0x0100, 0x10000)]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
         public void Ctor_FailureCase_RangeSize(int firstCodePoint, int rangeSize)
         {
             AssertExtensions.Throws<ArgumentOutOfRangeException>("length", () => new UnicodeRange(firstCodePoint, rangeSize));
diff --git a/src/libraries/System.Text.Encodings.Web/tests/UnicodeRangesTests.cs b/src/libraries/System.Text.Encodings.Web/tests/UnicodeRangesTests.cs
index 4217d130ff5e26..efa50bff2f8ee3 100644
--- a/src/libraries/System.Text.Encodings.Web/tests/UnicodeRangesTests.cs
+++ b/src/libraries/System.Text.Encodings.Web/tests/UnicodeRangesTests.cs
@@ -27,7 +27,6 @@ public static void Range_All()
 
         [Theory]
         [MemberData(nameof(UnicodeRanges_GeneratedData))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
         public static void Range_Unicode(ushort first, ushort last, string blockName)
         {
             Assert.Equal(0x0, first & 0xF); // first char in any block should be U+nnn0
diff --git a/src/libraries/System.Text.Json/src/System.Text.Json.csproj b/src/libraries/System.Text.Json/src/System.Text.Json.csproj
index 8a6315b1fe7c48..e3ba73d6b6c23b 100644
--- a/src/libraries/System.Text.Json/src/System.Text.Json.csproj
+++ b/src/libraries/System.Text.Json/src/System.Text.Json.csproj
@@ -2,7 +2,6 @@
   <PropertyGroup>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <TargetFrameworks>$(NetCoreAppCurrent);netcoreapp3.1;netstandard2.0;net461</TargetFrameworks>
-    <ExcludeCurrentNetCoreAppFromPackage>true</ExcludeCurrentNetCoreAppFromPackage>
     <!-- Workaround for overriding the XML comments related warnings that are being supressed repo wide (within arcade): -->
     <!-- https://github.com/dotnet/arcade/blob/ea6addfdc65e5df1b2c036f11614a5f922e36267/src/Microsoft.DotNet.Arcade.Sdk/tools/ProjectDefaults.props#L90 -->
     <!-- For this project, we want warnings if there are public APIs/types without properly formatted XML comments (particularly CS1591). -->
@@ -50,6 +49,9 @@
     <Compile Include="System\Text\Json\JsonHelpers.cs" />
     <Compile Include="System\Text\Json\JsonHelpers.Date.cs" />
     <Compile Include="System\Text\Json\JsonHelpers.Escaping.cs" />
+    <Compile Include="System\Text\Json\JsonPropertyDictionary.cs" />
+    <Compile Include="System\Text\Json\JsonPropertyDictionary.KeyCollection.cs" />
+    <Compile Include="System\Text\Json\JsonPropertyDictionary.ValueCollection.cs" />
     <Compile Include="System\Text\Json\JsonTokenType.cs" />
     <Compile Include="System\Text\Json\Nodes\JsonArray.cs" />
     <Compile Include="System\Text\Json\Nodes\JsonArray.IList.cs" />
@@ -62,8 +64,6 @@
     <Compile Include="System\Text\Json\Nodes\JsonObject.cs" />
     <Compile Include="System\Text\Json\Nodes\JsonObject.Dynamic.cs" />
     <Compile Include="System\Text\Json\Nodes\JsonObject.IDictionary.cs" />
-    <Compile Include="System\Text\Json\Nodes\JsonObject.KeyCollection.cs" />
-    <Compile Include="System\Text\Json\Nodes\JsonObject.ValueCollection.cs" />
     <Compile Include="System\Text\Json\Nodes\JsonValue.CreateOverloads.cs" />
     <Compile Include="System\Text\Json\Nodes\JsonValue.cs" />
     <Compile Include="System\Text\Json\Nodes\JsonValueNotTrimmable.cs" />
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Nodes/JsonObject.KeyCollection.cs b/src/libraries/System.Text.Json/src/System/Text/Json/JsonPropertyDictionary.KeyCollection.cs
similarity index 69%
rename from src/libraries/System.Text.Json/src/System/Text/Json/Nodes/JsonObject.KeyCollection.cs
rename to src/libraries/System.Text.Json/src/System/Text/Json/JsonPropertyDictionary.KeyCollection.cs
index 5d591084c32b60..69c19cd9fce3f7 100644
--- a/src/libraries/System.Text.Json/src/System/Text/Json/Nodes/JsonObject.KeyCollection.cs
+++ b/src/libraries/System.Text.Json/src/System/Text/Json/JsonPropertyDictionary.KeyCollection.cs
@@ -4,34 +4,33 @@
 using System.Collections;
 using System.Collections.Generic;
 
-namespace System.Text.Json.Nodes
+namespace System.Text.Json
 {
-    public partial class JsonObject
+    internal partial class JsonPropertyDictionary<T>
     {
         private KeyCollection? _keyCollection;
 
-        private KeyCollection GetKeyCollection(JsonObject jsonObject)
+        public ICollection<string> GetKeyCollection()
         {
-            CreateList();
-            return _keyCollection ??= new KeyCollection(jsonObject);
+            return _keyCollection ??= new KeyCollection(this);
         }
 
         private sealed class KeyCollection : ICollection<string>
         {
-            private readonly JsonObject _jObject;
+            private readonly JsonPropertyDictionary<T> _parent;
 
-            public KeyCollection(JsonObject jsonObject)
+            public KeyCollection(JsonPropertyDictionary<T> jsonObject)
             {
-                _jObject = jsonObject;
+                _parent = jsonObject;
             }
 
-            public int Count => _jObject.Count;
+            public int Count => _parent.Count;
 
             public bool IsReadOnly => true;
 
             IEnumerator IEnumerable.GetEnumerator()
             {
-                foreach (KeyValuePair<string, JsonNode?> item in _jObject)
+                foreach (KeyValuePair<string, T?> item in _parent)
                 {
                     yield return item.Key;
                 }
@@ -39,12 +38,9 @@ IEnumerator IEnumerable.GetEnumerator()
 
             public void Add(string propertyName) => throw ThrowHelper.NotSupportedException_NodeCollectionIsReadOnly();
 
-
             public void Clear() => throw ThrowHelper.NotSupportedException_NodeCollectionIsReadOnly();
 
-
-            public bool Contains(string propertyName) => _jObject.ContainsNode(propertyName);
-
+            public bool Contains(string propertyName) => _parent.ContainsProperty(propertyName);
 
             public void CopyTo(string[] propertyNameArray, int index)
             {
@@ -53,7 +49,7 @@ public void CopyTo(string[] propertyNameArray, int index)
                     ThrowHelper.ThrowArgumentOutOfRangeException_NodeArrayIndexNegative(nameof(index));
                 }
 
-                foreach (KeyValuePair<string, JsonNode?> item in _jObject)
+                foreach (KeyValuePair<string, T?> item in _parent)
                 {
                     if (index >= propertyNameArray.Length)
                     {
@@ -66,7 +62,7 @@ public void CopyTo(string[] propertyNameArray, int index)
 
             public IEnumerator<string> GetEnumerator()
             {
-                foreach (KeyValuePair<string, JsonNode?> item in _jObject)
+                foreach (KeyValuePair<string, T?> item in _parent)
                 {
                     yield return item.Key;
                 }
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Nodes/JsonObject.ValueCollection.cs b/src/libraries/System.Text.Json/src/System/Text/Json/JsonPropertyDictionary.ValueCollection.cs
similarity index 51%
rename from src/libraries/System.Text.Json/src/System/Text/Json/Nodes/JsonObject.ValueCollection.cs
rename to src/libraries/System.Text.Json/src/System/Text/Json/JsonPropertyDictionary.ValueCollection.cs
index 7ce76ed948d944..2470d31621d686 100644
--- a/src/libraries/System.Text.Json/src/System/Text/Json/Nodes/JsonObject.ValueCollection.cs
+++ b/src/libraries/System.Text.Json/src/System/Text/Json/JsonPropertyDictionary.ValueCollection.cs
@@ -4,55 +4,52 @@
 using System.Collections;
 using System.Collections.Generic;
 
-namespace System.Text.Json.Nodes
+namespace System.Text.Json
 {
-    public partial class JsonObject
+    internal partial class JsonPropertyDictionary<T>
     {
         private ValueCollection? _valueCollection;
 
-        private ValueCollection GetValueCollection(JsonObject jsonObject)
+        public ICollection<T?> GetValueCollection()
         {
-            CreateList();
-            return _valueCollection ??= new ValueCollection(jsonObject);
+            return _valueCollection ??= new ValueCollection(this);
         }
 
-        private sealed class ValueCollection : ICollection<JsonNode?>
+        private sealed class ValueCollection : ICollection<T?>
         {
-            private readonly JsonObject _jObject;
+            private readonly JsonPropertyDictionary<T> _parent;
 
-            public ValueCollection(JsonObject jsonObject)
+            public ValueCollection(JsonPropertyDictionary<T> jsonObject)
             {
-                _jObject = jsonObject;
+                _parent = jsonObject;
             }
 
-            public int Count => _jObject.Count;
+            public int Count => _parent.Count;
 
             public bool IsReadOnly => true;
 
             IEnumerator IEnumerable.GetEnumerator()
             {
-                foreach (KeyValuePair<string, JsonNode?> item in _jObject)
+                foreach (KeyValuePair<string, T?> item in _parent)
                 {
                     yield return item.Value;
                 }
             }
 
-            public void Add(JsonNode? jsonNode) => throw ThrowHelper.NotSupportedException_NodeCollectionIsReadOnly();
-
+            public void Add(T? jsonNode) => throw ThrowHelper.NotSupportedException_NodeCollectionIsReadOnly();
 
             public void Clear() => throw ThrowHelper.NotSupportedException_NodeCollectionIsReadOnly();
 
+            public bool Contains(T? jsonNode) => _parent.ContainsValue(jsonNode);
 
-            public bool Contains(JsonNode? jsonNode) => _jObject.ContainsNode(jsonNode);
-
-            public void CopyTo(JsonNode?[] nodeArray, int index)
+            public void CopyTo(T?[] nodeArray, int index)
             {
                 if (index < 0)
                 {
                     ThrowHelper.ThrowArgumentOutOfRangeException_NodeArrayIndexNegative(nameof(index));
                 }
 
-                foreach (KeyValuePair<string, JsonNode?> item in _jObject)
+                foreach (KeyValuePair<string, T?> item in _parent)
                 {
                     if (index >= nodeArray.Length)
                     {
@@ -63,15 +60,15 @@ public void CopyTo(JsonNode?[] nodeArray, int index)
                 }
             }
 
-            public IEnumerator<JsonNode?> GetEnumerator()
+            public IEnumerator<T?> GetEnumerator()
             {
-                foreach (KeyValuePair<string, JsonNode?> item in _jObject)
+                foreach (KeyValuePair<string, T?> item in _parent)
                 {
                     yield return item.Value;
                 }
             }
 
-            bool ICollection<JsonNode?>.Remove(JsonNode? node) => throw ThrowHelper.NotSupportedException_NodeCollectionIsReadOnly();
+            bool ICollection<T?>.Remove(T? node) => throw ThrowHelper.NotSupportedException_NodeCollectionIsReadOnly();
         }
     }
 }
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/JsonPropertyDictionary.cs b/src/libraries/System.Text.Json/src/System/Text/Json/JsonPropertyDictionary.cs
new file mode 100644
index 00000000000000..16845773f8df87
--- /dev/null
+++ b/src/libraries/System.Text.Json/src/System/Text/Json/JsonPropertyDictionary.cs
@@ -0,0 +1,416 @@
+// 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;
+
+namespace System.Text.Json
+{
+    /// <summary>
+    /// Keeps both a List and Dictionary in sync to enable determinstic enumeration ordering of List
+    /// and performance benefits of Dictionary once a threshold is hit.
+    /// </summary>
+    internal partial class JsonPropertyDictionary<T> where T : class
+    {
+        private const int ListToDictionaryThreshold = 9;
+
+        private Dictionary<string, T?>? _propertyDictionary;
+        private readonly List<KeyValuePair<string, T?>> _propertyList;
+
+        private StringComparer _stringComparer;
+
+        public JsonPropertyDictionary(bool caseInsensitive)
+        {
+            _stringComparer = caseInsensitive ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal;
+            _propertyList = new List<KeyValuePair<string, T?>>();
+        }
+
+        public JsonPropertyDictionary(bool caseInsensitive, int capacity)
+        {
+            _stringComparer = caseInsensitive ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal;
+            _propertyList = new List<KeyValuePair<string, T?>>(capacity);
+        }
+
+        // Enable direct access to the List for performance reasons.
+        public List<KeyValuePair<string, T?>> List => _propertyList;
+
+        public void Add(string propertyName, T? value)
+        {
+            if (IsReadOnly)
+            {
+                ThrowHelper.ThrowNotSupportedException_NodeCollectionIsReadOnly();
+            }
+
+            if (propertyName == null)
+            {
+                throw new ArgumentNullException(nameof(propertyName));
+            }
+
+            AddValue(propertyName, value);
+        }
+
+        public void Add(KeyValuePair<string, T?> property)
+        {
+            if (IsReadOnly)
+            {
+                ThrowHelper.ThrowNotSupportedException_NodeCollectionIsReadOnly();
+            }
+
+            Add(property.Key, property.Value);
+        }
+
+        public bool TryAdd(string propertyName, T value)
+        {
+            if (IsReadOnly)
+            {
+                ThrowHelper.ThrowNotSupportedException_NodeCollectionIsReadOnly();
+            }
+
+            // A check for a null propertyName is not required since this method is only called by internal code.
+            Debug.Assert(propertyName != null);
+
+            return TryAddValue(propertyName, value);
+        }
+
+        public void Clear()
+        {
+            if (IsReadOnly)
+            {
+                ThrowHelper.ThrowNotSupportedException_NodeCollectionIsReadOnly();
+            }
+
+            _propertyList.Clear();
+            _propertyDictionary?.Clear();
+        }
+
+        public bool ContainsKey(string propertyName)
+        {
+            if (propertyName == null)
+            {
+                throw new ArgumentNullException(nameof(propertyName));
+            }
+
+            return ContainsProperty(propertyName);
+        }
+
+        public int Count
+        {
+            get
+            {
+                return _propertyList.Count;
+            }
+        }
+
+        public bool Remove(string propertyName)
+        {
+            if (IsReadOnly)
+            {
+                ThrowHelper.ThrowNotSupportedException_NodeCollectionIsReadOnly();
+            }
+
+            if (propertyName == null)
+            {
+                throw new ArgumentNullException(nameof(propertyName));
+            }
+
+            return TryRemoveProperty(propertyName, out T? removedValue);
+        }
+
+        public bool Contains(KeyValuePair<string, T?> item)
+        {
+            foreach (KeyValuePair<string, T?> existing in this)
+            {
+                if (ReferenceEquals(item.Value, existing.Value) && _stringComparer.Equals(item.Key, existing.Key))
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        public void CopyTo(KeyValuePair<string, T?>[] array, int index)
+        {
+            if (index < 0)
+            {
+                ThrowHelper.ThrowArgumentOutOfRangeException_NodeArrayIndexNegative(nameof(index));
+            }
+
+            foreach (KeyValuePair<string, T?> item in _propertyList)
+            {
+                if (index >= array.Length)
+                {
+                    ThrowHelper.ThrowArgumentException_NodeArrayTooSmall(nameof(array));
+                }
+
+                array[index++] = item;
+            }
+        }
+
+        public IEnumerator<KeyValuePair<string, T?>> GetEnumerator()
+        {
+            foreach (KeyValuePair<string, T?> item in _propertyList)
+            {
+                yield return item;
+            }
+        }
+
+        public ICollection<string> Keys => GetKeyCollection();
+
+        public ICollection<T?> Values => GetValueCollection();
+
+        public bool TryGetValue(string propertyName, out T? value)
+        {
+            if (propertyName == null)
+            {
+                throw new ArgumentNullException(nameof(propertyName));
+            }
+
+            if (_propertyDictionary != null)
+            {
+                return _propertyDictionary.TryGetValue(propertyName, out value);
+            }
+            else
+            {
+                foreach (KeyValuePair<string, T?> item in _propertyList)
+                {
+                    if (_stringComparer.Equals(propertyName, item.Key))
+                    {
+                        value = item.Value;
+                        return true;
+                    }
+                }
+            }
+
+            value = null;
+            return false;
+        }
+
+        public bool IsReadOnly { get; set; }
+
+        public T? this[string propertyName]
+        {
+            get
+            {
+                if (TryGetPropertyValue(propertyName, out T? value))
+                {
+                    return value;
+                }
+
+                // Return null for missing properties.
+                return null;
+            }
+
+            set
+            {
+                SetValue(propertyName, value);
+            }
+        }
+
+        public T? SetValue(string propertyName, T? value, Action? assignParent = null)
+        {
+            if (IsReadOnly)
+            {
+                ThrowHelper.ThrowNotSupportedException_NodeCollectionIsReadOnly();
+            }
+
+            if (propertyName == null)
+            {
+                throw new ArgumentNullException(nameof(propertyName));
+            }
+
+            CreateDictionaryIfThresholdMet();
+
+            T? existing = null;
+
+            if (_propertyDictionary != null)
+            {
+                // Fast path if item doesn't exist in dictionary.
+                if (JsonHelpers.TryAdd(_propertyDictionary, propertyName, value))
+                {
+                    assignParent?.Invoke();
+                    _propertyList.Add(new KeyValuePair<string, T?>(propertyName, value));
+                    return null;
+                }
+
+                existing = _propertyDictionary[propertyName];
+                if (ReferenceEquals(existing, value))
+                {
+                    // Ignore if the same value.
+                    return null;
+                }
+            }
+
+            int i = FindValueIndex(propertyName);
+            if (i >= 0)
+            {
+                if (_propertyDictionary != null)
+                {
+                    _propertyDictionary[propertyName] = value;
+                }
+                else
+                {
+                    KeyValuePair<string, T?> current = _propertyList[i];
+                    if (ReferenceEquals(current.Value, value))
+                    {
+                        // Ignore if the same value.
+                        return null;
+                    }
+
+                    existing = current.Value;
+                }
+
+                assignParent?.Invoke();
+                _propertyList[i] = new KeyValuePair<string, T?>(propertyName, value);
+            }
+            else
+            {
+                assignParent?.Invoke();
+                _propertyDictionary?.Add(propertyName, value);
+                _propertyList.Add(new KeyValuePair<string, T?>(propertyName, value));
+                Debug.Assert(existing == null);
+            }
+
+            return existing;
+        }
+
+        private void AddValue(string propertyName, T? value)
+        {
+            if (!TryAddValue(propertyName, value))
+            {
+                ThrowHelper.ThrowArgumentException_DuplicateKey(propertyName);
+            }
+        }
+
+        private bool TryAddValue(string propertyName, T? value)
+        {
+            if (IsReadOnly)
+            {
+                ThrowHelper.ThrowNotSupportedException_NodeCollectionIsReadOnly();
+            }
+
+            CreateDictionaryIfThresholdMet();
+
+            if (_propertyDictionary == null)
+            {
+                // Verify there are no duplicates before adding.
+                if (ContainsProperty(propertyName))
+                {
+                    return false;
+                }
+            }
+            else
+            {
+                if (!JsonHelpers.TryAdd(_propertyDictionary, propertyName, value))
+                {
+                    return false;
+                }
+            }
+
+            _propertyList.Add(new KeyValuePair<string, T?>(propertyName, value));
+            return true;
+        }
+
+        private void CreateDictionaryIfThresholdMet()
+        {
+            if (_propertyDictionary == null && _propertyList.Count > ListToDictionaryThreshold)
+            {
+                _propertyDictionary = JsonHelpers.CreateDictionaryFromCollection(_propertyList, _stringComparer);
+            }
+        }
+
+        private bool ContainsValue(T? value)
+        {
+            foreach (T? item in GetValueCollection())
+            {
+                if (ReferenceEquals(item, value))
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        public KeyValuePair<string, T?>? FindValue(T? value)
+        {
+            foreach (KeyValuePair<string, T?> item in this)
+            {
+                if (ReferenceEquals(item.Value, value))
+                {
+                    return item;
+                }
+            }
+
+            return null;
+        }
+
+        private bool ContainsProperty(string propertyName)
+        {
+            if (_propertyDictionary != null)
+            {
+                return _propertyDictionary.ContainsKey(propertyName);
+            }
+
+            foreach (KeyValuePair<string, T?> item in _propertyList)
+            {
+                if (_stringComparer.Equals(propertyName, item.Key))
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        private int FindValueIndex(string propertyName)
+        {
+            for (int i = 0; i < _propertyList.Count; i++)
+            {
+                KeyValuePair<string, T?> current = _propertyList[i];
+                if (_stringComparer.Equals(propertyName, current.Key))
+                {
+                    return i;
+                }
+            }
+
+            return -1;
+        }
+
+        public bool TryGetPropertyValue(string propertyName, out T? value) => TryGetValue(propertyName, out value);
+
+        public bool TryRemoveProperty(string propertyName, out T? existing)
+        {
+            if (IsReadOnly)
+            {
+                ThrowHelper.ThrowNotSupportedException_NodeCollectionIsReadOnly();
+            }
+
+            if (_propertyDictionary != null)
+            {
+                if (!_propertyDictionary.TryGetValue(propertyName, out existing))
+                {
+                    return false;
+                }
+
+                bool success = _propertyDictionary.Remove(propertyName);
+                Debug.Assert(success);
+            }
+
+            for (int i = 0; i < _propertyList.Count; i++)
+            {
+                KeyValuePair<string, T?> current = _propertyList[i];
+
+                if (_stringComparer.Equals(current.Key, propertyName))
+                {
+                    _propertyList.RemoveAt(i);
+                    existing = current.Value;
+                    return true;
+                }
+            }
+
+            existing = null;
+            return false;
+        }
+    }
+}
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Nodes/JsonObject.IDictionary.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Nodes/JsonObject.IDictionary.cs
index 6ac113be9e0be1..ad439d17822509 100644
--- a/src/libraries/System.Text.Json/src/System/Text/Json/Nodes/JsonObject.IDictionary.cs
+++ b/src/libraries/System.Text.Json/src/System/Text/Json/Nodes/JsonObject.IDictionary.cs
@@ -10,17 +10,7 @@ namespace System.Text.Json.Nodes
 {
     public partial class JsonObject : IDictionary<string, JsonNode?>
     {
-        private const int ListToDictionaryThreshold = 9;
-
-        private Dictionary<string, JsonNode?>? _dictionary;
-        private List<KeyValuePair<string, JsonNode?>>? _list;
-
-        /// We defer creating the comparer as long as possible in case no options were specified during creation.
-        /// In that case if later we are added to a parent with a non-null options, we use the parent options.
-        private StringComparer? _stringComparer;
-
-        private string? _lastKey;
-        private JsonNode? _lastValue;
+        private JsonPropertyDictionary<JsonNode>? _dictionary;
 
         /// <summary>
         ///   Adds an element with the provided property name and value to the <see cref="JsonObject"/>.
@@ -35,12 +25,9 @@ public partial class JsonObject : IDictionary<string, JsonNode?>
         /// </exception>
         public void Add(string propertyName, JsonNode? value)
         {
-            if (propertyName == null)
-            {
-                throw new ArgumentNullException(nameof(propertyName));
-            }
-
-            AddNode(propertyName, value);
+            InitializeIfRequired();
+            Debug.Assert(_dictionary != null);
+            _dictionary.Add(propertyName, value);
             value?.AssignParent(this);
         }
 
@@ -68,20 +55,22 @@ public void Clear()
         {
             if (_jsonElement != null)
             {
-                Debug.Assert(_list == null);
                 Debug.Assert(_dictionary == null);
                 _jsonElement = null;
                 return;
             }
 
-            foreach (JsonNode? node in GetValueCollection(this))
+            if (_dictionary == null)
+            {
+                return;
+            }
+
+            foreach (JsonNode? node in _dictionary.GetValueCollection())
             {
                 DetachParent(node);
             }
 
-            _list?.Clear();
-            _dictionary?.Clear();
-            ClearLastValueCache();
+            _dictionary.Clear();
         }
 
         /// <summary>
@@ -96,12 +85,9 @@ public void Clear()
         /// </exception>
         public bool ContainsKey(string propertyName)
         {
-            if (propertyName == null)
-            {
-                throw new ArgumentNullException(nameof(propertyName));
-            }
-
-            return ContainsNode(propertyName);
+            InitializeIfRequired();
+            Debug.Assert(_dictionary != null);
+            return _dictionary.ContainsKey(propertyName);
         }
 
         /// <summary>
@@ -111,9 +97,9 @@ public int Count
         {
             get
             {
-                CreateList();
-                Debug.Assert(_list != null);
-                return _list.Count;
+                InitializeIfRequired();
+                Debug.Assert(_dictionary != null);
+                return _dictionary.Count;
             }
         }
 
@@ -134,7 +120,10 @@ public bool Remove(string propertyName)
                 throw new ArgumentNullException(nameof(propertyName));
             }
 
-            bool success = TryRemoveNode(propertyName, out JsonNode? removedNode);
+            InitializeIfRequired();
+            Debug.Assert(_dictionary != null);
+
+            bool success = _dictionary.TryRemoveProperty(propertyName, out JsonNode? removedNode);
             if (success)
             {
                 DetachParent(removedNode);
@@ -152,16 +141,9 @@ public bool Remove(string propertyName)
         /// </returns>
         bool ICollection<KeyValuePair<string, JsonNode?>>.Contains(KeyValuePair<string, JsonNode?> item)
         {
-            foreach (KeyValuePair<string, JsonNode?> existing in this)
-            {
-                Debug.Assert(_stringComparer != null);
-                if (ReferenceEquals(item.Value, existing.Value) && _stringComparer.Equals(item.Key, existing.Key))
-                {
-                    return true;
-                }
-            }
-
-            return false;
+            InitializeIfRequired();
+            Debug.Assert(_dictionary != null);
+            return _dictionary.Contains(item);
         }
 
         /// <summary>
@@ -183,23 +165,9 @@ public bool Remove(string propertyName)
         /// </exception>
         void ICollection<KeyValuePair<string, JsonNode?>>.CopyTo(KeyValuePair<string, JsonNode?>[] array, int index)
         {
-            if (index < 0)
-            {
-                ThrowHelper.ThrowArgumentOutOfRangeException_NodeArrayIndexNegative(nameof(index));
-            }
-
-            CreateList();
-            Debug.Assert(_list != null);
-
-            foreach (KeyValuePair<string, JsonNode?> item in _list)
-            {
-                if (index >= array.Length)
-                {
-                    ThrowHelper.ThrowArgumentException_NodeArrayTooSmall(nameof(array));
-                }
-
-                array[index++] = item;
-            }
+            InitializeIfRequired();
+            Debug.Assert(_dictionary != null);
+            _dictionary.CopyTo(array, index);
         }
 
         /// <summary>
@@ -210,13 +178,9 @@ public bool Remove(string propertyName)
         /// </returns>
         public IEnumerator<KeyValuePair<string, JsonNode?>> GetEnumerator()
         {
-            CreateList();
-            Debug.Assert(_list != null);
-
-            foreach (KeyValuePair<string, JsonNode?> item in _list)
-            {
-                yield return item;
-            }
+            InitializeIfRequired();
+            Debug.Assert(_dictionary != null);
+            return _dictionary.GetEnumerator();
         }
 
         /// <summary>
@@ -233,12 +197,28 @@ public bool Remove(string propertyName)
         /// <summary>
         ///   Gets a collection containing the property names in the <see cref="JsonObject"/>.
         /// </summary>
-        ICollection<string> IDictionary<string, JsonNode?>.Keys => GetKeyCollection(this);
+        ICollection<string> IDictionary<string, JsonNode?>.Keys
+        {
+            get
+            {
+                InitializeIfRequired();
+                Debug.Assert(_dictionary != null);
+                return _dictionary.Keys;
+            }
+        }
 
         /// <summary>
         ///   Gets a collection containing the property values in the <see cref="JsonObject"/>.
         /// </summary>
-        ICollection<JsonNode?> IDictionary<string, JsonNode?>.Values => GetValueCollection(this);
+        ICollection<JsonNode?> IDictionary<string, JsonNode?>.Values
+        {
+            get
+            {
+                InitializeIfRequired();
+                Debug.Assert(_dictionary != null);
+                return _dictionary.Values;
+            }
+        }
 
         /// <summary>
         ///   Gets the value associated with the specified property name.
@@ -256,51 +236,9 @@ public bool Remove(string propertyName)
         /// </exception>
         bool IDictionary<string, JsonNode?>.TryGetValue(string propertyName, out JsonNode? jsonNode)
         {
-            if (propertyName == null)
-            {
-                throw new ArgumentNullException(nameof(propertyName));
-            }
-
-            CreateList();
-            Debug.Assert(_list != null);
-            Debug.Assert(_stringComparer != null);
-
-            if (propertyName == _lastKey)
-            {
-                // Optimize for repeating sections in code:
-                // obj.Foo.Bar.FirstProperty = value1;
-                // obj.Foo.Bar.SecondProperty = value2;
-                jsonNode = _lastValue;
-                return true;
-            }
-
-            if (_dictionary != null)
-            {
-                bool success = _dictionary.TryGetValue(propertyName, out jsonNode);
-                if (success)
-                {
-                    _lastKey = propertyName;
-                    _lastValue = jsonNode;
-                }
-
-                return success;
-            }
-            else
-            {
-                foreach (KeyValuePair<string, JsonNode?> item in _list)
-                {
-                    if (_stringComparer.Equals(propertyName, item.Key))
-                    {
-                        jsonNode = item.Value;
-                        _lastKey = propertyName;
-                        _lastValue = jsonNode;
-                        return true;
-                    }
-                }
-            }
-
-            jsonNode = null;
-            return false;
+            InitializeIfRequired();
+            Debug.Assert(_dictionary != null);
+            return _dictionary.TryGetValue(propertyName, out jsonNode);
         }
 
         /// <summary>
@@ -316,63 +254,20 @@ public bool Remove(string propertyName)
         /// </returns>
         IEnumerator IEnumerable.GetEnumerator()
         {
-            CreateList();
-            Debug.Assert(_list != null);
-
-            foreach (KeyValuePair<string, JsonNode?> item in _list)
-            {
-                yield return item;
-            }
-        }
-
-        private void CreateStringComparer()
-        {
-            bool caseInsensitive = Options?.PropertyNameCaseInsensitive == true;
-            if (caseInsensitive)
-            {
-                _stringComparer = StringComparer.OrdinalIgnoreCase;
-            }
-            else
-            {
-                _stringComparer = StringComparer.Ordinal;
-            }
-        }
-
-        private void AddNode(string propertyName, JsonNode? node)
-        {
-            CreateList();
-            Debug.Assert(_list != null);
-
-            CreateDictionaryIfThreshold();
-
-            if (_dictionary == null)
-            {
-                // Verify there are no duplicates before adding.
-                VerifyListItemMissing(propertyName);
-            }
-            else
-            {
-                _dictionary.Add(propertyName, node);
-            }
-
-            _list.Add(new KeyValuePair<string, JsonNode?>(propertyName, node));
-        }
-
-        private void ClearLastValueCache()
-        {
-            _lastKey = null;
-            _lastValue = null;
+            InitializeIfRequired();
+            Debug.Assert(_dictionary != null);
+            return _dictionary.GetEnumerator();
         }
 
-        private void CreateList()
+        private void InitializeIfRequired()
         {
-            if (_list != null)
+            if (_dictionary != null)
             {
                 return;
             }
 
-            CreateStringComparer();
-            var list = new List<KeyValuePair<string, JsonNode?>>();
+            bool caseInsensitive = Options.HasValue ? Options.Value.PropertyNameCaseInsensitive : false;
+            var dictionary = new JsonPropertyDictionary<JsonNode>(caseInsensitive);
             if (_jsonElement.HasValue)
             {
                 JsonElement jElement = _jsonElement.Value;
@@ -385,202 +280,13 @@ private void CreateList()
                         node.Parent = this;
                     }
 
-                    list.Add(new KeyValuePair<string, JsonNode?>(jElementProperty.Name, node));
+                    dictionary.Add(new KeyValuePair<string, JsonNode?>(jElementProperty.Name, node));
                 }
 
                 _jsonElement = null;
             }
 
-            _list = list;
-            CreateDictionaryIfThreshold();
-        }
-
-        private JsonNode? SetNode(string propertyName, JsonNode? node)
-        {
-            CreateList();
-            Debug.Assert(_list != null);
-
-            CreateDictionaryIfThreshold();
-
-            JsonNode? existing = null;
-
-            if (_dictionary != null)
-            {
-                // Fast path if item doesn't exist in dictionary.
-                if (JsonHelpers.TryAdd(_dictionary, propertyName, node))
-                {
-                    node?.AssignParent(this);
-                    _list.Add(new KeyValuePair<string, JsonNode?>(propertyName, node));
-                    return null;
-                }
-
-                existing = _dictionary[propertyName];
-                if (ReferenceEquals(existing, node))
-                {
-                    _lastKey = propertyName;
-                    _lastValue = node;
-
-                    // Ignore if the same value.
-                    return null;
-                }
-            }
-
-            int i = FindNodeIndex(propertyName);
-            if (i >= 0)
-            {
-                if (_dictionary != null)
-                {
-                    _dictionary[propertyName] = node;
-                }
-                else
-                {
-                    KeyValuePair<string, JsonNode?> current = _list[i];
-                    if (ReferenceEquals(current.Value, node))
-                    {
-                        // Ignore if the same value.
-                        return null;
-                    }
-
-                    existing = current.Value;
-                }
-
-                node?.AssignParent(this);
-                _list[i] = new KeyValuePair<string, JsonNode?>(propertyName, node);
-            }
-            else
-            {
-                node?.AssignParent(this);
-                _dictionary?.Add(propertyName, node);
-                _list.Add(new KeyValuePair<string, JsonNode?>(propertyName, node));
-                Debug.Assert(existing == null);
-            }
-
-            _lastKey = propertyName;
-            _lastValue = node;
-
-            return existing;
-        }
-
-        private int FindNodeIndex(string propertyName)
-        {
-            Debug.Assert(_list != null);
-            Debug.Assert(_stringComparer != null);
-
-            for (int i = 0; i < _list.Count; i++)
-            {
-                KeyValuePair<string, JsonNode?> current = _list[i];
-                if (_stringComparer.Equals(propertyName, current.Key))
-                {
-                    return i;
-                }
-            }
-
-            return -1;
-        }
-
-        private void CreateDictionaryIfThreshold()
-        {
-            Debug.Assert(_list != null);
-            Debug.Assert(_stringComparer != null);
-
-            if (_dictionary == null && _list.Count > ListToDictionaryThreshold)
-            {
-                _dictionary = JsonHelpers.CreateDictionaryFromCollection(_list, _stringComparer);
-            }
-        }
-
-        private bool ContainsNode(JsonNode? node)
-        {
-            CreateList();
-
-            foreach (JsonNode? item in GetValueCollection(this))
-            {
-                if (ReferenceEquals(item, node))
-                {
-                    return true;
-                }
-            }
-
-            return false;
-        }
-
-        private KeyValuePair<string, JsonNode?>? FindNode(JsonNode? node)
-        {
-            CreateList();
-
-            foreach (KeyValuePair<string, JsonNode?> item in this)
-            {
-                if (ReferenceEquals(item.Value, node))
-                {
-                    return item;
-                }
-            }
-
-            return null;
-        }
-
-        private bool ContainsNode(string propertyName)
-        {
-            if (_dictionary != null)
-            {
-                return _dictionary.ContainsKey(propertyName);
-            }
-
-            foreach (string item in GetKeyCollection(this))
-            {
-                Debug.Assert(_stringComparer != null);
-                if (_stringComparer.Equals(item, propertyName))
-                {
-                    return true;
-                }
-            }
-
-            return false;
-        }
-
-        private bool TryRemoveNode(string propertyName, out JsonNode? existing)
-        {
-            CreateList();
-            Debug.Assert(_list != null);
-            Debug.Assert(_stringComparer != null);
-
-            if (_dictionary != null)
-            {
-                if (!_dictionary.TryGetValue(propertyName, out existing))
-                {
-                    return false;
-                }
-
-                bool success = _dictionary.Remove(propertyName);
-                Debug.Assert(success);
-            }
-
-            for (int i = 0; i < _list.Count; i++)
-            {
-                KeyValuePair<string, JsonNode?> current = _list[i];
-
-                if (_stringComparer.Equals(current.Key, propertyName))
-                {
-                    _list.RemoveAt(i);
-                    existing = current.Value;
-                    DetachParent(existing);
-                    return true;
-                }
-            }
-
-            existing = null;
-            return false;
-        }
-
-        private void VerifyListItemMissing(string propertyName)
-        {
-            Debug.Assert(_dictionary == null);
-            Debug.Assert(_list != null);
-
-            if (ContainsNode(propertyName))
-            {
-                ThrowHelper.ThrowArgumentException_DuplicateKey(propertyName);
-            }
+            _dictionary = dictionary;
         }
     }
 }
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Nodes/JsonObject.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Nodes/JsonObject.cs
index 46d86c4fc74c61..1817fe511f9f7b 100644
--- a/src/libraries/System.Text.Json/src/System/Text/Json/Nodes/JsonObject.cs
+++ b/src/libraries/System.Text.Json/src/System/Text/Json/Nodes/JsonObject.cs
@@ -125,7 +125,9 @@ internal override void GetPath(List<string> path, JsonNode? child)
         {
             if (child != null)
             {
-                string propertyName = FindNode(child)!.Value.Key;
+                InitializeIfRequired();
+                Debug.Assert(_dictionary != null);
+                string propertyName = _dictionary.FindValue(child)!.Value.Key;
                 if (propertyName.IndexOfAny(ReadStack.SpecialCharacters) != -1)
                 {
                     path.Add($"['{propertyName}']");
@@ -144,24 +146,21 @@ internal override void GetPath(List<string> path, JsonNode? child)
 
         internal void SetItem(string propertyName, JsonNode? value)
         {
-            if (propertyName == null)
-            {
-                throw new ArgumentNullException(nameof(propertyName));
-            }
-
-            JsonNode? existing = SetNode(propertyName, value);
+            InitializeIfRequired();
+            Debug.Assert(_dictionary != null);
+            JsonNode? existing = _dictionary.SetValue(propertyName, value, () => value?.AssignParent(this));
             DetachParent(existing);
         }
 
         private void DetachParent(JsonNode? item)
         {
+            InitializeIfRequired();
+            Debug.Assert(_dictionary != null);
+
             if (item != null)
             {
                 item.Parent = null;
             }
-
-            // Prevent previous child from being returned from these cached variables.
-            ClearLastValueCache();
         }
 
         [ExcludeFromCodeCoverage] // Justification = "Design-time"
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/JsonMetadataServicesConverter.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/JsonMetadataServicesConverter.cs
index d28134eae452a1..9bc8a95c97adab 100644
--- a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/JsonMetadataServicesConverter.cs
+++ b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/JsonMetadataServicesConverter.cs
@@ -58,7 +58,7 @@ internal override bool OnTryRead(ref Utf8JsonReader reader, Type typeToConvert,
 
             if (_converterStrategy == ConverterStrategy.Object && jsonTypeInfo.PropertyCache == null)
             {
-                jsonTypeInfo.InitializeDeserializePropCache();
+                jsonTypeInfo.InitializePropCache();
             }
 
             return Converter.OnTryRead(ref reader, typeToConvert, options, ref state, out value);
@@ -79,9 +79,9 @@ jsonTypeInfo is JsonTypeInfo<T> info &&
                 return true;
             }
 
-            if (_converterStrategy == ConverterStrategy.Object && jsonTypeInfo.PropertyCacheArray == null)
+            if (_converterStrategy == ConverterStrategy.Object && jsonTypeInfo.PropertyCache == null)
             {
-                jsonTypeInfo.InitializeSerializePropCache();
+                jsonTypeInfo.InitializePropCache();
             }
 
             return Converter.OnTryWrite(writer, value, options, ref state);
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Object/ObjectDefaultConverter.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Object/ObjectDefaultConverter.cs
index 234c2c2fe076e5..89b9cdad1eeffa 100644
--- a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Object/ObjectDefaultConverter.cs
+++ b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Object/ObjectDefaultConverter.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.Collections.Generic;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
@@ -248,41 +249,34 @@ internal sealed override bool OnTryWrite(
                     }
                 }
 
-                JsonPropertyInfo? dataExtensionProperty = jsonTypeInfo.DataExtensionProperty;
-
-                int propertyCount = 0;
-                JsonPropertyInfo[]? propertyCacheArray = jsonTypeInfo.PropertyCacheArray;
-                if (propertyCacheArray != null)
+                List<KeyValuePair<string, JsonPropertyInfo?>> properties = state.Current.JsonTypeInfo.PropertyCache!.List;
+                for (int i = 0; i < properties.Count; i++)
                 {
-                    propertyCount = propertyCacheArray.Length;
+                    JsonPropertyInfo jsonPropertyInfo = properties[i].Value!;
+                    if (jsonPropertyInfo.ShouldSerialize)
+                    {
+                        // Remember the current property for JsonPath support if an exception is thrown.
+                        state.Current.DeclaredJsonPropertyInfo = jsonPropertyInfo;
+                        state.Current.NumberHandling = jsonPropertyInfo.NumberHandling;
+
+                        bool success = jsonPropertyInfo.GetMemberAndWriteJson(objectValue, ref state, writer);
+                        // Converters only return 'false' when out of data which is not possible in fast path.
+                        Debug.Assert(success);
+
+                        state.Current.EndProperty();
+                    }
                 }
 
-                for (int i = 0; i < propertyCount; i++)
+                // Write extension data after the normal properties.
+                JsonPropertyInfo? dataExtensionProperty = state.Current.JsonTypeInfo.DataExtensionProperty;
+                if (dataExtensionProperty?.ShouldSerialize == true)
                 {
-                    JsonPropertyInfo jsonPropertyInfo = propertyCacheArray![i];
-
                     // Remember the current property for JsonPath support if an exception is thrown.
-                    state.Current.DeclaredJsonPropertyInfo = jsonPropertyInfo;
-                    state.Current.NumberHandling = jsonPropertyInfo.NumberHandling;
+                    state.Current.DeclaredJsonPropertyInfo = dataExtensionProperty;
+                    state.Current.NumberHandling = dataExtensionProperty.NumberHandling;
 
-                    if (jsonPropertyInfo.ShouldSerialize)
-                    {
-                        if (jsonPropertyInfo == dataExtensionProperty)
-                        {
-                            if (!jsonPropertyInfo.GetMemberAndWriteJsonExtensionData(objectValue, ref state, writer))
-                            {
-                                return false;
-                            }
-                        }
-                        else
-                        {
-                            if (!jsonPropertyInfo.GetMemberAndWriteJson(objectValue, ref state, writer))
-                            {
-                                Debug.Assert(jsonPropertyInfo.ConverterBase.ConverterStrategy != ConverterStrategy.Value);
-                                return false;
-                            }
-                        }
-                    }
+                    bool success = dataExtensionProperty.GetMemberAndWriteJsonExtensionData(objectValue, ref state, writer);
+                    Debug.Assert(success);
 
                     state.Current.EndProperty();
                 }
@@ -306,46 +300,64 @@ internal sealed override bool OnTryWrite(
                     state.Current.ProcessedStartToken = true;
                 }
 
-                JsonPropertyInfo? dataExtensionProperty = jsonTypeInfo.DataExtensionProperty;
-
-                int propertyCount = 0;
-                JsonPropertyInfo[]? propertyCacheArray = jsonTypeInfo.PropertyCacheArray;
-                if (propertyCacheArray != null)
+                List<KeyValuePair<string, JsonPropertyInfo?>>? propertyList = state.Current.JsonTypeInfo.PropertyCache!.List!;
+                while (state.Current.EnumeratorIndex < propertyList.Count)
                 {
-                    propertyCount = propertyCacheArray.Length;
-                }
-
-                while (propertyCount > state.Current.EnumeratorIndex)
-                {
-                    JsonPropertyInfo jsonPropertyInfo = propertyCacheArray![state.Current.EnumeratorIndex];
-                    state.Current.DeclaredJsonPropertyInfo = jsonPropertyInfo;
-                    state.Current.NumberHandling = jsonPropertyInfo.NumberHandling;
-
+                    JsonPropertyInfo? jsonPropertyInfo = propertyList![state.Current.EnumeratorIndex].Value;
+                    Debug.Assert(jsonPropertyInfo != null);
                     if (jsonPropertyInfo.ShouldSerialize)
                     {
-                        if (jsonPropertyInfo == dataExtensionProperty)
+                        state.Current.DeclaredJsonPropertyInfo = jsonPropertyInfo;
+                        state.Current.NumberHandling = jsonPropertyInfo.NumberHandling;
+
+                        if (!jsonPropertyInfo.GetMemberAndWriteJson(objectValue!, ref state, writer))
                         {
-                            if (!jsonPropertyInfo.GetMemberAndWriteJsonExtensionData(objectValue!, ref state, writer))
-                            {
-                                return false;
-                            }
+                            Debug.Assert(jsonPropertyInfo.ConverterBase.ConverterStrategy != ConverterStrategy.Value ||
+                                         jsonPropertyInfo.ConverterBase.TypeToConvert == JsonTypeInfo.ObjectType);
+
+                            return false;
                         }
-                        else
+
+                        state.Current.EndProperty();
+                        state.Current.EnumeratorIndex++;
+
+                        if (ShouldFlush(writer, ref state))
                         {
-                            if (!jsonPropertyInfo.GetMemberAndWriteJson(objectValue!, ref state, writer))
-                            {
-                                Debug.Assert(jsonPropertyInfo.ConverterBase.ConverterStrategy != ConverterStrategy.Value);
-                                return false;
-                            }
+                            return false;
                         }
                     }
+                    else
+                    {
+                        state.Current.EnumeratorIndex++;
+                    }
+                }
 
-                    state.Current.EndProperty();
-                    state.Current.EnumeratorIndex++;
+                // Write extension data after the normal properties.
+                if (state.Current.EnumeratorIndex == propertyList.Count)
+                {
+                    JsonPropertyInfo? dataExtensionProperty = state.Current.JsonTypeInfo.DataExtensionProperty;
+                    if (dataExtensionProperty?.ShouldSerialize == true)
+                    {
+                        // Remember the current property for JsonPath support if an exception is thrown.
+                        state.Current.DeclaredJsonPropertyInfo = dataExtensionProperty;
+                        state.Current.NumberHandling = dataExtensionProperty.NumberHandling;
+
+                        if (!dataExtensionProperty.GetMemberAndWriteJsonExtensionData(objectValue, ref state, writer))
+                        {
+                            return false;
+                        }
 
-                    if (ShouldFlush(writer, ref state))
+                        state.Current.EndProperty();
+                        state.Current.EnumeratorIndex++;
+
+                        if (ShouldFlush(writer, ref state))
+                        {
+                            return false;
+                        }
+                    }
+                    else
                     {
-                        return false;
+                        state.Current.EnumeratorIndex++;
                     }
                 }
 
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Object/ObjectWithParameterizedConstructorConverter.Large.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Object/ObjectWithParameterizedConstructorConverter.Large.cs
index 9d761393af7263..051475001e1941 100644
--- a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Object/ObjectWithParameterizedConstructorConverter.Large.cs
+++ b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Object/ObjectWithParameterizedConstructorConverter.Large.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Buffers;
+using System.Collections.Generic;
 using System.Diagnostics;
 using System.Text.Json.Serialization.Metadata;
 
@@ -55,12 +56,16 @@ protected override void InitializeConstructorArgumentCaches(ref ReadStack state,
                 typeInfo.CreateObjectWithArgs = options.MemberAccessorStrategy.CreateParameterizedConstructor<T>(ConstructorInfo!);
             }
 
-            object[] arguments = ArrayPool<object>.Shared.Rent(typeInfo.ParameterCount);
-            foreach (JsonParameterInfo jsonParameterInfo in typeInfo.ParameterCache!.Values)
+            List<KeyValuePair<string, JsonParameterInfo?>> cache = typeInfo.ParameterCache!.List;
+            object[] arguments = ArrayPool<object>.Shared.Rent(cache.Count);
+            for (int i = 0; i < typeInfo.ParameterCount; i++)
             {
-                if (jsonParameterInfo.ShouldDeserialize)
+                JsonParameterInfo? parameterInfo = cache[i].Value;
+                Debug.Assert(parameterInfo != null);
+
+                if (parameterInfo.ShouldDeserialize)
                 {
-                    arguments[jsonParameterInfo.Position] = jsonParameterInfo.DefaultValue!;
+                    arguments[parameterInfo.Position] = parameterInfo.DefaultValue!;
                 }
             }
 
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Object/ObjectWithParameterizedConstructorConverter.Small.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Object/ObjectWithParameterizedConstructorConverter.Small.cs
index f10460374a02dd..e5f8c5ecefa22e 100644
--- a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Object/ObjectWithParameterizedConstructorConverter.Small.cs
+++ b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Object/ObjectWithParameterizedConstructorConverter.Small.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.Collections.Generic;
 using System.Diagnostics;
 using System.Text.Json.Serialization.Metadata;
 
@@ -85,8 +86,12 @@ protected override void InitializeConstructorArgumentCaches(ref ReadStack state,
 
             var arguments = new Arguments<TArg0, TArg1, TArg2, TArg3>();
 
-            foreach (JsonParameterInfo parameterInfo in typeInfo.ParameterCache!.Values)
+            List<KeyValuePair<string, JsonParameterInfo?>> cache = typeInfo.ParameterCache!.List;
+            for (int i = 0; i < typeInfo.ParameterCount; i++)
             {
+                JsonParameterInfo? parameterInfo = cache[i].Value;
+                Debug.Assert(parameterInfo != null);
+
                 if (parameterInfo.ShouldDeserialize)
                 {
                     int position = parameterInfo.Position;
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Value/ObjectConverter.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Value/ObjectConverter.cs
index 597dce6b7ef175..65b47d6507431e 100644
--- a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Value/ObjectConverter.cs
+++ b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Value/ObjectConverter.cs
@@ -24,7 +24,10 @@ public ObjectConverter()
 
         public override void Write(Utf8JsonWriter writer, object? value, JsonSerializerOptions options)
         {
-            throw new InvalidOperationException();
+            Debug.Assert(value?.GetType() == typeof(object));
+
+            writer.WriteStartObject();
+            writer.WriteEndObject();
         }
 
         internal override object ReadWithQuotes(ref Utf8JsonReader reader)
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonConverterOfT.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonConverterOfT.cs
index 6ea73dd49c9ec5..33f45fd3ceda5f 100644
--- a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonConverterOfT.cs
+++ b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonConverterOfT.cs
@@ -18,12 +18,11 @@ public abstract partial class JsonConverter<T> : JsonConverter
         /// </summary>
         protected internal JsonConverter()
         {
-            // Today only typeof(object) can have polymorphic writes.
-            // In the future, this will be check for !IsSealed (and excluding value types).
-            CanBePolymorphic = TypeToConvert == JsonTypeInfo.ObjectType;
-            IsValueType = TypeToConvert.IsValueType;
-            CanBeNull = !IsValueType || TypeToConvert.IsNullableOfT();
             IsInternalConverter = GetType().Assembly == typeof(JsonConverter).Assembly;
+            // Today only the internal JsonConverter<object> can have polymorphic writes.
+            CanBePolymorphic = IsInternalConverter && TypeToConvert == JsonTypeInfo.ObjectType;
+            IsValueType = TypeToConvert.IsValueType;
+            CanBeNull = default(T) is null;
 
             if (HandleNull)
             {
@@ -220,7 +219,12 @@ internal bool TryRead(ref Utf8JsonReader reader, Type typeToConvert, JsonSeriali
             // Remember if we were a continuation here since Push() may affect IsContinuation.
             bool wasContinuation = state.IsContinuation;
 
+#if DEBUG
+            // DEBUG: ensure push/pop operations preserve stack integrity
+            JsonTypeInfo originalJsonTypeInfo = state.Current.JsonTypeInfo;
+#endif
             state.Push();
+            Debug.Assert(TypeToConvert.IsAssignableFrom(state.Current.JsonTypeInfo.Type));
 
 #if !DEBUG
             // For performance, only perform validation on internal converters on debug builds.
@@ -257,6 +261,9 @@ internal bool TryRead(ref Utf8JsonReader reader, Type typeToConvert, JsonSeriali
 
                         value = default;
                         state.Pop(true);
+#if DEBUG
+                        Debug.Assert(ReferenceEquals(originalJsonTypeInfo, state.Current.JsonTypeInfo));
+#endif
                         return true;
                     }
 
@@ -288,6 +295,9 @@ internal bool TryRead(ref Utf8JsonReader reader, Type typeToConvert, JsonSeriali
             }
 
             state.Pop(success);
+#if DEBUG
+            Debug.Assert(ReferenceEquals(originalJsonTypeInfo, state.Current.JsonTypeInfo));
+#endif
             return success;
         }
 
@@ -298,6 +308,9 @@ internal override sealed bool TryReadAsObject(ref Utf8JsonReader reader, JsonSer
             return success;
         }
 
+        /// <summary>
+        /// Overridden by the nullable converter to prevent boxing of values by the JIT.
+        /// </summary>
         internal virtual bool IsNull(in T value) => value == null;
 
         internal bool TryWrite(Utf8JsonWriter writer, in T value, JsonSerializerOptions options, ref WriteStack state)
@@ -307,7 +320,7 @@ internal bool TryWrite(Utf8JsonWriter writer, in T value, JsonSerializerOptions
                 ThrowHelper.ThrowJsonException_SerializerCycleDetected(options.EffectiveMaxDepth);
             }
 
-            if (CanBeNull && !HandleNullOnWrite && IsNull(value))
+            if (default(T) is null && !HandleNullOnWrite && IsNull(value))
             {
                 // We do not pass null values to converters unless HandleNullOnWrite is true. Null values for properties were
                 // already handled in GetMemberAndWriteJson() so we don't need to check for IgnoreNullValues here.
@@ -317,81 +330,72 @@ internal bool TryWrite(Utf8JsonWriter writer, in T value, JsonSerializerOptions
 
             bool ignoreCyclesPopReference = false;
 
-            if (options.ReferenceHandlingStrategy == ReferenceHandlingStrategy.IgnoreCycles &&
-                // .NET types that are serialized as JSON primitive values don't need to be tracked for cycle detection e.g: string.
-                ConverterStrategy != ConverterStrategy.Value &&
-                !IsValueType && !IsNull(value))
+            if (
+#if NET5_0_OR_GREATER
+                !typeof(T).IsValueType && // treated as a constant by recent versions of the JIT.
+#else
+                !IsValueType &&
+#endif
+                value is not null)
             {
-                // Custom (user) converters shall not track references
-                //  it is responsibility of the user to break cycles in case there's any
-                //  if we compare against Preserve, objects don't get preserved when a custom converter exists
-                //  given that the custom converter executes prior to the preserve logic.
-                Debug.Assert(IsInternalConverter);
-                Debug.Assert(value != null);
 
-                ReferenceResolver resolver = state.ReferenceResolver;
-
-                // Write null to break reference cycles.
-                if (resolver.ContainsReferenceForCycleDetection(value))
+                if (options.ReferenceHandlingStrategy == ReferenceHandlingStrategy.IgnoreCycles &&
+                    // .NET types that are serialized as JSON primitive values don't need to be tracked for cycle detection e.g: string.
+                    ConverterStrategy != ConverterStrategy.Value)
                 {
-                    writer.WriteNullValue();
-                    return true;
-                }
-
-                // For boxed reference types: do not push when boxed in order to avoid false positives
-                //   when we run the ContainsReferenceForCycleDetection check for the converter of the unboxed value.
-                Debug.Assert(!CanBePolymorphic);
-                resolver.PushReferenceForCycleDetection(value);
-                ignoreCyclesPopReference = true;
-            }
+                    // Custom (user) converters shall not track references
+                    //  it is responsibility of the user to break cycles in case there's any
+                    //  if we compare against Preserve, objects don't get preserved when a custom converter exists
+                    //  given that the custom converter executes prior to the preserve logic.
+                    Debug.Assert(IsInternalConverter);
 
-            if (CanBePolymorphic)
-            {
-                if (value == null)
-                {
-                    Debug.Assert(ConverterStrategy == ConverterStrategy.Value);
-                    Debug.Assert(!state.IsContinuation);
-                    Debug.Assert(HandleNullOnWrite);
+                    ReferenceResolver resolver = state.ReferenceResolver;
 
-                    int originalPropertyDepth = writer.CurrentDepth;
-                    Write(writer, value, options);
-                    VerifyWrite(originalPropertyDepth, writer);
+                    // Write null to break reference cycles.
+                    if (resolver.ContainsReferenceForCycleDetection(value))
+                    {
+                        writer.WriteNullValue();
+                        return true;
+                    }
 
-                    return true;
+                    // For boxed reference types: do not push when boxed in order to avoid false positives
+                    //   when we run the ContainsReferenceForCycleDetection check for the converter of the unboxed value.
+                    Debug.Assert(!CanBePolymorphic);
+                    resolver.PushReferenceForCycleDetection(value);
+                    ignoreCyclesPopReference = true;
                 }
 
-                Type type = value.GetType();
-                if (type == JsonTypeInfo.ObjectType)
+                if (CanBePolymorphic)
                 {
-                    writer.WriteStartObject();
-                    writer.WriteEndObject();
-                    return true;
-                }
+                    Debug.Assert(IsInternalConverter);
 
-                if (type != TypeToConvert && IsInternalConverter)
-                {
-                    // For internal converter only: Handle polymorphic case and get the new converter.
-                    // Custom converter, even though polymorphic converter, get called for reading AND writing.
-                    JsonConverter jsonConverter = state.Current.InitializeReEntry(type, options);
-                    Debug.Assert(jsonConverter != this);
+                    Type type = value.GetType();
 
-                    if (options.ReferenceHandlingStrategy == ReferenceHandlingStrategy.IgnoreCycles &&
-                        jsonConverter.IsValueType)
+                    if (type != TypeToConvert)
                     {
-                        // For boxed value types: push the value before it gets unboxed on TryWriteAsObject.
-                        state.ReferenceResolver.PushReferenceForCycleDetection(value);
-                        ignoreCyclesPopReference = true;
-                    }
+                        // For internal converter only: Handle polymorphic case and get the new converter.
+                        // Custom converter, even though polymorphic converter, get called for reading AND writing.
+                        JsonConverter jsonConverter = state.Current.InitializeReEntry(type, options);
+                        Debug.Assert(jsonConverter != this);
 
-                    // We found a different converter; forward to that.
-                    bool success2 = jsonConverter.TryWriteAsObject(writer, value, options, ref state);
+                        if (options.ReferenceHandlingStrategy == ReferenceHandlingStrategy.IgnoreCycles &&
+                            jsonConverter.IsValueType)
+                        {
+                            // For boxed value types: push the value before it gets unboxed on TryWriteAsObject.
+                            state.ReferenceResolver.PushReferenceForCycleDetection(value);
+                            ignoreCyclesPopReference = true;
+                        }
 
-                    if (ignoreCyclesPopReference)
-                    {
-                        state.ReferenceResolver.PopReferenceForCycleDetection();
-                    }
+                        // We found a different converter; forward to that.
+                        bool success2 = jsonConverter.TryWriteAsObject(writer, value, options, ref state);
 
-                    return success2;
+                        if (ignoreCyclesPopReference)
+                        {
+                            state.ReferenceResolver.PopReferenceForCycleDetection();
+                        }
+
+                        return success2;
+                    }
                 }
             }
 
@@ -411,12 +415,30 @@ internal bool TryWrite(Utf8JsonWriter writer, in T value, JsonSerializerOptions
                 }
 
                 VerifyWrite(originalPropertyDepth, writer);
+
+                if (
+#if NET5_0_OR_GREATER
+                    !typeof(T).IsValueType && // treated as a constant by recent versions of the JIT.
+#endif
+                    ignoreCyclesPopReference)
+                {
+                    // should only be entered if we're serializing instances
+                    // of type object using the internal object converter.
+                    Debug.Assert(value?.GetType() == typeof(object) && IsInternalConverter);
+                    state.ReferenceResolver.PopReferenceForCycleDetection();
+                }
+
                 return true;
             }
 
             bool isContinuation = state.IsContinuation;
 
+#if DEBUG
+            // DEBUG: ensure push/pop operations preserve stack integrity
+            JsonTypeInfo originalJsonTypeInfo = state.Current.JsonTypeInfo;
+#endif
             state.Push();
+            Debug.Assert(TypeToConvert.IsAssignableFrom(state.Current.JsonTypeInfo.Type));
 
             if (!isContinuation)
             {
@@ -432,6 +454,9 @@ internal bool TryWrite(Utf8JsonWriter writer, in T value, JsonSerializerOptions
             }
 
             state.Pop(success);
+#if DEBUG
+            Debug.Assert(ReferenceEquals(originalJsonTypeInfo, state.Current.JsonTypeInfo));
+#endif
 
             if (ignoreCyclesPopReference)
             {
@@ -476,6 +501,7 @@ internal bool TryWriteDataExtensionProperty(Utf8JsonWriter writer, T value, Json
 
             // Ignore the naming policy for extension data.
             state.Current.IgnoreDictionaryKeyPolicy = true;
+            state.Current.DeclaredJsonPropertyInfo = state.Current.JsonTypeInfo.ElementTypeInfo!.PropertyInfoForTypeInfo;
 
             success = dictionaryConverter.OnWriteResume(writer, value, options, ref state);
             if (success)
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonSerializer.Write.Helpers.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonSerializer.Write.Helpers.cs
index 60836120d89070..cd6cd1b163b33b 100644
--- a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonSerializer.Write.Helpers.cs
+++ b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonSerializer.Write.Helpers.cs
@@ -43,6 +43,7 @@ private static void WriteUsingMetadata<TValue>(Utf8JsonWriter writer, in TValue
                 typedInfo.Options._context?.CanUseSerializationLogic == true)
             {
                 typedInfo.Serialize(writer, value);
+                writer.Flush();
             }
             else
             {
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonSerializer.Write.String.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonSerializer.Write.String.cs
index 71c30c512756c6..db52ffc079ffe3 100644
--- a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonSerializer.Write.String.cs
+++ b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonSerializer.Write.String.cs
@@ -125,9 +125,6 @@ private static string WriteUsingMetadata<TValue>(in TValue value, JsonTypeInfo?
                 throw new ArgumentNullException(nameof(jsonTypeInfo));
             }
 
-            WriteStack state = default;
-            state.Initialize(jsonTypeInfo, supportContinuation: false);
-
             JsonSerializerOptions options = jsonTypeInfo.Options;
 
             using (var output = new PooledByteBufferWriter(options.DefaultBufferSize))
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonSerializerContext.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonSerializerContext.cs
index 78843cfcda7823..77f723b59fe66d 100644
--- a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonSerializerContext.cs
+++ b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonSerializerContext.cs
@@ -37,8 +37,14 @@ internal bool CanUseSerializationLogic
                             // Guard against unsupported features
                             Options.Converters.Count == 0 &&
                             Options.Encoder == null &&
-                            Options.NumberHandling == JsonNumberHandling.Strict &&
+                            // Disallow custom number handling we'd need to honor when writing.
+                            // AllowReadingFromString and Strict are fine since there's no action to take when writing.
+                            (Options.NumberHandling & (JsonNumberHandling.WriteAsString | JsonNumberHandling.AllowNamedFloatingPointLiterals)) == 0 &&
                             Options.ReferenceHandlingStrategy == ReferenceHandlingStrategy.None &&
+#pragma warning disable SYSLIB0020
+                            !Options.IgnoreNullValues && // This property is obsolete.
+#pragma warning restore SYSLIB0020
+
                             // Ensure options values are consistent with expected defaults.
                             Options.DefaultIgnoreCondition == _defaultOptions.DefaultIgnoreCondition &&
                             Options.IgnoreReadOnlyFields == _defaultOptions.IgnoreReadOnlyFields &&
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonSerializerOptions.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonSerializerOptions.cs
index d6bb3410100480..b37f11ea941cf3 100644
--- a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonSerializerOptions.cs
+++ b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonSerializerOptions.cs
@@ -559,7 +559,12 @@ internal MemberAccessor MemberAccessorStrategy
             {
                 if (_memberAccessorStrategy == null)
                 {
-#if NETFRAMEWORK || NETCOREAPP
+#if NETCOREAPP
+                    // if dynamic code isn't supported, fallback to reflection
+                    _memberAccessorStrategy = RuntimeFeature.IsDynamicCodeSupported ?
+                        new ReflectionEmitMemberAccessor() :
+                        new ReflectionMemberAccessor();
+#elif NETFRAMEWORK
                     _memberAccessorStrategy = new ReflectionEmitMemberAccessor();
 #else
                     _memberAccessorStrategy = new ReflectionMemberAccessor();
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/JsonPropertyInfoOfT.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/JsonPropertyInfoOfT.cs
index 911ee9f3ede5ff..8e268c2509940f 100644
--- a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/JsonPropertyInfoOfT.cs
+++ b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/JsonPropertyInfoOfT.cs
@@ -234,11 +234,17 @@ internal override bool GetMemberAndWriteJson(object obj, ref WriteStack state, U
         {
             T value = Get!(obj);
 
-            if (Options.ReferenceHandlingStrategy == ReferenceHandlingStrategy.IgnoreCycles &&
-                value != null &&
+            if (
+#if NET5_0_OR_GREATER
+                !typeof(T).IsValueType && // treated as a constant by recent versions of the JIT.
+#else
+                !Converter.IsValueType &&
+#endif
+                Options.ReferenceHandlingStrategy == ReferenceHandlingStrategy.IgnoreCycles &&
+                value is not null &&
                 // .NET types that are serialized as JSON primitive values don't need to be tracked for cycle detection e.g: string.
                 // However JsonConverter<object> that uses ConverterStrategy == Value is an exception.
-                (Converter.CanBePolymorphic || (!Converter.IsValueType && ConverterStrategy != ConverterStrategy.Value)) &&
+                (Converter.CanBePolymorphic || ConverterStrategy != ConverterStrategy.Value) &&
                 state.ReferenceResolver.ContainsReferenceForCycleDetection(value))
             {
                 // If a reference cycle is detected, treat value as null.
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/JsonTypeInfo.Cache.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/JsonTypeInfo.Cache.cs
index f6cbe62a84fbb4..7b3369a90ee67d 100644
--- a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/JsonTypeInfo.Cache.cs
+++ b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/JsonTypeInfo.Cache.cs
@@ -32,15 +32,11 @@ public partial class JsonTypeInfo
         internal int ParameterCount { get; private set; }
 
         // All of the serializable parameters on a POCO constructor keyed on parameter name.
-        // Only paramaters which bind to properties are cached.
-        internal Dictionary<string, JsonParameterInfo>? ParameterCache;
+        // Only parameters which bind to properties are cached.
+        internal JsonPropertyDictionary<JsonParameterInfo>? ParameterCache;
 
         // All of the serializable properties on a POCO (except the optional extension property) keyed on property name.
-        internal Dictionary<string, JsonPropertyInfo>? PropertyCache;
-
-        // All of the serializable properties on a POCO including the optional extension property.
-        // Used for performance during serialization instead of 'PropertyCache' above.
-        internal JsonPropertyInfo[]? PropertyCacheArray;
+        internal JsonPropertyDictionary<JsonPropertyInfo>? PropertyCache;
 
         // Fast cache of constructor parameters by first JSON ordering; may not contain all parameters. Accessed before ParameterCache.
         // Use an array (instead of List<T>) for highest performance.
@@ -208,6 +204,8 @@ internal JsonPropertyInfo GetProperty(
 
             if (PropertyCache.TryGetValue(JsonHelpers.Utf8GetString(propertyName), out JsonPropertyInfo? info))
             {
+                Debug.Assert(info != null);
+
                 if (Options.PropertyNameCaseInsensitive)
                 {
                     if (propertyName.SequenceEqual(info.NameAsUtf8Bytes))
@@ -225,8 +223,8 @@ internal JsonPropertyInfo GetProperty(
                 }
                 else
                 {
-                    Debug.Assert(key == GetKey(info.NameAsUtf8Bytes!.AsSpan()));
-                    utf8PropertyName = info.NameAsUtf8Bytes!;
+                    Debug.Assert(key == GetKey(info.NameAsUtf8Bytes.AsSpan()));
+                    utf8PropertyName = info.NameAsUtf8Bytes;
                 }
             }
             else
@@ -345,6 +343,8 @@ internal JsonPropertyInfo GetProperty(
 
             if (ParameterCache.TryGetValue(JsonHelpers.Utf8GetString(propertyName), out JsonParameterInfo? info))
             {
+                Debug.Assert(info != null);
+
                 if (Options.PropertyNameCaseInsensitive)
                 {
                     if (propertyName.SequenceEqual(info.NameAsUtf8Bytes))
@@ -472,6 +472,7 @@ internal static ulong GetKey(ReadOnlySpan<byte> name)
                 }
             }
 
+#if DEBUG
             // Verify key contains the embedded bytes as expected.
             // Note: the expected properties do not hold true on big-endian platforms
             if (BitConverter.IsLittleEndian)
@@ -490,6 +491,7 @@ internal static ulong GetKey(ReadOnlySpan<byte> name)
                     (name.Length >= 0xFF || (key & ((ulong)0xFF << BitsInByte * 7)) >> BitsInByte * 7 == (ulong)name.Length) &&
                     (name.Length < 0xFF || (key & ((ulong)0xFF << BitsInByte * 7)) >> BitsInByte * 7 == 0xFF));
             }
+#endif
 
             return key;
         }
@@ -566,12 +568,12 @@ internal void UpdateSortedParameterCache(ref ReadStackFrame frame)
             frame.CtorArgumentState.ParameterRefCache = null;
         }
 
-        internal void InitializeSerializePropCache()
+        internal void InitializePropCache()
         {
-            JsonSerializerContext? context = Options._context;
+            Debug.Assert(PropertyInfoForTypeInfo.ConverterStrategy == ConverterStrategy.Object);
 
+            JsonSerializerContext? context = Options._context;
             Debug.Assert(context != null);
-            Debug.Assert(PropertyInfoForTypeInfo.ConverterStrategy == ConverterStrategy.Object);
 
             if (PropInitFunc == null)
             {
@@ -579,34 +581,19 @@ internal void InitializeSerializePropCache()
                 return;
             }
 
-            PropertyCacheArray = PropInitFunc(context);
-        }
-
-        internal void InitializeDeserializePropCache()
-        {
-            Debug.Assert(PropertyInfoForTypeInfo.ConverterStrategy == ConverterStrategy.Object);
-
-            if (PropertyCacheArray == null)
+            JsonPropertyInfo[] array = PropInitFunc(context);
+            var properties = new JsonPropertyDictionary<JsonPropertyInfo>(Options.PropertyNameCaseInsensitive, array.Length);
+            for (int i = 0; i < array.Length; i++)
             {
-                InitializeSerializePropCache();
-            }
-
-            Dictionary<string, JsonPropertyInfo> propertyCache = new(Options.PropertyNameCaseInsensitive
-                ? StringComparer.OrdinalIgnoreCase
-                : StringComparer.Ordinal);
-
-            for (int i = 0; i < PropertyCacheArray!.Length; i++)
-            {
-                JsonPropertyInfo jsonPropertyInfo = PropertyCacheArray[i];
-
-                if (!JsonHelpers.TryAdd(propertyCache, jsonPropertyInfo.NameAsString, jsonPropertyInfo))
+                JsonPropertyInfo property = array[i];
+                if (!properties.TryAdd(property.NameAsString, property))
                 {
-                    ThrowHelper.ThrowInvalidOperationException_SerializerPropertyNameConflict(Type, jsonPropertyInfo);
+                    ThrowHelper.ThrowInvalidOperationException_SerializerPropertyNameConflict(Type, property);
                 }
             }
 
             // Avoid threading issues by populating a local cache, and assigning it to the global cache after completion.
-            PropertyCache = propertyCache;
+            PropertyCache = properties;
         }
     }
 }
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/JsonTypeInfo.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/JsonTypeInfo.cs
index 2de65bf152c7cd..53ed06d9c36645 100644
--- a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/JsonTypeInfo.cs
+++ b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/JsonTypeInfo.cs
@@ -184,24 +184,29 @@ internal JsonTypeInfo(Type type, JsonConverter converter, Type runtimeType, Json
             {
                 case ConverterStrategy.Object:
                     {
+                        const BindingFlags bindingFlags =
+                            BindingFlags.Instance |
+                            BindingFlags.Public |
+                            BindingFlags.NonPublic |
+                            BindingFlags.DeclaredOnly;
+
                         CreateObject = Options.MemberAccessorStrategy.CreateConstructor(type);
-                        Dictionary<string, JsonPropertyInfo> cache = new Dictionary<string, JsonPropertyInfo>(
-                            Options.PropertyNameCaseInsensitive
-                                ? StringComparer.OrdinalIgnoreCase
-                                : StringComparer.Ordinal);
 
                         Dictionary<string, MemberInfo>? ignoredMembers = null;
 
+                        PropertyInfo[] properties = type.GetProperties(bindingFlags);
+
+                        // PropertyCache is not accessed by other threads until the current JsonTypeInfo instance
+                        //  is finished initializing and added to the cache on JsonSerializerOptions.
+                        // Default 'capacity' to the common non-polymorphic + property case.
+                        PropertyCache = new JsonPropertyDictionary<JsonPropertyInfo>(Options.PropertyNameCaseInsensitive, capacity: properties.Length);
+
                         // We start from the most derived type.
-                        for (Type? currentType = type; currentType != null; currentType = currentType.BaseType)
-                        {
-                            const BindingFlags bindingFlags =
-                                BindingFlags.Instance |
-                                BindingFlags.Public |
-                                BindingFlags.NonPublic |
-                                BindingFlags.DeclaredOnly;
+                        Type? currentType = type;
 
-                            foreach (PropertyInfo propertyInfo in currentType.GetProperties(bindingFlags))
+                        while (true)
+                        {
+                            foreach (PropertyInfo propertyInfo in properties)
                             {
                                 // Ignore indexers and virtual properties that have overrides that were [JsonIgnore]d.
                                 if (propertyInfo.GetIndexParameters().Length > 0 || PropertyIsOverridenAndIgnored(propertyInfo, ignoredMembers))
@@ -213,7 +218,12 @@ internal JsonTypeInfo(Type type, JsonConverter converter, Type runtimeType, Json
                                 if (propertyInfo.GetMethod?.IsPublic == true ||
                                     propertyInfo.SetMethod?.IsPublic == true)
                                 {
-                                    CacheMember(currentType, propertyInfo.PropertyType, propertyInfo, typeNumberHandling, cache, ref ignoredMembers);
+                                    CacheMember(
+                                        currentType,
+                                        propertyInfo.PropertyType,
+                                        propertyInfo,
+                                        typeNumberHandling,
+                                        ref ignoredMembers);
                                 }
                                 else
                                 {
@@ -239,7 +249,12 @@ internal JsonTypeInfo(Type type, JsonConverter converter, Type runtimeType, Json
                                 {
                                     if (hasJsonInclude || Options.IncludeFields)
                                     {
-                                        CacheMember(currentType, fieldInfo.FieldType, fieldInfo, typeNumberHandling, cache, ref ignoredMembers);
+                                        CacheMember(
+                                            currentType,
+                                            fieldInfo.FieldType,
+                                            fieldInfo,
+                                            typeNumberHandling,
+                                            ref ignoredMembers);
                                     }
                                 }
                                 else
@@ -252,34 +267,16 @@ internal JsonTypeInfo(Type type, JsonConverter converter, Type runtimeType, Json
                                     // Non-public fields should not be included for (de)serialization.
                                 }
                             }
-                        }
-
-                        JsonPropertyInfo[] cacheArray;
-                        if (DetermineExtensionDataProperty(cache))
-                        {
-                            // Remove from cache since it is handled independently.
-                            cache.Remove(DataExtensionProperty!.NameAsString);
-
-                            cacheArray = new JsonPropertyInfo[cache.Count + 1];
 
-                            // Set the last element to the extension property.
-                            cacheArray[cache.Count] = DataExtensionProperty;
-                        }
-                        else
-                        {
-                            cacheArray = new JsonPropertyInfo[cache.Count];
-                        }
-
-                        // Copy the dictionary cache to the array cache.
-                        cache.Values.CopyTo(cacheArray, 0);
+                            currentType = currentType.BaseType;
+                            if (currentType == null)
+                            {
+                                break;
+                            }
 
-                        // These are not accessed by other threads until the current JsonTypeInfo instance
-                        // is finished initializing and added to the cache on JsonSerializerOptions.
-                        PropertyCache = cache;
-                        PropertyCacheArray = cacheArray;
+                            properties = currentType.GetProperties(bindingFlags);
+                        };
 
-                        // Allow constructor parameter logic to remove items from the dictionary since the JSON
-                        // property values will be passed to the constructor and do not call a property setter.
                         if (converter.ConstructorIsParameterized)
                         {
                             InitializeConstructorParameters(converter.ConstructorInfo!);
@@ -320,43 +317,57 @@ private void CacheMember(
             Type memberType,
             MemberInfo memberInfo,
             JsonNumberHandling? typeNumberHandling,
-            Dictionary<string, JsonPropertyInfo> cache,
             ref Dictionary<string, MemberInfo>? ignoredMembers)
         {
+            bool hasExtensionAttribute = memberInfo.GetCustomAttribute(typeof(JsonExtensionDataAttribute)) != null;
+            if (hasExtensionAttribute && DataExtensionProperty != null)
+            {
+                ThrowHelper.ThrowInvalidOperationException_SerializationDuplicateTypeAttribute(Type, typeof(JsonExtensionDataAttribute));
+            }
+
             JsonPropertyInfo jsonPropertyInfo = AddProperty(memberInfo, memberType, declaringType, typeNumberHandling, Options);
             Debug.Assert(jsonPropertyInfo.NameAsString != null);
 
-            string memberName = memberInfo.Name;
-
-            // The JsonPropertyNameAttribute or naming policy resulted in a collision.
-            if (!JsonHelpers.TryAdd(cache, jsonPropertyInfo.NameAsString, jsonPropertyInfo))
+            if (hasExtensionAttribute)
             {
-                JsonPropertyInfo other = cache[jsonPropertyInfo.NameAsString];
+                Debug.Assert(DataExtensionProperty == null);
+                ValidateAndAssignDataExtensionProperty(jsonPropertyInfo);
+                Debug.Assert(DataExtensionProperty != null);
+            }
+            else
+            {
+                string memberName = memberInfo.Name;
 
-                if (other.IsIgnored)
+                // The JsonPropertyNameAttribute or naming policy resulted in a collision.
+                if (!PropertyCache!.TryAdd(jsonPropertyInfo.NameAsString, jsonPropertyInfo))
                 {
-                    // Overwrite previously cached property since it has [JsonIgnore].
-                    cache[jsonPropertyInfo.NameAsString] = jsonPropertyInfo;
+                    JsonPropertyInfo other = PropertyCache[jsonPropertyInfo.NameAsString]!;
+
+                    if (other.IsIgnored)
+                    {
+                        // Overwrite previously cached property since it has [JsonIgnore].
+                        PropertyCache[jsonPropertyInfo.NameAsString] = jsonPropertyInfo;
+                    }
+                    else if (
+                        // Does the current property have `JsonIgnoreAttribute`?
+                        !jsonPropertyInfo.IsIgnored &&
+                        // Is the current property hidden by the previously cached property
+                        // (with `new` keyword, or by overriding)?
+                        other.MemberInfo!.Name != memberName &&
+                        // Was a property with the same CLR name was ignored? That property hid the current property,
+                        // thus, if it was ignored, the current property should be ignored too.
+                        ignoredMembers?.ContainsKey(memberName) != true)
+                    {
+                        // We throw if we have two public properties that have the same JSON property name, and neither have been ignored.
+                        ThrowHelper.ThrowInvalidOperationException_SerializerPropertyNameConflict(Type, jsonPropertyInfo);
+                    }
+                    // Ignore the current property.
                 }
-                else if (
-                    // Does the current property have `JsonIgnoreAttribute`?
-                    !jsonPropertyInfo.IsIgnored &&
-                    // Is the current property hidden by the previously cached property
-                    // (with `new` keyword, or by overriding)?
-                    other.MemberInfo!.Name != memberName &&
-                    // Was a property with the same CLR name was ignored? That property hid the current property,
-                    // thus, if it was ignored, the current property should be ignored too.
-                    ignoredMembers?.ContainsKey(memberName) != true)
+
+                if (jsonPropertyInfo.IsIgnored)
                 {
-                    // We throw if we have two public properties that have the same JSON property name, and neither have been ignored.
-                    ThrowHelper.ThrowInvalidOperationException_SerializerPropertyNameConflict(Type, jsonPropertyInfo);
+                    (ignoredMembers ??= new Dictionary<string, MemberInfo>()).Add(memberName, memberInfo);
                 }
-                // Ignore the current property.
-            }
-
-            if (jsonPropertyInfo.IsIgnored)
-            {
-                (ignoredMembers ??= new Dictionary<string, MemberInfo>()).Add(memberName, memberInfo);
             }
         }
 
@@ -399,8 +410,7 @@ public ParameterLookupValue(JsonPropertyInfo jsonPropertyInfo)
         private void InitializeConstructorParameters(ConstructorInfo constructorInfo)
         {
             ParameterInfo[] parameters = constructorInfo.GetParameters();
-            var parameterCache = new Dictionary<string, JsonParameterInfo>(
-                parameters.Length, Options.PropertyNameCaseInsensitive ? StringComparer.OrdinalIgnoreCase : null);
+            var parameterCache = new JsonPropertyDictionary<JsonParameterInfo>(Options.PropertyNameCaseInsensitive, parameters.Length);
 
             static Type GetMemberType(MemberInfo memberInfo)
             {
@@ -416,13 +426,14 @@ static Type GetMemberType(MemberInfo memberInfo)
             // record types or anonymous types are used.
             // The property name key does not use [JsonPropertyName] or PropertyNamingPolicy since we only bind
             // the parameter name to the object property name and do not use the JSON version of the name here.
-            var nameLookup = new Dictionary<ParameterLookupKey, ParameterLookupValue>(PropertyCacheArray!.Length);
+            var nameLookup = new Dictionary<ParameterLookupKey, ParameterLookupValue>(PropertyCache!.Count);
 
-            foreach (JsonPropertyInfo jsonProperty in PropertyCacheArray!)
+            foreach (KeyValuePair<string, JsonPropertyInfo?> kvp in PropertyCache.List)
             {
+                JsonPropertyInfo jsonProperty = kvp.Value!;
                 string propertyName = jsonProperty.MemberInfo!.Name;
                 var key = new ParameterLookupKey(propertyName, GetMemberType(jsonProperty.MemberInfo));
-                var value= new ParameterLookupValue(jsonProperty);
+                var value = new ParameterLookupValue(jsonProperty);
                 if (!JsonHelpers.TryAdd(nameLookup, key, value))
                 {
                     // More than one property has the same case-insensitive name and Type.
@@ -453,17 +464,13 @@ static Type GetMemberType(MemberInfo memberInfo)
                     JsonPropertyInfo jsonPropertyInfo = matchingEntry.JsonPropertyInfo;
                     JsonParameterInfo jsonParameterInfo = AddConstructorParameter(parameterInfo, jsonPropertyInfo, Options);
                     parameterCache.Add(jsonPropertyInfo.NameAsString, jsonParameterInfo);
-
-                    // Remove property from deserialization cache to reduce the number of JsonPropertyInfos considered during JSON matching.
-                    PropertyCache!.Remove(jsonPropertyInfo.NameAsString);
                 }
-            }
-
-            // It is invalid for the extension data property to bind with a constructor argument.
-            if (DataExtensionProperty != null &&
-                parameterCache.ContainsKey(DataExtensionProperty.NameAsString))
-            {
-                ThrowHelper.ThrowInvalidOperationException_ExtensionDataCannotBindToCtorParam(DataExtensionProperty.MemberInfo!, Type, constructorInfo);
+                // It is invalid for the extension data property to bind with a constructor argument.
+                else if (DataExtensionProperty != null &&
+                    StringComparer.OrdinalIgnoreCase.Equals(paramToCheck.Name, DataExtensionProperty.NameAsString))
+                {
+                    ThrowHelper.ThrowInvalidOperationException_ExtensionDataCannotBindToCtorParam(DataExtensionProperty.MemberInfo!, Type, constructorInfo);
+                }
             }
 
             ParameterCache = parameterCache;
@@ -498,54 +505,24 @@ private static bool PropertyIsVirtual(PropertyInfo? propertyInfo)
             return propertyInfo != null && (propertyInfo.GetMethod?.IsVirtual == true || propertyInfo.SetMethod?.IsVirtual == true);
         }
 
-        private bool DetermineExtensionDataProperty(Dictionary<string, JsonPropertyInfo> cache)
+        private void ValidateAndAssignDataExtensionProperty(JsonPropertyInfo jsonPropertyInfo)
         {
-            JsonPropertyInfo? jsonPropertyInfo = GetPropertyWithUniqueAttribute(Type, typeof(JsonExtensionDataAttribute), cache);
-            if (jsonPropertyInfo != null)
+            Type memberType = jsonPropertyInfo.DeclaredPropertyType;
+            JsonConverter? converter = null;
+            if (typeof(IDictionary<string, object>).IsAssignableFrom(memberType) ||
+                typeof(IDictionary<string, JsonElement>).IsAssignableFrom(memberType) ||
+                // Avoid a reference to typeof(JsonNode) to support trimming.
+                (memberType.FullName == JsonObjectTypeName && ReferenceEquals(memberType.Assembly, GetType().Assembly)))
             {
-                JsonConverter? converter = null;
-                Type declaredPropertyType = jsonPropertyInfo.DeclaredPropertyType;
-                if (typeof(IDictionary<string, object>).IsAssignableFrom(declaredPropertyType) ||
-                    typeof(IDictionary<string, JsonElement>).IsAssignableFrom(declaredPropertyType) ||
-                    // Avoid a reference to typeof(JsonNode) to support trimming.
-                    (declaredPropertyType.FullName == JsonObjectTypeName && ReferenceEquals(declaredPropertyType.Assembly, GetType().Assembly)))
-                {
-                    converter = Options.GetConverterInternal(declaredPropertyType);
-                    Debug.Assert(converter != null);
-                }
-
-                if (converter == null)
-                {
-                    ThrowHelper.ThrowInvalidOperationException_SerializationDataExtensionPropertyInvalid(Type, jsonPropertyInfo);
-                }
-
-                DataExtensionProperty = jsonPropertyInfo;
-                return true;
+                converter = Options.GetConverterInternal(memberType);
             }
 
-            return false;
-        }
-
-        private static JsonPropertyInfo? GetPropertyWithUniqueAttribute(Type classType, Type attributeType, Dictionary<string, JsonPropertyInfo> cache)
-        {
-            JsonPropertyInfo? property = null;
-
-            foreach (JsonPropertyInfo jsonPropertyInfo in cache.Values)
+            if (converter == null)
             {
-                Debug.Assert(jsonPropertyInfo.MemberInfo != null);
-                Attribute? attribute = jsonPropertyInfo.MemberInfo.GetCustomAttribute(attributeType);
-                if (attribute != null)
-                {
-                    if (property != null)
-                    {
-                        ThrowHelper.ThrowInvalidOperationException_SerializationDuplicateTypeAttribute(classType, attributeType);
-                    }
-
-                    property = jsonPropertyInfo;
-                }
+                ThrowHelper.ThrowInvalidOperationException_SerializationDataExtensionPropertyInvalid(Type, jsonPropertyInfo);
             }
 
-            return property;
+            DataExtensionProperty = jsonPropertyInfo;
         }
 
         private static JsonParameterInfo AddConstructorParameter(
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/ReadStack.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/ReadStack.cs
index 2f0347f68332ae..c78646f45f4b16 100644
--- a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/ReadStack.cs
+++ b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/ReadStack.cs
@@ -16,16 +16,24 @@ internal struct ReadStack
         internal static readonly char[] SpecialCharacters = { '.', ' ', '\'', '/', '"', '[', ']', '(', ')', '\t', '\n', '\r', '\f', '\b', '\\', '\u0085', '\u2028', '\u2029' };
 
         /// <summary>
-        /// The number of stack frames when the continuation started.
+        /// Exposes the stackframe that is currently active.
         /// </summary>
-        private int _continuationCount;
+        public ReadStackFrame Current;
+
+        /// <summary>
+        /// Buffer containing all frames in the stack. For performance it is only populated for serialization depths > 1.
+        /// </summary>
+        private ReadStackFrame[] _stack;
 
         /// <summary>
-        /// The number of stack frames including Current. _previous will contain _count-1 higher frames.
+        /// Tracks the current depth of the stack.
         /// </summary>
         private int _count;
 
-        private List<ReadStackFrame> _previous;
+        /// <summary>
+        /// If not zero, indicates that the stack is part of a re-entrant continuation of given depth.
+        /// </summary>
+        private int _continuationCount;
 
         // State cache when deserializing objects with parameterized constructors.
         private List<ArgumentState>? _ctorArgStateCache;
@@ -35,11 +43,10 @@ internal struct ReadStack
         /// </summary>
         public long BytesConsumed;
 
-        // A field is used instead of a property to avoid value semantics.
-        public ReadStackFrame Current;
-
+        /// <summary>
+        /// Indicates that the state still contains suspended frames waiting re-entry.
+        /// </summary>
         public bool IsContinuation => _continuationCount != 0;
-        public bool IsLastContinuation => _continuationCount == _count;
 
         /// <summary>
         /// Internal flag to let us know that we need to read ahead in the inner read loop.
@@ -59,25 +66,19 @@ internal struct ReadStack
         /// </summary>
         public bool UseFastPath;
 
-        private void AddCurrent()
+        /// <summary>
+        /// Ensures that the stack buffer has sufficient capacity to hold an additional frame.
+        /// </summary>
+        private void EnsurePushCapacity()
         {
-            if (_previous == null)
-            {
-                _previous = new List<ReadStackFrame>();
-            }
-
-            if (_count > _previous.Count)
+            if (_stack is null)
             {
-                // Need to allocate a new array element.
-                _previous.Add(Current);
+                _stack = new ReadStackFrame[4];
             }
-            else
+            else if (_count - 1 == _stack.Length)
             {
-                // Use a previously allocated slot.
-                _previous[_count - 1] = Current;
+                Array.Resize(ref _stack, 2 * _stack.Length);
             }
-
-            _count++;
         }
 
         public void Initialize(Type type, JsonSerializerOptions options, bool supportContinuation)
@@ -143,8 +144,10 @@ public void Push()
                         jsonTypeInfo = Current.JsonTypeInfo.ElementTypeInfo!;
                     }
 
-                    AddCurrent();
-                    Current.Reset();
+                    EnsurePushCapacity();
+                    _stack[_count - 1] = Current;
+                    Current = default;
+                    _count++;
 
                     Current.JsonTypeInfo = jsonTypeInfo;
                     Current.JsonPropertyInfo = jsonTypeInfo.PropertyInfoForTypeInfo;
@@ -152,29 +155,26 @@ public void Push()
                     Current.NumberHandling = numberHandling ?? Current.JsonPropertyInfo.NumberHandling;
                 }
             }
-            else if (_continuationCount == 1)
-            {
-                // No need for a push since there is only one stack frame.
-                Debug.Assert(_count == 1);
-                _continuationCount = 0;
-            }
             else
             {
-                // A continuation; adjust the index.
-                Current = _previous[_count - 1];
-
-                // Check if we are done.
-                if (_count == _continuationCount)
+                // We are re-entering a continuation, adjust indices accordingly
+                if (_count++ > 0)
                 {
-                    _continuationCount = 0;
+                    Current = _stack[_count - 1];
                 }
-                else
+
+                // check if we are done
+                if (_continuationCount == _count)
                 {
-                    _count++;
+                    _continuationCount = 0;
                 }
             }
 
             SetConstructorArgumentState();
+#if DEBUG
+            // Ensure the method is always exercised in debug builds.
+            _ = JsonPath();
+#endif
         }
 
         public void Pop(bool success)
@@ -188,41 +188,34 @@ public void Pop(bool success)
                 {
                     if (_count == 1)
                     {
-                        // No need for a continuation since there is only one stack frame.
+                        // No need to copy any frames here.
                         _continuationCount = 1;
-                    }
-                    else
-                    {
-                        AddCurrent();
-                        _count--;
-                        _continuationCount = _count;
-                        _count--;
-                        Current = _previous[_count - 1];
+                        _count = 0;
+                        return;
                     }
 
-                    return;
+                    // Need to push the Current frame to the stack,
+                    // ensure that we have sufficient capacity.
+                    EnsurePushCapacity();
+                    _continuationCount = _count--;
                 }
-
-                if (_continuationCount == 1)
+                else if (--_count == 0)
                 {
-                    // No need for a pop since there is only one stack frame.
-                    Debug.Assert(_count == 1);
+                    // reached the root, no need to copy frames.
                     return;
                 }
 
-                // Update the list entry to the current value.
-                _previous[_count - 1] = Current;
-
-                Debug.Assert(_count > 0);
+                _stack[_count] = Current;
+                Current = _stack[_count - 1];
             }
             else
             {
                 Debug.Assert(_continuationCount == 0);
-            }
 
-            if (_count > 1)
-            {
-                Current = _previous[--_count -1];
+                if (--_count > 0)
+                {
+                    Current = _stack[_count - 1];
+                }
             }
 
             SetConstructorArgumentState();
@@ -240,26 +233,25 @@ public string JsonPath()
 
             for (int i = 0; i < count - 1; i++)
             {
-                AppendStackFrame(sb, _previous[i]);
+                AppendStackFrame(sb, ref _stack[i]);
             }
 
             if (_continuationCount == 0)
             {
-                AppendStackFrame(sb, Current);
+                AppendStackFrame(sb, ref Current);
             }
 
             return sb.ToString();
 
-            static void AppendStackFrame(StringBuilder sb, in ReadStackFrame frame)
+            static void AppendStackFrame(StringBuilder sb, ref ReadStackFrame frame)
             {
                 // Append the property name.
-                string? propertyName = GetPropertyName(frame);
+                string? propertyName = GetPropertyName(ref frame);
                 AppendPropertyName(sb, propertyName);
 
                 if (frame.JsonTypeInfo != null && frame.IsProcessingEnumerable())
                 {
-                    IEnumerable? enumerable = (IEnumerable?)frame.ReturnValue;
-                    if (enumerable == null)
+                    if (frame.ReturnValue is not IEnumerable enumerable)
                     {
                         return;
                     }
@@ -276,7 +268,7 @@ static void AppendStackFrame(StringBuilder sb, in ReadStackFrame frame)
                 }
             }
 
-           static int GetCount(IEnumerable enumerable)
+            static int GetCount(IEnumerable enumerable)
             {
                 if (enumerable is ICollection collection)
                 {
@@ -311,7 +303,7 @@ static void AppendPropertyName(StringBuilder sb, string? propertyName)
                 }
             }
 
-            static string? GetPropertyName(in ReadStackFrame frame)
+            static string? GetPropertyName(ref ReadStackFrame frame)
             {
                 string? propertyName = null;
 
@@ -350,10 +342,7 @@ private void SetConstructorArgumentState()
                 // A zero index indicates a new stack frame.
                 if (Current.CtorArgumentStateIndex == 0)
                 {
-                    if (_ctorArgStateCache == null)
-                    {
-                        _ctorArgStateCache = new List<ArgumentState>();
-                    }
+                    _ctorArgStateCache ??= new List<ArgumentState>();
 
                     var newState = new ArgumentState();
                     _ctorArgStateCache.Add(newState);
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/ReadStackFrame.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/ReadStackFrame.cs
index f4f64dcbb1a51d..137305f1d5b431 100644
--- a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/ReadStackFrame.cs
+++ b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/ReadStackFrame.cs
@@ -89,20 +89,5 @@ public bool IsProcessingEnumerable()
         {
             return (JsonTypeInfo.PropertyInfoForTypeInfo.ConverterStrategy & ConverterStrategy.Enumerable) != 0;
         }
-
-        public void Reset()
-        {
-            CtorArgumentStateIndex = 0;
-            CtorArgumentState = null;
-            JsonTypeInfo = null!;
-            ObjectState = StackFrameObjectState.None;
-            OriginalDepth = 0;
-            OriginalTokenType = JsonTokenType.None;
-            PropertyIndex = 0;
-            PropertyRefCache = null;
-            ReturnValue = null;
-
-            EndProperty();
-        }
     }
 }
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/WriteStack.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/WriteStack.cs
index 22f67983ec3463..e9a9f1e9e75460 100644
--- a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/WriteStack.cs
+++ b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/WriteStack.cs
@@ -16,15 +16,25 @@ namespace System.Text.Json
     internal struct WriteStack
     {
         /// <summary>
-        /// The number of stack frames when the continuation started.
+        /// Exposes the stackframe that is currently active.
         /// </summary>
-        private int _continuationCount;
+        public WriteStackFrame Current;
+
+        /// <summary>
+        /// Buffer containing all frames in the stack. For performance it is only populated for serialization depths > 1.
+        /// </summary>
+        private WriteStackFrame[] _stack;
 
         /// <summary>
-        /// The number of stack frames including Current. _previous will contain _count-1 higher frames.
+        /// Tracks the current depth of the stack.
         /// </summary>
         private int _count;
 
+        /// <summary>
+        /// If not zero, indicates that the stack is part of a re-entrant continuation of given depth.
+        /// </summary>
+        private int _continuationCount;
+
         /// <summary>
         /// Cancellation token used by converters performing async serialization (e.g. IAsyncEnumerable)
         /// </summary>
@@ -41,17 +51,15 @@ internal struct WriteStack
         /// </summary>
         public List<IAsyncDisposable>? PendingAsyncDisposables;
 
-        private List<WriteStackFrame> _previous;
-
-        // A field is used instead of a property to avoid value semantics.
-        public WriteStackFrame Current;
-
         /// <summary>
         /// The amount of bytes to write before the underlying Stream should be flushed and the
         /// current buffer adjusted to remove the processed bytes.
         /// </summary>
         public int FlushThreshold;
 
+        /// <summary>
+        /// Indicates that the state still contains suspended frames waiting re-entry.
+        /// </summary>
         public bool IsContinuation => _continuationCount != 0;
 
         // The bag of preservable references.
@@ -62,25 +70,16 @@ internal struct WriteStack
         /// </summary>
         public bool SupportContinuation;
 
-        private void AddCurrent()
+        private void EnsurePushCapacity()
         {
-            if (_previous == null)
+            if (_stack is null)
             {
-                _previous = new List<WriteStackFrame>();
+                _stack = new WriteStackFrame[4];
             }
-
-            if (_count > _previous.Count)
+            else if (_count - 1 == _stack.Length)
             {
-                // Need to allocate a new array element.
-                _previous.Add(Current);
+                Array.Resize(ref _stack, 2 * _stack.Length);
             }
-            else
-            {
-                // Use a previously allocated slot.
-                _previous[_count - 1] = Current;
-            }
-
-            _count++;
         }
 
         /// <summary>
@@ -125,8 +124,10 @@ public void Push()
                     JsonTypeInfo jsonTypeInfo = Current.GetPolymorphicJsonPropertyInfo().RuntimeTypeInfo;
                     JsonNumberHandling? numberHandling = Current.NumberHandling;
 
-                    AddCurrent();
-                    Current.Reset();
+                    EnsurePushCapacity();
+                    _stack[_count - 1] = Current;
+                    Current = default;
+                    _count++;
 
                     Current.JsonTypeInfo = jsonTypeInfo;
                     Current.DeclaredJsonPropertyInfo = jsonTypeInfo.PropertyInfoForTypeInfo;
@@ -134,27 +135,25 @@ public void Push()
                     Current.NumberHandling = numberHandling ?? Current.DeclaredJsonPropertyInfo.NumberHandling;
                 }
             }
-            else if (_continuationCount == 1)
-            {
-                // No need for a push since there is only one stack frame.
-                Debug.Assert(_count == 1);
-                _continuationCount = 0;
-            }
             else
             {
-                // A continuation, adjust the index.
-                Current = _previous[_count - 1];
-
-                // Check if we are done.
-                if (_count == _continuationCount)
+                // We are re-entering a continuation, adjust indices accordingly
+                if (_count++ > 0)
                 {
-                    _continuationCount = 0;
+                    Current = _stack[_count - 1];
                 }
-                else
+
+                // check if we are done
+                if (_continuationCount == _count)
                 {
-                    _count++;
+                    _continuationCount = 0;
                 }
             }
+
+#if DEBUG
+            // Ensure the method is always exercised in debug builds.
+            _ = PropertyPath();
+#endif
         }
 
         public void Pop(bool success)
@@ -168,33 +167,25 @@ public void Pop(bool success)
                 {
                     if (_count == 1)
                     {
-                        // No need for a continuation since there is only one stack frame.
+                        // No need to copy any frames here.
                         _continuationCount = 1;
-                        _count = 1;
-                    }
-                    else
-                    {
-                        AddCurrent();
-                        _count--;
-                        _continuationCount = _count;
-                        _count--;
-                        Current = _previous[_count - 1];
+                        _count = 0;
+                        return;
                     }
 
-                    return;
+                    // Need to push the Current frame to the stack,
+                    // ensure that we have sufficient capacity.
+                    EnsurePushCapacity();
+                    _continuationCount = _count--;
                 }
-
-                if (_continuationCount == 1)
+                else if (--_count == 0)
                 {
-                    // No need for a pop since there is only one stack frame.
-                    Debug.Assert(_count == 1);
+                    // reached the root, no need to copy frames.
                     return;
                 }
 
-                // Update the list entry to the current value.
-                _previous[_count - 1] = Current;
-
-                Debug.Assert(_count > 0);
+                _stack[_count] = Current;
+                Current = _stack[_count - 1];
             }
             else
             {
@@ -207,11 +198,11 @@ public void Pop(bool success)
                     PendingAsyncDisposables ??= new List<IAsyncDisposable>();
                     PendingAsyncDisposables.Add(Current.AsyncEnumerator);
                 }
-            }
 
-            if (_count > 1)
-            {
-                Current = _previous[--_count - 1];
+                if (--_count > 0)
+                {
+                    Current = _stack[_count - 1];
+                }
             }
         }
 
@@ -253,13 +244,10 @@ public void DisposePendingDisposablesOnException()
             DisposeFrame(Current.CollectionEnumerator, ref exception);
 
             int stackSize = Math.Max(_count, _continuationCount);
-            if (stackSize > 1)
+            for (int i = 0; i < stackSize - 1; i++)
             {
-                for (int i = 0; i < stackSize - 1; i++)
-                {
-                    Debug.Assert(_previous[i].AsyncEnumerator is null);
-                    DisposeFrame(_previous[i].CollectionEnumerator, ref exception);
-                }
+                Debug.Assert(_stack[i].AsyncEnumerator is null);
+                DisposeFrame(_stack[i].CollectionEnumerator, ref exception);
             }
 
             if (exception is not null)
@@ -294,12 +282,9 @@ public async ValueTask DisposePendingDisposablesOnExceptionAsync()
             exception = await DisposeFrame(Current.CollectionEnumerator, Current.AsyncEnumerator, exception).ConfigureAwait(false);
 
             int stackSize = Math.Max(_count, _continuationCount);
-            if (stackSize > 1)
+            for (int i = 0; i < stackSize - 1; i++)
             {
-                for (int i = 0; i < stackSize - 1; i++)
-                {
-                    exception = await DisposeFrame(_previous[i].CollectionEnumerator, _previous[i].AsyncEnumerator, exception).ConfigureAwait(false);
-                }
+                exception = await DisposeFrame(_stack[i].CollectionEnumerator, _stack[i].AsyncEnumerator, exception).ConfigureAwait(false);
             }
 
             if (exception is not null)
@@ -343,17 +328,17 @@ public string PropertyPath()
 
             for (int i = 0; i < count - 1; i++)
             {
-                AppendStackFrame(sb, _previous[i]);
+                AppendStackFrame(sb, ref _stack[i]);
             }
 
             if (_continuationCount == 0)
             {
-                AppendStackFrame(sb, Current);
+                AppendStackFrame(sb, ref Current);
             }
 
             return sb.ToString();
 
-            void AppendStackFrame(StringBuilder sb, in WriteStackFrame frame)
+            static void AppendStackFrame(StringBuilder sb, ref WriteStackFrame frame)
             {
                 // Append the property name.
                 string? propertyName = frame.DeclaredJsonPropertyInfo?.MemberInfo?.Name;
@@ -366,7 +351,7 @@ void AppendStackFrame(StringBuilder sb, in WriteStackFrame frame)
                 AppendPropertyName(sb, propertyName);
             }
 
-            void AppendPropertyName(StringBuilder sb, string? propertyName)
+            static void AppendPropertyName(StringBuilder sb, string? propertyName)
             {
                 if (propertyName != null)
                 {
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/WriteStackFrame.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/WriteStackFrame.cs
index b162b55709c300..7d9ed3b6863f34 100644
--- a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/WriteStackFrame.cs
+++ b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/WriteStackFrame.cs
@@ -120,20 +120,5 @@ public JsonConverter InitializeReEntry(Type type, JsonSerializerOptions options)
 
             return PolymorphicJsonPropertyInfo.ConverterBase;
         }
-
-        public void Reset()
-        {
-            CollectionEnumerator = null;
-            EnumeratorIndex = 0;
-            AsyncEnumerator = null;
-            AsyncEnumeratorIsPendingCompletion = false;
-            IgnoreDictionaryKeyPolicy = false;
-            JsonTypeInfo = null!;
-            OriginalDepth = 0;
-            ProcessedStartToken = false;
-            ProcessedEndToken = false;
-
-            EndProperty();
-        }
     }
 }
diff --git a/src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Tests/SerializationLogicTests.cs b/src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Tests/SerializationLogicTests.cs
index 87d8822c818ff9..daa3a4cb71ec9d 100644
--- a/src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Tests/SerializationLogicTests.cs
+++ b/src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Tests/SerializationLogicTests.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Collections.Generic;
+using System.IO;
 using System.Text.Encodings.Web;
 using System.Text.Json.Serialization;
 using Xunit;
@@ -10,6 +11,25 @@ namespace System.Text.Json.SourceGeneration.Tests
 {
     public static class SerializationLogicTests
     {
+        private static JsonSerializerOptions s_compatibleOptions = new JsonSerializerOptions
+        {
+            DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingDefault,
+            PropertyNamingPolicy = JsonNamingPolicy.CamelCase
+        };
+
+        [Theory]
+        [MemberData(nameof(GetOptionsUsingDeserializationOnlyFeatures))]
+        [MemberData(nameof(GetCompatibleOptions))]
+        public static void SerializationFuncInvokedWhenSupported(JsonSerializerOptions options)
+        {
+            JsonMessage message = new();
+
+            // Per context implementation, NotImplementedException thrown because the options are compatible, hence the serialization func is invoked.
+            JsonContext context = new(options);
+            Assert.Throws<NotImplementedException>(() => JsonSerializer.Serialize(message, context.JsonMessage));
+            Assert.Throws<NotImplementedException>(() => JsonSerializer.Serialize(message, typeof(JsonMessage), context));
+        }
+
         [Theory]
         [MemberData(nameof(GetOptionsUsingUnsupportedFeatures))]
         [MemberData(nameof(GetIncompatibleOptions))]
@@ -39,23 +59,69 @@ public static void DictionaryFastPathPrimitiveValueSupported()
             Assert.Null(DictionaryTypeContext.Default.Int32.Serialize);
         }
 
-        // Options with features that aren't supported in generated serialization funcs.
+        // Options with features that apply only to deserialization.
+        public static IEnumerable<object[]> GetOptionsUsingDeserializationOnlyFeatures()
+        {
+            yield return new object[] { new JsonSerializerOptions(s_compatibleOptions) { AllowTrailingCommas = true } };
+            yield return new object[] { new JsonSerializerOptions(s_compatibleOptions) { DefaultBufferSize = 8192 } };
+            yield return new object[] { new JsonSerializerOptions(s_compatibleOptions) { PropertyNameCaseInsensitive = true } };
+            yield return new object[] { new JsonSerializerOptions(s_compatibleOptions) { ReadCommentHandling = JsonCommentHandling.Skip } };
+            yield return new object[] { new JsonSerializerOptions(s_compatibleOptions) { NumberHandling = JsonNumberHandling.AllowReadingFromString } };
+        }
+
+        /// <summary>
+        /// Options compatible with <see cref="JsonContext.s_defaultOptions"/>.
+        /// </summary>
+        public static IEnumerable<object[]> GetCompatibleOptions()
+        {
+            yield return new object[] { s_compatibleOptions };
+            yield return new object[] { new JsonSerializerOptions(JsonSerializerDefaults.Web) { DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingDefault } };
+            yield return new object[] { new JsonSerializerOptions(s_compatibleOptions) { NumberHandling = JsonNumberHandling.Strict } };
+        }
+
+        // Options with features that aren't supported in the generated serialization funcs.
         public static IEnumerable<object[]> GetOptionsUsingUnsupportedFeatures()
         {
+            yield return new object[] { new JsonSerializerOptions(s_compatibleOptions) { Converters = { new JsonStringEnumConverter() } } };
+            yield return new object[] { new JsonSerializerOptions(s_compatibleOptions) { Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping } };
+            yield return new object[] { new JsonSerializerOptions(s_compatibleOptions) { NumberHandling = JsonNumberHandling.WriteAsString } };
+            yield return new object[] { new JsonSerializerOptions(s_compatibleOptions) { NumberHandling = JsonNumberHandling.AllowNamedFloatingPointLiterals } };
+            yield return new object[] { new JsonSerializerOptions(s_compatibleOptions) { NumberHandling = JsonNumberHandling.WriteAsString | JsonNumberHandling.AllowNamedFloatingPointLiterals } };
+            yield return new object[] { new JsonSerializerOptions(s_compatibleOptions) { ReferenceHandler = ReferenceHandler.Preserve } };
+            yield return new object[] { new JsonSerializerOptions(s_compatibleOptions) { ReferenceHandler = ReferenceHandler.IgnoreCycles } };
+#pragma warning disable SYSLIB0020 // Type or member is obsolete
+            yield return new object[] { new JsonSerializerOptions { IgnoreNullValues = true, PropertyNamingPolicy = JsonNamingPolicy.CamelCase } };
+#pragma warning restore SYSLIB0020 // Type or member is obsolete
+        }
+
+        /// <summary>
+        /// Options incompatible with <see cref="JsonContext.s_defaultOptions"/>.
+        /// </summary>
+        public static IEnumerable<object[]> GetIncompatibleOptions()
+        {
+            yield return new object[] { new JsonSerializerOptions() };
             yield return new object[] { new JsonSerializerOptions { Converters = { new JsonStringEnumConverter() } } };
             yield return new object[] { new JsonSerializerOptions { Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping } };
             yield return new object[] { new JsonSerializerOptions { NumberHandling = JsonNumberHandling.WriteAsString } };
             yield return new object[] { new JsonSerializerOptions { ReferenceHandler = ReferenceHandler.Preserve } };
             yield return new object[] { new JsonSerializerOptions { ReferenceHandler = ReferenceHandler.IgnoreCycles } };
-            yield return new object[] { new JsonSerializerOptions { ReferenceHandler = ReferenceHandler.IgnoreCycles } };
+            yield return new object[] { new JsonSerializerOptions { DefaultIgnoreCondition = JsonIgnoreCondition.Never } };
+            yield return new object[] { new JsonSerializerOptions { IgnoreReadOnlyFields = true } };
+            yield return new object[] { new JsonSerializerOptions { DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingDefault } };
+            yield return new object[] { new JsonSerializerOptions { PropertyNamingPolicy = JsonNamingPolicy.CamelCase } };
+            yield return new object[] { new JsonSerializerOptions(s_compatibleOptions) { DefaultIgnoreCondition = JsonIgnoreCondition.Never } };
+            yield return new object[] { new JsonSerializerOptions(s_compatibleOptions) { IgnoreReadOnlyFields = true } };
         }
 
-        // Options incompatible with JsonContext.s_defaultOptions below.
-        public static IEnumerable<object[]> GetIncompatibleOptions()
+        [Fact]
+        public static void WriterIsFlushedAtRootCall()
         {
-            yield return new object[] { new JsonSerializerOptions() };
-            yield return new object[] { new JsonSerializerOptions { DefaultIgnoreCondition = JsonIgnoreCondition.Never } };
-            yield return new object[] { new JsonSerializerOptions { IgnoreReadOnlyFields = true } };
+            using MemoryStream ms = new();
+            using Utf8JsonWriter writer = new(ms);
+
+            JsonSerializer.Serialize(writer, new HighLowTemps(), SerializationContext.Default.HighLowTemps);
+            Assert.Equal(18, writer.BytesCommitted);
+            Assert.Equal(0, writer.BytesPending);
         }
     }
 }
diff --git a/src/libraries/System.Text.Json/tests/System.Text.Json.Tests/JsonNode/ParseTests.cs b/src/libraries/System.Text.Json/tests/System.Text.Json.Tests/JsonNode/ParseTests.cs
index 92ce636e7c0982..5c6022f503f112 100644
--- a/src/libraries/System.Text.Json/tests/System.Text.Json.Tests/JsonNode/ParseTests.cs
+++ b/src/libraries/System.Text.Json/tests/System.Text.Json.Tests/JsonNode/ParseTests.cs
@@ -152,26 +152,38 @@ public static void InternalValueFields()
             FieldInfo elementField = typeof(JsonObject).GetField("_jsonElement", BindingFlags.Instance | BindingFlags.NonPublic);
             Assert.NotNull(elementField);
 
-            FieldInfo listField = typeof(JsonObject).GetField("_list", BindingFlags.Instance | BindingFlags.NonPublic);
+            FieldInfo jsonDictionaryField = typeof(JsonObject).GetField("_dictionary", BindingFlags.Instance | BindingFlags.NonPublic);
+            Assert.NotNull(jsonDictionaryField);
+
+            Type jsonPropertyDictionaryType = typeof(JsonObject).Assembly.GetType("System.Text.Json.JsonPropertyDictionary`1");
+            Assert.NotNull(jsonPropertyDictionaryType);
+
+            jsonPropertyDictionaryType = jsonPropertyDictionaryType.MakeGenericType(new Type[] { typeof(JsonNode) });
+
+            FieldInfo listField = jsonPropertyDictionaryType.GetField("_propertyList", BindingFlags.Instance | BindingFlags.NonPublic);
             Assert.NotNull(listField);
 
-            FieldInfo dictionaryField = typeof(JsonObject).GetField("_dictionary", BindingFlags.Instance | BindingFlags.NonPublic);
+            FieldInfo dictionaryField = jsonPropertyDictionaryType.GetField("_propertyDictionary", BindingFlags.Instance | BindingFlags.NonPublic);
             Assert.NotNull(dictionaryField);
 
             using (MemoryStream stream = new MemoryStream(SimpleTestClass.s_data))
             {
                 // Only JsonElement is present.
                 JsonNode node = JsonNode.Parse(stream);
+                object jsonDictionary = jsonDictionaryField.GetValue(node);
+                Assert.Null(jsonDictionary); // Value is null until converted from JsonElement.
                 Assert.NotNull(elementField.GetValue(node));
-                Assert.Null(listField.GetValue(node));
-                Assert.Null(dictionaryField.GetValue(node));
                 Test();
 
                 // Cause the single JsonElement to expand into individual JsonElement nodes.
                 Assert.Equal(1, node.AsObject()["MyInt16"].GetValue<int>());
                 Assert.Null(elementField.GetValue(node));
-                Assert.NotNull(listField.GetValue(node));
-                Assert.NotNull(dictionaryField.GetValue(node)); // The dictionary threshold was reached.
+
+                jsonDictionary = jsonDictionaryField.GetValue(node);
+                Assert.NotNull(jsonDictionary);
+
+                Assert.NotNull(listField.GetValue(jsonDictionary));
+                Assert.NotNull(dictionaryField.GetValue(jsonDictionary)); // The dictionary threshold was reached.
                 Test();
 
                 void Test()
diff --git a/src/libraries/System.Text.Json/tests/System.Text.Json.Tests/JsonTestHelper.cs b/src/libraries/System.Text.Json/tests/System.Text.Json.Tests/JsonTestHelper.cs
index 338445a9f51669..269469a8748393 100644
--- a/src/libraries/System.Text.Json/tests/System.Text.Json.Tests/JsonTestHelper.cs
+++ b/src/libraries/System.Text.Json/tests/System.Text.Json.Tests/JsonTestHelper.cs
@@ -25,12 +25,6 @@ internal static partial class JsonTestHelper
         public const string SingleFormatString = "G9";
 #endif
 
-        private const string CompiledNewline = @"
-";
-
-        private static readonly bool s_replaceNewlines =
-            !StringComparer.Ordinal.Equals(CompiledNewline, Environment.NewLine);
-
         public static string NewtonsoftReturnStringHelper(TextReader reader)
         {
             var sb = new StringBuilder();
@@ -812,11 +806,22 @@ public static void AssertThrows<E>(
         public static string StripWhitespace(this string value)
             => s_stripWhitespace.Replace(value, string.Empty);
 
+#if NET6_0_OR_GREATER
+        // This is needed due to the fact that git might normalize line endings when checking-out files
+        public static string NormalizeLineEndings(this string value) => value.ReplaceLineEndings();
+#else
+        private const string CompiledNewline = @"
+";
+
+        private static readonly bool s_replaceNewlines =
+            !StringComparer.Ordinal.Equals(CompiledNewline, Environment.NewLine);
+
         // Should be called only on compile-time strings
         // This is needed due to the fact that git might normalize line endings when checking-out files
         public static string NormalizeLineEndings(this string value)
             => s_replaceNewlines ?
             value.Replace(CompiledNewline, Environment.NewLine) :
             value;
+#endif
     }
 }
diff --git a/src/libraries/System.Text.Json/tests/System.Text.Json.Tests/Serialization/ConstructorTests/ConstructorTests.Exceptions.cs b/src/libraries/System.Text.Json/tests/System.Text.Json.Tests/Serialization/ConstructorTests/ConstructorTests.Exceptions.cs
index c3d5ea546c105c..6f686e3afa6be5 100644
--- a/src/libraries/System.Text.Json/tests/System.Text.Json.Tests/Serialization/ConstructorTests/ConstructorTests.Exceptions.cs
+++ b/src/libraries/System.Text.Json/tests/System.Text.Json.Tests/Serialization/ConstructorTests/ConstructorTests.Exceptions.cs
@@ -123,7 +123,7 @@ public async Task RandomReferenceMetadataNotSupported()
         public async Task ExtensionDataProperty_CannotBindTo_CtorParam()
         {
             InvalidOperationException ex = await Assert.ThrowsAsync<InvalidOperationException>(() => Serializer.DeserializeWrapper<Class_ExtData_CtorParam>("{}"));
-            string exStr = ex.ToString();
+            string exStr = ex.ToString(); // System.InvalidOperationException: 'The extension data property 'System.Collections.Generic.Dictionary`2[System.String,System.Text.Json.JsonElement] ExtensionData' on type 'System.Text.Json.Serialization.Tests.ConstructorTests+Class_ExtData_CtorParam' cannot bind with a parameter in constructor 'Void .ctor(System.Collections.Generic.Dictionary`2[System.String,System.Text.Json.JsonElement])'.'
             Assert.Contains("System.Collections.Generic.Dictionary`2[System.String,System.Text.Json.JsonElement] ExtensionData", exStr);
             Assert.Contains("System.Text.Json.Serialization.Tests.ConstructorTests+Class_ExtData_CtorParam", exStr);
             Assert.Contains("(System.Collections.Generic.Dictionary`2[System.String,System.Text.Json.JsonElement])", exStr);
diff --git a/src/libraries/System.Text.Json/tests/System.Text.Json.Tests/Serialization/CustomConverterTests/CustomConverterTests.Object.cs b/src/libraries/System.Text.Json/tests/System.Text.Json.Tests/Serialization/CustomConverterTests/CustomConverterTests.Object.cs
index 0ab7ad020de5d2..36309616eaf5f4 100644
--- a/src/libraries/System.Text.Json/tests/System.Text.Json.Tests/Serialization/CustomConverterTests/CustomConverterTests.Object.cs
+++ b/src/libraries/System.Text.Json/tests/System.Text.Json.Tests/Serialization/CustomConverterTests/CustomConverterTests.Object.cs
@@ -307,7 +307,9 @@ public override object Read(ref Utf8JsonReader reader, Type typeToConvert, JsonS
 
             public override void Write(Utf8JsonWriter writer, object value, JsonSerializerOptions options)
             {
-                throw new InvalidOperationException("Should not get here.");
+                Assert.IsType<object>(value);
+                writer.WriteStartObject();
+                writer.WriteEndObject();
             }
         }
 
@@ -732,5 +734,23 @@ static void Verify(JsonSerializerOptions options)
             options.Converters.Add(new SystemObjectNewtonsoftCompatibleConverter());
             Verify(options);
         }
+
+        [Fact]
+        public static void CanCustomizeSystemObjectSerialization()
+        {
+            var options = new JsonSerializerOptions { Converters = { new CustomSystemObjectConverter() } };
+
+            string expectedJson = "42";
+            string actualJson = JsonSerializer.Serialize(new object(), options);
+            Assert.Equal(expectedJson, actualJson);
+        }
+
+        private class CustomSystemObjectConverter : JsonConverter<object>
+        {
+            public override object? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) => throw new NotImplementedException();
+            public override void Write(Utf8JsonWriter writer, object value, JsonSerializerOptions options)
+                => writer.WriteNumberValue(42);
+        }
     }
+
 }
diff --git a/src/libraries/System.Text.Json/tests/System.Text.Json.Tests/Serialization/OptionsTests.cs b/src/libraries/System.Text.Json/tests/System.Text.Json.Tests/Serialization/OptionsTests.cs
index 06747c8778626f..f7d80c2a01e63c 100644
--- a/src/libraries/System.Text.Json/tests/System.Text.Json.Tests/Serialization/OptionsTests.cs
+++ b/src/libraries/System.Text.Json/tests/System.Text.Json.Tests/Serialization/OptionsTests.cs
@@ -328,12 +328,12 @@ public static void JsonEncodedTextStringsCustomAllowAll(string message, string e
         [Fact]
         public static void Options_GetConverterForObjectJsonElement_GivesCorrectConverter()
         {
-            GenericObjectOrJsonElementConverterTestHelper<object>("ObjectConverter", new object(), "[3]", true);
+            GenericObjectOrJsonElementConverterTestHelper<object>("ObjectConverter", new object(), "{}");
             JsonElement element = JsonDocument.Parse("[3]").RootElement;
-            GenericObjectOrJsonElementConverterTestHelper<JsonElement>("JsonElementConverter", element, "[3]", false);
+            GenericObjectOrJsonElementConverterTestHelper<JsonElement>("JsonElementConverter", element, "[3]");
         }
 
-        private static void GenericObjectOrJsonElementConverterTestHelper<T>(string converterName, object objectValue, string stringValue, bool throws)
+        private static void GenericObjectOrJsonElementConverterTestHelper<T>(string converterName, object objectValue, string stringValue)
         {
             var options = new JsonSerializerOptions();
 
@@ -347,10 +347,7 @@ private static void GenericObjectOrJsonElementConverterTestHelper<T>(string conv
 
             if (readValue is JsonElement element)
             {
-                Assert.Equal(JsonValueKind.Array, element.ValueKind);
-                JsonElement.ArrayEnumerator iterator = element.EnumerateArray();
-                Assert.True(iterator.MoveNext());
-                Assert.Equal(3, iterator.Current.GetInt32());
+                JsonTestHelper.AssertJsonEqual(stringValue, element.ToString());
             }
             else
             {
@@ -360,22 +357,14 @@ private static void GenericObjectOrJsonElementConverterTestHelper<T>(string conv
             using (var stream = new MemoryStream())
             using (var writer = new Utf8JsonWriter(stream))
             {
-                if (throws)
-                {
-                    Assert.Throws<InvalidOperationException>(() => converter.Write(writer, (T)objectValue, options));
-                    Assert.Throws<InvalidOperationException>(() => converter.Write(writer, (T)objectValue, null));
-                }
-                else
-                {
-                    converter.Write(writer, (T)objectValue, options);
-                    writer.Flush();
-                    Assert.Equal(stringValue, Encoding.UTF8.GetString(stream.ToArray()));
-
-                    writer.Reset(stream);
-                    converter.Write(writer, (T)objectValue, null); // Test with null option
-                    writer.Flush();
-                    Assert.Equal(stringValue + stringValue, Encoding.UTF8.GetString(stream.ToArray()));
-                }
+                converter.Write(writer, (T)objectValue, options);
+                writer.Flush();
+                Assert.Equal(stringValue, Encoding.UTF8.GetString(stream.ToArray()));
+
+                writer.Reset(stream);
+                converter.Write(writer, (T)objectValue, null); // Test with null option
+                writer.Flush();
+                Assert.Equal(stringValue + stringValue, Encoding.UTF8.GetString(stream.ToArray()));
             }
         }
 
diff --git a/src/libraries/System.Text.Json/tests/System.Text.Json.Tests/Serialization/ReferenceHandlerTests.IgnoreCycles.cs b/src/libraries/System.Text.Json/tests/System.Text.Json.Tests/Serialization/ReferenceHandlerTests.IgnoreCycles.cs
index 8157f9bbdf3c99..235fa8010deb87 100644
--- a/src/libraries/System.Text.Json/tests/System.Text.Json.Tests/Serialization/ReferenceHandlerTests.IgnoreCycles.cs
+++ b/src/libraries/System.Text.Json/tests/System.Text.Json.Tests/Serialization/ReferenceHandlerTests.IgnoreCycles.cs
@@ -14,7 +14,7 @@ namespace System.Text.Json.Serialization.Tests
     public class ReferenceHandlerTests_IgnoreCycles
     {
         private static readonly JsonSerializerOptions s_optionsIgnoreCycles =
-            new JsonSerializerOptions { ReferenceHandler = ReferenceHandler.IgnoreCycles };
+            new JsonSerializerOptions { ReferenceHandler = ReferenceHandler.IgnoreCycles, DefaultBufferSize = 1 };
 
         [Fact]
         public async Task IgnoreCycles_OnObject()
@@ -401,6 +401,25 @@ public async void IgnoreCycles_BoxedValueShouldNotBeIgnored()
             await Test_Serialize_And_SerializeAsync_Contains(root, expectedSubstring: @"""DayOfBirth"":15", expectedTimes: 2, s_optionsIgnoreCycles);
         }
 
+        [Fact]
+        public async Task CycleDetectionStatePersistsAcrossContinuations()
+        {
+            string expectedValueJson = @"{""LargePropertyName"":""A large-ish string to force continuations"",""Nested"":null}";
+            var recVal = new RecursiveValue { LargePropertyName = "A large-ish string to force continuations" };
+            recVal.Nested = recVal;
+
+            var value = new List<RecursiveValue> { recVal, recVal };
+            string expectedJson = $"[{expectedValueJson},{expectedValueJson}]";
+
+            await Test_Serialize_And_SerializeAsync(value, expectedJson, s_optionsIgnoreCycles);
+        }
+
+        public class RecursiveValue
+        {
+            public string LargePropertyName { get; set; }
+            public RecursiveValue? Nested { get; set; }
+        }
+
         private async Task Test_Serialize_And_SerializeAsync<T>(T obj, string expected, JsonSerializerOptions options)
         {
             string json;
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 ee40bac56dac3b..7395d6f54e999a 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
@@ -361,7 +361,7 @@ public int GroupNumberFromName(string name)
             else
             {
                 // Otherwise, try to parse it as a number.
-                return uint.TryParse(name, NumberStyles.None, provider: null, out uint result) && result < capsize ? (int)result : -1;
+                return uint.TryParse(name, NumberStyles.None, CultureInfo.InvariantCulture, out uint result) && result < capsize ? (int)result : -1;
             }
         }
 
diff --git a/src/libraries/System.Threading.AccessControl/ref/System.Threading.AccessControl.csproj b/src/libraries/System.Threading.AccessControl/ref/System.Threading.AccessControl.csproj
index 439a5aac186c40..396bb7caf52f38 100644
--- a/src/libraries/System.Threading.AccessControl/ref/System.Threading.AccessControl.csproj
+++ b/src/libraries/System.Threading.AccessControl/ref/System.Threading.AccessControl.csproj
@@ -8,8 +8,8 @@
     <Compile Include="System.Threading.AccessControl.cs" Condition="'$(TargetFramework)' != 'net461'" />
     <Compile Include="System.Threading.AccessControl.net461.cs" Condition="'$(TargetFramework)' == 'net461'" />
   </ItemGroup>
-  <ItemGroup Condition="'$(TargetFramework)' != 'net461'">
-    <ProjectReference Include="..\..\System.Security.AccessControl\ref\System.Security.AccessControl.csproj" />
-    <ProjectReference Include="..\..\System.Security.Principal.Windows\ref\System.Security.Principal.Windows.csproj" />
+  <ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">
+    <PackageReference Include="System.Security.AccessControl" Version="$(SystemSecurityAccessControlVersion)" />
+    <PackageReference Include="System.Security.Principal.Windows" Version="$(SystemSecurityPrincipalWindowsVersion)" />
   </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/src/libraries/System.Threading.AccessControl/src/System.Threading.AccessControl.csproj b/src/libraries/System.Threading.AccessControl/src/System.Threading.AccessControl.csproj
index a63c89a8547292..4e2e14f344db1f 100644
--- a/src/libraries/System.Threading.AccessControl/src/System.Threading.AccessControl.csproj
+++ b/src/libraries/System.Threading.AccessControl/src/System.Threading.AccessControl.csproj
@@ -1,19 +1,19 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFrameworks>netstandard2.0-windows;net461-windows;netstandard2.0</TargetFrameworks>
+    <TargetFrameworks>netstandard2.0-windows;netstandard2.0;net461-windows</TargetFrameworks>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <Nullable>enable</Nullable>
   </PropertyGroup>
   <!-- DesignTimeBuild requires all the TargetFramework Derived Properties to not be present in the first property group. -->
   <PropertyGroup>
-    <GeneratePlatformNotSupportedAssemblyMessage Condition="$(TargetFramework.StartsWith('netstandard')) and '$(TargetsWindows)' != 'true'">SR.PlatformNotSupported_AccessControl</GeneratePlatformNotSupportedAssemblyMessage>
-    <IsPartialFacadeAssembly Condition="$(TargetFramework.StartsWith('net4'))">true</IsPartialFacadeAssembly>
+    <IsPartialFacadeAssembly Condition="$([MSBuild]::GetTargetFrameworkIdentifier('$(TargetFramework)')) == '.NETFramework'">true</IsPartialFacadeAssembly>
+    <GeneratePlatformNotSupportedAssemblyMessage Condition="'$(IsPartialFacadeAssembly)' != 'true' and '$(TargetsWindows)' != 'true'">SR.PlatformNotSupported_AccessControl</GeneratePlatformNotSupportedAssemblyMessage>
   </PropertyGroup>
   <ItemGroup Condition="'$(TargetsWindows)' == 'true'">
     <Compile Include="$(CommonPath)Interop\Windows\Kernel32\Interop.MAX_PATH.cs"
              Link="Interop\Windows\Kernel32\Interop.MAX_PATH.cs" />
   </ItemGroup>
-  <ItemGroup Condition="$(TargetFramework.StartsWith('netstandard')) and '$(TargetsWindows)' == 'true'">
+  <ItemGroup Condition="'$(IsPartialFacadeAssembly)' != 'true' and '$(TargetsWindows)' == 'true'">
     <Compile Include="$(CommonPath)Interop\Windows\Interop.Errors.cs"
              Link="Common\Interop\Windows\Interop.Errors.cs" />
     <Compile Include="$(CommonPath)Interop\Windows\Interop.BOOL.cs"
@@ -44,16 +44,16 @@
     <Compile Include="System\Threading\SemaphoreAcl.cs" />
     <Compile Include="System\Threading\ThreadingAclExtensions.cs" />
   </ItemGroup>
-  <ItemGroup Condition="$(TargetFramework.StartsWith('net4'))">
+  <ItemGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETFramework'">
     <Compile Include="System\Threading\EventWaitHandleAcl.net46.cs" />
     <Compile Include="System\Threading\MutexAcl.net46.cs" />
     <Compile Include="System\Threading\SemaphoreAcl.net46.cs" />
     <Compile Include="System\Threading\ThreadingAclExtensions.net46.cs" />
   </ItemGroup>
-  <ItemGroup Condition="$(TargetFramework.StartsWith('netstandard2.0'))">
+  <ItemGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETStandard'">
     <PackageReference Include="System.Memory" Version="$(SystemMemoryVersion)" />
+    <PackageReference Include="System.Security.AccessControl" Version="$(SystemSecurityAccessControlVersion)" />
+    <PackageReference Include="System.Security.Principal.Windows" Version="$(SystemSecurityPrincipalWindowsVersion)" />
     <ProjectReference Include="$(LibrariesProjectRoot)System.Runtime.CompilerServices.Unsafe\src\System.Runtime.CompilerServices.Unsafe.ilproj" />
-    <ProjectReference Include="$(LibrariesProjectRoot)System.Security.AccessControl\src\System.Security.AccessControl.csproj" />
-    <ProjectReference Include="$(LibrariesProjectRoot)System.Security.Principal.Windows\src\System.Security.Principal.Windows.csproj" />
   </ItemGroup>
 </Project>
diff --git a/src/libraries/System.Threading.Channels/ref/System.Threading.Channels.cs b/src/libraries/System.Threading.Channels/ref/System.Threading.Channels.cs
index 8c093689cb84f3..4e4e4aeff965c7 100644
--- a/src/libraries/System.Threading.Channels/ref/System.Threading.Channels.cs
+++ b/src/libraries/System.Threading.Channels/ref/System.Threading.Channels.cs
@@ -45,9 +45,11 @@ public abstract partial class ChannelReader<T>
     {
         protected ChannelReader() { }
         public virtual bool CanCount { get { throw null; } }
+        public virtual bool CanPeek { get { throw null; } }
         public virtual System.Threading.Tasks.Task Completion { get { throw null; } }
         public virtual int Count { get { throw null; } }
         public virtual System.Threading.Tasks.ValueTask<T> ReadAsync(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
+        public virtual bool TryPeek([System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute(false)] out T item) { throw null; }
         public abstract bool TryRead([System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute(false)] out T item);
         public abstract System.Threading.Tasks.ValueTask<bool> WaitToReadAsync(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken));
     }
diff --git a/src/libraries/System.Threading.Channels/ref/System.Threading.Channels.csproj b/src/libraries/System.Threading.Channels/ref/System.Threading.Channels.csproj
index b1b6add200ce35..02b0092f908346 100644
--- a/src/libraries/System.Threading.Channels/ref/System.Threading.Channels.csproj
+++ b/src/libraries/System.Threading.Channels/ref/System.Threading.Channels.csproj
@@ -1,7 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <TargetFrameworks>$(NetCoreAppCurrent);netcoreapp3.1;netstandard2.1;netstandard2.0;net461</TargetFrameworks>
-    <ExcludeCurrentNetCoreAppFromPackage>true</ExcludeCurrentNetCoreAppFromPackage>
     <Nullable>enable</Nullable>
   </PropertyGroup>
   <ItemGroup>
diff --git a/src/libraries/System.Threading.Channels/src/System.Threading.Channels.csproj b/src/libraries/System.Threading.Channels/src/System.Threading.Channels.csproj
index 9fd61f126bfa46..54bdd1c1738686 100644
--- a/src/libraries/System.Threading.Channels/src/System.Threading.Channels.csproj
+++ b/src/libraries/System.Threading.Channels/src/System.Threading.Channels.csproj
@@ -1,7 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <TargetFrameworks>$(NetCoreAppCurrent);netcoreapp3.1;netstandard2.1;netstandard2.0;net461</TargetFrameworks>
-    <ExcludeCurrentNetCoreAppFromPackage>true</ExcludeCurrentNetCoreAppFromPackage>
     <Nullable>enable</Nullable>
   </PropertyGroup>
   <ItemGroup>
diff --git a/src/libraries/System.Threading.Channels/src/System/Collections/Generic/Deque.cs b/src/libraries/System.Threading.Channels/src/System/Collections/Generic/Deque.cs
index e0fbdb6268682e..90fb36692d1e3e 100644
--- a/src/libraries/System.Threading.Channels/src/System/Collections/Generic/Deque.cs
+++ b/src/libraries/System.Threading.Channels/src/System/Collections/Generic/Deque.cs
@@ -63,6 +63,12 @@ public T DequeueHead()
             return item;
         }
 
+        public T PeekHead()
+        {
+            Debug.Assert(!IsEmpty); // caller's responsibility to make sure there are elements remaining
+            return _array[_head];
+        }
+
         public T DequeueTail()
         {
             Debug.Assert(!IsEmpty); // caller's responsibility to make sure there are elements remaining
diff --git a/src/libraries/System.Threading.Channels/src/System/Threading/Channels/BoundedChannel.cs b/src/libraries/System.Threading.Channels/src/System/Threading/Channels/BoundedChannel.cs
index bc7b18fd348855..d68f1d72ddae18 100644
--- a/src/libraries/System.Threading.Channels/src/System/Threading/Channels/BoundedChannel.cs
+++ b/src/libraries/System.Threading.Channels/src/System/Threading/Channels/BoundedChannel.cs
@@ -74,6 +74,8 @@ internal BoundedChannelReader(BoundedChannel<T> parent)
 
             public override bool CanCount => true;
 
+            public override bool CanPeek => true;
+
             public override int Count
             {
                 get
@@ -113,6 +115,25 @@ public override bool TryRead([MaybeNullWhen(false)] out T item)
                 return false;
             }
 
+            public override bool TryPeek([MaybeNullWhen(false)] out T item)
+            {
+                BoundedChannel<T> parent = _parent;
+                lock (parent.SyncObj)
+                {
+                    parent.AssertInvariants();
+
+                    // Peek at an item if there is one.
+                    if (!parent._items.IsEmpty)
+                    {
+                        item = parent._items.PeekHead();
+                        return true;
+                    }
+                }
+
+                item = default;
+                return false;
+            }
+
             public override ValueTask<T> ReadAsync(CancellationToken cancellationToken)
             {
                 if (cancellationToken.IsCancellationRequested)
diff --git a/src/libraries/System.Threading.Channels/src/System/Threading/Channels/ChannelReader.cs b/src/libraries/System.Threading.Channels/src/System/Threading/Channels/ChannelReader.cs
index 1c3f12e0993fb6..ee184dd13bb315 100644
--- a/src/libraries/System.Threading.Channels/src/System/Threading/Channels/ChannelReader.cs
+++ b/src/libraries/System.Threading.Channels/src/System/Threading/Channels/ChannelReader.cs
@@ -21,6 +21,9 @@ public abstract partial class ChannelReader<T>
         /// <summary>Gets whether <see cref="Count"/> is available for use on this <see cref="ChannelReader{T}"/> instance.</summary>
         public virtual bool CanCount => false;
 
+        /// <summary>Gets whether <see cref="TryPeek"/> is available for use on this <see cref="ChannelReader{T}"/> instance.</summary>
+        public virtual bool CanPeek => false;
+
         /// <summary>Gets the current number of items available from this channel reader.</summary>
         /// <exception cref="NotSupportedException">Counting is not supported on this instance.</exception>
         public virtual int Count => throw new NotSupportedException();
@@ -30,6 +33,15 @@ public abstract partial class ChannelReader<T>
         /// <returns>true if an item was read; otherwise, false if no item was read.</returns>
         public abstract bool TryRead([MaybeNullWhen(false)] out T item);
 
+        /// <summary>Attempts to peek at an item from the channel.</summary>
+        /// <param name="item">The peeked item, or a default value if no item could be peeked.</param>
+        /// <returns>true if an item was read; otherwise, false if no item was read.</returns>
+        public virtual bool TryPeek([MaybeNullWhen(false)] out T item)
+        {
+            item = default;
+            return false;
+        }
+
         /// <summary>Returns a <see cref="ValueTask{Boolean}"/> that will complete when data is available to read.</summary>
         /// <param name="cancellationToken">A <see cref="CancellationToken"/> used to cancel the wait operation.</param>
         /// <returns>
diff --git a/src/libraries/System.Threading.Channels/src/System/Threading/Channels/SingleConsumerUnboundedChannel.cs b/src/libraries/System.Threading.Channels/src/System/Threading/Channels/SingleConsumerUnboundedChannel.cs
index ec795e64b84b2c..9d099c4a747ff0 100644
--- a/src/libraries/System.Threading.Channels/src/System/Threading/Channels/SingleConsumerUnboundedChannel.cs
+++ b/src/libraries/System.Threading.Channels/src/System/Threading/Channels/SingleConsumerUnboundedChannel.cs
@@ -65,6 +65,8 @@ internal UnboundedChannelReader(SingleConsumerUnboundedChannel<T> parent)
 
             public override Task Completion => _parent._completion.Task;
 
+            public override bool CanPeek => true;
+
             public override ValueTask<T> ReadAsync(CancellationToken cancellationToken)
             {
                 if (cancellationToken.IsCancellationRequested)
@@ -132,6 +134,9 @@ public override bool TryRead([MaybeNullWhen(false)] out T item)
                 return false;
             }
 
+            public override bool TryPeek([MaybeNullWhen(false)] out T item) =>
+                _parent._items.TryPeek(out item);
+
             public override ValueTask<bool> WaitToReadAsync(CancellationToken cancellationToken)
             {
                 // Outside of the lock, check if there are any items waiting to be read.  If there are, we're done.
diff --git a/src/libraries/System.Threading.Channels/src/System/Threading/Channels/UnboundedChannel.cs b/src/libraries/System.Threading.Channels/src/System/Threading/Channels/UnboundedChannel.cs
index b534aabe5b8df8..62c7a86f177a12 100644
--- a/src/libraries/System.Threading.Channels/src/System/Threading/Channels/UnboundedChannel.cs
+++ b/src/libraries/System.Threading.Channels/src/System/Threading/Channels/UnboundedChannel.cs
@@ -56,6 +56,8 @@ internal UnboundedChannelReader(UnboundedChannel<T> parent)
 
             public override bool CanCount => true;
 
+            public override bool CanPeek => true;
+
             public override int Count => _parent._items.Count;
 
             public override ValueTask<T> ReadAsync(CancellationToken cancellationToken)
@@ -123,6 +125,9 @@ public override bool TryRead([MaybeNullWhen(false)] out T item)
                 return false;
             }
 
+            public override bool TryPeek([MaybeNullWhen(false)] out T item) =>
+                _parent._items.TryPeek(out item);
+
             private void CompleteIfDone(UnboundedChannel<T> parent)
             {
                 if (parent._doneWriting != null && parent._items.IsEmpty)
diff --git a/src/libraries/System.Threading.Channels/tests/ChannelTestBase.cs b/src/libraries/System.Threading.Channels/tests/ChannelTestBase.cs
index a345de444978ac..fb12696415f7bb 100644
--- a/src/libraries/System.Threading.Channels/tests/ChannelTestBase.cs
+++ b/src/libraries/System.Threading.Channels/tests/ChannelTestBase.cs
@@ -354,6 +354,7 @@ public void TryRead_DataAvailable_Success()
         {
             Channel<int> c = CreateChannel();
             ValueTask write = c.Writer.WriteAsync(42);
+            Assert.True(write.IsCompletedSuccessfully);
             Assert.True(c.Reader.TryRead(out int result));
             Assert.Equal(42, result);
         }
@@ -363,7 +364,51 @@ public void TryRead_AfterComplete_ReturnsFalse()
         {
             Channel<int> c = CreateChannel();
             c.Writer.Complete();
-            Assert.False(c.Reader.TryRead(out int result));
+            Assert.False(c.Reader.TryRead(out _));
+        }
+
+        [Fact]
+        public void TryPeek_SucceedsWhenDataAvailable()
+        {
+            Channel<int> c = CreateChannel();
+
+            Assert.True(c.Reader.CanPeek); // all built-in readers support peeking
+
+            for (int i = 0; i < 3; i++)
+            {
+                // Write a value
+                Assert.True(c.Writer.WriteAsync(42).IsCompletedSuccessfully);
+
+                // Can peek at the written value
+                Assert.True(c.Reader.TryPeek(out int peekedResult));
+                Assert.Equal(42, peekedResult);
+
+                // Can still read out that value
+                Assert.True(c.Reader.TryRead(out int readResult));
+                Assert.Equal(42, readResult);
+
+                // Peeking no longer finds it
+                Assert.False(c.Reader.TryPeek(out int noResult));
+                Assert.Equal(0, noResult);
+            }
+
+            // Write another value
+            Assert.True(c.Writer.WriteAsync(84).IsCompletedSuccessfully);
+
+            // Mark as completed
+            c.Writer.Complete();
+
+            // Can peek at the written value
+            Assert.True(c.Reader.TryPeek(out int lastPeekedResult));
+            Assert.Equal(84, lastPeekedResult);
+
+            // Can still read out that value
+            Assert.True(c.Reader.TryRead(out int lastReadResult));
+            Assert.Equal(84, lastReadResult);
+
+            // Peeking no longer finds it
+            Assert.False(c.Reader.TryPeek(out int lastNoResult));
+            Assert.Equal(0, lastNoResult);
         }
 
         [Fact]
diff --git a/src/libraries/System.Threading.Channels/tests/ChannelTests.cs b/src/libraries/System.Threading.Channels/tests/ChannelTests.cs
index c5c37b66938a16..2765e66d4f346a 100644
--- a/src/libraries/System.Threading.Channels/tests/ChannelTests.cs
+++ b/src/libraries/System.Threading.Channels/tests/ChannelTests.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
@@ -164,6 +165,15 @@ public async Task TestBaseClassReadAsync()
             await Assert.ThrowsAsync<ChannelClosedException>(() => readTask.AsTask());
         }
 
+        [Fact]
+        public void TestBaseClassTryPeek()
+        {
+            var reader = new TryPeekNoOverrideReader<int>();
+            Assert.False(reader.CanPeek);
+            Assert.False(reader.TryPeek(out int item));
+            Assert.Equal(0, item);
+        }
+
         // This reader doesn't override ReadAsync to force using the base class ReadAsync method
         private sealed class WrapperChannelReader<T> : ChannelReader<T>
         {
@@ -216,7 +226,6 @@ private sealed class TestChannelReader<T> : ChannelReader<T>
         {
             private Random _rand = new Random(42);
             private IEnumerator<T> _enumerator;
-            private int _count;
             private bool _closed;
 
             public TestChannelReader(IEnumerable<T> enumerable) => _enumerator = enumerable.GetEnumerator();
@@ -240,7 +249,6 @@ public override bool TryRead(out T item)
                 }
 
                 // Otherwise return the next item.
-                _count++;
                 item = _enumerator.Current;
                 return true;
             }
@@ -263,6 +271,17 @@ private sealed class TryReadThrowingReader<T> : ChannelReader<T>
             public override ValueTask<bool> WaitToReadAsync(CancellationToken cancellationToken = default) => throw new DriveNotFoundException();
         }
 
+        private sealed class TryPeekNoOverrideReader<T> : ChannelReader<T>
+        {
+            public override bool TryRead([MaybeNullWhen(false)] out T item)
+            {
+                item = default;
+                return false;
+            }
+
+            public override ValueTask<bool> WaitToReadAsync(CancellationToken cancellationToken) => default;
+        }
+
         private sealed class CanReadFalseStream : MemoryStream
         {
             public override bool CanRead => false;
diff --git a/src/libraries/System.Threading.Channels/tests/Stress.cs b/src/libraries/System.Threading.Channels/tests/Stress.cs
index fe59da5d6ccc89..ffae1e8ce88fbc 100644
--- a/src/libraries/System.Threading.Channels/tests/Stress.cs
+++ b/src/libraries/System.Threading.Channels/tests/Stress.cs
@@ -50,12 +50,14 @@ public static IEnumerable<object[]> ReadWriteVariations_TestData()
 
         private static async Task<bool> ReadSynchronous(ChannelReader<int> reader)
         {
-            while (!reader.TryRead(out int value))
+            while (!reader.TryRead(out _))
             {
                 if (!await reader.WaitToReadAsync())
                 {
                     return false;
                 }
+
+                reader.TryPeek(out _);
             }
 
             return true;
diff --git a/src/libraries/System.Threading.Tasks.Dataflow/ref/System.Threading.Tasks.Dataflow.csproj b/src/libraries/System.Threading.Tasks.Dataflow/ref/System.Threading.Tasks.Dataflow.csproj
index 6a5bb818fe9b7e..925e102aaee110 100644
--- a/src/libraries/System.Threading.Tasks.Dataflow/ref/System.Threading.Tasks.Dataflow.csproj
+++ b/src/libraries/System.Threading.Tasks.Dataflow/ref/System.Threading.Tasks.Dataflow.csproj
@@ -1,11 +1,14 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFrameworks>netstandard2.1;netstandard2.0;net461</TargetFrameworks>
+    <TargetFrameworks>$(NetCoreAppCurrent);netstandard2.1;netstandard2.0;net461</TargetFrameworks>
     <Nullable>enable</Nullable>
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="System.Threading.Tasks.Dataflow.cs" />
     <Compile Include="System.Threading.Tasks.Dataflow.netstandard21.cs"
-             Condition="'$(TargetFramework)' == 'netstandard2.1'" />
+             Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'netstandard2.1'))" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == '$(NetCoreAppCurrent)'">
+    <ProjectReference Include="$(LibrariesProjectRoot)System.Runtime\ref\System.Runtime.csproj" />
   </ItemGroup>
 </Project>
diff --git a/src/libraries/System.Threading.Tasks.Dataflow/src/System.Threading.Tasks.Dataflow.csproj b/src/libraries/System.Threading.Tasks.Dataflow/src/System.Threading.Tasks.Dataflow.csproj
index 0625f1b876b92f..2a87946567c2b4 100644
--- a/src/libraries/System.Threading.Tasks.Dataflow/src/System.Threading.Tasks.Dataflow.csproj
+++ b/src/libraries/System.Threading.Tasks.Dataflow/src/System.Threading.Tasks.Dataflow.csproj
@@ -1,7 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <TargetFrameworks>$(NetCoreAppCurrent);netstandard2.1;netstandard2.0;net461</TargetFrameworks>
-    <ExcludeCurrentNetCoreAppFromPackage>true</ExcludeCurrentNetCoreAppFromPackage>
     <Nullable>enable</Nullable>
   </PropertyGroup>
   <ItemGroup>
@@ -58,6 +57,7 @@
     <Reference Include="System.Threading" />
     <Reference Include="System.Threading.Thread" />
     <Reference Include="System.Threading.ThreadPool" />
+    <Reference Include="System.Threading.Timer" />
   </ItemGroup>
   <ItemGroup Condition="'$(TargetFramework)' == 'net461'">
     <PackageReference Include="System.Diagnostics.Contracts" Version="$(SystemDiagnosticsContractsVersion)" />
diff --git a/src/libraries/System.Threading.Tasks.Dataflow/tests/Dataflow/ActionBlockTests.cs b/src/libraries/System.Threading.Tasks.Dataflow/tests/Dataflow/ActionBlockTests.cs
index 35668423bd37dc..55f7c4f0b5d639 100644
--- a/src/libraries/System.Threading.Tasks.Dataflow/tests/Dataflow/ActionBlockTests.cs
+++ b/src/libraries/System.Threading.Tasks.Dataflow/tests/Dataflow/ActionBlockTests.cs
@@ -366,7 +366,6 @@ public async Task TestFault()
         }
 
         [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
         public async Task TestFaulting()
         {
             for (int trial = 0; trial < 3; trial++)
diff --git a/src/libraries/System.Threading.Tasks/tests/System.Runtime.CompilerServices/AsyncTaskMethodBuilderTests.cs b/src/libraries/System.Threading.Tasks/tests/System.Runtime.CompilerServices/AsyncTaskMethodBuilderTests.cs
index 1ce1e3fe05f984..177696010f8cc5 100644
--- a/src/libraries/System.Threading.Tasks/tests/System.Runtime.CompilerServices/AsyncTaskMethodBuilderTests.cs
+++ b/src/libraries/System.Threading.Tasks/tests/System.Runtime.CompilerServices/AsyncTaskMethodBuilderTests.cs
@@ -5,6 +5,7 @@
 using System.Collections.Generic;
 using System.Diagnostics.Tracing;
 using System.Linq;
+using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Text;
 using Microsoft.DotNet.RemoteExecutor;
@@ -644,6 +645,30 @@ public static void DroppedIncompleteStateMachine_RaisesIncompleteAsyncMethodEven
             }).Dispose();
         }
 
+        [ConditionalFact(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))]
+        public void AsyncTaskMethodBuilder_Completed_RemovedFromTracking()
+        {
+            RemoteExecutor.Invoke(() =>
+            {
+                // NOTE: This depends on private implementation details generally only used by the debugger.
+                // If those ever change, this test will need to be updated as well.
+                typeof(Task).GetField("s_asyncDebuggingEnabled", BindingFlags.NonPublic | BindingFlags.Static).SetValue(null, true);
+
+                for (int i = 0; i < 1000; i++)
+                {
+                    static async Task YieldAsync(TaskCompletionSource tcs) => await tcs.Task;
+
+                    TaskCompletionSource tcs = new();
+                    Task t = YieldAsync(tcs);
+                    tcs.SetResult();
+                    t.Wait();
+                }
+
+                int activeCount = ((dynamic)typeof(Task).GetField("s_currentActiveTasks", BindingFlags.NonPublic | BindingFlags.Static).GetValue(null)).Count;
+                Assert.InRange(activeCount, 0, 10); // some other tasks may be created by the runtime, so this is just using a reasonably small upper bound
+            }).Dispose();
+        }
+
         #region Helper Methods / Classes
 
         [MethodImpl(MethodImplOptions.NoInlining)]
diff --git a/src/libraries/System.Threading.Thread/tests/ThreadTests.cs b/src/libraries/System.Threading.Thread/tests/ThreadTests.cs
index acfd85eebc9c02..23a9c0d7c48966 100644
--- a/src/libraries/System.Threading.Thread/tests/ThreadTests.cs
+++ b/src/libraries/System.Threading.Thread/tests/ThreadTests.cs
@@ -169,7 +169,6 @@ public static IEnumerable<object[]> ApartmentStateTest_MemberData()
         [InlineData("MTAMain.exe", "SetApartmentStateTest")]
         [InlineData("DefaultApartmentStateMain.exe", "GetApartmentStateTest")]
         [InlineData("DefaultApartmentStateMain.exe", "SetApartmentStateTest")]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
         [ActiveIssue("https://github.com/dotnet/runtime/issues/50577", TestPlatforms.Android)]
         [SkipOnPlatform(TestPlatforms.iOS | TestPlatforms.MacCatalyst | TestPlatforms.tvOS, "Not supported on iOS, MacCatalyst, or tvOS.")]
         public static void ApartmentState_AttributePresent(string appName, string testName)
diff --git a/src/libraries/System.Threading.ThreadPool/tests/ThreadPoolTests.cs b/src/libraries/System.Threading.ThreadPool/tests/ThreadPoolTests.cs
index fbd515aecb7f47..767e5bef92c165 100644
--- a/src/libraries/System.Threading.ThreadPool/tests/ThreadPoolTests.cs
+++ b/src/libraries/System.Threading.ThreadPool/tests/ThreadPoolTests.cs
@@ -3,6 +3,7 @@
 
 using System.Collections.Generic;
 using System.Linq;
+using System.Reflection;
 using System.Threading.Tasks;
 using System.Threading.Tests;
 using Microsoft.DotNet.RemoteExecutor;
@@ -885,6 +886,69 @@ public static void ThreadPoolThreadCreationDoesNotTransferExecutionContext()
             }).Dispose();
         }
 
+        [ConditionalFact(nameof(IsThreadingAndRemoteExecutorSupported))]
+        public static void CooperativeBlockingCanCreateThreadsFaster()
+        {
+            // Run in a separate process to test in a clean thread pool environment such that work items queued by the test
+            // would cause the thread pool to create threads
+            RemoteExecutor.Invoke(() =>
+            {
+                // All but the last of these work items will block and the last queued work item would release the blocking.
+                // Without cooperative blocking, this would lead to starvation after <proc count> work items run. Since
+                // starvation adds threads at a rate of at most 2 per second, the extra 120 work items would take roughly 60
+                // seconds to get unblocked and since the test waits for 30 seconds it would time out. Cooperative blocking is
+                // configured below to increase the rate of thread injection for testing purposes while getting a decent amount
+                // of coverage for its behavior. With cooperative blocking as configured below, the test should finish within a
+                // few seconds.
+                int processorCount = Environment.ProcessorCount;
+                int workItemCount = processorCount + 120;
+                SetBlockingConfigValue("ThreadsToAddWithoutDelay_ProcCountFactor", 1);
+                SetBlockingConfigValue("MaxDelayMs", 1);
+
+                var allWorkItemsUnblocked = new AutoResetEvent(false);
+
+                // Run a second iteration for some extra coverage. Iterations after the first one would be much faster because
+                // the necessary number of threads would already have been created by then, and would not add much to the test
+                // time.
+                for (int iterationIndex = 0; iterationIndex < 2; ++iterationIndex)
+                {
+                    var tcs = new TaskCompletionSource<int>();
+                    int unblockedThreadCount = 0;
+
+                    Action<int> blockingWorkItem = _ =>
+                    {
+                        tcs.Task.Wait();
+                        if (Interlocked.Increment(ref unblockedThreadCount) == workItemCount - 1)
+                        {
+                            allWorkItemsUnblocked.Set();
+                        }
+                    };
+
+                    for (int i = 0; i < workItemCount - 1; ++i)
+                    {
+                        ThreadPool.UnsafeQueueUserWorkItem(blockingWorkItem, 0, preferLocal: false);
+                    }
+
+                    Action<int> unblockingWorkItem = _ => tcs.SetResult(0);
+                    ThreadPool.UnsafeQueueUserWorkItem(unblockingWorkItem, 0, preferLocal: false);
+                    Assert.True(allWorkItemsUnblocked.WaitOne(30_000));
+                }
+
+                void SetBlockingConfigValue(string name, int value) =>
+                    AppContextSetData("System.Threading.ThreadPool.Blocking." + name, value);
+
+                void AppContextSetData(string name, object value)
+                {
+                    typeof(AppContext).InvokeMember(
+                        "SetData",
+                        BindingFlags.ExactBinding | BindingFlags.InvokeMethod | BindingFlags.Public | BindingFlags.Static,
+                        null,
+                        null,
+                        new object[] { name, value });
+                }
+            }).Dispose();
+        }
+
         public static bool IsThreadingAndRemoteExecutorSupported =>
             PlatformDetection.IsThreadingSupported && RemoteExecutor.IsSupported;
     }
diff --git a/src/libraries/System.Threading/tests/MutexTests.cs b/src/libraries/System.Threading/tests/MutexTests.cs
index c7fea3554ac331..a893662df15195 100644
--- a/src/libraries/System.Threading/tests/MutexTests.cs
+++ b/src/libraries/System.Threading/tests/MutexTests.cs
@@ -406,7 +406,6 @@ public static IEnumerable<object[]> CrossProcess_NamedMutex_ProtectedFileAccessA
         [ConditionalTheory(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))]
         [ActiveIssue("https://github.com/dotnet/runtime/issues/36307", TestRuntimes.Mono)]
         [MemberData(nameof(CrossProcess_NamedMutex_ProtectedFileAccessAtomic_MemberData))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/49568", typeof(PlatformDetection), nameof(PlatformDetection.IsMacOsAppleSilicon))]
         public void CrossProcess_NamedMutex_ProtectedFileAccessAtomic(string prefix)
         {
             string fileName = GetTestFilePath();
diff --git a/src/libraries/System.Transactions.Local/tests/LTMEnlistmentTests.cs b/src/libraries/System.Transactions.Local/tests/LTMEnlistmentTests.cs
index 42accba1d80e06..a5fd3047fa64a1 100644
--- a/src/libraries/System.Transactions.Local/tests/LTMEnlistmentTests.cs
+++ b/src/libraries/System.Transactions.Local/tests/LTMEnlistmentTests.cs
@@ -76,7 +76,6 @@ public void SinglePhaseDurable(int volatileCount, EnlistmentOptions volatileEnli
         }
 
         [Theory]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/50969", typeof(PlatformDetection), nameof(PlatformDetection.IsBrowser), nameof(PlatformDetection.IsMonoAOT))]
         // This test needs to change once we have promotion support.
         // Right now any attempt to create a two phase durable enlistment will attempt to promote and will fail because promotion is not supported. This results in the transaction being
         // aborted.
diff --git a/src/libraries/System.Windows.Extensions/ref/System.Windows.Extensions.csproj b/src/libraries/System.Windows.Extensions/ref/System.Windows.Extensions.csproj
index d04eae0963b753..080d2f34b074a4 100644
--- a/src/libraries/System.Windows.Extensions/ref/System.Windows.Extensions.csproj
+++ b/src/libraries/System.Windows.Extensions/ref/System.Windows.Extensions.csproj
@@ -1,7 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <TargetFrameworks>$(NetCoreAppCurrent);netcoreapp3.1</TargetFrameworks>
-    <ExcludeCurrentNetCoreAppFromPackage>true</ExcludeCurrentNetCoreAppFromPackage>
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="System.Windows.Extensions.cs" />
diff --git a/src/libraries/System.Windows.Extensions/src/System.Windows.Extensions.csproj b/src/libraries/System.Windows.Extensions/src/System.Windows.Extensions.csproj
index 916c0b133ea5b3..e995c093bb7c9a 100644
--- a/src/libraries/System.Windows.Extensions/src/System.Windows.Extensions.csproj
+++ b/src/libraries/System.Windows.Extensions/src/System.Windows.Extensions.csproj
@@ -2,7 +2,6 @@
   <PropertyGroup>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <TargetFrameworks>$(NetCoreAppCurrent)-windows;$(NetCoreAppCurrent);netcoreapp3.1-windows;netcoreapp3.1</TargetFrameworks>
-    <ExcludeCurrentNetCoreAppFromPackage>true</ExcludeCurrentNetCoreAppFromPackage>
   </PropertyGroup>
   <!-- DesignTimeBuild requires all the TargetFramework Derived Properties to not be present in the first property group. -->
   <PropertyGroup Condition="'$(TargetsWindows)' != 'true'"> 
diff --git a/src/libraries/libraries-packages.proj b/src/libraries/libraries-packages.proj
index 7c870d603ad8ab..383dd088e127c0 100644
--- a/src/libraries/libraries-packages.proj
+++ b/src/libraries/libraries-packages.proj
@@ -1,28 +1,19 @@
 <Project Sdk="Microsoft.Build.Traversal" DefaultTargets="Pack">
 
-  <PropertyGroup>
-    <AdditionalBuildTargetFrameworks Condition="'$(DotNetBuildFromSource)' == 'true'">$(AdditionalBuildTargetFrameworks);package-$(Configuration)</AdditionalBuildTargetFrameworks>
-  </PropertyGroup>
-
-  <PropertyGroup>
-    <PackagingTaskAssembly>$(NuGetPackageRoot)microsoft.dotnet.build.tasks.packaging\$(MicrosoftDotNetBuildTasksPackagingVersion)\tools\</PackagingTaskAssembly>
-    <PackagingTaskAssembly Condition="'$(MSBuildRuntimeType)' == 'core'">$(PackagingTaskAssembly)netcoreapp3.1\</PackagingTaskAssembly>
-    <PackagingTaskAssembly Condition="'$(MSBuildRuntimeType)' != 'core'">$(PackagingTaskAssembly)net472\</PackagingTaskAssembly>
-    <PackagingTaskAssembly>$(PackagingTaskAssembly)Microsoft.DotNet.Build.Tasks.Packaging.dll</PackagingTaskAssembly>
-  </PropertyGroup>
-
   <ItemGroup>
+    <PackageReference Include="Microsoft.DotNet.Build.Tasks.Packaging" Version="$(MicrosoftDotNetBuildTasksPackagingVersion)" />
+
     <ProjectReference Include="$(PkgDir)*\*.proj" Exclude="$(PkgDir)test\*" />
     <ProjectReference Include="$(MSBuildThisFileDirectory)*\src\*.*proj"
-                      Condition="('$(BuildAllConfigurations)' == 'true' or '$(DotNetBuildFromSource)' == 'true')"
+                      Condition="'$(BuildAllConfigurations)' == 'true'"
                       Exclude="$(MSBuildThisFileDirectory)*\src\**\*.shproj"/>
   </ItemGroup>
 
   <!-- Need the PackageIndexFile file property from baseline.props -->
   <Import Project="$(PkgDir)baseline\baseline.props" />
 
-  <!-- Calculate PackageDownload items for restore. -->
-  <Import Project="$(RepositoryEngineeringDir)restore\harvestPackages.targets" Condition="'$(MSBuildRestoreSessionId)' != ''" />
+  <!-- Calculate PackageDownload items for restore. Skip this logic during source build to avoid pre-builts. -->
+  <Import Project="$(RepositoryEngineeringDir)restore\harvestPackages.targets" Condition="'$(MSBuildRestoreSessionId)' != '' and '$(DotNetBuildFromSource)' != 'true'" />
 
   <!--
     Updates the package index to mark all packages we are building that can go stable as stable.
@@ -31,7 +22,6 @@
     ones that might do this. After we ship a stable set of packages this target should be ran and the
     changes to the package index should be commited to the repo.
   -->
-  <UsingTask TaskName="UpdatePackageIndex" AssemblyFile="$(PackagingTaskAssembly)"/>
   <Target Name="UpdatePackageIndexWithStableVersions"
           BeforeTargets="Build;Pack"
           Condition="'$(DotNetFinalVersionKind)' == 'release'">
diff --git a/src/libraries/pkg/Directory.Build.props b/src/libraries/pkg/Directory.Build.props
index 1594de11844b8b..f05c02795a6512 100644
--- a/src/libraries/pkg/Directory.Build.props
+++ b/src/libraries/pkg/Directory.Build.props
@@ -1,6 +1,6 @@
 <Project>
   <PropertyGroup>
-    <DisableProjectRestore>true</DisableProjectRestore>
+    <DisableProjectRestore Condition="'$(MSBuildProjectName)' != 'testPackages'">true</DisableProjectRestore>
   </PropertyGroup>
 
   <Import Project="..\Directory.Build.props" />
diff --git a/src/libraries/pkg/Microsoft.Windows.Compatibility/Microsoft.Windows.Compatibility.pkgproj b/src/libraries/pkg/Microsoft.Windows.Compatibility/Microsoft.Windows.Compatibility.pkgproj
index b6d264834f9c8a..caa2fc5f2428d4 100644
--- a/src/libraries/pkg/Microsoft.Windows.Compatibility/Microsoft.Windows.Compatibility.pkgproj
+++ b/src/libraries/pkg/Microsoft.Windows.Compatibility/Microsoft.Windows.Compatibility.pkgproj
@@ -1,7 +1,6 @@
 <Project DefaultTargets="Build">
   <Import Project="$([MSBuild]::GetPathOfFileAbove(Directory.Build.props))" />
   <PropertyGroup>
-    <ServiceModelVersion>4.8.0</ServiceModelVersion>
     <!-- We don't need to harvest the stable packages to build this -->
     <HarvestStablePackage>false</HarvestStablePackage>
     <PackageDescription>This Windows Compatibility Pack provides access to APIs that were previously available only for .NET Framework. It can be used from both .NET Core as well as .NET Standard.</PackageDescription>
@@ -15,7 +14,6 @@
     </NS21PrereleaseLibraryPackage>
   </ItemDefinitionGroup>
   <ItemGroup>
-    <PrereleaseLibraryPackage Include="Microsoft.Win32.Registry" />
     <PrereleaseLibraryPackage Include="Microsoft.Win32.Registry.AccessControl" />
     <PrereleaseLibraryPackage Include="Microsoft.Win32.SystemEvents" />
     <PrereleaseLibraryPackage Include="System.CodeDom" />
@@ -29,19 +27,14 @@
     <PrereleaseLibraryPackage Include="System.DirectoryServices" />
     <PrereleaseLibraryPackage Include="System.DirectoryServices.AccountManagement" />
     <PrereleaseLibraryPackage Include="System.DirectoryServices.Protocols" />
-    <PrereleaseLibraryPackage Include="System.IO.FileSystem.AccessControl" />
     <PrereleaseLibraryPackage Include="System.IO.Packaging" />
-    <PrereleaseLibraryPackage Include="System.IO.Pipes.AccessControl" />
     <PrereleaseLibraryPackage Include="System.IO.Ports" />
     <PrereleaseLibraryPackage Include="System.Management" />
     <PrereleaseLibraryPackage Include="System.Runtime.Caching" />
-    <PrereleaseLibraryPackage Include="System.Security.AccessControl" />
-    <PrereleaseLibraryPackage Include="System.Security.Cryptography.Cng" />
     <PrereleaseLibraryPackage Include="System.Security.Cryptography.Pkcs" />
     <PrereleaseLibraryPackage Include="System.Security.Cryptography.ProtectedData" />
     <PrereleaseLibraryPackage Include="System.Security.Cryptography.Xml" />
     <PrereleaseLibraryPackage Include="System.Security.Permissions" />
-    <PrereleaseLibraryPackage Include="System.Security.Principal.Windows" />
     <PrereleaseLibraryPackage Include="System.ServiceModel.Syndication" />
     <PrereleaseLibraryPackage Include="System.ServiceProcess.ServiceController" />
     <PrereleaseLibraryPackage Include="System.Speech" />
@@ -52,61 +45,60 @@
     <NS21PrereleaseLibraryPackage Include="System.Reflection.Context" />
 
     <!-- Packages we don't build in main anymore -->
-    <LibraryPackage Include="System.Data.DataSetExtensions">
-      <Version>4.5.0</Version>
-    </LibraryPackage>
-    <LibraryPackage Include="System.Data.SqlClient">
-      <Version>4.8.1</Version>
-    </LibraryPackage>
-    <LibraryPackage Include="System.Reflection.Emit">
-      <Version>4.7.0</Version>
-    </LibraryPackage>
-    <LibraryPackage Include="System.Reflection.Emit.ILGeneration">
-      <Version>4.7.0</Version>
-    </LibraryPackage>
-    <LibraryPackage Include="System.Reflection.Emit.Lightweight">
-      <Version>4.7.0</Version>
-    </LibraryPackage>
+    <LibraryPackage Include="System.Data.SqlClient" Version="$(SystemDataSqlClientVersion)" />
+
+    <!-- Packages which are inbox in NET6 and don't need to be referenced. -->
+    <BeforeNET6LibraryPackage Include="Microsoft.Win32.Registry" Version="$(MicrosoftWin32RegistryVersion)" />
+    <BeforeNET6LibraryPackage Include="System.Data.DataSetExtensions" Version="$(SystemDataDataSetExtensionsVersion)" />
+    <BeforeNET6LibraryPackage Include="System.IO.FileSystem.AccessControl" Version="$(SystemIOFileSystemAccessControlVersion)" />
+    <BeforeNET6LibraryPackage Include="System.IO.Pipes.AccessControl" Version="$(SystemIOPipesAccessControlVersion)" />
+    <BeforeNET6LibraryPackage Include="System.Reflection.Emit" Version="$(SystemReflectionEmitVersion)" />
+    <BeforeNET6LibraryPackage Include="System.Reflection.Emit.ILGeneration" Version="$(SystemReflectionEmitILGenerationVersion)" />
+    <BeforeNET6LibraryPackage Include="System.Reflection.Emit.Lightweight" Version="$(SystemReflectionEmitLightweightVersion)" />
+    <BeforeNET6LibraryPackage Include="System.Security.AccessControl" Version="$(SystemSecurityAccessControlVersion)" />
+    <BeforeNET6LibraryPackage Include="System.Security.Cryptography.Cng" Version="$(SystemSecurityCryptographyCngVersion)" />
+    <BeforeNET6LibraryPackage Include="System.Security.Principal.Windows" Version="$(SystemSecurityPrincipalWindowsVersion)" />
 
     <!-- Service model packages -->
-    <ExternalLibraryPackage Include="System.ServiceModel.Primitives">
-      <Version>$(ServiceModelVersion)</Version>
-    </ExternalLibraryPackage>
-    <ExternalLibraryPackage Include="System.ServiceModel.Duplex">
-      <Version>$(ServiceModelVersion)</Version>
-    </ExternalLibraryPackage>
-    <ExternalLibraryPackage Include="System.ServiceModel.Http">
-      <Version>$(ServiceModelVersion)</Version>
-    </ExternalLibraryPackage>
-    <ExternalLibraryPackage Include="System.ServiceModel.NetTcp">
-      <Version>$(ServiceModelVersion)</Version>
-    </ExternalLibraryPackage>
-    <ExternalLibraryPackage Include="System.ServiceModel.Security">
-      <Version>$(ServiceModelVersion)</Version>
-    </ExternalLibraryPackage>
+    <ExternalLibraryPackage Include="System.ServiceModel.Primitives;
+                                     System.ServiceModel.Duplex;
+                                     System.ServiceModel.Http;
+                                     System.ServiceModel.NetTcp;
+                                     System.ServiceModel.Security"
+                            Version="$(ServiceModelVersion)" />
   </ItemGroup>
+
   <ItemGroup>
-    <IndexedDependency Include="@(LibraryPackage);@(PrereleaseLibraryPackage);@(NS21PrereleaseLibraryPackage)">
-      <TargetFramework>netcoreapp3.1</TargetFramework>
-    </IndexedDependency>
-    <IndexedDependency Include="@(LibraryPackage);@(PrereleaseLibraryPackage)">
-      <TargetFramework>netstandard2.0</TargetFramework>
-    </IndexedDependency>
-    <IndexedDependency Include="@(LibraryPackage);@(PrereleaseLibraryPackage);@(NS21PrereleaseLibraryPackage)">
-      <TargetFramework>netstandard2.1</TargetFramework>
-    </IndexedDependency>
+    <IndexedDependency Include="@(LibraryPackage);
+                                @(PrereleaseLibraryPackage);
+                                @(NS21PrereleaseLibraryPackage)"
+                       TargetFramework="net6.0" />
+    <IndexedDependency Include="@(BeforeNET6LibraryPackage);
+                                @(LibraryPackage);
+                                @(PrereleaseLibraryPackage);
+                                @(NS21PrereleaseLibraryPackage)"
+                       TargetFramework="netcoreapp3.1" />
+    <IndexedDependency Include="@(BeforeNET6LibraryPackage);
+                                @(LibraryPackage);
+                                @(PrereleaseLibraryPackage);
+                                @(NS21PrereleaseLibraryPackage)"
+                       TargetFramework="netstandard2.1" />
+    <IndexedDependency Include="@(BeforeNET6LibraryPackage);
+                                @(LibraryPackage);
+                                @(PrereleaseLibraryPackage)"
+                       TargetFramework="netstandard2.0" />
   </ItemGroup>
 
   <ItemGroup>
-    <Dependency Include="@(ExternalLibraryPackage)">
-      <TargetFramework>netcoreapp3.1</TargetFramework>
-    </Dependency>
-    <Dependency Include="@(ExternalLibraryPackage)">
-      <TargetFramework>netstandard2.0</TargetFramework>
-    </Dependency>
-    <Dependency Include="@(ExternalLibraryPackage)">
-      <TargetFramework>netstandard2.1</TargetFramework>
-    </Dependency>
+    <Dependency Include="@(ExternalLibraryPackage)"
+                TargetFramework="net6.0" />
+    <Dependency Include="@(ExternalLibraryPackage)"
+                TargetFramework="netcoreapp3.1" />
+    <Dependency Include="@(ExternalLibraryPackage)"
+                TargetFramework="netstandard2.0" />
+    <Dependency Include="@(ExternalLibraryPackage)"
+                TargetFramework="netstandard2.1" />
   </ItemGroup>
+
   <Import Project="$([MSBuild]::GetPathOfFileAbove(Directory.Build.targets))" />
 </Project>
diff --git a/src/libraries/pkg/baseline/packageIndex.json b/src/libraries/pkg/baseline/packageIndex.json
index 33389f789205c8..b6bffe1a4f55dd 100644
--- a/src/libraries/pkg/baseline/packageIndex.json
+++ b/src/libraries/pkg/baseline/packageIndex.json
@@ -1392,16 +1392,17 @@
         "4.7.0",
         "5.0.0"
       ],
-      "BaselineVersion": "6.0.0",
-      "InboxOn": {},
+      "BaselineVersion": "5.0.0",
+      "InboxOn": {
+        "net6.0": "6.0.0.0"
+      },
       "AssemblyVersionInPackageVersion": {
         "4.0.0.0": "4.0.0",
         "4.0.1.0": "4.3.0",
         "4.1.0.0": "4.4.0",
         "4.1.1.0": "4.5.0",
         "4.1.2.0": "4.6.0",
-        "5.0.0.0": "5.0.0",
-        "6.0.0.0": "6.0.0"
+        "5.0.0.0": "5.0.0"
       }
     },
     "Microsoft.Win32.Registry.AccessControl": {
@@ -2724,7 +2725,8 @@
         "netcoreapp2.1": "4.0.3.1",
         "netcoreapp3.0": "4.0.4.0",
         "netcoreapp3.1": "4.0.5.0",
-        "net5.0": "5.0.0.0"
+        "net5.0": "5.0.0.0",
+        "net6.0": "6.0.0.0"
       },
       "AssemblyVersionInPackageVersion": {
         "4.0.0.0": "4.0.0",
@@ -3415,7 +3417,8 @@
       "InboxOn": {
         "netcoreapp2.1": "4.2.1.0",
         "netcoreapp3.1": "4.2.2.0",
-        "net5.0": "5.0.0.0"
+        "net5.0": "5.0.0.0",
+        "net6.0": "6.0.0.0"
       },
       "AssemblyVersionInPackageVersion": {
         "4.2.0.0": "4.4.0",
@@ -3505,16 +3508,17 @@
         "4.6.0",
         "5.0.0"
       ],
-      "BaselineVersion": "6.0.0",
-      "InboxOn": {},
+      "BaselineVersion": "5.0.0",
+      "InboxOn": {
+        "net6.0": "6.0.0.0"
+      },
       "AssemblyVersionInPackageVersion": {
         "4.0.0.0": "4.0.0",
         "4.0.1.0": "4.3.0",
         "4.0.2.0": "4.4.0",
         "4.0.3.0": "4.5.0",
         "4.0.4.0": "4.6.0",
-        "5.0.0.0": "5.0.0",
-        "6.0.0.0": "6.0.0"
+        "5.0.0.0": "5.0.0"
       }
     },
     "System.IO.FileSystem.DriveInfo": {
@@ -3734,14 +3738,15 @@
         "4.5.1",
         "5.0.0"
       ],
-      "BaselineVersion": "6.0.0",
-      "InboxOn": {},
+      "BaselineVersion": "5.0.0",
+      "InboxOn": {
+        "net6.0": "6.0.0.0"
+      },
       "AssemblyVersionInPackageVersion": {
         "4.0.1.0": "4.3.0",
         "4.0.2.0": "4.4.0",
         "4.0.3.0": "4.5.0",
-        "5.0.0.0": "5.0.0",
-        "6.0.0.0": "6.0.0"
+        "5.0.0.0": "5.0.0"
       }
     },
     "System.IO.Ports": {
@@ -4827,7 +4832,8 @@
     },
     "System.Private.Runtime.InteropServices.JavaScript": {
       "InboxOn": {
-        "net5.0": "5.0.0.0"
+        "net5.0": "5.0.0.0",
+        "net6.0": "6.0.0.0"
       }
     },
     "System.Private.Uri": {
@@ -5420,7 +5426,8 @@
       "InboxOn": {
         "netcoreapp3.0": "4.0.5.0",
         "netcoreapp3.1": "4.0.6.0",
-        "net5.0": "5.0.0.0"
+        "net5.0": "5.0.0.0",
+        "net6.0": "6.0.0.0"
       },
       "AssemblyVersionInPackageVersion": {
         "4.0.3.0": "4.4.0",
@@ -5657,7 +5664,8 @@
       "InboxOn": {
         "netcoreapp3.0": "4.0.0.0",
         "netcoreapp3.1": "4.0.1.0",
-        "net5.0": "5.0.0.0"
+        "net5.0": "5.0.0.0",
+        "net6.0": "6.0.0.0"
       }
     },
     "System.Runtime.Loader": {
@@ -5671,12 +5679,12 @@
         "netcoreapp2.1": "4.0.3.0",
         "netcoreapp3.0": "4.1.0.0",
         "netcoreapp3.1": "4.1.1.0",
-        "net5.0": "5.0.0.0"
+        "net5.0": "5.0.0.0",
+        "net6.0": "6.0.0.0"
       },
       "AssemblyVersionInPackageVersion": {
         "4.0.0.0": "4.0.0",
-        "4.0.1.0": "4.3.0",
-        "4.1.0.0": "4.6.0"
+        "4.0.1.0": "4.3.0"
       }
     },
     "System.Runtime.Numerics": {
@@ -5994,16 +6002,17 @@
         "4.6.0",
         "5.0.0"
       ],
-      "BaselineVersion": "6.0.0",
-      "InboxOn": {},
+      "BaselineVersion": "5.0.0",
+      "InboxOn": {
+        "net6.0": "6.0.0.0"
+      },
       "AssemblyVersionInPackageVersion": {
         "4.0.0.0": "4.0.0",
         "4.0.1.0": "4.3.0",
         "4.1.0.0": "4.4.0",
         "4.1.1.0": "4.5.0",
         "4.1.2.0": "4.6.0",
-        "5.0.0.0": "5.0.0",
-        "6.0.0.0": "6.0.0"
+        "5.0.0.0": "5.0.0"
       }
     },
     "System.Security.Claims": {
@@ -6385,8 +6394,10 @@
         "4.6.0",
         "5.0.0"
       ],
-      "BaselineVersion": "6.0.0",
-      "InboxOn": {},
+      "BaselineVersion": "5.0.0",
+      "InboxOn": {
+        "net6.0": "6.0.0.0"
+      },
       "AssemblyVersionInPackageVersion": {
         "4.0.0.0": "4.0.0",
         "4.0.1.0": "4.3.0",
@@ -6394,8 +6405,7 @@
         "4.1.1.0": "4.5.0",
         "4.1.1.1": "4.5.1",
         "4.1.2.0": "4.6.0",
-        "5.0.0.0": "5.0.0",
-        "6.0.0.0": "6.0.0"
+        "5.0.0.0": "5.0.0"
       }
     },
     "System.Security.SecureString": {
@@ -6790,7 +6800,8 @@
       "InboxOn": {
         "netcoreapp3.0": "4.0.4.0",
         "netcoreapp3.1": "4.0.5.0",
-        "net5.0": "5.0.0.0"
+        "net5.0": "5.0.0.0",
+        "net6.0": "6.0.0.0"
       },
       "AssemblyVersionInPackageVersion": {
         "4.0.0.0": "4.0.0",
@@ -6815,7 +6826,8 @@
       "InboxOn": {
         "netcoreapp3.0": "4.0.0.0",
         "netcoreapp3.1": "4.0.1.0",
-        "net5.0": "5.0.0.0"
+        "net5.0": "5.0.0.0",
+        "net6.0": "6.0.0.0"
       },
       "AssemblyVersionInPackageVersion": {
         "4.0.0.0": "4.6.0",
@@ -6949,7 +6961,8 @@
       "InboxOn": {
         "netcoreapp3.0": "4.0.1.0",
         "netcoreapp3.1": "4.0.2.0",
-        "net5.0": "5.0.0.0"
+        "net5.0": "5.0.0.0",
+        "net6.0": "6.0.0.0"
       },
       "AssemblyVersionInPackageVersion": {
         "4.0.0.0": "4.5.0",
diff --git a/src/libraries/pkg/test/build/Directory.Build.props b/src/libraries/pkg/test/build/Directory.Build.props
new file mode 100644
index 00000000000000..d26162f97bd955
--- /dev/null
+++ b/src/libraries/pkg/test/build/Directory.Build.props
@@ -0,0 +1,9 @@
+<Project>
+  <PropertyGroup>
+    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+    <RestoreUseStaticGraphEvaluation>true</RestoreUseStaticGraphEvaluation>
+  </PropertyGroup>
+
+  <Import Project="Versions.props" />
+  <Import Project="netfxreference.props" />
+</Project>
diff --git a/src/libraries/pkg/test/build/Directory.Build.targets b/src/libraries/pkg/test/build/Directory.Build.targets
new file mode 100644
index 00000000000000..c73efb87b0f5a8
--- /dev/null
+++ b/src/libraries/pkg/test/build/Directory.Build.targets
@@ -0,0 +1,4 @@
+<Project>
+  <Import Project="targetingpacks.targets" />
+  <Import Project="packageTest.targets" />
+</Project>
diff --git a/src/libraries/pkg/test/build/dirs.proj b/src/libraries/pkg/test/build/dirs.proj
new file mode 100644
index 00000000000000..ab3b637846a64b
--- /dev/null
+++ b/src/libraries/pkg/test/build/dirs.proj
@@ -0,0 +1,16 @@
+<Project>
+  <PropertyGroup>
+    <ImportDirectoryBuildProps>false</ImportDirectoryBuildProps>
+    <ImportDirectoryBuildTargets>false</ImportDirectoryBuildTargets>
+    <RestoreUseStaticGraphEvaluation>true</RestoreUseStaticGraphEvaluation>
+    <RestorePackagesPath>$(MSBuildThisFileDirectory)cache\</RestorePackagesPath>
+  </PropertyGroup>
+
+  <Import Project="Sdk.props" Sdk="Microsoft.Build.Traversal" />
+
+  <ItemGroup>
+    <ProjectReference Include="projects\**\*.csproj" />
+  </ItemGroup>
+
+  <Import Project="Sdk.targets" Sdk="Microsoft.Build.Traversal" />
+</Project>
\ No newline at end of file
diff --git a/src/libraries/pkg/test/build/packageTest.targets b/src/libraries/pkg/test/build/packageTest.targets
new file mode 100644
index 00000000000000..28f5cc0240a7c2
--- /dev/null
+++ b/src/libraries/pkg/test/build/packageTest.targets
@@ -0,0 +1,162 @@
+<Project>
+  <PropertyGroup Condition="'$(TargetFrameworkIdentifier)' != ''">
+    <_targetFrameworkIdentifier>$(TargetFrameworkIdentifier.Substring(1).ToLower())</_targetFrameworkIdentifier>
+  </PropertyGroup>
+
+  <PropertyGroup>
+    <!-- Make sure the SDK raises the runtime items so that they are passed to conflict resolution -->
+    <CopyLocalLockFileAssemblies>true</CopyLocalLockFileAssemblies>
+    <!-- Suppress any SYSLIB9000 errors, as in these cases restore/build would succeed, the failure would be at run-time -->
+    <SuppressTfmSupportBuildWarnings>true</SuppressTfmSupportBuildWarnings>
+  </PropertyGroup>
+
+  <Import Project="build\Packaging.common.targets" />
+  <!-- Import framework settings. -->
+  <Import Project="frameworkSettings\$(_targetFrameworkIdentifier)\*.targets"
+          Condition="'$(_targetFrameworkIdentifier)' != ''"  />
+  <Import Project="frameworkSettings\$(TargetFramework)\*.targets" />
+  <!-- Import package settings. -->
+  <Import Project="packageSettings\$(TestPackageId)\*.targets" />
+  <Import Project="packageSettings\$(TestPackageId)\$(_targetFrameworkIdentifier)\*.targets"
+          Condition="'$(_targetFrameworkIdentifier)' != ''" />
+  <Import Project="packageSettings\$(TestPackageId)\$(TargetFramework)\*.targets"
+          Condition="'$(TargetFramework)' != ''" />
+  
+  <ItemGroup>
+    <!-- Type duplicated: https://github.com/dotnet/runtime/issues/33998 -->
+    <IgnoredTypes Include="Microsoft.Extensions.Logging.LoggingBuilderExtensions" />
+    <!-- Type duplicated: https://github.com/dotnet/runtime/issues/34420 -->
+    <IgnoredTypes Include="System.Collections.Generic.CollectionExtensions" />
+  </ItemGroup>
+
+  
+  <Target Name="LogBeginTest"
+          Condition="'$(TargetFramework)' != ''">
+    <Message Importance="High" Text="Testing $(TestPackageID) TFM=$(TargetFramework)" />
+  </Target>
+
+  <Target Name="VerifyReferenceClosure"
+          DependsOnTargets="ResolveReferences"
+          Condition="'$(ShouldVerifyClosure)' == 'true'">
+    <ItemGroup>
+      <_refClosureFileNames Include="@(ReferencePath->'%(FileName)')">
+        <Original>%(Identity)</Original>
+      </_refClosureFileNames>
+      <_refClosureFileNamesFiltered Include="@(_refClosureFileNames)" Exclude="@(ExcludeFromClosure);@(ExcludeFromClosure->'%(Identity).ni')"/>
+      <_refClosureFileFiltered Include="@(_refClosureFileNamesFiltered->'%(Original)')"/>
+    </ItemGroup>
+
+    <VerifyClosure Condition="'@(_refClosureFileFiltered)' != ''"
+                   Sources="@(_refClosureFileFiltered)"
+                   IgnoredReferences="@(IgnoredReference)" />
+  </Target>
+
+  <Target Name="VerifyReferenceTypes" 
+          DependsOnTargets="ResolveReferences"
+          Condition="'$(ShouldVerifyTypes)' == 'true'">
+    <ItemGroup>
+      <_refTypesFileNames Include="@(ReferencePath->'%(FileName)')">
+        <Original>%(Identity)</Original>
+      </_refTypesFileNames>
+      <_refTypesFileNamesFiltered Include="@(_refTypesFileNames)" Exclude="@(ExcludeFromTypes);@(ExcludeFromTypes->'%(Identity).ni')"/>
+      <_refTypesFileFiltered Include="@(_refTypesFileNamesFiltered->'%(Original)')"/>
+    </ItemGroup>
+
+    <VerifyTypes Condition="'@(_refTypesFileFiltered)' != ''"
+                 Sources="@(_refTypesFileFiltered)"
+                 IgnoredTypes="@(IgnoredTypes)" />
+  </Target>
+
+  <Target Name="PrepareForRuntimeTesting" DependsOnTargets="ResolveReferences">
+    <ItemGroup>
+      <ReferenceLibToTest Include="@(ReferencePath)" Condition="'%(ReferencePath.NuGetPackageId)' == '$(TestPackageId)'" />
+      <RuntimeLibToTest Include="@(ReferenceCopyLocalPaths)" Condition="'%(ReferenceCopyLocalPaths.NuGetPackageId)' == '$(TestPackageId)'" />
+      <RuntimeLibToTest Condition="'%(RuntimeLibToTest.RuntimeIdentifier)' == ''" RuntimeIdentifier="none" />
+    </ItemGroup>
+
+    <!-- These libraries are part of the runtime pack but aren't exposed in the targeting pack: https://github.com/dotnet/runtime/issues/53892 -->
+    <ItemGroup Condition="'$(TargetFramework)' == '$(NetCoreAppCurrent)'">
+      <ReferenceLibToTest Remove="@(ReferenceLibToTest)"
+                          Condition="'$(TestPackageId)' == 'Microsoft.Win32.Registry' or
+                                     '$(TestPackageId)' == 'System.IO.FileSystem.AccessControl' or
+                                     '$(TestPackageId)' == 'System.IO.Pipes.AccessControl' or
+                                     '$(TestPackageId)' == 'System.Security.AccessControl' or
+                                     '$(TestPackageId)' == 'System.Security.Principal.Windows'" />
+    </ItemGroup>
+
+    <ItemGroup>
+      <RuntimeLibToTestDependency Include="@(ReferencePath)" Condition="'%(ReferencePath.NuGetPackageId)' != '$(TestPackageId)'" />
+
+      <!-- Some dependent packages may be excluded from compile, consider these as candiates as well.-->
+      <ReferenceCopyLocalPaths Original="%(Identity)" />
+      <_referenceCopyLocalPathsPackages Include="@(ReferenceCopyLocalPaths->'%(NuGetPackageId)')" 
+                                        Condition="'%(ReferenceCopyLocalPaths.RuntimeIdentifier)' == ''"
+                                        Exclude="@(ReferencePath->'%(NuGetPackageId)');$(TestPackageId)" />
+      <RuntimeLibToTestDependency Include="@(_referenceCopyLocalPathsPackages->'%(Original)')" />
+    </ItemGroup>
+
+    <Error Condition="'@(RuntimeLibToTest)' == '' AND '@(ReferenceLibToTest)' != ''" Text="Could not locate any runtime items from Package $(TestPackageID)" />
+    
+    <Message Condition="'@(RuntimeLibToTest)' != ''" Importance="High" Text="Testing $(TestPackageID) runtime on TFM=$(TargetFramework) RIDs=@(RuntimeLibToTest->'%(RuntimeIdentifier)'->Distinct())" />
+  </Target>
+
+  <Target Name="VerifyRuntimeClosure" 
+          Inputs="%(RuntimeLibToTest.RuntimeIdentifier)" 
+          Outputs="unused"
+          DependsOnTargets="PrepareForRuntimeTesting"
+          Condition="'$(ShouldVerifyClosure)' == 'true' and '$(SkipVerifyClosureForRuntime)' != 'true'">
+    <Message Importance="High" Text="Testing closure for $(TestPackageID) TFM=$(TargetFramework) RID=%(RuntimeLibToTest.RuntimeIdentifier)" />
+    <ItemGroup>
+      <_runClosureFileNames Include="@(RuntimeLibToTestDependency->'%(FileName)');@(RuntimeLibToTest->'%(FileName)')">
+        <Original>%(Identity)</Original>
+      </_runClosureFileNames>
+      <_runClosureFileNamesFiltered Include="@(_runClosureFileNames)" Exclude="@(ExcludeFromClosure);@(ExcludeFromClosure->'%(Identity).ni')"/>
+      <_runClosureFileFiltered Include="@(_runClosureFileNamesFiltered->'%(Original)')"/>
+    </ItemGroup>
+
+    <VerifyClosure Condition="'@(_runClosureFileFiltered)' != ''"
+                   Sources="@(_runClosureFileFiltered)"
+                   IgnoredReferences="@(IgnoredReference)" />
+  </Target>
+
+  <Target Name="VerifyRuntimeTypes" 
+          Inputs="%(RuntimeLibToTest.RuntimeIdentifier)" 
+          Outputs="unused"
+          DependsOnTargets="PrepareForRuntimeTesting"
+          Condition="'$(ShouldVerifyTypes)' == 'true'">
+    <Message Importance="High" Text="Testing for duplicate types for $(TestPackageID) TFM=$(TargetFramework) RID=%(RuntimeLibToTest.RuntimeIdentifier)" />
+    <ItemGroup>
+      <_runTypesFileNames Include="@(RuntimeLibToTestDependency->'%(FileName)');@(RuntimeLibToTest->'%(FileName)')">
+        <Original>%(Identity)</Original>
+      </_runTypesFileNames>
+      <_runTypesFileNamesFiltered Include="@(_runTypesFileNames)" Exclude="@(ExcludeFromTypes);@(ExcludeFromTypes->'%(Identity).ni')"/>
+      <_runTypesFileFiltered Include="@(_runTypesFileNamesFiltered->'%(Original)')"/>
+    </ItemGroup>
+
+    <VerifyTypes Condition="'@(_runTypesFileFiltered)' != ''"
+                 Sources="@(_runTypesFileFiltered)"
+                 IgnoredTypes="@(IgnoredTypes)" />
+  </Target>
+
+  <Target Name="VerifyNotDependsOnNetStandard"
+          DependsOnTargets="ResolveReferences"
+          Condition="'$(TargetFrameworkIdentifier)' == '.NETFramework' and
+                      '$(DisableVerifyNotDependsOnNetStandardTest)' != 'true'">
+    <Error Condition="'$(DependsOnNetStandard)' == 'true'" Text="Package $(TestPackageId) requires netstandard shims when targeting $(TargetFramework)" />
+  </Target>
+
+  <PropertyGroup>
+    <TestDependsOn>
+      LogBeginTest;
+      VerifyNotDependsOnNetStandard;
+      VerifyReferenceClosure;
+      VerifyReferenceTypes;
+      VerifyRuntimeClosure;
+      VerifyRuntimeTypes;
+    </TestDependsOn>
+    <InnerTargets>Test</InnerTargets>
+  </PropertyGroup>
+  
+  <!-- Runs all tests scenarios for this project -->
+  <Target Name="Test" DependsOnTargets="$(TestDependsOn)"/>
+</Project>
diff --git a/src/libraries/pkg/test/frameworkSettings/net5.0/settings.targets b/src/libraries/pkg/test/frameworkSettings/net5.0/settings.targets
deleted file mode 100644
index a8fa34134f4350..00000000000000
--- a/src/libraries/pkg/test/frameworkSettings/net5.0/settings.targets
+++ /dev/null
@@ -1,11 +0,0 @@
-<Project>
-  <PropertyGroup>
-    <RuntimeFrameworkVersion>$(MicrosoftNETCoreAppVersion)</RuntimeFrameworkVersion>
-  </PropertyGroup>
-  <ItemGroup>
-    <KnownFrameworkReference Remove="Microsoft.AspNetCore.App" />
-    <KnownFrameworkReference Remove="Microsoft.WindowsDesktop.App" />
-    <KnownFrameworkReference Remove="Microsoft.WindowsDesktop.App.WPF" />
-    <KnownFrameworkReference Remove="Microsoft.WindowsDesktop.App.WindowsForms" />
-  </ItemGroup>
-</Project>
\ No newline at end of file
diff --git a/src/libraries/pkg/test/frameworkSettings/net6.0/settings.targets b/src/libraries/pkg/test/frameworkSettings/net6.0/settings.targets
deleted file mode 100644
index a8fa34134f4350..00000000000000
--- a/src/libraries/pkg/test/frameworkSettings/net6.0/settings.targets
+++ /dev/null
@@ -1,11 +0,0 @@
-<Project>
-  <PropertyGroup>
-    <RuntimeFrameworkVersion>$(MicrosoftNETCoreAppVersion)</RuntimeFrameworkVersion>
-  </PropertyGroup>
-  <ItemGroup>
-    <KnownFrameworkReference Remove="Microsoft.AspNetCore.App" />
-    <KnownFrameworkReference Remove="Microsoft.WindowsDesktop.App" />
-    <KnownFrameworkReference Remove="Microsoft.WindowsDesktop.App.WPF" />
-    <KnownFrameworkReference Remove="Microsoft.WindowsDesktop.App.WindowsForms" />
-  </ItemGroup>
-</Project>
\ No newline at end of file
diff --git a/src/libraries/pkg/test/frameworkSettings/netcoreapp/settings.targets b/src/libraries/pkg/test/frameworkSettings/netcoreapp/settings.targets
index ce47469c3e0602..7338b1a0a84be1 100644
--- a/src/libraries/pkg/test/frameworkSettings/netcoreapp/settings.targets
+++ b/src/libraries/pkg/test/frameworkSettings/netcoreapp/settings.targets
@@ -1,15 +1,16 @@
 <Project>
-  <Import Project="$(ToolsDir)netfxreference.props" />
-
   <PropertyGroup>
     <ShouldVerifyClosure>true</ShouldVerifyClosure>
     <ShouldVerifyTypes>true</ShouldVerifyTypes>
-
-    <!-- ensure that we get runtime assemblies in ReferenceCopyLocalPaths -->
-    <SelfContained>true</SelfContained>
-    <CopyLocalLockFileAssemblies>true</CopyLocalLockFileAssemblies>
   </PropertyGroup>
 
+  <ItemGroup>
+    <KnownFrameworkReference Remove="Microsoft.AspNetCore.App" />
+    <KnownFrameworkReference Remove="Microsoft.WindowsDesktop.App" />
+    <KnownFrameworkReference Remove="Microsoft.WindowsDesktop.App.WPF" />
+    <KnownFrameworkReference Remove="Microsoft.WindowsDesktop.App.WindowsForms" />
+  </ItemGroup>
+
   <ItemGroup>
     <!-- intentionally dangling refs in shims -->
     <ExcludeFromClosure Include="@(NetFxReference)" />
diff --git a/src/libraries/pkg/test/frameworkSettings/netcoreapp1.0/settings.targets b/src/libraries/pkg/test/frameworkSettings/netcoreapp1.0/settings.targets
deleted file mode 100644
index f319b958689917..00000000000000
--- a/src/libraries/pkg/test/frameworkSettings/netcoreapp1.0/settings.targets
+++ /dev/null
@@ -1,32 +0,0 @@
-<Project>
-  <ItemGroup Condition="'$(RuntimeIdentifier)' != ''">
-    <IgnoredTypes Include="System.Collections.StructuralComparisons" />
-    <IgnoredTypes Include="System.Threading.WaitHandleExtensions" />
-    <IgnoredTypes Include="System.Console" />
-    <IgnoredTypes Include="System.BitConverter" />
-    <IgnoredTypes Include="System.IO.Path" />
-    <IgnoredTypes Include="System.IServiceProvider" />
-    <IgnoredTypes Include="System.IO.FileAccess" />
-    <IgnoredTypes Include="System.IO.UnmanagedMemoryAccessor" />
-    <IgnoredTypes Include="System.IO.UnmanagedMemoryStream" />
-    <IgnoredTypes Include="System.Runtime.CompilerServices.RuntimeOps" />
-    <IgnoredTypes Include="System.Net.Sockets.IPAddressExtensions" />
-    <IgnoredTypes Include="System.Collections.ObjectModel.KeyedCollection`2" />
-    <IgnoredTypes Include="System.Collections.ObjectModel.ReadOnlyDictionary`2" />
-    <IgnoredTypes Include="System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection" />
-    <IgnoredTypes Include="System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection" />
-    <IgnoredTypes Include="System.Security.Principal.IIdentity" />
-    <IgnoredTypes Include="System.Security.Principal.IPrincipal" />
-    <IgnoredTypes Include="System.Security.Principal.TokenImpersonationLevel" />
-    <IgnoredTypes Include="System.Threading.CountdownEvent" />
-    <IgnoredTypes Include="System.Threading.IOCompletionCallback" />
-    <IgnoredTypes Include="System.Threading.NativeOverlapped" />
-    <IgnoredTypes Include="System.DBNull" />
-    <IgnoredTypes Include="System.Runtime.Serialization.OnDeserializedAttribute" />
-    <IgnoredTypes Include="System.Runtime.Serialization.OnDeserializingAttribute" />
-    <IgnoredTypes Include="System.Runtime.Serialization.OnSerializingAttribute" />
-    <IgnoredTypes Include="System.Runtime.Serialization.OnSerializedAttribute" />
-    <IgnoredTypes Include="System.Runtime.Serialization.SerializationException" />
-    <IgnoredTypes Include="System.Runtime.Serialization.StreamingContext" />
-  </ItemGroup>
-</Project>
\ No newline at end of file
diff --git a/src/libraries/pkg/test/frameworkSettings/netcoreapp1.1/settings.targets b/src/libraries/pkg/test/frameworkSettings/netcoreapp1.1/settings.targets
deleted file mode 100644
index 846df54fdc37b0..00000000000000
--- a/src/libraries/pkg/test/frameworkSettings/netcoreapp1.1/settings.targets
+++ /dev/null
@@ -1,34 +0,0 @@
-<Project>
-  <ItemGroup Condition="'$(RuntimeIdentifier)' != ''">
-    <IgnoredTypes Include="System.Collections.StructuralComparisons" />
-    <IgnoredTypes Include="System.Threading.WaitHandleExtensions" />
-    <IgnoredTypes Include="System.Console" />
-    <IgnoredTypes Include="System.BitConverter" />
-    <IgnoredTypes Include="System.IO.Path" />
-    <IgnoredTypes Include="System.IServiceProvider" />
-    <IgnoredTypes Include="System.Text.NormalizationForm" />
-    <IgnoredTypes Include="System.Globalization.IdnMapping" />
-    <IgnoredTypes Include="System.IO.FileAccess" />
-    <IgnoredTypes Include="System.IO.UnmanagedMemoryAccessor" />
-    <IgnoredTypes Include="System.IO.UnmanagedMemoryStream" />
-    <IgnoredTypes Include="System.Runtime.CompilerServices.RuntimeOps" />
-    <IgnoredTypes Include="System.Net.Sockets.IPAddressExtensions" />
-    <IgnoredTypes Include="System.Collections.ObjectModel.KeyedCollection`2" />
-    <IgnoredTypes Include="System.Collections.ObjectModel.ReadOnlyDictionary`2" />
-    <IgnoredTypes Include="System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection" />
-    <IgnoredTypes Include="System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection" />
-    <IgnoredTypes Include="System.Security.Principal.IIdentity" />
-    <IgnoredTypes Include="System.Security.Principal.IPrincipal" />
-    <IgnoredTypes Include="System.Security.Principal.TokenImpersonationLevel" />
-    <IgnoredTypes Include="System.Threading.CountdownEvent" />
-    <IgnoredTypes Include="System.Threading.IOCompletionCallback" />
-    <IgnoredTypes Include="System.Threading.NativeOverlapped" />
-    <IgnoredTypes Include="System.DBNull" />
-    <IgnoredTypes Include="System.Runtime.Serialization.OnDeserializedAttribute" />
-    <IgnoredTypes Include="System.Runtime.Serialization.OnDeserializingAttribute" />
-    <IgnoredTypes Include="System.Runtime.Serialization.OnSerializingAttribute" />
-    <IgnoredTypes Include="System.Runtime.Serialization.OnSerializedAttribute" />
-    <IgnoredTypes Include="System.Runtime.Serialization.SerializationException" />
-    <IgnoredTypes Include="System.Runtime.Serialization.StreamingContext" />
-  </ItemGroup>
-</Project>
\ No newline at end of file
diff --git a/src/libraries/pkg/test/frameworkSettings/netcoreapp2.0/settings.targets b/src/libraries/pkg/test/frameworkSettings/netcoreapp2.0/settings.targets
deleted file mode 100644
index 4cfa63c93a5f02..00000000000000
--- a/src/libraries/pkg/test/frameworkSettings/netcoreapp2.0/settings.targets
+++ /dev/null
@@ -1,8 +0,0 @@
-<Project>
-  <ItemGroup Condition="'$(RuntimeIdentifier)' != ''">
-    <!-- NETCoreApp2.0 had experimental versions of Span and ReadOnlySpan 
-         which we don't match the final API nor were they ship-quality -->
-    <IgnoredTypes Include="System.ReadOnlySpan`1" />
-    <IgnoredTypes Include="System.Span`1" />
-  </ItemGroup>
-</Project>
\ No newline at end of file
diff --git a/src/libraries/pkg/test/frameworkSettings/netcoreapp3.0/settings.targets b/src/libraries/pkg/test/frameworkSettings/netcoreapp3.0/settings.targets
deleted file mode 100644
index 1aa65488bec595..00000000000000
--- a/src/libraries/pkg/test/frameworkSettings/netcoreapp3.0/settings.targets
+++ /dev/null
@@ -1,7 +0,0 @@
-<Project>
-  <ItemGroup>
-    <!-- Temporary till SDK supports transitive framework references. -->
-    <KnownFrameworkReference Remove="Microsoft.AspNetCore.App" />
-    <KnownFrameworkReference Remove="Microsoft.WindowsDesktop.App" />
-  </ItemGroup>
-</Project>
\ No newline at end of file
diff --git a/src/libraries/pkg/test/frameworkSettings/net/settings.targets b/src/libraries/pkg/test/frameworkSettings/netframework/settings.targets
similarity index 95%
rename from src/libraries/pkg/test/frameworkSettings/net/settings.targets
rename to src/libraries/pkg/test/frameworkSettings/netframework/settings.targets
index 30b04a6dee3b01..4c3ebbf3c58f98 100644
--- a/src/libraries/pkg/test/frameworkSettings/net/settings.targets
+++ b/src/libraries/pkg/test/frameworkSettings/netframework/settings.targets
@@ -6,10 +6,6 @@
   </PropertyGroup>
   
   <ItemGroup>
-    <!-- For .NET Framework we reference this package which has the same layout as the SDK, with this package,
-    tests can run in any machine without having to install .NET Framework. -->
-    <PackageReference Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.0-preview.2" />
-
     <!-- these are part of the targeting pack but not actual assemblies -->
     <ExcludeReference Include="System.EnterpriseServices.Thunk;System.EnterpriseServices.Wrapper" />
     
diff --git a/src/libraries/pkg/test/frameworkSettings/netstandard/settings.targets b/src/libraries/pkg/test/frameworkSettings/netstandard/settings.targets
index af593ca8234cb2..523094ac931dda 100644
--- a/src/libraries/pkg/test/frameworkSettings/netstandard/settings.targets
+++ b/src/libraries/pkg/test/frameworkSettings/netstandard/settings.targets
@@ -1,6 +1,4 @@
 <Project>
-  <Import Project="$(ToolsDir)netfxreference.props" />
-
   <PropertyGroup>
     <ShouldVerifyClosure>true</ShouldVerifyClosure>
     <ShouldVerifyTypes>true</ShouldVerifyTypes>
@@ -14,4 +12,12 @@
     <!-- windows.winmd is not part of the framework -->
     <IgnoredReference Include="Windows" />
   </ItemGroup>
+
+  <!-- Include NETStandard assemblies when considering runtime assets for conflict resolution
+       works around https://github.com/dotnet/sdk/issues/18129 -->
+  <Target Name="IncludeNetStandardConflictResolution" BeforeTargets="_HandlePackageFileConflicts">
+    <ItemGroup>
+      <_RuntimeAssetsForConflictResolution Include="@(Reference)" Condition="'%(Reference.NuGetPackageId)' == 'NETStandard.Library' or '%(Reference.NuGetPackageId)' == 'NETStandard.Library.Ref'" />
+    </ItemGroup>
+  </Target>
 </Project>
\ No newline at end of file
diff --git a/src/libraries/pkg/test/frameworkSettings/netstandard2.1/settings.targets b/src/libraries/pkg/test/frameworkSettings/netstandard2.1/settings.targets
deleted file mode 100644
index 1fbde1af9ed94e..00000000000000
--- a/src/libraries/pkg/test/frameworkSettings/netstandard2.1/settings.targets
+++ /dev/null
@@ -1,90 +0,0 @@
-<Project>
-  <!-- Issue https://github.com/dotnet/runtime/issues/29209 NS2.1 overlaps with existing ns2.0 libs -->
-  <ItemGroup>
-    <!-- System.Buffers -->
-    <IgnoredTypes Include="System.Buffers.ArrayPool`1" />
-
-    <!-- System.Memory -->
-    <IgnoredTypes Include="System.Buffers.Binary.BinaryPrimitives" />
-    <IgnoredTypes Include="System.Buffers.BuffersExtensions" />
-    <IgnoredTypes Include="System.Buffers.IBufferWriter`1" />
-    <IgnoredTypes Include="System.Buffers.IMemoryOwner`1" />
-    <IgnoredTypes Include="System.Buffers.IPinnable" />
-    <IgnoredTypes Include="System.Buffers.MemoryHandle" />
-    <IgnoredTypes Include="System.Buffers.MemoryManager`1" />
-    <IgnoredTypes Include="System.Buffers.MemoryPool`1" />
-    <IgnoredTypes Include="System.Buffers.OperationStatus" />
-    <IgnoredTypes Include="System.Buffers.ReadOnlySequence`1" />
-    <IgnoredTypes Include="System.Buffers.ReadOnlySequence`1/Enumerator" />
-    <IgnoredTypes Include="System.Buffers.ReadOnlySequenceSegment`1" />
-    <IgnoredTypes Include="System.Buffers.StandardFormat" />
-    <IgnoredTypes Include="System.Buffers.Text.Base64" />
-    <IgnoredTypes Include="System.Buffers.Text.Utf8Formatter" />
-    <IgnoredTypes Include="System.Buffers.Text.Utf8Parser" />
-    <IgnoredTypes Include="System.Memory`1" />
-    <IgnoredTypes Include="System.MemoryExtensions" />
-    <IgnoredTypes Include="System.ReadOnlyMemory`1" />
-    <IgnoredTypes Include="System.ReadOnlySpan`1" />
-    <IgnoredTypes Include="System.ReadOnlySpan`1/Enumerator" />
-    <IgnoredTypes Include="System.Runtime.InteropServices.MemoryMarshal" />
-    <IgnoredTypes Include="System.Runtime.InteropServices.SequenceMarshal" />
-    <IgnoredTypes Include="System.SequencePosition" />
-    <IgnoredTypes Include="System.Span`1" />
-    <IgnoredTypes Include="System.Span`1/Enumerator" />
-
-    <!-- System.Numerics.Vectors -->
-    <IgnoredTypes Include="System.Numerics.Matrix3x2" />
-    <IgnoredTypes Include="System.Numerics.Matrix4x4" />
-    <IgnoredTypes Include="System.Numerics.Plane" />
-    <IgnoredTypes Include="System.Numerics.Quaternion" />
-    <IgnoredTypes Include="System.Numerics.Vector" />
-    <IgnoredTypes Include="System.Numerics.Vector`1" />
-    <IgnoredTypes Include="System.Numerics.Vector2" />
-    <IgnoredTypes Include="System.Numerics.Vector3" />
-    <IgnoredTypes Include="System.Numerics.Vector4" />
-
-    <!-- System.Reflection.DispatchProxy -->
-    <IgnoredTypes Include="System.Reflection.DispatchProxy" />
-
-    <!-- System.Reflection.Emit -->
-    <IgnoredTypes Include="System.Reflection.Emit.AssemblyBuilder" />
-    <IgnoredTypes Include="System.Reflection.Emit.AssemblyBuilderAccess" />
-    <IgnoredTypes Include="System.Reflection.Emit.ConstructorBuilder" />
-    <IgnoredTypes Include="System.Reflection.Emit.EnumBuilder" />
-    <IgnoredTypes Include="System.Reflection.Emit.EventBuilder" />
-    <IgnoredTypes Include="System.Reflection.Emit.FieldBuilder" />
-    <IgnoredTypes Include="System.Reflection.Emit.GenericTypeParameterBuilder" />
-    <IgnoredTypes Include="System.Reflection.Emit.MethodBuilder" />
-    <IgnoredTypes Include="System.Reflection.Emit.ModuleBuilder" />
-    <IgnoredTypes Include="System.Reflection.Emit.PropertyBuilder" />
-    <IgnoredTypes Include="System.Reflection.Emit.TypeBuilder" />
-
-    <!-- System.Reflection.Emit.ILGeneration -->
-    <IgnoredTypes Include="System.Reflection.Emit.CustomAttributeBuilder" />
-    <IgnoredTypes Include="System.Reflection.Emit.ILGenerator" />
-    <IgnoredTypes Include="System.Reflection.Emit.Label" />
-    <IgnoredTypes Include="System.Reflection.Emit.LocalBuilder" />
-    <IgnoredTypes Include="System.Reflection.Emit.ParameterBuilder" />
-    <IgnoredTypes Include="System.Reflection.Emit.SignatureHelper" />
-
-    <!-- System.Reflection.Emit.Lightweight -->
-    <IgnoredTypes Include="System.Reflection.Emit.DynamicMethod" />
-
-    <!-- System.Threading.Tasks.Extensions -->
-    <IgnoredTypes Include="System.Runtime.CompilerServices.AsyncMethodBuilderAttribute" />
-    <IgnoredTypes Include="System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder" />
-    <IgnoredTypes Include="System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder`1" />
-    <IgnoredTypes Include="System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable" />
-    <IgnoredTypes Include="System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable/ConfiguredValueTaskAwaiter" />
-    <IgnoredTypes Include="System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable`1" />
-    <IgnoredTypes Include="System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable`1/ConfiguredValueTaskAwaiter" />
-    <IgnoredTypes Include="System.Runtime.CompilerServices.ValueTaskAwaiter" />
-    <IgnoredTypes Include="System.Runtime.CompilerServices.ValueTaskAwaiter`1" />
-    <IgnoredTypes Include="System.Threading.Tasks.Sources.IValueTaskSource" />
-    <IgnoredTypes Include="System.Threading.Tasks.Sources.IValueTaskSource`1" />
-    <IgnoredTypes Include="System.Threading.Tasks.Sources.ValueTaskSourceOnCompletedFlags" />
-    <IgnoredTypes Include="System.Threading.Tasks.Sources.ValueTaskSourceStatus" />
-    <IgnoredTypes Include="System.Threading.Tasks.ValueTask" />
-    <IgnoredTypes Include="System.Threading.Tasks.ValueTask`1" />
-  </ItemGroup>
-</Project>
\ No newline at end of file
diff --git a/src/libraries/pkg/test/frameworkSettings/portable-net45+win8+wp8+wpa81/settings.targets b/src/libraries/pkg/test/frameworkSettings/portable-net45+win8+wp8+wpa81/settings.targets
deleted file mode 100644
index 72095adf9916ef..00000000000000
--- a/src/libraries/pkg/test/frameworkSettings/portable-net45+win8+wp8+wpa81/settings.targets
+++ /dev/null
@@ -1,7 +0,0 @@
-<Project>
-  <PropertyGroup>
-    <TargetFrameworkIdentifier>.NETPortable</TargetFrameworkIdentifier>
-    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
-    <TargetFrameworkProfile>Profile259</TargetFrameworkProfile>
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/src/libraries/pkg/test/frameworkSettings/portable-net45+win8+wpa81/settings.targets b/src/libraries/pkg/test/frameworkSettings/portable-net45+win8+wpa81/settings.targets
deleted file mode 100644
index 77255b7800253a..00000000000000
--- a/src/libraries/pkg/test/frameworkSettings/portable-net45+win8+wpa81/settings.targets
+++ /dev/null
@@ -1,7 +0,0 @@
-<Project>
-  <PropertyGroup>
-    <TargetFrameworkIdentifier>.NETPortable</TargetFrameworkIdentifier>
-    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
-    <TargetFrameworkProfile>Profile111</TargetFrameworkProfile>
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/src/libraries/pkg/test/frameworkSettings/portable-net45+win8/settings.targets b/src/libraries/pkg/test/frameworkSettings/portable-net45+win8/settings.targets
deleted file mode 100644
index e488ebf9aa53af..00000000000000
--- a/src/libraries/pkg/test/frameworkSettings/portable-net45+win8/settings.targets
+++ /dev/null
@@ -1,7 +0,0 @@
-<Project>
-  <PropertyGroup>
-    <TargetFrameworkIdentifier>.NETPortable</TargetFrameworkIdentifier>
-    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
-    <TargetFrameworkProfile>Profile7</TargetFrameworkProfile>
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/src/libraries/pkg/test/frameworkSettings/portable45-net45+win8/settings.targets b/src/libraries/pkg/test/frameworkSettings/portable45-net45+win8/settings.targets
deleted file mode 100644
index e488ebf9aa53af..00000000000000
--- a/src/libraries/pkg/test/frameworkSettings/portable45-net45+win8/settings.targets
+++ /dev/null
@@ -1,7 +0,0 @@
-<Project>
-  <PropertyGroup>
-    <TargetFrameworkIdentifier>.NETPortable</TargetFrameworkIdentifier>
-    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
-    <TargetFrameworkProfile>Profile7</TargetFrameworkProfile>
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/src/libraries/pkg/test/frameworkSettings/portable46-net451+win81/settings.targets b/src/libraries/pkg/test/frameworkSettings/portable46-net451+win81/settings.targets
deleted file mode 100644
index 463ffc65f149fa..00000000000000
--- a/src/libraries/pkg/test/frameworkSettings/portable46-net451+win81/settings.targets
+++ /dev/null
@@ -1,7 +0,0 @@
-<Project>
-  <PropertyGroup>
-    <TargetFrameworkIdentifier>.NETPortable</TargetFrameworkIdentifier>
-    <TargetFrameworkVersion>v4.6</TargetFrameworkVersion>
-    <TargetFrameworkProfile>Profile44</TargetFrameworkProfile>
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/src/libraries/pkg/test/packageSettings/Microsoft.XmlSerializer.Generator/net/disableNetstandardTest.targets b/src/libraries/pkg/test/packageSettings/Microsoft.XmlSerializer.Generator/netframework/disableNetstandardTest.targets
similarity index 100%
rename from src/libraries/pkg/test/packageSettings/Microsoft.XmlSerializer.Generator/net/disableNetstandardTest.targets
rename to src/libraries/pkg/test/packageSettings/Microsoft.XmlSerializer.Generator/netframework/disableNetstandardTest.targets
diff --git a/src/libraries/pkg/test/packageTest.targets b/src/libraries/pkg/test/packageTest.targets
deleted file mode 100644
index 81bb15d99b9252..00000000000000
--- a/src/libraries/pkg/test/packageTest.targets
+++ /dev/null
@@ -1,159 +0,0 @@
-<Project>
-
-  <PropertyGroup>
-    <_targetFrameworkVersionIndex>$(TargetFramework.IndexOfAny(".-0123456789"))</_targetFrameworkVersionIndex>
-    <_targetFrameworkIdentifier Condition="'$(_runtimeOSVersionIndex)' != '-1'">$(TargetFramework.SubString(0, $(_targetFrameworkVersionIndex)))</_targetFrameworkIdentifier>
-    <!-- For net5.0 and later use netcoreapp folder. -->
-    <_targetFrameworkIdentifier Condition="'$(_targetFrameworkIdentifier)' == 'net' and !$(TargetFramework.StartsWith('net4'))">netcoreapp</_targetFrameworkIdentifier>
-    <ToolsDir>$(MSBuildThisFileDirectory)tools\</ToolsDir>
-
-    <RestoreSources>
-      https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public/nuget/v3/index.json;
-      https://dotnetfeed.blob.core.windows.net/dotnet-core/index.json;
-      https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet6/nuget/v3/index.json;
-      https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet6-transport/nuget/v3/index.json;
-      $(LocalPackagesPath)
-    </RestoreSources>
-  </PropertyGroup>
-
-  <Import Project="tools\build\Packaging.common.targets" />
-  <Import Project="tools\eng\Versions.props" />
-  <Import Project="frameworkSettings\$(_targetFrameworkIdentifier)\*.targets" />
-  <Import Project="frameworkSettings\$(TargetFramework)\*.targets" />
-  <Import Project="packageSettings\$(TestPackageId)\*.targets" />
-  <Import Project="packageSettings\$(TestPackageId)\$(_targetFrameworkIdentifier)\*.targets" />
-  <Import Project="packageSettings\$(TestPackageId)\$(TargetFramework)\*.targets" />
-  
-  <ItemGroup>
-    <!-- Type duplicated: https://github.com/dotnet/runtime/issues/33998 -->
-    <IgnoredTypes Include="Microsoft.Extensions.Logging.LoggingBuilderExtensions" />
-    <!-- Type duplicated: https://github.com/dotnet/runtime/issues/34420 -->
-    <IgnoredTypes Include="System.Collections.Generic.CollectionExtensions" />
-  </ItemGroup>
-
-  <Target Name="LogBeginTest">
-    <PropertyGroup>
-      <_message>Testing $(TestPackageID) TFM=$(TargetFramework)</_message>
-      <_message Condition="'$(RuntimeIdentifier)' != ''">$(_message) RID=$(RuntimeIdentifier)</_message>
-    </PropertyGroup>
-    <Message Importance="High" Text="$(_message)" />
-  </Target>
-
-  <Target Name="VerifyReferenceClosure"
-          DependsOnTargets="ResolveReferences"
-          Condition="'$(ShouldVerifyClosure)' == 'true' and '$(RuntimeIdentifier)' == ''">
-    <ItemGroup>
-      <_refClosureFileNames Include="@(ReferencePath->'%(FileName)')">
-        <Original>%(Identity)</Original>
-      </_refClosureFileNames>
-      <_refClosureFileNamesFiltered Include="@(_refClosureFileNames)" Exclude="@(ExcludeFromClosure);@(ExcludeFromClosure->'%(Identity).ni')"/>
-      <_refClosureFileFiltered Include="@(_refClosureFileNamesFiltered->'%(Original)')"/>
-    </ItemGroup>
-
-    <VerifyClosure Condition="'@(_refClosureFileFiltered)' != ''"
-                   Sources="@(_refClosureFileFiltered)"
-                   IgnoredReferences="@(IgnoredReference)" />
-  </Target>
-
-  <Target Name="VerifyReferenceTypes" 
-          DependsOnTargets="ResolveReferences"
-          Condition="'$(ShouldVerifyTypes)' == 'true' and '$(RuntimeIdentifier)' == ''">
-    <ItemGroup>
-      <_refTypesFileNames Include="@(ReferencePath->'%(FileName)')">
-        <Original>%(Identity)</Original>
-      </_refTypesFileNames>
-      <_refTypesFileNamesFiltered Include="@(_refTypesFileNames)" Exclude="@(ExcludeFromTypes);@(ExcludeFromTypes->'%(Identity).ni')"/>
-      <_refTypesFileFiltered Include="@(_refTypesFileNamesFiltered->'%(Original)')"/>
-    </ItemGroup>
-
-    <VerifyTypes Condition="'@(_refTypesFileFiltered)' != ''"
-                 Sources="@(_refTypesFileFiltered)"
-                 IgnoredTypes="@(IgnoredTypes)" />
-  </Target>
-
-  <Target Name="VerifyRuntimeClosure" 
-          DependsOnTargets="ResolveReferences"
-          Condition="'$(ShouldVerifyClosure)' == 'true' and '$(RuntimeIdentifier)' != '' and '$(SkipVerifyClosureForRuntime)' != 'true'">
-    <ItemGroup>
-      <_runClosureFileNames Include="@(ReferenceCopyLocalPaths->'%(FileName)')">
-        <Original>%(Identity)</Original>
-      </_runClosureFileNames>
-      <_runClosureFileNamesFiltered Include="@(_runClosureFileNames)" Exclude="@(ExcludeFromClosure);@(ExcludeFromClosure->'%(Identity).ni')"/>
-      <_runClosureFileFiltered Include="@(_runClosureFileNamesFiltered->'%(Original)')"/>
-    </ItemGroup>
-
-    <VerifyClosure Condition="'@(_runClosureFileFiltered)' != ''"
-                   Sources="@(_runClosureFileFiltered)"
-                   IgnoredReferences="@(IgnoredReference)" />
-  </Target>
-
-  <Target Name="VerifyRuntimeTypes" 
-          DependsOnTargets="ResolveReferences"
-          Condition="'$(ShouldVerifyTypes)' == 'true' and '$(RuntimeIdentifier)' != ''">
-    <ItemGroup>
-      <_runTypesFileNames Include="@(ReferenceCopyLocalPaths->'%(FileName)')">
-        <Original>%(Identity)</Original>
-      </_runTypesFileNames>
-      <_runTypesFileNamesFiltered Include="@(_runTypesFileNames)" Exclude="@(ExcludeFromTypes);@(ExcludeFromTypes->'%(Identity).ni')"/>
-      <_runTypesFileFiltered Include="@(_runTypesFileNamesFiltered->'%(Original)')"/>
-    </ItemGroup>
-
-    <VerifyTypes Condition="'@(_runTypesFileFiltered)' != ''"
-                 Sources="@(_runTypesFileFiltered)"
-                 IgnoredTypes="@(IgnoredTypes)" />
-  </Target>
-
-  <Target Name="VerifyNotDependsOnNetStandard"
-          DependsOnTargets="ResolveReferences"
-          Condition="'$(_ShortFrameworkIdentifier)' == 'net' AND '$(_TargetFrameworkVersionWithoutV)' &gt;= '4.6.1' AND '$(RuntimeIdentifier)' == '' AND '$(DisableVerifyNotDependsOnNetStandardTest)' != 'true'">
-    <Error Condition="'$(DependsOnNetStandard)' == 'true'" Text="Package $(TestPackageId) requires netstandard shims when targeting $(TargetFramework)" />
-  </Target>
-
-  <PropertyGroup>
-    <_testDependsOn>
-      LogBeginTest;
-      VerifyNotDependsOnNetStandard;
-      VerifyReferenceClosure;
-      VerifyReferenceTypes;
-      VerifyRuntimeClosure;
-      VerifyRuntimeTypes;
-    </_testDependsOn>
-  </PropertyGroup>
-  
-  <!-- inner target to be called by outer Test Target -->
-  <Target Name="_test"
-          DependsOnTargets="$(_testDependsOn)">
-    <MakeDir Directories="$(IntermediateOutputPath)" />
-    <Touch AlwaysCreate="true" Files="$(IntermediateOutputPath)\$(RuntimeIdentifier).testComplete" />
-  </Target>
-  
-  <Target Name="_getTestProjects">
-    <ItemGroup>
-      <_projectRuntime Include="$(RuntimeIdentifiers)" />
-
-      <!-- Run _test once without RID, then for each RID -->
-      <TestProject Include="$(MSBuildProjectFullPath)">
-        <Semaphore>$(IntermediateOutputPath)\.testComplete</Semaphore>
-      </TestProject>
-      <TestProject Include="$(MSBuildProjectFullPath)" Condition="'%(_projectRuntime.Identity)' != ''">
-        <Semaphore>$(IntermediateOutputPath)\%(_projectRuntime.Identity).testComplete</Semaphore>
-        <AdditionalProperties>RuntimeIdentifier=%(_projectRuntime.Identity)</AdditionalProperties>
-      </TestProject>
-    </ItemGroup>
-  </Target>
-  
-  
-  <PropertyGroup>
-    <TestDependsOn>_getTestProjects</TestDependsOn>
-    <!-- Runs ResolveReferences once up front in order to ensure we don't run it for the first time concurrently during testing.
-         This is needed to avoid sharing violations when RAR and ResolvePackageAssets write out state files. -->
-    <TestDependsOn Condition="'$(ShouldVerifyClosure)' == 'true' or '$(ShouldVerifyTypes)' == 'true'">$(TestDependsOn);ResolveReferences</TestDependsOn>
-  </PropertyGroup>
-  <!-- Runs all tests scenarios for this project -->
-  <Target Name="Test"
-          DependsOnTargets="$(TestDependsOn)"
-          Inputs="@(TestProject);$(MSBuildAllProjects);$(ProjectAssetsFile)"
-          Outputs="@(TestProject->'%(Semaphore)')">
-    <MSBuild Projects="@(TestProject)" Targets="_test" BuildInParallel="true" />
-  </Target>
-</Project>
diff --git a/src/libraries/pkg/test/project.csproj.template b/src/libraries/pkg/test/project.csproj.template
index 9e6ab08111971c..b2c4858b1e1f47 100644
--- a/src/libraries/pkg/test/project.csproj.template
+++ b/src/libraries/pkg/test/project.csproj.template
@@ -1,22 +1,26 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>{TFM}</TargetFramework>
-    <RuntimeIdentifiers>{RIDs}</RuntimeIdentifiers>
+    <TargetFrameworks>{TargetFrameworks}</TargetFrameworks>
     <TestPackageId>{PackageId}</TestPackageId>
-    <TestPackageVersion>{PackageVersion}</TestPackageVersion>
+
+    <!-- Restore settings -->
+    <RestorePackagesPath>{RestorePackagesPath}</RestorePackagesPath>
+    <RestoreAdditionalProjectSources>{RestoreAdditionalProjectSources}</RestoreAdditionalProjectSources>
+
+    <!-- Used in targetingpacks.targets -->
+    <NetCoreAppCurrentVersion>{NetCoreAppCurrentVersion}</NetCoreAppCurrentVersion>
+    <NetCoreAppCurrent>{NetCoreAppCurrent}</NetCoreAppCurrent>
+    <MicrosoftNetCoreAppFrameworkName>{MicrosoftNetCoreAppFrameworkName}</MicrosoftNetCoreAppFrameworkName>
+    <MicrosoftNetCoreAppRefPackDir>{MicrosoftNetCoreAppRefPackDir}</MicrosoftNetCoreAppRefPackDir>
+
     <!-- Turn off end of life target framework checks as we intentionally build older .NETCoreApp configurations. -->
     <CheckEolTargetFramework>false</CheckEolTargetFramework>
-    <NETCoreAppMaximumVersion>99.0</NETCoreAppMaximumVersion>
-
-    <!-- Suppress any SYSLIB9000 errors, as in these cases restore/build would succeed, the failure would be at run-time -->
-    <SuppressTfmSupportBuildWarnings>true</SuppressTfmSupportBuildWarnings>
-    <SupportFilesDir Condition="'$(SupportFilesDir)' == ''">$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), Directory.Build.props))\support</SupportFilesDir>
+    <NETCoreAppMaximumVersion>$(NetCoreAppCurrentVersion)</NETCoreAppMaximumVersion>
   </PropertyGroup>
 
   <ItemGroup>
     <PackageReference Include="{PackageId}" Version="{PackageVersion}" />
   </ItemGroup>
 
-  <Import Project="$(SupportFilesDir)\packageTest.targets" />
 </Project>
diff --git a/src/libraries/pkg/test/props/Directory.Build.props b/src/libraries/pkg/test/props/Directory.Build.props
deleted file mode 100644
index 537832e4ac1b1c..00000000000000
--- a/src/libraries/pkg/test/props/Directory.Build.props
+++ /dev/null
@@ -1,6 +0,0 @@
-<Project>
-  <PropertyGroup>
-    <ImportDirectoryBuildTargets>false</ImportDirectoryBuildTargets>
-    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
-  </PropertyGroup>
-</Project>
diff --git a/src/libraries/pkg/test/test.msbuild b/src/libraries/pkg/test/test.msbuild
deleted file mode 100644
index 6d0a6a47c6d117..00000000000000
--- a/src/libraries/pkg/test/test.msbuild
+++ /dev/null
@@ -1,32 +0,0 @@
-<Project DefaultTargets="Restore;Test">
-  <ItemGroup>
-    <PackagesToTest Condition="'$(PackagesToTest)' != ''" Include="$(PackagesToTest)" />
-  </ItemGroup>
-
-  <PropertyGroup>
-    <PackageTestProjectsDir Condition="'$(PackageTestProjectsDir)' == ''">$(MSBuildThisFileDirectory)..\projects</PackageTestProjectsDir>
-    <_projectProperties>SupportFilesDir=$(MSBuildThisFileDirectory)</_projectProperties>
-    <LocalPackagesPath Condition="'$(LocalPackagesPath)' == ''">$(MSBuildThisFileDirectory)\packages</LocalPackagesPath>
-  </PropertyGroup>
-
-  <Target Name="GetProjects">
-    <ItemGroup>
-      <Project Condition="'@(PackagesToTest)' == ''" Include="$(PackageTestProjectsDir)\**\*.csproj" />
-      <Project Condition="'@(PackagesToTest)' != ''" Include="$(PackageTestProjectsDir)\%(PackagesToTest.Identity)\**\*.csproj" />
-    </ItemGroup>
-  </Target>
-
-  <Target Name="Restore"
-          Inputs="@(Project)"
-          Outputs="@(Project->'%(RootDir)%(Directory)obj\project.assets.json')"
-          DependsOnTargets="GetProjects">
-    <MSBuild Projects="@(Project)" Targets="Restore" BuildInParallel="true" Properties="$(_projectProperties);LocalPackagesPath=$(LocalPackagesPath)" />
-    <Touch Files="@(Project->'%(RootDir)%(Directory)obj\project.assets.json')" />
-  </Target>
-
-  <Target Name="Test" DependsOnTargets="GetProjects">
-    <!-- We need to pass a dummy global property to force msbuild reevaluation after restoring the project to get implicit references added
-    and all generated props and targets imported in the test step. This is used to be able to call RestoreAndTest target when running in helix. -->
-    <MSBuild Projects="@(Project)" Targets="Test" BuildInParallel="true" Properties="$(_projectProperties);ForceMsbuildEvaluation=true" />
-  </Target>
-</Project>
\ No newline at end of file
diff --git a/src/libraries/pkg/test/testPackages.proj b/src/libraries/pkg/test/testPackages.proj
index 2dcacddce6c578..03492c30ee0f97 100644
--- a/src/libraries/pkg/test/testPackages.proj
+++ b/src/libraries/pkg/test/testPackages.proj
@@ -1,18 +1,29 @@
-<Project DefaultTargets="Build">
-  <Import Project="$([MSBuild]::GetPathOfFileAbove(Directory.Build.props))" />
+<Project Sdk="Microsoft.Build.NoTargets">
+
+  <UsingTask TaskName="GetCompatiblePackageTargetFrameworks"
+             AssemblyFile="$(DotNetPackageTestingAssembly)"
+             Condition="'$(DotNetPackageTestingAssembly)' != ''" />
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.DotNet.PackageTesting" Version="$(MicrosoftDotNetPackageTestingVersion)" />
+    <!-- Needed by packageTest.targets, could be moved into PackageTesting: https://github.com/dotnet/arcade/issues/7474. -->
+    <PackageReference Include="Microsoft.DotNet.Build.Tasks.Packaging" Version="$(MicrosoftDotNetBuildTasksPackagingVersion)" />
+  </ItemGroup>
 
   <PropertyGroup>
     <PackageNamePattern>[a-zA-z\.]*\.</PackageNamePattern>
+
+    <TestDir>$(ArtifactsBinDir)testPackages\</TestDir>
+    <TestProjectDir>$(TestDir)projects\</TestProjectDir>
+    <TestPackageDir>$(TestDir)cache\</TestPackageDir>
+    <TestProjectName>dirs.proj</TestProjectName>
+    <ProjectTemplate>project.csproj.template</ProjectTemplate>
   </PropertyGroup>
 
   <ItemGroup>
     <PackagesToTest Condition="'$(PackagesToTest)' != ''" Include="$(PackagesToTest)" />
 
-    <PackageReports Condition="'@(PackagesToTest)' == ''" Include="$(PackageReportDir)*.json" Exclude="@(ExcludePackages->'$(PackageReportDir)%(Identity).json')"/>
-    <PackageReports Condition="'@(PackagesToTest)' != ''" Include="@(PackagesToTest->'$(PackageReportDir)%(Identity).json')" />
-
     <!-- support override via commandline -->
-    <RuntimesToInclude Condition="'$(RuntimesToInclude)' != ''" Include="$(RuntimesToInclude)" />
     <TargetFrameworksToInclude Condition="'$(TargetFrameworksToInclude)' != ''" Include="$(TargetFrameworksToInclude)" />
     <SymbolsPackages Include="$(LibrariesAllConfigShippingPackagesDir)*.symbols.nupkg" />
     
@@ -23,67 +34,46 @@
     <AllPackages Include="@(AllPackagesFilePath->'%(PackageName)')" />
 
     <ExcludePackages Condition="'$(PackagesToTest)' != ''" Include="@(AllPackages)" Exclude="@(PackagesToTest)" />
-    <TestPackages Include="@(AllPackages)" Exclude="@(ExcludePackages)"/>
+    <TestPackages Include="@(AllPackages)" Exclude="@(ExcludePackages)" />
     <TestPackagesPath Include="@(TestPackages->'%(PackagePath)')" />
 
-    <!-- we don't build alpine or older OSX versions -->
-    <RuntimesToExclude Include="alpine.3.4.3-x64;osx.10.10-x64;osx.10.11-x64;freebsd-x64" />
-
     <!-- no targeting pack was ever shipped for net463 -->
     <TargetFrameworksToExclude Include="net463" />
     <TargetFrameworksToExclude Include="net47" />
     <TargetFrameworksToExclude Include="netcoreapp2.2" />
   </ItemGroup>
 
-  <PropertyGroup>
-    <TestDir>$(ArtifactsBinDir)testPkg/</TestDir>
-    <TestSupportDir>$(TestDir)support/</TestSupportDir>
-    <TestProjectName>test.msbuild</TestProjectName>
-    <TestProject>$(TestSupportDir)$(TestProjectName)</TestProject>
-    <TestToolsDir>$(TestSupportDir)tools/</TestToolsDir>
-    <TestProjectDir>$(TestDir)projects/</TestProjectDir>
-    <TestPackageDir>$(ArtifactsBinDir)testPackages</TestPackageDir>
-    <TestDotNetPath>$(DotNetRoot)dotnet</TestDotNetPath>
-
-    <ProjectTemplate>project.csproj.template</ProjectTemplate>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <TestSupportFiles Include="$(LibrariesProjectRoot)shims\netfxreference.props">
-      <DestinationFolder>$(TestToolsDir)</DestinationFolder>
-    </TestSupportFiles>
-    <TestSupportFiles Include="$(RepositoryEngineeringDir)versions.props">
-      <DestinationFolder>$(TestToolsDir)eng/</DestinationFolder>
-    </TestSupportFiles>
-    <TestSupportFiles Include="$(PackagingTaskDir)..\..\**\*.*" Exclude="$(PackagingTaskDir)..\..\*.*">
-      <DestinationFolder>$(TestToolsDir)%(RecursiveDir)</DestinationFolder>
-    </TestSupportFiles>
-    <TestSupportFiles Include="props\Directory.Build.props">
-      <DestinationFolder>$(TestDir)</DestinationFolder>
-    </TestSupportFiles>
-    <TestSupportFiles Include="**\*.targets">
-      <DestinationFolder>$(TestSupportDir)%(RecursiveDir)</DestinationFolder>
-    </TestSupportFiles>
-    <TestSupportFiles Include="$(TestProjectName)">
-      <DestinationFolder>$(TestSupportDir)</DestinationFolder>
-    </TestSupportFiles>
-  </ItemGroup>
-
   <ItemGroup>
-    <CliEnvironment Include="DOTNET_CLI_TELEMETRY_OPTOUT=1" />
-    <CliEnvironment Include="DOTNET_SKIP_FIRST_TIME_EXPERIENCE=1" />
-    <CliEnvironment Include="DOTNET_MULTILEVEL_LOOKUP=0" />
+    <!-- The main entry point file. -->
+    <TestSupportFile Include="build\$(TestProjectName)"
+                     DestinationFolder="$(TestDir)" />
+    <!-- msbuild support files and the packaging VerifyClosure assembly. -->
+    <TestSupportFile Include="$(RepoRoot)global.json;
+                              $(RepoRoot)NuGet.config;
+                              $(RepositoryEngineeringDir)Versions.props;
+                              $(RepositoryEngineeringDir)targetingpacks.targets;
+                              $(LibrariesProjectRoot)shims\netfxreference.props;
+                              build\packageTest.targets;
+                              build\Directory.Build.props;
+                              build\Directory.Build.targets"
+                     DestinationFolder="$(TestDir)" />
+    <TestSupportFile Include="$(PackagingTaskDir)..\..\**\*.*"
+                     Exclude="$(PackagingTaskDir)..\..\*.*"
+                     DestinationFolder="$(TestDir)%(RecursiveDir)" />
+    <!-- frameworksettings and packagesettings -->
+    <TestSupportFile Include="frameworkSettings\**\*"
+                     DestinationFolder="$(TestDir)frameworkSettings\%(RecursiveDir)" />
+    <TestSupportFile Include="packageSettings\**\*"
+                     DestinationFolder="$(TestDir)packageSettings\%(RecursiveDir)" />
   </ItemGroup>
 
   <Target Name="CreateTestDir"
-          Inputs="@(TestSupportFiles)"
-          Outputs="@(TestSupportFiles->'%(DestinationFolder)\%(FileName)%(Extension)')">
-    <MakeDir Directories="%(TestSupportFiles.DestinationFolder)" />
-    <Copy SourceFiles="@(TestSupportFiles)" DestinationFolder="%(TestSupportFiles.DestinationFolder)" />
+          Inputs="@(TestSupportFile)"
+          Outputs="@(TestSupportFile->'%(DestinationFolder)\%(FileName)%(Extension)')">
+    <MakeDir Directories="%(TestSupportFile.DestinationFolder)" />
+    <Copy SourceFiles="@(TestSupportFile)" DestinationFolder="%(TestSupportFile.DestinationFolder)" />
   </Target>
 
-  <UsingTask TaskName="GetCompatiblePackageTargetFrameworks" AssemblyFile="$(DotNetPackageTestingAssembly)"/>
-
   <Target Name="GetSupportedPackages">
     <GetCompatiblePackageTargetFrameworks PackagePaths="@(TestPackagesPath)">
       <Output TaskParameter="TestProjects" ItemName="SupportedPackage" />
@@ -91,11 +81,10 @@
 
     <ItemGroup>
       <SupportedPackage>
-        <ProjectDir>$(TestProjectDir)%(Identity)/%(TargetFrameworkShort)/</ProjectDir>
+        <ProjectDir>$(TestProjectDir)%(Identity)\</ProjectDir>
       </SupportedPackage>
       <SupportedPackage>
         <ProjectFile>%(ProjectDir)project.csproj</ProjectFile>
-        <AssetsFile>%(ProjectDir)obj/project.assets.json</AssetsFile>
       </SupportedPackage>
     </ItemGroup>
   </Target>
@@ -114,124 +103,41 @@
     </ItemGroup>
   </Target>
 
-  <Target Name="UpdateRuntimeIdentifiers"
-          AfterTargets="GetSupportedPackages"
-          Inputs="%(SupportedPackage.Identity);%(SupportedPackage.TargetFrameworkShort)"
-          Outputs="unused">
-    <ItemGroup>
-      <_supportedPackageRuntimes Remove="@(_supportedPackageRuntimes)" />
-      <_supportedPackageRuntimes Include="%(SupportedPackage.RuntimeIdentifiers)" />
-
-      <_supportedPackageRuntimesToRemove Include="@(_supportedPackageRuntimes)" Exclude="@(RuntimesToInclude)" Condition="'@(RuntimesToInclude)' != ''" />
-      <_filteredSupportedPackageRuntimes Include="@(_supportedPackageRuntimes)" Exclude="@(RuntimesToExclude);@(_supportedPackageRuntimesToRemove)" />
-
-      <SupportedPackage>
-        <RuntimeIdentifiers>@(_filteredSupportedPackageRuntimes)</RuntimeIdentifiers>
-      </SupportedPackage>
-    </ItemGroup>
-  </Target>
-
   <Target Name="GenerateProjects"
           DependsOnTargets="GetSupportedPackages;CreateTestDir"
           Inputs="@(TestPackagesPath);$(ProjectTemplate)"
           Outputs="%(SupportedPackage.ProjectFile)">
     <PropertyGroup>
-      <_projectDir>%(SupportedPackage.ProjectDir)/</_projectDir>
+      <_projectDir>%(SupportedPackage.ProjectDir)</_projectDir>
       <_projectFile>%(SupportedPackage.ProjectFile)</_projectFile>
       <_packageId>%(SupportedPackage.Identity)</_packageId>
       <_packageVersion>%(SupportedPackage.Version)</_packageVersion>
-      <_projectTFM>%(SupportedPackage.TargetFrameworkShort)</_projectTFM>
-      <_projectRIDs>%(SupportedPackage.RuntimeIdentifiers)</_projectRIDs>
+      <_projectTFMs>@(SupportedPackage->'%(TargetFrameworkShort)')</_projectTFMs>
     </PropertyGroup>
 
+    <!-- Generate project.csproj from template. -->
     <MakeDir Directories="$(_projectDir)" />
-    <!-- Update project.json template -->
     <WriteLinesToFile
       File="$(_projectFile)"
-      Lines="$([System.IO.File]::ReadAllText('$(ProjectTemplate)').Replace('{PackageId}', $(_packageId)).Replace('{PackageVersion}', $(_packageVersion)).Replace('{TFM}', $(_projectTFM)).Replace('{RIDs}', '$(_projectRIDs)'))"
+      Lines="$([System.IO.File]::ReadAllText('$(ProjectTemplate)').Replace('{PackageId}', $(_packageId)).Replace('{PackageVersion}', $(_packageVersion)).Replace('{TargetFrameworks}', $(_projectTFMs)).Replace('{NetCoreAppCurrent}', $(NetCoreAppCurrent)).Replace('{NetCoreAppCurrentVersion}', $(NetCoreAppCurrentVersion)).Replace('{MicrosoftNetCoreAppFrameworkName}', $(MicrosoftNetCoreAppFrameworkName)).Replace('{MicrosoftNetCoreAppRefPackDir}', $(MicrosoftNetCoreAppRefPackDir)).Replace('{RestoreAdditionalProjectSources}', $(ArtifactsPackagesDir)).Replace('{RestorePackagesPath}', $(TestPackageDir)))"
       Overwrite="true" />
-    <Message Text="Generated $(_projectFile)" />
   </Target>
 
-  <Target Name="CopyProducedPackages">
-    <!-- Copy over package local cache to our helix runtime path -->
+  <Target Name="InvokeProjects"
+          DependsOnTargets="GenerateProjects"
+          AfterTargets="Build;Test">
     <ItemGroup>
-     <_localPackages Include="$(ArtifactsShippingPackagesDir)*.nupkg"/>
-     <_localPackages Include="$(ArtifactsNonShippingPackagesDir)*.nupkg"/>
+      <TestProject Include="$(TestDir)$(TestProjectName)" Condition="'$(PackagesToTest)' == ''" />
+      <TestProject Include="%(SupportedPackage.ProjectFile)" Condition="'$(PackagesToTest)' != ''" />
     </ItemGroup>
+    
+    <MSBuild Projects="@(TestProject)"
+             Properties="MSBuildRestoreSessionId=$([System.Guid]::NewGuid())"
+             Targets="Restore" />
 
-    <Copy SourceFiles="@(_localPackages)"
-          UseHardlinksIfPossible="true"
-          DestinationFolder="$(TestSupportDir)packages" />
-  </Target>
-
-  <Target Name="ArchiveHelixItems"
-          DependsOnTargets="GenerateProjects;CopyProducedPackages"
-          Condition="'$(ArchiveTests)' == 'true'">
-
-    <MakeDir Directories="$(TestArchiveTestsRoot)" />
-    <ZipDirectory
-        SourceDirectory="$(TestProjectDir)%(SupportedPackage.Identity)"
-        DestinationFile="$(TestArchiveTestsRoot)%(SupportedPackage.Identity).zip"
-        Overwrite="true" />
-
-    <MakeDir Directories="$(TestArchiveRuntimeRoot)" />
-    <ZipDirectory
-        SourceDirectory="$(TestSupportDir)"
-        DestinationFile="$(TestArchiveRuntimeRoot)packages-testPayload-$(Configuration).zip"
-        Overwrite="true" />
-
-  </Target>
-
-  <Target Name="RestoreProjects"
-          DependsOnTargets="GenerateProjects"
-          Condition="'$(ArchiveTests)' != 'true'">
-
-    <PropertyGroup>
-      <TestRestoreCommand>"$(TestDotNetPath)"</TestRestoreCommand>
-      <TestRestoreCommand>$(TestRestoreCommand) restore</TestRestoreCommand>
-      <TestRestoreCommand>$(TestRestoreCommand) --packages "$(TestPackageDir)"</TestRestoreCommand>
-      <TestRestoreCommand>$(TestRestoreCommand) /p:LocalPackagesPath=$(ArtifactsPackagesDir)</TestRestoreCommand>
-      <TestRestoreCommand>$(TestRestoreCommand) /nr:false</TestRestoreCommand>
-      <TestRestoreCommand>$(TestRestoreCommand) /warnaserror</TestRestoreCommand>
-      <TestRestoreCommand  Condition="'$(PackagesToTest)' != ''">$(TestRestoreCommand) /p:PackagesToTest=$(PackagesToTest)</TestRestoreCommand>
-    </PropertyGroup>
-
-    <Message Importance="High" Text="*** Restoring ***" />
-    <Exec Command="$(TestRestoreCommand) &quot;$(TestProject)&quot;" EnvironmentVariables="@(CliEnvironment)" StandardOutputImportance="High" />
-  </Target>
-
-  <Target Name="BuildProjects"
-          DependsOnTargets="RestoreProjects"
-          Condition="'$(ArchiveTests)' != 'true'">
-
-    <PropertyGroup>
-      <TestBuildCommand>"$(TestDotNetPath)"</TestBuildCommand>
-      <TestBuildCommand>$(TestBuildCommand) msbuild</TestBuildCommand>
-      <TestBuildCommand>$(TestBuildCommand) /t:Test</TestBuildCommand>
-      <TestBuildCommand>$(TestBuildCommand) /nr:false</TestBuildCommand>
-      <TestBuildCommand>$(TestBuildCommand) /warnaserror</TestBuildCommand>
-      <TestBuildCommand  Condition="'$(PackagesToTest)' != ''">$(TestBuildCommand) /p:PackagesToTest=$(PackagesToTest)</TestBuildCommand>
-    </PropertyGroup>
-
-    <Message Importance="High" Text="*** Testing *** %(SupportedPackage.Identity)" />
-    <Message Importance="High" Text="$(TestBuildCommand) &quot;$(TestProject)&quot;" />
-    <Exec Command="$(TestBuildCommand) &quot;$(TestProject)&quot;" EnvironmentVariables="@(CliEnvironment)" StandardOutputImportance="High" />
-  </Target>
-
-  <UsingTask TaskName="ValidateHarvestVersionIsLatestForRelease" AssemblyFile="$(PackagingTaskDir)Microsoft.DotNet.Build.Tasks.Packaging.dll"/>
-  <Target Name="HarvestVersionValidation">
-    <!-- This target will validate that all packages that are harvesting assets will be doing it from the right package version.
-         If an error is detected, the task will print out the command needed in order to fix the problem. This test requires
-         network access, as what it does is ensure that the harvest version we are using is the latest stable available for that
-         specific package release. -->
-    <ValidateHarvestVersionIsLatestForRelease PackageReports="@(PackageReports)" />
+    <MSBuild Projects="@(TestProject)" />
   </Target>
 
-  <Target Name="Build" DependsOnTargets="BuildProjects;HarvestVersionValidation;ArchiveHelixItems" />
-
-  <!-- define test to do nothing, for this project Build does all the testing -->
   <Target Name="Test" />
 
-  <Import Project="$([MSBuild]::GetPathOfFileAbove(Directory.Build.targets))" />
 </Project>
diff --git a/src/libraries/sendtohelix.proj b/src/libraries/sendtohelix.proj
index 7640d51fedec70..940bb713331e1d 100644
--- a/src/libraries/sendtohelix.proj
+++ b/src/libraries/sendtohelix.proj
@@ -16,13 +16,11 @@
 
   <PropertyGroup>
     <TargetFramework>$(NetCoreAppToolCurrent)</TargetFramework>
-    <BuildTargetFramework Condition="'$(TestPackages)' != 'true'">$([MSBuild]::ValueOrDefault('$(BuildTargetFramework)', '$(NetCoreAppCurrent)'))</BuildTargetFramework>
+    <BuildTargetFramework>$([MSBuild]::ValueOrDefault('$(BuildTargetFramework)', '$(NetCoreAppCurrent)'))</BuildTargetFramework>
     <TargetsWindows Condition="'$(TargetOS)' == 'windows'">true</TargetsWindows>
 
     <!-- The Helix correlation payload file -->
-    <TestArchiveRuntimeFile Condition="'$(TestPackages)' != 'true' and
-                                       '$(BuildTargetFramework)' == '$(NetCoreAppCurrent)'">$(TestArchiveRuntimeRoot)test-runtime-$(NetCoreAppCurrentBuildSettings).zip</TestArchiveRuntimeFile>
-    <TestArchiveRuntimeFile Condition="'$(TestPackages)' == 'true'">$(TestArchiveRuntimeRoot)packages-testPayload-$(Configuration).zip</TestArchiveRuntimeFile>
+    <TestArchiveRuntimeFile Condition="'$(BuildTargetFramework)' == '$(NetCoreAppCurrent)'">$(TestArchiveRuntimeRoot)test-runtime-$(NetCoreAppCurrentBuildSettings).zip</TestArchiveRuntimeFile>
 
     <!-- Set the name of the scenario file. Note that this is only used in invocations where $(Scenario) is set
          (which is when this project is invoked to call the "CreateOneScenarioTestEnvFile" target). -->
@@ -157,8 +155,7 @@
           DependsOnTargets="IncludeDumpDocsInTesthost;_CollectRuntimeInputs"
           Inputs="@(_RuntimeInput);@(TestArchiveRuntimeDependency)"
           Outputs="$(TestArchiveRuntimeFile)"
-          Condition="'$(TestPackages)' != 'true' and
-                     '$(TargetsMobile)' != 'true' and
+          Condition="'$(TargetsMobile)' != 'true' and
                      '$(TestArchiveRuntimeFile)' != ''">
 
     <!-- Compress the test files, testhost, and per-scenario scripts into a single ZIP file for sending to the Helix machines. -->
diff --git a/src/libraries/sendtohelixhelp.proj b/src/libraries/sendtohelixhelp.proj
index 84c140a2182a64..25d7168bdc4639 100644
--- a/src/libraries/sendtohelixhelp.proj
+++ b/src/libraries/sendtohelixhelp.proj
@@ -29,6 +29,7 @@
     <_workItemTimeout Condition="'$(Scenario)' == '' and '$(_workItemTimeout)' == '' and ('$(TargetArchitecture)' == 'arm64' or '$(TargetArchitecture)' == 'arm')">00:45:00</_workItemTimeout>
     <_workItemTimeout Condition="'$(Scenario)' != '' and '$(_workItemTimeout)' == '' and ('$(TargetArchitecture)' == 'arm64' or '$(TargetArchitecture)' == 'arm')">01:00:00</_workItemTimeout>
     <_workItemTimeout Condition="'$(Scenario)' == 'BuildWasmApps' and '$(_workItemTimeout)' == ''">01:00:00</_workItemTimeout>
+    <_workItemTimeout Condition="'$(Scenario)' == '' and '$(_workItemTimeout)' == '' and '$(Outerloop)' == 'true'">00:20:00</_workItemTimeout>
     <_workItemTimeout Condition="'$(Scenario)' == '' and '$(_workItemTimeout)' == ''">00:15:00</_workItemTimeout>
     <_workItemTimeout Condition="'$(Scenario)' != '' and '$(_workItemTimeout)' == ''">00:30:00</_workItemTimeout>
 
@@ -53,44 +54,26 @@
     <NeedsToBuildWasmAppsOnHelix Condition="'$(TargetOS)' == 'Browser' and '$(NeedsToBuildWasmAppsOnHelix)' == '' and '$(Scenario)' == 'BuildWasmApps'">true</NeedsToBuildWasmAppsOnHelix>
   </PropertyGroup>
 
-  <PropertyGroup Condition="'$(TestPackages)' == 'true'">
-    <!-- Use Helix feature to include dotnet CLI for every workitem and add it to the path -->
-    <NeedsDotNetSdk>true</NeedsDotNetSdk>
-    <UseDotNetCliVersionFromGlobalJson>true</UseDotNetCliVersionFromGlobalJson>
-
-    <TestRunNamePrefix>packaging-</TestRunNamePrefix>
-  </PropertyGroup>
-
   <PropertyGroup Condition="'$(HelixType)' == ''">
     <!-- For PRs we want HelixType to be the same for all frameworks except package testing-->
     <TestScope Condition="'$(TestScope)' == ''">innerloop</TestScope>
     <HelixType>test/functional/cli/$(TestScope)/</HelixType>
-    <HelixType Condition="'$(TestPackages)' == 'true'">test/functional/packaging/</HelixType>
   </PropertyGroup>
 
   <PropertyGroup Condition="'$(TargetOS)' == 'Browser' or '$(TargetOS)' == 'Android' or '$(TargetOS)' == 'iOS' or '$(TargetOS)' == 'iOSSimulator' or '$(TargetOS)' == 'tvOS' or '$(TargetOS)' == 'tvOSSimulator' or '$(TargetOS)' == 'MacCatalyst'">
     <IncludeXHarnessCli>true</IncludeXHarnessCli>
   </PropertyGroup>
 
-  <ItemGroup Condition="'$(TestPackages)' == 'true'">
-    <HelixPreCommand Include="set DOTNET_CLI_TELEMETRY_OPTOUT=1" />
-    <HelixPreCommand Include="set DOTNET_SKIP_FIRST_TIME_EXPERIENCE=1" />
-    <HelixPreCommand Include="set DOTNET_MULTILEVEL_LOOKUP=0" />
-  </ItemGroup>
-
-  <PropertyGroup Condition="'$(TestPackages)' == 'true'">
-    <HelixCommand>dotnet msbuild %HELIX_CORRELATION_PAYLOAD%\test.msbuild</HelixCommand>
-    <HelixCommand>$(HelixCommand) /warnaserror</HelixCommand>
-    <HelixCommand>$(HelixCommand) /p:PackageTestProjectsDir=%HELIX_WORKITEM_PAYLOAD%</HelixCommand>
-    <HelixCommand>$(HelixCommand) /p:RestorePackagesPath=%HELIX_WORKITEM_PAYLOAD%\packages</HelixCommand>
-    <HelixCommand>$(HelixCommand) /p:LocalPackagesPath="%HELIX_CORRELATION_PAYLOAD%\packages\"</HelixCommand>
-  </PropertyGroup>
-
   <ItemGroup Condition="'$(MonoEnvOptions)' != ''">
     <HelixPreCommand Condition="'$(TargetsWindows)' == 'true' or '$(BrowserHost)' == 'windows'" Include="set MONO_ENV_OPTIONS='$(MonoEnvOptions)'" />
     <HelixPreCommand Condition="'$(TargetsWindows)' != 'true' and '$(BrowserHost)' != 'windows'" Include="export MONO_ENV_OPTIONS='$(MonoEnvOptions)'" />
   </ItemGroup>
 
+  <ItemGroup Condition="'$(TargetsWindows)' == 'true' or '$(BrowserHost)' == 'windows'">
+    <HelixPreCommand Include="taskkill.exe /f /im corerun.exe"/>
+    <HelixPostCommand Include="taskkill.exe /f /im corerun.exe"/>
+  </ItemGroup>
+
   <ItemGroup Condition="'$(TargetOS)' == 'Browser' and '$(BrowserHost)' != 'windows'">
     <HelixPreCommand Condition="'$(Scenario)' != 'WasmTestOnBrowser'" Include="export XHARNESS_COMMAND=test" />
     <HelixPreCommand Condition="'$(Scenario)' == 'WasmTestOnBrowser'" Include="export XHARNESS_COMMAND=test-browser" />
@@ -105,7 +88,7 @@
   </ItemGroup>
 
   <PropertyGroup Condition="'$(TargetOS)' == 'Browser'">
-    <!-- 
+    <!--
       We are hosting the payloads for the WASM/browser on kestrel in the xharness process.
       We also run some network tests to this server and so, we are running it on both HTTP and HTTPS.
       For the HTTPS endpoint we need development SSL certificate.
@@ -260,7 +243,7 @@
     <ItemGroup Condition="'$(TargetOS)' == 'iOS' or '$(TargetOS)' == 'tvOS' or '$(TargetOS)' == 'iOSSimulator' or '$(TargetOS)' == 'tvOSSimulator' or '$(TargetOS)' == 'MacCatalyst'">
       <!-- Create work items for test apps -->
       <XHarnessAppBundleToTest Include="$([System.IO.Directory]::GetDirectories('$(TestArchiveTestsRoot)', '*.app', System.IO.SearchOption.AllDirectories))">
-        <Targets>$(AppleTestTarget)</Targets>
+        <TestTarget>$(AppleTestTarget)</TestTarget>
       </XHarnessAppBundleToTest>
       <!-- Create work items for run-only apps -->
       <XHarnessAppBundleToTest Condition="Exists('$(TestArchiveRoot)runonly')" Include="$([System.IO.Directory]::GetDirectories('$(TestArchiveRoot)runonly', '*.app', System.IO.SearchOption.AllDirectories))" >
@@ -268,7 +251,7 @@
         <IncludesTestRunner>false</IncludesTestRunner>
         <!-- The sample's C# Main method returns 42 so it should be considered by xharness as a success -->
         <ExpectedExitCode>42</ExpectedExitCode>
-        <Targets>$(AppleTestTarget)</Targets>
+        <TestTarget>$(AppleTestTarget)</TestTarget>
       </XHarnessAppBundleToTest>
     </ItemGroup>
 
@@ -293,12 +276,17 @@
       <SeleniumUrl>https://storage.googleapis.com/chromium-browser-snapshots/Linux_x64/$(ChromiumRevision)/chromedriver_linux64.zip</SeleniumUrl>
       <EmSdkDir>$([MSBuild]::NormalizeDirectory('$(RepoRoot)', 'src', 'mono', 'wasm', 'emsdk'))</EmSdkDir>
       <WasmBuildTargetsDir>$([MSBuild]::NormalizeDirectory('$(RepoRoot)', 'src', 'mono', 'wasm', 'build'))</WasmBuildTargetsDir>
+      <TestEchoMiddleware>$([MSBuild]::NormalizeDirectory('$(ArtifactsDir)', 'bin', 'NetCoreServer', '$(NetCoreAppCurrent)-$(Configuration)'))</TestEchoMiddleware>
+      <RemoteLoopMiddleware>$([MSBuild]::NormalizeDirectory('$(ArtifactsDir)', 'bin', 'RemoteLoopServer', '$(NetCoreAppCurrent)-$(Configuration)'))</RemoteLoopMiddleware>
     </PropertyGroup>
 
     <PropertyGroup Condition="'$(RuntimeFlavor)' == 'Mono'">
-      <MonoAotCrossCompilerPath>$([MSBuild]::NormalizePath($(MonoAotCrossDir), 'mono-aot-cross'))</MonoAotCrossCompilerPath>
-      <MonoAotCrossCompilerPath Condition="$([MSBuild]::IsOSPlatform('WINDOWS'))">$(MonoAotCrossCompilerPath).exe</MonoAotCrossCompilerPath>
+      <_MonoAotCrossCompilerPath>$([MSBuild]::NormalizePath($(MonoAotCrossDir), 'mono-aot-cross'))</_MonoAotCrossCompilerPath>
+      <_MonoAotCrossCompilerPath Condition="$([MSBuild]::IsOSPlatform('WINDOWS'))">$(_MonoAotCrossCompilerPath).exe</_MonoAotCrossCompilerPath>
     </PropertyGroup>
+    <ItemGroup Condition="'$(RuntimeFlavor)' == 'Mono'">
+      <MonoAotCrossCompiler Include="$(_MonoAotCrossCompilerPath)" RuntimeIdentifier="$(TargetOS.ToLowerInvariant())-$(TargetArchitecture.ToLowerInvariant())" />
+    </ItemGroup>
 
     <Message Condition="'$(TargetOS)' == 'Browser'" Importance="High" Text="Using emsdk: $(EmSdkDir)" />
 
@@ -322,6 +310,11 @@
       <HelixCorrelationPayload Include="$(MonoAotCrossDir)"                      Destination="build/cross" />
     </ItemGroup>
 
+    <ItemGroup Condition="'$(TargetOS)' == 'Browser'">
+      <HelixCorrelationPayload Include="$(TestEchoMiddleware)" Destination="xharness/TestEchoMiddleware" />
+      <HelixCorrelationPayload Include="$(RemoteLoopMiddleware)" Destination="xharness/RemoteLoopMiddleware" />
+    </ItemGroup>
+
     <ItemGroup Condition="'$(TargetOS)' != 'Android' and '$(TargetOS)' != 'iOS' and '$(TargetOS)' != 'iOSSimulator' and '$(TargetOS)' != 'tvOS' and '$(TargetOS)' != 'tvOSSimulator' and '$(TargetOS)' != 'MacCatalyst'">
       <HelixCorrelationPayload Include="$(HelixCorrelationPayload)"
                                Condition="'$(IncludeHelixCorrelationPayload)' == 'true' and '$(TargetOS)' != 'Browser'" />
@@ -401,7 +394,6 @@
   </Target>
 
   <Target Name="PrintBuildTargetFramework">
-    <Message Condition="'$(TestPackages)' != 'true'" Importance="High" Text="Build TargetFramework: $(BuildTargetFramework)" />
-    <Message Condition="'$(TestPackages)' == 'true'" Importance="High" Text="Doing Package Testing" />
+    <Message Importance="High" Text="Build TargetFramework: $(BuildTargetFramework)" />
   </Target>
 </Project>
diff --git a/src/libraries/tests.proj b/src/libraries/tests.proj
index d624fdc840781b..5cad3c540880b1 100644
--- a/src/libraries/tests.proj
+++ b/src/libraries/tests.proj
@@ -217,7 +217,7 @@
     <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.IO.Compression.ZipFile/tests/System.IO.Compression.ZipFile.Tests.csproj" />
   </ItemGroup>
 
-  <ItemGroup Condition="('$(TargetOS)' == 'MacCatalyst') and '$(RunDisablediOSTests)' != 'true'">
+  <ItemGroup Condition="'$(TargetOS)' == 'MacCatalyst' and '$(RunDisablediOSTests)' != 'true'">
     <!-- Crashes randomly during test runs https://github.com/dotnet/runtime/issues/52460 -->
     <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.Threading.Tasks\tests\System.Threading.Tasks.Tests.csproj" />
     <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.Threading.Tasks.Dataflow\tests\System.Threading.Tasks.Dataflow.Tests.csproj" />
@@ -230,7 +230,33 @@
     <ProjectExclusions Include="$(RepoRoot)\src\tests\FunctionalTests\iOS\Simulator\AOT-LLVM\**\*.Test.csproj" />
   </ItemGroup>
 
+  <ItemGroup Condition="'$(TargetOS)' == 'MacCatalyst' and '$(TargetArchitecture)' == 'arm64' and '$(RunDisablediOSTests)' != 'true'">
+    <!-- App Crash https://github.com/dotnet/runtime/issues/53624 -->
+    <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.IO.FileSystem.Watcher/tests/System.IO.FileSystem.Watcher.Tests.csproj" />
+    <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.Net.WebSockets.Client/tests/System.Net.WebSockets.Client.Tests.csproj" />
+
+    <!-- App Launch Failure https://github.com/dotnet/runtime/issues/53813 -->
+    <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.Composition.AttributedModel/tests/System.Composition.AttributeModel.Tests.csproj" />
+    <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.Composition.TypedParts/tests/System.Composition.TypedParts.Tests.csproj" />
+    <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.Diagnostics.DiagnosticSource/tests/TestWithConfigSwitches/System.Diagnostics.DiagnosticSource.Switches.Tests.csproj" />
+    <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.Globalization.Calendars/tests/System.Globalization.Calendars.Tests.csproj" />
+    <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.IO.UnmanagedMemoryStream/tests/System.IO.UnmanagedMemoryStream.Tests.csproj" />
+    <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.Web.HttpUtility/tests/System.Web.HttpUtility.Tests.csproj" />
+  </ItemGroup>
+
+  <ItemGroup Condition="'$(TargetOS)' == 'MacCatalyst' and '$(TargetArchitecture)' == 'x64' and '$(RunDisablediOSTests)' != 'true'">
+    <!-- App Crash https://github.com/dotnet/runtime/issues/53624 -->
+    <ProjectExclusions Include="$(MSBuildThisFileDirectory)Microsoft.CSharp/tests/Microsoft.CSharp.Tests.csproj" />
+    <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.Diagnostics.Tracing/tests/System.Diagnostics.Tracing.Tests.csproj" />
+    <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.Dynamic.Runtime/tests/System.Dynamic.Runtime.Tests.csproj" />
+    <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.Linq.Expressions/tests/System.Linq.Expressions.Tests.csproj" />
+    <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.Linq.Parallel/tests/System.Linq.Parallel.Tests.csproj" />
+    <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.Text.Json/tests/System.Text.Json.Tests/System.Text.Json.Tests.csproj" />
+  </ItemGroup>
+
   <ItemGroup Condition="'$(TargetOS)' == 'Browser' and '$(RunDisabledWasmTests)' != 'true'">
+    <ProjectExclusions Include="$(MSBuildThisFileDirectory)Microsoft.NETCore.Platforms\tests\Microsoft.NETCore.Platforms.Tests.csproj" />
+
     <!-- Mono-Browser ignores runtimeconfig.template.json (e.g. for this it has "System.Globalization.EnforceJapaneseEraYearRanges": true) -->
     <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.Globalization.Calendars\tests\CalendarTestWithConfigSwitch\System.Globalization.CalendarsWithConfigSwitch.Tests.csproj" />
 
@@ -252,29 +278,14 @@
   </ItemGroup>
 
   <ItemGroup Condition="'$(TargetOS)' == 'Browser' and '$(BuildAOTTestsOnHelix)' == 'true' and '$(RunDisabledWasmTests)' != 'true' and '$(RunAOTCompilation)' == 'true'">
-    <!-- Issue: https://github.com/dotnet/runtime/issues/51722 -->
-    <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.Linq\tests\System.Linq.Tests.csproj" />
-
-    <!-- Issue: https://github.com/dotnet/runtime/issues/51677 -->
-    <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.Threading.Tasks.Parallel/tests/System.Threading.Tasks.Parallel.Tests.csproj" />
-
-    <!-- Issue: https://github.com/dotnet/runtime/issues/50965 -->
-    <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.Text.Encodings.Web\tests\System.Text.Encodings.Web.Tests.csproj" />
-
-    <!-- Issue: https://github.com/dotnet/runtime/issues/51678 -->
-    <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.Runtime.Loader\tests\System.Runtime.Loader.Tests.csproj" />
-
-    <!-- Issue: https://github.com/dotnet/runtime/issues/51676 -->
-    <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.Runtime.Extensions\tests\System.Runtime.Extensions.Tests.csproj" />
+    <!-- Issue: https://github.com/dotnet/runtime/issues/54194 -->
+    <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.IO.MemoryMappedFiles/tests/System.IO.MemoryMappedFiles.Tests.csproj" />
 
     <!-- Issue: https://github.com/dotnet/runtime/issues/52393 -->
     <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.Runtime/tests/System.Runtime.Tests.csproj" />
 
     <!-- Issue: https://github.com/dotnet/runtime/issues/51961 -->
     <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.Text.Json/tests/System.Text.Json.Tests/System.Text.Json.Tests.csproj" />
-
-    <!-- Issue: https://github.com/dotnet/runtime/issues/50959 -->
-    <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.IO.Pipelines\tests\System.IO.Pipelines.Tests.csproj" />
   </ItemGroup>
 
   <ItemGroup Condition="'$(TargetOS)' == 'Browser' and '$(BuildAOTTestsOnHelix)' == 'true' and '$(RunDisabledWasmTests)' != 'true'">
@@ -302,10 +313,6 @@
     <!-- Issue: https://github.com/dotnet/runtime/issues/51708 -->
     <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.Linq.Expressions\tests\System.Linq.Expressions.Tests.csproj" />
 
-    <!-- Issue: https://github.com/dotnet/runtime/issues/51244 -->
-    <!-- Issue: https://github.com/dotnet/runtime/issues/51911 -->
-    <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.Private.Xml\tests\Xslt\XslCompiledTransformApi\System.Xml.Xsl.XslCompiledTransformApi.Tests.csproj" />
-
     <!-- MarkTypeForDynamicallyAccessedMembers stack overflow https://github.com/mono/linker/issues/1881 -->
     <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.ComponentModel.Annotations\tests\System.ComponentModel.Annotations.Tests.csproj" />
 
@@ -315,7 +322,6 @@
 
   <ItemGroup Condition="'$(TargetOS)' == 'Browser' and '$(BrowserHost)' == 'windows' and '$(RunDisabledWasmTestsOnWindows)' != 'true'">
     <!-- Issue: https://github.com/dotnet/runtime/issues/52138 -->
-    <ProjectExclusions Include="$(MSBuildThisFileDirectory)Microsoft.Extensions.Http\tests\Microsoft.Extensions.Http.Tests\Microsoft.Extensions.Http.Tests.csproj" />
     <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.Text.Json\tests\System.Text.Json.Tests/System.Text.Json.Tests.csproj" />
     <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.IO.Compression\tests\System.IO.Compression.Tests.csproj" />
     <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.IO.Compression.ZipFile\tests\System.IO.Compression.ZipFile.Tests.csproj" />
@@ -329,55 +335,8 @@
     <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.Security.Cryptography.Algorithms/tests/System.Security.Cryptography.Algorithms.Tests.csproj" />
     <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.Security.Cryptography.OpenSsl/tests/System.Security.Cryptography.OpenSsl.Tests.csproj" />
     <!-- ActiveIssue XUnit crashes on Apple Silicon https://github.com/dotnet/runtime/issues/49110 -->
-    <ProjectExclusions Include="$(MSBuildThisFileDirectory)Common/tests/Common.Tests.csproj" />
-    <ProjectExclusions Include="$(MSBuildThisFileDirectory)Microsoft.Bcl.AsyncInterfaces/tests/Microsoft.Bcl.AsyncInterfaces.Tests.csproj" />
-    <ProjectExclusions Include="$(MSBuildThisFileDirectory)Microsoft.Extensions.Caching.Memory/tests/Microsoft.Extensions.Caching.Memory.Tests.csproj" />
-    <ProjectExclusions Include="$(MSBuildThisFileDirectory)Microsoft.Extensions.Configuration.EnvironmentVariables/tests/Microsoft.Extensions.Configuration.EnvironmentVariables.Tests.csproj" />
-    <ProjectExclusions Include="$(MSBuildThisFileDirectory)Microsoft.Extensions.DependencyInjection/tests/DI.External.Tests/Microsoft.Extensions.DependencyInjection.ExternalContainers.Tests.csproj" />
-    <ProjectExclusions Include="$(MSBuildThisFileDirectory)Microsoft.Extensions.DependencyInjection/tests/DI.Tests/Microsoft.Extensions.DependencyInjection.Tests.csproj" />
-    <ProjectExclusions Include="$(MSBuildThisFileDirectory)Microsoft.Extensions.Hosting/tests/UnitTests/Microsoft.Extensions.Hosting.Unit.Tests.csproj" />
-    <ProjectExclusions Include="$(MSBuildThisFileDirectory)Microsoft.Extensions.Logging.EventSource/tests/Microsoft.Extensions.Logging.EventSource.Tests.csproj" />
-    <ProjectExclusions Include="$(MSBuildThisFileDirectory)Microsoft.Extensions.Logging/tests/Common/Microsoft.Extensions.Logging.Tests.csproj" />
-    <ProjectExclusions Include="$(MSBuildThisFileDirectory)Microsoft.Extensions.Logging/tests/DI.Common/Common/tests/Microsoft.Extensions.Logging.Testing.Tests.csproj" />
-    <ProjectExclusions Include="$(MSBuildThisFileDirectory)Microsoft.Extensions.Primitives/tests/Microsoft.Extensions.Primitives.Tests.csproj" />
-    <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.CodeDom/tests/System.CodeDom.Tests.csproj" />
-    <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.Collections.NonGeneric/tests/System.Collections.NonGeneric.Tests.csproj" />
-    <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.Collections/tests/System.Collections.Tests.csproj" />
-    <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.ComponentModel.Composition/tests/System.ComponentModel.Composition.Tests.csproj" />
-    <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.ComponentModel.TypeConverter/tests/System.ComponentModel.TypeConverter.Tests.csproj" />
-    <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.DirectoryServices.Protocols/tests/System.DirectoryServices.Protocols.Tests.csproj" />
-    <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.Drawing.Primitives/tests/System.Drawing.Primitives.Tests.csproj" />
-    <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.Dynamic.Runtime/tests/System.Dynamic.Runtime.Tests.csproj" />
-    <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.Formats.Cbor/tests/System.Formats.Cbor.Tests.csproj" />
-    <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.IO.Compression.Brotli/tests/System.IO.Compression.Brotli.Tests.csproj" />
-    <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.IO.Compression/tests/System.IO.Compression.Tests.csproj" />
-    <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.IO.FileSystem/tests/System.IO.FileSystem.Tests.csproj" />
-    <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.IO.FileSystem.Watcher/tests/System.IO.FileSystem.Watcher.Tests.csproj" />
-    <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.IO.Pipes/tests/System.IO.Pipes.Tests.csproj" />
-    <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.Linq.Expressions/tests/System.Linq.Expressions.Tests.csproj" />
-    <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.Linq.Queryable/tests/System.Linq.Queryable.Tests.csproj" />
-    <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.Memory.Data/tests/System.Memory.Data.Tests.csproj" />
-    <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.Net.Mail/tests/Functional/System.Net.Mail.Functional.Tests.csproj" />
-    <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.Net.Ping/tests/FunctionalTests/System.Net.Ping.Functional.Tests.csproj" />
-    <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.Net.WebSockets.Client/tests/System.Net.WebSockets.Client.Tests.csproj" />
-    <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.Net.WebSockets/tests/System.Net.WebSockets.Tests.csproj" />
     <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.Numerics.Vectors/tests/System.Numerics.Vectors.Tests.csproj" />
-    <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.Private.Uri/tests/UnitTests/System.Private.Uri.Unit.Tests.csproj" />
-    <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.Private.Xml/tests/Misc/System.Xml.Misc.Tests.csproj" />
-    <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.Private.Xml/tests/XmlReader/Tests/System.Xml.RW.XmlReader.Tests.csproj" />
-    <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.Private.Xml/tests/XPath/XPathDocument/System.Xml.XPath.Tests.csproj" />
-    <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.Private.Xml/tests/Xslt/XslCompiledTransformApi/System.Xml.Xsl.XslCompiledTransformApi.Tests.csproj" />
-    <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.Reflection.Emit.Lightweight/tests/System.Reflection.Emit.Lightweight.Tests.csproj" />
-    <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.Resources.ResourceManager/tests/System.Resources.ResourceManager.Tests.csproj" />
     <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.Runtime/tests/System.Runtime.Tests.csproj" />
-    <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.Runtime.Loader/tests/System.Runtime.Loader.Tests.csproj" />
-    <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.Security.Cryptography.X509Certificates/tests/System.Security.Cryptography.X509Certificates.Tests.csproj" />
-    <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.Text.Json/tests/System.Text.Json.Tests.csproj" />
-    <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.Text.RegularExpressions/tests/System.Text.RegularExpressions.Tests.csproj" />
-    <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.Threading.Channels/tests/System.Threading.Channels.Tests.csproj" />
-    <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.Threading.Tasks.Dataflow/tests/System.Threading.Tasks.Dataflow.Tests.csproj" />
-    <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.Threading.Tasks.Parallel/tests/System.Threading.Tasks.Parallel.Tests.csproj" />
-    <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.Threading.Timer/tests/System.Threading.Timer.Tests.csproj" />
   </ItemGroup>
 
   <ItemGroup Condition="'$(TestSingleFile)' == 'true'">
diff --git a/src/mono/CMakeLists.txt b/src/mono/CMakeLists.txt
index 5eaaaa91b6504e..038be0cbcf7ccf 100644
--- a/src/mono/CMakeLists.txt
+++ b/src/mono/CMakeLists.txt
@@ -109,10 +109,6 @@ if((CMAKE_CXX_COMPILER_ID STREQUAL "GNU") OR(CMAKE_CXX_COMPILER_ID STREQUAL "Cla
   set(GCC 1)
 endif()
 
-if(DISABLE_INTERPRETER)
-  unset(ENABLE_METADATA_UPDATE)
-endif()
-
 add_definitions(-DHAVE_CONFIG_H)
 
 if(GCC)
diff --git a/src/mono/Directory.Build.props b/src/mono/Directory.Build.props
index 35e223f09c80a9..a457800199a3a0 100644
--- a/src/mono/Directory.Build.props
+++ b/src/mono/Directory.Build.props
@@ -61,9 +61,12 @@
 
   <PropertyGroup>
     <MonoAotCrossDir>$([MSBuild]::NormalizePath($(RuntimeBinDir), 'cross', '$(TargetOS.ToLowerInvariant())-$(TargetArchitecture.ToLowerInvariant())'))</MonoAotCrossDir>
-    <MonoAotCrossCompilerPath>$([MSBuild]::NormalizePath($(MonoAotCrossDir), 'mono-aot-cross'))</MonoAotCrossCompilerPath>
-    <MonoAotCrossCompilerPath Condition="$([MSBuild]::IsOSPlatform('WINDOWS'))">$(MonoAotCrossCompilerPath).exe</MonoAotCrossCompilerPath>
+    <_MonoAotCrossCompilerPath>$([MSBuild]::NormalizePath($(MonoAotCrossDir), 'mono-aot-cross'))</_MonoAotCrossCompilerPath>
+    <_MonoAotCrossCompilerPath Condition="$([MSBuild]::IsOSPlatform('WINDOWS'))">$(_MonoAotCrossCompilerPath).exe</_MonoAotCrossCompilerPath>
   </PropertyGroup>
+  <ItemGroup>
+    <MonoAotCrossCompiler Include="$(_MonoAotCrossCompilerPath)" RuntimeIdentifier="$(TargetOS.ToLowerInvariant())-$(TargetArchitecture.ToLowerInvariant())" />
+  </ItemGroup>
 
   <!-- Paths for Mobile App Projects  -->
   <PropertyGroup>
@@ -74,11 +77,4 @@
     <MonoAOTCompilerProjDirectory>$([MSBuild]::NormalizeDirectory('$(RepoTasksDir)', 'AotCompilerTask'))</MonoAOTCompilerProjDirectory>
   </PropertyGroup>
 
-  <!-- Feature defaults for mono.proj and System.Private.CoreLib.csproj -->
-  <PropertyGroup>
-    <!-- default metadata update support for specific platforms -->
-    <MonoMetadataUpdate Condition="'$(MonoMetadataUpdate)' == '' and ('$(TargetsAndroid)' == 'true' or '$(TargetsBrowser)' == 'true')">true</MonoMetadataUpdate>
-    <MonoMetadataUpdate Condition="'$(MonoMetadataUpdate)' == '' and ('$(TargetsiOS)' == 'true' or '$(TargetstvOS)' == 'true' or '$(TargetsMacCatalyst)' == 'true')">true</MonoMetadataUpdate>
-    <MonoMetadataUpdate Condition="'$(MonoMetadataUpdate)' == ''">false</MonoMetadataUpdate>
-  </PropertyGroup>
 </Project>
diff --git a/src/mono/System.Private.CoreLib/System.Private.CoreLib.csproj b/src/mono/System.Private.CoreLib/System.Private.CoreLib.csproj
index 34dcb45c40f995..61ad598697e045 100644
--- a/src/mono/System.Private.CoreLib/System.Private.CoreLib.csproj
+++ b/src/mono/System.Private.CoreLib/System.Private.CoreLib.csproj
@@ -125,11 +125,6 @@
     <DefineConstants Condition="'$(FeatureObjCMarshal)' == 'true'">$(DefineConstants);FEATURE_OBJCMARSHAL</DefineConstants>
   </PropertyGroup>
 
-  <!-- Experimental mono metadata update feature -->
-  <PropertyGroup>
-    <DefineConstants Condition="'$(MonoMetadataUpdate)' == 'true'">$(DefineConstants);FEATURE_METADATA_UPDATE</DefineConstants>
-  </PropertyGroup>
-
   <!-- ILLinker settings -->
   <PropertyGroup>
     <ILLinkTrimAssembly>true</ILLinkTrimAssembly>
diff --git a/src/mono/System.Private.CoreLib/src/System/Reflection/Metadata/AssemblyExtensions.cs b/src/mono/System.Private.CoreLib/src/System/Reflection/Metadata/AssemblyExtensions.cs
index 471ab27922ed8c..c211c5d68f5d64 100644
--- a/src/mono/System.Private.CoreLib/src/System/Reflection/Metadata/AssemblyExtensions.cs
+++ b/src/mono/System.Private.CoreLib/src/System/Reflection/Metadata/AssemblyExtensions.cs
@@ -37,9 +37,6 @@ public static void ApplyUpdate(Assembly assembly, ReadOnlySpan<byte> metadataDel
             if (runtimeAssembly == typeof(AssemblyExtensions).Assembly)
                 throw new InvalidOperationException (SR.InvalidOperation_AssemblyNotEditable);
 
-#if !FEATURE_METADATA_UPDATE
-            throw new NotSupportedException (SR.NotSupported_MethodBodyReplacement);
-#else
             unsafe
             {
                 IntPtr monoAssembly = runtimeAssembly.GetUnderlyingNativeHandle ();
@@ -48,22 +45,22 @@ public static void ApplyUpdate(Assembly assembly, ReadOnlySpan<byte> metadataDel
                     ApplyUpdate_internal(monoAssembly, metadataDeltaPtr, metadataDelta.Length, ilDeltaPtr, ilDelta.Length, pdbDeltaPtr, pdbDelta.Length);
                 }
             }
-#endif
         }
 
-        internal static string GetApplyUpdateCapabilities()
+        private static Lazy<string> s_ApplyUpdateCapabilities = new Lazy<string>(() => InitializeApplyUpdateCapabilities());
+
+        internal static string GetApplyUpdateCapabilities() => s_ApplyUpdateCapabilities.Value;
+
+        private static string InitializeApplyUpdateCapabilities()
         {
-#if !FEATURE_METADATA_UPDATE
-            return string.Empty;
-#else
-            return "Baseline";
-#endif
+            return ApplyUpdateEnabled() != 0 ? "Baseline" : string.Empty ;
         }
 
-#if FEATURE_METADATA_UPDATE
+
         [MethodImpl (MethodImplOptions.InternalCall)]
-        private static unsafe extern void ApplyUpdate_internal (IntPtr base_assm, byte* dmeta_bytes, int dmeta_length, byte *dil_bytes, int dil_length, byte *dpdb_bytes, int dpdb_length);
-#endif
+        private static extern int ApplyUpdateEnabled ();
 
+        [MethodImpl (MethodImplOptions.InternalCall)]
+        private static unsafe extern void ApplyUpdate_internal (IntPtr base_assm, byte* dmeta_bytes, int dmeta_length, byte *dil_bytes, int dil_length, byte *dpdb_bytes, int dpdb_length);
     }
 }
diff --git a/src/mono/System.Private.CoreLib/src/System/Reflection/RuntimeEventInfo.cs b/src/mono/System.Private.CoreLib/src/System/Reflection/RuntimeEventInfo.cs
index 2c7fbda9e8ddf3..e92011c9d2f816 100644
--- a/src/mono/System.Private.CoreLib/src/System/Reflection/RuntimeEventInfo.cs
+++ b/src/mono/System.Private.CoreLib/src/System/Reflection/RuntimeEventInfo.cs
@@ -82,14 +82,6 @@ internal RuntimeType GetDeclaringTypeInternal()
             return (RuntimeType)DeclaringType;
         }
 
-        private RuntimeType ReflectedTypeInternal
-        {
-            get
-            {
-                return (RuntimeType)ReflectedType;
-            }
-        }
-
         internal RuntimeModule GetRuntimeModule()
         {
             return GetDeclaringTypeInternal().GetRuntimeModule();
diff --git a/src/mono/System.Private.CoreLib/src/System/Reflection/RuntimeFieldInfo.cs b/src/mono/System.Private.CoreLib/src/System/Reflection/RuntimeFieldInfo.cs
index b4a9c2f13a065a..15649ac800affa 100644
--- a/src/mono/System.Private.CoreLib/src/System/Reflection/RuntimeFieldInfo.cs
+++ b/src/mono/System.Private.CoreLib/src/System/Reflection/RuntimeFieldInfo.cs
@@ -63,14 +63,6 @@ internal RuntimeType GetDeclaringTypeInternal()
             return (RuntimeType)DeclaringType!;
         }
 
-        private RuntimeType ReflectedTypeInternal
-        {
-            get
-            {
-                return (RuntimeType)ReflectedType;
-            }
-        }
-
         internal RuntimeModule GetRuntimeModule()
         {
             return GetDeclaringTypeInternal().GetRuntimeModule();
diff --git a/src/mono/System.Private.CoreLib/src/System/Reflection/RuntimeMethodInfo.cs b/src/mono/System.Private.CoreLib/src/System/Reflection/RuntimeMethodInfo.cs
index aba9b94c8b83f3..362b99998df2c5 100644
--- a/src/mono/System.Private.CoreLib/src/System/Reflection/RuntimeMethodInfo.cs
+++ b/src/mono/System.Private.CoreLib/src/System/Reflection/RuntimeMethodInfo.cs
@@ -157,14 +157,6 @@ public override Module Module
             }
         }
 
-        private RuntimeType? ReflectedTypeInternal
-        {
-            get
-            {
-                return (RuntimeType?)ReflectedType;
-            }
-        }
-
         private string FormatNameAndSig()
         {
             // Serialization uses ToString to resolve MethodInfo overloads.
@@ -788,14 +780,6 @@ internal RuntimeModule GetRuntimeModule()
             return RuntimeTypeHandle.GetModule((RuntimeType)DeclaringType);
         }
 
-        private RuntimeType? ReflectedTypeInternal
-        {
-            get
-            {
-                return (RuntimeType?)ReflectedType;
-            }
-        }
-
         public override MethodImplAttributes GetMethodImplementationFlags()
         {
             return MonoMethodInfo.GetMethodImplementationFlags(mhandle);
diff --git a/src/mono/System.Private.CoreLib/src/System/Reflection/RuntimePropertyInfo.cs b/src/mono/System.Private.CoreLib/src/System/Reflection/RuntimePropertyInfo.cs
index 9e05a18daaf0f6..20defaa52c48c8 100644
--- a/src/mono/System.Private.CoreLib/src/System/Reflection/RuntimePropertyInfo.cs
+++ b/src/mono/System.Private.CoreLib/src/System/Reflection/RuntimePropertyInfo.cs
@@ -131,14 +131,6 @@ internal RuntimeType GetDeclaringTypeInternal()
             return (RuntimeType)DeclaringType;
         }
 
-        private RuntimeType ReflectedTypeInternal
-        {
-            get
-            {
-                return (RuntimeType)ReflectedType;
-            }
-        }
-
         internal RuntimeModule GetRuntimeModule()
         {
             return GetDeclaringTypeInternal().GetRuntimeModule();
diff --git a/src/mono/System.Private.CoreLib/src/System/RuntimeType.Mono.cs b/src/mono/System.Private.CoreLib/src/System/RuntimeType.Mono.cs
index 7b9c50c6c25a9f..241fee87a4c435 100644
--- a/src/mono/System.Private.CoreLib/src/System/RuntimeType.Mono.cs
+++ b/src/mono/System.Private.CoreLib/src/System/RuntimeType.Mono.cs
@@ -7,7 +7,6 @@
 using System.Collections.Generic;
 using System.Runtime.Serialization;
 using System.Runtime.CompilerServices;
-using System.Diagnostics.Contracts;
 using System.Diagnostics.CodeAnalysis;
 using System.Runtime.InteropServices;
 using System.Diagnostics;
@@ -38,14 +37,6 @@ internal enum TypeNameFormatFlags
                               FormatFullInst
     }
 
-    internal enum TypeNameKind
-    {
-        Name,
-        ToString,
-        SerializationName,
-        FullName,
-    }
-
     internal partial class RuntimeType
     {
         #region Definitions
@@ -1127,8 +1118,135 @@ public override MemberInfo[] GetMember(string name, MemberTypes type, BindingFla
 
             return compressMembers;
         }
-        #endregion
 
+        public override MemberInfo GetMemberWithSameMetadataDefinitionAs(MemberInfo member)
+        {
+            if (member is null) throw new ArgumentNullException(nameof(member));
+
+            RuntimeType? runtimeType = this;
+            while (runtimeType != null)
+            {
+                MemberInfo? result = member.MemberType switch
+                {
+                    MemberTypes.Method => GetMethodWithSameMetadataDefinitionAs(runtimeType, member),
+                    MemberTypes.Constructor => GetConstructorWithSameMetadataDefinitionAs(runtimeType, member),
+                    MemberTypes.Property => GetPropertyWithSameMetadataDefinitionAs(runtimeType, member),
+                    MemberTypes.Field => GetFieldWithSameMetadataDefinitionAs(runtimeType, member),
+                    MemberTypes.Event => GetEventWithSameMetadataDefinitionAs(runtimeType, member),
+                    MemberTypes.NestedType => GetNestedTypeWithSameMetadataDefinitionAs(runtimeType, member),
+                    _ => null
+                };
+
+                if (result != null)
+                {
+                    return result;
+                }
+
+                runtimeType = runtimeType.GetBaseType();
+            }
+
+            throw CreateGetMemberWithSameMetadataDefinitionAsNotFoundException(member);
+        }
+
+        private const BindingFlags GetMemberWithSameMetadataDefinitionAsBindingFlags =
+            BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;
+
+        private static MemberInfo? GetMethodWithSameMetadataDefinitionAs(RuntimeType runtimeType, MemberInfo methodInfo)
+        {
+            ListBuilder<MethodInfo> methods = runtimeType.GetMethodCandidates(methodInfo.Name, GetMemberWithSameMetadataDefinitionAsBindingFlags, CallingConventions.Any, null, -1, allowPrefixLookup: false);
+
+            for (int i = 0; i < methods.Count; i++)
+            {
+                MethodInfo candidate = methods[i];
+                if (candidate.HasSameMetadataDefinitionAs(methodInfo))
+                {
+                    return candidate;
+                }
+            }
+
+            return null;
+        }
+
+        private static MemberInfo? GetConstructorWithSameMetadataDefinitionAs(RuntimeType runtimeType, MemberInfo constructorInfo)
+        {
+            ListBuilder<ConstructorInfo> ctors = runtimeType.GetConstructorCandidates(null, GetMemberWithSameMetadataDefinitionAsBindingFlags, CallingConventions.Any, null, allowPrefixLookup: false);
+
+            for (int i = 0; i < ctors.Count; i++)
+            {
+                ConstructorInfo candidate = ctors[i];
+                if (candidate.HasSameMetadataDefinitionAs(constructorInfo))
+                {
+                    return candidate;
+                }
+            }
+
+            return null;
+        }
+
+        private static MemberInfo? GetPropertyWithSameMetadataDefinitionAs(RuntimeType runtimeType, MemberInfo propertyInfo)
+        {
+            ListBuilder<PropertyInfo> properties = runtimeType.GetPropertyCandidates(propertyInfo.Name, GetMemberWithSameMetadataDefinitionAsBindingFlags, null, allowPrefixLookup: false);
+
+            for (int i = 0; i < properties.Count; i++)
+            {
+                PropertyInfo candidate = properties[i];
+                if (candidate.HasSameMetadataDefinitionAs(propertyInfo))
+                {
+                    return candidate;
+                }
+            }
+
+            return null;
+        }
+
+        private static MemberInfo? GetFieldWithSameMetadataDefinitionAs(RuntimeType runtimeType, MemberInfo fieldInfo)
+        {
+            ListBuilder<FieldInfo> fields = runtimeType.GetFieldCandidates(fieldInfo.Name, GetMemberWithSameMetadataDefinitionAsBindingFlags, allowPrefixLookup: false);
+
+            for (int i = 0; i < fields.Count; i++)
+            {
+                FieldInfo candidate = fields[i];
+                if (candidate.HasSameMetadataDefinitionAs(fieldInfo))
+                {
+                    return candidate;
+                }
+            }
+
+            return null;
+        }
+
+        private static MemberInfo? GetEventWithSameMetadataDefinitionAs(RuntimeType runtimeType, MemberInfo eventInfo)
+        {
+            ListBuilder<EventInfo> events = runtimeType.GetEventCandidates(null, GetMemberWithSameMetadataDefinitionAsBindingFlags, allowPrefixLookup: false);
+
+            for (int i = 0; i < events.Count; i++)
+            {
+                EventInfo candidate = events[i];
+                if (candidate.HasSameMetadataDefinitionAs(eventInfo))
+                {
+                    return candidate;
+                }
+            }
+
+            return null;
+        }
+
+        private static MemberInfo? GetNestedTypeWithSameMetadataDefinitionAs(RuntimeType runtimeType, MemberInfo nestedType)
+        {
+            ListBuilder<Type> nestedTypes = runtimeType.GetNestedTypeCandidates(nestedType.Name, GetMemberWithSameMetadataDefinitionAsBindingFlags, allowPrefixLookup: false);
+
+            for (int i = 0; i < nestedTypes.Count; i++)
+            {
+                Type candidate = nestedTypes[i];
+                if (candidate.HasSameMetadataDefinitionAs(nestedType))
+                {
+                    return candidate;
+                }
+            }
+
+            return null;
+        }
+        #endregion
 
         #region Hierarchy
 
diff --git a/src/mono/System.Private.CoreLib/src/System/Threading/ThreadPool.Browser.Mono.cs b/src/mono/System.Private.CoreLib/src/System/Threading/ThreadPool.Browser.Mono.cs
index df6112fa3696c3..9cfc8c91999b52 100644
--- a/src/mono/System.Private.CoreLib/src/System/Threading/ThreadPool.Browser.Mono.cs
+++ b/src/mono/System.Private.CoreLib/src/System/Threading/ThreadPool.Browser.Mono.cs
@@ -90,6 +90,12 @@ internal static bool NotifyWorkItemComplete(object? threadLocalCompletionCountOb
             return true;
         }
 
+        internal static bool NotifyThreadBlocked() => false;
+
+        internal static void NotifyThreadUnblocked()
+        {
+        }
+
         internal static object? GetOrCreateThreadLocalCompletionCountObject() => null;
 
         private static RegisteredWaitHandle RegisterWaitForSingleObject(
diff --git a/src/mono/System.Private.CoreLib/src/System/Type.Mono.cs b/src/mono/System.Private.CoreLib/src/System/Type.Mono.cs
index 7fa48ecb8eaf32..41791273e4293d 100644
--- a/src/mono/System.Private.CoreLib/src/System/Type.Mono.cs
+++ b/src/mono/System.Private.CoreLib/src/System/Type.Mono.cs
@@ -135,7 +135,22 @@ internal virtual FieldInfo GetField(FieldInfo fromNoninstanciated)
         private static extern Type internal_from_handle(IntPtr handle);
 
         [Intrinsic]
-        public static bool operator ==(Type? left, Type? right) => left == right;
+        public static bool operator ==(Type? left, Type? right)
+        {
+            if (object.ReferenceEquals(left, right))
+                return true;
+
+            if (left is null || right is null)
+                return false;
+
+            // CLR-compat: runtime types are never equal to non-runtime types
+            // If `left` is a non-runtime type with a weird Equals implementation
+            // this is where operator `==` would differ from `Equals` call.
+            if (left.IsRuntimeImplemented() || right.IsRuntimeImplemented())
+                return false;
+
+            return left.Equals(right);
+        }
 
         public static bool operator !=(Type? left, Type? right)
         {
diff --git a/src/mono/cmake/config.h.in b/src/mono/cmake/config.h.in
index d49cbd3b9a9d53..4a76a42e1461dd 100644
--- a/src/mono/cmake/config.h.in
+++ b/src/mono/cmake/config.h.in
@@ -1070,9 +1070,6 @@
 /* Enable runtime checks of mempool references between metadata images (must set env var MONO_CHECK_MODE=metadata) */
 #cmakedefine ENABLE_CHECKED_BUILD_METADATA 1
 
-/* Enable runtime support for metadata updates */
-#cmakedefine ENABLE_METADATA_UPDATE 1
-
 /* Enable static linking of mono runtime components */
 #cmakedefine STATIC_COMPONENTS
 
diff --git a/src/mono/cmake/options.cmake b/src/mono/cmake/options.cmake
index cc0078b2385d25..fa5a2fee8797f1 100644
--- a/src/mono/cmake/options.cmake
+++ b/src/mono/cmake/options.cmake
@@ -53,7 +53,6 @@ option (ENABLE_CHECKED_BUILD_PRIVATE_TYPES "Enable compile time checking that ge
 option (ENABLE_CHECKED_BUILD_GC "Enable runtime GC Safe / Unsafe mode assertion checks (must set env var MONO_CHECK_MODE=gc)")
 option (ENABLE_CHECKED_BUILD_THREAD "Enable runtime history of per-thread coop state transitions (must set env var MONO_CHECK_MODE=thread)")
 option (ENABLE_CHECKED_BUILD_METADATA "Enable runtime checks of mempool references between metadata images (must set env var MONO_CHECK_MODE=metadata)")
-option (ENABLE_METADATA_UPDATE "Enable runtime support for metadata updates")
 option (ENABLE_MSCORDBI "Generate mscordbi to support icordbg interface")
 option (STATIC_COMPONENTS "Compile mono runtime components as static (not dynamic) libraries")
 
@@ -63,4 +62,3 @@ set (ENABLE_MINIMAL "" CACHE STRING "Set many DISABLE_ options at once. Comma-se
 set (AOT_TARGET_TRIPLE "" CACHE STRING "Target triple for AOT cross compiler")
 set (AOT_OFFSETS_FILE "" CACHE STRING "Offsets file for AOT cross compiler")
 set (LLVM_PREFIX "" CACHE STRING "Enable LLVM support with LLVM installed at <LLVM_PREFIX>.")
-
diff --git a/src/mono/mono.proj b/src/mono/mono.proj
index d506e6a692ebe6..e5d4bb2970aa33 100644
--- a/src/mono/mono.proj
+++ b/src/mono/mono.proj
@@ -8,7 +8,6 @@
       - MonoAOTEnableLLVM - enable LLVM for an AOT-only Mono
       - MonoAOTLLVMDir - [optional] the directory where LLVM is located, for an AOT-only Mono
       - MonoVerboseBuild - enable verbose build
-      - MonoMetadataUpdate - enable experimental method body replacement code (in Directory.Build.props)
       - MonoThreadSuspend - coop,hybrid,preemptive - default thread suspend mode
   -->
 
@@ -76,6 +75,8 @@
     <MonoComponentsStatic Condition="'$(TargetsBrowser)' == 'true' and '$(MonoComponentsStatic)' == ''">true</MonoComponentsStatic>
     <MonoComponentsStatic Condition="'$(TargetsiOS)' == 'true' and '$(TargetsiOSSimulator)' != 'true' and '$(MonoComponentsStatic)' == ''">true</MonoComponentsStatic>
     <MonoComponentsStatic Condition="'$(TargetstvOS)' == 'true' and '$(TargetstvOSSimulator)' != 'true' and '$(MonoComponentsStatic)' == ''">true</MonoComponentsStatic>
+    <MonoComponentsStatic Condition="'$(TargetsiOS)' == 'true' and '$(TargetsiOSSimulator)' == 'true' and '$(MonoComponentsStatic)' == ''">false</MonoComponentsStatic>
+    <MonoComponentsStatic Condition="'$(TargetstvOS)' == 'true' and '$(TargetstvOSSimulator)' == 'true' and '$(MonoComponentsStatic)' == ''">false</MonoComponentsStatic>
     <MonoComponentsStatic Condition="'$(TargetsAndroid)' == 'true' and '$(MonoComponentsStatic)' == ''">false</MonoComponentsStatic>
     <!-- by default, do dynamic components -->
     <!-- TODO: Change to dynamic as default once package/deploy is fixed for all targets -->
@@ -412,10 +413,6 @@
     </ItemGroup>
 
     <!-- Devloop features -->
-    <ItemGroup Condition="'$(MonoMetadataUpdate)' == 'true'">
-      <_MonoCMakeArgs Include="-DENABLE_METADATA_UPDATE=1" />
-    </ItemGroup>
-
     <ItemGroup Condition="'$(MonoMsCorDbi)' == 'true'">
       <_MonoCMakeArgs Include="-DENABLE_MSCORDBI=1" />
     </ItemGroup>
@@ -423,7 +420,7 @@
     <ItemGroup Condition="'$(TargetsiOS)' == 'true' or '$(TargetstvOS)' == 'true'">
       <_MonoCMakeArgs Include="-DFEATURE_PERFTRACING_PAL_TCP=1"/>
       <_MonoCMakeArgs Include="-DFEATURE_PERFTRACING_DISABLE_DEFAULT_LISTEN_PORT=1"/>
-      <_MonoCMakeArgs Include="-DDISABLE_LINK_STATIC_COMPONENTS=1" />
+      <_MonoCMakeArgs Include="-DDISABLE_LINK_STATIC_COMPONENTS=1" Condition="!('$(TargetsiOSSimulator)' == 'true' or '$(TargetstvOSSimulator)' == 'true')"/>
     </ItemGroup>
 
     <ItemGroup Condition="'$(TargetsAndroid)' == 'true'">
@@ -481,6 +478,41 @@
     <!-- build -->
     <Message Condition="'$(BuildMonoAOTCrossCompilerOnly)' != 'true'" Text="Running '$(_MonoCMakeBuildCommand)' in '$(MonoObjDir)'" Importance="High"/>
     <Exec Condition="'$(BuildMonoAOTCrossCompilerOnly)' != 'true'" Command="$(_MonoCMakeBuildCommand)" IgnoreStandardErrorWarningFormat="true" WorkingDirectory="$(MonoObjDir)"/>
+
+    <!-- strip -->
+    <PropertyGroup>
+      <MonoToolchainPrebuiltOS Condition="$([MSBuild]::IsOSPlatform('Linux'))">linux-x86_64</MonoToolchainPrebuiltOS>
+      <MonoToolchainPrebuiltOS Condition="$([MSBuild]::IsOSPlatform('OSX'))">darwin-x86_64</MonoToolchainPrebuiltOS>
+      <MonoToolchainPrebuiltOS Condition="'$(OS)' == 'Windows_NT'">windows-x86_64</MonoToolchainPrebuiltOS>
+      <_MonoRuntimeFilePath>$(MonoObjDir)out\lib\$(MonoFileName)</_MonoRuntimeFilePath>
+      <_LinuxAbi Condition="'$(TargetsAndroid)' != 'true'">gnu</_LinuxAbi>
+      <_LinuxAbi Condition="'$(TargetsAndroid)' == 'true'">android</_LinuxAbi>
+      <_LinuxFloatAbi Condition="'$(TargetsAndroid)' != 'true'">hf</_LinuxFloatAbi>
+      <_Objcopy>objcopy</_Objcopy>
+      <_Objcopy Condition="'$(Platform)' == 'arm'">arm-linux-$(_LinuxAbi)eabi$(_LinuxFloatAbi)-$(_Objcopy)</_Objcopy>
+      <_Objcopy Condition="'$(Platform)' == 'arm64'">aarch64-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>
+    </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">
+      <Output TaskParameter="ExitCode" PropertyName="_ObjcopyFound"/>
+    </Exec>
+    <PropertyGroup>
+      <!-- if all else fails in finding a valid objcopy, fall back to no-prefix from $PATH (used for x64 on CentOS) -->
+      <_Objcopy Condition="'$(_ObjcopyFound)' != '0'">objcopy</_Objcopy>
+    </PropertyGroup>
+    <ItemGroup>
+      <FilesToStrip Include="$(_MonoRuntimeFilePath)" />
+      <FilesToStrip Include="$([System.IO.Directory]::GetParent($(_MonoRuntimeFilePath)))\libmono-component-*$(SharedLibExt)" />
+    </ItemGroup>
+    <Message Condition="'$(BuildMonoAOTCrossCompilerOnly)' != 'true' and ($([MSBuild]::IsOSPlatform('OSX')) or $([MSBuild]::IsOSPlatform('Linux')))" Text="Stripping debug symbols from %(FilesToStrip.Identity)" Importance="High"/>
+    <Exec Condition="!$([System.String]::Copy(%(FilesToStrip.Identity)).EndsWith('.a')) and '$(BuildMonoAOTCrossCompilerOnly)' != 'true' and ('$(TargetsOSX)' == 'true' or '$(TargetsMacCatalyst)' == 'true' or '$(TargetsiOS)' == 'true' or '$(TargetstvOS)' == 'true')" Command="dsymutil --flat --minimize %(FilesToStrip.Identity)" IgnoreStandardErrorWarningFormat="true" WorkingDirectory="$(MonoObjDir)"/>
+    <Exec Condition="!$([System.String]::Copy(%(FilesToStrip.Identity)).EndsWith('.a')) and '$(BuildMonoAOTCrossCompilerOnly)' != 'true' and ('$(TargetsOSX)' == 'true' or '$(TargetsMacCatalyst)' == 'true' or '$(TargetsiOS)' == 'true' or '$(TargetstvOS)' == 'true')" Command="strip -no_code_signature_warning -S %(FilesToStrip.Identity)" IgnoreStandardErrorWarningFormat="true" WorkingDirectory="$(MonoObjDir)"/>
+    <Exec Condition="!$([System.String]::Copy(%(FilesToStrip.Identity)).EndsWith('.a')) and '$(BuildMonoAOTCrossCompilerOnly)' != 'true' and ('$(TargetsLinux)' == 'true' or '$(TargetsAndroid)' == 'true')" Command="$(_Objcopy) --only-keep-debug %(FilesToStrip.Identity) %(FilesToStrip.Identity).dbg" IgnoreStandardErrorWarningFormat="true" WorkingDirectory="$(MonoObjDir)"/>
+    <Exec Condition="!$([System.String]::Copy(%(FilesToStrip.Identity)).EndsWith('.a')) and '$(BuildMonoAOTCrossCompilerOnly)' != 'true' and ('$(TargetsLinux)' == 'true' or '$(TargetsAndroid)' == 'true')" Command="$(_Objcopy) --strip-unneeded %(FilesToStrip.Identity)" IgnoreStandardErrorWarningFormat="true" WorkingDirectory="$(MonoObjDir)"/>
+    <Exec Condition="!$([System.String]::Copy(%(FilesToStrip.Identity)).EndsWith('.a')) and '$(BuildMonoAOTCrossCompilerOnly)' != 'true' and ('$(TargetsLinux)' == 'true' or '$(TargetsAndroid)' == 'true')" Command="$(_Objcopy) --add-gnu-debuglink=%(FilesToStrip.Identity).dbg %(FilesToStrip.Identity)" IgnoreStandardErrorWarningFormat="true" WorkingDirectory="$(MonoObjDir)"/>
   </Target>
 
   <!-- Build AOT cross compiler (if available) -->
@@ -620,9 +652,6 @@
       <MonoAOTCMakeArgs Condition="'$(MonoAOTEnableLLVM)' == 'true'" Include="-DLLVM_PREFIX=$(MonoAOTLLVMDir.TrimEnd('\/'))" />
       <MonoAOTCMakeArgs Include="$(_MonoAOTCFLAGSOption)" />
       <MonoAOTCMakeArgs Include="$(_MonoAOTCXXFLAGSOption)" />
-      <!-- Devloop features -->
-      <MonoAOTCMakeArgs Condition="'$(MonoMetadataUpdate)' == 'true'" Include="-DENABLE_METADATA_UPDATE=1" />
-
       <!-- thread suspend -->
       <MonoAOTCMakeArgs Include="-DGC_SUSPEND=$(MonoThreadSuspend)" />
     </ItemGroup>
@@ -705,9 +734,17 @@
     <ItemGroup>
       <_MonoRuntimeComponentsStaticFilePath Include="$([System.IO.Directory]::GetParent($(_MonoRuntimeFilePath)))\libmono-component-*$(StaticLibExt)" Condition="Exists($(_MonoRuntimeFilePath))" />
       <_MonoRuntimeComponentsSharedFilePath Include="$([System.IO.Directory]::GetParent($(_MonoRuntimeFilePath)))\libmono-component-*$(SharedLibExt)" Condition="Exists($(_MonoRuntimeFilePath))" />
+      <_MonoRuntimeComponentsSharedFilePath Include="$([System.IO.Directory]::GetParent($(_MonoRuntimeFilePath)))\libmono-component-*$(SharedLibExt).dwarf" Condition="Exists('$(_MonoRuntimeFilePath).dwarf')" />
+      <_MonoRuntimeComponentsSharedFilePath Include="$([System.IO.Directory]::GetParent($(_MonoRuntimeFilePath)))\libmono-component-*$(SharedLibExt).dbg" Condition="Exists('$(_MonoRuntimeFilePath).dbg')" />
       <_MonoRuntimeArtifacts Include="$(_MonoRuntimeFilePath)" Condition="Exists($(_MonoRuntimeFilePath))">
         <Destination>$(RuntimeBinDir)$(MonoFileName)</Destination>
       </_MonoRuntimeArtifacts>
+      <_MonoRuntimeArtifacts Include="$(_MonoRuntimeFilePath).dbg" Condition="Exists('$(_MonoRuntimeFilePath).dbg')">
+        <Destination>$(RuntimeBinDir)$(MonoFileName).dbg</Destination>
+      </_MonoRuntimeArtifacts>
+      <_MonoRuntimeArtifacts Include="$(_MonoRuntimeFilePath).dwarf" Condition="Exists('$(_MonoRuntimeFilePath).dwarf')">
+        <Destination>$(RuntimeBinDir)$(MonoFileName).dwarf</Destination>
+      </_MonoRuntimeArtifacts>
       <_MonoRuntimeArtifacts Include="$(_MonoRuntimeStaticFilePath)" Condition="Exists($(_MonoRuntimeStaticFilePath)) and '$(_MonoRuntimeStaticFilePath)' != '$(_MonoRuntimeFilePath)'">
         <Destination>$(RuntimeBinDir)$(MonoStaticLibFileName)</Destination>
       </_MonoRuntimeArtifacts>
diff --git a/src/mono/mono/cil/make-opcodes-def.pl b/src/mono/mono/cil/make-opcodes-def.pl
index 521b486fb43941..8835e6573267fc 100644
--- a/src/mono/mono/cil/make-opcodes-def.pl
+++ b/src/mono/mono/cil/make-opcodes-def.pl
@@ -79,6 +79,11 @@ sub print_trailer {
 OPALIAS(CEE_LDX_I4_MIX, "ldc.i4.M1", CEE_LDC_I4_M1)
 OPALIAS(CEE_ENDFAULT,   "endfault",  CEE_ENDFINALLY)
 
+/* Arguments to CEE_NO_ */
+#define CEE_NO_TYPECHECK 0x1
+#define CEE_NO_RANGECHECK 0x2
+#define CEE_NO_NULLCHECK 0x4
+
 #ifdef _MONO_CIL_OPALIAS_DEFINED_
 #undef OPALIAS
 #undef _MONO_CIL_OPALIAS_DEFINED_
diff --git a/src/mono/mono/cil/opcode.def b/src/mono/mono/cil/opcode.def
index a39b315bac5e9b..4b0769de95ebbb 100644
--- a/src/mono/mono/cil/opcode.def
+++ b/src/mono/mono/cil/opcode.def
@@ -343,6 +343,11 @@ OPALIAS(CEE_LDELEM_U8,  "ldelem.u8", CEE_LDELEM_I8)
 OPALIAS(CEE_LDX_I4_MIX, "ldc.i4.M1", CEE_LDC_I4_M1)
 OPALIAS(CEE_ENDFAULT,   "endfault",  CEE_ENDFINALLY)
 
+/* Arguments to CEE_NO_ */
+#define CEE_NO_TYPECHECK 0x1
+#define CEE_NO_RANGECHECK 0x2
+#define CEE_NO_NULLCHECK 0x4
+
 #ifdef _MONO_CIL_OPALIAS_DEFINED_
 #undef OPALIAS
 #undef _MONO_CIL_OPALIAS_DEFINED_
diff --git a/src/mono/mono/component/event_pipe.c b/src/mono/mono/component/event_pipe.c
index f3472be204e3d6..6ed6171875a03f 100644
--- a/src/mono/mono/component/event_pipe.c
+++ b/src/mono/mono/component/event_pipe.c
@@ -156,7 +156,8 @@ event_pipe_enable (
 		format,
 		rundown_requested,
 		stream,
-		sync_callback);
+		sync_callback,
+        NULL);
 
 	if (config_providers) {
 		for (int i = 0; i < providers_len; ++i) {
diff --git a/src/mono/mono/component/hot_reload-stub.c b/src/mono/mono/component/hot_reload-stub.c
index 0921a718347eae..718ce3e453a10b 100644
--- a/src/mono/mono/component/hot_reload-stub.c
+++ b/src/mono/mono/component/hot_reload-stub.c
@@ -7,6 +7,7 @@
 #include "mono/component/component.h"
 #include "mono/component/hot_reload.h"
 #include "mono/metadata/components.h"
+#include "mono/metadata/metadata-update.h"
 #include "mono/utils/mono-compiler.h"
 #include "mono/utils/mono-error-internals.h"
 
@@ -19,9 +20,61 @@ hot_reload_stub_apply_changes (MonoImage *base_image, gconstpointer dmeta, uint3
 static MonoComponentHotReload *
 component_hot_reload_stub_init (void);
 
+static void
+hot_reload_stub_set_fastpath_data (MonoMetadataUpdateData *ptr);
+
+static gboolean
+hot_reload_stub_update_enabled (int *modifiable_assemblies_out);
+
+static gboolean
+hot_reload_stub_no_inline (MonoMethod *caller, MonoMethod *callee);
+
+static uint32_t
+hot_reload_stub_thread_expose_published (void);
+
+static uint32_t
+hot_reload_stub_get_thread_generation (void);
+
+static void
+hot_reload_stub_cleanup_on_close (MonoImage *image);
+
+static void
+hot_reload_stub_effective_table_slow (const MonoTableInfo **t, int *idx);
+
+static int
+hot_reload_stub_relative_delta_index (MonoImage *image_dmeta, int token);
+
+static void
+hot_reload_stub_close_except_pools_all (MonoImage *base_image);
+
+static void
+hot_reload_stub_close_all (MonoImage *base_image);
+
+static gpointer
+hot_reload_stub_get_updated_method_rva (MonoImage *base_image, uint32_t idx);
+
+static gboolean
+hot_reload_stub_table_bounds_check (MonoImage *base_image, int table_index, int token_index);
+
+static gboolean
+hot_reload_stub_delta_heap_lookup (MonoImage *base_image, MetadataHeapGetterFunc get_heap, uint32_t orig_index, MonoImage **image_out, uint32_t *index_out);
+
 static MonoComponentHotReload fn_table = {
 	{ MONO_COMPONENT_ITF_VERSION, &hot_reload_stub_available },
+	&hot_reload_stub_set_fastpath_data,
+	&hot_reload_stub_update_enabled,
+	&hot_reload_stub_no_inline,
+	&hot_reload_stub_thread_expose_published,
+	&hot_reload_stub_get_thread_generation,
+	&hot_reload_stub_cleanup_on_close,
+	&hot_reload_stub_effective_table_slow,
+	&hot_reload_stub_relative_delta_index,
 	&hot_reload_stub_apply_changes,
+	&hot_reload_stub_close_except_pools_all,
+	&hot_reload_stub_close_all,
+	&hot_reload_stub_get_updated_method_rva,
+	&hot_reload_stub_table_bounds_check,
+	&hot_reload_stub_delta_heap_lookup,
 };
 
 static bool
@@ -30,16 +83,93 @@ hot_reload_stub_available (void)
 	return false;
 }
 
-static void
+static MonoComponentHotReload *
+component_hot_reload_stub_init (void)
+{
+	return &fn_table;
+}
+
+void
+hot_reload_stub_set_fastpath_data (MonoMetadataUpdateData *ptr)
+{
+}
+
+gboolean
+hot_reload_stub_update_enabled (int *modifiable_assemblies_out)
+{
+	if (modifiable_assemblies_out)
+		*modifiable_assemblies_out = MONO_MODIFIABLE_ASSM_NONE;
+	return false;
+}
+
+static gboolean
+hot_reload_stub_no_inline (MonoMethod *caller, MonoMethod *callee)
+{
+	return false;
+}
+
+
+static uint32_t
+hot_reload_stub_thread_expose_published (void)
+{
+	return 0;
+}
+
+uint32_t
+hot_reload_stub_get_thread_generation (void)
+{
+	return 0;
+}
+
+void
+hot_reload_stub_cleanup_on_close (MonoImage *image)
+{
+}
+
+void
+hot_reload_stub_effective_table_slow (const MonoTableInfo **t, int *idx)
+{
+	g_assert_not_reached ();
+}
+
+static int
+hot_reload_stub_relative_delta_index (MonoImage *image_dmeta, int token)
+{
+	g_assert_not_reached ();
+}
+
+void
 hot_reload_stub_apply_changes (MonoImage *base_image, gconstpointer dmeta, uint32_t dmeta_len, gconstpointer dil, uint32_t dil_len, MonoError *error)
 {
 	mono_error_set_not_supported (error, "Hot reload not supported in this runtime.");
 }
 
-static MonoComponentHotReload *
-component_hot_reload_stub_init (void)
+static void
+hot_reload_stub_close_except_pools_all (MonoImage *base_image)
 {
-	return &fn_table;
+}
+
+static void
+hot_reload_stub_close_all (MonoImage *base_image)
+{
+}
+
+gpointer
+hot_reload_stub_get_updated_method_rva (MonoImage *base_image, uint32_t idx)
+{
+	g_assert_not_reached ();
+}
+
+gboolean
+hot_reload_stub_table_bounds_check (MonoImage *base_image, int table_index, int token_index)
+{
+	g_assert_not_reached ();
+}
+
+static gboolean
+hot_reload_stub_delta_heap_lookup (MonoImage *base_image, MetadataHeapGetterFunc get_heap, uint32_t orig_index, MonoImage **image_out, uint32_t *index_out)
+{
+	g_assert_not_reached ();
 }
 
 MONO_COMPONENT_EXPORT_ENTRYPOINT
diff --git a/src/mono/mono/component/hot_reload.c b/src/mono/mono/component/hot_reload.c
index 9395a18eae53b3..0997e8f859c232 100644
--- a/src/mono/mono/component/hot_reload.c
+++ b/src/mono/mono/component/hot_reload.c
@@ -5,36 +5,1476 @@
 #include <config.h>
 #include <glib.h>
 
+#include <config.h>
+#include "mono/utils/mono-compiler.h"
+
+#include <glib.h>
+#include "mono/metadata/assembly-internals.h"
+#include "mono/metadata/metadata-internals.h"
+#include "mono/metadata/metadata-update.h"
+#include "mono/metadata/object-internals.h"
+#include "mono/metadata/tokentype.h"
+#include "mono/utils/mono-coop-mutex.h"
+#include "mono/utils/mono-error-internals.h"
+#include "mono/utils/mono-lazy-init.h"
+#include "mono/utils/mono-logger-internals.h"
+#include "mono/utils/mono-path.h"
+
+
 #include <mono/component/hot_reload.h>
 
 #include <mono/utils/mono-compiler.h>
 
+static void
+hot_reload_init (void);
+
 static bool
 hot_reload_available (void);
 
+static void
+hot_reload_set_fastpath_data (MonoMetadataUpdateData *data);
+
+static gboolean
+hot_reload_update_enabled (int *modifiable_assemblies_out);
+
+static gboolean
+hot_reload_no_inline (MonoMethod *caller, MonoMethod *callee);
+
+static uint32_t
+hot_reload_thread_expose_published (void);
+
+static uint32_t
+hot_reload_get_thread_generation (void);
+
+static void
+hot_reload_cleanup_on_close (MonoImage *image);
+
+static void
+hot_reload_effective_table_slow (const MonoTableInfo **t, int *idx);
+
 static void
 hot_reload_apply_changes (MonoImage *base_image, gconstpointer dmeta, uint32_t dmeta_len, gconstpointer dil, uint32_t dil_len, MonoError *error);
 
+static int
+hot_reload_relative_delta_index (MonoImage *image_dmeta, int token);
+
+static void
+hot_reload_close_except_pools_all (MonoImage *base_image);
+
+static void
+hot_reload_close_all (MonoImage *base_image);
+
+static gpointer
+hot_reload_get_updated_method_rva (MonoImage *base_image, uint32_t idx);
+
+static gboolean
+hot_reload_table_bounds_check (MonoImage *base_image, int table_index, int token_index);
+
+static gboolean
+hot_reload_delta_heap_lookup (MonoImage *base_image, MetadataHeapGetterFunc get_heap, uint32_t orig_index, MonoImage **image_out, uint32_t *index_out);
+
 static MonoComponentHotReload fn_table = {
 	{ MONO_COMPONENT_ITF_VERSION, &hot_reload_available },
+	&hot_reload_set_fastpath_data,
+	&hot_reload_update_enabled,
+	&hot_reload_no_inline,
+	&hot_reload_thread_expose_published,
+	&hot_reload_get_thread_generation,
+	&hot_reload_cleanup_on_close,
+	&hot_reload_effective_table_slow,
+	&hot_reload_relative_delta_index,
 	&hot_reload_apply_changes,
+	&hot_reload_close_except_pools_all,
+	&hot_reload_close_all,
+	&hot_reload_get_updated_method_rva,
+	&hot_reload_table_bounds_check,
+	&hot_reload_delta_heap_lookup,
 };
 
+MonoComponentHotReload *
+mono_component_hot_reload_init (void)
+{
+	hot_reload_init ();
+	return &fn_table;
+}
+
 static bool
 hot_reload_available (void)
 {
 	return true;
 }
 
+static MonoMetadataUpdateData* metadata_update_data_ptr;
+
 static void
-hot_reload_apply_changes (MonoImage *base_image, gconstpointer dmeta, uint32_t dmeta_len, gconstpointer dil, uint32_t dil_len, MonoError *error)
+hot_reload_set_fastpath_data (MonoMetadataUpdateData *ptr)
 {
-	/* TODO: implement me */
+	metadata_update_data_ptr = ptr;
 }
 
-MonoComponentHotReload *
-mono_component_hot_reload_init (void)
+/* TLS value is a uint32_t of the latest published generation that the thread can see */
+static MonoNativeTlsKey exposed_generation_id;
+
+#if 1
+#define UPDATE_DEBUG(stmt) do { stmt; } while (0)
+#else
+#define UPDATE_DEBUG(stmt) /*empty */
+#endif
+
+/* For each delta image, for each table:
+ * - the total logical number of rows for the previous generation
+ * - the number of modified rows in the current generation
+ * - the number of inserted rows in the current generation
+ *
+ * In each delta, the physical tables contain the rows that modify existing rows of a prior generation,
+ * followed by inserted rows.
+ * https://github.com/dotnet/runtime/blob/6072e4d3a7a2a1493f514cdf4be75a3d56580e84/src/libraries/System.Reflection.Metadata/src/System/Reflection/Metadata/Ecma335/MetadataAggregator.cs#L324
+ * 
+ * The total logical number of rows in a table for a particular generation is
+ *    prev_gen_rows + inserted_rows.
+ */
+typedef struct _delta_row_count {
+	guint32 prev_gen_rows;
+	guint32 modified_rows;
+	guint32 inserted_rows; 
+} delta_row_count;
+
+/* Additional informaiton for MonoImages representing deltas */
+typedef struct _DeltaInfo {
+	uint32_t generation; /* global update ID that added this delta image */
+
+	/* Maps MethodDef token indices to a pointer into the RVA of the delta IL */
+	GHashTable *method_table_update;
+
+	// for each table, the row in the EncMap table that has the first token for remapping it?
+	uint32_t enc_recs [MONO_TABLE_NUM];
+	delta_row_count count [MONO_TABLE_NUM];
+} DeltaInfo;
+
+
+/* Additional informaiton for baseline MonoImages */
+typedef struct _BaselineInfo {
+	/* List of MonoImages of deltas.  Parent image owns 1 refcount ref of the delta image */
+	GList *delta_image;
+	/* Tail of delta_image for fast appends */
+	GList *delta_image_last;
+
+	/* Maps MethodDef token indices to a boolean flag that there's an update for the method */
+	GHashTable *method_table_update;
+} BaselineInfo;
+
+#define DOTNET_MODIFIABLE_ASSEMBLIES "DOTNET_MODIFIABLE_ASSEMBLIES"
+
+/**
+ * mono_metadata_update_enable:
+ * \param modifiable_assemblies_out: set to MonoModifiableAssemblies value
+ *
+ * Returns \c TRUE if metadata updates are enabled at runtime.	False otherwise.
+ *
+ * If \p modifiable_assemblies_out is not \c NULL, it's set on return.
+ *
+ * The result depends on the value of the DOTNET_MODIFIABLE_ASSEMBLIES
+ * environment variable.  "debug" means debuggable assemblies are modifiable,
+ * all other values are ignored and metadata updates are disabled.
+ */
+gboolean
+hot_reload_update_enabled (int *modifiable_assemblies_out)
 {
-	/* TODO: implement me */
-	return &fn_table;
+	static gboolean inited = FALSE;
+	static int modifiable = MONO_MODIFIABLE_ASSM_NONE;
+
+	if (!inited) {
+		char *val = g_getenv (DOTNET_MODIFIABLE_ASSEMBLIES);
+		if (val && !g_strcasecmp (val, "debug")) {
+			mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "Metadata update enabled for debuggable assemblies");
+			modifiable = MONO_MODIFIABLE_ASSM_DEBUG;
+		}
+		g_free (val);
+		inited = TRUE;
+	}
+	if (modifiable_assemblies_out)
+		*modifiable_assemblies_out = modifiable;
+	return modifiable != MONO_MODIFIABLE_ASSM_NONE;
+}
+
+static gboolean
+assembly_update_supported (MonoAssembly *assm)
+{
+	int modifiable = 0;
+	if (!hot_reload_update_enabled (&modifiable))
+		return FALSE;
+	if (modifiable == MONO_MODIFIABLE_ASSM_DEBUG &&
+	    mono_assembly_is_jit_optimizer_disabled (assm))
+		return TRUE;
+	return FALSE;
+}
+
+/**
+ * hot_reload_update_no_inline:
+ * \param caller: the calling method
+ * \param callee: the method being called
+ *
+ * Returns \c TRUE if \p callee should not be inlined into \p caller.
+ *
+ * If metadata updates are enabled either for the caller or callee's module,
+ * the callee should not be inlined.
+ *
+ */
+gboolean
+hot_reload_no_inline (MonoMethod *caller, MonoMethod *callee)
+{
+	if (!hot_reload_update_enabled (NULL))
+		return FALSE;
+	MonoAssembly *caller_assm = m_class_get_image(caller->klass)->assembly;
+	MonoAssembly *callee_assm = m_class_get_image(callee->klass)->assembly;
+	return mono_assembly_is_jit_optimizer_disabled (caller_assm) || mono_assembly_is_jit_optimizer_disabled (callee_assm);
+}
+
+/* Maps each MonoTableInfo* to the MonoImage that it belongs to.  This is
+ * mapping the base image MonoTableInfos to the base MonoImage.  We don't need
+ * this for deltas.
+ */
+static GHashTable *table_to_image;
+/* Maps each delta MonoImage to its DeltaInfo */
+static GHashTable *delta_image_to_info;
+/* Maps each baseline MonoImage to its BaselineInfo */
+static GHashTable *baseline_image_to_info;
+/* Low-level lock to protects table_to_image and delta_image_to_info */
+/* FIXME: use concurrent hash tables so that readers don't have to lock. */
+static MonoCoopMutex table_to_image_mutex;
+
+static void
+table_to_image_lock (void)
+{
+	mono_coop_mutex_lock (&table_to_image_mutex);
+}
+
+static void
+table_to_image_unlock (void)
+{
+	mono_coop_mutex_unlock (&table_to_image_mutex);
+}
+
+
+static BaselineInfo *
+baseline_info_init (MonoImage *image_base)
+{
+	BaselineInfo *baseline_info = g_malloc0 (sizeof (BaselineInfo));
+
+	return baseline_info;
+}
+
+static void
+baseline_info_destroy (BaselineInfo *info)
+{
+	if (info->method_table_update)
+		g_hash_table_destroy (info->method_table_update);
+	g_free (info);
+}
+
+static BaselineInfo *
+baseline_info_lookup_or_add (MonoImage *base_image)
+{
+	BaselineInfo *info;
+	table_to_image_lock ();
+	info = g_hash_table_lookup (baseline_image_to_info, base_image);
+	if (!info) {
+		info = baseline_info_init (base_image);
+		g_hash_table_insert (baseline_image_to_info, base_image, info);
+	}
+	table_to_image_unlock ();
+	return info;
+}
+
+static void
+baseline_info_remove (MonoImage *base_image)
+{
+	table_to_image_lock ();
+	g_hash_table_remove (baseline_image_to_info, base_image);
+	table_to_image_unlock ();
+}
+
+static BaselineInfo *
+baseline_info_lookup (MonoImage *base_image)
+{
+	BaselineInfo *info;
+	table_to_image_lock ();
+	info = g_hash_table_lookup (baseline_image_to_info, base_image);
+	table_to_image_unlock ();
+	return info;
+}
+
+static DeltaInfo*
+delta_info_init (MonoImage *image_dmeta, MonoImage *image_base, BaselineInfo *base_info, uint32_t generation);
+
+static void
+delta_info_destroy (DeltaInfo *dinfo)
+{
+	if (dinfo->method_table_update)
+		g_hash_table_destroy (dinfo->method_table_update);
+	g_free (dinfo);
+}
+
+static DeltaInfo *
+delta_info_lookup_locked (MonoImage *delta_image)
+{
+	return (DeltaInfo*)g_hash_table_lookup (delta_image_to_info, delta_image);
+}
+
+static DeltaInfo *
+delta_info_lookup (MonoImage *delta_image)
+{
+	DeltaInfo *result;
+	table_to_image_lock ();
+	result = delta_info_lookup_locked (delta_image);
+	table_to_image_unlock ();
+	return result;
+}
+
+static void
+table_to_image_init (void)
+{
+	mono_coop_mutex_init (&table_to_image_mutex);
+	table_to_image = g_hash_table_new (NULL, NULL);
+	delta_image_to_info = g_hash_table_new (NULL, NULL);
+	baseline_image_to_info = g_hash_table_new (NULL, NULL);
+}
+
+static gboolean
+remove_base_image (gpointer key, gpointer value, gpointer user_data)
+{
+	MonoImage *base_image = (MonoImage*)user_data;
+	MonoImage *value_image = (MonoImage*)value;
+	return (value_image == base_image);
+}
+
+void
+hot_reload_cleanup_on_close (MonoImage *image)
+{
+	table_to_image_lock ();
+	/* remove all keys (delta images) that map to the given image (base image) */
+	g_hash_table_foreach_remove (table_to_image, remove_base_image, (gpointer)image);
+	/* remove delta image info */
+	DeltaInfo *delta_info = delta_info_lookup_locked (image);
+	if (delta_info) {
+		g_hash_table_remove (delta_image_to_info, image);
+		delta_info_destroy (delta_info);
+	}
+	table_to_image_unlock ();
+}
+
+void
+hot_reload_close_except_pools_all (MonoImage *base_image)
+{
+	BaselineInfo *info = baseline_info_lookup (base_image);
+	if (!info)
+		return;
+	for (GList *ptr = info->delta_image; ptr; ptr = ptr->next) {
+		MonoImage *image = (MonoImage *)ptr->data;
+		if (image) {
+			if (!mono_image_close_except_pools (image))
+			    ptr->data = NULL;
+		}
+	}
+}
+
+void
+hot_reload_close_all (MonoImage *base_image)
+{
+	BaselineInfo *info = baseline_info_lookup (base_image);
+	if (!info)
+		return;
+	for (GList *ptr = info->delta_image; ptr; ptr = ptr->next) {
+		MonoImage *image = (MonoImage *)ptr->data;
+		if (image)
+			mono_image_close_finish (image);
+	}
+	g_list_free (info->delta_image);
+	baseline_info_remove (base_image);
+	baseline_info_destroy (info);
+}
+
+static void
+table_to_image_add (MonoImage *base_image)
+{
+	/* If at least one table from this image is already here, they all are */
+	if (g_hash_table_contains (table_to_image, &base_image->tables[MONO_TABLE_MODULE]))
+		return;
+	table_to_image_lock ();
+	if (g_hash_table_contains (table_to_image, &base_image->tables[MONO_TABLE_MODULE])) {
+		table_to_image_unlock ();
+		return;
+	}
+	for (int idx = 0; idx < MONO_TABLE_NUM; ++idx) {
+		MonoTableInfo *table = &base_image->tables[idx];
+		g_hash_table_insert (table_to_image, table, base_image);
+	}
+	table_to_image_unlock ();
+}
+
+static MonoImage *
+table_info_get_base_image (const MonoTableInfo *t)
+{
+	MonoImage *image = (MonoImage *) g_hash_table_lookup (table_to_image, t);
+	return image;
+}
+
+static MonoImage*
+image_open_dmeta_from_data (MonoImage *base_image, uint32_t generation, gconstpointer dmeta_bytes, uint32_t dmeta_length);
+
+static void
+image_append_delta (MonoImage *base, BaselineInfo *base_info, MonoImage *delta, DeltaInfo *delta_info);
+
+static int
+metadata_update_local_generation (MonoImage *base, BaselineInfo *base_info, MonoImage *delta);
+
+void
+hot_reload_init (void)
+{
+	table_to_image_init ();
+	mono_native_tls_alloc (&exposed_generation_id, NULL);
+}
+
+static
+void
+hot_reload_update_published_invoke_hook (MonoAssemblyLoadContext *alc, uint32_t generation)
+{
+	if (mono_get_runtime_callbacks ()->metadata_update_published)
+		mono_get_runtime_callbacks ()->metadata_update_published (alc, generation);
+}
+
+static uint32_t update_published, update_alloc_frontier;
+static MonoCoopMutex publish_mutex;
+
+static void
+publish_lock (void)
+{
+	mono_coop_mutex_lock (&publish_mutex);
+}
+
+static void
+publish_unlock (void)
+{
+	mono_coop_mutex_unlock (&publish_mutex);
+}
+
+static mono_lazy_init_t metadata_update_lazy_init;
+
+static void
+initialize (void)
+{
+	mono_coop_mutex_init (&publish_mutex);
+}
+
+static void
+thread_set_exposed_generation (uint32_t value)
+{
+	mono_native_tls_set_value (exposed_generation_id, GUINT_TO_POINTER((guint)value));
+}
+
+/**
+ * LOCKING: assumes the publish_lock is held
+ */
+static void
+hot_reload_set_has_updates (void)
+{
+	g_assert (metadata_update_data_ptr != NULL);
+	metadata_update_data_ptr->has_updates = 1;
+}
+
+static uint32_t
+hot_reload_update_prepare (void)
+{
+	mono_lazy_initialize (&metadata_update_lazy_init, initialize);
+	/*
+	 * TODO: assert that the updater isn't depending on current metadata, else publishing might block.
+	 */
+	publish_lock ();
+	uint32_t alloc_gen = ++update_alloc_frontier;
+	/* Have to set this here so the updater starts using the slow path of metadata lookups */
+	hot_reload_set_has_updates ();
+	/* Expose the alloc frontier to the updater thread */
+	thread_set_exposed_generation (alloc_gen);
+	return alloc_gen;
+}
+
+static gboolean G_GNUC_UNUSED
+hot_reload_update_available (void)
+{
+	return update_published < update_alloc_frontier;
+}
+
+/**
+ * hot_reaload_thread_expose_published:
+ *
+ * Allow the current thread to see the latest published deltas.
+ *
+ * Returns the current published generation that the thread will see.
+ */
+uint32_t
+hot_reload_thread_expose_published (void)
+{
+	mono_memory_read_barrier ();
+	uint32_t thread_current_gen = update_published;
+	thread_set_exposed_generation (thread_current_gen);
+	return thread_current_gen;
+}
+
+/**
+ * hot_reload_get_thread_generation:
+ *
+ * Return the published generation that the current thread is allowed to see.
+ * May be behind the latest published generation if the thread hasn't called
+ * \c mono_metadata_update_thread_expose_published in a while.
+ */
+uint32_t
+hot_reload_get_thread_generation (void)
+{
+	return (uint32_t)GPOINTER_TO_UINT(mono_native_tls_get_value(exposed_generation_id));
+}
+
+static gboolean G_GNUC_UNUSED
+hot_reload_wait_for_update (uint32_t timeout_ms)
+{
+	/* TODO: give threads a way to voluntarily wait for an update to be published. */
+	g_assert_not_reached ();
+}
+
+static void
+hot_reload_update_publish (MonoAssemblyLoadContext *alc, uint32_t generation)
+{
+	g_assert (update_published < generation && generation <= update_alloc_frontier);
+	/* TODO: wait for all threads that are using old metadata to update. */
+	hot_reload_update_published_invoke_hook (alc, generation);
+	update_published = update_alloc_frontier;
+	mono_memory_write_barrier ();
+	publish_unlock ();
+}
+
+static void
+hot_reload_update_cancel (uint32_t generation)
+{
+	g_assert (update_alloc_frontier == generation);
+	g_assert (update_alloc_frontier > 0);
+	g_assert (update_alloc_frontier - 1 >= update_published);
+	--update_alloc_frontier;
+	/* Roll back exposed generation to the last published one */
+	thread_set_exposed_generation (update_published);
+	publish_unlock ();
+}
+
+/**
+ * LOCKING: Assumes the publish_lock is held
+ */
+void
+image_append_delta (MonoImage *base, BaselineInfo *base_info, MonoImage *delta, DeltaInfo *delta_info)
+{
+	if (!base_info->delta_image) {
+		base_info->delta_image = base_info->delta_image_last = g_list_alloc ();
+		base_info->delta_image->data = (gpointer)delta;
+		mono_memory_write_barrier ();
+		/* Have to set this here so that passes over the metadata in the updater thread start using the slow path */
+		base->has_updates = TRUE;
+		return;
+	}
+	g_assert (delta_info_lookup(((MonoImage*)base_info->delta_image_last->data))->generation < delta_info->generation);
+	/* g_list_append returns the given list, not the newly appended */
+	GList *l = g_list_append (base_info->delta_image_last, delta);
+	g_assert (l != NULL && l->next != NULL && l->next->next == NULL);
+	base_info->delta_image_last = l->next;
+
+	mono_memory_write_barrier ();
+	/* Have to set this here so that passes over the metadata in the updater thread start using the slow path */
+	base->has_updates = TRUE;
+
+}
+
+/**
+ * LOCKING: assumes the publish_lock is held
+ */
+MonoImage*
+image_open_dmeta_from_data (MonoImage *base_image, uint32_t generation, gconstpointer dmeta_bytes, uint32_t dmeta_length)
+{
+	MonoImageOpenStatus status;
+	MonoAssemblyLoadContext *alc = mono_image_get_alc (base_image);
+	MonoImage *dmeta_image = mono_image_open_from_data_internal (alc, (char*)dmeta_bytes, dmeta_length, TRUE, &status, TRUE, NULL, NULL);
+	g_assert (dmeta_image != NULL);
+	g_assert (status == MONO_IMAGE_OK);
+
+	return dmeta_image;
+}
+
+static gpointer
+open_dil_data (MonoImage *base_image G_GNUC_UNUSED, gconstpointer dil_src, uint32_t dil_length)
+{
+	/* TODO: find a better memory manager.	But this way we at least won't lose the IL data. */
+	MonoMemoryManager *mem_manager = (MonoMemoryManager *)mono_alc_get_default ()->memory_manager;
+
+	gpointer dil_copy = mono_mem_manager_alloc (mem_manager, dil_length);
+	memcpy (dil_copy, dil_src, dil_length);
+	return dil_copy;
+}
+
+static const char *
+scope_to_string (uint32_t tok)
+{
+	const char *scope;
+	switch (tok & MONO_RESOLUTION_SCOPE_MASK) {
+	case MONO_RESOLUTION_SCOPE_MODULE:
+		scope = ".";
+		break;
+	case MONO_RESOLUTION_SCOPE_MODULEREF:
+		scope = "M";
+		break;
+	case MONO_RESOLUTION_SCOPE_TYPEREF:
+		scope = "T";
+		break;
+	case MONO_RESOLUTION_SCOPE_ASSEMBLYREF:
+		scope = "A";
+		break;
+	default:
+		g_assert_not_reached ();
+	}
+	return scope;
+}
+
+static void
+dump_update_summary (MonoImage *image_base, MonoImage *image_dmeta)
+{
+	int rows;
+
+	mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "dmeta tables:");
+	for (int idx = 0; idx < MONO_TABLE_NUM; ++idx) {
+		if (image_dmeta->tables [idx].base)
+			mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "\t0x%02x \"%s\"", idx, mono_meta_table_name (idx));
+	}
+	mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "================================");
+
+	rows = mono_image_get_table_rows (image_base, MONO_TABLE_TYPEREF);
+	for (int i = 1; i <= rows; ++i) {
+		guint32 cols [MONO_TYPEREF_SIZE];
+		mono_metadata_decode_row (&image_base->tables [MONO_TABLE_TYPEREF], i - 1, cols, MONO_TYPEREF_SIZE);
+		const char *scope = scope_to_string (cols [MONO_TYPEREF_SCOPE]);
+		const char *name = mono_metadata_string_heap (image_base, cols [MONO_TYPEREF_NAME]);
+		const char *nspace = mono_metadata_string_heap (image_base, cols [MONO_TYPEREF_NAMESPACE]);
+
+		if (!name)
+			name = "<N/A>";
+		if (!nspace)
+			nspace = "<N/A>";
+
+		mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "base  typeref i=%d (token=0x%08x) -> scope=%s, namespace=%s, name=%s", i, MONO_TOKEN_TYPE_REF | i, scope, nspace, name);
+	}
+	if (!image_dmeta->minimal_delta) {
+		mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "--------------------------------");
+
+		rows = mono_image_get_table_rows (image_dmeta, MONO_TABLE_TYPEREF);
+		for (int i = 1; i <= rows; ++i) {
+			guint32 cols [MONO_TYPEREF_SIZE];
+			mono_metadata_decode_row (&image_dmeta->tables [MONO_TABLE_TYPEREF], i - 1, cols, MONO_TYPEREF_SIZE);
+			const char *scope = scope_to_string (cols [MONO_TYPEREF_SCOPE]);
+			const char *name = mono_metadata_string_heap (image_base, cols [MONO_TYPEREF_NAME]);
+			const char *nspace = mono_metadata_string_heap (image_base, cols [MONO_TYPEREF_NAMESPACE]);
+			mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "dmeta typeref i=%d (token=0x%08x) -> scope=%s, nspace=%s, name=%s", i, MONO_TOKEN_TYPE_REF | i, scope, nspace, name);
+		}
+	}
+	mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "================================");
+
+	rows = mono_image_get_table_rows (image_base, MONO_TABLE_METHOD);
+	for (int i = 1; i <= rows ; ++i) {
+		guint32 cols [MONO_METHOD_SIZE];
+		mono_metadata_decode_row_raw (&image_base->tables [MONO_TABLE_METHOD], i - 1, cols, MONO_METHOD_SIZE);
+		const char *name = mono_metadata_string_heap (image_base, cols [MONO_METHOD_NAME]);
+		guint32 rva = cols [MONO_METHOD_RVA];
+		mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "base  method i=%d (token=0x%08x), rva=%d/0x%04x, name=%s", i, MONO_TOKEN_METHOD_DEF | i, rva, rva, name);
+	}
+	mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "--------------------------------");
+
+	rows = mono_image_get_table_rows (image_dmeta, MONO_TABLE_METHOD);
+	for (int i = 1; i <= rows ; ++i) {
+		guint32 cols [MONO_METHOD_SIZE];
+		mono_metadata_decode_row_raw (&image_dmeta->tables [MONO_TABLE_METHOD], i - 1, cols, MONO_METHOD_SIZE);
+		const char *name = mono_metadata_string_heap (image_base, cols [MONO_METHOD_NAME]);
+		guint32 rva = cols [MONO_METHOD_RVA];
+		mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "dmeta method i=%d (token=0x%08x), rva=%d/0x%04x, name=%s", i, MONO_TOKEN_METHOD_DEF | i, rva, rva, name);
+	}
+	mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "================================");
+
+	rows = mono_image_get_table_rows (image_base, MONO_TABLE_STANDALONESIG);
+	for (int i = 1; i <= rows; ++i) {
+		guint32 cols [MONO_STAND_ALONE_SIGNATURE_SIZE];
+		mono_metadata_decode_row (&image_base->tables [MONO_TABLE_STANDALONESIG], i - 1, cols, MONO_STAND_ALONE_SIGNATURE_SIZE);
+		mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "base  standalonesig i=%d (token=0x%08x) -> 0x%08x", i, MONO_TOKEN_SIGNATURE | i, cols [MONO_STAND_ALONE_SIGNATURE]);
+	}
+
+	if (!image_dmeta->minimal_delta) {
+		mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "--------------------------------");
+
+		rows = mono_image_get_table_rows (image_dmeta, MONO_TABLE_STANDALONESIG);
+		for (int i = 1; i <= rows; ++i) {
+			guint32 cols [MONO_STAND_ALONE_SIGNATURE_SIZE];
+			mono_metadata_decode_row_raw (&image_dmeta->tables [MONO_TABLE_STANDALONESIG], i - 1, cols, MONO_STAND_ALONE_SIGNATURE_SIZE);
+			mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "dmeta standalonesig i=%d (token=0x%08x) -> 0x%08x", i, MONO_TOKEN_SIGNATURE | i, cols [MONO_STAND_ALONE_SIGNATURE]);
+		}
+	}
+	mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "================================");
+
+}
+
+void
+hot_reload_effective_table_slow (const MonoTableInfo **t, int *idx)
+{
+	if (G_LIKELY (*idx < table_info_get_rows (*t)))
+		return;
+
+	/* FIXME: don't let any thread other than the updater thread see values from a delta image
+	 * with a generation past update_published
+	 */
+
+	MonoImage *base = table_info_get_base_image (*t);
+	if (!base)
+		return;
+	BaselineInfo *info = baseline_info_lookup (base);
+	if (!info)
+		return;
+
+	GList *list = info->delta_image;
+	MonoImage *dmeta;
+	int ridx;
+	MonoTableInfo *table;
+
+	/* Invariant: `*t` must be a `MonoTableInfo` of the base image. */
+	g_assert (base->tables < *t && *t < &base->tables [MONO_TABLE_LAST]);
+
+	size_t s = ALIGN_TO (sizeof (MonoTableInfo), sizeof (gpointer));
+	int tbl_index = ((intptr_t) *t - (intptr_t) base->tables) / s;
+
+	/* FIXME: I don't understand how ReplaceMethodOften works - it always has a 
+	 * EnCMap  entry 2: 0x06000002 (MethodDef) for every revision.	Shouldn't the number of methodDef rows be going up?
+
+	 * Apparently not - because conceptually the EnC log is saying to overwrite the existing rows.
+	 */
+
+	/* FIXME: so if the tables are conceptually mutated by each delta, we can't just stop at the
+	 * first lookup that gets a relative index in the right range, can we? that will always be
+	 * the oldest delta.
+	 */
+
+	/* FIXME: the other problem is that the EnClog is a sequence of actions to MUTATE rows.	 So when looking up an existing row we have to be able to make it so that naive callers decoding that row see the updated data.
+	 *
+	 * That's the main thing that PAss1 should eb doing for us.
+	 *
+	 * I think we can't get away from mutating.  The format is just too geared toward it.
+	 *
+	 * We should make the mutations atomic, though.	 (And I guess the heap extension is probably unavoidable)
+	 *
+	 * 1. Keep a table of inv
+	 */
+	int g = 0;
+
+	do {
+		g_assertf (list, "couldn't find idx=0x%08x in assembly=%s", *idx, dmeta && dmeta->name ? dmeta->name : "unknown image");
+		dmeta = (MonoImage*)list->data;
+		list = list->next;
+		table = &dmeta->tables [tbl_index];
+		ridx = hot_reload_relative_delta_index (dmeta, mono_metadata_make_token (tbl_index, *idx + 1)) - 1;
+		g++;
+	} while (ridx < 0 || ridx >= table_info_get_rows (table));
+
+	mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "effective table for %s: 0x%08x -> 0x%08x (rows = 0x%08x) (gen %d, g %d)", mono_meta_table_name (tbl_index), *idx, ridx, table_info_get_rows (table), metadata_update_local_generation (base, info, dmeta), g);
+
+	*t = table;
+	*idx = ridx;
 }
+
+/*
+ * The ENCMAP table contains the base of the relative offset.
+ *
+ * Returns -1 if the token does not resolve in this generation's ENCMAP.
+ *
+ * Example:
+ * Say you have a base image with a METHOD table having 5 entries.  The minimal
+ * delta image adds another one, so it would be indexed with token
+ * `MONO_TOKEN_METHOD_DEF | 6`. However, the minimal delta image only has this
+ * single entry, and thus this would be an out-of-bounds access. That's where
+ * the ENCMAP table comes into play: It will have an entry
+ * `MONO_TOKEN_METHOD_DEF | 5`, so before accessing the new entry in the
+ * minimal delta image, it has to be substracted. Thus the new relative index
+ * is `1`, and no out-of-bounds acccess anymore.
+ *
+ * One can assume that ENCMAP is sorted (todo: verify this claim).
+ *
+ * BTW, `enc_recs` is just a pre-computed map to make the lookup for the
+ * relative index faster.
+ */
+int
+hot_reload_relative_delta_index (MonoImage *image_dmeta, int token)
+{
+	MonoTableInfo *encmap = &image_dmeta->tables [MONO_TABLE_ENCMAP];
+	int table = mono_metadata_token_table (token);
+	int index = mono_metadata_token_index (token);
+
+	/* this helper expects and returns as "index origin = 1" */
+	g_assert (index > 0);
+
+	if (!table_info_get_rows (encmap) || !image_dmeta->minimal_delta)
+		return mono_metadata_token_index (token);
+
+	DeltaInfo *delta_info = delta_info_lookup (image_dmeta);
+	g_assert (delta_info);
+
+	int index_map = delta_info->enc_recs [table];
+	int encmap_rows = table_info_get_rows (encmap);
+
+	/* if the table didn't have any updates in this generation and the
+	 * table index is bigger than the last table that got updates,
+	 * enc_recs will point past the last row */
+	if (index_map - 1 == encmap_rows)
+		return -1;
+	guint32 cols[MONO_ENCMAP_SIZE];
+	mono_metadata_decode_row (encmap, index_map - 1, cols, MONO_ENCMAP_SIZE);
+	int map_entry = cols [MONO_ENCMAP_TOKEN];
+
+	while (mono_metadata_token_table (map_entry) == table && mono_metadata_token_index (map_entry) < index && index_map < encmap_rows) {
+		mono_metadata_decode_row (encmap, ++index_map - 1, cols, MONO_ENCMAP_SIZE);
+		map_entry = cols [MONO_ENCMAP_TOKEN];
+	}
+
+	if (mono_metadata_token_table (map_entry) == table) {
+		if (mono_metadata_token_index (map_entry) == index) {
+			/* token resolves to this generation */
+			int return_val = index_map - delta_info->enc_recs [table] + 1;
+			g_assert (return_val > 0 && return_val <= table_info_get_rows (&image_dmeta->tables[table]));
+			mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "relative index for token 0x%08x -> table 0x%02x row 0x%08x", token, table, return_val);
+			return return_val;
+		} else {
+			/* otherwise the last entry in the encmap is for this table, but is still less than the index - the index is in the next generation */
+			g_assert (mono_metadata_token_index (map_entry) < index && index_map == encmap_rows);
+			return -1;
+		}
+	} else {
+		/* otherwise there are no more encmap entries for this table, and we didn't see the index, so there index is in the next generation */
+		g_assert (mono_metadata_token_table (map_entry) > table);
+		return -1;
+	}
+}
+
+/* LOCKING: assumes publish_lock is held */
+static DeltaInfo*
+delta_info_init (MonoImage *image_dmeta, MonoImage *image_base, BaselineInfo *base_info, uint32_t generation)
+{
+	MonoTableInfo *encmap = &image_dmeta->tables [MONO_TABLE_ENCMAP];
+	g_assert (!delta_info_lookup (image_dmeta));
+
+	if (!table_info_get_rows (encmap))
+		return NULL;
+
+	DeltaInfo *delta_info = g_malloc0 (sizeof (DeltaInfo));
+
+	delta_info->generation = generation;
+
+	table_to_image_lock ();
+	g_hash_table_insert (delta_image_to_info, image_dmeta, delta_info);
+	table_to_image_unlock ();
+
+	/* base_image takes ownership of 1 refcount ref of dmeta_image */
+	image_append_delta (image_base, base_info, image_dmeta, delta_info);
+
+	return delta_info;
+}
+
+/* LOCKING: assumes publish_lock is held */
+static gboolean
+delta_info_compute_table_records (MonoImage *image_dmeta, MonoImage *image_base, BaselineInfo *base_info, DeltaInfo *delta_info)
+{
+	MonoTableInfo *encmap = &image_dmeta->tables [MONO_TABLE_ENCMAP];
+
+	int table, prev_table = -1, idx;
+
+	/*** Compute logical table sizes ***/
+	if (base_info->delta_image == base_info->delta_image_last) {
+		/* this is the first update. */
+		for (int i = 0; i < MONO_TABLE_NUM; ++i) {
+			delta_info->count[i].prev_gen_rows = table_info_get_rows (&image_base->tables[i]);
+		}
+	} else {
+		/* Current image_dmeta is image_base->delta_image_last->data,
+		 * find its predecessor
+		 */
+		MonoImage *prev_delta = NULL;
+		g_assert (base_info->delta_image_last->prev != NULL);
+		prev_delta = (MonoImage*)base_info->delta_image_last->prev->data;
+		DeltaInfo *prev_gen_info = delta_info_lookup (prev_delta);
+		for (int i = 0; i < MONO_TABLE_NUM; ++i) {
+			delta_info->count[i].prev_gen_rows = prev_gen_info->count[i].prev_gen_rows + prev_gen_info->count[i].inserted_rows;
+		}
+	}
+
+
+	/* TODO: while going through the tables, update delta_info->count[tbl].{modified,inserted}_rows */
+
+	int encmap_rows = table_info_get_rows (encmap);
+	for (idx = 1; idx <= encmap_rows; ++idx) {
+		guint32 cols[MONO_ENCMAP_SIZE];
+		mono_metadata_decode_row (encmap, idx - 1, cols, MONO_ENCMAP_SIZE);
+		uint32_t tok = cols [MONO_ENCMAP_TOKEN];
+		table = mono_metadata_token_table (tok);
+		uint32_t rid = mono_metadata_token_index (tok);
+		g_assert (table >= 0 && table < MONO_TABLE_NUM);
+		g_assert (table != MONO_TABLE_ENCLOG);
+		g_assert (table != MONO_TABLE_ENCMAP);
+		g_assert (table >= prev_table);
+		/* FIXME: check bounds - is it < or <=. */
+		if (rid < delta_info->count[table].prev_gen_rows)
+			delta_info->count[table].modified_rows++;
+		else
+			delta_info->count[table].inserted_rows++;
+		if (table == prev_table)
+			continue;
+		while (prev_table < table) {
+			prev_table++;
+			delta_info->enc_recs [prev_table] = idx;
+		}
+	}
+	g_assert (prev_table < MONO_TABLE_NUM - 1);
+	while (prev_table < MONO_TABLE_NUM - 1) {
+		prev_table++;
+		delta_info->enc_recs [prev_table] = idx;
+	}
+
+	if (mono_trace_is_traced (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE)) {
+		for (int i = 0 ; i < MONO_TABLE_NUM; ++i) {
+			if (!image_dmeta->tables [i].base)
+				continue;
+
+			mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "enc_recs [%02x] / %s = 0x%02x\t(inserted: %03d, modified: %03d)", i, mono_meta_table_name (i), delta_info->enc_recs[i], delta_info->count[i].inserted_rows, delta_info->count[i].modified_rows);
+		}
+	}
+
+	return TRUE;
+}
+
+static const char*
+funccode_to_str (int func_code)
+{
+	switch (func_code) {
+		case 0: return "Func default";
+		case 1: return "Method Create";
+		case 2: return "Field Create";
+		case 3: return "Param Create";
+		case 4: return "Property Create";
+		case 5: return "Event Create";
+		default: g_assert_not_reached ();
+	}
+	return NULL;
+}
+
+/* Run some sanity checks first. If we detect unsupported scenarios, this
+ * function will fail and the metadata update should be aborted. This should
+ * run before anything in the metadata world is updated. */
+static gboolean
+apply_enclog_pass1 (MonoImage *image_base, MonoImage *image_dmeta, gconstpointer dil_data, uint32_t dil_length, MonoError *error)
+{
+	MonoTableInfo *table_enclog = &image_dmeta->tables [MONO_TABLE_ENCLOG];
+	int rows = table_info_get_rows (table_enclog);
+
+	gboolean unsupported_edits = FALSE;
+
+	/* hack: make a pass over it, looking only for table method updates, in
+	 * order to give more meaningful error messages first */
+
+	for (int i = 0; i < rows ; ++i) {
+		guint32 cols [MONO_ENCLOG_SIZE];
+		mono_metadata_decode_row (table_enclog, i, cols, MONO_ENCLOG_SIZE);
+
+		// FIXME: the top bit 0x8000000 of log_token is some kind of
+		// indicator see IsRecId in metamodelrw.cpp and
+		// MDInternalRW::EnumDeltaTokensInit which skips over those
+		// records when EditAndContinueModule::ApplyEditAndContinue is
+		// iterating.
+		int log_token = cols [MONO_ENCLOG_TOKEN];
+		int func_code = cols [MONO_ENCLOG_FUNC_CODE];
+
+		int token_table = mono_metadata_token_table (log_token);
+		int token_index = mono_metadata_token_index (log_token);
+
+		mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "row[0x%02x]:0x%08x (%s idx=0x%02x) (base table has 0x%04x rows)\tfunc=0x%02x\n", i, log_token, mono_meta_table_name (token_table), token_index, table_info_get_rows (&image_base->tables [token_table]), func_code);
+
+
+		if (token_table != MONO_TABLE_METHOD)
+			continue;
+
+		if (token_index > table_info_get_rows (&image_base->tables [token_table])) {
+			mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_METADATA_UPDATE, "\tcannot add new method with token 0x%08x", log_token);
+			mono_error_set_type_load_name (error, NULL, image_base->name, "EnC: cannot add new method with token 0x%08x", log_token);
+			unsupported_edits = TRUE;
+		}
+
+		g_assert (func_code == 0); /* anything else doesn't make sense here */
+	}
+
+	for (int i = 0; i < rows ; ++i) {
+		guint32 cols [MONO_ENCLOG_SIZE];
+		mono_metadata_decode_row (table_enclog, i, cols, MONO_ENCLOG_SIZE);
+
+		int log_token = cols [MONO_ENCLOG_TOKEN];
+		int func_code = cols [MONO_ENCLOG_FUNC_CODE];
+
+		int token_table = mono_metadata_token_table (log_token);
+		int token_index = mono_metadata_token_index (log_token);
+
+		switch (token_table) {
+		case MONO_TABLE_ASSEMBLYREF:
+			/* okay, supported */
+			break;
+		case MONO_TABLE_METHOD:
+			/* handled above */
+			break;
+		case MONO_TABLE_PROPERTY: {
+			/* modifying a property, ok */
+			if (token_index <= table_info_get_rows (&image_base->tables [token_table]))
+				break;
+			/* adding a property */
+			mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_METADATA_UPDATE, "row[0x%02x]:0x%08x we do not support adding new properties.", i, log_token);
+			mono_error_set_type_load_name (error, NULL, image_base->name, "EnC: we do not support adding new properties. token=0x%08x", log_token);
+			unsupported_edits = TRUE;
+			continue;
+		}
+		case MONO_TABLE_METHODSEMANTICS: {
+			if (token_index > table_info_get_rows (&image_base->tables [token_table])) {
+				/* new rows are fine, as long as they point at existing methods */
+				guint32 sema_cols [MONO_METHOD_SEMA_SIZE];
+				int mapped_token = hot_reload_relative_delta_index (image_dmeta, mono_metadata_make_token (token_table, token_index));
+				g_assert (mapped_token != -1);
+				mono_metadata_decode_row (&image_dmeta->tables [MONO_TABLE_METHODSEMANTICS], mapped_token - 1, sema_cols, MONO_METHOD_SEMA_SIZE);
+
+				switch (sema_cols [MONO_METHOD_SEMA_SEMANTICS]) {
+				case METHOD_SEMANTIC_GETTER:
+				case METHOD_SEMANTIC_SETTER: {
+					int prop_method_index = sema_cols [MONO_METHOD_SEMA_METHOD];
+					/* ok, if it's pointing to an existing getter/setter */
+					if (prop_method_index < table_info_get_rows (&image_base->tables [MONO_TABLE_METHOD]))
+						break;
+					mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_METADATA_UPDATE, "row[0x%02x]:0x%08x adding new getter/setter method 0x%08x to a property is not supported", i, log_token, prop_method_index);
+					mono_error_set_type_load_name (error, NULL, image_base->name, "EnC: we do not support adding a new getter or setter to a property, token=0x%08x", log_token);
+					unsupported_edits = TRUE;
+					continue;
+				}
+				default:
+					mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_METADATA_UPDATE, "row[0x%02x]:0x%08x adding new non-getter/setter property or event methods is not supported.", i, log_token);
+					mono_error_set_type_load_name (error, NULL, image_base->name, "EnC: we do not support adding new non-getter/setter property or event methods. token=0x%08x", log_token);
+					unsupported_edits = TRUE;
+					continue;
+				}
+			} else {
+				mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_METADATA_UPDATE, "row[0x%02x]:0x%08x we do not support patching of existing table cols.", i, log_token);
+				mono_error_set_type_load_name (error, NULL, image_base->name, "EnC: we do not support patching of existing table cols. token=0x%08x", log_token);
+				unsupported_edits = TRUE;
+				continue;
+			}
+		}
+		default:
+			/* FIXME: this bounds check is wrong for cumulative updates - need to look at the DeltaInfo:count.prev_gen_rows */
+			if (token_index <= table_info_get_rows (&image_base->tables [token_table])) {
+				mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_METADATA_UPDATE, "row[0x%02x]:0x%08x we do not support patching of existing table cols.", i, log_token);
+				mono_error_set_type_load_name (error, NULL, image_base->name, "EnC: we do not support patching of existing table cols. token=0x%08x", log_token);
+				unsupported_edits = TRUE;
+				continue;
+			}
+		}
+
+
+		/*
+		 * So the way a non-default func_code works is that it's attached to the EnCLog
+		 * record preceeding the new member defintion (so e.g. an addMethod code will be on
+		 * the preceeding MONO_TABLE_TYPEDEF enc record that identifies the parent type).
+		 */
+		switch (func_code) {
+			case 0: /* default */
+				break;
+			default:
+				mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_METADATA_UPDATE, "row[0x%02x]:0x%08x FunCode %d (%s) not supported (token=0x%08x)", i, log_token, func_code, funccode_to_str (func_code), log_token);
+				mono_error_set_type_load_name (error, NULL, image_base->name, "EnC: FuncCode %d (%s) not supported (token=0x%08x)", func_code, funccode_to_str (func_code), log_token);
+				unsupported_edits = TRUE;
+				continue;
+		}
+	}
+	return !unsupported_edits;
+}
+
+static void
+set_update_method (MonoImage *image_base, BaselineInfo *base_info, uint32_t generation, MonoImage *image_dmeta, DeltaInfo *delta_info, uint32_t token_index, const char* il_address)
+{
+	mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_METADATA_UPDATE, "setting method 0x%08x in g=%d IL=%p", token_index, generation, (void*)il_address);
+	/* FIXME: this is a race if other threads are doing a lookup. */
+	g_hash_table_insert (base_info->method_table_update, GUINT_TO_POINTER (token_index), GUINT_TO_POINTER (generation));
+	g_hash_table_insert (delta_info->method_table_update, GUINT_TO_POINTER (token_index), (gpointer) il_address);
+}
+
+/* do actuall enclog application */
+static gboolean
+apply_enclog_pass2 (MonoImage *image_base, BaselineInfo *base_info, uint32_t generation, MonoImage *image_dmeta, DeltaInfo *delta_info, gconstpointer dil_data, uint32_t dil_length, MonoError *error)
+{
+	MonoTableInfo *table_enclog = &image_dmeta->tables [MONO_TABLE_ENCLOG];
+	int rows = table_info_get_rows (table_enclog);
+
+	gboolean assemblyref_updated = FALSE;
+	for (int i = 0; i < rows ; ++i) {
+		guint32 cols [MONO_ENCLOG_SIZE];
+		mono_metadata_decode_row (table_enclog, i, cols, MONO_ENCLOG_SIZE);
+
+		int log_token = cols [MONO_ENCLOG_TOKEN];
+		int func_code = cols [MONO_ENCLOG_FUNC_CODE];
+
+		int token_table = mono_metadata_token_table (log_token);
+		int token_index = mono_metadata_token_index (log_token);
+		mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "enclog i=%d: token=0x%08x (table=%s): %d", i, log_token, mono_meta_table_name (token_table), func_code);
+
+		/* TODO: See CMiniMdRW::ApplyDelta for how to drive this.
+		 */
+		switch (func_code) {
+			case 0: /* default */
+				break;
+			default:
+				g_error ("EnC: unsupported FuncCode, should be caught by pass1");
+				break;
+		}
+
+		switch (token_table) {
+		case MONO_TABLE_ASSEMBLYREF: {
+			g_assert (token_index > table_info_get_rows (&image_base->tables [token_table]));
+
+			if (assemblyref_updated)
+				continue;
+
+			assemblyref_updated = TRUE;
+
+			/* FIXME: use DeltaInfo:prev_gen_rows instead of looping */
+			/* TODO: do we know that there will never be modified rows in ASSEMBLYREF? */
+			int old_rows = table_info_get_rows (&image_base->tables [MONO_TABLE_ASSEMBLYREF]);
+			for (GList *l = base_info->delta_image; l; l = l->next) {
+				MonoImage *delta_child = l->data;
+				old_rows += table_info_get_rows (&delta_child->tables [MONO_TABLE_ASSEMBLYREF]);
+			}
+			int new_rows = table_info_get_rows (&image_dmeta->tables [MONO_TABLE_ASSEMBLYREF]);
+
+			old_rows -= new_rows;
+			g_assert (new_rows > 0);
+			g_assert (old_rows > 0);
+
+			/* TODO: this can end bad with code around assembly.c:mono_assembly_load_reference */
+			mono_image_lock (image_base);
+			MonoAssembly **old_array = image_base->references;
+			g_assert (image_base->nreferences == old_rows);
+
+			image_base->references = g_new0 (MonoAssembly *, old_rows + new_rows + 1);
+			memcpy (image_base->references, old_array, sizeof (gpointer) * (old_rows + 1));
+			image_base->nreferences = old_rows + new_rows;
+			mono_image_unlock (image_base);
+
+			g_free (old_array);
+			break;
+		}
+		case MONO_TABLE_METHOD: {
+			if (token_index > table_info_get_rows (&image_base->tables [token_table])) {
+				g_error ("EnC: new method added, should be caught by pass1");
+			}
+
+			if (!base_info->method_table_update)
+				base_info->method_table_update = g_hash_table_new (g_direct_hash, g_direct_equal);
+			if (!delta_info->method_table_update)
+				delta_info->method_table_update = g_hash_table_new (g_direct_hash, g_direct_equal);
+
+			int mapped_token = hot_reload_relative_delta_index (image_dmeta, mono_metadata_make_token (token_table, token_index));
+			int rva = mono_metadata_decode_row_col (&image_dmeta->tables [MONO_TABLE_METHOD], mapped_token - 1, MONO_METHOD_RVA);
+			if (rva < dil_length) {
+				char *il_address = ((char *) dil_data) + rva;
+				set_update_method (image_base, base_info, generation, image_dmeta, delta_info, token_index, il_address);
+			} else {
+				/* rva points probably into image_base IL stream. can this ever happen? */
+				g_print ("TODO: this case is still a bit contrived. token=0x%08x with rva=0x%04x\n", log_token, rva);
+			}
+			break;
+		}
+		case MONO_TABLE_TYPEDEF: {
+			/* TODO: throw? */
+			/* TODO: happens changing the class (adding field or method). we ignore it, but dragons are here */
+
+			/* existing entries are supposed to be patched */
+			g_assert (token_index <= table_info_get_rows (&image_base->tables [token_table]));
+			break;
+		}
+		case MONO_TABLE_PROPERTY: {
+			/* allow updates to existing properties. */
+			/* FIXME: use DeltaInfo:prev_gen_rows instead of image_base */
+			g_assert (token_index <= table_info_get_rows (&image_base->tables [token_table]));
+			/* assuming that property attributes and type haven't changed. */
+			break;
+		}
+		default: {
+			g_assert (token_index > table_info_get_rows (&image_base->tables [token_table]));
+			if (mono_trace_is_traced (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE))
+				g_print ("todo: do something about this table index: 0x%02x\n", token_table);
+		}
+		}
+	}
+	return TRUE;
+}
+
+/**
+ *
+ * LOCKING: Takes the publish_lock
+ */
+void
+hot_reload_apply_changes (MonoImage *image_base, gconstpointer dmeta_bytes, uint32_t dmeta_length, gconstpointer dil_bytes_orig, uint32_t dil_length, MonoError *error)
+{
+	if (!assembly_update_supported (image_base->assembly)) {
+		mono_error_set_invalid_operation (error, "The assembly can not be edited or changed.");
+		return;
+	}
+
+	const char *basename = image_base->filename;
+
+	if (mono_trace_is_traced (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE)) {
+		g_print ("LOADING basename=%s delta update.\ndelta image=%p & dil=%p\n", basename, dmeta_bytes, dil_bytes_orig);
+                mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_METADATA_UPDATE, "delta image size 0x%08x, delta IL size 0x%08x\n", dmeta_length, dil_length);
+#if 0
+		mono_dump_mem (dmeta_bytes, dmeta_length);
+		mono_dump_mem (dil_bytes_orig, dil_length);
+#endif
+	}
+
+	uint32_t generation = hot_reload_update_prepare ();
+
+	mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "base image string size: 0x%08x", image_base->heap_strings.size);
+	mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "base image user string size: 0x%08x", image_base->heap_us.size);
+	mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "base image blob heap addr: %p", image_base->heap_blob.data);
+	mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "base image blob heap size: 0x%08x", image_base->heap_blob.size);
+
+	/* makes a copy of dmeta_bytes */
+	MonoImage *image_dmeta = image_open_dmeta_from_data (image_base, generation, dmeta_bytes, dmeta_length);
+	mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "delta image string size: 0x%08x", image_dmeta->heap_strings.size);
+	mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "delta image user string size: 0x%08x", image_dmeta->heap_us.size);
+	mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "delta image blob heap addr: %p", image_dmeta->heap_blob.data);
+	mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "delta image blob heap size: 0x%08x", image_dmeta->heap_blob.size);
+	g_assert (image_dmeta);
+
+	/* makes a copy of dil_bytes_orig */
+	gpointer dil_bytes = open_dil_data (image_base, dil_bytes_orig, dil_length);
+	/* TODO: make a copy of the dpdb bytes, once we consume them */
+
+	BaselineInfo *base_info = baseline_info_lookup_or_add (image_base);
+
+	DeltaInfo *delta_info = delta_info_init (image_dmeta, image_base, base_info, generation);
+
+
+	if (image_dmeta->minimal_delta) {
+		guint32 idx = mono_metadata_decode_row_col (&image_dmeta->tables [MONO_TABLE_MODULE], 0, MONO_MODULE_NAME);
+
+		const char *module_name = NULL;
+		module_name = mono_metadata_string_heap (image_base, idx);
+
+		/* Set the module name now that we know the base String heap size */
+		g_assert (!image_dmeta->module_name);
+		image_dmeta->module_name = module_name;
+		mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "applied dmeta name: '%s'\n", module_name);
+	}
+
+	MonoTableInfo *table_enclog = &image_dmeta->tables [MONO_TABLE_ENCLOG];
+	MonoTableInfo *table_encmap = &image_dmeta->tables [MONO_TABLE_ENCMAP];
+
+	if (!table_info_get_rows (table_enclog) && !table_info_get_rows (table_encmap)) {
+		mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_METADATA_UPDATE, "No enclog or encmap in delta image for base=%s, nothing to do", basename);
+		hot_reload_update_cancel (generation);
+		return;
+	}
+
+	/* Process EnCMap and compute number of added/modified rows from this
+	 * delta.  This enables computing row indexes relative to the delta.
+	 * We use it in pass1 to bail out early if the EnCLog has unsupported
+	 * edits.
+	 */
+	if (!delta_info_compute_table_records (image_dmeta, image_base, base_info, delta_info)) {
+		mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_METADATA_UPDATE, "Error on computing delta table info (base=%s)", basename);
+		hot_reload_update_cancel (generation);
+		return;
+	}
+
+
+	if (!apply_enclog_pass1 (image_base, image_dmeta, dil_bytes, dil_length, error)) {
+		mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_METADATA_UPDATE, "Error on sanity-checking delta image to base=%s, due to: %s", basename, mono_error_get_message (error));
+		hot_reload_update_cancel (generation);
+		return;
+	}
+
+	/* if there are updates, start tracking the tables of the base image, if we weren't already. */
+	if (table_info_get_rows (table_enclog))
+		table_to_image_add (image_base);
+
+	mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "base  guid: %s", image_base->guid);
+	mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "dmeta guid: %s", image_dmeta->guid);
+
+	if (mono_trace_is_traced (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE))
+		dump_update_summary (image_base, image_dmeta);
+
+	if (!apply_enclog_pass2 (image_base, base_info, generation, image_dmeta, delta_info, dil_bytes, dil_length, error)) {
+		mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_METADATA_UPDATE, "Error applying delta image to base=%s, due to: %s", basename, mono_error_get_message (error));
+		hot_reload_update_cancel (generation);
+		return;
+	}
+	mono_error_assert_ok (error);
+
+	MonoAssemblyLoadContext *alc = mono_image_get_alc (image_base);
+	hot_reload_update_publish (alc, generation);
+
+	mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_METADATA_UPDATE, ">>> EnC delta for base=%s (generation %d) applied", basename, generation);
+}
+
+/*
+ * Returns how many times the base image was updated upto and including the given delta.
+ */
+static int
+metadata_update_local_generation (MonoImage *base, BaselineInfo *base_info, MonoImage *delta)
+{
+	if (delta == base)
+		return 0;
+	int index = g_list_index (base_info->delta_image, delta);
+	g_assert (index != -1);
+	return 1 + index;
+}
+
+/*
+ * Returns how many times the given base image has been updated so far.
+ *
+ * NOTE: doesn't look at update_published or update_alloc_frontier, and therefore only usable by the
+ * update originator.
+ */
+static int
+metadata_update_count_updates (MonoImage *base)
+{
+	BaselineInfo *base_info = baseline_info_lookup (base);
+	if (!base_info || !base_info->delta_image_last)
+		return 0;
+	else
+		return metadata_update_local_generation (base, base_info, (MonoImage*)base_info->delta_image_last->data);
+}
+
+static gpointer
+get_method_update_rva (MonoImage *image_base, BaselineInfo *base_info, uint32_t idx)
+{
+	gpointer loc = NULL;
+	uint32_t cur = hot_reload_get_thread_generation ();
+	int generation = -1;
+	
+	/* Go through all the updates that the current thread can see and see
+	 * if they updated the method.	Keep the latest visible update */
+	for (GList *ptr = base_info->delta_image; ptr != NULL; ptr = ptr->next) {
+		MonoImage *image_delta = (MonoImage*) ptr->data;
+		DeltaInfo *delta_info = delta_info_lookup (image_delta);
+		g_assert (delta_info);
+		if (delta_info->generation > cur)
+			break;
+		if (delta_info->method_table_update) {
+			gpointer result = g_hash_table_lookup (delta_info->method_table_update, GUINT_TO_POINTER (idx));
+			/* if it's not in the table of a later generation, the
+			 * later generation didn't modify the method
+			 */
+			if (result != NULL) {
+				loc = result;
+				generation = delta_info->generation;
+			}
+		}
+	}
+	mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "method lookup idx=0x%08x returned gen=%d il=%p", idx, generation, loc);
+	return loc;
+}
+
+gpointer
+hot_reload_get_updated_method_rva (MonoImage *base_image, uint32_t idx)
+{
+	BaselineInfo *info = baseline_info_lookup (base_image);
+	if (!info)
+		return NULL;
+	gpointer loc = NULL;
+	/* EnC case */
+	if (G_UNLIKELY (info->method_table_update)) {
+		uint32_t gen = GPOINTER_TO_UINT (g_hash_table_lookup (info->method_table_update, GUINT_TO_POINTER (idx)));
+		if (G_UNLIKELY (gen > 0)) {
+			loc = get_method_update_rva (base_image, info, idx);
+		}
+	}
+	return loc;
+}
+
+
+/* returns TRUE if token index is out of bounds */
+gboolean
+hot_reload_table_bounds_check (MonoImage *base_image, int table_index, int token_index)
+{
+	BaselineInfo *base_info = baseline_info_lookup (base_image);
+	g_assert (base_info);
+
+	GList *list = base_info->delta_image;
+	MonoImage *dmeta;
+	MonoTableInfo *table;
+	/* result row, 0-based */
+	int ridx;
+
+	int original_token = mono_metadata_make_token (table_index, token_index);
+
+	uint32_t exposed_gen = hot_reload_get_thread_generation ();
+	do {
+		if (!list)
+			return TRUE;
+		dmeta = list->data;
+		DeltaInfo *delta_info = delta_info_lookup (dmeta);
+		g_assert (delta_info);
+		if (delta_info->generation > exposed_gen)
+			return TRUE;
+		list = list->next;
+		table = &dmeta->tables [table_index];
+		/* mono_image_relative_delta_index returns a 1-based index */
+		ridx = hot_reload_relative_delta_index (dmeta, original_token) - 1;
+	} while (ridx < 0 || ridx >= table_info_get_rows (table));
+
+	return FALSE;
+}
+
+gboolean
+hot_reload_delta_heap_lookup (MonoImage *base_image, MetadataHeapGetterFunc get_heap, uint32_t orig_index, MonoImage **image_out, uint32_t *index_out)
+{
+	g_assert (image_out);
+	g_assert (index_out);
+	MonoStreamHeader *heap = get_heap (base_image);
+	g_assert (orig_index >= heap->size);
+	BaselineInfo *base_info = baseline_info_lookup (base_image);
+	g_assert (base_info);
+	g_assert (base_info->delta_image);
+
+	*image_out = base_image;
+	*index_out = orig_index;
+
+	guint32 prev_size = heap->size;
+
+	uint32_t current_gen = hot_reload_get_thread_generation ();
+	GList *cur;
+	for (cur = base_info->delta_image; cur; cur = cur->next) {
+		MonoImage *delta_image = (MonoImage*)cur->data;
+		heap = get_heap (delta_image);
+
+		*image_out = delta_image;
+
+		DeltaInfo *delta_info = delta_info_lookup (delta_image);
+		if (delta_info->generation > current_gen)
+			return FALSE;
+
+		/* FIXME: for non-minimal deltas we should just look in the last published image. */
+		if (G_LIKELY (delta_image->minimal_delta))
+			*index_out -= prev_size;
+		if (*index_out < heap->size)
+			break;
+		prev_size = heap->size;
+	}
+	return (cur != NULL);
+}
+
diff --git a/src/mono/mono/component/hot_reload.h b/src/mono/mono/component/hot_reload.h
index b870b9417f25a3..4994664103cc2e 100644
--- a/src/mono/mono/component/hot_reload.h
+++ b/src/mono/mono/component/hot_reload.h
@@ -7,13 +7,28 @@
 
 #include <glib.h>
 #include "mono/metadata/object-forward.h"
+#include "mono/metadata/metadata-internals.h"
+#include "mono/metadata/metadata-update.h"
 #include "mono/utils/mono-error.h"
 #include "mono/utils/mono-compiler.h"
 #include "mono/component/component.h"
 
 typedef struct _MonoComponentHotReload {
 	MonoComponent component;
+	void (*set_fastpath_data) (MonoMetadataUpdateData *data);
+	gboolean (*update_enabled) (int *modifiable_assemblies_out);
+	gboolean (*no_inline) (MonoMethod *caller, MonoMethod *callee);
+	uint32_t (*thread_expose_published) (void);
+	uint32_t (*get_thread_generation) (void);
+	void (*cleanup_on_close) (MonoImage *image);
+	void (*effective_table_slow) (const MonoTableInfo **t, int *idx);
+	int (*relative_delta_index) (MonoImage *image_dmeta, int token);
 	void (*apply_changes) (MonoImage *base_image, gconstpointer dmeta, uint32_t dmeta_len, gconstpointer dil, uint32_t dil_len, MonoError *error);
+	void (*image_close_except_pools_all) (MonoImage *base_image);
+	void (*image_close_all) (MonoImage *base_image);
+	gpointer (*get_updated_method_rva) (MonoImage *base_image, uint32_t idx);
+	gboolean (*table_bounds_check) (MonoImage *base_image, int table_index, int token_index);
+	gboolean (*delta_heap_lookup) (MonoImage *base_image, MetadataHeapGetterFunc get_heap, uint32_t orig_index, MonoImage **image_out, uint32_t *index_out);
 } MonoComponentHotReload;
 
 MONO_COMPONENT_EXPORT_ENTRYPOINT
diff --git a/src/mono/mono/eventpipe/ep-rt-mono.c b/src/mono/mono/eventpipe/ep-rt-mono.c
index 8416cf0ad8f161..f8b85538db0f0b 100644
--- a/src/mono/mono/eventpipe/ep-rt-mono.c
+++ b/src/mono/mono/eventpipe/ep-rt-mono.c
@@ -44,6 +44,7 @@ char *_ep_rt_mono_os_cmd_line = NULL;
 mono_lazy_init_t _ep_rt_mono_managed_cmd_line_init = MONO_LAZY_INIT_STATUS_NOT_INITIALIZED;
 char *_ep_rt_mono_managed_cmd_line = NULL;
 
+
 // Sample profiler.
 static GArray * _ep_rt_mono_sampled_thread_callstacks = NULL;
 static uint32_t _ep_rt_mono_max_sampled_thread_count = 32;
diff --git a/src/mono/mono/eventpipe/ep-rt-mono.h b/src/mono/mono/eventpipe/ep-rt-mono.h
index c048682445c409..22bdccdcd7df2c 100644
--- a/src/mono/mono/eventpipe/ep-rt-mono.h
+++ b/src/mono/mono/eventpipe/ep-rt-mono.h
@@ -20,9 +20,12 @@
 #include <mono/utils/mono-rand.h>
 #include <mono/utils/mono-lazy-init.h>
 #include <mono/utils/w32api.h>
+#include <mono/metadata/assembly.h>
 #include <mono/metadata/w32file.h>
 #include <mono/metadata/w32event.h>
 #include <mono/metadata/environment-internals.h>
+#include <mono/metadata/metadata-internals.h>
+#include <runtime_version.h>
 #include <mono/metadata/profiler.h>
 
 #undef EP_ARRAY_SIZE
@@ -1824,6 +1827,22 @@ ep_rt_diagnostics_command_line_get (void)
 	return cmd_line;
 }
 
+static
+inline
+const ep_char8_t *
+ep_rt_entrypoint_assembly_name_get_utf8 (void)
+{
+	return (const ep_char8_t *)m_image_get_assembly_name (mono_assembly_get_main ()->image);
+}
+
+static
+inline
+const ep_char8_t *
+ep_rt_runtime_version_get_utf8 (void)
+{
+	return (const ep_char8_t *)EGLIB_TOSTRING (RuntimeProductVersion);
+}
+
 /*
  * Thread.
  */
diff --git a/src/mono/mono/metadata/assembly-internals.h b/src/mono/mono/metadata/assembly-internals.h
index b236d6473049a6..4548b7fd864519 100644
--- a/src/mono/mono/metadata/assembly-internals.h
+++ b/src/mono/mono/metadata/assembly-internals.h
@@ -147,6 +147,7 @@ mono_assembly_get_image_internal (MonoAssembly *assembly);
 void
 mono_set_assemblies_path_direct (char **path);
 
+MONO_COMPONENT_API
 gboolean
 mono_assembly_is_jit_optimizer_disabled (MonoAssembly *assembly);
 
diff --git a/src/mono/mono/metadata/assembly-load-context.c b/src/mono/mono/metadata/assembly-load-context.c
index 6550920e153067..85c9b3313bf751 100644
--- a/src/mono/mono/metadata/assembly-load-context.c
+++ b/src/mono/mono/metadata/assembly-load-context.c
@@ -72,6 +72,7 @@ mono_alcs_init (void)
 	mono_coop_mutex_init (&alc_list_lock);
 
 	default_alc = mono_alc_create (FALSE);
+	default_alc->gchandle = mono_gchandle_new_internal (NULL, FALSE);
 }
 
 MonoAssemblyLoadContext *
@@ -237,8 +238,10 @@ ves_icall_System_Runtime_Loader_AssemblyLoadContext_InternalInitializeNativeALC
 	if (is_default_alc) {
 		alc = default_alc;
 		g_assert (alc);
-		if (!alc->gchandle)
-			alc->gchandle = this_gchandle;
+
+		// Change target of the existing GCHandle
+		mono_gchandle_set_target (alc->gchandle, mono_gchandle_get_target_internal (this_gchandle));
+		mono_gchandle_free_internal (this_gchandle);
 	} else {
 		alc = mono_alc_create_individual (this_gchandle, collectible, error);
 	}
@@ -416,6 +419,9 @@ mono_alc_is_default (MonoAssemblyLoadContext *alc)
 MonoAssemblyLoadContext *
 mono_alc_from_gchandle (MonoGCHandle alc_gchandle)
 {
+	if (alc_gchandle == default_alc->gchandle)
+		return default_alc;
+
 	HANDLE_FUNCTION_ENTER ();
 	MonoManagedAssemblyLoadContextHandle managed_alc = MONO_HANDLE_CAST (MonoManagedAssemblyLoadContext, mono_gchandle_get_target_handle (alc_gchandle));
 	MonoAssemblyLoadContext *alc = MONO_HANDLE_GETVAL (managed_alc, native_assembly_load_context);
@@ -438,6 +444,9 @@ invoke_resolve_method (MonoMethod *resolve_method, MonoAssemblyLoadContext *alc,
 	if (mono_runtime_get_no_exec ())
 		return NULL;
 
+	if (!mono_gchandle_get_target_internal (alc->gchandle))
+		return NULL;
+
 	HANDLE_FUNCTION_ENTER ();
 
 	aname_str = mono_stringify_assembly_name (aname);
diff --git a/src/mono/mono/metadata/class-inlines.h b/src/mono/mono/metadata/class-inlines.h
index 7c8a61ae5b8e79..a9aa3c992a5416 100644
--- a/src/mono/mono/metadata/class-inlines.h
+++ b/src/mono/mono/metadata/class-inlines.h
@@ -217,6 +217,18 @@ m_method_is_virtual (MonoMethod *method)
 	return (method->flags & METHOD_ATTRIBUTE_VIRTUAL) != 0;
 }
 
+static inline gboolean
+m_method_is_abstract (MonoMethod *method)
+{
+        return (method->flags & METHOD_ATTRIBUTE_ABSTRACT) != 0;
+}
+
+static inline gboolean
+m_method_is_final (MonoMethod *method)
+{
+        return (method->flags & METHOD_ATTRIBUTE_FINAL) != 0;
+}
+
 static inline gboolean
 m_method_is_icall (MonoMethod *method)
 {
diff --git a/src/mono/mono/metadata/components.c b/src/mono/mono/metadata/components.c
index a1ba44aa2480b4..765bc726a2efee 100644
--- a/src/mono/mono/metadata/components.c
+++ b/src/mono/mono/metadata/components.c
@@ -140,14 +140,18 @@ try_load (const char* dir, const MonoComponentEntry *component, const char* comp
 {
 	MonoDl *lib = NULL;
 	char *path = NULL;
-	path = g_module_build_path (dir, component_base_lib);
-	if (path) {
+	void *iter = NULL;
+
+	while ((path = mono_dl_build_path (dir, component_base_lib, &iter))) {
 		char *error_msg = NULL;
 		lib = mono_dl_open (path, MONO_DL_EAGER | MONO_DL_LOCAL, &error_msg);
+		if (lib)
+			break;
 		if (!lib) {
 			mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_DLLIMPORT, "Component %s not found: %s", component->name, error_msg);
 		}
 		g_free (error_msg);
+		g_free (path);
 	}
 	if (lib)
 		mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_DLLIMPORT, "Component %s found at %s", component->name, path);
diff --git a/src/mono/mono/metadata/domain.c b/src/mono/mono/metadata/domain.c
index 2078bc7a0bfdc1..4a8e06d28ae2cf 100644
--- a/src/mono/mono/metadata/domain.c
+++ b/src/mono/mono/metadata/domain.c
@@ -485,10 +485,8 @@ void
 mono_close_exe_image (void)
 {
 	gboolean do_close = exe_image != NULL;
-#ifdef ENABLE_METADATA_UPDATE
 	/* FIXME: shutdown hack. We mess something up and try to double-close/free it. */
-	do_close = do_close && !exe_image->delta_image;
-#endif
+	do_close = do_close && !exe_image->has_updates;
 	if (do_close)
 		mono_image_close (exe_image);
 }
diff --git a/src/mono/mono/metadata/icall-decl.h b/src/mono/mono/metadata/icall-decl.h
index f226f71bc40fe7..b78d7c6a06d248 100644
--- a/src/mono/mono/metadata/icall-decl.h
+++ b/src/mono/mono/metadata/icall-decl.h
@@ -242,8 +242,7 @@ ICALL_EXPORT void     ves_icall_System_Threading_LowLevelLifoSemaphore_ReleaseIn
 ICALL_EXPORT void ves_icall_System_Runtime_Intrinsics_X86_X86Base___cpuidex (int abcd[4], int function_id, int subfunction_id);
 #endif
 
-#ifdef ENABLE_METADATA_UPDATE
 ICALL_EXPORT void ves_icall_AssemblyExtensions_ApplyUpdate (MonoAssembly *assm, gconstpointer dmeta_bytes, int32_t dmeta_len, gconstpointer dil_bytes, int32_t dil_len, gconstpointer dpdb_bytes, int32_t dpdb_len);
-#endif
+ICALL_EXPORT gint32 ves_icall_AssemblyExtensions_ApplyUpdateEnabled (void);
 
 #endif // __MONO_METADATA_ICALL_DECL_H__
diff --git a/src/mono/mono/metadata/icall-def-netcore.h b/src/mono/mono/metadata/icall-def-netcore.h
index 42c1d777b40849..6fb0ddd4712f1b 100644
--- a/src/mono/mono/metadata/icall-def-netcore.h
+++ b/src/mono/mono/metadata/icall-def-netcore.h
@@ -245,10 +245,9 @@ ICALL_TYPE(FIELDI, "System.Reflection.FieldInfo", FILEDI_1)
 HANDLES(FILEDI_1, "get_marshal_info", ves_icall_System_Reflection_FieldInfo_get_marshal_info, MonoReflectionMarshalAsAttribute, 1, (MonoReflectionField))
 HANDLES(FILEDI_2, "internal_from_handle_type", ves_icall_System_Reflection_FieldInfo_internal_from_handle_type, MonoReflectionField, 2, (MonoClassField_ref, MonoType_ref))
 
-#ifdef ENABLE_METADATA_UPDATE
-ICALL_TYPE(ASSMEXT, "System.Reflection.Metadata.AssemblyExtensions", ASSMEXT_1)
+ICALL_TYPE(ASSMEXT, "System.Reflection.Metadata.AssemblyExtensions", ASSMEXT_2)
+NOHANDLES(ICALL(ASSMEXT_2, "ApplyUpdateEnabled", ves_icall_AssemblyExtensions_ApplyUpdateEnabled))
 NOHANDLES(ICALL(ASSMEXT_1, "ApplyUpdate_internal", ves_icall_AssemblyExtensions_ApplyUpdate))
-#endif
 
 ICALL_TYPE(MBASE, "System.Reflection.MethodBase", MBASE_1)
 HANDLES(MBASE_1, "GetCurrentMethod", ves_icall_GetCurrentMethod, MonoReflectionMethod, 0, ())
diff --git a/src/mono/mono/metadata/icall.c b/src/mono/mono/metadata/icall.c
index cddaa2171f12f5..014b69b043334c 100644
--- a/src/mono/mono/metadata/icall.c
+++ b/src/mono/mono/metadata/icall.c
@@ -56,6 +56,7 @@
 #include <mono/metadata/mono-endian.h>
 #include <mono/metadata/tokentype.h>
 #include <mono/metadata/metadata-internals.h>
+#include <mono/metadata/metadata-update.h>
 #include <mono/metadata/class-internals.h>
 #include <mono/metadata/class-init.h>
 #include <mono/metadata/reflection-internals.h>
@@ -2525,6 +2526,23 @@ ves_icall_RuntimeType_GetInterfaces (MonoReflectionTypeHandle ref_type, MonoErro
 	return NULL_HANDLE_ARRAY;
 }
 
+static gboolean
+method_is_reabstracted (MonoMethod *method)
+{
+	/* only on interfaces */
+	/* method is marked "final abstract" */
+	/* FIXME: we need some other way to detect reabstracted methods.  "final" is an incidental detail of the spec. */
+	return m_method_is_final (method) && m_method_is_abstract (method);
+}
+
+static gboolean
+method_is_dim (MonoMethod *method)
+{
+	/* only valid on interface methods*/
+	/* method is marked "virtual" but not "virtual abstract" */
+	return m_method_is_virtual (method) && !m_method_is_abstract (method);
+}
+
 static gboolean
 set_interface_map_data_method_object (MonoMethod *method, MonoClass *iclass, int ioffset, MonoClass *klass, MonoArrayHandle targets, MonoArrayHandle methods, int i, MonoError *error)
 {
@@ -2558,9 +2576,25 @@ set_interface_map_data_method_object (MonoMethod *method, MonoClass *iclass, int
 		}
 	}
 
-	if (foundMethod->flags & METHOD_ATTRIBUTE_ABSTRACT)
+	/*
+	 * if the iterface method is reabstracted, and either the found implementation method is abstract, or the found
+	 * implementation method is from another DIM (meaning neither klass nor any of its ancestor classes implemented
+	 * the method), then say the target method is null.
+	 */
+	if (method_is_reabstracted (method) &&
+	    (m_method_is_abstract (foundMethod) ||
+	     (mono_class_is_interface (foundMethod->klass) && method_is_dim (foundMethod))))
 		MONO_HANDLE_ARRAY_SETREF (targets, i, NULL_HANDLE);
-	else {
+	else if (mono_class_is_interface (foundMethod->klass) && method_is_reabstracted (foundMethod) && !m_class_is_abstract (klass)) {
+		/* if the method we found is a reabstracted DIM method, but the class isn't abstract, return NULL */
+		/*
+		 * (C# doesn't seem to allow constructing such types, it requires the whole class to be abstract - in
+		 * which case we are supposed to return the reabstracted interface method.  But in IL we can make a
+		 * non-abstract class with reabstracted interface methods - which is supposed to fail with an
+		 * EntryPointNotFoundException at invoke time, but does not prevent the class from loading.)
+		 */
+		MONO_HANDLE_ARRAY_SETREF (targets, i, NULL_HANDLE);
+	} else {
 		MONO_HANDLE_ASSIGN (member, mono_method_get_object_handle (foundMethod, mono_class_is_interface (foundMethod->klass) ? foundMethod->klass : klass, error));
 		goto_if_nok (error, leave);
 		MONO_HANDLE_ARRAY_SETREF (targets, i, member);
@@ -5736,7 +5770,6 @@ ves_icall_Mono_Runtime_DumpStateTotal (guint64 *portable_hash, guint64 *unportab
 	return result;
 }
 
-#ifdef ENABLE_METADATA_UPDATE
 void
 ves_icall_AssemblyExtensions_ApplyUpdate (MonoAssembly *assm,
 					   gconstpointer dmeta_bytes, int32_t dmeta_len,
@@ -5753,7 +5786,11 @@ ves_icall_AssemblyExtensions_ApplyUpdate (MonoAssembly *assm,
 	mono_image_load_enc_delta (image_base, dmeta_bytes, dmeta_len, dil_bytes, dil_len, error);
 	mono_error_set_pending_exception (error);
 }
-#endif
+
+gint32 ves_icall_AssemblyExtensions_ApplyUpdateEnabled (void)
+{
+        return mono_metadata_update_available ();
+}
 
 MonoBoolean
 ves_icall_System_Reflection_AssemblyName_ParseAssemblyName (const char *name, MonoAssemblyName *aname, MonoBoolean *is_version_defined_arg, MonoBoolean *is_token_defined_arg)
@@ -6631,7 +6668,7 @@ ves_icall_System_Environment_get_TickCount64 (void)
 gpointer
 ves_icall_RuntimeMethodHandle_GetFunctionPointer (MonoMethod *method, MonoError *error)
 {
-	return mono_compile_method_checked (method, error);
+	return mono_get_runtime_callbacks ()->get_ftnptr (method, error);
 }
 
 MonoBoolean
diff --git a/src/mono/mono/metadata/image.c b/src/mono/mono/metadata/image.c
index 182f35cd96f8a4..68b7b377266ce4 100644
--- a/src/mono/mono/metadata/image.c
+++ b/src/mono/mono/metadata/image.c
@@ -599,14 +599,12 @@ load_tables (MonoImage *image)
 	image->idx_guid_wide   = ((heap_sizes & 0x02) == 2);
 	image->idx_blob_wide   = ((heap_sizes & 0x04) == 4);
 
-#ifdef ENABLE_METADATA_UPDATE
 	if (G_UNLIKELY (image->minimal_delta)) {
 		/* sanity check */
 		g_assert (image->idx_string_wide);
 		g_assert (image->idx_guid_wide);
 		g_assert (image->idx_blob_wide);
 	}
-#endif
 	
 	valid_mask = read64 (heap_tables + 8);
 	rows = (const guint32 *) (heap_tables + 24);
@@ -1174,7 +1172,6 @@ hash_guid (const char *str)
 	return h;
 }
 
-#ifdef ENABLE_METADATA_UPDATE
 static void
 dump_encmap (MonoImage *image)
 {
@@ -1192,7 +1189,6 @@ dump_encmap (MonoImage *image)
 		}
 	}
 }
-#endif
 
 static MonoImage *
 do_mono_image_load (MonoImage *image, MonoImageOpenStatus *status,
@@ -1238,9 +1234,7 @@ do_mono_image_load (MonoImage *image, MonoImageOpenStatus *status,
 	if (!mono_image_load_cli_data (image))
 		goto invalid_image;
 
-#ifdef ENABLE_METADATA_UPDATE
 	dump_encmap (image);
-#endif
 
 	mono_image_load_names (image);
 
@@ -2114,20 +2108,6 @@ mono_image_close_except_pools_all (MonoImage**images, int image_count)
 	}
 }
 
-#ifdef ENABLE_METADATA_UPDATE
-static void
-mono_image_close_except_pools_all_list (GList *images)
-{
-	for (GList *ptr = images; ptr; ptr = ptr->next) {
-		MonoImage *image = (MonoImage *)ptr->data;
-		if (image) {
-			if (!mono_image_close_except_pools (image))
-			    ptr->data = NULL;
-		}
-	}
-}
-#endif
-
 /*
  * Returns whether mono_image_close_finish() must be called as well.
  * We must unload images in two steps because clearing the domain in
@@ -2165,9 +2145,7 @@ mono_image_close_except_pools (MonoImage *image)
 
 	mono_image_invoke_unload_hook (image);
 
-#ifdef ENABLE_METADATA_UPDATE
 	mono_metadata_update_cleanup_on_close (image);
-#endif
 
 	/*
 	 * The caches inside a MonoImage might refer to metadata which is stored in referenced 
@@ -2287,10 +2265,8 @@ mono_image_close_except_pools (MonoImage *image)
 	mono_image_close_except_pools_all (image->modules, image->module_count);
 	g_free (image->modules_loaded);
 
-#ifdef ENABLE_METADATA_UPDATE
-	if (image->delta_image)
-		mono_image_close_except_pools_all_list (image->delta_image);
-#endif
+	if (image->has_updates)
+		mono_metadata_update_image_close_except_pools_all (image);
 
 	mono_os_mutex_destroy (&image->szarray_cache_lock);
 	mono_os_mutex_destroy (&image->lock);
@@ -2318,20 +2294,6 @@ mono_image_close_all (MonoImage**images, int image_count)
 		g_free (images);
 }
 
-#ifdef ENABLE_METADATA_UPDATE
-static void
-mono_image_close_all_list (GList *images)
-{
-	for (GList *ptr = images; ptr; ptr = ptr->next) {
-		MonoImage *image = (MonoImage *)ptr->data;
-		if (image)
-			mono_image_close_finish (image);
-	}
-
-	g_list_free (images);
-}
-#endif
-
 void
 mono_image_close_finish (MonoImage *image)
 {
@@ -2350,9 +2312,7 @@ mono_image_close_finish (MonoImage *image)
 	mono_image_close_all (image->files, image->file_count);
 	mono_image_close_all (image->modules, image->module_count);
 
-#ifdef ENABLE_METADATA_UPDATE
-	mono_image_close_all_list (image->delta_image);
-#endif
+	mono_metadata_update_image_close_all (image);
 
 #ifndef DISABLE_PERFCOUNTERS
 	/* FIXME: use an explicit subtraction method as soon as it's available */
diff --git a/src/mono/mono/metadata/loader-internals.h b/src/mono/mono/metadata/loader-internals.h
index f55fdbc69fe16a..a317db69785468 100644
--- a/src/mono/mono/metadata/loader-internals.h
+++ b/src/mono/mono/metadata/loader-internals.h
@@ -254,6 +254,7 @@ mono_alc_invoke_resolve_using_resolving_event_nofail (MonoAssemblyLoadContext *a
 MonoAssembly*
 mono_alc_invoke_resolve_using_resolve_satellite_nofail (MonoAssemblyLoadContext *alc, MonoAssemblyName *aname);
 
+MONO_COMPONENT_API
 MonoAssemblyLoadContext *
 mono_alc_get_default (void);
 
@@ -301,6 +302,7 @@ mono_mem_manager_lock (MonoMemoryManager *memory_manager);
 void
 mono_mem_manager_unlock (MonoMemoryManager *memory_manager);
 
+MONO_COMPONENT_API
 void *
 mono_mem_manager_alloc (MonoMemoryManager *memory_manager, guint size);
 
diff --git a/src/mono/mono/metadata/loader.c b/src/mono/mono/metadata/loader.c
index d58494d032f9c2..f16c8c36f81471 100644
--- a/src/mono/mono/metadata/loader.c
+++ b/src/mono/mono/metadata/loader.c
@@ -1981,36 +1981,6 @@ mono_method_has_no_body (MonoMethod *method)
 		(method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL));
 }
 
-#ifdef ENABLE_METADATA_UPDATE
-static gpointer
-get_method_update_rva (MonoImage *image_base, uint32_t idx)
-{
-	gpointer loc = NULL;
-	uint32_t cur = mono_metadata_update_get_thread_generation ();
-	int generation = -1;
-	GList *ptr = image_base->delta_image;
-	/* Go through all the updates that the current thread can see and see
-	 * if they updated the method.  Keep the latest visible update */
-	for (; ptr != NULL; ptr = ptr->next) {
-		MonoImage *image_delta = (MonoImage*) ptr->data;
-		if (image_delta->generation > cur)
-			break;
-		if (image_delta->method_table_update) {
-			gpointer result = g_hash_table_lookup (image_delta->method_table_update, GUINT_TO_POINTER (idx));
-			/* if it's not in the table of a later generation, the
-			 * later generation didn't modify the method
-			 */
-			if (result != NULL) {
-				loc = result;
-				generation = image_delta->generation;
-			}
-		}
-	}
-	mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "method lookup idx=0x%08x returned gen=%d il=%p", idx, generation, loc);
-	return loc;
-}
-#endif
-
 // FIXME Replace all internal callers of mono_method_get_header_checked with
 // mono_method_get_header_internal; the difference is in error initialization.
 MonoMethodHeader*
@@ -2065,16 +2035,8 @@ mono_method_get_header_internal (MonoMethod *method, MonoError *error)
 	g_assert (mono_metadata_token_table (method->token) == MONO_TABLE_METHOD);
 	idx = mono_metadata_token_index (method->token);
 
-#ifdef ENABLE_METADATA_UPDATE
-	/* EnC case */
-	if (G_UNLIKELY (img->method_table_update)) {
-		/* pre-computed rva pointer into delta IL image */
-		uint32_t gen = GPOINTER_TO_UINT (g_hash_table_lookup (img->method_table_update, GUINT_TO_POINTER (idx)));
-		if (G_UNLIKELY (gen > 0)) {
-			loc = get_method_update_rva (img, idx);
-		}
-	}
-#endif
+        if (G_UNLIKELY (img->has_updates))
+                loc = mono_metadata_update_get_updated_method_rva (img, idx);
 
 	if (!loc) {
 		rva = mono_metadata_decode_row_col (&img->tables [MONO_TABLE_METHOD], idx - 1, MONO_METHOD_RVA);
diff --git a/src/mono/mono/metadata/marshal-ilgen.c b/src/mono/mono/metadata/marshal-ilgen.c
index 05b749ebfd89e0..7d8e9f0743b529 100644
--- a/src/mono/mono/metadata/marshal-ilgen.c
+++ b/src/mono/mono/metadata/marshal-ilgen.c
@@ -1337,6 +1337,7 @@ emit_thread_interrupt_checkpoint_call (MonoMethodBuilder *mb, MonoJitICallId che
 
 	mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
 	mono_mb_emit_byte (mb, CEE_MONO_LDPTR_INT_REQ_FLAG);
+	mono_mb_emit_no_nullcheck (mb);
 	mono_mb_emit_byte (mb, CEE_LDIND_U4);
 	pos_noabort = mono_mb_emit_branch (mb, CEE_BRFALSE);
 
@@ -1351,6 +1352,7 @@ emit_thread_interrupt_checkpoint_call (MonoMethodBuilder *mb, MonoJitICallId che
 	mono_mb_emit_byte (mb, CEE_DUP);
 	mono_mb_emit_ldflda (mb, MONO_STRUCT_OFFSET (MonoException, caught_in_unmanaged));
 	mono_mb_emit_byte (mb, CEE_LDC_I4_1);
+	mono_mb_emit_no_nullcheck (mb);
 	mono_mb_emit_byte (mb, CEE_STIND_I4);
 
 	mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
@@ -1572,7 +1574,9 @@ emit_invoke_call (MonoMethodBuilder *mb, MonoMethod *method,
 		case MONO_TYPE_R8:
 		case MONO_TYPE_I8:
 		case MONO_TYPE_U8:
+			mono_mb_emit_no_nullcheck (mb);
 			mono_mb_emit_byte (mb, CEE_LDIND_I);
+			mono_mb_emit_no_nullcheck (mb);
 			mono_mb_emit_byte (mb, mono_type_to_ldind (sig->params [i]));
 			break;
 		case MONO_TYPE_STRING:
@@ -1582,10 +1586,12 @@ emit_invoke_call (MonoMethodBuilder *mb, MonoMethod *method,
 		case MONO_TYPE_FNPTR:
 		case MONO_TYPE_SZARRAY:
 		case MONO_TYPE_OBJECT:
+			mono_mb_emit_no_nullcheck (mb);
 			mono_mb_emit_byte (mb, mono_type_to_ldind (sig->params [i]));
 			break;
 		case MONO_TYPE_GENERICINST:
 			if (!mono_type_generic_inst_is_valuetype (sig->params [i])) {
+				mono_mb_emit_no_nullcheck (mb);
 				mono_mb_emit_byte (mb, mono_type_to_ldind (sig->params [i]));
 				break;
 			}
@@ -1598,6 +1604,7 @@ emit_invoke_call (MonoMethodBuilder *mb, MonoMethod *method,
 				type = mono_class_enum_basetype_internal (t->data.klass)->type;
 				goto handle_enum;
 			}
+			mono_mb_emit_no_nullcheck (mb);
 			mono_mb_emit_byte (mb, CEE_LDIND_I);
 			if (mono_class_is_nullable (mono_class_from_mono_type_internal (sig->params [i]))) {
 				/* Need to convert a boxed vtype to an mp to a Nullable struct */
diff --git a/src/mono/mono/metadata/metadata-internals.h b/src/mono/mono/metadata/metadata-internals.h
index 1fb28e385cb26e..a3f56cf1f84b1c 100644
--- a/src/mono/mono/metadata/metadata-internals.h
+++ b/src/mono/mono/metadata/metadata-internals.h
@@ -522,22 +522,8 @@ struct _MonoImage {
 	/* Contains 1 based indexes */
 	GHashTable *weak_field_indexes;
 
-#ifdef ENABLE_METADATA_UPDATE
-	/* List of MonoImages of deltas.  Parent image owns 1 refcount ref of the delta image */
-	GList *delta_image;
-	/* Tail of delta_image for fast appends */
-	GList *delta_image_last;
-
-	/* Metadata delta images only */
-	uint32_t generation; /* global update ID that added this delta image */
-
-	/* Maps MethodDef token indices to something. In base images a boolean
-	 * flag that there's an update for the method; in delta images a
-	 * pointer into the RVA of the delta IL */
-	GHashTable *method_table_update;
-
-
-#endif
+        /* baseline images only: whether any metadata updates have been applied to this image */
+        gboolean has_updates;
 
 	/*
 	 * No other runtime locks must be taken while holding this lock.
@@ -762,9 +748,11 @@ mono_g_list_prepend_image (MonoImage *image, GList *list, gpointer data);
 GSList*
 mono_g_slist_append_image (MonoImage *image, GSList *list, gpointer data);
 
+MONO_COMPONENT_API
 void
 mono_image_lock (MonoImage *image);
 
+MONO_COMPONENT_API
 void
 mono_image_unlock (MonoImage *image);
 
@@ -777,9 +765,11 @@ mono_image_property_insert (MonoImage *image, gpointer subject, guint32 property
 void
 mono_image_property_remove (MonoImage *image, gpointer subject);
 
+MONO_COMPONENT_API
 gboolean
 mono_image_close_except_pools (MonoImage *image);
 
+MONO_COMPONENT_API
 void
 mono_image_close_finish (MonoImage *image);
 
@@ -797,25 +787,19 @@ mono_install_image_loader (const MonoImageLoader *loader);
 void
 mono_image_append_class_to_reflection_info_set (MonoClass *klass);
 
-#ifndef ENABLE_METADATA_UPDATE
-static inline gboolean
-mono_metadata_has_updates (void)
-{
-	return FALSE;
-}
+typedef struct _MonoMetadataUpdateData MonoMetadataUpdateData;
 
-static inline void
-mono_image_effective_table (const MonoTableInfo **t, int *idx)
-{
-}
-#else /* ENABLE_METADATA_UPDATE */
-extern int mono_metadata_update_has_updates_private;
+struct _MonoMetadataUpdateData {
+	int has_updates;
+};
+
+extern MonoMetadataUpdateData mono_metadata_update_data_private;
 
 /* returns TRUE if there's at least one update */
 static inline gboolean
 mono_metadata_has_updates (void)
 {
-	return mono_metadata_update_has_updates_private != 0;
+	return mono_metadata_update_data_private.has_updates != 0;
 }
 
 void
@@ -836,7 +820,6 @@ mono_image_relative_delta_index (MonoImage *image_dmeta, int token);
 
 void
 mono_image_load_enc_delta (MonoImage *base_image, gconstpointer dmeta, uint32_t dmeta_len, gconstpointer dil, uint32_t dil_len, MonoError *error);
-#endif /* ENABLE_METADATA_UPDATE */
 
 gboolean
 mono_image_load_cli_header (MonoImage *image, MonoCLIImageInfo *iinfo);
@@ -853,6 +836,10 @@ mono_metadata_blob_heap_checked (MonoImage *meta, uint32_t table_index, MonoErro
 gboolean
 mono_metadata_decode_row_checked (const MonoImage *image, const MonoTableInfo *t, int idx, uint32_t *res, int res_size, MonoError *error);
 
+MONO_COMPONENT_API
+void
+mono_metadata_decode_row_raw (const MonoTableInfo *t, int idx, uint32_t *res, int res_size);
+
 gboolean
 mono_metadata_decode_row_dynamic_checked (const MonoDynamicImage *image, const MonoDynamicTable *t, int idx, guint32 *res, int res_size, MonoError *error);
 
@@ -862,14 +849,6 @@ mono_metadata_get_shared_type (MonoType *type);
 void
 mono_metadata_clean_generic_classes_for_image (MonoImage *image);
 
-#ifndef ENABLE_METADATA_UPDATE
-static inline gboolean
-mono_metadata_table_bounds_check (MonoImage *image, int table_index, int token_index)
-{
-	/* token_index is 1-based. TRUE means the token is out of bounds */
-	return token_index > image->tables [table_index].rows_;
-}
-#else
 gboolean
 mono_metadata_table_bounds_check_slow (MonoImage *image, int table_index, int token_index);
 
@@ -880,10 +859,12 @@ mono_metadata_table_bounds_check (MonoImage *image, int table_index, int token_i
 	/* returns true if given index is not in bounds with provided table/index pair */
 	if (G_LIKELY (token_index <= table_info_get_rows (&image->tables [table_index])))
 		return FALSE;
+        if (G_LIKELY (!image->has_updates))
+                return TRUE;
 	return mono_metadata_table_bounds_check_slow (image, table_index, token_index);
 }
-#endif
 
+MONO_COMPONENT_API
 const char *   mono_meta_table_name              (int table);
 void           mono_metadata_compute_table_bases (MonoImage *meta);
 
@@ -1051,6 +1032,7 @@ MonoImage *mono_image_open_raw (MonoAssemblyLoadContext *alc, const char *fname,
 
 MonoImage *mono_image_open_metadata_only (MonoAssemblyLoadContext *alc, const char *fname, MonoImageOpenStatus *status);
 
+MONO_COMPONENT_API
 MonoImage *mono_image_open_from_data_internal (MonoAssemblyLoadContext *alc, char *data, guint32 data_len, gboolean need_copy, MonoImageOpenStatus *status, gboolean metadata_only, const char *name, const char *filename);
 
 MonoException *mono_get_exception_field_access_msg (const char *msg);
diff --git a/src/mono/mono/metadata/metadata-update.c b/src/mono/mono/metadata/metadata-update.c
index 21797dae123bf7..d1d646c49ba25b 100644
--- a/src/mono/mono/metadata/metadata-update.c
+++ b/src/mono/mono/metadata/metadata-update.c
@@ -10,1153 +10,114 @@
 #include <config.h>
 #include "mono/utils/mono-compiler.h"
 
-#ifdef ENABLE_METADATA_UPDATE
-
-#include <glib.h>
-#include "mono/metadata/assembly-internals.h"
-#include "mono/metadata/metadata-internals.h"
 #include "mono/metadata/metadata-update.h"
-#include "mono/metadata/object-internals.h"
-#include "mono/metadata/tokentype.h"
-#include "mono/utils/mono-coop-mutex.h"
-#include "mono/utils/mono-error-internals.h"
-#include "mono/utils/mono-lazy-init.h"
-#include "mono/utils/mono-logger-internals.h"
-#include "mono/utils/mono-path.h"
-
-/* TLS value is a uint32_t of the latest published generation that the thread can see */
-static MonoNativeTlsKey exposed_generation_id;
-
-#if 1
-#define UPDATE_DEBUG(stmt) do { stmt; } while (0)
-#else
-#define UPDATE_DEBUG(stmt) /*empty */
-#endif
-
-/*
- * set to non-zero if at least one update has been published.
- */
-int mono_metadata_update_has_updates_private;
-
-/* For each delta image, for each table:
- * - the total logical number of rows for the previous generation
- * - the number of modified rows in the current generation
- * - the number of inserted rows in the current generation
- *
- * In each delta, the physical tables contain the rows that modify existing rows of a prior generation,
- * followed by inserted rows.
- * https://github.com/dotnet/runtime/blob/6072e4d3a7a2a1493f514cdf4be75a3d56580e84/src/libraries/System.Reflection.Metadata/src/System/Reflection/Metadata/Ecma335/MetadataAggregator.cs#L324
- * 
- * The total logical number of rows in a table for a particular generation is
- *    prev_gen_rows + inserted_rows.
- */
-typedef struct _delta_row_count {
-	guint32 prev_gen_rows;
-	guint32 modified_rows;
-	guint32 inserted_rows; 
-} delta_row_count;
-
-typedef struct _DeltaInfo {
-	// for each table, the row in the EncMap table that has the first token for remapping it?
-	uint32_t enc_recs [MONO_TABLE_NUM];
-	delta_row_count count [MONO_TABLE_NUM];
-} DeltaInfo;
-
-
-#define DOTNET_MODIFIABLE_ASSEMBLIES "DOTNET_MODIFIABLE_ASSEMBLIES"
-
-/**
- * mono_metadata_update_enable:
- * \param modifiable_assemblies_out: set to MonoModifiableAssemblies value
- *
- * Returns \c TRUE if metadata updates are enabled at runtime.  False otherwise.
- *
- * If \p modifiable_assemblies_out is not \c NULL, it's set on return.
- *
- * The result depends on the value of the DOTNET_MODIFIABLE_ASSEMBLIES
- * environment variable.  "debug" means debuggable assemblies are modifiable,
- * all other values are ignored and metadata updates are disabled.
- */
-gboolean
-mono_metadata_update_enabled (int *modifiable_assemblies_out)
-{
-	static gboolean inited = FALSE;
-	static int modifiable = MONO_MODIFIABLE_ASSM_NONE;
+#include "mono/metadata/components.h"
+#include "mono/component/hot_reload.h"
 
-	if (!inited) {
-		char *val = g_getenv (DOTNET_MODIFIABLE_ASSEMBLIES);
-		if (val && !g_strcasecmp (val, "debug")) {
-			mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "Metadata update enabled for debuggable assemblies");
-			modifiable = MONO_MODIFIABLE_ASSM_DEBUG;
-		}
-		g_free (val);
-		inited = TRUE;
-	}
-	if (modifiable_assemblies_out)
-		*modifiable_assemblies_out = modifiable;
-	return modifiable != MONO_MODIFIABLE_ASSM_NONE;
-}
-
-static gboolean
-assembly_update_supported (MonoAssembly *assm)
-{
-	int modifiable = 0;
-	if (!mono_metadata_update_enabled (&modifiable))
-		return FALSE;
-	if (modifiable == MONO_MODIFIABLE_ASSM_DEBUG &&
-	    mono_assembly_is_jit_optimizer_disabled (assm))
-		return TRUE;
-	return FALSE;
-}
-
-/**
- * mono_metadata_update_no_inline:
- * \param caller: the calling method
- * \param callee: the method being called
- *
- * Returns \c TRUE if \p callee should not be inlined into \p caller.
- *
- * If metadata updates are enabled either for the caller or callee's module,
- * the callee should not be inlined.
- *
- */
 gboolean
-mono_metadata_update_no_inline (MonoMethod *caller, MonoMethod *callee)
-{
-	if (!mono_metadata_update_enabled (NULL))
-		return FALSE;
-	MonoAssembly *caller_assm = m_class_get_image(caller->klass)->assembly;
-	MonoAssembly *callee_assm = m_class_get_image(callee->klass)->assembly;
-	return mono_assembly_is_jit_optimizer_disabled (caller_assm) || mono_assembly_is_jit_optimizer_disabled (callee_assm);
-}
-
-static void
-mono_metadata_update_ee_init (MonoError *error);
-
-/* Maps each MonoTableInfo* to the MonoImage that it belongs to.  This is
- * mapping the base image MonoTableInfos to the base MonoImage.  We don't need
- * this for deltas.
- */
-static GHashTable *table_to_image, *delta_image_to_info;
-/* Low-level lock to protects table_to_image and delta_image_to_info */
-/* FIXME: use concurrent hash tables so that readers don't have to lock. */
-static MonoCoopMutex table_to_image_mutex;
-
-static void
-table_to_image_lock (void)
-{
-	mono_coop_mutex_lock (&table_to_image_mutex);
-}
-
-static void
-table_to_image_unlock (void)
-{
-	mono_coop_mutex_unlock (&table_to_image_mutex);
-}
-
-
-static void
-delta_info_destroy (DeltaInfo *dinfo)
-{
-	g_free (dinfo);
-}
-
-static DeltaInfo *
-delta_info_lookup_locked (MonoImage *delta_image)
-{
-	return (DeltaInfo*)g_hash_table_lookup (delta_image_to_info, delta_image);
-}
-
-static DeltaInfo *
-delta_info_lookup (MonoImage *delta_image)
-{
-	DeltaInfo *result;
-	table_to_image_lock ();
-	result = delta_info_lookup_locked (delta_image);
-	table_to_image_unlock ();
-	return result;
-}
-
-static void
-table_to_image_init (void)
-{
-	mono_coop_mutex_init (&table_to_image_mutex);
-	table_to_image = g_hash_table_new (NULL, NULL);
-	delta_image_to_info = g_hash_table_new (NULL, NULL);
-}
-
-static gboolean
-remove_base_image (gpointer key, gpointer value, gpointer user_data)
-{
-	MonoImage *base_image = (MonoImage*)user_data;
-	MonoImage *value_image = (MonoImage*)value;
-	return (value_image == base_image);
-}
-
-void
-mono_metadata_update_cleanup_on_close (MonoImage *image)
-{
-	table_to_image_lock ();
-	/* remove all keys (delta images) that map to the given image (base image) */
-	g_hash_table_foreach_remove (table_to_image, remove_base_image, (gpointer)image);
-	/* remove delta image info */
-	DeltaInfo *delta_info = delta_info_lookup_locked (image);
-	if (delta_info) {
-		g_hash_table_remove (delta_image_to_info, image);
-		delta_info_destroy (delta_info);
-	}
-	table_to_image_unlock ();
-}
-
-static void
-table_to_image_add (MonoImage *base_image)
-{
-	/* If at least one table from this image is already here, they all are */
-	if (g_hash_table_contains (table_to_image, &base_image->tables[MONO_TABLE_MODULE]))
-		return;
-	table_to_image_lock ();
-	if (g_hash_table_contains (table_to_image, &base_image->tables[MONO_TABLE_MODULE])) {
-	        table_to_image_unlock ();
-		return;
-	}
-	for (int idx = 0; idx < MONO_TABLE_NUM; ++idx) {
-		MonoTableInfo *table = &base_image->tables[idx];
-		g_hash_table_insert (table_to_image, table, base_image);
-	}
-	table_to_image_unlock ();
-}
-
-MonoImage *
-mono_table_info_get_base_image (const MonoTableInfo *t)
+mono_metadata_update_available (void)
 {
-	MonoImage *image = (MonoImage *) g_hash_table_lookup (table_to_image, t);
-	return image;
+        return mono_component_hot_reload ()->component.available ();
 }
 
-static MonoImage*
-mono_image_open_dmeta_from_data (MonoImage *base_image, uint32_t generation, gconstpointer dmeta_bytes, uint32_t dmeta_length, MonoImageOpenStatus *status);
-
-static void
-mono_image_append_delta (MonoImage *base, MonoImage *delta);
-
-static int
-metadata_update_local_generation (MonoImage *base, MonoImage *delta);
+MonoMetadataUpdateData mono_metadata_update_data_private;
 
 void
 mono_metadata_update_init (void)
 {
-	mono_metadata_update_has_updates_private = 0;
-	table_to_image_init ();
-	mono_native_tls_alloc (&exposed_generation_id, NULL);
-}
-
-/* Inform the execution engine that updates are coming */
-static void
-mono_metadata_update_ee_init (MonoError *error)
-{
-	static gboolean inited = FALSE;
-
-	if (inited)
-		return;
-	if (mono_get_runtime_callbacks ()->metadata_update_init)
-		mono_get_runtime_callbacks ()->metadata_update_init (error);
-	inited = TRUE;
-}
-
-static
-void
-mono_metadata_update_invoke_hook (MonoAssemblyLoadContext *alc, uint32_t generation)
-{
-	if (mono_get_runtime_callbacks ()->metadata_update_published)
-		mono_get_runtime_callbacks ()->metadata_update_published (alc, generation);
-}
-
-static uint32_t update_published, update_alloc_frontier;
-static MonoCoopMutex publish_mutex;
-
-static void
-publish_lock (void)
-{
-	mono_coop_mutex_lock (&publish_mutex);
-}
-
-static void
-publish_unlock (void)
-{
-	mono_coop_mutex_unlock (&publish_mutex);
-}
-
-static mono_lazy_init_t metadata_update_lazy_init;
-
-static void
-initialize (void)
-{
-	mono_coop_mutex_init (&publish_mutex);
-}
-
-static void
-thread_set_exposed_generation (uint32_t value)
-{
-	mono_native_tls_set_value (exposed_generation_id, GUINT_TO_POINTER((guint)value));
-}
-
-/**
- * LOCKING: assumes the publish_lock is held
- */
-static void
-metadata_update_set_has_updates (void)
-{
-	mono_metadata_update_has_updates_private = 1;
+	memset (&mono_metadata_update_data_private, 0, sizeof (mono_metadata_update_data_private));
+	MonoComponentHotReload *comp = mono_component_hot_reload ();
+	comp->set_fastpath_data (&mono_metadata_update_data_private);
 }
 
-uint32_t
-mono_metadata_update_prepare (void)
+gboolean
+mono_metadata_update_enabled (int *modifiable_assemblies_out)
 {
-	mono_lazy_initialize (&metadata_update_lazy_init, initialize);
-	/*
-	 * TODO: assert that the updater isn't depending on current metadata, else publishing might block.
-	 */
-	publish_lock ();
-	uint32_t alloc_gen = ++update_alloc_frontier;
-	/* Have to set this here so the updater starts using the slow path of metadata lookups */
-	metadata_update_set_has_updates ();
-	/* Expose the alloc frontier to the updater thread */
-	thread_set_exposed_generation (alloc_gen);
-	return alloc_gen;
+	return mono_component_hot_reload ()->update_enabled (modifiable_assemblies_out);
 }
 
 gboolean
-mono_metadata_update_available (void)
+mono_metadata_update_no_inline (MonoMethod *caller, MonoMethod *callee)
 {
-	return update_published < update_alloc_frontier;
+	return mono_component_hot_reload ()->no_inline (caller, callee);
 }
 
-/**
- * mono_metadata_update_thread_expose_published:
- *
- * Allow the current thread to see the latest published deltas.
- *
- * Returns the current published generation that the thread will see.
- */
 uint32_t
 mono_metadata_update_thread_expose_published (void)
 {
-	mono_memory_read_barrier ();
-	uint32_t thread_current_gen = update_published;
-	thread_set_exposed_generation (thread_current_gen);
-	return thread_current_gen;
+	return mono_component_hot_reload ()->thread_expose_published ();
 }
 
-/**
- * mono_metadata_update_get_thread_generation:
- *
- * Return the published generation that the current thread is allowed to see.
- * May be behind the latest published generation if the thread hasn't called
- * \c mono_metadata_update_thread_expose_published in a while.
- */
 uint32_t
 mono_metadata_update_get_thread_generation (void)
 {
-	return (uint32_t)GPOINTER_TO_UINT(mono_native_tls_get_value(exposed_generation_id));
-}
-
-gboolean
-mono_metadata_wait_for_update (uint32_t timeout_ms)
-{
-	/* TODO: give threads a way to voluntarily wait for an update to be published. */
-	g_assert_not_reached ();
+	return mono_component_hot_reload ()->get_thread_generation ();
 }
 
 void
-mono_metadata_update_publish (MonoAssemblyLoadContext *alc, uint32_t generation)
+mono_metadata_update_cleanup_on_close (MonoImage *base_image)
 {
-	g_assert (update_published < generation && generation <= update_alloc_frontier);
-	/* TODO: wait for all threads that are using old metadata to update. */
-	mono_metadata_update_invoke_hook (alc, generation);
-	update_published = update_alloc_frontier;
-	mono_memory_write_barrier ();
-	publish_unlock ();
-}
-
-void
-mono_metadata_update_cancel (uint32_t generation)
-{
-	g_assert (update_alloc_frontier == generation);
-	g_assert (update_alloc_frontier > 0);
-	g_assert (update_alloc_frontier - 1 >= update_published);
-	--update_alloc_frontier;
-	/* Roll back exposed generation to the last published one */
-	thread_set_exposed_generation (update_published);
-	publish_unlock ();
-}
-
-/**
- * LOCKING: Assumes the publish_lock is held
- */
-void
-mono_image_append_delta (MonoImage *base, MonoImage *delta)
-{
-	if (!base->delta_image) {
-		base->delta_image = base->delta_image_last = g_list_alloc ();
-		base->delta_image->data = (gpointer)delta;
-		return;
-	}
-	g_assert (((MonoImage*)base->delta_image_last->data)->generation < delta->generation);
-	/* g_list_append returns the given list, not the newly appended */
-	GList *l = g_list_append (base->delta_image_last, delta);
-	g_assert (l != NULL && l->next != NULL && l->next->next == NULL);
-	base->delta_image_last = l->next;
-}
-
-/**
- * LOCKING: assumes the publish_lock is held
- */
-MonoImage*
-mono_image_open_dmeta_from_data (MonoImage *base_image, uint32_t generation, gconstpointer dmeta_bytes, uint32_t dmeta_length, MonoImageOpenStatus *status)
-{
-	MonoAssemblyLoadContext *alc = mono_image_get_alc (base_image);
-	MonoImage *dmeta_image = mono_image_open_from_data_internal (alc, (char*)dmeta_bytes, dmeta_length, TRUE, status, TRUE, NULL, NULL);
-
-	dmeta_image->generation = generation;
-
-	/* base_image takes ownership of 1 refcount ref of dmeta_image */
-	mono_image_append_delta (base_image, dmeta_image);
-
-	return dmeta_image;
-}
-
-static gpointer
-open_dil_data (MonoImage *base_image G_GNUC_UNUSED, gconstpointer dil_src, uint32_t dil_length)
-{
-	/* TODO: find a better memory manager.  But this way we at least won't lose the IL data. */
-	MonoMemoryManager *mem_manager = (MonoMemoryManager *)mono_alc_get_default ()->memory_manager;
-
-	gpointer dil_copy = mono_mem_manager_alloc (mem_manager, dil_length);
-	memcpy (dil_copy, dil_src, dil_length);
-	return dil_copy;
-}
-
-static const char *
-scope_to_string (uint32_t tok)
-{
-	const char *scope;
-	switch (tok & MONO_RESOLUTION_SCOPE_MASK) {
-	case MONO_RESOLUTION_SCOPE_MODULE:
-		scope = ".";
-		break;
-	case MONO_RESOLUTION_SCOPE_MODULEREF:
-		scope = "M";
-		break;
-	case MONO_RESOLUTION_SCOPE_TYPEREF:
-		scope = "T";
-		break;
-	case MONO_RESOLUTION_SCOPE_ASSEMBLYREF:
-		scope = "A";
-		break;
-	default:
-		g_assert_not_reached ();
-	}
-	return scope;
-}
-
-static void
-dump_update_summary (MonoImage *image_base, MonoImage *image_dmeta)
-{
-	int rows;
-
-	mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "dmeta tables:");
-	for (int idx = 0; idx < MONO_TABLE_NUM; ++idx) {
-		if (image_dmeta->tables [idx].base)
-			mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "\t0x%02x \"%s\"", idx, mono_meta_table_name (idx));
-	}
-	mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "================================");
-
-	rows = mono_image_get_table_rows (image_base, MONO_TABLE_TYPEREF);
-	for (int i = 1; i <= rows; ++i) {
-		guint32 cols [MONO_TYPEREF_SIZE];
-		mono_metadata_decode_row (&image_base->tables [MONO_TABLE_TYPEREF], i - 1, cols, MONO_TYPEREF_SIZE);
-		const char *scope = scope_to_string (cols [MONO_TYPEREF_SCOPE]);
-		const char *name = mono_metadata_string_heap (image_base, cols [MONO_TYPEREF_NAME]);
-		const char *nspace = mono_metadata_string_heap (image_base, cols [MONO_TYPEREF_NAMESPACE]);
-
-		if (!name)
-			name = "<N/A>";
-		if (!nspace)
-			nspace = "<N/A>";
-
-		mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "base  typeref i=%d (token=0x%08x) -> scope=%s, namespace=%s, name=%s", i, MONO_TOKEN_TYPE_REF | i, scope, nspace, name);
-	}
-	if (!image_dmeta->minimal_delta) {
-		mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "--------------------------------");
-
-		rows = mono_image_get_table_rows (image_dmeta, MONO_TABLE_TYPEREF);
-		for (int i = 1; i <= rows; ++i) {
-			guint32 cols [MONO_TYPEREF_SIZE];
-			mono_metadata_decode_row (&image_dmeta->tables [MONO_TABLE_TYPEREF], i - 1, cols, MONO_TYPEREF_SIZE);
-			const char *scope = scope_to_string (cols [MONO_TYPEREF_SCOPE]);
-			const char *name = mono_metadata_string_heap (image_base, cols [MONO_TYPEREF_NAME]);
-			const char *nspace = mono_metadata_string_heap (image_base, cols [MONO_TYPEREF_NAMESPACE]);
-			mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "dmeta typeref i=%d (token=0x%08x) -> scope=%s, nspace=%s, name=%s", i, MONO_TOKEN_TYPE_REF | i, scope, nspace, name);
-		}
-	}
-	mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "================================");
-
-	rows = mono_image_get_table_rows (image_base, MONO_TABLE_METHOD);
-	for (int i = 1; i <= rows ; ++i) {
-		guint32 cols [MONO_METHOD_SIZE];
-		mono_metadata_decode_row_raw (&image_base->tables [MONO_TABLE_METHOD], i - 1, cols, MONO_METHOD_SIZE);
-		const char *name = mono_metadata_string_heap (image_base, cols [MONO_METHOD_NAME]);
-		guint32 rva = cols [MONO_METHOD_RVA];
-		mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "base  method i=%d (token=0x%08x), rva=%d/0x%04x, name=%s", i, MONO_TOKEN_METHOD_DEF | i, rva, rva, name);
-	}
-	mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "--------------------------------");
-
-	rows = mono_image_get_table_rows (image_dmeta, MONO_TABLE_METHOD);
-	for (int i = 1; i <= rows ; ++i) {
-		guint32 cols [MONO_METHOD_SIZE];
-		mono_metadata_decode_row_raw (&image_dmeta->tables [MONO_TABLE_METHOD], i - 1, cols, MONO_METHOD_SIZE);
-		const char *name = mono_metadata_string_heap (image_base, cols [MONO_METHOD_NAME]);
-		guint32 rva = cols [MONO_METHOD_RVA];
-		mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "dmeta method i=%d (token=0x%08x), rva=%d/0x%04x, name=%s", i, MONO_TOKEN_METHOD_DEF | i, rva, rva, name);
-	}
-	mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "================================");
-
-	rows = mono_image_get_table_rows (image_base, MONO_TABLE_STANDALONESIG);
-	for (int i = 1; i <= rows; ++i) {
-		guint32 cols [MONO_STAND_ALONE_SIGNATURE_SIZE];
-		mono_metadata_decode_row (&image_base->tables [MONO_TABLE_STANDALONESIG], i - 1, cols, MONO_STAND_ALONE_SIGNATURE_SIZE);
-		mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "base  standalonesig i=%d (token=0x%08x) -> 0x%08x", i, MONO_TOKEN_SIGNATURE | i, cols [MONO_STAND_ALONE_SIGNATURE]);
-	}
-
-	if (!image_dmeta->minimal_delta) {
-		mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "--------------------------------");
-
-		rows = mono_image_get_table_rows (image_dmeta, MONO_TABLE_STANDALONESIG);
-		for (int i = 1; i <= rows; ++i) {
-			guint32 cols [MONO_STAND_ALONE_SIGNATURE_SIZE];
-			mono_metadata_decode_row_raw (&image_dmeta->tables [MONO_TABLE_STANDALONESIG], i - 1, cols, MONO_STAND_ALONE_SIGNATURE_SIZE);
-			mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "dmeta standalonesig i=%d (token=0x%08x) -> 0x%08x", i, MONO_TOKEN_SIGNATURE | i, cols [MONO_STAND_ALONE_SIGNATURE]);
-		}
-	}
-	mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "================================");
-
+	mono_component_hot_reload ()->cleanup_on_close (base_image);
 }
 
 void
 mono_image_effective_table_slow (const MonoTableInfo **t, int *idx)
 {
-	if (G_LIKELY (*idx < table_info_get_rows (*t)))
-		return;
-
-	/* FIXME: don't let any thread other than the updater thread see values from a delta image
-	 * with a generation past update_published
-	 */
-
-	MonoImage *base = mono_table_info_get_base_image (*t);
-	if (!base || !base->delta_image)
-		return;
-
-	GList *list = base->delta_image;
-	MonoImage *dmeta;
-	int ridx;
-	MonoTableInfo *table;
-
-	/* Invariant: `*t` must be a `MonoTableInfo` of the base image. */
-	g_assert (base->tables < *t && *t < &base->tables [MONO_TABLE_LAST]);
-
-	size_t s = ALIGN_TO (sizeof (MonoTableInfo), sizeof (gpointer));
-	int tbl_index = ((intptr_t) *t - (intptr_t) base->tables) / s;
-
-	/* FIXME: I don't understand how ReplaceMethodOften works - it always has a 
-	 * EnCMap  entry 2: 0x06000002 (MethodDef) for every revision.  Shouldn't the number of methodDef rows be going up?
-
-	 * Apparently not - because conceptually the EnC log is saying to overwrite the existing rows.
-	 */
-
-	/* FIXME: so if the tables are conceptually mutated by each delta, we can't just stop at the
-	 * first lookup that gets a relative index in the right range, can we? that will always be
-	 * the oldest delta.
-	 */
-
-	/* FIXME: the other problem is that the EnClog is a sequence of actions to MUTATE rows.  So when looking up an existing row we have to be able to make it so that naive callers decoding that row see the updated data.
-	 *
-	 * That's the main thing that PAss1 should eb doing for us.
-	 *
-	 * I think we can't get away from mutating.  The format is just too geared toward it.
-	 *
-	 * We should make the mutations atomic, though.  (And I guess the heap extension is probably unavoidable)
-	 *
-	 * 1. Keep a table of inv
-	 */
-	int g = 0;
-
-	do {
-		g_assertf (list, "couldn't find idx=0x%08x in assembly=%s", *idx, dmeta && dmeta->name ? dmeta->name : "unknown image");
-		dmeta = (MonoImage*)list->data;
-		list = list->next;
-		table = &dmeta->tables [tbl_index];
-		ridx = mono_image_relative_delta_index (dmeta, mono_metadata_make_token (tbl_index, *idx + 1)) - 1;
-		g++;
-	} while (ridx < 0 || ridx >= table_info_get_rows (table));
-
-	mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "effective table for %s: 0x%08x -> 0x%08x (rows = 0x%08x) (gen %d, g %d)", mono_meta_table_name (tbl_index), *idx, ridx, table_info_get_rows (table), metadata_update_local_generation (base, dmeta), g);
-
-	*t = table;
-	*idx = ridx;
+	mono_component_hot_reload ()->effective_table_slow (t, idx);
 }
 
-/*
- * The ENCMAP table contains the base of the relative offset.
- *
- * Returns -1 if the token does not resolve in this generation's ENCMAP.
- *
- * Example:
- * Say you have a base image with a METHOD table having 5 entries.  The minimal
- * delta image adds another one, so it would be indexed with token
- * `MONO_TOKEN_METHOD_DEF | 6`. However, the minimal delta image only has this
- * single entry, and thus this would be an out-of-bounds access. That's where
- * the ENCMAP table comes into play: It will have an entry
- * `MONO_TOKEN_METHOD_DEF | 5`, so before accessing the new entry in the
- * minimal delta image, it has to be substracted. Thus the new relative index
- * is `1`, and no out-of-bounds acccess anymore.
- *
- * One can assume that ENCMAP is sorted (todo: verify this claim).
- *
- * BTW, `enc_recs` is just a pre-computed map to make the lookup for the
- * relative index faster.
- */
 int
 mono_image_relative_delta_index (MonoImage *image_dmeta, int token)
 {
-	MonoTableInfo *encmap = &image_dmeta->tables [MONO_TABLE_ENCMAP];
-	int table = mono_metadata_token_table (token);
-	int index = mono_metadata_token_index (token);
-
-	/* this helper expects and returns as "index origin = 1" */
-	g_assert (index > 0);
-
-	if (!table_info_get_rows (encmap) || !image_dmeta->minimal_delta)
-		return mono_metadata_token_index (token);
-
-	DeltaInfo *delta_info = delta_info_lookup (image_dmeta);
-	g_assert (delta_info);
-
-	int index_map = delta_info->enc_recs [table];
-	int encmap_rows = table_info_get_rows (encmap);
-
-	/* if the table didn't have any updates in this generation and the
-	 * table index is bigger than the last table that got updates,
-	 * enc_recs will point past the last row */
-	if (index_map - 1 == encmap_rows)
-		return -1;
-	guint32 cols[MONO_ENCMAP_SIZE];
-	mono_metadata_decode_row (encmap, index_map - 1, cols, MONO_ENCMAP_SIZE);
-	int map_entry = cols [MONO_ENCMAP_TOKEN];
-
-	while (mono_metadata_token_table (map_entry) == table && mono_metadata_token_index (map_entry) < index && index_map < encmap_rows) {
-		mono_metadata_decode_row (encmap, ++index_map - 1, cols, MONO_ENCMAP_SIZE);
-		map_entry = cols [MONO_ENCMAP_TOKEN];
-	}
-
-	if (mono_metadata_token_table (map_entry) == table) {
-		if (mono_metadata_token_index (map_entry) == index) {
-			/* token resolves to this generation */
-			int return_val = index_map - delta_info->enc_recs [table] + 1;
-			g_assert (return_val > 0 && return_val <= table_info_get_rows (&image_dmeta->tables[table]));
-			mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "relative index for token 0x%08x -> table 0x%02x row 0x%08x", token, table, return_val);
-			return return_val;
-		} else {
-			/* otherwise the last entry in the encmap is for this table, but is still less than the index - the index is in the next generation */
-			g_assert (mono_metadata_token_index (map_entry) < index && index_map == encmap_rows);
-			return -1;
-		}
-	} else {
-		/* otherwise there are no more encmap entries for this table, and we didn't see the index, so there index is in the next generation */
-		g_assert (mono_metadata_token_table (map_entry) > table);
-		return -1;
-	}
-}
-
-static DeltaInfo*
-delta_info_init (MonoImage *image_dmeta, MonoImage *image_base)
-{
-	MonoTableInfo *encmap = &image_dmeta->tables [MONO_TABLE_ENCMAP];
-	int table, prev_table = -1, idx;
-
-	g_assert (!delta_info_lookup (image_dmeta));
-
-	if (!table_info_get_rows (encmap))
-		return NULL;
-
-	DeltaInfo *delta_info = g_malloc0 (sizeof (DeltaInfo));
-
-	/*** Compute logical table sizes ***/
-	if (image_base->delta_image == image_base->delta_image_last) {
-		/* this is the first update. */
-		for (int i = 0; i < MONO_TABLE_NUM; ++i) {
-			delta_info->count[i].prev_gen_rows = table_info_get_rows (&image_base->tables[i]);
-		}
-	} else {
-		/* Current image_dmeta is image_base->delta_image_last->data,
-		 * find its predecessor
-		 */
-		MonoImage *prev_delta = NULL;
-		g_assert (image_base->delta_image_last->prev != NULL);
-		prev_delta = (MonoImage*)image_base->delta_image_last->prev->data;
-		DeltaInfo *prev_gen_info = delta_info_lookup (prev_delta);
-		for (int i = 0; i < MONO_TABLE_NUM; ++i) {
-			delta_info->count[i].prev_gen_rows = prev_gen_info->count[i].prev_gen_rows + prev_gen_info->count[i].inserted_rows;
-		}
-	}
-
-
-	/* TODO: while going through the tables, update delta_info->count[tbl].{modified,inserted}_rows */
-
-	int encmap_rows = table_info_get_rows (encmap);
-	for (idx = 1; idx <= encmap_rows; ++idx) {
-		guint32 cols[MONO_ENCMAP_SIZE];
-		mono_metadata_decode_row (encmap, idx - 1, cols, MONO_ENCMAP_SIZE);
-		uint32_t tok = cols [MONO_ENCMAP_TOKEN];
-		table = mono_metadata_token_table (tok);
-		uint32_t rid = mono_metadata_token_index (tok);
-		g_assert (table >= 0 && table < MONO_TABLE_NUM);
-		g_assert (table != MONO_TABLE_ENCLOG);
-		g_assert (table != MONO_TABLE_ENCMAP);
-		g_assert (table >= prev_table);
-		/* FIXME: check bounds - is it < or <=. */
-		if (rid < delta_info->count[table].prev_gen_rows)
-			delta_info->count[table].modified_rows++;
-		else
-			delta_info->count[table].inserted_rows++;
-		if (table == prev_table)
-			continue;
-		while (prev_table < table) {
-			prev_table++;
-			delta_info->enc_recs [prev_table] = idx;
-		}
-	}
-	g_assert (prev_table < MONO_TABLE_NUM - 1);
-	while (prev_table < MONO_TABLE_NUM - 1) {
-		prev_table++;
-		delta_info->enc_recs [prev_table] = idx;
-	}
-
-	if (mono_trace_is_traced (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE)) {
-		for (int i = 0 ; i < MONO_TABLE_NUM; ++i) {
-			if (!image_dmeta->tables [i].base)
-				continue;
-
-			mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "enc_recs [%02x] / %s = 0x%02x\t(inserted: %03d, modified: %03d)", i, mono_meta_table_name (i), delta_info->enc_recs[i], delta_info->count[i].inserted_rows, delta_info->count[i].modified_rows);
-		}
-	}
-
-	table_to_image_lock ();
-	g_hash_table_insert (delta_image_to_info, image_dmeta, delta_info);
-	table_to_image_unlock ();
-
-
-	return delta_info;
+	return mono_component_hot_reload ()->relative_delta_index (image_dmeta, token);
 }
 
-static const char*
-funccode_to_str (int func_code)
+void
+mono_image_load_enc_delta (MonoImage *base_image, gconstpointer dmeta, uint32_t dmeta_len, gconstpointer dil, uint32_t dil_len, MonoError *error)
 {
-	switch (func_code) {
-		case 0: return "Func default";
-		case 1: return "Method Create";
-		case 2: return "Field Create";
-		case 3: return "Param Create";
-		case 4: return "Property Create";
-		case 5: return "Event Create";
-		default: g_assert_not_reached ();
-	}
-	return NULL;
+	mono_component_hot_reload ()->apply_changes (base_image, dmeta, dmeta_len, dil, dil_len, error);
 }
 
-/* Run some sanity checks first. If we detect unsupported scenarios, this
- * function will fail and the metadata update should be aborted. This should
- * run before anything in the metadata world is updated. */
-static gboolean
-apply_enclog_pass1 (MonoImage *image_base, MonoImage *image_dmeta, gconstpointer dil_data, uint32_t dil_length, MonoError *error)
+static void
+mono_image_close_except_pools_all_list (GList *images)
 {
-	MonoTableInfo *table_enclog = &image_dmeta->tables [MONO_TABLE_ENCLOG];
-	int rows = table_info_get_rows (table_enclog);
-
-	gboolean unsupported_edits = FALSE;
-
-	/* hack: make a pass over it, looking only for table method updates, in
-	 * order to give more meaningful error messages first */
-
-	for (int i = 0; i < rows ; ++i) {
-		guint32 cols [MONO_ENCLOG_SIZE];
-		mono_metadata_decode_row (table_enclog, i, cols, MONO_ENCLOG_SIZE);
-
-		// FIXME: the top bit 0x8000000 of log_token is some kind of
-		// indicator see IsRecId in metamodelrw.cpp and
-		// MDInternalRW::EnumDeltaTokensInit which skips over those
-		// records when EditAndContinueModule::ApplyEditAndContinue is
-		// iterating.
-		int log_token = cols [MONO_ENCLOG_TOKEN];
-		int func_code = cols [MONO_ENCLOG_FUNC_CODE];
-
-		int token_table = mono_metadata_token_table (log_token);
-		int token_index = mono_metadata_token_index (log_token);
-
-		mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "row[0x%02x]:0x%08x (%s idx=0x%02x) (base table has 0x%04x rows)\tfunc=0x%02x\n", i, log_token, mono_meta_table_name (token_table), token_index, table_info_get_rows (&image_base->tables [token_table]), func_code);
-
-
-		if (token_table != MONO_TABLE_METHOD)
-			continue;
-
-		if (token_index > table_info_get_rows (&image_base->tables [token_table])) {
-			mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_METADATA_UPDATE, "\tcannot add new method with token 0x%08x", log_token);
-			mono_error_set_type_load_name (error, NULL, image_base->name, "EnC: cannot add new method with token 0x%08x", log_token);
-			unsupported_edits = TRUE;
-		}
-
-		g_assert (func_code == 0); /* anything else doesn't make sense here */
-	}
-
-	for (int i = 0; i < rows ; ++i) {
-		guint32 cols [MONO_ENCLOG_SIZE];
-		mono_metadata_decode_row (table_enclog, i, cols, MONO_ENCLOG_SIZE);
-
-		int log_token = cols [MONO_ENCLOG_TOKEN];
-		int func_code = cols [MONO_ENCLOG_FUNC_CODE];
-
-		int token_table = mono_metadata_token_table (log_token);
-		int token_index = mono_metadata_token_index (log_token);
-
-		switch (token_table) {
-		case MONO_TABLE_ASSEMBLYREF:
-			/* okay, supported */
-			break;
-		case MONO_TABLE_METHOD:
-			/* handled above */
-			break;
-		case MONO_TABLE_PROPERTY: {
-			/* modifying a property, ok */
-			if (token_index <= table_info_get_rows (&image_base->tables [token_table]))
-				break;
-			/* adding a property */
-			mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_METADATA_UPDATE, "row[0x%02x]:0x%08x we do not support adding new properties.", i, log_token);
-			mono_error_set_type_load_name (error, NULL, image_base->name, "EnC: we do not support adding new properties. token=0x%08x", log_token);
-			unsupported_edits = TRUE;
-			continue;
-		}
-		case MONO_TABLE_METHODSEMANTICS: {
-			if (token_index > table_info_get_rows (&image_base->tables [token_table])) {
-				/* new rows are fine, as long as they point at existing methods */
-				guint32 sema_cols [MONO_METHOD_SEMA_SIZE];
-				int mapped_token = mono_image_relative_delta_index (image_dmeta, mono_metadata_make_token (token_table, token_index));
-				g_assert (mapped_token != -1);
-				mono_metadata_decode_row (&image_dmeta->tables [MONO_TABLE_METHODSEMANTICS], mapped_token - 1, sema_cols, MONO_METHOD_SEMA_SIZE);
-
-				switch (sema_cols [MONO_METHOD_SEMA_SEMANTICS]) {
-				case METHOD_SEMANTIC_GETTER:
-				case METHOD_SEMANTIC_SETTER: {
-					int prop_method_index = sema_cols [MONO_METHOD_SEMA_METHOD];
-					/* ok, if it's pointing to an existing getter/setter */
-					if (prop_method_index < table_info_get_rows (&image_base->tables [MONO_TABLE_METHOD]))
-						break;
-					mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_METADATA_UPDATE, "row[0x%02x]:0x%08x adding new getter/setter method 0x%08x to a property is not supported", i, log_token, prop_method_index);
-					mono_error_set_type_load_name (error, NULL, image_base->name, "EnC: we do not support adding a new getter or setter to a property, token=0x%08x", log_token);
-					unsupported_edits = TRUE;
-					continue;
-				}
-				default:
-					mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_METADATA_UPDATE, "row[0x%02x]:0x%08x adding new non-getter/setter property or event methods is not supported.", i, log_token);
-					mono_error_set_type_load_name (error, NULL, image_base->name, "EnC: we do not support adding new non-getter/setter property or event methods. token=0x%08x", log_token);
-					unsupported_edits = TRUE;
-					continue;
-				}
-			} else {
-				mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_METADATA_UPDATE, "row[0x%02x]:0x%08x we do not support patching of existing table cols.", i, log_token);
-				mono_error_set_type_load_name (error, NULL, image_base->name, "EnC: we do not support patching of existing table cols. token=0x%08x", log_token);
-				unsupported_edits = TRUE;
-				continue;
-			}
-		}
-		default:
-			/* FIXME: this bounds check is wrong for cumulative updates - need to look at the DeltaInfo:count.prev_gen_rows */
-			if (token_index <= table_info_get_rows (&image_base->tables [token_table])) {
-				mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_METADATA_UPDATE, "row[0x%02x]:0x%08x we do not support patching of existing table cols.", i, log_token);
-				mono_error_set_type_load_name (error, NULL, image_base->name, "EnC: we do not support patching of existing table cols. token=0x%08x", log_token);
-				unsupported_edits = TRUE;
-				continue;
-			}
-		}
-
-
-		/*
-		 * So the way a non-default func_code works is that it's attached to the EnCLog
-		 * record preceeding the new member defintion (so e.g. an addMethod code will be on
-		 * the preceeding MONO_TABLE_TYPEDEF enc record that identifies the parent type).
-		 */
-		switch (func_code) {
-			case 0: /* default */
-				break;
-			default:
-				mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_METADATA_UPDATE, "row[0x%02x]:0x%08x FunCode %d (%s) not supported (token=0x%08x)", i, log_token, func_code, funccode_to_str (func_code), log_token);
-				mono_error_set_type_load_name (error, NULL, image_base->name, "EnC: FuncCode %d (%s) not supported (token=0x%08x)", func_code, funccode_to_str (func_code), log_token);
-				unsupported_edits = TRUE;
-				continue;
+	for (GList *ptr = images; ptr; ptr = ptr->next) {
+		MonoImage *image = (MonoImage *)ptr->data;
+		if (image) {
+			if (!mono_image_close_except_pools (image))
+			    ptr->data = NULL;
 		}
 	}
-	return !unsupported_edits;
 }
 
-static void
-set_update_method (MonoImage *image_base, uint32_t generation, MonoImage *image_dmeta, uint32_t token_index, const char* il_address)
+void
+mono_metadata_update_image_close_except_pools_all (MonoImage *base_image)
 {
-	mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_METADATA_UPDATE, "setting method 0x%08x in g=%d IL=%p", token_index, generation, (void*)il_address);
-	/* FIXME: this is a race if other threads are doing a lookup. */
-	g_hash_table_insert (image_base->method_table_update, GUINT_TO_POINTER (token_index), GUINT_TO_POINTER (generation));
-	g_hash_table_insert (image_dmeta->method_table_update, GUINT_TO_POINTER (token_index), (gpointer) il_address);
+        mono_component_hot_reload ()->image_close_except_pools_all (base_image);
 }
 
-/* do actuall enclog application */
-static gboolean
-apply_enclog_pass2 (MonoImage *image_base, uint32_t generation, MonoImage *image_dmeta, gconstpointer dil_data, uint32_t dil_length, MonoError *error)
+void
+mono_metadata_update_image_close_all (MonoImage *base_image)
 {
-	MonoTableInfo *table_enclog = &image_dmeta->tables [MONO_TABLE_ENCLOG];
-	int rows = table_info_get_rows (table_enclog);
-
-	gboolean assemblyref_updated = FALSE;
-	for (int i = 0; i < rows ; ++i) {
-		guint32 cols [MONO_ENCLOG_SIZE];
-		mono_metadata_decode_row (table_enclog, i, cols, MONO_ENCLOG_SIZE);
-
-		int log_token = cols [MONO_ENCLOG_TOKEN];
-		int func_code = cols [MONO_ENCLOG_FUNC_CODE];
-
-		int token_table = mono_metadata_token_table (log_token);
-		int token_index = mono_metadata_token_index (log_token);
-		mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "enclog i=%d: token=0x%08x (table=%s): %d", i, log_token, mono_meta_table_name (token_table), func_code);
-
-		/* TODO: See CMiniMdRW::ApplyDelta for how to drive this.
-		 */
-		switch (func_code) {
-			case 0: /* default */
-				break;
-			default:
-				g_error ("EnC: unsupported FuncCode, should be caught by pass1");
-				break;
-		}
-
-		switch (token_table) {
-		case MONO_TABLE_ASSEMBLYREF: {
-			g_assert (token_index > table_info_get_rows (&image_base->tables [token_table]));
-
-			if (assemblyref_updated)
-				continue;
-
-			assemblyref_updated = TRUE;
-
-			/* FIXME: use DeltaInfo:prev_gen_rows instead of looping */
-			/* TODO: do we know that there will never be modified rows in ASSEMBLYREF? */
-			int old_rows = table_info_get_rows (&image_base->tables [MONO_TABLE_ASSEMBLYREF]);
-			for (GList *l = image_base->delta_image; l; l = l->next) {
-				MonoImage *delta_child = l->data;
-				old_rows += table_info_get_rows (&delta_child->tables [MONO_TABLE_ASSEMBLYREF]);
-			}
-			int new_rows = table_info_get_rows (&image_dmeta->tables [MONO_TABLE_ASSEMBLYREF]);
-
-			old_rows -= new_rows;
-			g_assert (new_rows > 0);
-			g_assert (old_rows > 0);
-
-			/* TODO: this can end bad with code around assembly.c:mono_assembly_load_reference */
-			mono_image_lock (image_base);
-			MonoAssembly **old_array = image_base->references;
-			g_assert (image_base->nreferences == old_rows);
-
-			image_base->references = g_new0 (MonoAssembly *, old_rows + new_rows + 1);
-			memcpy (image_base->references, old_array, sizeof (gpointer) * (old_rows + 1));
-			image_base->nreferences = old_rows + new_rows;
-			mono_image_unlock (image_base);
-
-			g_free (old_array);
-			break;
-		}
-		case MONO_TABLE_METHOD: {
-			if (token_index > table_info_get_rows (&image_base->tables [token_table])) {
-				g_error ("EnC: new method added, should be caught by pass1");
-			}
-
-			if (!image_base->method_table_update)
-				image_base->method_table_update = g_hash_table_new (g_direct_hash, g_direct_equal);
-			if (!image_dmeta->method_table_update)
-				image_dmeta->method_table_update = g_hash_table_new (g_direct_hash, g_direct_equal);
-
-			int mapped_token = mono_image_relative_delta_index (image_dmeta, mono_metadata_make_token (token_table, token_index));
-			int rva = mono_metadata_decode_row_col (&image_dmeta->tables [MONO_TABLE_METHOD], mapped_token - 1, MONO_METHOD_RVA);
-			if (rva < dil_length) {
-				char *il_address = ((char *) dil_data) + rva;
-				set_update_method (image_base, generation, image_dmeta, token_index, il_address);
-			} else {
-				/* rva points probably into image_base IL stream. can this ever happen? */
-				g_print ("TODO: this case is still a bit contrived. token=0x%08x with rva=0x%04x\n", log_token, rva);
-			}
-			break;
-		}
-		case MONO_TABLE_TYPEDEF: {
-			/* TODO: throw? */
-			/* TODO: happens changing the class (adding field or method). we ignore it, but dragons are here */
-
-			/* existing entries are supposed to be patched */
-			g_assert (token_index <= table_info_get_rows (&image_base->tables [token_table]));
-			break;
-		}
-		case MONO_TABLE_PROPERTY: {
-			/* allow updates to existing properties. */
-			/* FIXME: use DeltaInfo:prev_gen_rows instead of image_base */
-			g_assert (token_index <= table_info_get_rows (&image_base->tables [token_table]));
-			/* assuming that property attributes and type haven't changed. */
-			break;
-		}
-		default: {
-			g_assert (token_index > table_info_get_rows (&image_base->tables [token_table]));
-			if (mono_trace_is_traced (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE))
-				g_print ("todo: do something about this table index: 0x%02x\n", token_table);
-		}
-		}
-	}
-	return TRUE;
+        mono_component_hot_reload ()->image_close_all (base_image);
 }
 
-/**
- *
- * LOCKING: Takes the publish_lock
- */
-void
-mono_image_load_enc_delta (MonoImage *image_base, gconstpointer dmeta_bytes, uint32_t dmeta_length, gconstpointer dil_bytes_orig, uint32_t dil_length, MonoError *error)
+gpointer
+mono_metadata_update_get_updated_method_rva (MonoImage *base_image, uint32_t idx)
 {
-	mono_metadata_update_ee_init (error);
-	if (!is_ok (error))
-		return;
-
-	if (!assembly_update_supported (image_base->assembly)) {
-		mono_error_set_invalid_operation (error, "The assembly can not be edited or changed.");
-		return;
-	}
-
-	const char *basename = image_base->filename;
-
-	if (mono_trace_is_traced (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE)) {
-		g_print ("LOADING basename=%s delta update.\ndelta image=%p & dil=%p\n", basename, dmeta_bytes, dil_bytes_orig);
-		/* TODO: add a non-async version of mono_dump_mem */
-		mono_dump_mem (dmeta_bytes, dmeta_length);
-		mono_dump_mem (dil_bytes_orig, dil_length);
-	}
-
-	uint32_t generation = mono_metadata_update_prepare ();
-
-	mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "base image string size: 0x%08x", image_base->heap_strings.size);
-	mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "base image user string size: 0x%08x", image_base->heap_us.size);
-	mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "base image blob heap addr: %p", image_base->heap_blob.data);
-	mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "base image blob heap size: 0x%08x", image_base->heap_blob.size);
-
-	MonoImageOpenStatus status;
-	/* makes a copy of dmeta_bytes */
-	MonoImage *image_dmeta = mono_image_open_dmeta_from_data (image_base, generation, dmeta_bytes, dmeta_length, &status);
-	mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "delta image string size: 0x%08x", image_dmeta->heap_strings.size);
-	mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "delta image user string size: 0x%08x", image_dmeta->heap_us.size);
-	mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "delta image blob heap addr: %p", image_dmeta->heap_blob.data);
-	mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "delta image blob heap size: 0x%08x", image_dmeta->heap_blob.size);
-	g_assert (image_dmeta);
-	g_assert (status == MONO_IMAGE_OK);
-
-	/* makes a copy of dil_bytes_orig */
-	gpointer dil_bytes = open_dil_data (image_base, dil_bytes_orig, dil_length);
-	/* TODO: make a copy of the dpdb bytes, once we consume them */
-
-	if (image_dmeta->minimal_delta) {
-		guint32 idx = mono_metadata_decode_row_col (&image_dmeta->tables [MONO_TABLE_MODULE], 0, MONO_MODULE_NAME);
-
-		const char *module_name = NULL;
-		module_name = mono_metadata_string_heap (image_base, idx);
-
-		/* Set the module name now that we know the base String heap size */
-		g_assert (!image_dmeta->module_name);
-		image_dmeta->module_name = module_name;
-		mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "applied dmeta name: '%s'\n", module_name);
-	}
-
-	MonoTableInfo *table_enclog = &image_dmeta->tables [MONO_TABLE_ENCLOG];
-	MonoTableInfo *table_encmap = &image_dmeta->tables [MONO_TABLE_ENCMAP];
-
-	if (!table_info_get_rows (table_enclog) && !table_info_get_rows (table_encmap)) {
-		mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_METADATA_UPDATE, "No enclog or encmap in delta image for base=%s, nothing to do", basename);
-		mono_metadata_update_cancel (generation);
-		return;
-	}
-
-	/* Process EnCMap and compute number of added/modified rows from this
-	 * delta.  This enables computing row indexes relative to the delta.
-	 * We use it in pass1 to bail out early if the EnCLog has unsupported
-	 * edits.
-	 */
-	delta_info_init (image_dmeta, image_base);
-
-
-	if (!apply_enclog_pass1 (image_base, image_dmeta, dil_bytes, dil_length, error)) {
-		mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_METADATA_UPDATE, "Error on sanity-checking delta image to base=%s, due to: %s", basename, mono_error_get_message (error));
-		mono_metadata_update_cancel (generation);
-		return;
-	}
-
-	/* if there are updates, start tracking the tables of the base image, if we weren't already. */
-	if (table_info_get_rows (table_enclog))
-		table_to_image_add (image_base);
-
-	mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "base  guid: %s", image_base->guid);
-	mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "dmeta guid: %s", image_dmeta->guid);
-
-	if (mono_trace_is_traced (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE))
-		dump_update_summary (image_base, image_dmeta);
-
-	if (!apply_enclog_pass2 (image_base, generation, image_dmeta, dil_bytes, dil_length, error)) {
-		mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_METADATA_UPDATE, "Error applying delta image to base=%s, due to: %s", basename, mono_error_get_message (error));
-		mono_metadata_update_cancel (generation);
-		return;
-	}
-	mono_error_assert_ok (error);
-
-	MonoAssemblyLoadContext *alc = mono_image_get_alc (image_base);
-	mono_metadata_update_publish (alc, generation);
-
-	mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_METADATA_UPDATE, ">>> EnC delta for base=%s (generation %d) applied", basename, generation);
+        return mono_component_hot_reload ()->get_updated_method_rva (base_image, idx);
 }
 
-/*
- * Returns how many times the base image was updated upto and including the given delta.
- */
-static int
-metadata_update_local_generation (MonoImage *base, MonoImage *delta)
+gboolean
+mono_metadata_update_table_bounds_check (MonoImage *base_image, int table_index, int token_index)
 {
-	if (delta == base)
-		return 0;
-	int index = g_list_index (base->delta_image, delta);
-	g_assert (index != -1);
-	return 1 + index;
+        return mono_component_hot_reload ()->table_bounds_check (base_image, table_index, token_index);
 }
 
-/*
- * Returns how many times the given base image has been updated so far.
- *
- * NOTE: doesn't look at update_published or update_alloc_frontier, and therefore only usable by the
- * update originator.
- */
-static int
-metadata_update_count_updates (MonoImage *base)
+gboolean
+mono_metadata_update_delta_heap_lookup (MonoImage *base_image, MetadataHeapGetterFunc get_heap, uint32_t orig_index, MonoImage **image_out, uint32_t *index_out)
 {
-	if (!base->delta_image_last)
-		return 0;
-	else
-		return metadata_update_local_generation (base, (MonoImage*)base->delta_image_last->data);
+        return mono_component_hot_reload ()->delta_heap_lookup (base_image, get_heap, orig_index, image_out, index_out);
 }
-#else /* ENABLE_METADATA_UPDATE */
-MONO_EMPTY_SOURCE_FILE (metadata_update);
-#endif /* ENABLE_METADATA_UPDATE */
+
 
diff --git a/src/mono/mono/metadata/metadata-update.h b/src/mono/mono/metadata/metadata-update.h
index b14f7cd3e6bb8c..52bfa701e57f82 100644
--- a/src/mono/mono/metadata/metadata-update.h
+++ b/src/mono/mono/metadata/metadata-update.h
@@ -9,7 +9,8 @@
 #include "mono/metadata/loader-internals.h"
 #include "mono/metadata/metadata-internals.h"
 
-#ifdef ENABLE_METADATA_UPDATE
+void
+mono_metadata_update_init (void);
 
 enum MonoModifiableAssemblies {
 	/* modifiable assemblies are disabled */
@@ -18,17 +19,16 @@ enum MonoModifiableAssemblies {
 	MONO_MODIFIABLE_ASSM_DEBUG = 1,
 };
 
-gboolean
-mono_metadata_update_enabled (int *modifiable_assemblies_out);
+typedef MonoStreamHeader* (*MetadataHeapGetterFunc) (MonoImage*);
 
 gboolean
-mono_metadata_update_no_inline (MonoMethod *caller, MonoMethod *callee);
+mono_metadata_update_available (void);
 
-void
-mono_metadata_update_init (void);
+gboolean
+mono_metadata_update_enabled (int *modifiable_assemblies_out);
 
 gboolean
-mono_metadata_update_available (void);
+mono_metadata_update_no_inline (MonoMethod *caller, MonoMethod *callee);
 
 uint32_t
 mono_metadata_update_thread_expose_published (void);
@@ -36,40 +36,22 @@ mono_metadata_update_thread_expose_published (void);
 uint32_t
 mono_metadata_update_get_thread_generation (void);
 
-gboolean
-mono_metadata_wait_for_update (uint32_t timeout_ms);
-
-uint32_t
-mono_metadata_update_prepare (void);
-
 void
-mono_metadata_update_publish (MonoAssemblyLoadContext *alc, uint32_t generation);
+mono_metadata_update_cleanup_on_close (MonoImage *base_image);
 
 void
-mono_metadata_update_cancel (uint32_t generation);
+mono_metadata_update_image_close_except_pools_all (MonoImage *base_image);
 
 void
-mono_metadata_update_cleanup_on_close (MonoImage *base_image);
-
-MonoImage *
-mono_table_info_get_base_image (const MonoTableInfo *t);
-
-#else /* ENABLE_METADATA_UPDATE */
+mono_metadata_update_image_close_all (MonoImage *base_image);
 
-static inline gboolean
-mono_metadata_update_enabled (int *modifiable_assemblies_out)
-{
-        if (modifiable_assemblies_out)
-                *modifiable_assemblies_out = 0;
-        return FALSE;
-}
+gpointer
+mono_metadata_update_get_updated_method_rva (MonoImage *base_image, uint32_t idx);
 
-static inline gboolean
-mono_metadata_update_no_inline (MonoMethod *caller, MonoMethod *callee)
-{
-        return FALSE;
-}
+gboolean
+mono_metadata_update_table_bounds_check (MonoImage *base_image, int table_index, int token_index);
 
-#endif /* ENABLE_METADATA_UPDATE */
+gboolean
+mono_metadata_update_delta_heap_lookup (MonoImage *base_image, MetadataHeapGetterFunc get_heap, uint32_t orig_index, MonoImage **image_out, uint32_t *index_out);
 
 #endif /*__MONO_METADATA_UPDATE_H__*/
diff --git a/src/mono/mono/metadata/metadata.c b/src/mono/mono/metadata/metadata.c
index 5d106028ea6da1..ca8cced208a76b 100644
--- a/src/mono/mono/metadata/metadata.c
+++ b/src/mono/mono/metadata/metadata.c
@@ -986,7 +986,6 @@ mono_metadata_compute_size (MonoImage *meta, int tableindex, guint32 *result_bit
 	return size;
 }
 
-#ifdef ENABLE_METADATA_UPDATE
 /* returns true if given index is not in bounds with provided table/index pair */
 gboolean
 mono_metadata_table_bounds_check_slow (MonoImage *image, int table_index, int token_index)
@@ -994,30 +993,11 @@ mono_metadata_table_bounds_check_slow (MonoImage *image, int table_index, int to
 	if (G_LIKELY (token_index <= table_info_get_rows (&image->tables [table_index])))
 		return FALSE;
 
-	GList *list = image->delta_image;
-	MonoImage *dmeta;
-	MonoTableInfo *table;
-	/* result row, 0-based */
-	int ridx;
+        if (G_LIKELY (!image->has_updates))
+                return TRUE;
 
-	int original_token = mono_metadata_make_token (table_index, token_index);
-
-	uint32_t exposed_gen = mono_metadata_update_get_thread_generation ();
-	do {
-		if (!list)
-			return TRUE;
-		dmeta = list->data;
-		if (dmeta->generation > exposed_gen)
-			return TRUE;
-		list = list->next;
-		table = &dmeta->tables [table_index];
-		/* mono_image_relative_delta_index returns a 1-based index */
-		ridx = mono_image_relative_delta_index (dmeta, original_token) - 1;
-	} while (ridx < 0 || ridx >= table_info_get_rows (table));
-
-	return FALSE;
+        return mono_metadata_update_table_bounds_check (image, table_index, token_index);
 }
-#endif
 
 /**
  * mono_metadata_compute_table_bases:
@@ -1076,11 +1056,6 @@ mono_metadata_locate_token (MonoImage *meta, guint32 token)
 	return mono_metadata_locate (meta, token >> 24, token & 0xffffff);
 }
 
-
-
-typedef MonoStreamHeader* (*MetadataHeapGetterFunc) (MonoImage*);
-
-#ifdef ENABLE_METADATA_UPDATE
 static MonoStreamHeader *
 get_string_heap (MonoImage *image)
 {
@@ -1102,35 +1077,8 @@ get_blob_heap (MonoImage *image)
 static gboolean
 mono_delta_heap_lookup (MonoImage *base_image, MetadataHeapGetterFunc get_heap, guint32 orig_index, MonoImage **image_out, guint32 *index_out)
 {
-	g_assert (image_out);
-	g_assert (index_out);
-	MonoStreamHeader *heap = get_heap (base_image);
-	g_assert (orig_index >= heap->size && base_image->delta_image);
-
-	*image_out = base_image;
-	*index_out = orig_index;
-
-	guint32 prev_size = heap->size;
-
-	uint32_t current_gen = mono_metadata_update_get_thread_generation ();
-	GList *cur;
-	for (cur = base_image->delta_image; cur; cur = cur->next) {
-		*image_out = (MonoImage*)cur->data;
-		heap = get_heap (*image_out);
-
-		if ((*image_out)->generation > current_gen)
-			return FALSE;
-
-		/* FIXME: for non-minimal deltas we should just look in the last published image. */
-		if (G_LIKELY ((*image_out)->minimal_delta))
-			*index_out -= prev_size;
-		if (*index_out < heap->size)
-			break;
-		prev_size = heap->size;
-	}
-	return (cur != NULL);
+        return mono_metadata_update_delta_heap_lookup (base_image, get_heap, orig_index, image_out, index_out);
 }
-#endif
 
 /**
  * mono_metadata_string_heap:
@@ -1141,8 +1089,7 @@ mono_delta_heap_lookup (MonoImage *base_image, MetadataHeapGetterFunc get_heap,
 const char *
 mono_metadata_string_heap (MonoImage *meta, guint32 index)
 {
-#ifdef ENABLE_METADATA_UPDATE
-	if (G_UNLIKELY (index >= meta->heap_strings.size && meta->delta_image)) {
+	if (G_UNLIKELY (index >= meta->heap_strings.size && meta->has_updates)) {
 		MonoImage *dmeta;
 		guint32 dindex;
 		gboolean ok = mono_delta_heap_lookup (meta, &get_string_heap, index, &dmeta, &dindex);
@@ -1150,7 +1097,6 @@ mono_metadata_string_heap (MonoImage *meta, guint32 index)
 		meta = dmeta;
 		index = dindex;
 	}
-#endif
 
 	g_assertf (index < meta->heap_strings.size, " index = 0x%08x size = 0x%08x meta=%s ", index, meta->heap_strings.size, meta && meta->name ? meta->name : "unknown image" );
 	g_return_val_if_fail (index < meta->heap_strings.size, "");
@@ -1179,8 +1125,7 @@ mono_metadata_string_heap_checked (MonoImage *meta, guint32 index, MonoError *er
 		return img->sheap.data + index;
 	}
 
-#ifdef ENABLE_METADATA_UPDATE
-	if (G_UNLIKELY (index >= meta->heap_strings.size && meta->delta_image)) {
+	if (G_UNLIKELY (index >= meta->heap_strings.size && meta->has_updates)) {
 		MonoImage *dmeta;
 		guint32 dindex;
 		gboolean ok = mono_delta_heap_lookup (meta, &get_string_heap, index, &dmeta, &dindex);
@@ -1193,7 +1138,6 @@ mono_metadata_string_heap_checked (MonoImage *meta, guint32 index, MonoError *er
 		meta = dmeta;
 		index = dindex;
 	}
-#endif
 
 	if (G_UNLIKELY (!(index < meta->heap_strings.size))) {
 		const char *image_name = meta && meta->name ? meta->name : "unknown image";
@@ -1212,8 +1156,7 @@ mono_metadata_string_heap_checked (MonoImage *meta, guint32 index, MonoError *er
 const char *
 mono_metadata_user_string (MonoImage *meta, guint32 index)
 {
-#ifdef ENABLE_METADATA_UPDATE
-	if (G_UNLIKELY (index >= meta->heap_us.size && meta->delta_image)) {
+	if (G_UNLIKELY (index >= meta->heap_us.size && meta->has_updates)) {
 		MonoImage *dmeta;
 		guint32 dindex;
 		gboolean ok = mono_delta_heap_lookup (meta, &get_user_string_heap, index, &dmeta, &dindex);
@@ -1221,7 +1164,6 @@ mono_metadata_user_string (MonoImage *meta, guint32 index)
 		meta = dmeta;
 		index = dindex;
 	}
-#endif
 	g_assert (index < meta->heap_us.size);
 	g_return_val_if_fail (index < meta->heap_us.size, "");
 	return meta->heap_us.data + index;
@@ -1241,8 +1183,7 @@ mono_metadata_blob_heap (MonoImage *meta, guint32 index)
 	 * assertion is hit, consider updating caller to use
 	 * mono_metadata_blob_heap_null_ok and handling a null return value. */
 	g_assert (!(index == 0 && meta->heap_blob.size == 0));
-#ifdef ENABLE_METADATA_UPDATE
-	if (G_UNLIKELY (index >= meta->heap_blob.size && meta->delta_image)) {
+	if (G_UNLIKELY (index >= meta->heap_blob.size && meta->has_updates)) {
 		MonoImage *dmeta;
 		guint32 dindex;
 		gboolean ok = mono_delta_heap_lookup (meta, &get_blob_heap, index, &dmeta, &dindex);
@@ -1250,7 +1191,6 @@ mono_metadata_blob_heap (MonoImage *meta, guint32 index)
 		meta = dmeta;
 		index = dindex;
 	}
-#endif
 	g_assert (index < meta->heap_blob.size);
 	return meta->heap_blob.data + index;
 }
@@ -1296,8 +1236,7 @@ mono_metadata_blob_heap_checked (MonoImage *meta, guint32 index, MonoError *erro
 	}
 	if (G_UNLIKELY (index == 0 && meta->heap_blob.size == 0))
 		return NULL;
-#ifdef ENABLE_METADATA_UPDATE
-	if (G_UNLIKELY (index >= meta->heap_blob.size && meta->delta_image)) {
+	if (G_UNLIKELY (index >= meta->heap_blob.size && meta->has_updates)) {
 		MonoImage *dmeta;
 		guint32 dindex;
 		gboolean ok = mono_delta_heap_lookup (meta, &get_blob_heap, index, &dmeta, &dindex);
@@ -1309,7 +1248,6 @@ mono_metadata_blob_heap_checked (MonoImage *meta, guint32 index, MonoError *erro
 		meta = dmeta;
 		index = dindex;
 	}
-#endif
 	if (G_UNLIKELY (!(index < meta->heap_blob.size))) {
 		const char *image_name = meta && meta->name ? meta->name : "unknown image";
 		mono_error_set_bad_image_by_name (error, image_name, "blob heap index %u out of bounds %u: %s", index, meta->heap_blob.size, image_name);
@@ -1327,7 +1265,7 @@ mono_metadata_blob_heap_checked (MonoImage *meta, guint32 index, MonoError *erro
 const char *
 mono_metadata_guid_heap (MonoImage *meta, guint32 index)
 {
-	/* EnC TODO: lookup in MonoImage:delta_image_last.  Unlike the other heaps, the GUID heaps are always full in every delta, even in minimal delta images. */
+	/* EnC TODO: lookup in DeltaInfo:delta_image_last.  Unlike the other heaps, the GUID heaps are always full in every delta, even in minimal delta images. */
 	--index;
 	index *= 16; /* adjust for guid size and 1-based index */
 	g_return_val_if_fail (index < meta->heap_guid.size, "");
@@ -2031,9 +1969,7 @@ mono_metadata_init (void)
 
 	mono_components_init ();
 
-#ifdef ENABLE_METADATA_UPDATE
 	mono_metadata_update_init ();
-#endif
 }
 
 /**
diff --git a/src/mono/mono/metadata/metadata.h b/src/mono/mono/metadata/metadata.h
index 62350f113ff385..c045f8c9a135e0 100644
--- a/src/mono/mono/metadata/metadata.h
+++ b/src/mono/mono/metadata/metadata.h
@@ -205,8 +205,6 @@ typedef struct {
 
 MONO_API void         mono_metadata_init (void);
 
-void mono_metadata_decode_row_raw (const MonoTableInfo *t, int idx, uint32_t *res, int res_size);
-
 MONO_API void         mono_metadata_decode_row (const MonoTableInfo   *t,
 				       int                    idx,
 				       uint32_t               *res,
diff --git a/src/mono/mono/metadata/method-builder-ilgen.c b/src/mono/mono/metadata/method-builder-ilgen.c
index 9d48b6da80b7a8..68ddbaae60e800 100644
--- a/src/mono/mono/metadata/method-builder-ilgen.c
+++ b/src/mono/mono/metadata/method-builder-ilgen.c
@@ -622,6 +622,14 @@ mono_mb_emit_add_to_local (MonoMethodBuilder *mb, guint16 local, gint32 incr)
 	mono_mb_emit_stloc (mb, local); 
 }
 
+void
+mono_mb_emit_no_nullcheck (MonoMethodBuilder *mb)
+{
+	mono_mb_emit_byte (mb, CEE_PREFIX1);
+	mono_mb_emit_byte (mb, CEE_NO_);
+	mono_mb_emit_byte (mb, CEE_NO_NULLCHECK);
+}
+
 void
 mono_mb_set_clauses (MonoMethodBuilder *mb, int num_clauses, MonoExceptionClause *clauses)
 {
diff --git a/src/mono/mono/metadata/method-builder-ilgen.h b/src/mono/mono/metadata/method-builder-ilgen.h
index 82daf70e91e5ea..2a5e40dc70256d 100644
--- a/src/mono/mono/metadata/method-builder-ilgen.h
+++ b/src/mono/mono/metadata/method-builder-ilgen.h
@@ -127,6 +127,9 @@ mono_mb_emit_op (MonoMethodBuilder *mb, guint8 op, gpointer data);
 void
 mono_mb_emit_ldstr (MonoMethodBuilder *mb, char *str);
 
+void
+mono_mb_emit_no_nullcheck (MonoMethodBuilder *mb);
+
 void
 mono_mb_set_clauses (MonoMethodBuilder *mb, int num_clauses, MonoExceptionClause *clauses);
 
diff --git a/src/mono/mono/metadata/mono-private-unstable.h b/src/mono/mono/metadata/mono-private-unstable.h
index 6585c2e575aedb..4618c8fe08bc92 100644
--- a/src/mono/mono/metadata/mono-private-unstable.h
+++ b/src/mono/mono/metadata/mono-private-unstable.h
@@ -28,6 +28,7 @@ typedef MonoAssembly * (*MonoAssemblyPreLoadFuncV3) (MonoAssemblyLoadContextGCHa
 MONO_API MONO_RT_EXTERNAL_ONLY void
 mono_install_assembly_preload_hook_v3 (MonoAssemblyPreLoadFuncV3 func, void *user_data, mono_bool append);
 
+// This can point at NULL before the default ALC is initialized
 MONO_API MONO_RT_EXTERNAL_ONLY MonoAssemblyLoadContextGCHandle
 mono_alc_get_default_gchandle (void);
 
diff --git a/src/mono/mono/metadata/native-library.c b/src/mono/mono/metadata/native-library.c
index 252f6d32f8a387..10808d2144b134 100644
--- a/src/mono/mono/metadata/native-library.c
+++ b/src/mono/mono/metadata/native-library.c
@@ -630,6 +630,9 @@ netcore_resolve_with_load (MonoAssemblyLoadContext *alc, const char *scope, Mono
 	if (mono_runtime_get_no_exec ())
 		return NULL;
 
+	if (!mono_gchandle_get_target_internal (alc->gchandle))
+		return NULL;
+
 	HANDLE_FUNCTION_ENTER ();
 
 	MonoStringHandle scope_handle;
@@ -693,6 +696,9 @@ netcore_resolve_with_resolving_event (MonoAssemblyLoadContext *alc, MonoAssembly
 	if (mono_runtime_get_no_exec ())
 		return NULL;
 
+	if (!mono_gchandle_get_target_internal (alc->gchandle))
+		return NULL;
+
 	HANDLE_FUNCTION_ENTER ();
 
 	MonoStringHandle scope_handle;
diff --git a/src/mono/mono/metadata/object-internals.h b/src/mono/mono/metadata/object-internals.h
index cf3eda5f6e67aa..0af9ed940682c5 100644
--- a/src/mono/mono/metadata/object-internals.h
+++ b/src/mono/mono/metadata/object-internals.h
@@ -638,12 +638,11 @@ typedef struct {
 	gboolean (*is_interpreter_enabled) (void);
 	void (*init_mem_manager)(MonoMemoryManager*);
 	void (*free_mem_manager)(MonoMemoryManager*);
-#ifdef ENABLE_METADATA_UPDATE
-	void     (*metadata_update_init) (MonoError *error);
 	void     (*metadata_update_published) (MonoAssemblyLoadContext *alc, uint32_t generation);
-#endif
 	void (*get_jit_stats)(gint64 *methods_compiled, gint64 *cil_code_size_bytes, gint64 *native_code_size_bytes);
 	void (*get_exception_stats)(guint32 *exception_count);
+	// Same as compile_method, but returns a MonoFtnDesc in llvmonly mode
+	gpointer (*get_ftnptr)(MonoMethod *method, MonoError *error);
 } MonoRuntimeCallbacks;
 
 typedef gboolean (*MonoInternalStackWalk) (MonoStackFrameInfo *frame, MonoContext *ctx, gpointer data);
@@ -688,6 +687,7 @@ mono_runtime_free_method    (MonoMethod *method);
 void
 mono_install_callbacks      (MonoRuntimeCallbacks *cbs);
 
+MONO_COMPONENT_API
 MonoRuntimeCallbacks*
 mono_get_runtime_callbacks (void);
 
diff --git a/src/mono/mono/metadata/threads.c b/src/mono/mono/metadata/threads.c
index 016f8e74b4df5c..fb43d7fab58689 100644
--- a/src/mono/mono/metadata/threads.c
+++ b/src/mono/mono/metadata/threads.c
@@ -25,6 +25,7 @@
 #include <mono/metadata/threads-types.h>
 #include <mono/metadata/exception.h>
 #include <mono/metadata/environment.h>
+#include <mono/metadata/metadata-update.h>
 #include <mono/metadata/monitor.h>
 #include <mono/metadata/mono-hash-internals.h>
 #include <mono/metadata/gc-internals.h>
@@ -839,10 +840,8 @@ mono_thread_attach_internal (MonoThread *thread, gboolean force_attach)
 
 	mono_threads_unlock ();
 
-#ifdef MONO_METADATA_UPDATE
 	/* Roll up to the latest published metadata generation */
 	mono_metadata_update_thread_expose_published ();
-#endif
 
 	THREAD_DEBUG (g_message ("%s: Attached thread ID %" G_GSIZE_FORMAT " (handle %p)", __func__, internal->tid, internal->handle));
 
diff --git a/src/mono/mono/mini/aot-compiler.c b/src/mono/mono/mini/aot-compiler.c
index d4fe08b7fb675c..b36fea0cdf422e 100644
--- a/src/mono/mono/mini/aot-compiler.c
+++ b/src/mono/mono/mini/aot-compiler.c
@@ -1115,17 +1115,15 @@ arch_init (MonoAotCompile *acfg)
 	acfg->llvm_label_prefix = "";
 	acfg->user_symbol_prefix = "";
 
-#if defined(TARGET_X86)
-#ifdef TARGET_ANDROID
-	g_string_append_printf (acfg->llc_args, " -mtriple=i686-none-linux-android21");
-#else
+#if TARGET_X86 || TARGET_AMD64
 	const gboolean has_custom_args = !!acfg->aot_opts.llvm_llc || acfg->aot_opts.use_current_cpu;
-	g_string_append_printf (acfg->llc_args, " -march=x86 %s", has_custom_args ? "" : "-mcpu=generic");
 #endif
+
+#if defined(TARGET_X86)
+	g_string_append_printf (acfg->llc_args, " -march=x86 %s", has_custom_args ? "" : "-mcpu=generic");
 #endif
 
 #if defined(TARGET_AMD64)
-	const gboolean has_custom_args = !!acfg->aot_opts.llvm_llc || acfg->aot_opts.use_current_cpu;
 	g_string_append_printf (acfg->llc_args, " -march=x86-64 %s", has_custom_args ? "" : "-mcpu=generic");
 	/* NOP */
 	acfg->align_pad_value = 0x90;
@@ -1159,7 +1157,13 @@ arch_init (MonoAotCompile *acfg)
 		g_string_append (acfg->llc_args, " -mattr=+vfp2,-neon,+d16 -float-abi=hard");
 		g_string_append (acfg->as_args, " -mfpu=vfp3");
 #elif defined(ARM_FPU_VFP)
+
+#if defined(TARGET_ARM)
+		// +d16 triggers a warning on arm
+		g_string_append (acfg->llc_args, " -mattr=+vfp2,-neon");
+#else
 		g_string_append (acfg->llc_args, " -mattr=+vfp2,-neon,+d16");
+#endif
 		g_string_append (acfg->as_args, " -mfpu=vfp3");
 #else
 		g_string_append (acfg->llc_args, " -mattr=+soft-float");
@@ -6983,6 +6987,8 @@ emit_method_info (MonoAotCompile *acfg, MonoCompile *cfg)
 		flags |= MONO_AOT_METHOD_FLAG_HAS_PATCHES;
 	if (needs_ctx && ctx)
 		flags |= MONO_AOT_METHOD_FLAG_HAS_CTX;
+	if (cfg->interp_entry_only)
+		flags |= MONO_AOT_METHOD_FLAG_INTERP_ENTRY_ONLY;
 	/* Saved into another table so it can be accessed without having access to this data */
 	cfg->aot_method_flags = flags;
 
diff --git a/src/mono/mono/mini/aot-runtime.c b/src/mono/mono/mini/aot-runtime.c
index 545487122f098c..6a181644fee5fb 100644
--- a/src/mono/mono/mini/aot-runtime.c
+++ b/src/mono/mono/mini/aot-runtime.c
@@ -4190,7 +4190,7 @@ load_method (MonoAotModule *amodule, MonoImage *image, MonoMethod *method, guint
 	if (mono_llvm_only) {
 		guint8 flags = amodule->method_flags_table [method_index];
 		/* The caller needs to looks this up, but its hard to do without constructing the full MonoJitInfo, so save it here */
-		if (flags & MONO_AOT_METHOD_FLAG_GSHAREDVT_VARIABLE) {
+		if (flags & (MONO_AOT_METHOD_FLAG_GSHAREDVT_VARIABLE | MONO_AOT_METHOD_FLAG_INTERP_ENTRY_ONLY)) {
 			mono_aot_lock ();
 			if (!code_to_method_flags)
 				code_to_method_flags = g_hash_table_new (NULL, NULL);
diff --git a/src/mono/mono/mini/aot-runtime.h b/src/mono/mono/mini/aot-runtime.h
index 862e74e948c74e..af40e8bbb12f4e 100644
--- a/src/mono/mono/mini/aot-runtime.h
+++ b/src/mono/mono/mini/aot-runtime.h
@@ -82,7 +82,8 @@ typedef enum {
 	MONO_AOT_METHOD_FLAG_HAS_CCTOR = 1,
 	MONO_AOT_METHOD_FLAG_GSHAREDVT_VARIABLE = 2,
 	MONO_AOT_METHOD_FLAG_HAS_PATCHES = 4,
-	MONO_AOT_METHOD_FLAG_HAS_CTX = 8
+	MONO_AOT_METHOD_FLAG_HAS_CTX = 8,
+	MONO_AOT_METHOD_FLAG_INTERP_ENTRY_ONLY = 16,
 } MonoAotMethodFlags;
 
 typedef enum {
diff --git a/src/mono/mono/mini/cpu-amd64.md b/src/mono/mono/mini/cpu-amd64.md
index e581a983944f7c..48a1b9f0fbafae 100644
--- a/src/mono/mono/mini/cpu-amd64.md
+++ b/src/mono/mono/mini/cpu-amd64.md
@@ -779,9 +779,7 @@ extract_i4: dest:i src1:x len:5
 extract_i8: dest:i src1:x len:9
 
 extract_i2: dest:i src1:x len:13
-extract_u2: dest:i src1:x len:13
 extract_i1: dest:i src1:x len:13
-extract_u1: dest:i src1:x len:13
 extract_r8: dest:f src1:x len:5
 
 iconv_to_r4_raw: dest:f src1:i len:10
diff --git a/src/mono/mono/mini/cpu-x86.md b/src/mono/mono/mini/cpu-x86.md
index a0f0fc14f15dd9..25e44d16eea5b7 100644
--- a/src/mono/mono/mini/cpu-x86.md
+++ b/src/mono/mono/mini/cpu-x86.md
@@ -631,9 +631,7 @@ iconv_to_x: dest:x src1:i len:4
 extract_i4: dest:i src1:x len:4
 
 extract_i2: dest:i src1:x len:10
-extract_u2: dest:i src1:x len:10
 extract_i1: dest:i src1:x len:10
-extract_u1: dest:i src1:x len:10
 extract_r8: dest:f src1:x len:8
 
 insert_i2: dest:x src1:x src2:i len:5 clob:1
diff --git a/src/mono/mono/mini/debugger-agent.c b/src/mono/mono/mini/debugger-agent.c
index 593cdff22298d1..b1efc0d246c717 100644
--- a/src/mono/mono/mini/debugger-agent.c
+++ b/src/mono/mono/mini/debugger-agent.c
@@ -109,8 +109,7 @@
 #define DISABLE_SOCKET_TRANSPORT
 #endif
 
-#ifndef DISABLE_SDB
-
+#if !defined (DISABLE_SDB) || defined(TARGET_WASM)
 #include <mono/utils/mono-os-mutex.h>
 
 #include <fcntl.h>
@@ -145,28 +144,6 @@ typedef struct {
 	gboolean using_icordbg;
 } AgentConfig;
 
-typedef struct _InvokeData InvokeData;
-
-struct _InvokeData
-{
-	int id;
-	int flags;
-	guint8 *p;
-	guint8 *endp;
-	/* This is the context which needs to be restored after the invoke */
-	MonoContext ctx;
-	gboolean has_ctx;
-	/*
-	 * If this is set, invoke this method with the arguments given by ARGS.
-	 */
-	MonoMethod *method;
-	gpointer *args;
-	guint32 suspend_count;
-	int nmethods;
-
-	InvokeData *last_invoke;
-};
-
 struct _DebuggerTlsData {
 	MonoThreadUnwindState context;
 
@@ -262,15 +239,6 @@ struct _DebuggerTlsData {
 	gboolean gc_finalizing;
 };
 
-typedef struct {
-	const char *name;
-	void (*connect) (const char *address);
-	void (*close1) (void);
-	void (*close2) (void);
-	gboolean (*send) (void *buf, int len);
-	int (*recv) (void *buf, int len);
-} DebuggerTransport;
-
 /* Buffered reply packets */
 static ReplyPacket reply_packets [128];
 static int nreply_packets;
@@ -314,7 +282,9 @@ typedef struct {
 /*
  * Globals
  */
-
+#ifdef TARGET_WASM
+static DebuggerTlsData debugger_wasm_thread;
+#endif
 static AgentConfig agent_config;
 
 /* 
@@ -397,6 +367,28 @@ static gint32 suspend_count;
 /* Whenever to buffer reply messages and send them together */
 static gboolean buffer_replies;
 
+
+#ifndef TARGET_WASM
+#define GET_TLS_DATA_FROM_THREAD(thread) \
+	DebuggerTlsData *tls = NULL; \
+	mono_loader_lock(); \
+	if (thread_to_tls != NULL) \
+		tls = (DebuggerTlsData*)mono_g_hash_table_lookup(thread_to_tls, thread); \
+	mono_loader_unlock();
+#define GET_DEBUGGER_TLS() \
+	DebuggerTlsData *tls; \
+	tls = (DebuggerTlsData *)mono_native_tls_get_value (debugger_tls_id); 
+#else
+#define GET_TLS_DATA_FROM_THREAD(thread) \
+	DebuggerTlsData *tls; \
+	tls = &debugger_wasm_thread;
+#define GET_DEBUGGER_TLS() \
+	DebuggerTlsData *tls; \
+	tls = &debugger_wasm_thread;
+#endif
+
+//mono_native_tls_get_value (debugger_tls_id);
+
 #define dbg_lock mono_de_lock
 #define dbg_unlock mono_de_unlock
 
@@ -460,6 +452,7 @@ static void objrefs_init (void);
 static void objrefs_cleanup (void);
 
 static void ids_init (void);
+
 static void ids_cleanup (void);
 
 static void suspend_init (void);
@@ -478,19 +471,13 @@ static MonoContext* tls_get_restore_state (void *the_tls);
 static gboolean try_process_suspend (void *tls, MonoContext *ctx, gboolean from_breakpoint);
 static gboolean begin_breakpoint_processing (void *tls, MonoContext *ctx, MonoJitInfo *ji, gboolean from_signal);
 static void begin_single_step_processing (MonoContext *ctx, gboolean from_signal);
-static void ss_discard_frame_context (void *the_tls);
-static void ss_calculate_framecount (void *tls, MonoContext *ctx, gboolean force_use_ctx, DbgEngineStackFrame ***frames, int *nframes);
 static gboolean ensure_jit (DbgEngineStackFrame* the_frame);
 static int ensure_runtime_is_suspended (void);
-static int get_this_async_id (DbgEngineStackFrame *frame);
-static void* create_breakpoint_events (GPtrArray *ss_reqs, GPtrArray *bp_reqs, MonoJitInfo *ji, EventKind kind);
-static void process_breakpoint_events (void *_evts, MonoMethod *method, MonoContext *ctx, int il_offset);
-static int ss_create_init_args (SingleStepReq *ss_req, SingleStepArgs *args);
-static void ss_args_destroy (SingleStepArgs *ss_args);
 static int handle_multiple_ss_requests (void);
 
 static GENERATE_TRY_GET_CLASS_WITH_CACHE (fixed_buffer, "System.Runtime.CompilerServices", "FixedBufferAttribute")
 
+
 #ifndef DISABLE_SOCKET_TRANSPORT
 static void
 register_socket_transport (void);
@@ -710,17 +697,17 @@ debugger_agent_init (void)
 	cbs.try_process_suspend = try_process_suspend;
 	cbs.begin_breakpoint_processing = begin_breakpoint_processing;
 	cbs.begin_single_step_processing = begin_single_step_processing;
-	cbs.ss_discard_frame_context = ss_discard_frame_context;
-	cbs.ss_calculate_framecount = ss_calculate_framecount;
+	cbs.ss_discard_frame_context = mono_ss_discard_frame_context;
+	cbs.ss_calculate_framecount = mono_ss_calculate_framecount;
 	cbs.ensure_jit = ensure_jit;
 	cbs.ensure_runtime_is_suspended = ensure_runtime_is_suspended;
-	cbs.get_this_async_id = get_this_async_id;
+	cbs.get_this_async_id = mono_get_this_async_id;
 	cbs.set_set_notification_for_wait_completion_flag = set_set_notification_for_wait_completion_flag;
 	cbs.get_notify_debugger_of_wait_completion_method = get_notify_debugger_of_wait_completion_method;
-	cbs.create_breakpoint_events = create_breakpoint_events;
-	cbs.process_breakpoint_events = process_breakpoint_events;
-	cbs.ss_create_init_args = ss_create_init_args;
-	cbs.ss_args_destroy = ss_args_destroy;
+	cbs.create_breakpoint_events = mono_dbg_create_breakpoint_events;
+	cbs.process_breakpoint_events = mono_dbg_process_breakpoint_events;
+	cbs.ss_create_init_args = mono_ss_create_init_args;
+	cbs.ss_args_destroy = mono_ss_args_destroy;
 	cbs.handle_multiple_ss_requests = handle_multiple_ss_requests;
 
 	mono_de_init (&cbs);
@@ -1287,9 +1274,6 @@ static DebuggerTransport *transport;
 static DebuggerTransport transports [MAX_TRANSPORTS];
 static int ntransports;
 
-MONO_API void
-mono_debugger_agent_register_transport (DebuggerTransport *trans);
-
 void
 mono_debugger_agent_register_transport (DebuggerTransport *trans)
 {
@@ -1590,6 +1574,24 @@ static GHashTable *obj_to_objref;
 /* Protected by the dbg lock */
 static MonoGHashTable *suspended_objs;
 
+#ifdef TARGET_WASM
+void mono_init_debugger_agent_for_wasm (int log_level_parm)
+{
+	if (mono_atomic_cas_i32 (&agent_inited, 1, 0) == 1)
+		return;
+
+	ids_init();
+	objrefs = g_hash_table_new_full (NULL, NULL, NULL, mono_debugger_free_objref);
+	obj_to_objref = g_hash_table_new (NULL, NULL);
+
+	log_level = log_level;
+	event_requests = g_ptr_array_new ();
+	vm_start_event_sent = TRUE;
+	transport = &transports [0];
+	memset(&debugger_wasm_thread, 0, sizeof(DebuggerTlsData));
+	agent_config.enabled = TRUE;
+}
+#endif
 
 
 static void
@@ -1986,7 +1988,6 @@ static int
 buffer_add_ptr_id (Buffer *buf, MonoDomain *domain, IdType type, gpointer val)
 {
 	int id = get_id (domain, type, val);
-
 	buffer_add_id (buf, id);
 	return id;
 }
@@ -2176,6 +2177,21 @@ save_thread_context (MonoContext *ctx)
 		mono_thread_state_init_from_current (&tls->context);
 }
 
+#ifdef TARGET_WASM
+void
+mono_wasm_save_thread_context (void) 
+{
+	debugger_wasm_thread.really_suspended = TRUE;
+	mono_thread_state_init_from_current (&debugger_wasm_thread.context);
+}
+
+DebuggerTlsData*
+mono_wasm_get_tls (void) 
+{
+	return &debugger_wasm_thread;
+}
+#endif
+
 static MonoCoopMutex suspend_mutex;
 
 /* Cond variable used to wait for suspend_count becoming 0 */
@@ -2700,7 +2716,8 @@ static int
 count_threads_to_wait_for (void)
 {
 	int count = 0;
-
+	if (thread_to_tls == NULL)
+		return 0;
 	mono_loader_lock ();
 	mono_g_hash_table_foreach (thread_to_tls, count_thread, &count);
 	mono_loader_unlock ();
@@ -3049,7 +3066,7 @@ compute_frame_info (MonoInternalThread *thread, DebuggerTlsData *tls, gboolean f
 	tls->frames = new_frames;
 	tls->frame_count = new_frame_count;
 	tls->frames_up_to_date = TRUE;
-
+#ifndef TARGET_WASM
 	if (CHECK_PROTOCOL_VERSION (2, 52)) {
 		MonoJitTlsData *jit_data = thread->thread_info->jit_data;
 		gboolean has_interp_resume_state = FALSE;
@@ -3064,6 +3081,7 @@ compute_frame_info (MonoInternalThread *thread, DebuggerTlsData *tls, gboolean f
 			}
 		}
 	}
+#endif	
 }
 
 /*
@@ -3494,7 +3512,7 @@ process_event (EventKind event, gpointer arg, gint32 il_offset, MonoContext *ctx
 				return;
 		}
 	}
-	
+
 	if (event == EVENT_KIND_VM_START) 
 		suspend_policy = agent_config.suspend ? SUSPEND_POLICY_ALL : SUSPEND_POLICY_NONE;	
 	
@@ -3552,12 +3570,10 @@ process_event (EventKind event, gpointer arg, gint32 il_offset, MonoContext *ctx
 			break;
 		case EVENT_KIND_BREAKPOINT:
 		case EVENT_KIND_STEP: {
-			DebuggerTlsData *tls;
-			tls = (DebuggerTlsData *)mono_native_tls_get_value (debugger_tls_id);
+			GET_DEBUGGER_TLS();
 			g_assert (tls);
 			mono_stopwatch_stop (&tls->step_time);
 			MonoMethod *method = (MonoMethod *)arg;
-
 			buffer_add_methodid (&buf, domain, method);
 			buffer_add_long (&buf, il_offset);
 			break;
@@ -3578,6 +3594,9 @@ process_event (EventKind event, gpointer arg, gint32 il_offset, MonoContext *ctx
 		case EVENT_KIND_EXCEPTION: {
 			EventInfo *ei = (EventInfo *)arg;
 			buffer_add_objid (&buf, ei->exc);
+#ifdef TARGET_WASM
+			buffer_add_byte (&buf, ei->caught);
+#endif				
 			/*
 			 * We are not yet suspending, so get_objref () will not keep this object alive. So we need to do it
 			 * later after the suspension. (#12494).
@@ -3586,8 +3605,7 @@ process_event (EventKind event, gpointer arg, gint32 il_offset, MonoContext *ctx
 			break;
 		}
 		case EVENT_KIND_USER_BREAK: {
-			DebuggerTlsData *tls;
-			tls = (DebuggerTlsData *)mono_native_tls_get_value (debugger_tls_id);
+			GET_DEBUGGER_TLS();
 			g_assert (tls);
 			// We are already processing a breakpoint event
 			if (tls->disable_breakpoints)
@@ -4042,14 +4060,18 @@ event_requests_cleanup (void)
  *
  * Ensure DebuggerTlsData fields are filled out.
  */
-static void
-ss_calculate_framecount (void *the_tls, MonoContext *ctx, gboolean force_use_ctx, DbgEngineStackFrame ***frames, int *nframes)
+void
+mono_ss_calculate_framecount (void *the_tls, MonoContext *ctx, gboolean force_use_ctx, DbgEngineStackFrame ***frames, int *nframes)
 {
 	DebuggerTlsData *tls = (DebuggerTlsData*)the_tls;
-
+#ifndef TARGET_WASM	
 	if (force_use_ctx || !tls->context.valid)
 		mono_thread_state_init_from_monoctx (&tls->context, ctx);
 	compute_frame_info (tls->thread, tls, FALSE);
+#else
+	compute_frame_info (tls->thread, tls, TRUE);
+#endif
+
 	if (frames)
 		*frames = (DbgEngineStackFrame**)tls->frames;
 	if (nframes)
@@ -4061,8 +4083,8 @@ ss_calculate_framecount (void *the_tls, MonoContext *ctx, gboolean force_use_ctx
  *
  * Discard frame data and invalidate any context
  */
-static void
-ss_discard_frame_context (void *the_tls)
+void
+mono_ss_discard_frame_context (void *the_tls)
 {
 	DebuggerTlsData *tls = (DebuggerTlsData*)the_tls;
 	tls->context.valid = FALSE;
@@ -4107,8 +4129,8 @@ breakpoint_matches_assembly (MonoBreakpoint *bp, MonoAssembly *assembly)
 
 //This ID is used to figure out if breakpoint hit on resumeOffset belongs to us or not
 //since thread probably changed...
-static int
-get_this_async_id (DbgEngineStackFrame *frame)
+int
+mono_get_this_async_id (DbgEngineStackFrame *frame)
 {
 	MonoClassField *builder_field;
 	gpointer builder;
@@ -4161,8 +4183,11 @@ begin_breakpoint_processing (void *the_tls, MonoContext *ctx, MonoJitInfo *ji, g
 	 * Skip the instruction causing the breakpoint signal.
 	 */
 	if (from_signal)
+#ifdef MONO_ARCH_SOFT_DEBUG_SUPPORTED
 		mono_arch_skip_breakpoint (ctx, ji);
-
+#else
+		NOT_IMPLEMENTED;
+#endif
 	if (tls->disable_breakpoints)
 		return FALSE;
 	return TRUE;
@@ -4174,8 +4199,8 @@ typedef struct {
 	int suspend_policy;
 } BreakPointEvents;
 
-static void*
-create_breakpoint_events (GPtrArray *ss_reqs, GPtrArray *bp_reqs, MonoJitInfo *ji, EventKind kind)
+void*
+mono_dbg_create_breakpoint_events (GPtrArray *ss_reqs, GPtrArray *bp_reqs, MonoJitInfo *ji, EventKind kind)
 {
 	int suspend_policy = 0;
 	BreakPointEvents *evts = g_new0 (BreakPointEvents, 1);
@@ -4191,8 +4216,8 @@ create_breakpoint_events (GPtrArray *ss_reqs, GPtrArray *bp_reqs, MonoJitInfo *j
 	return evts;
 }
 
-static void
-process_breakpoint_events (void *_evts, MonoMethod *method, MonoContext *ctx, int il_offset)
+void
+mono_dbg_process_breakpoint_events (void *_evts, MonoMethod *method, MonoContext *ctx, int il_offset)
 {
 	BreakPointEvents *evts = (BreakPointEvents*)_evts;
 	/*
@@ -4301,8 +4326,8 @@ user_break_cb (StackFrameInfo *frame, MonoContext *ctx, gpointer user_data)
 /*
  * Called by System.Diagnostics.Debugger:Break ().
  */
-static void
-debugger_agent_user_break (void)
+void
+mono_dbg_debugger_agent_user_break (void)
 {
 	if (agent_config.enabled) {
 		MonoContext ctx;
@@ -4332,7 +4357,11 @@ static void
 begin_single_step_processing (MonoContext *ctx, gboolean from_signal)
 {
 	if (from_signal)
+#ifdef MONO_ARCH_SOFT_DEBUG_SUPPORTED
 		mono_arch_skip_single_step (ctx);
+#else
+		NOT_IMPLEMENTED;
+#endif
 }
 
 static void
@@ -4364,7 +4393,11 @@ debugger_agent_single_step_event (void *sigctx)
 		MonoContext ctx;
 
 		mono_sigctx_to_monoctx (sigctx, &ctx);
+#ifdef MONO_ARCH_SOFT_DEBUG_SUPPORTED
 		mono_arch_skip_single_step (&ctx);
+#else
+		NOT_IMPLEMENTED;
+#endif
 		mono_monoctx_to_sigctx (&ctx, sigctx);
 		return;
 	}
@@ -4444,8 +4477,8 @@ debugger_agent_breakpoint_from_context (MonoContext *ctx)
 	if (MONO_CONTEXT_GET_IP (ctx) == orig_ip - 1)
 		MONO_CONTEXT_SET_IP (ctx, orig_ip);
 }
-static void
-ss_args_destroy (SingleStepArgs *ss_args)
+void
+mono_ss_args_destroy (SingleStepArgs *ss_args)
 {
 	if (ss_args->frames)
 		free_frames ((StackFrame**)ss_args->frames, ss_args->nframes);
@@ -4470,8 +4503,8 @@ ensure_runtime_is_suspended (void)
 	return ERR_NONE;
 }
 
-static int
-ss_create_init_args (SingleStepReq *ss_req, SingleStepArgs *args)
+int
+mono_ss_create_init_args (SingleStepReq *ss_req, SingleStepArgs *args)
 {
 	MonoSeqPointInfo *info = NULL;
 	gboolean found_sp;
@@ -4481,10 +4514,9 @@ ss_create_init_args (SingleStepReq *ss_req, SingleStepArgs *args)
 	gboolean set_ip = FALSE;
 	StackFrame **frames = NULL;
 	int nframes = 0;
-
-	mono_loader_lock ();
-	DebuggerTlsData *tls = (DebuggerTlsData *)mono_g_hash_table_lookup (thread_to_tls, ss_req->thread);
-	mono_loader_unlock ();
+	
+	GET_TLS_DATA_FROM_THREAD (ss_req->thread);
+	
 	g_assert (tls);
 	if (!tls->context.valid) {
 		PRINT_DEBUG_MSG (1, "Received a single step request on a thread with no managed frames.\n");
@@ -4727,8 +4759,8 @@ debugger_agent_unhandled_exception (MonoException *exc)
 	process_event (EVENT_KIND_EXCEPTION, &ei, 0, NULL, events, suspend_policy);
 }
 
-static void
-debugger_agent_handle_exception (MonoException *exc, MonoContext *throw_ctx,
+void
+mono_debugger_agent_handle_exception (MonoException *exc, MonoContext *throw_ctx,
 									  MonoContext *catch_ctx, StackFrameInfo *catch_frame)
 {
 	if (catch_ctx == NULL && catch_frame == NULL && mini_debug_options.suspend_on_unhandled && mono_object_class (exc) != mono_defaults.threadabortexception_class) {
@@ -4736,23 +4768,15 @@ debugger_agent_handle_exception (MonoException *exc, MonoContext *throw_ctx,
 		while (1)
 			;
 	}
-	
 	int i, j, suspend_policy;
 	GSList *events;
 	MonoJitInfo *ji, *catch_ji;
 	EventInfo ei;
-	DebuggerTlsData *tls = NULL;
-
-	if (thread_to_tls != NULL) {
-		MonoInternalThread *thread = mono_thread_internal_current ();
-
-		mono_loader_lock ();
-		tls = (DebuggerTlsData *)mono_g_hash_table_lookup (thread_to_tls, thread);
-		mono_loader_unlock ();
-
-		if (tls && tls->abort_requested)
+	GET_TLS_DATA_FROM_THREAD (mono_thread_internal_current ());
+	if (tls != NULL) {
+		if (tls->abort_requested)
 			return;
-		if (tls && tls->disable_breakpoints)
+		if (tls->disable_breakpoints)
 			return;
 	}
 
@@ -4965,7 +4989,10 @@ buffer_add_info_for_null_value (Buffer* buf, MonoType* t, MonoDomain* domain)
 		buffer_add_int (buf, m_class_get_rank (mono_class_from_mono_type_internal (t)));
 		if (m_class_get_byval_arg (m_class_get_element_class (mono_class_from_mono_type_internal (t)))->type == MONO_TYPE_CLASS)
 			buffer_add_typeid (buf, domain, m_class_get_element_class (mono_class_from_mono_type_internal (t)));
+		buffer_add_typeid (buf, domain, mono_class_from_mono_type_internal (t));			
 		break;
+	default:
+		buffer_add_typeid (buf, domain, mono_class_from_mono_type_internal (t));
 	}
 }
 /*
@@ -5149,6 +5176,9 @@ buffer_add_value_full (Buffer *buf, MonoType *t, void *addr, MonoDomain *domain,
 
 		buffer_add_byte (buf, MONO_TYPE_VALUETYPE);
 		buffer_add_byte (buf, m_class_is_enumtype (klass));
+
+		if (CHECK_PROTOCOL_VERSION(2, 61))
+			buffer_add_byte(buf, boxed_vtype);
 		buffer_add_typeid (buf, domain, klass);
 
 		nfields = 0;
@@ -5222,9 +5252,8 @@ decode_vtype (MonoType *t, MonoDomain *domain, gpointer void_addr, gpointer void
 	ErrorCode err;
 
 	is_enum = decode_byte (buf, &buf, limit);
-	/* Enums are sent as a normal vtype */
-	if (is_enum)
-		return ERR_NOT_IMPLEMENTED;
+	if (CHECK_PROTOCOL_VERSION(2, 61))
+		decode_byte (buf, &buf, limit);
 	klass = decode_typeid (buf, &buf, limit, &d, &err);
 	if (err != ERR_NONE)
 		return err;
@@ -5413,7 +5442,7 @@ decode_value_internal (MonoType *t, int type, MonoDomain *domain, guint8 *addr,
 	handle_ref:
 	default:
 		if (MONO_TYPE_IS_REFERENCE (t)) {
-			if (type == MONO_TYPE_OBJECT || type == MONO_TYPE_STRING) {
+			if (type == MONO_TYPE_CLASS || type == MONO_TYPE_OBJECT || type == MONO_TYPE_STRING) {
 				int objid = decode_objid (buf, &buf, limit);
 				ErrorCode err;
 				MonoObject *obj;
@@ -5435,7 +5464,12 @@ decode_value_internal (MonoType *t, int type, MonoDomain *domain, guint8 *addr,
 
 				mono_gc_wbarrier_generic_store_internal (addr, obj);
 			} else if (type == VALUE_TYPE_ID_NULL) {
+				if (CHECK_PROTOCOL_VERSION (2, 59)) {
+					decode_byte (buf, &buf, limit);
+					decode_int (buf, &buf, limit); //not used
+				}
 				*(MonoObject**)addr = NULL;
+
 			} else if (type == MONO_TYPE_VALUETYPE) {
 				ERROR_DECL (error);
 				guint8 *buf2;
@@ -5452,8 +5486,7 @@ decode_value_internal (MonoType *t, int type, MonoDomain *domain, guint8 *addr,
 				*/
 				buf2 = buf;
 				is_enum = decode_byte (buf, &buf, limit);
-				if (is_enum)
-					return ERR_NOT_IMPLEMENTED;
+				decode_byte (buf, &buf, limit); //ignore is boxed
 				klass = decode_typeid (buf, &buf, limit, &d, &err);
 				if (err != ERR_NONE)
 					return err;
@@ -5913,8 +5946,8 @@ add_thread (gpointer key, gpointer value, gpointer user_data)
 }
 
 
-static ErrorCode
-do_invoke_method (DebuggerTlsData *tls, Buffer *buf, InvokeData *invoke, guint8 *p, guint8 **endp)
+ErrorCode
+mono_do_invoke_method (DebuggerTlsData *tls, Buffer *buf, InvokeData *invoke, guint8 *p, guint8 **endp)
 {
 	ERROR_DECL (error);
 	guint8 *end = invoke->endp;
@@ -5981,7 +6014,7 @@ do_invoke_method (DebuggerTlsData *tls, Buffer *buf, InvokeData *invoke, guint8
 					return err;
 			}
 	} else {
-		if (!(m->flags & METHOD_ATTRIBUTE_STATIC && CHECK_PROTOCOL_VERSION (2, 59))) { //on icordbg I couldn't find an object when invoking a static method maybe I can change this later
+		if (!(m->flags & METHOD_ATTRIBUTE_STATIC) || (m->flags & METHOD_ATTRIBUTE_STATIC && !CHECK_PROTOCOL_VERSION (2, 59))) { //on icordbg I couldn't find an object when invoking a static method maybe I can change this later
 			err = decode_value(m_class_get_byval_arg(m->klass), domain, this_buf, p, &p, end, FALSE);
 			if (err != ERR_NONE)
 				return err;
@@ -6236,7 +6269,7 @@ invoke_method (void)
 		if (err) {
 			/* Fail the other invokes as well */
 		} else {
-			err = do_invoke_method (tls, &buf, invoke, p, &p);
+			err = mono_do_invoke_method (tls, &buf, invoke, p, &p);
 		}
 
 		if (tls->abort_requested) {
@@ -6455,7 +6488,6 @@ get_types_for_source_file (gpointer key, gpointer value, gpointer user_data)
 static gboolean
 module_apply_changes (MonoImage *image, MonoArray *dmeta, MonoArray *dil, MonoArray *dpdb, MonoError *error)
 {
-#ifdef ENABLE_METADATA_UPDATE
 	/* TODO: use dpdb */
 	gpointer dmeta_bytes = (gpointer)mono_array_addr_internal (dmeta, char, 0);
 	int32_t dmeta_len = mono_array_length_internal (dmeta);
@@ -6465,10 +6497,6 @@ module_apply_changes (MonoImage *image, MonoArray *dmeta, MonoArray *dil, MonoAr
 	int32_t dpdb_len G_GNUC_UNUSED = !dpdb ? 0 : mono_array_length_internal (dpdb);
 	mono_image_load_enc_delta (image, dmeta_bytes, dmeta_len, dil_bytes, dil_len, error);
 	return is_ok (error);
-#else
-	mono_error_set_not_supported (error, "");
-	return FALSE;
-#endif
 }
 	
 
@@ -6934,6 +6962,39 @@ vm_commands (int command, int id, guint8 *p, guint8 *end, Buffer *buf)
 		buffer_add_byte_array (buf, memory, size);
 		break;
 	}
+	case MDBGPROT_CMD_GET_ASSEMBLY_BY_NAME: {
+		int i;
+		char* assembly_name = decode_string (p, &p, end);
+		//we get 'foo.dll' but mono_assembly_load expects 'foo' so we strip the last dot
+		char *lookup_name = g_strdup (assembly_name);
+		for (i = strlen (lookup_name) - 1; i >= 0; --i) {
+			if (lookup_name [i] == '.') {
+				lookup_name [i] = 0;
+				break;
+			}
+		}
+
+		//resolve the assembly
+		MonoImageOpenStatus status;
+		MonoAssemblyName* aname = mono_assembly_name_new (lookup_name);
+		if (!aname) {
+			PRINT_DEBUG_MSG (1, "Could not resolve assembly %s\n", assembly_name);
+			buffer_add_int(buf, -1);
+			break;
+		}
+		MonoAssemblyByNameRequest byname_req;
+		mono_assembly_request_prepare_byname (&byname_req, MONO_ASMCTX_DEFAULT, mono_alc_get_default ());
+		MonoAssembly *assembly = mono_assembly_request_byname (aname, &byname_req, &status);
+		g_free (lookup_name);
+		mono_assembly_name_free_internal (aname);		
+		if (!assembly) {
+			PRINT_DEBUG_MSG (1, "Could not resolve assembly %s\n", assembly_name);
+			buffer_add_int(buf, -1);
+			break;
+		}
+		buffer_add_assemblyid (buf, mono_get_root_domain (), assembly);
+		break;
+	}
 	default:
 		return ERR_NOT_IMPLEMENTED;
 	}
@@ -7096,10 +7157,9 @@ event_commands (int command, guint8 *p, guint8 *end, Buffer *buf)
 				g_free (req);
 				return err;
 			}
+
+			GET_TLS_DATA_FROM_THREAD (THREAD_TO_INTERNAL(step_thread));
 			
-			mono_loader_lock ();
-			DebuggerTlsData *tls = (DebuggerTlsData *)mono_g_hash_table_lookup (thread_to_tls, THREAD_TO_INTERNAL(step_thread));
-			mono_loader_unlock ();
 			g_assert (tls);
 		
 			if (tls->terminated) { 
@@ -7113,6 +7173,22 @@ event_commands (int command, guint8 *p, guint8 *end, Buffer *buf)
 				g_free (req);
 				return err;
 			}
+#ifdef TARGET_WASM			
+			int isBPOnManagedCode = 0;
+			SingleStepReq *ss_req = req->info;
+			if (ss_req && ss_req->bps) {
+				GSList *l;
+
+				for (l = ss_req->bps; l; l = l->next) {
+					if (((MonoBreakpoint *)l->data)->method->wrapper_type != MONO_WRAPPER_RUNTIME_INVOKE)
+						isBPOnManagedCode = 1;
+				}
+			}
+			if (!isBPOnManagedCode) {
+				mono_de_cancel_all_ss ();
+			}
+			buffer_add_byte (buf, isBPOnManagedCode);
+#endif
 		} else if (req->event_kind == EVENT_KIND_METHOD_ENTRY) {
 			req->info = mono_de_set_breakpoint (NULL, METHOD_ENTRY_IL_OFFSET, req, NULL);
 		} else if (req->event_kind == EVENT_KIND_METHOD_EXIT) {
@@ -7743,7 +7819,11 @@ type_commands_internal (int command, MonoClass *klass, MonoDomain *domain, guint
 		buffer_add_string (buf, m_class_get_name_space (klass));
 		buffer_add_string (buf, m_class_get_name (klass));
 		// FIXME: byref
-		name = mono_type_get_name_full (m_class_get_byval_arg (klass), MONO_TYPE_NAME_FORMAT_FULL_NAME);
+		
+		MonoTypeNameFormat format = MONO_TYPE_NAME_FORMAT_FULL_NAME;
+		if (CHECK_PROTOCOL_VERSION(2, 61))
+			format = (MonoTypeNameFormat) decode_int (p, &p, end);
+		name = mono_type_get_name_full (m_class_get_byval_arg (klass), format);
 		buffer_add_string (buf, name);
 		g_free (name);
 		buffer_add_assemblyid (buf, domain, m_class_get_image (klass)->assembly);
@@ -8187,6 +8267,23 @@ type_commands_internal (int command, MonoClass *klass, MonoDomain *domain, guint
 		buffer_add_int (buf, value_size);
 		break;
 	}
+	case MDBGPROT_CMD_TYPE_GET_PARENTS: {
+		MonoClass *parent_klass = m_class_get_parent (klass);
+		int count = 0;
+		while (parent_klass != NULL)
+		{
+			count++;
+			parent_klass = m_class_get_parent (parent_klass);
+		}
+		buffer_add_int (buf, count);
+		parent_klass = m_class_get_parent (klass);
+		while (parent_klass != NULL)
+		{
+			buffer_add_typeid (buf, domain, parent_klass);
+			parent_klass = m_class_get_parent (parent_klass);
+		}
+		break;
+	}
 	default:
 		err = ERR_NOT_IMPLEMENTED;
 		goto exit;
@@ -8242,7 +8339,11 @@ method_commands_internal (int command, MonoMethod *method, MonoDomain *domain, g
 	switch (command) {
 	case CMD_METHOD_GET_NAME: {
 		buffer_add_string (buf, method->name);
-		break;			
+		break;
+	}
+	case MDBGPROT_CMD_METHOD_GET_NAME_FULL: {
+		buffer_add_string (buf, mono_method_full_name (method, FALSE));
+		break;
 	}
 	case MDBGPROT_CMD_METHOD_GET_CLASS_TOKEN: {
 		buffer_add_int (buf, m_class_get_type_token (method->klass));
@@ -8681,6 +8782,16 @@ method_commands_internal (int command, MonoMethod *method, MonoDomain *domain, g
 		buffer_add_assemblyid(buf, mono_domain_get (), m_class_get_image(method->klass)->assembly);
 		break;
 	}
+	case MDBGPROT_CMD_METHOD_HAS_ASYNC_DEBUG_INFO: {
+		MonoDebugMethodAsyncInfo* async_method = mono_debug_lookup_method_async_debug_info (method);
+		if (async_method) {
+			buffer_add_byte(buf, TRUE);
+			mono_debug_free_method_async_debug_info (async_method);
+		}
+		else
+			buffer_add_byte(buf, FALSE);
+		break;
+	}
 	default:
 		return ERR_NOT_IMPLEMENTED;
 	}
@@ -8766,7 +8877,6 @@ thread_commands (int command, guint8 *p, guint8 *end, Buffer *buf)
 		break;
 	}
 	case MDBGPROT_CMD_THREAD_GET_CONTEXT: {
-		DebuggerTlsData *tls;
 		int start_frame;
 		while (!is_suspended ()) {
 			if (suspend_count)
@@ -8774,9 +8884,7 @@ thread_commands (int command, guint8 *p, guint8 *end, Buffer *buf)
 		}
 		start_frame = decode_int (p, &p, end);
 
-		mono_loader_lock ();
-		tls = (DebuggerTlsData *)mono_g_hash_table_lookup (thread_to_tls, thread);
-		mono_loader_unlock ();
+		GET_TLS_DATA_FROM_THREAD (thread);
 		if (tls == NULL)
 			return ERR_UNLOADED;
 
@@ -8789,7 +8897,6 @@ thread_commands (int command, guint8 *p, guint8 *end, Buffer *buf)
 		break;
 	}
 	case CMD_THREAD_GET_FRAME_INFO: {
-		DebuggerTlsData *tls;
 		int i, start_frame, length;
 
 		// Wait for suspending if it already started
@@ -8810,10 +8917,7 @@ thread_commands (int command, guint8 *p, guint8 *end, Buffer *buf)
 
 		if (start_frame != 0 || length != -1)
 			return ERR_NOT_IMPLEMENTED;
-
-		mono_loader_lock ();
-		tls = (DebuggerTlsData *)mono_g_hash_table_lookup (thread_to_tls, thread);
-		mono_loader_unlock ();
+		GET_TLS_DATA_FROM_THREAD (thread);
 		if (tls == NULL)
 			return ERR_UNLOADED;
 
@@ -8985,7 +9089,6 @@ frame_commands (int command, guint8 *p, guint8 *end, Buffer *buf)
 	MonoThread *thread_obj;
 	MonoInternalThread *thread;
 	int pos, i, len, frame_idx;
-	DebuggerTlsData *tls;
 	StackFrame *frame;
 	MonoDebugMethodJitInfo *jit;
 	MonoMethodSignature *sig;
@@ -9002,9 +9105,7 @@ frame_commands (int command, guint8 *p, guint8 *end, Buffer *buf)
 
 	id = decode_id (p, &p, end);
 
-	mono_loader_lock ();
-	tls = (DebuggerTlsData *)mono_g_hash_table_lookup (thread_to_tls, thread);
-	mono_loader_unlock ();
+	GET_TLS_DATA_FROM_THREAD (thread);
 	g_assert (tls);
 
 	for (i = 0; i < tls->frame_count; ++i) {
@@ -9015,7 +9116,7 @@ frame_commands (int command, guint8 *p, guint8 *end, Buffer *buf)
 		return ERR_INVALID_FRAMEID;
 
 	/* The thread is still running native code, can't get frame variables info */
-	if (!tls->really_suspended && !tls->async_state.valid) 
+	if (!tls->really_suspended && !tls->async_state.valid)
 		return ERR_NOT_SUSPENDED;
 	frame_idx = i;
 	frame = tls->frames [frame_idx];
@@ -9579,6 +9680,17 @@ object_commands (int command, guint8 *p, guint8 *end, Buffer *buf)
 		buffer_add_typeid (buf, obj->vtable->domain, mono_class_from_mono_type_internal (((MonoReflectionType*)obj->vtable->type)->type));
 		buffer_add_domainid (buf, obj->vtable->domain);
 		break;
+	case MDBGPROT_CMD_OBJECT_REF_DELEGATE_GET_METHOD:
+		buffer_add_methodid (buf, obj->vtable->domain, ((MonoDelegate *)obj)->method);
+		break;
+	case MDBGPROT_CMD_OBJECT_IS_DELEGATE: {
+		MonoType *type = m_class_get_byval_arg (obj_type);
+		if (m_class_is_delegate (obj_type) || (type->type == MONO_TYPE_GENERICINST && m_class_is_delegate (type->data.generic_class->container_class)))
+			buffer_add_byte (buf, TRUE);
+		else
+			buffer_add_byte (buf, FALSE);
+		break;
+	}
 	default:
 		err = ERR_NOT_IMPLEMENTED;
 		goto exit;
@@ -9895,6 +10007,62 @@ wait_for_attach (void)
 	return TRUE;
 }
 
+ErrorCode
+mono_process_dbg_packet (int id, CommandSet command_set, int command, gboolean *no_reply, guint8 *buf, guint8 *end, Buffer *ret_buf)
+{
+	ErrorCode err;
+	/* Process the request */
+	switch (command_set) {
+	case CMD_SET_VM:
+		err = vm_commands (command, id, buf, end, ret_buf);
+		if (err == ERR_NONE && command == CMD_VM_INVOKE_METHOD)
+			/* Sent after the invoke is complete */
+			*no_reply = TRUE;
+		break;
+	case CMD_SET_EVENT_REQUEST:
+		err = event_commands (command, buf, end, ret_buf);
+		break;
+	case CMD_SET_APPDOMAIN:
+		err = domain_commands (command, buf, end, ret_buf);
+		break;
+	case CMD_SET_ASSEMBLY:
+		err = assembly_commands (command, buf, end, ret_buf);
+		break;
+	case CMD_SET_MODULE:
+		err = module_commands (command, buf, end, ret_buf);
+		break;
+	case CMD_SET_FIELD:
+		err = field_commands (command, buf, end, ret_buf);
+		break;
+	case CMD_SET_TYPE:
+		err = type_commands (command, buf, end, ret_buf);
+		break;
+	case CMD_SET_METHOD:
+		err = method_commands (command, buf, end, ret_buf);
+		break;
+	case CMD_SET_THREAD:
+		err = thread_commands (command, buf, end, ret_buf);
+		break;
+	case CMD_SET_STACK_FRAME:
+		err = frame_commands (command, buf, end, ret_buf);
+		break;
+	case CMD_SET_ARRAY_REF:
+		err = array_commands (command, buf, end, ret_buf);
+		break;
+	case CMD_SET_STRING_REF:
+		err = string_commands (command, buf, end, ret_buf);
+		break;
+	case CMD_SET_POINTER:
+		err = pointer_commands (command, buf, end, ret_buf);
+		break;
+	case CMD_SET_OBJECT_REF:
+		err = object_commands (command, buf, end, ret_buf);
+		break;
+	default:
+		err = ERR_NOT_IMPLEMENTED;
+	}
+	return err;
+}
 /*
  * debugger_thread:
  *
@@ -9990,57 +10158,7 @@ debugger_thread (void *arg)
 
 		err = ERR_NONE;
 		no_reply = FALSE;
-
-		/* Process the request */
-		switch (command_set) {
-		case CMD_SET_VM:
-			err = vm_commands (command, id, p, end, &buf);
-			if (err == ERR_NONE && command == CMD_VM_INVOKE_METHOD)
-				/* Sent after the invoke is complete */
-				no_reply = TRUE;
-			break;
-		case CMD_SET_EVENT_REQUEST:
-			err = event_commands (command, p, end, &buf);
-			break;
-		case CMD_SET_APPDOMAIN:
-			err = domain_commands (command, p, end, &buf);
-			break;
-		case CMD_SET_ASSEMBLY:
-			err = assembly_commands (command, p, end, &buf);
-			break;
-		case CMD_SET_MODULE:
-			err = module_commands (command, p, end, &buf);
-			break;
-		case CMD_SET_FIELD:
-			err = field_commands (command, p, end, &buf);
-			break;
-		case CMD_SET_TYPE:
-			err = type_commands (command, p, end, &buf);
-			break;
-		case CMD_SET_METHOD:
-			err = method_commands (command, p, end, &buf);
-			break;
-		case CMD_SET_THREAD:
-			err = thread_commands (command, p, end, &buf);
-			break;
-		case CMD_SET_STACK_FRAME:
-			err = frame_commands (command, p, end, &buf);
-			break;
-		case CMD_SET_ARRAY_REF:
-			err = array_commands (command, p, end, &buf);
-			break;
-		case CMD_SET_STRING_REF:
-			err = string_commands (command, p, end, &buf);
-			break;
-		case CMD_SET_POINTER:
-			err = pointer_commands (command, p, end, &buf);
-			break;
-		case CMD_SET_OBJECT_REF:
-			err = object_commands (command, p, end, &buf);
-			break;
-		default:
-			err = ERR_NOT_IMPLEMENTED;
-		}		
+		err = mono_process_dbg_packet (id, command_set, command, &no_reply, p, end, &buf);	
 
 		if (command_set == CMD_SET_VM && command == CMD_VM_START_BUFFERING) {
 			buffer_replies = TRUE;
@@ -10111,10 +10229,10 @@ mono_debugger_agent_init (void)
 	cbs.breakpoint_from_context = debugger_agent_breakpoint_from_context;
 	cbs.free_mem_manager = debugger_agent_free_mem_manager;
 	cbs.unhandled_exception = debugger_agent_unhandled_exception;
-	cbs.handle_exception = debugger_agent_handle_exception;
+	cbs.handle_exception = mono_debugger_agent_handle_exception;
 	cbs.begin_exception_filter = debugger_agent_begin_exception_filter;
 	cbs.end_exception_filter = debugger_agent_end_exception_filter;
-	cbs.user_break = debugger_agent_user_break;
+	cbs.user_break = mono_dbg_debugger_agent_user_break;
 	cbs.debug_log = debugger_agent_debug_log;
 	cbs.debug_log_is_enabled = debugger_agent_debug_log_is_enabled;
 	cbs.send_crash = mono_debugger_agent_send_crash;
diff --git a/src/mono/mono/mini/debugger-agent.h b/src/mono/mono/mini/debugger-agent.h
index 500e8e610c3b54..bf0a06e2056fef 100644
--- a/src/mono/mono/mini/debugger-agent.h
+++ b/src/mono/mono/mini/debugger-agent.h
@@ -6,12 +6,45 @@
 #define __MONO_DEBUGGER_AGENT_H__
 
 #include "mini.h"
+#include "debugger-protocol.h"
+
 #include <mono/utils/mono-stack-unwinding.h>
 
 #define MONO_DBG_CALLBACKS_VERSION (4)
 // 2. debug_log parameters changed from MonoString* to MonoStringHandle
 // 3. debug_log parameters changed from MonoStringHandle back to MonoString*
 
+typedef struct _InvokeData InvokeData;
+
+struct _InvokeData
+{
+	int id;
+	int flags;
+	guint8 *p;
+	guint8 *endp;
+	/* This is the context which needs to be restored after the invoke */
+	MonoContext ctx;
+	gboolean has_ctx;
+	/*
+	 * If this is set, invoke this method with the arguments given by ARGS.
+	 */
+	MonoMethod *method;
+	gpointer *args;
+	guint32 suspend_count;
+	int nmethods;
+
+	InvokeData *last_invoke;
+};
+
+typedef struct {
+	const char *name;
+	void (*connect) (const char *address);
+	void (*close1) (void);
+	void (*close2) (void);
+	gboolean (*send) (void *buf, int len);
+	int (*recv) (void *buf, int len);
+} DebuggerTransport;
+
 struct _MonoDebuggerCallbacks {
 	int version;
 	void (*parse_options) (char *options);
@@ -46,4 +79,37 @@ mono_debugger_agent_stub_init (void);
 MONO_API MONO_RT_EXTERNAL_ONLY gboolean
 mono_debugger_agent_transport_handshake (void);
 
+MONO_API void
+mono_debugger_agent_register_transport (DebuggerTransport *trans);
+
+MdbgProtErrorCode
+mono_process_dbg_packet (int id, MdbgProtCommandSet command_set, int command, gboolean *no_reply, guint8 *p, guint8 *end, MdbgProtBuffer *buf);
+
+void
+mono_init_debugger_agent_for_wasm (int log_level);
+
+void*
+mono_dbg_create_breakpoint_events (GPtrArray *ss_reqs, GPtrArray *bp_reqs, MonoJitInfo *ji, MdbgProtEventKind kind);
+
+void
+mono_dbg_process_breakpoint_events (void *_evts, MonoMethod *method, MonoContext *ctx, int il_offset);
+
+void 
+mono_dbg_debugger_agent_user_break (void);
+
+void
+mono_wasm_save_thread_context (void);
+
+DebuggerTlsData*
+mono_wasm_get_tls (void);
+
+MdbgProtErrorCode
+mono_do_invoke_method (DebuggerTlsData *tls, MdbgProtBuffer *buf, InvokeData *invoke, guint8 *p, guint8 **endp);
+
+void
+mono_debugger_agent_handle_exception (MonoException *exc, MonoContext *throw_ctx, MonoContext *catch_ctx, StackFrameInfo *catch_frame);
+
+void 
+mono_ss_discard_frame_context (void *the_tls);
+
 #endif
diff --git a/src/mono/mono/mini/debugger-engine.c b/src/mono/mono/mini/debugger-engine.c
index 2008b51338ac85..8c85227e8420cd 100644
--- a/src/mono/mono/mini/debugger-engine.c
+++ b/src/mono/mono/mini/debugger-engine.c
@@ -388,13 +388,6 @@ collect_domain_bp (gpointer key, gpointer value, gpointer user_data)
 	jit_mm_unlock (jit_mm);
 }
 
-void
-mono_de_clear_all_breakpoints (void)
-{
-	while (breakpoints->len)
-		mono_de_clear_breakpoint ((MonoBreakpoint*)g_ptr_array_index (breakpoints, 0));
-}
-
 /*
  * mono_de_set_breakpoint:
  *
@@ -1609,13 +1602,14 @@ mono_debugger_free_objref (gpointer value)
 // Returns true if TaskBuilder has NotifyDebuggerOfWaitCompletion method
 // false if not(AsyncVoidBuilder)
 MonoClass *
-get_class_to_get_builder_field(DbgEngineStackFrame *frame)
+get_class_to_get_builder_field (DbgEngineStackFrame *frame)
 {
 	ERROR_DECL (error);
+	StackFrame *the_frame = (StackFrame *)frame;
 	gpointer this_addr = get_this_addr (frame);
 	MonoClass *original_class = frame->method->klass;
 	MonoClass *ret;
-	if (!m_class_is_valuetype (original_class) && mono_class_is_open_constructed_type (m_class_get_byval_arg (original_class))) {
+	if (mono_class_is_open_constructed_type (m_class_get_byval_arg (original_class))) {
 		MonoObject *this_obj = *(MonoObject**)this_addr;
 		MonoGenericContext context;
 		MonoType *inflated_type;
@@ -1623,7 +1617,7 @@ get_class_to_get_builder_field(DbgEngineStackFrame *frame)
 		if (!this_obj)
 			return NULL;
 			
-		context = mono_get_generic_context_from_stack_frame (frame->ji, this_obj->vtable);
+		context = mono_get_generic_context_from_stack_frame (frame->ji, mono_get_generic_info_from_stack_frame (frame->ji, &the_frame->ctx));
 		inflated_type = mono_class_inflate_generic_type_checked (m_class_get_byval_arg (original_class), &context, error);
 		mono_error_assert_ok (error); /* FIXME don't swallow the error */
 
diff --git a/src/mono/mono/mini/debugger-engine.h b/src/mono/mono/mini/debugger-engine.h
index 24ad575093e696..20fe88fedb8d76 100644
--- a/src/mono/mono/mini/debugger-engine.h
+++ b/src/mono/mono/mini/debugger-engine.h
@@ -497,7 +497,6 @@ MonoBreakpoint* mono_de_set_breakpoint (MonoMethod *method, long il_offset, Even
 void mono_de_collect_breakpoints_by_sp (SeqPoint *sp, MonoJitInfo *ji, GPtrArray *ss_reqs, GPtrArray *bp_reqs);
 void mono_de_clear_breakpoints_for_domain (MonoDomain *domain);
 void mono_de_add_pending_breakpoints (MonoMethod *method, MonoJitInfo *ji);
-void mono_de_clear_all_breakpoints (void);
 MonoBreakpoint * mono_de_get_breakpoint_by_id (int id);
 
 //single stepping
@@ -545,3 +544,15 @@ void win32_debugger_log(FILE *stream, const gchar *format, ...);
 #define PRINT_ERROR_MSG(...) g_printerr (__VA_ARGS__)
 #define PRINT_MSG(...) g_print (__VA_ARGS__)
 #endif
+
+int 
+mono_ss_create_init_args (SingleStepReq *ss_req, SingleStepArgs *args);
+
+void
+mono_ss_args_destroy (SingleStepArgs *ss_args);
+
+int 
+mono_get_this_async_id (DbgEngineStackFrame *frame);
+
+void 
+mono_ss_calculate_framecount (void *tls, MonoContext *ctx, gboolean force_use_ctx, DbgEngineStackFrame ***frames, int *nframes);
diff --git a/src/mono/mono/mini/debugger-protocol.c b/src/mono/mono/mini/debugger-protocol.c
index 1402dae3d36efe..2fe3096608a511 100644
--- a/src/mono/mono/mini/debugger-protocol.c
+++ b/src/mono/mono/mini/debugger-protocol.c
@@ -56,7 +56,6 @@ m_dbgprot_decode_int (uint8_t *buf, uint8_t **endbuf, uint8_t *limit)
 {
 	*endbuf = buf + 4;
 	g_assert (*endbuf <= limit);
-
 	return (((int)buf [0]) << 24) | (((int)buf [1]) << 16) | (((int)buf [2]) << 8) | (((int)buf [3]) << 0);
 }
 
diff --git a/src/mono/mono/mini/debugger-protocol.h b/src/mono/mono/mini/debugger-protocol.h
index 87d9e232c851af..24e8a2e42c27e6 100644
--- a/src/mono/mono/mini/debugger-protocol.h
+++ b/src/mono/mono/mini/debugger-protocol.h
@@ -34,7 +34,8 @@ typedef enum {
 	MDBGPROT_CMD_VM_START_BUFFERING = 14,
 	MDBGPROT_CMD_VM_STOP_BUFFERING = 15,
 	MDBGPROT_CMD_VM_READ_MEMORY = 16,
-	MDBGPROT_CMD_VM_WRITE_MEMORY = 17
+	MDBGPROT_CMD_VM_WRITE_MEMORY = 17,
+	MDBGPROT_CMD_GET_ASSEMBLY_BY_NAME = 18
 } MdbgProtCmdVM;
 
 typedef enum {
@@ -173,7 +174,9 @@ typedef enum {
 	MDBGPROT_CMD_METHOD_MAKE_GENERIC_METHOD = 10,
 	MDBGPROT_CMD_METHOD_TOKEN = 11,
 	MDBGPROT_CMD_METHOD_ASSEMBLY = 12,
-	MDBGPROT_CMD_METHOD_GET_CLASS_TOKEN = 13
+	MDBGPROT_CMD_METHOD_GET_CLASS_TOKEN = 13,
+	MDBGPROT_CMD_METHOD_HAS_ASYNC_DEBUG_INFO = 14,
+	MDBGPROT_CMD_METHOD_GET_NAME_FULL = 15
 } MdbgProtCmdMethod;
 
 typedef enum {
@@ -197,7 +200,8 @@ typedef enum {
 	MDBGPROT_CMD_TYPE_IS_INITIALIZED = 18,
 	MDBGPROT_CMD_TYPE_CREATE_INSTANCE = 19,
 	MDBGPROT_CMD_TYPE_GET_VALUE_SIZE = 20,
-	MDBGPROT_CMD_TYPE_GET_VALUES_ICORDBG = 21
+	MDBGPROT_CMD_TYPE_GET_VALUES_ICORDBG = 21,
+	MDBGPROT_CMD_TYPE_GET_PARENTS = 22
 } MdbgProtCmdType;
 
 typedef enum {
@@ -235,7 +239,9 @@ typedef enum {
 	MDBGPROT_CMD_OBJECT_REF_GET_DOMAIN = 5,
 	MDBGPROT_CMD_OBJECT_REF_SET_VALUES = 6,
 	MDBGPROT_CMD_OBJECT_REF_GET_INFO = 7,
-	MDBGPROT_CMD_OBJECT_REF_GET_VALUES_ICORDBG = 8
+	MDBGPROT_CMD_OBJECT_REF_GET_VALUES_ICORDBG = 8,
+	MDBGPROT_CMD_OBJECT_REF_DELEGATE_GET_METHOD = 9,
+	MDBGPROT_CMD_OBJECT_IS_DELEGATE = 10
 } MdbgProtCmdObject;
 
 typedef enum {
diff --git a/src/mono/mono/mini/ee.h b/src/mono/mono/mini/ee.h
index 3e1d07039c475f..ba2796207f091e 100644
--- a/src/mono/mono/mini/ee.h
+++ b/src/mono/mono/mini/ee.h
@@ -14,7 +14,7 @@
 #ifndef __MONO_EE_H__
 #define __MONO_EE_H__
 
-#define MONO_EE_API_VERSION 0x11
+#define MONO_EE_API_VERSION 0x12
 
 typedef struct _MonoInterpStackIter MonoInterpStackIter;
 
@@ -56,7 +56,6 @@ typedef gpointer MonoInterpFrameHandle;
 	MONO_EE_CALLBACK (void, stop_single_stepping, (void)) \
 	MONO_EE_CALLBACK (void, free_context, (gpointer)) \
 	MONO_EE_CALLBACK (void, set_optimizations, (guint32)) \
-	MONO_EE_CALLBACK (void, metadata_update_init, (MonoError *error)) \
 	MONO_EE_CALLBACK (void, invalidate_transformed, (void)) \
 	MONO_EE_CALLBACK (void, cleanup, (void)) \
 	MONO_EE_CALLBACK (void, mark_stack, (gpointer thread_info, GcScanFunc func, gpointer gc_data, gboolean precise)) \
diff --git a/src/mono/mono/mini/interp-stubs.c b/src/mono/mono/mini/interp-stubs.c
index 4dff348a93eed4..8aa96e0183ccb6 100644
--- a/src/mono/mono/mini/interp-stubs.c
+++ b/src/mono/mono/mini/interp-stubs.c
@@ -79,11 +79,6 @@ stub_set_optimizations (guint32 i)
 {
 }
 
-static void
-stub_metadata_update_init (MonoError *error)
-{
-}
-
 static void
 stub_invalidate_transformed (void)
 {
diff --git a/src/mono/mono/mini/interp/interp-internals.h b/src/mono/mono/mini/interp/interp-internals.h
index 2afac6e27ddc1b..465fd20240fa45 100644
--- a/src/mono/mono/mini/interp/interp-internals.h
+++ b/src/mono/mono/mini/interp/interp-internals.h
@@ -124,6 +124,7 @@ struct InterpMethod {
 	MonoType *rtype;
 	MonoType **param_types;
 	MonoJitInfo *jinfo;
+	MonoFtnDesc *ftndesc;
 
 	guint32 locals_size;
 	guint32 alloca_size;
diff --git a/src/mono/mono/mini/interp/interp.c b/src/mono/mono/mini/interp/interp.c
index 2b92e7f160e22e..1c7468ba3cadc7 100644
--- a/src/mono/mono/mini/interp/interp.c
+++ b/src/mono/mono/mini/interp/interp.c
@@ -959,7 +959,6 @@ interp_throw (ThreadContext *context, MonoException *ex, InterpFrame *frame, con
 	ERROR_DECL (error);
 	MonoLMFExt ext;
 
-	interp_push_lmf (&ext, frame);
 	/*
 	 * When explicitly throwing exception we pass the ip of the instruction that throws the exception.
 	 * Offset the subtraction from interp_frame_get_ip, so we don't end up in prev instruction.
@@ -985,21 +984,11 @@ interp_throw (ThreadContext *context, MonoException *ex, InterpFrame *frame, con
 	 * Since ctx.ip is 0, this will start unwinding from the LMF frame
 	 * pushed above, which points to our frames.
 	 */
-	HandleExceptionCbData cb_data = { ex, &ctx };
-	if (mono_aot_mode == MONO_AOT_MODE_LLVMONLY_INTERP) {
-		gboolean thrown = FALSE;
-		/*
-		 * If the exception is uncaught in interpreter code, mono_handle_exception_internal () will rethrow it.
-		 * Catch and rethrow it here again so we can pop the LMF.
-		 */
-		mono_llvm_cpp_catch_exception (handle_exception_cb, &cb_data, &thrown);
-		if (thrown) {
-			interp_pop_lmf (&ext);
-			mono_llvm_rethrow_exception ((MonoObject*)ex);
-		}
-	} else {
-		handle_exception_cb (&cb_data);
-	}
+	interp_push_lmf (&ext, frame);
+
+	mono_handle_exception (&ctx, (MonoObject*)ex);
+
+	interp_pop_lmf (&ext);
 
 	if (MONO_CONTEXT_GET_IP (&ctx) != 0) {
 		/* We need to unwind into non-interpreter code */
@@ -1007,8 +996,6 @@ interp_throw (ThreadContext *context, MonoException *ex, InterpFrame *frame, con
 		g_assert_not_reached ();
 	}
 
-	interp_pop_lmf (&ext);
-
 	g_assert (context->has_resume_state);
 }
 
@@ -1633,6 +1620,9 @@ interp_init_delegate (MonoDelegate *del, MonoError *error)
 	} if (del->method_ptr && !del->method) {
 		/* Delegate created from methodInfo.MethodHandle.GetFunctionPointer() */
 		del->interp_method = (InterpMethod *)del->method_ptr;
+		if (mono_llvm_only)
+			// FIXME:
+			g_assert_not_reached ();
 	} else if (del->method) {
 		/* Delegate created dynamically */
 		del->interp_method = mono_interp_get_imethod (del->method, error);
@@ -1672,13 +1662,57 @@ interp_init_delegate (MonoDelegate *del, MonoError *error)
 	}
 }
 
+/* Convert a function pointer for a managed method to an InterpMethod* */
+static InterpMethod*
+ftnptr_to_imethod (gpointer addr)
+{
+	InterpMethod *imethod;
+
+	if (mono_llvm_only) {
+		ERROR_DECL (error);
+		/* Function pointers are represented by a MonoFtnDesc structure */
+		MonoFtnDesc *ftndesc = (MonoFtnDesc*)addr;
+		g_assert (ftndesc);
+		g_assert (ftndesc->method);
+
+		imethod = ftndesc->interp_method;
+		if (!imethod) {
+			imethod = mono_interp_get_imethod (ftndesc->method, error);
+			mono_error_assert_ok (error);
+			mono_memory_barrier ();
+			ftndesc->interp_method = imethod;
+		}
+	} else {
+		/* Function pointers are represented by their InterpMethod */
+		imethod = (InterpMethod*)addr;
+	}
+	return imethod;
+}
+
+static gpointer
+imethod_to_ftnptr (InterpMethod *imethod)
+{
+	if (mono_llvm_only) {
+		ERROR_DECL (error);
+		/* Function pointers are represented by a MonoFtnDesc structure */
+		MonoFtnDesc *ftndesc = imethod->ftndesc;
+		if (!ftndesc) {
+			ftndesc = mini_llvmonly_load_method_ftndesc (imethod->method, FALSE, FALSE, error);
+			mono_error_assert_ok (error);
+			mono_memory_barrier ();
+			imethod->ftndesc = ftndesc;
+		}
+		return ftndesc;
+	} else {
+		return imethod;
+	}
+}
+
 static void
 interp_delegate_ctor (MonoObjectHandle this_obj, MonoObjectHandle target, gpointer addr, MonoError *error)
 {
-	/*
-	 * addr is the result of an LDFTN opcode, i.e. an InterpMethod
-	 */
-	InterpMethod *imethod = (InterpMethod*)addr;
+	/* addr is the result of an LDFTN opcode */
+	InterpMethod *imethod = ftnptr_to_imethod (addr);
 
 	if (!(imethod->method->flags & METHOD_ATTRIBUTE_STATIC)) {
 		MonoMethod *invoke = mono_get_delegate_invoke_internal (mono_handle_class (this_obj));
@@ -1982,7 +2016,6 @@ interp_entry (InterpEntryData *data)
 
 	context->stack_pointer = (guchar*)sp;
 
-	g_assert (!context->has_resume_state);
 	g_assert (!context->safepoint_frame);
 
 	if (rmethod->needs_thread_attach)
@@ -1990,6 +2023,7 @@ interp_entry (InterpEntryData *data)
 
 	if (mono_llvm_only) {
 		if (context->has_resume_state)
+			/* The exception will be handled in a frame above us */
 			mono_llvm_reraise_exception ((MonoException*)mono_gchandle_get_target_internal (context->exc_gchandle));
 	} else {
 		g_assert (!context->has_resume_state);
@@ -2313,7 +2347,7 @@ init_jit_call_info (InterpMethod *rmethod, MonoError *error)
 }
 
 static MONO_NEVER_INLINE void
-do_jit_call (stackval *ret_sp, stackval *sp, InterpFrame *frame, InterpMethod *rmethod, MonoError *error)
+do_jit_call (ThreadContext *context, stackval *ret_sp, stackval *sp, InterpFrame *frame, InterpMethod *rmethod, MonoError *error)
 {
 	MonoLMFExt ext;
 	JitCallInfo *cinfo;
@@ -2370,8 +2404,14 @@ do_jit_call (stackval *ret_sp, stackval *sp, InterpFrame *frame, InterpMethod *r
 	}
 	interp_pop_lmf (&ext);
 	if (thrown) {
+		if (context->has_resume_state)
+			/*
+			 * This happens when interp_entry calls mono_llvm_reraise_exception ().
+			 */
+			return;
 		MonoObject *obj = mono_llvm_load_exception ();
 		g_assert (obj);
+		mono_llvm_clear_exception ();
 		mono_error_set_exception_instance (error, (MonoException*)obj);
 		return;
 	}
@@ -3427,7 +3467,9 @@ interp_exec_method (InterpFrame *frame, ThreadContext *context, FrameClauseArgs
 
 			csignature = (MonoMethodSignature*)frame->imethod->data_items [ip [4]];
 
-			cmethod = LOCAL_VAR (ip [2], InterpMethod*);
+			/* In mixed mode, stay in the interpreter for simplicity even if there is an AOT version of the callee */
+			cmethod = ftnptr_to_imethod (LOCAL_VAR (ip [2], gpointer));
+
 			if (cmethod->method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL) {
 				cmethod = mono_interp_get_imethod (mono_marshal_get_native_wrapper (cmethod->method, FALSE, FALSE), error);
 				mono_interp_error_cleanup (error); /* FIXME: don't swallow the error */
@@ -3536,7 +3578,7 @@ interp_exec_method (InterpFrame *frame, ThreadContext *context, FrameClauseArgs
 			} else if (code_type == IMETHOD_CODE_COMPILED) {
 				frame->state.ip = ip;
 				error_init_reuse (error);
-				do_jit_call ((stackval*)(locals + return_offset), (stackval*)(locals + call_args_offset), frame, cmethod, error);
+				do_jit_call (context, (stackval*)(locals + return_offset), (stackval*)(locals + call_args_offset), frame, cmethod, error);
 				if (!is_ok (error)) {
 					MonoException *ex = mono_error_convert_to_exception (error);
 					THROW_EX (ex, ip);
@@ -3631,7 +3673,7 @@ interp_exec_method (InterpFrame *frame, ThreadContext *context, FrameClauseArgs
 			error_init_reuse (error);
 			/* for calls, have ip pointing at the start of next instruction */
 			frame->state.ip = ip + 4;
-			do_jit_call ((stackval*)(locals + ip [1]), (stackval*)(locals + ip [2]), frame, rmethod, error);
+			do_jit_call (context, (stackval*)(locals + ip [1]), (stackval*)(locals + ip [2]), frame, rmethod, error);
 			if (!is_ok (error)) {
 				MonoException *ex = mono_error_convert_to_exception (error);
 				THROW_EX (ex, ip);
@@ -3649,7 +3691,7 @@ interp_exec_method (InterpFrame *frame, ThreadContext *context, FrameClauseArgs
 			error_init_reuse (error);
 
 			frame->state.ip = ip + 6;
-			do_jit_call ((stackval*)(locals + ip [1]), frame, rmethod, error);
+			do_jit_call (context, (stackval*)(locals + ip [1]), frame, rmethod, error);
 			if (!is_ok (error)) {
 				MonoException *ex = mono_error_convert_to_exception (error);
 				THROW_EX (ex, ip);
@@ -6462,25 +6504,36 @@ MINT_IN_CASE(MINT_BRTRUE_I8_SP) ZEROP_SP(gint64, !=); MINT_IN_BREAK;
 #undef RELOP_FP
 #undef RELOP_CAST
 
-		MINT_IN_CASE(MINT_LDFTN) {
+		MINT_IN_CASE(MINT_LDFTN_ADDR) {
 			LOCAL_VAR (ip [1], gpointer) = frame->imethod->data_items [ip [2]];
 			ip += 3;
 			MINT_IN_BREAK;
 		}
+		MINT_IN_CASE(MINT_LDFTN) {
+			InterpMethod *m = (InterpMethod*)frame->imethod->data_items [ip [2]];
+
+			LOCAL_VAR (ip [1], gpointer) = imethod_to_ftnptr (m);
+			ip += 3;
+			MINT_IN_BREAK;
+		}
 		MINT_IN_CASE(MINT_LDVIRTFTN) {
 			InterpMethod *m = (InterpMethod*)frame->imethod->data_items [ip [3]];
 			MonoObject *o = LOCAL_VAR (ip [2], MonoObject*);
 			NULL_CHECK (o);
-				
-			LOCAL_VAR (ip [1], gpointer) = get_virtual_method (m, o->vtable);
+
+			m = get_virtual_method (m, o->vtable);
+			LOCAL_VAR (ip [1], gpointer) = imethod_to_ftnptr (m);
 			ip += 4;
 			MINT_IN_BREAK;
 		}
 		MINT_IN_CASE(MINT_LDFTN_DYNAMIC) {
 			error_init_reuse (error);
-			InterpMethod *m = mono_interp_get_imethod (LOCAL_VAR (ip [2], MonoMethod*), error);
+
+			MonoMethod *cmethod = LOCAL_VAR (ip [2], MonoMethod*);
+
+			InterpMethod *m = mono_interp_get_imethod (cmethod, error);
 			mono_error_assert_ok (error);
-			LOCAL_VAR (ip [1], gpointer) = m;
+			LOCAL_VAR (ip [1], gpointer) = imethod_to_ftnptr (m);
 			ip += 3;
 			MINT_IN_BREAK;
 		}
@@ -6662,7 +6715,7 @@ MINT_IN_CASE(MINT_BRTRUE_I8_SP) ZEROP_SP(gint64, !=); MINT_IN_BREAK;
 				mono_error_assert_ok (error);
 			}
 			g_assert (del->interp_method);
-			LOCAL_VAR (ip [1], gpointer) = del->interp_method;
+			LOCAL_VAR (ip [1], gpointer) = imethod_to_ftnptr (del->interp_method);
 			ip += 3;
 			MINT_IN_BREAK;
 		}
@@ -7337,12 +7390,6 @@ copy_imethod_for_frame (InterpFrame *frame)
 	 */
 }
 
-static void
-interp_metadata_update_init (MonoError *error)
-{
-}
-
-#ifdef ENABLE_METADATA_UPDATE
 static void
 metadata_update_backup_frames (MonoThreadInfo *info, InterpFrame *frame)
 {
@@ -7388,18 +7435,17 @@ metadata_update_prepare_to_invalidate (void)
 
 	/* (2) invalidate all the registered imethods */
 }
-#endif
 
 
 static void
 interp_invalidate_transformed (void)
 {
 	gboolean need_stw_restart = FALSE;
-#ifdef ENABLE_METADATA_UPDATE
-	need_stw_restart = TRUE;
-	mono_stop_world (MONO_THREAD_INFO_FLAGS_NO_GC);
-	metadata_update_prepare_to_invalidate ();
-#endif
+        if (mono_metadata_has_updates ()) {
+                mono_stop_world (MONO_THREAD_INFO_FLAGS_NO_GC);
+                metadata_update_prepare_to_invalidate ();
+                need_stw_restart = TRUE;
+        }
 
 	// FIXME: Enumerate all memory managers
 	MonoJitMemoryManager *jit_mm = get_default_jit_mm ();
diff --git a/src/mono/mono/mini/interp/mintops.def b/src/mono/mono/mini/interp/mintops.def
index 1f55c92ec59000..0de870874beca4 100644
--- a/src/mono/mono/mini/interp/mintops.def
+++ b/src/mono/mono/mini/interp/mintops.def
@@ -356,6 +356,7 @@ OPDEF(MINT_BOX_NULLABLE_PTR, "box.nullable.ptr", 4, 1, 1, MintOpShortInt)
 OPDEF(MINT_UNBOX, "unbox", 4, 1, 1, MintOpClassToken)
 OPDEF(MINT_LDTOKEN, "ldtoken", 3, 1, 0, MintOpShortInt)
 OPDEF(MINT_LDFTN, "ldftn", 3, 1, 0, MintOpMethodToken)
+OPDEF(MINT_LDFTN_ADDR, "ldftn_addr", 3, 1, 0, MintOpMethodToken)
 OPDEF(MINT_LDFTN_DYNAMIC, "ldftn.dynamic", 3, 1, 1, MintOpMethodToken)
 OPDEF(MINT_LDVIRTFTN, "ldvirtftn", 4, 1, 1, MintOpMethodToken)
 OPDEF(MINT_CPOBJ, "cpobj", 4, 0, 2, MintOpClassToken)
diff --git a/src/mono/mono/mini/interp/transform.c b/src/mono/mono/mini/interp/transform.c
index f6a710f34a49b1..e4651250385769 100644
--- a/src/mono/mono/mini/interp/transform.c
+++ b/src/mono/mono/mini/interp/transform.c
@@ -27,6 +27,7 @@
 
 #include <mono/mini/mini.h>
 #include <mono/mini/mini-runtime.h>
+#include <mono/mini/aot-runtime.h>
 
 #include "mintops.h"
 #include "interp-internals.h"
@@ -544,27 +545,26 @@ push_types (TransformData *td, StackInfo *types, int count)
 }
 
 static void
-mark_bb_as_dead (TransformData *td, InterpBasicBlock *bb)
+mark_bb_as_dead (TransformData *td, InterpBasicBlock *bb, InterpBasicBlock *replace_bb)
 {
 	// Update IL offset to bb mapping so that offset_to_bb doesn't point to dead
 	// bblocks. This mapping can still be needed when computing clause ranges. Since
 	// multiple IL offsets can end up pointing to same bblock after optimizations,
 	// make sure we update mapping for all of them
-	if (bb->ip >= td->header->code && bb->ip < td->il_code + td->header->code_size) {
-		// To avoid scanning the entire offset_to_bb array, we scan only in the vicinity
-		// of the IL offset of bb. We can stop search when we encounter a different bblock.
-		for (int il_offset = bb->ip - td->il_code; il_offset >= 0; il_offset--) {
-			if (td->offset_to_bb [il_offset] == bb)
-				td->offset_to_bb [il_offset] = bb->next_bb;
-			else if (td->offset_to_bb [il_offset])
-				break;
-		}
-		for (int il_offset = bb->ip - td->il_code + 1; il_offset < td->header->code_size; il_offset++) {
-			if (td->offset_to_bb [il_offset] == bb)
-				td->offset_to_bb [il_offset] = bb->next_bb;
-			else if (td->offset_to_bb [il_offset])
-				break;
-		}
+	//
+	// To avoid scanning the entire offset_to_bb array, we scan only in the vicinity
+	// of the IL offset of bb. We can stop search when we encounter a different bblock.
+	for (int il_offset = bb->il_offset; il_offset >= 0; il_offset--) {
+		if (td->offset_to_bb [il_offset] == bb)
+			td->offset_to_bb [il_offset] = replace_bb;
+		else if (td->offset_to_bb [il_offset])
+			break;
+	}
+	for (int il_offset = bb->il_offset + 1; il_offset < td->header->code_size; il_offset++) {
+		if (td->offset_to_bb [il_offset] == bb)
+			td->offset_to_bb [il_offset] = replace_bb;
+		else if (td->offset_to_bb [il_offset])
+			break;
 	}
 
 	bb->dead = TRUE;
@@ -615,7 +615,7 @@ interp_merge_bblocks (TransformData *td, InterpBasicBlock *bb, InterpBasicBlock
 		}
 	}
 
-	mark_bb_as_dead (td, bbadd);
+	mark_bb_as_dead (td, bbadd, bb);
 }
 
 // array must contain ref
@@ -659,7 +659,7 @@ interp_remove_bblock (TransformData *td, InterpBasicBlock *bb, InterpBasicBlock
 	while (bb->out_count)
 		interp_unlink_bblocks (bb, bb->out_bb [0]);
 	prev_bb->next_bb = bb->next_bb;
-	mark_bb_as_dead (td, bb);
+	mark_bb_as_dead (td, bb, bb->next_bb);
 
 	return needs_cprop;
 }
@@ -1145,11 +1145,18 @@ mono_interp_jit_call_supported (MonoMethod *method, MonoMethodSignature *sig)
 	if (method->wrapper_type != MONO_WRAPPER_NONE)
 		return FALSE;
 
+	if (method->flags & METHOD_ATTRIBUTE_REQSECOBJ)
+		/* Used to mark methods containing StackCrawlMark locals */
+		return FALSE;
+
 	if (mono_aot_only && m_class_get_image (method->klass)->aot_module && !(method->iflags & METHOD_IMPL_ATTRIBUTE_SYNCHRONIZED)) {
 		ERROR_DECL (error);
-		gpointer addr = mono_jit_compile_method_jit_only (method, error);
-		if (addr && is_ok (error))
-			return TRUE;
+		gpointer addr = mono_aot_get_method (method, error);
+		if (addr && is_ok (error)) {
+			MonoAotMethodFlags flags = mono_aot_get_method_flags (addr);
+			if (!(flags & MONO_AOT_METHOD_FLAG_INTERP_ENTRY_ONLY))
+				return TRUE;
+		}
 	}
 
 	for (l = mono_interp_jit_classes; l; l = l->next) {
@@ -2417,13 +2424,51 @@ interp_handle_intrinsics (TransformData *td, MonoMethod *target_method, MonoClas
 	} else if (in_corlib && !strcmp (klass_name_space, "System") && !strcmp (klass_name, "RuntimeMethodHandle") && !strcmp (tm, "GetFunctionPointer") && csignature->param_count == 1) {
 		// We must intrinsify this method on interp so we don't return a pointer to native code entering interpreter
 		*op = MINT_LDFTN_DYNAMIC;
-	} else if (in_corlib && target_method->klass == mono_defaults.systemtype_class && !strcmp (target_method->name, "op_Equality")) {
+	} else if (in_corlib && target_method->klass == mono_defaults.systemtype_class && !strcmp (target_method->name, "op_Equality") &&
+			td->sp [-1].klass == mono_defaults.runtimetype_class && td->sp [-2].klass == mono_defaults.runtimetype_class) {
+		// We do a reference comparison only if we know both operands are runtime type
+		// (they originate from object.GetType or ldftn + GetTypeFromHandle)
 		*op = MINT_CEQ_P;
 	} else if (in_corlib && target_method->klass == mono_defaults.object_class) {
-		if (!strcmp (tm, "InternalGetHashCode"))
+		if (!strcmp (tm, "InternalGetHashCode")) {
 			*op = MINT_INTRINS_GET_HASHCODE;
-		else if (!strcmp (tm, "GetType"))
-			*op = MINT_INTRINS_GET_TYPE;
+		} else if (!strcmp (tm, "GetType")) {
+			if (constrained_class && m_class_is_valuetype (constrained_class)) {
+				// If constrained_class is valuetype we already know its type.
+				// Resolve GetType to a constant so we can fold type comparisons
+				ERROR_DECL(error);
+				gpointer systype = mono_type_get_object_checked (m_class_get_byval_arg (constrained_class), error);
+				return_val_if_nok (error, FALSE);
+
+				td->sp--;
+				interp_add_ins (td, MINT_MONO_LDPTR);
+				push_type (td, STACK_TYPE_O, mono_defaults.runtimetype_class);
+				interp_ins_set_dreg (td->last_ins, td->sp [-1].local);
+				td->last_ins->data [0] = get_data_item_index (td, systype);
+
+				td->ip += 5;
+				return TRUE;
+			} else {
+				if (constrained_class) {
+					// deref the managed pointer to get the object
+					interp_add_ins (td, MINT_LDIND_I);
+					td->sp--;
+					interp_ins_set_sreg (td->last_ins, td->sp [0].local);
+					push_simple_type (td, STACK_TYPE_O);
+					interp_ins_set_dreg (td->last_ins, td->sp [-1].local);
+				}
+				interp_add_ins (td, MINT_INTRINS_GET_TYPE);
+				td->sp--;
+				interp_ins_set_sreg (td->last_ins, td->sp [0].local);
+				push_type (td, STACK_TYPE_O, mono_defaults.runtimetype_class);
+				interp_ins_set_dreg (td->last_ins, td->sp [-1].local);
+
+				mono_class_init_internal (target_method->klass);
+
+				td->ip += 5;
+				return TRUE;
+			}
+		}
 	} else if (in_corlib && target_method->klass == mono_defaults.enum_class && !strcmp (tm, "HasFlag")) {
 		gboolean intrinsify = FALSE;
 		MonoClass *base_klass = NULL;
@@ -2876,6 +2921,14 @@ interp_inline_method (TransformData *td, MonoMethod *target_method, MonoMethodHe
 
 		interp_link_bblocks (td, prev_cbb, td->entry_bb);
 		prev_cbb->next_bb = td->entry_bb;
+
+		// Make sure all bblocks that were added will now be offset from the original method that
+		// is being transformed.
+		InterpBasicBlock *tmp_bb = td->entry_bb;
+		while (tmp_bb != NULL) {
+			tmp_bb->il_offset = prev_ip - prev_il_code;
+			tmp_bb = tmp_bb->next_bb;
+		}
 	}
 
 	td->ip = prev_ip;
@@ -3496,7 +3549,7 @@ get_bb (TransformData *td, unsigned char *ip, gboolean make_list)
 
 	if (!bb) {
 		bb = (InterpBasicBlock*)mono_mempool_alloc0 (td->mempool, sizeof (InterpBasicBlock));
-		bb->ip = ip;
+		bb->il_offset = offset;
 		bb->native_offset = -1;
 		bb->stack_height = -1;
 		bb->index = td->bb_count++;
@@ -4092,14 +4145,21 @@ interp_emit_sfld_access (TransformData *td, MonoClassField *field, MonoClass *fi
 
 		// Do a load/store to this address
 		if (is_load) {
-			int opcode = (mt == MINT_TYPE_VT) ? MINT_LDOBJ_VT : interp_get_ldind_for_mt (mt);
-			interp_add_ins (td, opcode);
-			interp_ins_set_sreg (td->last_ins, td->sp [-1].local);
-			td->sp--;
-			push_simple_type (td, stack_type [mt]);
-			interp_ins_set_dreg (td->last_ins, td->sp [-1].local);
-			if (mt == MINT_TYPE_VT)
-				td->last_ins->data [0] = get_data_item_index (td, field_class);
+			if (mt == MINT_TYPE_VT) {
+				int field_size = mono_class_value_size (field_class, NULL);
+				interp_add_ins (td, MINT_LDOBJ_VT);
+				interp_ins_set_sreg (td->last_ins, td->sp [-1].local);
+				td->sp--;
+				push_type_vt (td, field_class, field_size);
+				interp_ins_set_dreg (td->last_ins, td->sp [-1].local);
+				td->last_ins->data [0] = field_size;
+			} else {
+				interp_add_ins (td, interp_get_ldind_for_mt (mt));
+				interp_ins_set_sreg (td->last_ins, td->sp [-1].local);
+				td->sp--;
+				push_type (td, stack_type [mt], field_class);
+				interp_ins_set_dreg (td->last_ins, td->sp [-1].local);
+			}
 		} else {
 			int opcode = (mt == MINT_TYPE_VT) ? MINT_STOBJ_VT : interp_get_stind_for_mt (mt);
 			interp_add_ins (td, opcode);
@@ -6711,7 +6771,7 @@ generate_code (TransformData *td, MonoMethod *method, MonoMethodHeader *header,
 				interp_add_ins (td, MINT_MONO_LDPTR);
 				gpointer systype = mono_type_get_object_checked ((MonoType*)handle, error);
 				goto_if_nok (error, exit);
-				push_simple_type (td, STACK_TYPE_MP);
+				push_type (td, STACK_TYPE_O, mono_defaults.runtimetype_class);
 				interp_ins_set_dreg (td->last_ins, td->sp [-1].local);
 				td->last_ins->data [0] = get_data_item_index (td, systype);
 				td->ip = next_ip + 5;
@@ -6837,7 +6897,7 @@ generate_code (TransformData *td, MonoMethod *method, MonoMethodHeader *header,
 					td->ip += 5;
 					const gconstpointer func = mono_find_jit_icall_info ((MonoJitICallId)token)->func;
 
-					interp_add_ins (td, MINT_LDFTN);
+					interp_add_ins (td, MINT_LDFTN_ADDR);
 					push_simple_type (td, STACK_TYPE_I);
 					interp_ins_set_dreg (td->last_ins, td->sp [-1].local);
 					td->last_ins->data [0] = get_data_item_index (td, (gpointer)func);
@@ -9581,9 +9641,7 @@ mono_interp_transform_method (InterpMethod *imethod, ThreadContext *context, Mon
 
 	error_init (error);
 
-#ifdef ENABLE_METADATA_UPDATE
 	mono_metadata_update_thread_expose_published ();
-#endif
 
 	if (mono_class_is_open_constructed_type (m_class_get_byval_arg (method->klass))) {
 		mono_error_set_invalid_operation (error, "%s", "Could not execute the method because the containing type is not fully instantiated.");
diff --git a/src/mono/mono/mini/interp/transform.h b/src/mono/mono/mini/interp/transform.h
index 4d9aa9233283f9..8964a3ba92482b 100644
--- a/src/mono/mono/mini/interp/transform.h
+++ b/src/mono/mono/mini/interp/transform.h
@@ -86,7 +86,7 @@ struct _InterpInst {
 };
 
 struct _InterpBasicBlock {
-	guint8 *ip;
+	int il_offset;
 	GSList *seq_points;
 	SeqPoint *last_seq_point;
 
diff --git a/src/mono/mono/mini/intrinsics.c b/src/mono/mono/mini/intrinsics.c
index d194525124dbd9..5ad1eb487a10cb 100644
--- a/src/mono/mono/mini/intrinsics.c
+++ b/src/mono/mono/mini/intrinsics.c
@@ -140,15 +140,18 @@ llvm_emit_inst_for_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSign
 			}
 #if defined(TARGET_X86) || defined(TARGET_AMD64)
 			else if (!strcmp (cmethod->name, "Round") && (mini_get_cpu_features (cfg) & MONO_CPU_X86_SSE41) != 0) {
-				// special case: emit vroundps for MathF.Round directly instead of what llvm.round.f32 emits
+				// special case: emit vroundss for MathF.Round directly instead of what llvm.round.f32 emits
 				// to align with CoreCLR behavior
 				int xreg = alloc_xreg (cfg);
 				EMIT_NEW_UNALU (cfg, ins, OP_FCONV_TO_R4_X, xreg, args [0]->dreg);
-				EMIT_NEW_UNALU (cfg, ins, OP_SSE41_ROUNDS, xreg, xreg);
+				int xround = alloc_xreg (cfg);
+				EMIT_NEW_BIALU (cfg, ins, OP_SSE41_ROUNDS, xround, xreg, xreg);
 				ins->inst_c0 = 0x4; // vroundss xmm0, xmm0, xmm0, 0x4 (mode for rounding)
 				ins->inst_c1 = MONO_TYPE_R4;
 				int dreg = alloc_freg (cfg);
-				EMIT_NEW_UNALU (cfg, ins, OP_EXTRACT_R4, dreg, xreg);
+				EMIT_NEW_UNALU (cfg, ins, OP_EXTRACT_R4, dreg, xround);
+				ins->inst_c0 = 0;
+				ins->inst_c1 = MONO_TYPE_R4;
 				return ins;
 			}
 #endif
@@ -662,11 +665,13 @@ byref_arg_is_reference (MonoType *t)
 }
 
 MonoInst*
-mini_emit_inst_for_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args)
+mini_emit_inst_for_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args, gboolean *ins_type_initialized)
 {
 	MonoInst *ins = NULL;
 	MonoClass *runtime_helpers_class = mono_class_get_runtime_helpers_class ();
 
+	*ins_type_initialized = FALSE;
+
 	const char* cmethod_klass_name_space;
 	if (m_class_get_nested_in (cmethod->klass))
 		cmethod_klass_name_space = m_class_get_name_space (m_class_get_nested_in (cmethod->klass));
@@ -743,7 +748,9 @@ mini_emit_inst_for_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSign
 			MONO_EMIT_NEW_LOAD_MEMBASE_FAULT (cfg, vt_reg, args [0]->dreg, MONO_STRUCT_OFFSET (MonoObject, vtable));
 			EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, dreg, vt_reg, MONO_STRUCT_OFFSET (MonoVTable, type));
 			mini_type_from_op (cfg, ins, NULL, NULL);
-
+			mini_type_to_eval_stack_type (cfg, fsig->ret, ins);
+			ins->klass = mono_defaults.runtimetype_class;
+			*ins_type_initialized = TRUE;
 			return ins;
 		} else if (!cfg->backend->emulate_mul_div && strcmp (cmethod->name, "InternalGetHashCode") == 0 && fsig->param_count == 1 && !mono_gc_is_moving ()) {
 			int dreg = alloc_ireg (cfg);
@@ -1798,7 +1805,8 @@ mini_emit_inst_for_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSign
 				return ins;
 			}
 		}
-	} else if (cmethod->klass == mono_defaults.systemtype_class && !strcmp (cmethod->name, "op_Equality")) {
+	} else if (cmethod->klass == mono_defaults.systemtype_class && !strcmp (cmethod->name, "op_Equality") &&
+			args [0]->klass == mono_defaults.runtimetype_class && args [1]->klass == mono_defaults.runtimetype_class) {
 		EMIT_NEW_BIALU (cfg, ins, OP_COMPARE, -1, args [0]->dreg, args [1]->dreg);
 		MONO_INST_NEW (cfg, ins, OP_PCEQ);
 		ins->dreg = alloc_preg (cfg);
diff --git a/src/mono/mono/mini/llvm-intrinsics.h b/src/mono/mono/mini/llvm-intrinsics.h
index b72ec3cd09c7a4..f12bb53d873156 100644
--- a/src/mono/mono/mini/llvm-intrinsics.h
+++ b/src/mono/mono/mini/llvm-intrinsics.h
@@ -255,15 +255,15 @@ INTRINS(AESNI_AESENCLAST, x86_aesni_aesenclast, X86)
 INTRINS(AESNI_AESIMC, x86_aesni_aesimc, X86)
 #if LLVM_API_VERSION >= 800
 	// these intrinsics were renamed in LLVM 8
-INTRINS_OVR(SSE_SADD_SATI8, sadd_sat, Generic, sse_i1_t)
-INTRINS_OVR(SSE_UADD_SATI8, uadd_sat, Generic, sse_i1_t)
-INTRINS_OVR(SSE_SADD_SATI16, sadd_sat, Generic, sse_i1_t)
-INTRINS_OVR(SSE_UADD_SATI16, uadd_sat, Generic, sse_i1_t)
-
-INTRINS_OVR(SSE_SSUB_SATI8, ssub_sat, Generic, sse_i2_t)
-INTRINS_OVR(SSE_USUB_SATI8, usub_sat, Generic, sse_i2_t)
-INTRINS_OVR(SSE_SSUB_SATI16, ssub_sat, Generic, sse_i2_t)
-INTRINS_OVR(SSE_USUB_SATI16, usub_sat, Generic, sse_i2_t)
+INTRINS_OVR(SSE_SADD_SATI8, sadd_sat, Generic, v128_i1_t)
+INTRINS_OVR(SSE_UADD_SATI8, uadd_sat, Generic, v128_i1_t)
+INTRINS_OVR(SSE_SADD_SATI16, sadd_sat, Generic, v128_i2_t)
+INTRINS_OVR(SSE_UADD_SATI16, uadd_sat, Generic, v128_i2_t)
+
+INTRINS_OVR(SSE_SSUB_SATI8, ssub_sat, Generic, v128_i1_t)
+INTRINS_OVR(SSE_USUB_SATI8, usub_sat, Generic, v128_i1_t)
+INTRINS_OVR(SSE_SSUB_SATI16, ssub_sat, Generic, v128_i2_t)
+INTRINS_OVR(SSE_USUB_SATI16, usub_sat, Generic, v128_i2_t)
 #else
 INTRINS(SSE_SADD_SATI8, x86_sse2_padds_b, X86)
 INTRINS(SSE_UADD_SATI8, x86_sse2_paddus_b, X86)
diff --git a/src/mono/mono/mini/llvmonly-runtime.c b/src/mono/mono/mini/llvmonly-runtime.c
index 9dd899bae1b41d..d457dadfb7feeb 100644
--- a/src/mono/mono/mini/llvmonly-runtime.c
+++ b/src/mono/mono/mini/llvmonly-runtime.c
@@ -115,9 +115,10 @@ mini_llvmonly_get_delegate_arg (MonoMethod *method, gpointer method_ptr)
 MonoFtnDesc*
 mini_llvmonly_create_ftndesc (MonoMethod *m, gpointer addr, gpointer arg)
 {
-	MonoFtnDesc *ftndesc = (MonoFtnDesc*)m_method_alloc0 (m, 2 * sizeof (gpointer));
+	MonoFtnDesc *ftndesc = (MonoFtnDesc*)m_method_alloc0 (m, sizeof (MonoFtnDesc));
 	ftndesc->addr = addr;
 	ftndesc->arg = arg;
+	ftndesc->method = m;
 
 	return ftndesc;
 }
diff --git a/src/mono/mono/mini/memory-access.c b/src/mono/mono/mini/memory-access.c
index 66f32251d845ea..51c748c9bbfdbe 100644
--- a/src/mono/mono/mini/memory-access.c
+++ b/src/mono/mono/mini/memory-access.c
@@ -498,7 +498,8 @@ mini_emit_memory_store (MonoCompile *cfg, MonoType *type, MonoInst *dest, MonoIn
 	} else if (!mini_debug_options.weak_memory_model && mini_type_is_reference (type) && cfg->method->wrapper_type != MONO_WRAPPER_WRITE_BARRIER)
 		mini_emit_memory_barrier (cfg, MONO_MEMORY_BARRIER_REL);
 
-	MONO_EMIT_NULL_CHECK (cfg, dest->dreg, FALSE);
+	if (!(ins_flag & MONO_INST_NONULLCHECK))
+		MONO_EMIT_NULL_CHECK (cfg, dest->dreg, FALSE);
 
 	if ((ins_flag & MONO_INST_UNALIGNED) && !COMPILE_LLVM (cfg)) {
 		MonoInst *addr, *mov, *tmp_var;
diff --git a/src/mono/mono/mini/method-to-ir.c b/src/mono/mono/mini/method-to-ir.c
index 86a4add50608f3..964d31d41269e0 100644
--- a/src/mono/mono/mini/method-to-ir.c
+++ b/src/mono/mono/mini/method-to-ir.c
@@ -182,7 +182,7 @@ int mono_op_to_op_imm (int opcode);
 int mono_op_to_op_imm_noemul (int opcode);
 
 static int inline_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **sp,
-						  guchar *ip, guint real_offset, gboolean inline_always);
+						  guchar *ip, guint real_offset, gboolean inline_always, gboolean *is_empty);
 static MonoInst*
 convert_value (MonoCompile *cfg, MonoType *type, MonoInst *ins);
 
@@ -2227,7 +2227,7 @@ mono_emit_jit_icall_by_info (MonoCompile *cfg, int il_offset, MonoJitICallInfo *
 		 * an exception check.
 		 */
 		costs = inline_method (cfg, info->wrapper_method, NULL,
-							   args, NULL, il_offset, TRUE);
+							   args, NULL, il_offset, TRUE, NULL);
 		g_assert (costs > 0);
 		g_assert (!MONO_TYPE_IS_VOID (info->sig->ret));
 
@@ -4559,7 +4559,7 @@ emit_init_local (MonoCompile *cfg, int local, MonoType *type, gboolean init)
 int
 mini_inline_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **sp, guchar *ip, guint real_offset, gboolean inline_always)
 {
-	return inline_method (cfg, cmethod, fsig, sp, ip, real_offset, inline_always);
+	return inline_method (cfg, cmethod, fsig, sp, ip, real_offset, inline_always, NULL);
 }
 
 /*
@@ -4569,7 +4569,7 @@ mini_inline_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *
  */
 static int
 inline_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **sp,
-	       guchar *ip, guint real_offset, gboolean inline_always)
+			   guchar *ip, guint real_offset, gboolean inline_always, gboolean *is_empty)
 {
 	ERROR_DECL (error);
 	MonoInst *ins, *rvar = NULL;
@@ -4611,6 +4611,9 @@ inline_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig,
 		cmethod->inline_info = 1;
 	}
 
+	if (is_empty)
+		*is_empty = FALSE;
+
 	/* allocate local variables */
 	cheader = mono_method_get_header_checked (cmethod, error);
 	if (!cheader) {
@@ -4623,6 +4626,9 @@ inline_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig,
 		return 0;
 	}
 
+	if (is_empty && cheader->code_size == 1 && cheader->code [0] == CEE_RET)
+		*is_empty = TRUE;
+
 	/* allocate space to store the return value */
 	if (!MONO_TYPE_IS_VOID (fsig->ret)) {
 		rvar = mono_compile_create_var (cfg, fsig->ret, OP_LOCAL);
@@ -5589,7 +5595,7 @@ handle_ctor_call (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fs
 			   !mono_class_is_subclass_of_internal (cmethod->klass, mono_defaults.exception_class, FALSE)) {
 		int costs;
 
-		if ((costs = inline_method (cfg, cmethod, fsig, sp, ip, cfg->real_offset, FALSE))) {
+		if ((costs = inline_method (cfg, cmethod, fsig, sp, ip, cfg->real_offset, FALSE, NULL))) {
 			cfg->real_offset += 5;
 
 			*inline_costs += costs - 5;
@@ -6057,6 +6063,7 @@ mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_b
 	MonoBitSet *seq_point_set_locs = NULL;
 	gboolean emitted_funccall_seq_point = FALSE;
 	gboolean detached_before_ret = FALSE;
+	gboolean ins_has_side_effect;
 
 	cfg->disable_inline = (method->iflags & METHOD_IMPL_ATTRIBUTE_NOOPTIMIZATION) || is_jit_optimizer_disabled (method);
 	cfg->current_method = method;
@@ -6491,11 +6498,8 @@ mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_b
 	}
 
 	if (cfg->llvm_only && cfg->interp && cfg->method == method) {
-		for (int i = 0; i < header->num_clauses; ++i) {
-			MonoExceptionClause *clause = &header->clauses [i];
-			if (clause->flags != MONO_EXCEPTION_CLAUSE_FINALLY && clause->flags != MONO_EXCEPTION_CLAUSE_FAULT && clause->flags != MONO_EXCEPTION_CLAUSE_NONE)
-				cfg->interp_entry_only = TRUE;
-		}
+		if (!cfg->method->wrapper_type && header->num_clauses)
+			cfg->interp_entry_only = TRUE;
 
 		if (cfg->interp_entry_only)
 			emit_llvmonly_interp_entry (cfg, header);
@@ -6654,6 +6658,13 @@ mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_b
 		if (cfg->verbose_level > 3)
 			printf ("converting (in B%d: stack: %d) %s", cfg->cbb->block_num, (int)(sp - stack_start), mono_disasm_code_one (NULL, method, ip, NULL));
 
+		/*
+		 * This is used to compute BB_HAS_SIDE_EFFECTS, which is used for the elimination of
+		 * foreach finally clauses, so only IL opcodes which occur in such clauses
+		 * need to set this.
+		 */
+		ins_has_side_effect = TRUE;
+
 		// Variables shared by CEE_CALLI CEE_CALL CEE_CALLVIRT CEE_JMP.
 		// Initialize to either what they all need or zero.
 		gboolean emit_widen = TRUE;
@@ -6706,6 +6717,7 @@ mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_b
 				MONO_INST_NEW (cfg, ins, OP_NOP);
 			MONO_ADD_INS (cfg->cbb, ins);
 			emitted_funccall_seq_point = FALSE;
+			ins_has_side_effect = FALSE;
 			break;
 		case MONO_CEE_BREAK:
 			if (mini_should_insert_breakpoint (cfg->method)) {
@@ -6787,6 +6799,7 @@ mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_b
 				break;
 			}
 
+			ins_has_side_effect = FALSE;
 			EMIT_NEW_LOCLOADA (cfg, ins, n);
 			*sp++ = ins;
 			break;
@@ -7050,7 +7063,7 @@ mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_b
 
 					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);
+						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;
@@ -7142,7 +7155,10 @@ mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_b
 					goto calli_end;
 				}
 			}
-			ins = (MonoInst*)mini_emit_calli_full (cfg, fsig, sp, addr, NULL, NULL, tailcall);
+			if (cfg->llvm_only && !(cfg->method->wrapper_type && cfg->method->wrapper_type != MONO_WRAPPER_DYNAMIC_METHOD))
+				ins = mini_emit_llvmonly_calli (cfg, fsig, sp, addr);
+			else
+				ins = (MonoInst*)mini_emit_calli_full (cfg, fsig, sp, addr, NULL, NULL, tailcall);
 			goto calli_end;
 		}
 		case MONO_CEE_CALL:
@@ -7376,9 +7392,11 @@ mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_b
 			}
 
 			/* Conversion to a JIT intrinsic */
-			if ((ins = mini_emit_inst_for_method (cfg, cmethod, fsig, sp))) {
+			gboolean ins_type_initialized;
+			if ((ins = mini_emit_inst_for_method (cfg, cmethod, fsig, sp, &ins_type_initialized))) {
 				if (!MONO_TYPE_IS_VOID (fsig->ret)) {
-					mini_type_to_eval_stack_type ((cfg), fsig->ret, ins);
+					if (!ins_type_initialized)
+						mini_type_to_eval_stack_type ((cfg), fsig->ret, ins);
 					emit_widen = FALSE;
 				}
 				// FIXME This is only missed if in fact the intrinsic involves a call.
@@ -7403,6 +7421,7 @@ mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_b
 			    mono_method_check_inlining (cfg, cmethod)) {
 				int costs;
 				gboolean always = FALSE;
+				gboolean is_empty = FALSE;
 
 				if (cmethod->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) {
 					/* Prevent inlining of methods that call wrappers */
@@ -7413,7 +7432,7 @@ mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_b
 					always = TRUE;
 				}
 
-				costs = inline_method (cfg, cmethod, fsig, sp, ip, cfg->real_offset, always);
+				costs = inline_method (cfg, cmethod, fsig, sp, ip, cfg->real_offset, always, &is_empty);
 				if (costs) {
 					cfg->real_offset += 5;
 
@@ -7435,6 +7454,8 @@ mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_b
 					// signature match/mismatch.
 					if (inst_tailcall) // FIXME
 						mono_tailcall_print ("missed tailcall inline %s -> %s\n", method->name, cmethod->name);
+					if (is_empty)
+						ins_has_side_effect = FALSE;
 					goto call_end;
 				}
 			}
@@ -7807,7 +7828,7 @@ mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_b
 				/* Inline the wrapper */
 				wrapper = mono_marshal_get_native_wrapper (cmethod, TRUE, cfg->compile_aot);
 
-				costs = inline_method (cfg, wrapper, fsig, sp, ip, cfg->real_offset, TRUE);
+				costs = inline_method (cfg, wrapper, fsig, sp, ip, cfg->real_offset, TRUE, NULL);
 				g_assert (costs > 0);
 				cfg->real_offset += 5;
 
@@ -8336,7 +8357,8 @@ mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_b
 		case MONO_CEE_LDIND_REF:
 			--sp;
 
-			MONO_EMIT_NULL_CHECK (cfg, sp [0]->dreg, FALSE);
+			if (!(ins_flag & MONO_INST_NONULLCHECK))
+				MONO_EMIT_NULL_CHECK (cfg, sp [0]->dreg, FALSE);
 
 			ins = mini_emit_memory_load (cfg, m_class_get_byval_arg (ldind_to_type (il_op)), sp [0], 0, ins_flag);
 			*sp++ = ins;
@@ -10238,7 +10260,7 @@ mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_b
 						EMIT_NEW_PCONST (cfg, ins, rt);
 					}
 					ins->type = STACK_OBJ;
-					ins->klass = cmethod->klass;
+					ins->klass = mono_defaults.runtimetype_class;
 					il_op = (MonoOpcodeEnum)next_ip [0];
 					next_ip += 5;
 				} else {
@@ -10302,6 +10324,7 @@ mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_b
 			MONO_INST_NEW (cfg, ins, OP_ENDFINALLY);
 			MONO_ADD_INS (cfg->cbb, ins);
 			start_new_bblock = 1;
+			ins_has_side_effect = FALSE;
 
 			/*
 			 * Control will leave the method so empty the stack, otherwise
@@ -11270,6 +11293,7 @@ mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_b
 		case MONO_CEE_CONSTRAINED_:
 			constrained_class = mini_get_class (method, token, generic_context);
 			CHECK_TYPELOAD (constrained_class);
+			ins_has_side_effect = FALSE;
 			break;
 		case MONO_CEE_CPBLK:
 			sp -= 3;
@@ -11284,13 +11308,12 @@ mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_b
 			inline_costs += 1;
 			break;
 		case MONO_CEE_NO_:
-			if (ip [2] & 1)
+			if (ip [2] & CEE_NO_TYPECHECK)
 				ins_flag |= MONO_INST_NOTYPECHECK;
-			if (ip [2] & 2)
+			if (ip [2] & CEE_NO_RANGECHECK)
 				ins_flag |= MONO_INST_NORANGECHECK;
-			/* we ignore the no-nullcheck for now since we
-			 * really do it explicitly only when doing callvirt->call
-			 */
+			if (ip [2] & CEE_NO_NULLCHECK)
+				ins_flag |= MONO_INST_NONULLCHECK;
 			break;
 		case MONO_CEE_RETHROW: {
 			MonoInst *load;
@@ -11401,6 +11424,9 @@ mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_b
 			g_warning ("opcode 0x%02x not handled", il_op);
 			UNVERIFIED;
 		}
+
+		if (ins_has_side_effect)
+			cfg->cbb->flags |= BB_HAS_SIDE_EFFECTS;
 	}
 	if (start_new_bblock != 1)
 		UNVERIFIED;
diff --git a/src/mono/mono/mini/mini-amd64.c b/src/mono/mono/mini/mini-amd64.c
index 38fa18a04bee1b..150791b62c3dde 100644
--- a/src/mono/mono/mini/mini-amd64.c
+++ b/src/mono/mono/mini/mini-amd64.c
@@ -4076,8 +4076,8 @@ mono_arch_lowering_pass (MonoCompile *cfg, MonoBasicBlock *bb)
 
 		case OP_XEXTRACT_R4:
 		case OP_XEXTRACT_R8:
-		case OP_XEXTRACT_I32:
-		case OP_XEXTRACT_I64: {
+		case OP_XEXTRACT_I4:
+		case OP_XEXTRACT_I8: {
 			// TODO
 			g_assert_not_reached();
 			break;
@@ -7235,19 +7235,17 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb)
 			}
 			break;
 		case OP_EXTRACT_I1:
-		case OP_EXTRACT_U1:
 			amd64_movd_reg_xreg_size (code, ins->dreg, ins->sreg1, 4);
 			if (ins->inst_c0)
 				amd64_shift_reg_imm (code, X86_SHR, ins->dreg, ins->inst_c0 * 8);
-			amd64_widen_reg (code, ins->dreg, ins->dreg, ins->opcode == OP_EXTRACT_I1, FALSE);
+			amd64_widen_reg (code, ins->dreg, ins->dreg, ins->inst_c1 == MONO_TYPE_I1, FALSE);
 			break;
 		case OP_EXTRACT_I2:
-		case OP_EXTRACT_U2:
 			/*amd64_movd_reg_xreg_size (code, ins->dreg, ins->sreg1, 4);
 			if (ins->inst_c0)
 				amd64_shift_reg_imm_size (code, X86_SHR, ins->dreg, 16, 4);*/
 			amd64_sse_pextrw_reg_reg_imm (code, ins->dreg, ins->sreg1, ins->inst_c0);
-			amd64_widen_reg_size (code, ins->dreg, ins->dreg, ins->opcode == OP_EXTRACT_I2, TRUE, 4);
+			amd64_widen_reg_size (code, ins->dreg, ins->dreg, ins->inst_c1 == MONO_TYPE_I2, TRUE, 4);
 			break;
 		case OP_EXTRACT_R8:
 			if (ins->inst_c0)
@@ -7909,7 +7907,7 @@ MONO_RESTORE_WARNING
 
 				/*
 				 * Save the original location of 'this',
-				 * get_generic_info_from_stack_frame () needs this to properly look up
+				 * mono_get_generic_info_from_stack_frame () needs this to properly look up
 				 * the argument value during the handling of async exceptions.
 				 */
 				if (i == 0 && sig->hasthis) {
@@ -8965,6 +8963,8 @@ mono_arch_emit_inst_for_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMetho
 				ins->inst_c1 = MONO_TYPE_R8;
 				int dreg = alloc_freg (cfg);
 				EMIT_NEW_UNALU (cfg, ins, OP_EXTRACT_R8, dreg, xreg);
+				ins->inst_c0 = 0;
+				ins->inst_c1 = MONO_TYPE_R8;
 				return ins;
 			}
 		}
diff --git a/src/mono/mono/mini/mini-arm.c b/src/mono/mono/mini/mini-arm.c
index 1f4ec81d761f4c..4fc43ee3071660 100644
--- a/src/mono/mono/mini/mini-arm.c
+++ b/src/mono/mono/mini/mini-arm.c
@@ -873,6 +873,8 @@ mono_arch_init (void)
 	   have a way to properly detect CPU features on it. */
 	thumb_supported = TRUE;
 	iphone_abi = TRUE;
+#elif defined(TARGET_ANDROID)
+	thumb_supported = TRUE;
 #else
 	thumb_supported = mono_hwcap_arm_has_thumb;
 	thumb2_supported = mono_hwcap_arm_has_thumb2;
diff --git a/src/mono/mono/mini/mini-exceptions.c b/src/mono/mono/mini/mini-exceptions.c
index ecaf46f9db105b..9ffc8410766046 100644
--- a/src/mono/mono/mini/mini-exceptions.c
+++ b/src/mono/mono/mini/mini-exceptions.c
@@ -782,8 +782,8 @@ unwinder_unwind_frame (Unwinder *unwinder,
 /*
  * This function is async-safe.
  */
-static gpointer
-get_generic_info_from_stack_frame (MonoJitInfo *ji, MonoContext *ctx)
+gpointer
+mono_get_generic_info_from_stack_frame (MonoJitInfo *ji, MonoContext *ctx)
 {
 	MonoGenericJitInfo *gi;
 	MonoMethod *method;
@@ -1356,7 +1356,7 @@ mono_walk_stack_full (MonoJitStackWalk func, MonoContext *start_ctx, MonoJitTlsD
 		/* actual_method might already be set by mono_arch_unwind_frame () */
 		if (!frame.actual_method) {
 			if ((unwind_options & MONO_UNWIND_LOOKUP_ACTUAL_METHOD) && frame.ji)
-				frame.actual_method = get_method_from_stack_frame (frame.ji, get_generic_info_from_stack_frame (frame.ji, &ctx));
+				frame.actual_method = get_method_from_stack_frame (frame.ji, mono_get_generic_info_from_stack_frame (frame.ji, &ctx));
 			else
 				frame.actual_method = frame.method;
 		}
@@ -1895,7 +1895,7 @@ ves_icall_get_frame_info (gint32 skip, MonoBoolean need_file_info,
 			jmethod = frame.method;
 			actual_method = frame.actual_method;
 		} else {
-			actual_method = get_method_from_stack_frame (ji, get_generic_info_from_stack_frame (ji, &ctx));
+			actual_method = get_method_from_stack_frame (ji, mono_get_generic_info_from_stack_frame (ji, &ctx));
 		}
 	}
 
@@ -1951,7 +1951,7 @@ get_exception_catch_class (MonoJitExceptionInfo *ei, MonoJitInfo *ji, MonoContex
 
 	if (!ji->has_generic_jit_info || !mono_jit_info_get_generic_jit_info (ji)->has_this)
 		return catch_class;
-	context = mono_get_generic_context_from_stack_frame (ji, get_generic_info_from_stack_frame (ji, ctx));
+	context = mono_get_generic_context_from_stack_frame (ji, mono_get_generic_info_from_stack_frame (ji, ctx));
 
 	/* FIXME: we shouldn't inflate but instead put the
 	   type in the rgctx and fetch it from there.  It
@@ -2183,7 +2183,8 @@ typedef enum {
  * return \c MONO_FIRST_PASS_CALLBACK_TO_NATIVE).
  */
 static MonoFirstPassResult
-handle_exception_first_pass (MonoContext *ctx, MonoObject *obj, gint32 *out_filter_idx, MonoJitInfo **out_ji, MonoJitInfo **out_prev_ji, MonoObject *non_exception, StackFrameInfo *catch_frame, gboolean *last_mono_wrapper_runtime_invoke)
+handle_exception_first_pass (MonoContext *ctx, MonoObject *obj, gint32 *out_filter_idx, MonoJitInfo **out_ji, MonoJitInfo **out_prev_ji,
+							 MonoObject *non_exception, StackFrameInfo *catch_frame, gboolean *last_mono_wrapper_runtime_invoke, gboolean enable_trace)
 {
 	ERROR_DECL (error);
 	MonoDomain *domain = mono_domain_get ();
@@ -2281,12 +2282,6 @@ handle_exception_first_pass (MonoContext *ctx, MonoObject *obj, gint32 *out_filt
 			*ctx = new_ctx;
 			continue;
 		case FRAME_TYPE_INTERP_ENTRY:
-			if (mono_aot_mode == MONO_AOT_MODE_LLVMONLY_INTERP)
-				/*
-				 * There might be AOTed frames above the intepreted frames which can handle the exception,
-				 * so stop first pass, the caller will rethrow the exception, starting the process again.
-				 */
-				return MONO_FIRST_PASS_UNHANDLED;
 			*ctx = new_ctx;
 			continue;
 		case FRAME_TYPE_INTERP:
@@ -2320,7 +2315,7 @@ handle_exception_first_pass (MonoContext *ctx, MonoObject *obj, gint32 *out_filt
 			// avoid giant stack traces during a stack overflow
 			if (frame_count < 1000) {
 				trace_ips = g_list_prepend (trace_ips, ip);
-				trace_ips = g_list_prepend (trace_ips, get_generic_info_from_stack_frame (ji, ctx));
+				trace_ips = g_list_prepend (trace_ips, mono_get_generic_info_from_stack_frame (ji, ctx));
 				trace_ips = g_list_prepend (trace_ips, ji);
 			}
 		}
@@ -2405,12 +2400,22 @@ handle_exception_first_pass (MonoContext *ctx, MonoObject *obj, gint32 *out_filt
 						jit_tls->orig_ex_ctx_set = FALSE;
 					}
 
+					if (enable_trace) {
+						char *name = mono_method_get_full_name (method);
+						g_print ("[%p:] EXCEPTION running filter clause %d in '%s'.\n", (void*)(gsize)mono_native_thread_id_get (), i, name);
+						g_free (name);
+					}
+
 					if (ji->is_interp) {
 						/* The filter ends where the exception handler starts */
 						filtered = mini_get_interp_callbacks ()->run_filter (&frame, (MonoException*)ex_obj, i, ei->data.filter, ei->handler_start);
 					} else {
 						filtered = call_filter (ctx, ei->data.filter);
 					}
+
+					if (enable_trace)
+						g_print ("[%p:] EXCEPTION filter result: %d\n", (void*)(gsize)mono_native_thread_id_get (), filtered);
+
 					mini_get_dbg_callbacks ()->end_exception_filter (mono_ex, ctx, &initial_ctx);
 					if (filtered && out_filter_idx)
 						*out_filter_idx = filter_idx;
@@ -2596,6 +2601,8 @@ mono_handle_exception_internal (MonoContext *ctx, MonoObject *obj, gboolean resu
 	 */
 	memcpy (&jit_tls->orig_ex_ctx, ctx, sizeof (MonoContext));
 
+	gboolean enable_trace = FALSE;
+
 	if (!resume) {
 		MonoContext ctx_cp = *ctx;
 		if (mono_trace_is_enabled ()) {
@@ -2631,9 +2638,12 @@ mono_handle_exception_internal (MonoContext *ctx, MonoObject *obj, gboolean resu
 			}
 			g_print ("[%p:] EXCEPTION handling: %s.%s: %s\n", (void*)(gsize)mono_native_thread_id_get (), m_class_get_name_space (mono_object_class (obj)), m_class_get_name (mono_object_class (obj)), msg);
 			g_free (msg);
-			if (mono_ex && mono_trace_eval_exception (mono_object_class (mono_ex)))
+			if (mono_ex && mono_trace_eval_exception (mono_object_class (mono_ex))) {
+				enable_trace = TRUE;
 				mono_print_thread_dump_from_ctx (ctx);
+			}
 		}
+
 		jit_tls->orig_ex_ctx_set = TRUE;
 		MONO_PROFILER_RAISE (exception_throw, (obj));
 		jit_tls->orig_ex_ctx_set = FALSE;
@@ -2642,14 +2652,9 @@ mono_handle_exception_internal (MonoContext *ctx, MonoObject *obj, gboolean resu
 
 		StackFrameInfo catch_frame;
 		MonoFirstPassResult res;
-		res = handle_exception_first_pass (&ctx_cp, obj, &first_filter_idx, &ji, &prev_ji, non_exception, &catch_frame, &last_mono_wrapper_runtime_invoke);
+		res = handle_exception_first_pass (&ctx_cp, obj, &first_filter_idx, &ji, &prev_ji, non_exception, &catch_frame, &last_mono_wrapper_runtime_invoke, enable_trace);
 
 		if (res == MONO_FIRST_PASS_UNHANDLED) {
-			if (mono_aot_mode == MONO_AOT_MODE_LLVMONLY_INTERP) {
-				/* Reached the top interpreted frames, but there might be native frames above us */
-				throw_exception (obj, TRUE);
-				g_assert_not_reached ();
-			}
 			if (mini_debug_options.break_on_exc)
 				G_BREAKPOINT ();
 			mini_get_dbg_callbacks ()->handle_exception ((MonoException *)obj, ctx, NULL, NULL);
diff --git a/src/mono/mono/mini/mini-generic-sharing.c b/src/mono/mono/mini/mini-generic-sharing.c
index e2a4a6d3a1ac9b..8b0da4a3f4e4af 100644
--- a/src/mono/mono/mini/mini-generic-sharing.c
+++ b/src/mono/mono/mini/mini-generic-sharing.c
@@ -2794,6 +2794,7 @@ mini_rgctx_info_type_to_patch_info_type (MonoRgctxInfoType info_type)
  * @method: a method
  * @in_mrgctx: whether to put the data into the MRGCTX
  * @data: the info data
+ * @did_register: whether data was registered
  * @info_type: the type of info to register about data
  * @generic_context: a generic context
  *
@@ -2802,7 +2803,7 @@ mini_rgctx_info_type_to_patch_info_type (MonoRgctxInfoType info_type)
  * encoded slot number.
  */
 static guint32
-lookup_or_register_info (MonoMemoryManager *mem_manager, MonoClass *klass, MonoMethod *method, gboolean in_mrgctx, gpointer data,
+lookup_or_register_info (MonoMemoryManager *mem_manager, MonoClass *klass, MonoMethod *method, gboolean in_mrgctx, gpointer data, gboolean *did_register,
 						 MonoRgctxInfoType info_type, MonoGenericContext *generic_context)
 {
 	int type_argc = 0;
@@ -2851,7 +2852,10 @@ lookup_or_register_info (MonoMemoryManager *mem_manager, MonoClass *klass, MonoM
 
 	/* We haven't found the info */
 	if (index == -1)
+	{
 		index = register_info (klass, type_argc, data, info_type);
+		*did_register = TRUE;
+	}
 
 	/* interlocked by loader lock */
 	if (index > UnlockedRead (&rgctx_max_slot_number))
@@ -4232,6 +4236,8 @@ int
 mini_get_rgctx_entry_slot (MonoJumpInfoRgctxEntry *entry)
 {
 	gpointer entry_data = NULL;
+	gboolean did_register = FALSE;
+	guint32 result = -1;
 
 	switch (entry->data->type) {
 	case MONO_PATCH_INFO_CLASS:
@@ -4302,9 +4308,27 @@ mini_get_rgctx_entry_slot (MonoJumpInfoRgctxEntry *entry)
 	MonoJitMemoryManager *jit_mm = get_default_jit_mm ();
 
 	if (entry->in_mrgctx)
-		return lookup_or_register_info (jit_mm->mem_manager, entry->d.method->klass, entry->d.method, entry->in_mrgctx, entry_data, entry->info_type, mono_method_get_context (entry->d.method));
+		result = lookup_or_register_info (jit_mm->mem_manager, entry->d.method->klass, entry->d.method, entry->in_mrgctx, entry_data, &did_register, entry->info_type, mono_method_get_context (entry->d.method));
 	else
-		return lookup_or_register_info (jit_mm->mem_manager, entry->d.klass, NULL, entry->in_mrgctx, entry_data, entry->info_type, mono_class_get_context (entry->d.klass));
+		result = lookup_or_register_info (jit_mm->mem_manager, entry->d.klass, NULL, entry->in_mrgctx, entry_data, &did_register, entry->info_type, mono_class_get_context (entry->d.klass));
+
+	if (!did_register)
+		switch (entry->data->type) {
+		case MONO_PATCH_INFO_GSHAREDVT_CALL:
+		case MONO_PATCH_INFO_VIRT_METHOD:
+		case MONO_PATCH_INFO_DELEGATE_TRAMPOLINE:
+			g_free (entry_data);
+			break;
+		case MONO_PATCH_INFO_GSHAREDVT_METHOD: {
+			g_free (((MonoGSharedVtMethodInfo *) entry_data)->entries);
+			g_free (entry_data);
+			break;
+		}
+		default :
+			break;
+		}
+
+	return result;
 }
 
 static gboolean gsharedvt_supported;
diff --git a/src/mono/mono/mini/mini-llvm.c b/src/mono/mono/mini/mini-llvm.c
index 8c118f3dd0f0fb..b19cf2fe572c12 100644
--- a/src/mono/mono/mini/mini-llvm.c
+++ b/src/mono/mono/mini/mini-llvm.c
@@ -107,6 +107,7 @@ typedef struct {
 	GPtrArray *callsite_list;
 	LLVMContextRef context;
 	LLVMValueRef sentinel_exception;
+	LLVMValueRef gc_safe_point_flag_var;
 	void *di_builder, *cu;
 	GHashTable *objc_selector_to_var;
 	GPtrArray *cfgs;
@@ -286,6 +287,20 @@ static LLVMRealPredicate fpcond_to_llvm_cond [] = {
 	LLVMRealUNO
 };
 
+/* See Table 3-1 ("Comparison Predicate for CMPPD and CMPPS Instructions") in
+ * Vol. 2A of the Intel SDM.
+ */
+enum {
+    SSE_eq_ord_nosignal = 0,
+    SSE_lt_ord_signal = 1,
+    SSE_le_ord_signal = 2,
+    SSE_unord_nosignal = 3,
+    SSE_neq_unord_nosignal = 4,
+    SSE_nlt_unord_signal = 5,
+    SSE_nle_unord_signal = 6,
+    SSE_ord_nosignal = 7,
+};
+
 static MonoLLVMModule aot_module;
 
 static GHashTable *intrins_id_to_intrins;
@@ -466,6 +481,12 @@ const_int1 (int v)
 	return LLVMConstInt (LLVMInt1Type (), v ? 1 : 0, FALSE);
 }
 
+static LLVMValueRef
+const_int8 (int v)
+{
+	return LLVMConstInt (LLVMInt8Type (), v, FALSE);
+}
+
 static LLVMValueRef
 const_int32 (int v)
 {
@@ -1096,56 +1117,6 @@ simd_ins_to_intrins (int opcode)
 {
 	switch (opcode) {
 #if defined(TARGET_X86) || defined(TARGET_AMD64)
-	case OP_MINPD:
-		return INTRINS_SSE_MINPD;
-	case OP_MINPS:
-		return INTRINS_SSE_MINPS;
-	case OP_MAXPD:
-		return INTRINS_SSE_MAXPD;
-	case OP_MAXPS:
-		return INTRINS_SSE_MAXPS;
-	case OP_HADDPD:
-		return INTRINS_SSE_HADDPD;
-	case OP_HADDPS:
-		return INTRINS_SSE_HADDPS;
-	case OP_HSUBPD:
-		return INTRINS_SSE_HSUBPD;
-	case OP_HSUBPS:
-		return INTRINS_SSE_HSUBPS;
-	case OP_ADDSUBPS:
-		return INTRINS_SSE_ADDSUBPS;
-	case OP_ADDSUBPD:
-		return INTRINS_SSE_ADDSUBPD;
-	case OP_EXTRACT_MASK:
-		return INTRINS_SSE_PMOVMSKB;
-	case OP_PSHRW:
-	case OP_PSHRW_REG:
-		return INTRINS_SSE_PSRLI_W;
-	case OP_PSHRD:
-	case OP_PSHRD_REG:
-		return INTRINS_SSE_PSRLI_D;
-	case OP_PSHRQ:
-	case OP_PSHRQ_REG:
-		return INTRINS_SSE_PSRLI_Q;
-	case OP_PSHLW:
-	case OP_PSHLW_REG:
-		return INTRINS_SSE_PSLLI_W;
-	case OP_PSHLD:
-	case OP_PSHLD_REG:
-		return INTRINS_SSE_PSLLI_D;
-	case OP_PSHLQ:
-	case OP_PSHLQ_REG:
-		return INTRINS_SSE_PSLLI_Q;
-	case OP_PSARW:
-	case OP_PSARW_REG:
-		return INTRINS_SSE_PSRAI_W;
-	case OP_PSARD:
-	case OP_PSARD_REG:
-		return INTRINS_SSE_PSRAI_D;
-	case OP_RSQRTPS:
-		return INTRINS_SSE_RSQRT_PS;
-	case OP_RCPPS:
-		return INTRINS_SSE_RCP_PS;
 	case OP_CVTPD2DQ:
 		return INTRINS_SSE_CVTPD2DQ;
 	case OP_CVTPS2DQ:
@@ -1156,28 +1127,10 @@ simd_ins_to_intrins (int opcode)
 		return INTRINS_SSE_CVTTPD2DQ;
 	case OP_CVTTPS2DQ:
 		return INTRINS_SSE_CVTTPS2DQ;
-	case OP_PACKW:
-		return INTRINS_SSE_PACKSSWB;
-	case OP_PACKD:
-		return INTRINS_SSE_PACKSSDW;
-	case OP_PACKW_UN:
-		return INTRINS_SSE_PACKUSWB;
-	case OP_PACKD_UN:
-		return INTRINS_SSE_PACKUSDW;
-	case OP_PMULW_HIGH:
-		return INTRINS_SSE_PMULHW;
-	case OP_PMULW_HIGH_UN:
-		return INTRINS_SSE_PMULHU;
-	case OP_DPPS:
-		return INTRINS_SSE_DPPS;
 	case OP_SSE_SQRTSS:
 		return INTRINS_SSE_SQRT_SS;
 	case OP_SSE2_SQRTSD:
 		return INTRINS_SSE_SQRT_SD;
-	case OP_SQRTPS:
-		return INTRINS_SSE_SQRT_PS;
-	case OP_SQRTPD:
-		return INTRINS_SSE_SQRT_PD;
 #endif
 	default:
 		g_assert_not_reached ();
@@ -1200,12 +1153,10 @@ simd_op_to_llvm_type (int opcode)
 	case OP_EXPAND_I4:
 		return sse_i4_t;
 	case OP_EXTRACT_I2:
-	case OP_EXTRACT_U2:
 	case OP_EXTRACTX_U2:
 	case OP_EXPAND_I2:
 		return sse_i2_t;
 	case OP_EXTRACT_I1:
-	case OP_EXTRACT_U1:
 	case OP_EXPAND_I1:
 		return sse_i1_t;
 	case OP_EXTRACT_R4:
@@ -1218,11 +1169,8 @@ simd_op_to_llvm_type (int opcode)
 	case OP_CVTPS2DQ:
 	case OP_CVTTPS2DQ:
 		return sse_r4_t;
-	case OP_EXTRACT_MASK:
-		return sse_i1_t;
 	case OP_SQRTPS:
 	case OP_RSQRTPS:
-	case OP_RCPPS:
 	case OP_DUPPS_LOW:
 	case OP_DUPPS_HIGH:
 		return sse_r4_t;
@@ -1955,6 +1903,15 @@ get_aotconst_module (MonoLLVMModule *module, LLVMBuilderRef builder, MonoJumpInf
 	guint32 got_offset;
 	LLVMValueRef load;
 
+	if (module->static_link && type == MONO_PATCH_INFO_GC_SAFE_POINT_FLAG) {
+		const char *symbol = "mono_polling_required";
+		if (!module->gc_safe_point_flag_var) {
+			module->gc_safe_point_flag_var = LLVMAddGlobal (module->lmodule, llvm_type, symbol);
+			LLVMSetLinkage (module->gc_safe_point_flag_var, LLVMExternalLinkage);
+		}
+		return module->gc_safe_point_flag_var;
+	}
+
 	MonoJumpInfo tmp_ji;
 	tmp_ji.type = type;
 	tmp_ji.data.target = data;
@@ -5065,6 +5022,13 @@ immediate_unroll_commit_default (ImmediateUnrollCtx *ictx, LLVMValueRef value)
 	LLVMAddIncoming (ictx->phi, &value, &ictx->default_case, 1);
 }
 
+static void
+immediate_unroll_unreachable_default (ImmediateUnrollCtx *ictx)
+{
+	immediate_unroll_default (ictx);
+	LLVMBuildUnreachable (ictx->ctx->builder);
+}
+
 static LLVMValueRef
 immediate_unroll_end (ImmediateUnrollCtx *ictx, LLVMBasicBlockRef *continuation)
 {
@@ -7415,6 +7379,72 @@ process_bb (EmitContext *ctx, MonoBasicBlock *bb)
 		}
 
 #if defined(TARGET_X86) || defined(TARGET_AMD64) || defined(TARGET_ARM64) || defined(TARGET_WASM)
+		case OP_EXTRACTX_U2:
+		case OP_XEXTRACT_I1:
+		case OP_XEXTRACT_I2:
+		case OP_XEXTRACT_I4:
+		case OP_XEXTRACT_I8:
+		case OP_XEXTRACT_R4:
+		case OP_XEXTRACT_R8:
+		case OP_EXTRACT_I1:
+		case OP_EXTRACT_I2:
+		case OP_EXTRACT_I4:
+		case OP_EXTRACT_I8:
+		case OP_EXTRACT_R4:
+		case OP_EXTRACT_R8: {
+			MonoTypeEnum mono_elt_t = inst_c1_type (ins);
+			LLVMTypeRef elt_t = primitive_type_to_llvm_type (mono_elt_t);
+			gboolean sext = FALSE;
+			gboolean zext = FALSE;
+			switch (mono_elt_t) {
+			case MONO_TYPE_I1: case MONO_TYPE_I2: sext = TRUE; break;
+			case MONO_TYPE_U1: case MONO_TYPE_U2: zext = TRUE; break;
+			}
+			LLVMValueRef element_ix = NULL;
+			switch (ins->opcode) {
+			case OP_XEXTRACT_I1:
+			case OP_XEXTRACT_I2:
+			case OP_XEXTRACT_I4:
+			case OP_XEXTRACT_R4:
+			case OP_XEXTRACT_R8:
+			case OP_XEXTRACT_I8:
+				element_ix = rhs;
+				break;
+			default:
+				element_ix = const_int32 (ins->inst_c0);
+			}
+			LLVMTypeRef lhs_t = LLVMTypeOf (lhs);
+			int vec_width = mono_llvm_get_prim_size_bits (lhs_t);
+			int elem_width = mono_llvm_get_prim_size_bits (elt_t);
+			int elements = vec_width / elem_width;
+			element_ix = LLVMBuildAnd (builder, element_ix, const_int32 (elements - 1), "extract");
+			LLVMTypeRef ret_t = LLVMVectorType (elt_t, elements);
+			LLVMValueRef src = LLVMBuildBitCast (builder, lhs, ret_t, "extract");
+			LLVMValueRef result = LLVMBuildExtractElement (builder, src, element_ix, "extract");
+			if (zext)
+				result = LLVMBuildZExt (builder, result, i4_t, "extract_zext");
+			else if (sext)
+				result = LLVMBuildSExt (builder, result, i4_t, "extract_sext");
+			values [ins->dreg] = result;
+			break;
+		}
+		case OP_XINSERT_I1:
+		case OP_XINSERT_I2:
+		case OP_XINSERT_I4:
+		case OP_XINSERT_I8:
+		case OP_XINSERT_R4:
+		case OP_XINSERT_R8: {
+			MonoTypeEnum primty = inst_c1_type (ins);
+			LLVMTypeRef ret_t = simd_class_to_llvm_type (ctx, ins->klass);
+			LLVMTypeRef elem_t = LLVMGetElementType (ret_t);
+			int elements = LLVMGetVectorSize (ret_t);
+			LLVMValueRef element_ix = LLVMBuildAnd (builder, arg3, const_int32 (elements - 1), "xinsert");
+			LLVMValueRef vec = convert (ctx, lhs, ret_t);
+			LLVMValueRef val = convert_full (ctx, rhs, elem_t, primitive_type_is_unsigned (primty));
+			LLVMValueRef result = LLVMBuildInsertElement (builder, vec, val, element_ix, "xinsert");
+			values [ins->dreg] = result;
+			break;
+		}
 		case OP_EXPAND_I1:
 		case OP_EXPAND_I2:
 		case OP_EXPAND_I4:
@@ -7730,30 +7760,6 @@ process_bb (EmitContext *ctx, MonoBasicBlock *bb)
 			values [ins->dreg] = LLVMBuildSelect (builder, cmp, lhs, rhs, "");
 			break;
 		}
-		case OP_MINPD:
-		case OP_MINPS:
-		case OP_MAXPD:
-		case OP_MAXPS:
-		case OP_ADDSUBPD:
-		case OP_ADDSUBPS:
-		case OP_HADDPD:
-		case OP_HADDPS:
-		case OP_HSUBPD:
-		case OP_HSUBPS:
-		case OP_PACKW:
-		case OP_PACKD:
-		case OP_PACKW_UN:
-		case OP_PACKD_UN:
-		case OP_PMULW_HIGH:
-		case OP_PMULW_HIGH_UN: {
-			LLVMValueRef args [2];
-
-			args [0] = lhs;
-			args [1] = rhs;
-
-			values [ins->dreg] = call_intrins (ctx, simd_ins_to_intrins (ins->opcode), args, "");
-			break;
-		}
 		case OP_PAVGB_UN:
 		case OP_PAVGW_UN: {
 			LLVMValueRef ones_vec;
@@ -7805,84 +7811,6 @@ process_bb (EmitContext *ctx, MonoBasicBlock *bb)
 			values [ins->dreg] = LLVMBuildSExt (builder, pcmp, retType, "");
 			break;
 		}
-		case OP_EXTRACT_R4:
-		case OP_EXTRACT_R8:
-		case OP_EXTRACT_I8:
-		case OP_EXTRACT_I4:
-		case OP_EXTRACT_I2:
-		case OP_EXTRACT_U2:
-		case OP_EXTRACTX_U2:
-		case OP_EXTRACT_I1:
-		case OP_EXTRACT_U1: {
-			LLVMTypeRef t;
-			gboolean zext = FALSE;
-
-			t = simd_op_to_llvm_type (ins->opcode);
-
-			switch (ins->opcode) {
-			case OP_EXTRACT_R4:
-			case OP_EXTRACT_R8:
-			case OP_EXTRACT_I8:
-			case OP_EXTRACT_I4:
-			case OP_EXTRACT_I2:
-			case OP_EXTRACT_I1:
-				break;
-			case OP_EXTRACT_U2:
-			case OP_EXTRACTX_U2:
-			case OP_EXTRACT_U1:
-				zext = TRUE;
-				break;
-			default:
-				t = LLVMInt32Type ();
-				g_assert_not_reached ();
-			}
-
-			lhs = LLVMBuildBitCast (builder, lhs, t, "");
-			values [ins->dreg] = LLVMBuildExtractElement (builder, lhs, LLVMConstInt (LLVMInt32Type (), ins->inst_c0, FALSE), "");
-			if (zext)
-				values [ins->dreg] = LLVMBuildZExt (builder, values [ins->dreg], LLVMInt32Type (), "");
-			break;
-		}
-		case OP_XINSERT_I2: {
-			LLVMBasicBlockRef bbs [64];
-			LLVMValueRef switch_ins;
-			LLVMValueRef vector = lhs;
-			LLVMValueRef value = rhs;
-			LLVMValueRef index = values [ins->sreg3];
-			LLVMValueRef phi_values [64];
-			int nelems = LLVMGetVectorSize (LLVMTypeOf (lhs));
-			int i;
-
-			/*
-			 * Many SIMD opcodes require an immediate operand, but can be called with a non-immediate.
-			 * To handle these cases, generate a switch statement with one case for all possible
-			 * values of the immediate.
-			 * switch (index) {
-			 * case i:
-			 *   res = <op> (val, i)
-			 *   break;
-			 * }
-			 */
-			g_assert (nelems <= 64);
-			for (i = 0; i < nelems; ++i)
-				bbs [i] = gen_bb (ctx, "XINSERT_CASE_BB");
-			cbb = gen_bb (ctx, "XINSERT_COND_BB");
-
-			switch_ins = LLVMBuildSwitch (builder, LLVMBuildAnd (builder, index, const_int32 (0xf), ""), bbs [0], 0);
-			for (i = 0; i < nelems; ++i) {
-				LLVMAddCase (switch_ins, LLVMConstInt (LLVMInt32Type (), i, FALSE), bbs [i]);
-				LLVMPositionBuilderAtEnd (builder, bbs [i]);
-				phi_values [i] = LLVMBuildInsertElement (builder, vector, convert (ctx, value, LLVMGetElementType (LLVMTypeOf (vector))), LLVMConstInt (LLVMInt32Type (), i, FALSE), "");
-				LLVMBuildBr (builder, cbb);
-			}
-
-			LLVMPositionBuilderAtEnd (builder, cbb);
-			values [ins->dreg] = LLVMBuildPhi (builder, LLVMTypeOf (phi_values [0]), "");
-			LLVMAddIncoming (values [ins->dreg], phi_values, bbs, nelems);
-
-			ctx->bblocks [bb->block_num].end_bblock = cbb;
-			break;
-		}
 		case OP_CVTDQ2PS: {
 			LLVMValueRef i4 = LLVMBuildBitCast (builder, lhs, sse_i4_t, "");
 			values [ins->dreg] = LLVMBuildSIToFP (builder, i4, sse_r4_t, dname);
@@ -7921,12 +7849,7 @@ process_bb (EmitContext *ctx, MonoBasicBlock *bb)
 		case OP_CVTPD2DQ:
 		case OP_CVTPS2DQ:
 		case OP_CVTPD2PS:
-		case OP_CVTTPD2DQ:
-		case OP_EXTRACT_MASK:
-		case OP_SQRTPS:
-		case OP_SQRTPD:
-		case OP_RSQRTPS:
-		case OP_RCPPS: {
+		case OP_CVTTPD2DQ: {
 			LLVMValueRef v;
 
 			v = convert (ctx, values [ins->sreg1], simd_op_to_llvm_type (ins->opcode));
@@ -7979,40 +7902,6 @@ process_bb (EmitContext *ctx, MonoBasicBlock *bb)
 			values [ins->dreg] = lhs;
 			break;
 
-		case OP_PSHRW:
-		case OP_PSHRD:
-		case OP_PSHRQ:
-		case OP_PSARW:
-		case OP_PSARD:
-		case OP_PSHLW:
-		case OP_PSHLD:
-		case OP_PSHLQ: {
-			LLVMValueRef args [3];
-
-			args [0] = lhs;
-			args [1] = LLVMConstInt (LLVMInt32Type (), ins->inst_imm, FALSE);
-
-			values [ins->dreg] = call_intrins (ctx, simd_ins_to_intrins (ins->opcode), args, dname);
-			break;
-		}
-
-		case OP_PSHRW_REG:
-		case OP_PSHRD_REG:
-		case OP_PSHRQ_REG:
-		case OP_PSARW_REG:
-		case OP_PSARD_REG:
-		case OP_PSHLW_REG:
-		case OP_PSHLD_REG:
-		case OP_PSHLQ_REG: {
-			LLVMValueRef args [3];
-
-			args [0] = lhs;
-			args [1] = values [ins->sreg2];
-
-			values [ins->dreg] = call_intrins (ctx, simd_ins_to_intrins (ins->opcode), args, dname);
-			break;
-		}
-
 		case OP_SHUFPS:
 		case OP_SHUFPD:
 		case OP_PSHUFLED:
@@ -8198,18 +8087,6 @@ process_bb (EmitContext *ctx, MonoBasicBlock *bb)
 			break;
 		}
 
-		case OP_DPPS: {
-			LLVMValueRef args [3];
-
-			args [0] = lhs;
-			args [1] = rhs;
-			/* 0xf1 == multiply all 4 elements, add them together, and store the result to the lowest element */
-			args [2] = LLVMConstInt (LLVMInt8Type (), 0xf1, FALSE);
-
-			values [ins->dreg] = call_intrins (ctx, simd_ins_to_intrins (ins->opcode), args, dname);
-			break;
-		}
-
 		case OP_FCONV_TO_R8_X: {
 			values [ins->dreg] = LLVMBuildInsertElement (builder, LLVMConstNull (sse_r8_t), lhs, LLVMConstInt (LLVMInt32Type (), 0, FALSE), "");
 			break;
@@ -8449,36 +8326,6 @@ process_bb (EmitContext *ctx, MonoBasicBlock *bb)
 			break;
 		}
 
-		case OP_SSE_SHUFFLE: {
-			LLVMValueRef shuffle_vec = create_const_vector_4_i32 (
-				((ins->inst_c0 >> 0) & 0x3) + 0, // take two elements from lhs
-				((ins->inst_c0 >> 2) & 0x3) + 0, 
-				((ins->inst_c0 >> 4) & 0x3) + 4, // and two from rhs
-				((ins->inst_c0 >> 6) & 0x3) + 4);
-			values [ins->dreg] = LLVMBuildShuffleVector (builder, lhs, rhs, shuffle_vec, "");
-			break;
-		}
-
-		case OP_SSE2_SHUFFLE: {
-			LLVMValueRef right_vec;
-			LLVMValueRef shuffle_vec;
-			if (ins->inst_c1 == MONO_TYPE_R8) {
-				right_vec = rhs;
-				shuffle_vec = create_const_vector_2_i32 (
-					((ins->inst_c0 >> 0) & 0x1) + 0,
-					((ins->inst_c0 >> 1) & 0x1) + 2);
-			} else {
-				right_vec = LLVMGetUndef (LLVMVectorType (LLVMInt32Type (), 4));
-				shuffle_vec = create_const_vector_4_i32 (
-					(ins->inst_c0 >> 0) & 0x3,
-					(ins->inst_c0 >> 2) & 0x3, 
-					(ins->inst_c0 >> 4) & 0x3,
-					(ins->inst_c0 >> 6) & 0x3);
-			}
-			values [ins->dreg] = LLVMBuildShuffleVector (builder, lhs, right_vec, shuffle_vec, "");
-			break;
-		}
-
 		case OP_SSE_OR: {
 			LLVMValueRef vec_lhs_i64 = convert (ctx, lhs, sse_i8_t);
 			LLVMValueRef vec_rhs_i64 = convert (ctx, rhs, sse_i8_t);
@@ -8554,30 +8401,42 @@ process_bb (EmitContext *ctx, MonoBasicBlock *bb)
 		case OP_SSE_CMPSS:
 		case OP_SSE2_CMPSD: {
 			int imm = -1;
+			gboolean swap = FALSE;
 			switch (ins->inst_c0) {
-			case CMP_EQ: imm = 0; break;
-			case CMP_GT: imm = 6; break;
-			case CMP_GE: imm = 5; break;
-			case CMP_LT: imm = 1; break;
-			case CMP_LE: imm = 2; break;
-			case CMP_NE: imm = 4; break;
-			case CMP_ORD: imm = 7; break;
-			case CMP_UNORD: imm = 3; break;
+			case CMP_EQ: imm = SSE_eq_ord_nosignal; break;
+			case CMP_GT: imm = SSE_lt_ord_signal; swap = TRUE; break;
+			case CMP_GE: imm = SSE_le_ord_signal; swap = TRUE; break;
+			case CMP_LT: imm = SSE_lt_ord_signal; break;
+			case CMP_LE: imm = SSE_le_ord_signal; break;
+			case CMP_GT_UN: imm = SSE_nle_unord_signal; break;
+			case CMP_GE_UN: imm = SSE_nlt_unord_signal; break;
+			case CMP_LT_UN: imm = SSE_nle_unord_signal; swap = TRUE; break;
+			case CMP_LE_UN: imm = SSE_nlt_unord_signal; swap = TRUE; break;
+			case CMP_NE: imm = SSE_neq_unord_nosignal; break;
+			case CMP_ORD: imm = SSE_ord_nosignal; break;
+			case CMP_UNORD: imm = SSE_unord_nosignal; break;
 			default: g_assert_not_reached (); break;
 			}
 			LLVMValueRef cmp = LLVMConstInt (LLVMInt8Type (), imm, FALSE);
 			LLVMValueRef args [] = { lhs, rhs, cmp };
+			if (swap) {
+				args [0] = rhs;
+				args [1] = lhs;
+			}
+			IntrinsicId id = (IntrinsicId) 0;
 			switch (ins->opcode) {
-			case OP_SSE_CMPSS:
-				values [ins->dreg] = call_intrins (ctx, INTRINS_SSE_CMPSS, args, "");
-				break;
-			case OP_SSE2_CMPSD:
-				values [ins->dreg] = call_intrins (ctx, INTRINS_SSE_CMPSD, args, "");
-				break;
-			default:
-				g_assert_not_reached ();
-				break;
+			case OP_SSE_CMPSS: id = INTRINS_SSE_CMPSS; break;
+			case OP_SSE2_CMPSD: id = INTRINS_SSE_CMPSD; break;
+			default: g_assert_not_reached (); break;
+			}
+			int elements = LLVMGetVectorSize (LLVMTypeOf (lhs));
+			int mask_values [MAX_VECTOR_ELEMS] = { 0 };
+			for (int i = 1; i < elements; ++i) {
+				mask_values [i] = elements + i;
 			}
+			LLVMValueRef result = call_intrins (ctx, id, args, "");
+			result = LLVMBuildShuffleVector (builder, result, lhs, create_const_vector_i32 (mask_values, elements), "");
+			values [ins->dreg] = result;
 			break;
 		}
 		case OP_SSE_COMISS: {
@@ -8914,50 +8773,50 @@ process_bb (EmitContext *ctx, MonoBasicBlock *bb)
 			break;
 		}
 
+		case OP_SSE_SHUFPS:
 		case OP_SSE2_SHUFPD:
 		case OP_SSE2_PSHUFD:
 		case OP_SSE2_PSHUFHW:
 		case OP_SSE2_PSHUFLW: {
-			LLVMBasicBlockRef bbs [256 + 1];
-			LLVMValueRef switch_ins;
-			LLVMValueRef v1, v2, mask;
-			LLVMValueRef phi_values [256 + 1];
-			int ncases;
-
-			// FIXME: Optimize constant shuffle mask
-
-			if (ins->opcode == OP_SSE2_SHUFPD) {
-				/* 3 parameter version */
-				v1 = lhs;
-				v2 = rhs;
-				mask = values [ins->sreg3];
-				ncases = 4;
-			} else {
-				/* 2 parameter version */
-				v1 = v2 = lhs;
-				mask = rhs;
-				ncases = 256;
-			}
-
-			for (int i = 0; i < ncases; ++i)
-				bbs [i] = gen_bb (ctx, "PSHUFHW_CASE_BB");
-			cbb = gen_bb (ctx, "PSHUFHW_COND_BB");
-			/* No default case */
-			switch_ins = LLVMBuildSwitch (builder, mask, bbs [0], 0);
-			for (int i = 0; i < ncases; ++i) {
-				LLVMAddCase (switch_ins, LLVMConstInt (LLVMInt32Type (), i, FALSE), bbs [i]);
-				LLVMPositionBuilderAtEnd (builder, bbs [i]);
+			LLVMTypeRef ret_t = LLVMTypeOf (lhs);
+			LLVMValueRef l = lhs;
+			LLVMValueRef r = rhs;
+			LLVMValueRef ctl = arg3;
+			const char *oname = "";
+			int ncases = 0;
+
+			switch (ins->opcode) {
+			case OP_SSE_SHUFPS: ncases = 256; break;
+			case OP_SSE2_SHUFPD: ncases = 4; break;
+			case OP_SSE2_PSHUFD: case OP_SSE2_PSHUFHW: case OP_SSE2_PSHUFLW: ncases = 256; r = lhs; ctl = rhs; break;
+			}
+
+			switch (ins->opcode) {
+			case OP_SSE_SHUFPS: oname = "sse_shufps"; break;
+			case OP_SSE2_SHUFPD: oname = "sse2_shufpd"; break;
+			case OP_SSE2_PSHUFD: oname = "sse2_pshufd"; break;
+			case OP_SSE2_PSHUFHW: oname = "sse2_pshufhw"; break;
+			case OP_SSE2_PSHUFLW: oname = "sse2_pshuflw"; break;
+			}
 
-				/* Convert the x86 shuffle mask to LLVM's */
-				guint32 imask = i;
-				int mask_values [8];
-				int mask_len = 0;
+			ctl = LLVMBuildAnd (builder, ctl, const_int32 (ncases - 1), "");
+			ImmediateUnrollCtx ictx = immediate_unroll_begin (ctx, bb, ncases, ctl, ret_t, oname);
+			int mask_values [8];
+			int mask_len = 0;
+			int i = 0;
+			while (immediate_unroll_next (&ictx, &i)) {
 				switch (ins->opcode) {
+				case OP_SSE_SHUFPS:
+					mask_len = 4;
+					mask_values [0] = ((i >> 0) & 0x3) + 0; // take two elements from lhs
+					mask_values [1] = ((i >> 2) & 0x3) + 0;
+					mask_values [2] = ((i >> 4) & 0x3) + 4; // and two from rhs
+					mask_values [3] = ((i >> 6) & 0x3) + 4;
+					break;
 				case OP_SSE2_SHUFPD:
-					/* Bit 0 selects v1[0] or v1[1], bit 1 selects v2[0] or v2[1] */
 					mask_len = 2;
-					mask_values [0] = ((imask >> 0) & 1);
-					mask_values [1] = ((imask >> 1) & 1) + 2;
+					mask_values [0] = ((i >> 0) & 0x1) + 0;
+					mask_values [1] = ((i >> 1) & 0x1) + 2;
 					break;
 				case OP_SSE2_PSHUFD:
 					/*
@@ -8966,7 +8825,7 @@ process_bb (EmitContext *ctx, MonoBasicBlock *bb)
 					 */
 					mask_len = 4;
 					for (int j = 0; j < 4; ++j) {
-						int windex = (imask >> (j * 2)) & 0x3;
+						int windex = (i >> (j * 2)) & 0x3;
 						mask_values [j] = windex;
 					}
 					break;
@@ -8980,7 +8839,7 @@ process_bb (EmitContext *ctx, MonoBasicBlock *bb)
 					for (int j = 0; j < 4; ++j)
 						mask_values [j] = j;
 					for (int j = 0; j < 4; ++j) {
-						int windex = (imask >> (j * 2)) & 0x3;
+						int windex = (i >> (j * 2)) & 0x3;
 						mask_values [j + 4] = 4 + windex;
 					}
 					break;
@@ -8990,21 +8849,18 @@ process_bb (EmitContext *ctx, MonoBasicBlock *bb)
 					for (int j = 0; j < 4; ++j)
 						mask_values [j + 4] = j + 4;
 					for (int j = 0; j < 4; ++j) {
-						int windex = (imask >> (j * 2)) & 0x3;
+						int windex = (i >> (j * 2)) & 0x3;
 						mask_values [j] = windex;
 					}
 					break;
-				default:
-					g_assert_not_reached ();
-					break;
 				}
-				phi_values [i] = LLVMBuildShuffleVector (builder, v1, v2, create_const_vector_i32 (mask_values, mask_len), "");
-				LLVMBuildBr (builder, cbb);
+				LLVMValueRef mask = create_const_vector_i32 (mask_values, mask_len);
+				LLVMValueRef result = LLVMBuildShuffleVector (builder, l, r, mask, oname);
+				immediate_unroll_commit (&ictx, i, result);
 			}
-
-			LLVMPositionBuilderAtEnd (builder, cbb);
-			values [ins->dreg] = LLVMBuildPhi (builder, LLVMTypeOf (phi_values [0]), "");
-			LLVMAddIncoming (values [ins->dreg], phi_values, bbs, ncases);
+			immediate_unroll_default (&ictx);
+			immediate_unroll_commit_default (&ictx, LLVMGetUndef (ret_t));
+			values [ins->dreg] = immediate_unroll_end (&ictx, &cbb);
 			break;
 		}
 
@@ -9016,10 +8872,11 @@ process_bb (EmitContext *ctx, MonoBasicBlock *bb)
 			break;
 		}
 		case OP_SSE3_MOVDDUP_MEM: {
-			int mask [] = { 0, 0 };
-			LLVMTypeRef t = type_to_sse_type (ins->inst_c1);
-			LLVMValueRef value = mono_llvm_build_load (builder, convert (ctx, lhs, LLVMPointerType (t, 0)), "", FALSE);
-			values [ins->dreg] = LLVMBuildShuffleVector (builder, value, LLVMGetUndef (LLVMTypeOf (value)), create_const_vector_i32 (mask, 2), "");
+			LLVMValueRef undef = LLVMGetUndef (v128_r8_t);
+			LLVMValueRef addr = convert (ctx, lhs, LLVMPointerType (r8_t, 0));
+			LLVMValueRef elem = mono_llvm_build_aligned_load (builder, addr, "sse3_movddup_mem", FALSE, 1);
+			LLVMValueRef val = LLVMBuildInsertElement (builder, undef, elem, const_int32 (0), "sse3_movddup_mem");
+			values [ins->dreg] = LLVMBuildShuffleVector (builder, val, undef, LLVMConstNull (LLVMVectorType (i4_t, 2)), "sse3_movddup_mem");
 			break;
 		}
 		case OP_SSE3_MOVSHDUP: {
@@ -9050,16 +8907,37 @@ process_bb (EmitContext *ctx, MonoBasicBlock *bb)
 			values [ins->dreg] = convert (ctx, abs, typ);
 			break;
 		}
-		
+
 		case OP_SSSE3_ALIGNR: {
-			LLVMValueRef mask_values [16];
-			for (int i = 0; i < 16; i++)
-				mask_values [i] = LLVMConstInt (LLVMInt32Type (), i + ins->inst_c0, FALSE);
-			LLVMValueRef shuffled = LLVMBuildShuffleVector (builder, 
-				convert (ctx, rhs, sse_i1_t),
-				convert (ctx, lhs, sse_i1_t),
-				LLVMConstVector (mask_values, 16), "");
-			values [ins->dreg] = convert (ctx, shuffled, type_to_sse_type (ins->inst_c1));
+			LLVMTypeRef ret_t = simd_class_to_llvm_type (ctx, ins->klass);
+			LLVMValueRef zero = LLVMConstNull (v128_i1_t);
+			LLVMValueRef hivec = convert (ctx, lhs, v128_i1_t);
+			LLVMValueRef lovec = convert (ctx, rhs, v128_i1_t);
+			LLVMValueRef rshift_amount = convert (ctx, arg3, i1_t);
+			ImmediateUnrollCtx ictx = immediate_unroll_begin (ctx, bb, 32, rshift_amount, v128_i1_t, "ssse3_alignr");
+			LLVMValueRef mask_values [16]; // 128-bit vector, 8-bit elements, 16 total elements
+			int i = 0;
+			while (immediate_unroll_next (&ictx, &i)) {
+				LLVMValueRef hi = NULL;
+				LLVMValueRef lo = NULL;
+				if (i <= 16) {
+					for (int j = 0; j < 16; j++)
+						mask_values [j] = const_int32 (i + j);
+					lo = lovec;
+					hi = hivec;
+				} else {
+					for (int j = 0; j < 16; j++)
+						mask_values [j] = const_int32 (i + j - 16);
+					lo = hivec;
+					hi = zero;
+				}
+				LLVMValueRef shuffled = LLVMBuildShuffleVector (builder, lo, hi, LLVMConstVector (mask_values, 16), "ssse3_alignr");
+				immediate_unroll_commit (&ictx, i, shuffled);
+			}
+			immediate_unroll_default (&ictx);
+			immediate_unroll_commit_default (&ictx, zero);
+			LLVMValueRef result = immediate_unroll_end (&ictx, &cbb);
+			values [ins->dreg] = convert (ctx, result, ret_t);
 			break;
 		}
 
@@ -9077,58 +8955,116 @@ process_bb (EmitContext *ctx, MonoBasicBlock *bb)
 			break;
 		}
 
-		case OP_SSE41_DPPS_IMM: {
-			LLVMValueRef args [] = { lhs, rhs, LLVMConstInt (LLVMInt8Type (), ins->inst_c0, FALSE) };
-			values [ins->dreg] = call_intrins (ctx, INTRINS_SSE_DPPS, args, dname);
-			break;
-		}
-
-		case OP_SSE41_DPPD_IMM: {
-			LLVMValueRef args [] = { lhs, rhs, LLVMConstInt (LLVMInt8Type (), ins->inst_c0, FALSE) };
-			values [ins->dreg] = call_intrins (ctx, INTRINS_SSE_DPPD, args, dname);
+		case OP_SSE41_DPPS:
+		case OP_SSE41_DPPD: {
+			/* Bits 0, 1, 4, 5 are meaningful for the control mask
+			 * in dppd; all bits are meaningful for dpps.
+			 */
+			LLVMTypeRef ret_t = NULL;
+			LLVMValueRef mask = NULL;
+			int mask_bits = 0;
+			int high_shift = 0;
+			int low_mask = 0;
+			IntrinsicId iid = (IntrinsicId) 0;
+			const char *oname = "";
+			switch (ins->opcode) {
+			case OP_SSE41_DPPS:
+				ret_t = v128_r4_t;
+				mask = const_int8 (0xff); // 0b11111111
+				mask_bits = 8;
+				high_shift = 4;
+				low_mask = 0xf;
+				iid = INTRINS_SSE_DPPS;
+				oname = "sse41_dpps";
+				break;
+			case OP_SSE41_DPPD:
+				ret_t = v128_r8_t;
+				mask = const_int8 (0x33); // 0b00110011
+				mask_bits = 4;
+				high_shift = 2;
+				low_mask = 0x3;
+				iid = INTRINS_SSE_DPPD;
+				oname = "sse41_dppd";
+				break;
+			}
+			LLVMValueRef args [] = { lhs, rhs, NULL };
+			LLVMValueRef index = LLVMBuildAnd (builder, convert (ctx, arg3, i1_t), mask, oname);
+			ImmediateUnrollCtx ictx = immediate_unroll_begin (ctx, bb, 1 << mask_bits, index, ret_t, oname);
+			int i = 0;
+			while (immediate_unroll_next (&ictx, &i)) {
+				int imm = ((i >> high_shift) << 4) | (i & low_mask);
+				args [2] = const_int8 (imm);
+				LLVMValueRef result = call_intrins (ctx, iid, args, dname);
+				immediate_unroll_commit (&ictx, imm, result);
+			}
+			immediate_unroll_default (&ictx);
+			immediate_unroll_commit_default (&ictx, LLVMGetUndef (ret_t));
+			values [ins->dreg] = immediate_unroll_end (&ictx, &cbb);
 			break;
 		}
 
-		case OP_SSE41_MPSADBW_IMM: {
-			LLVMValueRef args [3];
-			args [0] = LLVMBuildBitCast (ctx->builder, lhs, sse_i1_t, "");
-			args [1] = LLVMBuildBitCast (ctx->builder, rhs, sse_i1_t, "");
-			args [2] = LLVMConstInt (LLVMInt8Type (), ins->inst_c0, FALSE);
-			values [ins->dreg] = call_intrins (ctx, INTRINS_SSE_MPSADBW, args, dname);
+		case OP_SSE41_MPSADBW: {
+			LLVMValueRef args [] = {
+				convert (ctx, lhs, sse_i1_t),
+				convert (ctx, rhs, sse_i1_t),
+				NULL,
+			};
+			LLVMValueRef ctl = convert (ctx, arg3, i1_t);
+			// Only 3 bits (bits 0-2) are used by mpsadbw and llvm.x86.sse41.mpsadbw
+			int used_bits = 0x7;
+			ctl = LLVMBuildAnd (builder, ctl, const_int8 (used_bits), "sse41_mpsadbw");
+			ImmediateUnrollCtx ictx = immediate_unroll_begin (ctx, bb, used_bits + 1, ctl, v128_i2_t, "sse41_mpsadbw");
+			int i = 0;
+			while (immediate_unroll_next (&ictx, &i)) {
+				args [2] = const_int8 (i);
+				LLVMValueRef result = call_intrins (ctx, INTRINS_SSE_MPSADBW, args, "sse41_mpsadbw");
+				immediate_unroll_commit (&ictx, i, result);
+			}
+			immediate_unroll_unreachable_default (&ictx);
+			values [ins->dreg] = immediate_unroll_end (&ictx, &cbb);
 			break;
 		}
 
-		case OP_SSE41_INSERT: {
-			if (ins->inst_c1 == MONO_TYPE_R4) {
-				// special case for <float> overload
-				LLVMValueRef args [3];
-				args [0] = values [ins->sreg1];
-				args [1] = values [ins->sreg2];
-				args [2] = convert (ctx, values [ins->sreg3], LLVMInt8Type ());
-				values [ins->dreg] = call_intrins (ctx, INTRINS_SSE_INSERTPS, args, dname);
-			} else {
-				// other overloads are implemented with `insertelement`
-				values [ins->dreg] = LLVMBuildInsertElement (builder, 
-					values [ins->sreg1], 
-					convert (ctx, values [ins->sreg2], primitive_type_to_llvm_type (inst_c1_type (ins))),
-					convert (ctx, values [ins->sreg3], LLVMInt8Type ()), dname);
+		case OP_SSE41_INSERTPS: {
+			LLVMValueRef ctl = convert (ctx, arg3, i1_t);
+			LLVMValueRef args [] = { lhs, rhs, NULL };
+			ImmediateUnrollCtx ictx = immediate_unroll_begin (ctx, bb, 256, ctl, v128_r4_t, "sse41_insertps");
+			int i = 0;
+			while (immediate_unroll_next (&ictx, &i)) {
+				args [2] = const_int8 (i);
+				LLVMValueRef result = call_intrins (ctx, INTRINS_SSE_INSERTPS, args, dname);
+				immediate_unroll_commit (&ictx, i, result);
 			}
+			immediate_unroll_unreachable_default (&ictx);
+			values [ins->dreg] = immediate_unroll_end (&ictx, &cbb);
 			break;
 		}
 
-		case OP_SSE41_BLEND_IMM: {
-			int nelem = LLVMGetVectorSize (LLVMTypeOf (lhs));
-			g_assert(nelem >= 2 && nelem <= 8); // I2, U2, R4, R8
-			
-			int mask_values [8];
-			for (int i = 0; i < nelem; i++) {
-				// n-bit in inst_c0 (control byte) is set to 1
-				gboolean bit_set = ((ins->inst_c0 & ( 1 << i )) >> i);
-				mask_values [i] = i + (bit_set ? 1 : 0) * nelem;
+		case OP_SSE41_BLEND: {
+			LLVMTypeRef ret_t = LLVMTypeOf (lhs);
+			int nelem = LLVMGetVectorSize (ret_t);
+			g_assert (nelem >= 2 && nelem <= 8); // I2, U2, R4, R8
+			int unique_ctl_patterns = 1 << nelem;
+			int ctlmask = unique_ctl_patterns - 1;
+			LLVMValueRef ctl = convert (ctx, arg3, i1_t);
+			ctl = LLVMBuildAnd (builder, ctl, const_int8 (ctlmask), "sse41_blend");
+
+			ImmediateUnrollCtx ictx = immediate_unroll_begin (ctx, bb, unique_ctl_patterns, ctl, ret_t, "sse41_blend");
+			int i = 0;
+			int mask_values [MAX_VECTOR_ELEMS] = { 0 };
+			while (immediate_unroll_next (&ictx, &i)) {
+				for (int lane = 0; lane < nelem; ++lane) {
+					// n-bit in inst_c0 (control byte) is set to 1
+					gboolean bit_set = (i & (1 << lane)) >> lane;
+					mask_values [lane] = lane + (bit_set ? nelem : 0);
+				}
+				LLVMValueRef mask = create_const_vector_i32 (mask_values, nelem);
+				LLVMValueRef result = LLVMBuildShuffleVector (builder, lhs, rhs, mask, "sse41_blend");
+				immediate_unroll_commit (&ictx, i, result);
 			}
-			
-			LLVMValueRef mask = create_const_vector_i32 (mask_values, nelem);
-			values [ins->dreg] = LLVMBuildShuffleVector (builder, lhs, rhs, mask, "");
+			immediate_unroll_default (&ictx);
+			immediate_unroll_commit_default (&ictx, LLVMGetUndef (ret_t));
+			values [ins->dreg] = immediate_unroll_end (&ictx, &cbb);
 			break;
 		}
 
@@ -9245,15 +9181,37 @@ process_bb (EmitContext *ctx, MonoBasicBlock *bb)
 			break;
 		}
 
-		case OP_PCLMULQDQ_IMM: {
-			LLVMValueRef args [] = { lhs, rhs, LLVMConstInt (LLVMInt8Type (), ins->inst_c0, FALSE) };
-			values [ins->dreg] = call_intrins (ctx, INTRINS_PCLMULQDQ, args, "");
+		case OP_PCLMULQDQ: {
+			LLVMValueRef args [] = { lhs, rhs, NULL };
+			LLVMValueRef ctl = convert (ctx, arg3, i1_t);
+			// Only bits 0 and 4 of the immediate operand are used by PCLMULQDQ.
+			ctl = LLVMBuildAnd (builder, ctl, const_int8 (0x11), "pclmulqdq");
+			ImmediateUnrollCtx ictx = immediate_unroll_begin (ctx, bb, 1 << 2, ctl, v128_i8_t, "pclmulqdq");
+			int i = 0;
+			while (immediate_unroll_next (&ictx, &i)) {
+				int imm = ((i & 0x2) << 3) | (i & 0x1);
+				args [2] = const_int8 (imm);
+				LLVMValueRef result = call_intrins (ctx, INTRINS_PCLMULQDQ, args, "pclmulqdq");
+				immediate_unroll_commit (&ictx, imm, result);
+			}
+			immediate_unroll_unreachable_default (&ictx);
+			values [ins->dreg] = immediate_unroll_end (&ictx, &cbb);
 			break;
 		}
 
-		case OP_AES_KEYGEN_IMM: {
-			LLVMValueRef args [] = { lhs, LLVMConstInt (LLVMInt8Type (), ins->inst_c0, FALSE) };
-			values [ins->dreg] = call_intrins (ctx, INTRINS_AESNI_AESKEYGENASSIST, args, "");
+		case OP_AES_KEYGENASSIST: {
+			LLVMValueRef roundconstant = convert (ctx, rhs, i1_t);
+			LLVMValueRef args [] = { convert (ctx, lhs, v128_i8_t), NULL };
+			ImmediateUnrollCtx ictx = immediate_unroll_begin (ctx, bb, 256, roundconstant, v128_i8_t, "aes_keygenassist");
+			int i = 0;
+			while (immediate_unroll_next (&ictx, &i)) {
+				args [1] = const_int8 (i);
+				LLVMValueRef result = call_intrins (ctx, INTRINS_AESNI_AESKEYGENASSIST, args, "aes_keygenassist");
+				immediate_unroll_commit (&ictx, i, result);
+			}
+			immediate_unroll_unreachable_default (&ictx);
+			LLVMValueRef result = immediate_unroll_end (&ictx, &cbb);
+			values [ins->dreg] = convert (ctx, result, v128_i1_t);
 			break;
 		}
 #endif
@@ -9349,24 +9307,6 @@ process_bb (EmitContext *ctx, MonoBasicBlock *bb)
 			values [ins->dreg] = LLVMBuildZExt (builder, cmp_zero, LLVMInt8Type (), "");
 			break;
 		}
-		case OP_XEXTRACT_I32:
-		case OP_XEXTRACT_I64:
-		case OP_XEXTRACT_R8:
-		case OP_XEXTRACT_R4: {
-			LLVMTypeRef rhst = LLVMTypeOf (rhs);
-			LLVMValueRef mask = NULL;
-			switch (ins->opcode) {
-			case OP_XEXTRACT_I32: case OP_XEXTRACT_R4:
-				mask = LLVMConstInt (rhst, 0x3, FALSE); break;
-			case OP_XEXTRACT_I64: case OP_XEXTRACT_R8:
-				mask = LLVMConstInt (rhst, 0x1, FALSE); break;
-			default:
-				g_assert_not_reached ();
-			}
-			LLVMValueRef selector = LLVMBuildAnd (builder, rhs, mask, "");
-			values [ins->dreg] = LLVMBuildExtractElement (builder, lhs, selector, "");
-			break;
-		}
 		case OP_POPCNT32:
 			values [ins->dreg] = call_intrins (ctx, INTRINS_CTPOP_I32, &lhs, "");
 			break;
@@ -9381,12 +9321,12 @@ process_bb (EmitContext *ctx, MonoBasicBlock *bb)
 			values [ins->dreg] = call_intrins (ctx, ins->opcode == OP_CTTZ32 ? INTRINS_CTTZ_I32 : INTRINS_CTTZ_I64, args, "");
 			break;
 		}
-		case OP_BEXTR32:
-		case OP_BEXTR64: {
+		case OP_BMI1_BEXTR32:
+		case OP_BMI1_BEXTR64: {
 			LLVMValueRef args [2];
 			args [0] = lhs;
-			args [1] = convert (ctx, rhs, ins->opcode == OP_BEXTR32 ? LLVMInt32Type () : LLVMInt64Type ()); // cast ushort to u32/u64
-			values [ins->dreg] = call_intrins (ctx, ins->opcode == OP_BEXTR32 ? INTRINS_BEXTR_I32 : INTRINS_BEXTR_I64, args, "");
+			args [1] = convert (ctx, rhs, ins->opcode == OP_BMI1_BEXTR32 ? i4_t : i8_t); // cast ushort to u32/u64
+			values [ins->dreg] = call_intrins (ctx, ins->opcode == OP_BMI1_BEXTR32 ? INTRINS_BEXTR_I32 : INTRINS_BEXTR_I64, args, "");
 			break;
 		}
 		case OP_BZHI32:
@@ -9407,8 +9347,9 @@ process_bb (EmitContext *ctx, MonoBasicBlock *bb)
 			LLVMValueRef rx = LLVMBuildZExt (ctx->builder, rhs, LLVMInt128Type (), "");
 			LLVMValueRef mulx = LLVMBuildMul (ctx->builder, lx, rx, "");
 			if (!only_high) {
+				LLVMValueRef addr = convert (ctx, arg3, LLVMPointerType (is_64 ? i8_t : i4_t, 0));
 				LLVMValueRef lowx = LLVMBuildTrunc (ctx->builder, mulx, is_64 ? LLVMInt64Type () : LLVMInt32Type (), "");
-				LLVMBuildStore (ctx->builder, lowx, values [ins->sreg3]);
+				LLVMBuildStore (ctx->builder, lowx, addr);
 			}
 			LLVMValueRef shift = LLVMConstInt (LLVMInt128Type (), is_64 ? 64 : 32, FALSE);
 			LLVMValueRef highx = LLVMBuildLShr (ctx->builder, mulx, shift, "");
@@ -9437,66 +9378,15 @@ process_bb (EmitContext *ctx, MonoBasicBlock *bb)
 #if defined(TARGET_ARM64) || defined(TARGET_X86) || defined(TARGET_AMD64)
 		case OP_LZCNT32:
 		case OP_LZCNT64: {
-			LLVMValueRef args [2];
-			args [0] = lhs;
-			args [1] = LLVMConstInt (LLVMInt1Type (), 1, FALSE);
-			values [ins->dreg] = LLVMBuildCall (builder, get_intrins (ctx, ins->opcode == OP_LZCNT32 ? INTRINS_CTLZ_I32 : INTRINS_CTLZ_I64), args, 2, "");
+			IntrinsicId iid = ins->opcode == OP_LZCNT32 ? INTRINS_CTLZ_I32 : INTRINS_CTLZ_I64;
+			LLVMValueRef args [] = { lhs, const_int1 (FALSE) };
+			values [ins->dreg] = call_intrins (ctx, iid, args, "");
 			break;
 		}
 #endif
 
 #if defined(TARGET_ARM64)
-		case OP_EXTRACT_VAR_I1:
-		case OP_EXTRACT_VAR_U1:
-		case OP_EXTRACT_VAR_I2:
-		case OP_EXTRACT_VAR_U2:
-		case OP_EXTRACT_VAR_I4:
-		case OP_EXTRACT_VAR_R4:
-		case OP_EXTRACT_VAR_R8:
-		case OP_EXTRACT_VAR_I8:
-		case OP_EXTRACT_U1:
-		case OP_EXTRACT_I1:
-		case OP_EXTRACT_U2:
-		case OP_EXTRACT_I2:
-		case OP_EXTRACT_I4:
-		case OP_EXTRACT_I8:
-		case OP_EXTRACT_R4:
-		case OP_EXTRACT_R8: {
-			gboolean sext = FALSE;
-			gboolean zext = FALSE;
-			switch (ins->opcode) {
-			case OP_EXTRACT_U1: case OP_EXTRACT_U2: zext = TRUE; break;
-			case OP_EXTRACT_I1: case OP_EXTRACT_I2: sext = TRUE; break;
-			case OP_EXTRACT_VAR_U1: case OP_EXTRACT_VAR_U2: zext = TRUE; break;
-			case OP_EXTRACT_VAR_I1: case OP_EXTRACT_VAR_I2: sext = TRUE; break;
-			}
-			LLVMValueRef element_ix = NULL;
-			switch (ins->opcode) {
-			case OP_EXTRACT_VAR_I1:
-			case OP_EXTRACT_VAR_U1:
-			case OP_EXTRACT_VAR_I2:
-			case OP_EXTRACT_VAR_U2:
-			case OP_EXTRACT_VAR_I4:
-			case OP_EXTRACT_VAR_R4:
-			case OP_EXTRACT_VAR_R8:
-			case OP_EXTRACT_VAR_I8:
-				element_ix = rhs;
-				break;
-			default:
-				element_ix = const_int32 (ins->inst_c0);
-			}
-			LLVMValueRef result = LLVMBuildExtractElement (builder, lhs, element_ix, "extract");
-			/* TODO: Scalar types smaller than i32 seem to be
-			 * normalized to i32 via zero or sign extension.
-			 * Is this still necessary?
-			 */
-			if (zext)
-				result = LLVMBuildZExt (builder, result, i4_t, "extract_zext");
-			else if (sext)
-				result = LLVMBuildSExt (builder, result, i4_t, "extract_sext");
-			values [ins->dreg] = result;
-			break;
-		}
+
 		case OP_XOP_I4_I4:
 		case OP_XOP_I8_I8: {
 			IntrinsicId id = (IntrinsicId)ins->inst_c0;
@@ -9576,24 +9466,6 @@ process_bb (EmitContext *ctx, MonoBasicBlock *bb)
 			values [ins->dreg] = result;
 			break;
 		}
-		case OP_XINSERT_I1:
-		case OP_XINSERT_I2:
-		case OP_XINSERT_I4:
-		case OP_XINSERT_I8:
-		case OP_XINSERT_R4:
-		case OP_XINSERT_R8: {
-			/* TODO: Scalar types smaller than i32 seem to be
-			 * normalized to i32 via zero or sign extension.
-			 * Is this still necessary?
-			 */
-			LLVMTypeRef t = LLVMTypeOf (lhs);
-			LLVMTypeRef elem_t = LLVMGetElementType (t);
-			MonoTypeEnum primty = inst_c1_type (ins);
-			LLVMValueRef val = convert_full (ctx, rhs, elem_t, primitive_type_is_unsigned (primty));
-			LLVMValueRef result = LLVMBuildInsertElement (builder, lhs, val, arg3, "xinsert");
-			values [ins->dreg] = result;
-			break;
-		}
 		case OP_XCOMPARE_FP_SCALAR:
 		case OP_XCOMPARE_FP: {
 			g_assert (LLVMTypeOf (lhs) == LLVMTypeOf (rhs));
diff --git a/src/mono/mono/mini/mini-ops.h b/src/mono/mono/mini/mini-ops.h
index d7ab7c739f3c1c..5fadd703be0363 100644
--- a/src/mono/mono/mini/mini-ops.h
+++ b/src/mono/mono/mini/mini-ops.h
@@ -787,16 +787,19 @@ MINI_OP(OP_NOT_NULL, "not_null", NONE, IREG, NONE)
 
 #if defined(TARGET_X86) || defined(TARGET_AMD64) || defined(TARGET_WASM) || defined(TARGET_ARM64)
 
-MINI_OP(OP_EXTRACT_I4, "extract_i4", IREG, XREG, NONE)
 MINI_OP(OP_ICONV_TO_R4_RAW, "iconv_to_r4_raw", FREG, IREG, NONE)
 
-MINI_OP(OP_EXTRACT_I2, "extract_i2", IREG, XREG, NONE)
-MINI_OP(OP_EXTRACT_U2, "extract_u2", IREG, XREG, NONE)
+/* Extract an element from a vector with a constant lane index.
+ * inst_c0 is the lane index.
+ * inst_c1 is a MonoTypeEnum representing the element type.
+ */
 MINI_OP(OP_EXTRACT_I1, "extract_i1", IREG, XREG, NONE)
-MINI_OP(OP_EXTRACT_U1, "extract_u1", IREG, XREG, NONE)
+MINI_OP(OP_EXTRACT_I2, "extract_i2", IREG, XREG, NONE)
+MINI_OP(OP_EXTRACT_I4, "extract_i4", IREG, XREG, NONE)
+MINI_OP(OP_EXTRACT_I8, "extract_i8", LREG, XREG, NONE)
 MINI_OP(OP_EXTRACT_R4, "extract_r4", FREG, XREG, NONE)
 MINI_OP(OP_EXTRACT_R8, "extract_r8", FREG, XREG, NONE)
-MINI_OP(OP_EXTRACT_I8, "extract_i8", LREG, XREG, NONE)
+MINI_OP(OP_EXTRACTX_U2, "extractx_u2", IREG, XREG, NONE)
 
 /* Used by LLVM */
 MINI_OP(OP_INSERT_I1, "insert_i1", XREG, XREG, IREG)
@@ -806,8 +809,6 @@ MINI_OP(OP_INSERT_I8, "insert_i8", XREG, XREG, LREG)
 MINI_OP(OP_INSERT_R4, "insert_r4", XREG, XREG, FREG)
 MINI_OP(OP_INSERT_R8, "insert_r8", XREG, XREG, FREG)
 
-MINI_OP(OP_EXTRACTX_U2, "extractx_u2", IREG, XREG, NONE)
-
 /*these slow ops are modeled around the availability of a fast 2 bytes insert op*/
 /*insertx_u1_slow takes old value and new value as source regs */
 MINI_OP(OP_INSERTX_U1_SLOW, "insertx_u1_slow", XREG, IREG, IREG)
@@ -1003,10 +1004,6 @@ MINI_OP(OP_CVTPS2PD, "cvtps2pd", XREG, XREG, NONE)
 MINI_OP(OP_CVTTPD2DQ, "cvttpd2dq", XREG, XREG, NONE)
 MINI_OP(OP_CVTTPS2DQ, "cvttps2dq", XREG, XREG, NONE)
 
-/* r4 dot product */
-/* multiply all 4 single precision float elements, add them together, and store the result to the lowest element */
-MINI_OP(OP_DPPS, "dpps", XREG, XREG, XREG)
-
 /* sse 1 */
 /* inst_c1 is target type */
 MINI_OP(OP_SSE_LOADU, "sse_loadu", XREG, XREG, NONE)
@@ -1019,7 +1016,7 @@ MINI_OP(OP_SSE_MOVEHL, "sse_movehl", XREG, XREG, XREG)
 MINI_OP(OP_SSE_MOVELH, "sse_movelh", XREG, XREG, XREG)
 MINI_OP(OP_SSE_UNPACKLO, "sse_unpacklo", XREG, XREG, XREG)
 MINI_OP(OP_SSE_UNPACKHI, "sse_unpackhi", XREG, XREG, XREG)
-MINI_OP(OP_SSE_SHUFFLE, "sse_shuffle", XREG, XREG, XREG)
+MINI_OP3(OP_SSE_SHUFPS, "sse_shufps", XREG, XREG, XREG, IREG)
 MINI_OP(OP_SSE_AND, "sse_and", XREG, XREG, XREG)
 MINI_OP(OP_SSE_OR, "sse_or", XREG, XREG, XREG)
 MINI_OP(OP_SSE_XOR, "sse_xor", XREG, XREG, XREG)
@@ -1051,7 +1048,6 @@ MINI_OP(OP_SSE_CVTSI2SS64, "sse_cvtsi2ss64", XREG, XREG, LREG)
 /* sse 2 */
 MINI_OP(OP_SSE2_PACKUS, "sse2_packus", XREG, XREG, XREG)
 MINI_OP(OP_SSE2_SRLI, "sse2_srli", XREG, XREG, XREG)
-MINI_OP(OP_SSE2_SHUFFLE, "sse2_shuffle", XREG, XREG, XREG)
 MINI_OP(OP_SSE2_ADDS, "sse2_adds", XREG, XREG, XREG)
 MINI_OP(OP_SSE2_SUBS, "sse2_subs", XREG, XREG, XREG)
 MINI_OP(OP_SSE2_CMPSD, "sse2_cmpsd", XREG, XREG, XREG)
@@ -1100,23 +1096,23 @@ MINI_OP3(OP_SSSE3_ALIGNR, "ssse3_alignr", XREG, XREG, XREG, IREG)
 
 /* sse 4.1 */
 MINI_OP(OP_SSE41_ROUNDP, "roundp", XREG, XREG, NONE) // packed, inst_c0 - mode, inst_c1 - r4 or r8
-MINI_OP(OP_SSE41_ROUNDS, "rounds", XREG, XREG, XREG) // scalar, inst_c0 - mode, inst_c1 - r4 or r8
-MINI_OP3(OP_SSE41_INSERT, "sse41_insert", XREG, XREG, XREG, IREG)
+MINI_OP(OP_SSE41_ROUNDS, "sse41_rounds", XREG, XREG, XREG) // scalar, inst_c0 - mode, inst_c1 - r4 or r8
+MINI_OP3(OP_SSE41_INSERTPS, "sse41_insertps", XREG, XREG, XREG, IREG)
 MINI_OP3(OP_SSE41_BLENDV, "sse41_blendv", XREG, XREG, XREG, XREG)
-MINI_OP(OP_SSE41_BLEND_IMM, "sse41_blend", XREG, XREG, XREG)
+MINI_OP3(OP_SSE41_BLEND, "sse41_blend", XREG, XREG, XREG, IREG)
 MINI_OP(OP_SSE41_LOADANT, "sse41_loadant", XREG, XREG, NONE)
 MINI_OP(OP_SSE41_MUL, "sse41_mul", XREG, XREG, XREG)
 MINI_OP(OP_SSE41_MULLO, "sse41_mullo", XREG, XREG, XREG)
 MINI_OP(OP_SSE_CVTII, "sse_cvtii", XREG, XREG, NONE)
-MINI_OP(OP_SSE41_DPPS_IMM, "sse_dpps", XREG, XREG, XREG)
-MINI_OP(OP_SSE41_DPPD_IMM, "sse_dppd", XREG, XREG, XREG)
-MINI_OP(OP_SSE41_MPSADBW_IMM, "sse_mpsadbw", XREG, XREG, XREG)
+MINI_OP3(OP_SSE41_DPPS, "sse41_dpps", XREG, XREG, XREG, IREG)
+MINI_OP3(OP_SSE41_DPPD, "sse41_dppd", XREG, XREG, XREG, IREG)
+MINI_OP3(OP_SSE41_MPSADBW, "sse41_mpsadbw", XREG, XREG, XREG, IREG)
 
 /* pclmulqdq */
-MINI_OP(OP_PCLMULQDQ_IMM, "pclmulqdq", XREG, XREG, XREG)
+MINI_OP3(OP_PCLMULQDQ, "pclmulqdq", XREG, XREG, XREG, IREG)
 
 /* aes */
-MINI_OP(OP_AES_KEYGEN_IMM, "aes_keygen", XREG, XREG, NONE)
+MINI_OP(OP_AES_KEYGENASSIST, "aes_keygen", XREG, XREG, IREG)
 
 /* sse 4.2 */
 MINI_OP(OP_SSE42_CRC32, "sse42_crc32", IREG, IREG, IREG)
@@ -1127,8 +1123,8 @@ MINI_OP(OP_SSE42_PTESTZ, "sse42_ptestc", IREG, XREG, XREG)
 /* Count trailing zeroes, return 32/64 if the input is 0 */
 MINI_OP(OP_CTTZ32, "cttz32", IREG, IREG, NONE)
 MINI_OP(OP_CTTZ64, "cttz64", LREG, LREG, NONE)
-MINI_OP(OP_BEXTR32, "bextr32", IREG, IREG, IREG)
-MINI_OP(OP_BEXTR64, "bextr64", LREG, LREG, LREG)
+MINI_OP(OP_BMI1_BEXTR32, "bmi1_bextr32", IREG, IREG, IREG)
+MINI_OP(OP_BMI1_BEXTR64, "bmi1_bextr64", LREG, LREG, LREG)
 
 /* Intel BMI2 */
 MINI_OP(OP_BZHI32, "bzhi32", IREG, IREG, IREG)
@@ -1568,17 +1564,24 @@ MINI_OP(OP_XOP_OVR_BYSCALAR_X_X_X, "xop_ovr_byscalar_x_x_x", XREG, XREG, XREG)
 MINI_OP(OP_XCONCAT, "xconcat", XREG, XREG, XREG)
 
 MINI_OP(OP_XCAST, "xcast", XREG, XREG, NONE)
-/* Extract element of vector */
-/* The index is assumed to be in range */
-/* inst_i0 is the element type */
-MINI_OP(OP_XEXTRACT_I32, "xextract_i32", IREG, XREG, IREG)
-MINI_OP(OP_XEXTRACT_I64, "xextract_i64", LREG, XREG, IREG)
-MINI_OP(OP_XEXTRACT_R8, "xextract_r8", FREG, XREG, IREG)
-/* Return an R4 */
+
+/* Extract an element from a vector with a variable lane index.
+ * The index is assumed to be in range.
+ * inst_c1 is a MonoTypeEnum representing the element type.
+ */
+MINI_OP(OP_XEXTRACT_I1, "xextract_i1", IREG, XREG, IREG)
+MINI_OP(OP_XEXTRACT_I2, "xextract_i2", IREG, XREG, IREG)
+MINI_OP(OP_XEXTRACT_I4, "xextract_i4", IREG, XREG, IREG)
+MINI_OP(OP_XEXTRACT_I8, "xextract_i8", LREG, XREG, IREG)
 MINI_OP(OP_XEXTRACT_R4, "xextract_r4", FREG, XREG, IREG)
+MINI_OP(OP_XEXTRACT_R8, "xextract_r8", FREG, XREG, IREG)
 
-/* Insert element into a vector */
-/* sreg1 is the vector, sreg2 is the value, sreg3 is the index */
+/* Insert an element into a vector with a variable lane index.
+ * sreg1 is the vector, sreg2 is the value, sreg3 is the index.
+ * inst_c1 is a MonoTypeEnum representing the element type, used to control
+ * sign/zero extension if conversion of sreg2 happens to be necessary.
+ * klass must be set to the MonoClass representing the return type of the op.
+ */
 MINI_OP3(OP_XINSERT_I1, "xinsert_i1", XREG, XREG, IREG, IREG)
 MINI_OP3(OP_XINSERT_I2, "xinsert_i2", XREG, XREG, IREG, IREG)
 MINI_OP3(OP_XINSERT_I4, "xinsert_i4", XREG, XREG, IREG, IREG)
@@ -1738,15 +1741,6 @@ MINI_OP(OP_ARM64_SQXTUN2, "arm64_sqxtun2", XREG, XREG, XREG)
 
 MINI_OP(OP_ARM64_SELECT_SCALAR, "arm64_select_scalar", XREG, XREG, IREG)
 
-MINI_OP(OP_EXTRACT_VAR_I1, "extract_var_i1", IREG, XREG, IREG)
-MINI_OP(OP_EXTRACT_VAR_U1, "extract_var_u1", IREG, XREG, IREG)
-MINI_OP(OP_EXTRACT_VAR_I2, "extract_var_i2", IREG, XREG, IREG)
-MINI_OP(OP_EXTRACT_VAR_U2, "extract_var_u2", IREG, XREG, IREG)
-MINI_OP(OP_EXTRACT_VAR_I4, "extract_var_i4", IREG, XREG, IREG)
-MINI_OP(OP_EXTRACT_VAR_R4, "extract_var_r4", FREG, XREG, IREG)
-MINI_OP(OP_EXTRACT_VAR_R8, "extract_var_r8", FREG, XREG, IREG)
-MINI_OP(OP_EXTRACT_VAR_I8, "extract_var_i8", LREG, XREG, IREG)
-
 MINI_OP(OP_ARM64_FCVTZU, "arm64_fcvtzu", XREG, XREG, NONE)
 MINI_OP(OP_ARM64_FCVTZS, "arm64_fcvtzs", XREG, XREG, NONE)
 MINI_OP(OP_ARM64_FCVTZU_SCALAR, "arm64_fcvtzu_scalar", XREG, XREG, NONE)
diff --git a/src/mono/mono/mini/mini-runtime.c b/src/mono/mono/mini/mini-runtime.c
index 60d0130f83fff2..09944b33a7234b 100644
--- a/src/mono/mono/mini/mini-runtime.c
+++ b/src/mono/mono/mini/mini-runtime.c
@@ -159,10 +159,7 @@ GSList *mono_interp_only_classes;
 
 static void register_icalls (void);
 static void runtime_cleanup (MonoDomain *domain, gpointer user_data);
-#ifdef ENABLE_METADATA_UPDATE
-static void mini_metadata_update_init (MonoError *error);
 static void mini_invalidate_transformed_interp_methods (MonoAssemblyLoadContext *alc, uint32_t generation);
-#endif
 
 gboolean
 mono_running_on_valgrind (void)
@@ -2690,6 +2687,22 @@ mono_jit_compile_method_jit_only (MonoMethod *method, MonoError *error)
 	return code;
 }
 
+/*
+ * get_ftnptr_for_method:
+ *
+ *   Return a function pointer for METHOD which is indirectly callable from managed code.
+ * On llvmonly, this returns a MonoFtnDesc, otherwise it returns a normal function pointer.
+ */
+static gpointer
+get_ftnptr_for_method (MonoMethod *method, MonoError *error)
+{
+	if (!mono_llvm_only) {
+		return mono_jit_compile_method (method, error);
+	} else {
+		return mini_llvmonly_load_method_ftndesc (method, FALSE, FALSE, error);
+	}
+}
+
 #ifdef MONO_ARCH_HAVE_INVALIDATE_METHOD
 static void
 invalidated_delegate_trampoline (char *desc)
@@ -3228,6 +3241,10 @@ mono_jit_runtime_invoke (MonoMethod *method, void *obj, void **params, MonoObjec
 
 		gboolean use_interp = FALSE;
 
+		if (mono_aot_mode == MONO_AOT_MODE_LLVMONLY_INTERP)
+			/* The runtime invoke wrappers contain clauses so they are not AOTed */
+			use_interp = TRUE;
+
 		if (callee) {
 			compiled_method = mono_jit_compile_method_jit_only (callee, error);
 			if (!compiled_method) {
@@ -4325,6 +4342,7 @@ mini_init (const char *filename, const char *runtime_version)
 	callbacks.create_jit_trampoline = mono_create_jit_trampoline;
 	callbacks.create_delegate_trampoline = mono_create_delegate_trampoline;
 	callbacks.free_method = mono_jit_free_method;
+	callbacks.get_ftnptr = get_ftnptr_for_method;
 #endif
 	callbacks.is_interpreter_enabled = mini_is_interpreter_enabled;
 	callbacks.get_weak_field_indexes = mono_aot_get_weak_field_indexes;
@@ -4332,10 +4350,7 @@ mini_init (const char *filename, const char *runtime_version)
 #ifndef DISABLE_CRASH_REPORTING
 	callbacks.install_state_summarizer = mini_register_sigterm_handler;
 #endif
-#ifdef ENABLE_METADATA_UPDATE
-	callbacks.metadata_update_init = mini_metadata_update_init;
 	callbacks.metadata_update_published = mini_invalidate_transformed_interp_methods;
-#endif
 	callbacks.init_mem_manager = init_jit_mem_manager;
 	callbacks.free_mem_manager = free_jit_mem_manager;
 
@@ -5118,19 +5133,12 @@ mono_runtime_install_custom_handlers_usage (void)
 }
 #endif /* HOST_WIN32 */
 
-#ifdef ENABLE_METADATA_UPDATE
-void
-mini_metadata_update_init (MonoError *error)
-{
-	mini_get_interp_callbacks ()->metadata_update_init (error);
-}
-
 void
 mini_invalidate_transformed_interp_methods (MonoAssemblyLoadContext *alc G_GNUC_UNUSED, uint32_t generation G_GNUC_UNUSED)
 {
 	mini_get_interp_callbacks ()->invalidate_transformed ();
 }
-#endif
+
 
 /*
  * mini_get_default_mem_manager:
diff --git a/src/mono/mono/mini/mini-s390x.c b/src/mono/mono/mini/mini-s390x.c
index 9f276742151e52..bc4e9b24d114c6 100644
--- a/src/mono/mono/mini/mini-s390x.c
+++ b/src/mono/mono/mini/mini-s390x.c
@@ -5131,19 +5131,17 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb)
 			}
 			break;
 		case OP_EXTRACT_I1:
-		case OP_EXTRACT_U1:
 			amd64_movd_reg_xreg_size (code, ins->dreg, ins->sreg1, 4);
 			if (ins->inst_c0)
 				amd64_shift_reg_imm (code, X86_SHR, ins->dreg, ins->inst_c0 * 8);
-			amd64_widen_reg (code, ins->dreg, ins->dreg, ins->opcode == OP_EXTRACT_I1, FALSE);
+			amd64_widen_reg (code, ins->dreg, ins->dreg, ins->inst_c1 == MONO_TYPE_I1, FALSE);
 			break;
 		case OP_EXTRACT_I2:
-		case OP_EXTRACT_U2:
 			/*amd64_movd_reg_xreg_size (code, ins->dreg, ins->sreg1, 4);
 			if (ins->inst_c0)
 				amd64_shift_reg_imm_size (code, X86_SHR, ins->dreg, 16, 4);*/
 			s390x_pextrw_imm (code, ins->dreg, ins->sreg1, ins->inst_c0);
-			amd64_widen_reg_size (code, ins->dreg, ins->dreg, ins->opcode == OP_EXTRACT_I2, TRUE, 4);
+			amd64_widen_reg_size (code, ins->dreg, ins->dreg, ins->inst_c1 == MONO_TYPE_I2, TRUE, 4);
 			break;
 		case OP_EXTRACT_R8:
 			if (ins->inst_c0)
diff --git a/src/mono/mono/mini/mini-wasm-debugger.c b/src/mono/mono/mini/mini-wasm-debugger.c
index 352bb81deb9232..fd19c6a846277b 100644
--- a/src/mono/mono/mini/mini-wasm-debugger.c
+++ b/src/mono/mono/mini/mini-wasm-debugger.c
@@ -11,6 +11,8 @@
 #include <mono/mini/aot-runtime.h>
 #include <mono/mini/seq-points.h>
 #include <mono/mini/debugger-engine.h>
+#include <mono/mini/debugger-protocol.h>
+#include <mono/mini/debugger-agent.h>
 
 //XXX This is dirty, extend ee.h to support extracting info from MonoInterpFrameHandle
 #include <mono/mini/interp/interp-internals.h>
@@ -24,84 +26,29 @@
 
 static int log_level = 1;
 
-enum {
-	EXCEPTION_MODE_NONE,
-	EXCEPTION_MODE_UNCAUGHT,
-	EXCEPTION_MODE_ALL
-};
-
-// Flags for get_*_properties
-#define GPFLAG_NONE               0x0000
-#define GPFLAG_OWN_PROPERTIES     0x0001
-#define GPFLAG_ACCESSORS_ONLY     0x0002
-#define GPFLAG_EXPAND_VALUETYPES  0x0004
-
 //functions exported to be used by JS
 G_BEGIN_DECLS
 
-EMSCRIPTEN_KEEPALIVE int mono_wasm_set_breakpoint (const char *assembly_name, int method_token, int il_offset);
-EMSCRIPTEN_KEEPALIVE int mono_wasm_remove_breakpoint (int bp_id);
-EMSCRIPTEN_KEEPALIVE int mono_wasm_current_bp_id (void);
-EMSCRIPTEN_KEEPALIVE void mono_wasm_enum_frames (void);
-EMSCRIPTEN_KEEPALIVE gboolean mono_wasm_get_local_vars (int scope, int* pos, int len);
-EMSCRIPTEN_KEEPALIVE void mono_wasm_clear_all_breakpoints (void);
-EMSCRIPTEN_KEEPALIVE int mono_wasm_setup_single_step (int kind);
-EMSCRIPTEN_KEEPALIVE int mono_wasm_pause_on_exceptions (int state);
-EMSCRIPTEN_KEEPALIVE gboolean mono_wasm_get_object_properties (int object_id, int gpflags);
-EMSCRIPTEN_KEEPALIVE gboolean mono_wasm_get_array_values (int object_id, int start_idx, int count, int gpflags);
-EMSCRIPTEN_KEEPALIVE gboolean mono_wasm_invoke_getter_on_object (int object_id, const char* name);
-EMSCRIPTEN_KEEPALIVE gboolean mono_wasm_invoke_getter_on_value (void *value, MonoClass *klass, const char *name);
-EMSCRIPTEN_KEEPALIVE gboolean mono_wasm_get_deref_ptr_value (void *value_addr, MonoClass *klass);
 EMSCRIPTEN_KEEPALIVE void mono_wasm_set_is_debugger_attached (gboolean is_attached);
-EMSCRIPTEN_KEEPALIVE gboolean mono_wasm_set_variable_on_frame (int scope, int index, const char* name, const char* value);
-EMSCRIPTEN_KEEPALIVE gboolean mono_wasm_set_value_on_object (int object_id, const char* name, const char* value);
+EMSCRIPTEN_KEEPALIVE gboolean mono_wasm_send_dbg_command (int id, MdbgProtCommandSet command_set, int command, guint8* data, unsigned int size);
+EMSCRIPTEN_KEEPALIVE gboolean mono_wasm_send_dbg_command_with_parms (int id, MdbgProtCommandSet command_set, int command, guint8* data, unsigned int size, int valtype, char* newvalue);
+
 
 //JS functions imported that we use
-extern void mono_wasm_add_frame (int il_offset, int method_token, int frame_id, const char *assembly_name, const char *method_name);
-extern void mono_wasm_fire_bp (void);
-extern void mono_wasm_fire_exception (int exception_obj_id, const char* message, const char* class_name, gboolean uncaught);
-extern void mono_wasm_add_obj_var (const char*, const char*, guint64);
-extern void mono_wasm_add_enum_var (const char*, const char*, guint64);
-extern void mono_wasm_add_func_var (const char*, const char*, guint64);
-extern void mono_wasm_add_properties_var (const char*, gint32);
-extern void mono_wasm_add_array_item (int);
-extern void mono_wasm_set_is_async_method (guint64);
-extern void mono_wasm_add_typed_value (const char *type, const char *str_value, double value);
+extern void mono_wasm_fire_debugger_agent_message (void);
 extern void mono_wasm_asm_loaded (const char *asm_name, const char *assembly_data, guint32 assembly_len, const char *pdb_data, guint32 pdb_len);
 
 G_END_DECLS
 
-static void describe_object_properties_for_klass (void *obj, MonoClass *klass, gboolean isAsyncLocalThis, int gpflags);
 static void handle_exception (MonoException *exc, MonoContext *throw_ctx, MonoContext *catch_ctx, StackFrameInfo *catch_frame);
+static gboolean receive_debugger_agent_message (void *data, int len);
 static void assembly_loaded (MonoProfiler *prof, MonoAssembly *assembly);
-static MonoObject* mono_runtime_try_invoke_internal (MonoMethod *method, void *obj, void **params, MonoObject **exc, MonoError* error);
 
 //FIXME move all of those fields to the profiler object
 static gboolean debugger_enabled;
 
 static gboolean has_pending_lazy_loaded_assemblies;
 
-static int event_request_id;
-static GHashTable *objrefs;
-static GHashTable *obj_to_objref;
-static int objref_id = 0;
-static int pause_on_exc = EXCEPTION_MODE_NONE;
-static MonoObject* exception_on_runtime_invoke = NULL;
-
-static const char*
-all_getters_allowed_class_names[] = {
-	"System.DateTime",
-	"System.DateTimeOffset",
-	"System.TimeSpan"
-};
-
-static const char*
-to_string_as_descr_names[] = {
-	"System.DateTime",
-	"System.DateTimeOffset",
-	"System.Decimal",
-	"System.TimeSpan"
-};
 
 #define THREAD_TO_INTERNAL(thread) (thread)->internal_thread
 
@@ -129,14 +76,6 @@ void wasm_debugger_log (int level, const gchar *format, ...)
 	g_free (mesg);
 }
 
-static void
-inplace_tolower (char *c)
-{
-	int i;
-	for (i = strlen (c) - 1; i >= 0; --i)
-		c [i] = tolower (c [i]);
-}
-
 static void
 jit_done (MonoProfiler *prof, MonoMethod *method, MonoJitInfo *jinfo)
 {
@@ -149,78 +88,6 @@ appdomain_load (MonoProfiler *prof, MonoDomain *domain)
 	mono_de_domain_add (domain);
 }
 
-/* Frame state handling */
-static GPtrArray *frames;
-
-static void
-free_frame (DbgEngineStackFrame *frame)
-{
-	g_free (frame);
-}
-
-static gboolean
-collect_frames (MonoStackFrameInfo *info, MonoContext *ctx, gpointer data)
-{
-	SeqPoint sp;
-	MonoMethod *method;
-
-	//skip wrappers
-	if (info->type != FRAME_TYPE_MANAGED && info->type != FRAME_TYPE_INTERP)
-		return FALSE;
-
-	if (info->ji)
-		method = jinfo_get_method (info->ji);
-	else
-		method = info->method;
-
-	if (!method)
-		return FALSE;
-
-	PRINT_DEBUG_MSG (2, "collect_frames: Reporting method %s native_offset %d, wrapper_type: %d\n", method->name, info->native_offset, method->wrapper_type);
-
-	if (!mono_find_prev_seq_point_for_native_offset (method, info->native_offset, NULL, &sp))
-		PRINT_DEBUG_MSG (2, "collect_frames: Failed to lookup sequence point. method: %s, native_offset: %d \n", method->name, info->native_offset);
-
- 
-	StackFrame *frame = g_new0 (StackFrame, 1);
-	frame->de.ji = info->ji;
-	frame->de.domain = mono_get_root_domain ();
-	frame->de.method = method;
-	frame->de.native_offset = info->native_offset;
-
-	frame->il_offset = info->il_offset;
-	frame->interp_frame = info->interp_frame;
-	frame->frame_addr = info->frame_addr;
-	
-	g_ptr_array_add (frames, frame);
-
-	return FALSE;
-}
-
-static void
-free_frame_state (void)
-{
-	if (frames) {
-		int i;
-		for (i = 0; i < frames->len; ++i)
-			free_frame ((DbgEngineStackFrame*)g_ptr_array_index (frames, i));
-		g_ptr_array_set_size (frames, 0);
-	}	
-}
-
-static void
-compute_frames (void) {
-	if (frames) {
-		int i;
-		for (i = 0; i < frames->len; ++i)
-			free_frame ((DbgEngineStackFrame*)g_ptr_array_index (frames, i));
-		g_ptr_array_set_size (frames, 0);
-	} else {
-		frames = g_ptr_array_new ();
-	}
-
-	mono_walk_stack_with_ctx (collect_frames, NULL, MONO_UNWIND_NONE, NULL);	
-}
 static MonoContext*
 tls_get_restore_state (void *tls)
 {
@@ -247,17 +114,14 @@ begin_single_step_processing (MonoContext *ctx, gboolean from_signal)
 static void
 ss_discard_frame_context (void *the_tls)
 {
-	free_frame_state ();
+	mono_ss_discard_frame_context (mono_wasm_get_tls());
 }
 
 static void
 ss_calculate_framecount (void *tls, MonoContext *ctx, gboolean force_use_ctx, DbgEngineStackFrame ***out_frames, int *nframes)
 {
-	compute_frames ();
-	if (out_frames)
-		*out_frames = (DbgEngineStackFrame **)frames->pdata;
-	if (nframes)
-		*nframes = frames->len;
+	mono_wasm_save_thread_context();
+	mono_ss_calculate_framecount(mono_wasm_get_tls(), NULL, force_use_ctx, out_frames, nframes);
 }
 
 static gboolean
@@ -272,132 +136,8 @@ ensure_runtime_is_suspended (void)
 	return DE_ERR_NONE;
 }
 
-static int 
-get_object_id (MonoObject *obj) 
-{
-	ObjRef *ref;
-	if (!obj)
-		return 0;
-
-	ref = (ObjRef *)g_hash_table_lookup (obj_to_objref, GINT_TO_POINTER (~((gsize)obj)));
-	if (ref)
-		return ref->id;
-	ref = g_new0 (ObjRef, 1);
-	ref->id = mono_atomic_inc_i32 (&objref_id);
-	ref->handle = mono_gchandle_new_weakref_internal (obj, FALSE);
-	g_hash_table_insert (objrefs, GINT_TO_POINTER (ref->id), ref);
-	g_hash_table_insert (obj_to_objref, GINT_TO_POINTER (~((gsize)obj)), ref);
-	return ref->id;
-}
-
-
-static int
-get_this_async_id (DbgEngineStackFrame *frame)
-{
-	MonoClassField *builder_field;
-	gpointer builder;
-	MonoMethod *method;
-	MonoObject *ex;
-	ERROR_DECL (error);
-	MonoObject *obj;
-	
-	/*
-	 * FRAME points to a method in a state machine class/struct.
-	 * Call the ObjectIdForDebugger method of the associated method builder type.
-	 */
-	builder = get_async_method_builder (frame);
-	if (!builder)
-		return 0;
-
-	builder_field = mono_class_get_field_from_name_full (get_class_to_get_builder_field(frame), "<>t__builder", NULL);
-	if (!builder_field)
-		return 0;
-
-	method = get_object_id_for_debugger_method (mono_class_from_mono_type_internal (builder_field->type));
-	if (!method) {
-		return 0;
-	}
-
-	obj = mono_runtime_try_invoke_internal (method, builder, NULL, &ex, error);
-	mono_error_assert_ok (error);
-
-	return get_object_id (obj);
-}
-
-typedef struct {
-	gboolean is_ss; //do I need this?
-} BpEvents;
-
-static void*
-create_breakpoint_events (GPtrArray *ss_reqs, GPtrArray *bp_reqs, MonoJitInfo *ji, EventKind kind)
-{
-	PRINT_DEBUG_MSG (1, "ss_reqs %d bp_reqs %d\n", ss_reqs->len, bp_reqs->len);
-	if ((ss_reqs && ss_reqs->len) || (bp_reqs && bp_reqs->len)) {
-		BpEvents *evts = g_new0 (BpEvents, 1); //just a non-null value to make sure we can raise it on process_breakpoint_events
-		evts->is_ss = (ss_reqs && ss_reqs->len);
-		return evts;
-	}
-	return NULL;
-}
-
-static void
-process_breakpoint_events (void *_evts, MonoMethod *method, MonoContext *ctx, int il_offsets)
-{
-	BpEvents *evts = (BpEvents*)_evts;
-	if (evts) {
-		if (evts->is_ss)
-			mono_de_cancel_all_ss ();
-		mono_wasm_fire_bp ();
-		g_free (evts);
-	}
-}
-
-static void
-no_seq_points_found (MonoMethod *method, int offset)
-{
-	/*
-	 * This can happen in full-aot mode with assemblies AOTed without the 'soft-debug' option to save space.
-	 */
-	PRINT_DEBUG_MSG (1, "Unable to find seq points for method '%s', offset 0x%x.\n", mono_method_full_name (method, TRUE), offset);
-}
-
 #define DBG_NOT_SUSPENDED 1
 
-static int
-ss_create_init_args (SingleStepReq *ss_req, SingleStepArgs *ss_args)
-{
-	PRINT_DEBUG_MSG (1, "ss_create_init_args\n");
-	int dummy = 0;
-	ss_req->start_sp = ss_req->last_sp = &dummy;
-	compute_frames ();
-	memset (ss_args, 0, sizeof (*ss_args));
-
-	// This shouldn't happen - maybe should assert here ?
-	if (frames->len == 0) {
-		PRINT_DEBUG_MSG (1, "SINGLE STEPPING FOUND NO FRAMES");
-		return DBG_NOT_SUSPENDED;
-	}
-
-	DbgEngineStackFrame *frame = (DbgEngineStackFrame*)g_ptr_array_index (frames, 0);
-	ss_req->start_method = ss_args->method = frame->method;
-	gboolean found_sp = mono_find_prev_seq_point_for_native_offset (frame->method, frame->native_offset, &ss_args->info, &ss_args->sp);
-	if (!found_sp)
-		no_seq_points_found (frame->method, frame->native_offset);
-	g_assert (found_sp);
-
-	ss_args->frames = (DbgEngineStackFrame**)frames->pdata;
-	ss_args->nframes = frames->len;
-	//XXX do sp
-
-	return DE_ERR_NONE;
-}
-
-static void
-ss_args_destroy (SingleStepArgs *ss_args)
-{
-	//nothing to do	
-}
-
 static int
 handle_multiple_ss_requests (void) {
 	mono_de_cancel_all_ss ();
@@ -419,13 +159,13 @@ mono_wasm_debugger_init (void)
 		.ss_calculate_framecount = ss_calculate_framecount,
 		.ensure_jit = ensure_jit,
 		.ensure_runtime_is_suspended = ensure_runtime_is_suspended,
-		.get_this_async_id = get_this_async_id,
+		.get_this_async_id = mono_get_this_async_id,
 		.set_set_notification_for_wait_completion_flag = set_set_notification_for_wait_completion_flag,
 		.get_notify_debugger_of_wait_completion_method = get_notify_debugger_of_wait_completion_method,
-		.create_breakpoint_events = create_breakpoint_events,
-		.process_breakpoint_events = process_breakpoint_events,
-		.ss_create_init_args = ss_create_init_args,
-		.ss_args_destroy = ss_args_destroy,
+		.create_breakpoint_events = mono_dbg_create_breakpoint_events,
+		.process_breakpoint_events = mono_dbg_process_breakpoint_events,
+		.ss_create_init_args = mono_ss_create_init_args,
+		.ss_args_destroy = mono_ss_args_destroy,
 		.handle_multiple_ss_requests = handle_multiple_ss_requests,
 	};
 
@@ -444,11 +184,16 @@ mono_wasm_debugger_init (void)
 	mono_profiler_set_domain_loaded_callback (prof, appdomain_load);
 	mono_profiler_set_assembly_loaded_callback (prof, assembly_loaded);
 
-	obj_to_objref = g_hash_table_new (NULL, NULL);
-	objrefs = g_hash_table_new_full (NULL, NULL, NULL, mono_debugger_free_objref);
+	mini_get_dbg_callbacks ()->handle_exception = mono_debugger_agent_handle_exception;
+	mini_get_dbg_callbacks ()->user_break = mono_dbg_debugger_agent_user_break;
+
+//debugger-agent initialization	
+	DebuggerTransport trans;
+	trans.name = "buffer-wasm-communication";
+	trans.send = receive_debugger_agent_message;
 
-	mini_get_dbg_callbacks ()->handle_exception = handle_exception;
-	mini_get_dbg_callbacks ()->user_break = mono_wasm_user_break;
+	mono_debugger_agent_register_transport (&trans);
+	mono_init_debugger_agent_for_wasm (log_level);
 }
 
 MONO_API void
@@ -459,69 +204,6 @@ mono_wasm_enable_debugging (int debug_level)
 	log_level = debug_level;
 }
 
-EMSCRIPTEN_KEEPALIVE int
-mono_wasm_pause_on_exceptions (int state)
-{
-	pause_on_exc = state;
-	PRINT_DEBUG_MSG (1, "setting pause on exception: %d\n", pause_on_exc);
-	return 1;
-}
-
-EMSCRIPTEN_KEEPALIVE int
-mono_wasm_setup_single_step (int kind)
-{
-	int nmodifiers = 1;
-
-	PRINT_DEBUG_MSG (2, ">>>> mono_wasm_setup_single_step %d\n", kind);
-	EventRequest *req = (EventRequest *)g_malloc0 (sizeof (EventRequest) + (nmodifiers * sizeof (Modifier)));
-	req->id = ++event_request_id;
-	req->event_kind = EVENT_KIND_STEP;
-	// DE doesn't care about suspend_policy
-	// req->suspend_policy = SUSPEND_POLICY_ALL;
-	req->nmodifiers = nmodifiers;
-
-	StepSize size = STEP_SIZE_MIN;
-
-	//FIXME I DON'T KNOW WHAT I'M DOING!!!!! filter all the things.
-	StepFilter filter = (StepFilter)(STEP_FILTER_STATIC_CTOR | STEP_FILTER_DEBUGGER_HIDDEN | STEP_FILTER_DEBUGGER_STEP_THROUGH | STEP_FILTER_DEBUGGER_NON_USER_CODE);
-	req->modifiers [0].data.filter = filter;
-
-	StepDepth depth;
-	switch (kind) {
-	case 0: //into
-		depth = STEP_DEPTH_INTO;
-		break;
-	case 1: //out
-		depth = STEP_DEPTH_OUT;
-		break;
-	case 2: //over
-		depth = STEP_DEPTH_OVER;
-		break;
-	default:
-		g_error ("[dbg] unknown step kind %d", kind);
-	}
-
-	DbgEngineErrorCode err = mono_de_ss_create (THREAD_TO_INTERNAL (mono_thread_current ()), size, depth, filter, req);
-	if (err != DE_ERR_NONE) {
-		PRINT_DEBUG_MSG (1, "[dbg] Failed to setup single step request");
-	}
-	PRINT_DEBUG_MSG (1, "[dbg] single step is in place, now what?\n");
-	SingleStepReq *ss_req = req->info;
-	int isBPOnNativeCode = 0;
-	if (ss_req && ss_req->bps) {
-		GSList *l;
-
-		for (l = ss_req->bps; l; l = l->next) {
-			if (((MonoBreakpoint *)l->data)->method->wrapper_type != MONO_WRAPPER_RUNTIME_INVOKE)
-				isBPOnNativeCode = 1;
-		}
-	}
-	if (!isBPOnNativeCode) {
-		mono_de_cancel_all_ss ();
-	}
-	return isBPOnNativeCode;
-}
-
 static void
 assembly_loaded (MonoProfiler *prof, MonoAssembly *assembly)
 {
@@ -551,1403 +233,203 @@ assembly_loaded (MonoProfiler *prof, MonoAssembly *assembly)
 	}
 }
 
-static void
-handle_exception (MonoException *exc, MonoContext *throw_ctx, MonoContext *catch_ctx, StackFrameInfo *catch_frame)
-{
-	ERROR_DECL (error);
-	const char *default_error_message = "Failed to get exception message.";
-
-	PRINT_DEBUG_MSG (1, "handle exception - %d - %p - %p - %p\n", pause_on_exc, exc, throw_ctx, catch_ctx);
-	
-    //normal mono_runtime_try_invoke does not capture the exception and this is a temporary workaround.
-	exception_on_runtime_invoke = (MonoObject*)exc;
-
-	if (pause_on_exc == EXCEPTION_MODE_NONE)
-		return;
-	if (pause_on_exc == EXCEPTION_MODE_UNCAUGHT && catch_ctx != NULL)
-		return;
-
-	int obj_id = get_object_id ((MonoObject *)exc);
-	char *error_message = mono_string_to_utf8_checked_internal (exc->message, error);
 
-	const char *class_name = mono_class_full_name (mono_object_class (exc));
-	PRINT_DEBUG_MSG (2, "handle exception - calling mono_wasm_fire_exc(): %d - message - %s, class_name: %s\n", obj_id,  !is_ok (error) ? error_message : default_error_message, class_name);
-
-	mono_wasm_fire_exception (obj_id, !is_ok (error) ? error_message : default_error_message, class_name, !catch_ctx);
-
-	if (error_message != NULL)
-		g_free (error_message);
-	
-	PRINT_DEBUG_MSG (2, "handle exception - done\n");
+void
+mono_wasm_single_step_hit (void)
+{
+	mono_de_process_single_step (mono_wasm_get_tls(), FALSE);
 }
 
-
-EMSCRIPTEN_KEEPALIVE void
-mono_wasm_clear_all_breakpoints (void)
+void
+mono_wasm_breakpoint_hit (void)
 {
-	PRINT_DEBUG_MSG (1, "CLEAR BREAKPOINTS\n");
-	mono_de_clear_all_breakpoints ();
+	mono_de_process_breakpoint (mono_wasm_get_tls(), FALSE);
 }
 
-EMSCRIPTEN_KEEPALIVE int
-mono_wasm_set_breakpoint (const char *assembly_name, int method_token, int il_offset)
+static gboolean
+write_value_to_buffer (MdbgProtBuffer *buf, MonoTypeEnum type, const char* variableValue)
 {
-	int i;
-	ERROR_DECL (error);
-	PRINT_DEBUG_MSG (1, "SET BREAKPOINT: assembly %s method %x offset %x\n", assembly_name, method_token, il_offset);
-
-
-	//we get 'foo.dll' but mono_assembly_load expects 'foo' so we strip the last dot
-	char *lookup_name = g_strdup (assembly_name);
-	for (i = strlen (lookup_name) - 1; i >= 0; --i) {
-		if (lookup_name [i] == '.') {
-			lookup_name [i] = 0;
+	char* endptr;
+	errno = 0;
+	buffer_add_byte (buf, type);
+	switch (type) {
+		case MONO_TYPE_BOOLEAN:
+			if (!strcasecmp (variableValue, "True"))
+				buffer_add_int (buf, 1);
+			else if (!strcasecmp (variableValue, "False"))
+				buffer_add_int (buf, 0);
+			else
+				return FALSE;
+			break;
+		case MONO_TYPE_CHAR:
+			if (strlen (variableValue) > 1)
+				return FALSE;
+			buffer_add_int (buf, (variableValue [0]));
+			break;
+		case MONO_TYPE_I1: {
+			intmax_t val = strtoimax (variableValue, &endptr, 10);
+			if (errno != 0)
+				return FALSE;
+			if (val >= -128 && val <= 127)
+				buffer_add_int (buf, val);
+			else
+				return FALSE;
 			break;
 		}
+		case MONO_TYPE_U1: {
+			intmax_t val = strtoimax (variableValue, &endptr, 10);
+			if (errno != 0)
+				return FALSE;
+			if (val >= 0 && val <= 255)
+				buffer_add_int (buf, val);
+			else
+				return FALSE;
+			break;
+		}
+		case MONO_TYPE_I2: {
+			intmax_t val = strtoimax (variableValue, &endptr, 10);
+			if (errno != 0)
+				return FALSE;
+			if (val >= -32768 && val <= 32767)
+				buffer_add_int (buf, val);
+			else
+				return FALSE;
+			break;
+		}
+		case MONO_TYPE_U2: {
+			intmax_t val = strtoimax (variableValue, &endptr, 10);
+			if (errno != 0)
+				return FALSE;
+			if (val >= 0 && val <= 65535)
+				buffer_add_int (buf, val);
+			else
+				return FALSE;
+			break;
+		}
+		case MONO_TYPE_I4: {
+			intmax_t val = strtoimax (variableValue, &endptr, 10);
+			if (errno != 0)
+				return FALSE;
+			if (val >= -2147483648 && val <= 2147483647)
+				buffer_add_int (buf, val);
+			else
+				return FALSE;
+			break;
+		}
+		case MONO_TYPE_U4: {
+			intmax_t val = strtoimax (variableValue, &endptr, 10);
+			if (errno != 0)
+				return FALSE;
+			if (val >= 0 && val <= 4294967295)
+				buffer_add_int (buf, val);
+			else
+				return FALSE;
+			break;
+		}
+		case MONO_TYPE_I8: {
+			long long val = strtoll (variableValue, &endptr, 10);
+			if (errno != 0)
+				return FALSE;
+			buffer_add_long (buf, val);
+			break;
+		}
+		case MONO_TYPE_U8: {
+			long long val = strtoll (variableValue, &endptr, 10);
+			if (errno != 0)
+				return FALSE;
+			buffer_add_long (buf, val);
+			break;
+		}
+		case MONO_TYPE_R4: {
+			gfloat val = strtof (variableValue, &endptr);
+			if (errno != 0)
+				return FALSE;
+			buffer_add_int (buf, *((gint32*)(&val)));
+			break;
+		}
+		case MONO_TYPE_R8: {
+			gdouble val = strtof (variableValue, &endptr);
+			if (errno != 0)
+				return FALSE;
+			buffer_add_long (buf, *((guint64*)(&val)));
+			break;
+		}
+		default:
+			return FALSE;
 	}
-
-	//resolve the assembly
-	MonoImageOpenStatus status;
-	MonoAssemblyName* aname = mono_assembly_name_new (lookup_name);
-	MonoAssemblyByNameRequest byname_req;
-	mono_assembly_request_prepare_byname (&byname_req, MONO_ASMCTX_DEFAULT, mono_alc_get_default ());
-	MonoAssembly *assembly = mono_assembly_request_byname (aname, &byname_req, &status);
-	g_free (lookup_name);
-	if (!assembly) {
-		PRINT_DEBUG_MSG (1, "Could not resolve assembly %s\n", assembly_name);
-		return -1;
-	}
-
-	mono_assembly_name_free_internal (aname);
-
-	MonoMethod *method = mono_get_method_checked (assembly->image, MONO_TOKEN_METHOD_DEF | method_token, NULL, NULL, error);
-	if (!method) {
-		//FIXME don't swallow the error
-		PRINT_DEBUG_MSG (1, "Could not find method due to %s\n", mono_error_get_message (error));
-		mono_error_cleanup (error);
-		return -1;
-	}
-
-	//FIXME right now none of the EventRequest fields are used by debugger-engine
-	EventRequest *req = g_new0 (EventRequest, 1);
-	req->id = ++event_request_id;
-	req->event_kind = EVENT_KIND_BREAKPOINT;
-	//DE doesn't care about suspend_policy
-	// req->suspend_policy = SUSPEND_POLICY_ALL;
-	req->nmodifiers = 0; //funny thing,
-
-	// BreakPointRequest *req = breakpoint_request_new (assembly, method, il_offset);
-	MonoBreakpoint *bp = mono_de_set_breakpoint (method, il_offset, req, error);
-
-	if (!bp) {
-		PRINT_DEBUG_MSG (1, "Could not set breakpoint to %s\n", mono_error_get_message (error));
-		mono_error_cleanup (error);
-		return 0;
-	}
-
-	PRINT_DEBUG_MSG (1, "NEW BP %p has id %d\n", req, req->id);
-	return req->id;
-}
-
-EMSCRIPTEN_KEEPALIVE int
-mono_wasm_remove_breakpoint (int bp_id)
-{
-	MonoBreakpoint *bp = mono_de_get_breakpoint_by_id (bp_id);
-	if (!bp)
-		return 0;
-
-	mono_de_clear_breakpoint (bp);
-	return 1;
+	return TRUE;
 }
 
-void
-mono_wasm_single_step_hit (void)
+EMSCRIPTEN_KEEPALIVE void 
+mono_wasm_set_is_debugger_attached (gboolean is_attached)
 {
-	mono_de_process_single_step (NULL, FALSE);
+	mono_set_is_debugger_attached (is_attached);
+	if (is_attached && has_pending_lazy_loaded_assemblies)
+	{
+		GPtrArray *assemblies = mono_alc_get_all_loaded_assemblies ();
+		for (int i = 0; i < assemblies->len; ++i) {
+			MonoAssembly *ass = (MonoAssembly*)g_ptr_array_index (assemblies, i);
+			assembly_loaded (NULL, ass);
+		}
+		g_ptr_array_free (assemblies, TRUE);
+		has_pending_lazy_loaded_assemblies = FALSE;
+	}
 }
 
-void
-mono_wasm_breakpoint_hit (void)
+EMSCRIPTEN_KEEPALIVE gboolean 
+mono_wasm_send_dbg_command_with_parms (int id, MdbgProtCommandSet command_set, int command, guint8* data, unsigned int size, int valtype, char* newvalue)
 {
-	mono_de_process_breakpoint (NULL, FALSE);
-	// mono_wasm_fire_bp ();
+	MdbgProtBuffer bufWithParms;
+	buffer_init (&bufWithParms, 128);
+	m_dbgprot_buffer_add_data (&bufWithParms, data, size);
+	if (!write_value_to_buffer(&bufWithParms, valtype, newvalue)) {
+		EM_ASM ({
+			MONO.mono_wasm_add_dbg_command_received ($0, $1, $2, $3);
+		}, 0, id, 0, 0);
+		return TRUE;
+	}
+	mono_wasm_send_dbg_command(id, command_set, command, bufWithParms.buf, m_dbgprot_buffer_len(&bufWithParms));
+	buffer_free (&bufWithParms);
+	return TRUE;
 }
 
-void
-mono_wasm_user_break (void)
+EMSCRIPTEN_KEEPALIVE gboolean 
+mono_wasm_send_dbg_command (int id, MdbgProtCommandSet command_set, int command, guint8* data, unsigned int size)
 {
-	mono_wasm_fire_bp ();
+	ss_calculate_framecount (NULL, NULL, TRUE, NULL, NULL);
+	MdbgProtBuffer buf;
+	buffer_init (&buf, 128);
+	gboolean no_reply;
+	MdbgProtErrorCode error = 0;
+	if (command_set == MDBGPROT_CMD_SET_VM && command == MDBGPROT_CMD_VM_INVOKE_METHOD ) 
+	{
+		DebuggerTlsData* tls = mono_wasm_get_tls();
+		InvokeData invoke_data;
+		memset(&invoke_data, 0, sizeof(InvokeData));
+		invoke_data.endp = data + size;
+		error = mono_do_invoke_method(tls, &buf, &invoke_data, data, &data);
+	}
+	else
+		error = mono_process_dbg_packet(id, command_set, command, &no_reply, data, data + size, &buf);
+	EM_ASM ({
+		MONO.mono_wasm_add_dbg_command_received ($0, $1, $2, $3);
+	}, error == MDBGPROT_ERR_NONE, id, buf.buf, buf.p-buf.buf);
+	
+	buffer_free (&buf);
+	return TRUE;
 }
 
-EMSCRIPTEN_KEEPALIVE int
-mono_wasm_current_bp_id (void)
+static gboolean 
+receive_debugger_agent_message (void *data, int len)
 {
-	PRINT_DEBUG_MSG (2, "COMPUTING breakpoint ID\n");
-	//FIXME handle compiled case
-
-	/* Interpreter */
-	MonoLMF *lmf = mono_get_lmf ();
-
-	g_assert (((guint64)lmf->previous_lmf) & 2);
-	MonoLMFExt *ext = (MonoLMFExt*)lmf;
-
-	g_assert (ext->kind == MONO_LMFEXT_INTERP_EXIT || ext->kind == MONO_LMFEXT_INTERP_EXIT_WITH_CTX);
-	MonoInterpFrameHandle *frame = (MonoInterpFrameHandle*)ext->interp_exit_data;
-	MonoJitInfo *ji = mini_get_interp_callbacks ()->frame_get_jit_info (frame);
-	guint8 *ip = (guint8*)mini_get_interp_callbacks ()->frame_get_ip (frame);
-
-	g_assert (ji && !ji->is_trampoline);
-	MonoMethod *method = jinfo_get_method (ji);
-
-	/* Compute the native offset of the breakpoint from the ip */
-	guint32 native_offset = ip - (guint8*)ji->code_start;
-
-	MonoSeqPointInfo *info = NULL;
-	SeqPoint sp;
-	gboolean found_sp = mono_find_prev_seq_point_for_native_offset (method, native_offset, &info, &sp);
-	if (!found_sp)
-		PRINT_DEBUG_MSG (1, "Could not find SP\n");
-
-
-	GPtrArray *bp_reqs = g_ptr_array_new ();
-	mono_de_collect_breakpoints_by_sp (&sp, ji, NULL, bp_reqs);
-
-	if (bp_reqs->len == 0) {
-		PRINT_DEBUG_MSG (1, "BP NOT FOUND for method %s JI %p il_offset %d\n", method->name, ji, sp.il_offset);
-		return -1;
-	}
-
-	if (bp_reqs->len > 1)
-		PRINT_DEBUG_MSG (1, "Multiple breakpoints (%d) at the same location, returning the first one.", bp_reqs->len);
-
-	EventRequest *evt = (EventRequest *)g_ptr_array_index (bp_reqs, 0);
-	g_ptr_array_free (bp_reqs, TRUE);
-
-	PRINT_DEBUG_MSG (1, "Found BP %p with id %d\n", evt, evt->id);
-	return evt->id;
-}
-
-static MonoObject*
-get_object_from_id (int objectId)
-{
-	ObjRef *ref = (ObjRef *)g_hash_table_lookup (objrefs, GINT_TO_POINTER (objectId));
-	if (!ref) {
-		PRINT_DEBUG_MSG (2, "get_object_from_id !ref: %d\n", objectId);
-		return NULL;
-	}
-
-	MonoObject *obj = mono_gchandle_get_target_internal (ref->handle);
-	if (!obj)
-		PRINT_DEBUG_MSG (2, "get_object_from_id !obj: %d\n", objectId);
-
-	return obj;
-}
-
-static gboolean
-list_frames (MonoStackFrameInfo *info, MonoContext *ctx, gpointer data)
-{
-	SeqPoint sp;
-	MonoMethod *method;
-	char *method_full_name;
-
-	int* frame_id_p = (int*)data;
-	(*frame_id_p)++;
-
-	//skip wrappers
-	if (info->type != FRAME_TYPE_MANAGED && info->type != FRAME_TYPE_INTERP)
-		return FALSE;
-
-	if (info->ji)
-		method = jinfo_get_method (info->ji);
-	else
-		method = info->method;
-
-	if (!method || method->wrapper_type != MONO_WRAPPER_NONE)
-		return FALSE;
-
-	PRINT_DEBUG_MSG (2, "list_frames: Reporting method %s native_offset %d, wrapper_type: %d\n", method->name, info->native_offset, method->wrapper_type);
-
-	if (!mono_find_prev_seq_point_for_native_offset (method, info->native_offset, NULL, &sp))
-		PRINT_DEBUG_MSG (2, "list_frames: Failed to lookup sequence point. method: %s, native_offset: %d\n", method->name, info->native_offset);
-
-	method_full_name = mono_method_full_name (method, FALSE);
-	while (method->is_inflated)
-		method = ((MonoMethodInflated*)method)->declaring;
-
-	char *assembly_name = g_strdup (m_class_get_image (method->klass)->module_name);
-	inplace_tolower (assembly_name);
-
-	PRINT_DEBUG_MSG (2, "adding off %d token %d assembly name %s\n", sp.il_offset, mono_metadata_token_index (method->token), assembly_name);
-	mono_wasm_add_frame (sp.il_offset, mono_metadata_token_index (method->token), *frame_id_p, assembly_name, method_full_name);
-
-	g_free (assembly_name);
-
-	return FALSE;
-}
-
-EMSCRIPTEN_KEEPALIVE void
-mono_wasm_enum_frames (void)
-{
-	int frame_id = -1;
-	mono_walk_stack_with_ctx (list_frames, NULL, MONO_UNWIND_NONE, &frame_id);
-}
-
-static char*
-invoke_to_string (const char *class_name, MonoClass *klass, gpointer addr)
-{
-	MonoObject *exc;
-	MonoString *mstr;
-	char *ret_str;
-	ERROR_DECL (error);
-	MonoObject *obj;
-
-	// TODO: this is for a specific use case right now,
-	//       (invoke ToString() get a preview/description for *some* types)
-	//       and we don't want to report errors for that.
-	if (m_class_is_valuetype (klass)) {
-		MonoMethod *method;
-
-		MONO_STATIC_POINTER_INIT (MonoMethod, to_string)
-			to_string = mono_class_get_method_from_name_checked (mono_get_object_class (), "ToString", 0, METHOD_ATTRIBUTE_VIRTUAL | METHOD_ATTRIBUTE_PUBLIC, error);
-			mono_error_assert_ok (error);
-		MONO_STATIC_POINTER_INIT_END (MonoMethod, to_string)
-
-		method = mono_class_get_virtual_method (klass, to_string, error);
-		if (!method)
-			return NULL;
-
-		MonoString *mstr = (MonoString*) mono_runtime_try_invoke_internal (method, addr , NULL, &exc, error);
-		if (exc || !is_ok (error)) {
-			PRINT_DEBUG_MSG (1, "Failed to invoke ToString for %s\n", class_name);
-			return NULL;
-		}
-
-		return mono_string_to_utf8_checked_internal (mstr, error);
-	}
-
-	obj = *(MonoObject**)addr;
-	if (!obj)
-		return NULL;
-
-	mstr = mono_object_try_to_string (obj, &exc, error);
-	if (exc || !is_ok (error))
-		return NULL;
-
-	ret_str = mono_string_to_utf8_checked_internal (mstr, error);
-	if (!is_ok (error))
-		return NULL;
-
-	return ret_str;
-}
-
-static char*
-get_to_string_description (const char* class_name, MonoClass *klass, gpointer addr)
-{
-	if (!class_name || !klass || !addr)
-		return NULL;
-
-	if (strcmp (class_name, "System.Guid") == 0)
-		return mono_guid_to_string (addr);
-
-	for (int i = 0; i < G_N_ELEMENTS (to_string_as_descr_names); i ++) {
-		if (strcmp (to_string_as_descr_names [i], class_name) == 0) {
-			return invoke_to_string (class_name, klass, addr);
-		}
-	}
-
-	return NULL;
-}
-
-typedef struct {
-	int cur_frame;
-	int target_frame;
-	int len;
-	int *pos;
-	gboolean found;
-} FrameDescData;
-
-
-typedef struct {
-	int cur_frame;
-	int target_frame;
-	int pos;
-	const char* new_value;
-	gboolean found;
-	gboolean error;
-} SetVariableValueData;
-
-/*
- * this returns a string formatted like
- *
- *  <ret_type>:[<comma separated list of arg types>]:<method name>
- *
- *  .. which is consumed by `mono_wasm_add_func_var`. It is used for
- *  generating this for the delegate, and it's target.
- */
-static char*
-mono_method_to_desc_for_js (MonoMethod *method, gboolean include_namespace)
-{
-	MonoMethodSignature *sig = mono_method_signature_internal (method);
-	char *ret_desc = mono_type_full_name (sig->ret);
-	char *args_desc = mono_signature_get_desc (sig, include_namespace);
-
-	char *sig_desc = g_strdup_printf ("%s:%s:%s", ret_desc, args_desc, method->name);
-
-	g_free (ret_desc);
-	g_free (args_desc);
-	return sig_desc;
-}
-
-static guint64
-read_enum_value (const char *mem, int type)
-{
-	switch (type) {
-	case MONO_TYPE_BOOLEAN:
-	case MONO_TYPE_U1:
-		return *(guint8*)mem;
-	case MONO_TYPE_I1:
-		return *(gint8*)mem;
-	case MONO_TYPE_CHAR:
-	case MONO_TYPE_U2:
-		return read16 (mem);
-	case MONO_TYPE_I2:
-		return (gint16) read16 (mem);
-	case MONO_TYPE_U4:
-	case MONO_TYPE_R4:
-		return read32 (mem);
-	case MONO_TYPE_I4:
-		return (gint32) read32 (mem);
-	case MONO_TYPE_U8:
-	case MONO_TYPE_I8:
-	case MONO_TYPE_R8:
-		return read64 (mem);
-	case MONO_TYPE_U:
-	case MONO_TYPE_I:
-#if SIZEOF_REGISTER == 8
-		return read64 (mem);
-#else
-		return read32 (mem);
-#endif
-	default:
-		g_assert_not_reached ();
-	}
-	return 0;
-}
-
-static gboolean
-nullable_try_get_value (guint8 *nullable, MonoClass *klass, gpointer* out_value)
-{
-	mono_class_setup_fields (klass);
-	g_assert (m_class_is_fields_inited (klass));
-
-	*out_value = NULL;
-	MonoClassField *klass_fields = m_class_get_fields (klass);
-	gpointer addr_for_has_value = mono_vtype_get_field_addr (nullable, &klass_fields[0]);
-	if (0 == *(guint8*)addr_for_has_value)
-		return FALSE;
-
-	*out_value = mono_vtype_get_field_addr (nullable, &klass_fields[1]);
-	return TRUE;
-}
-
-static gboolean
-describe_value(MonoType * type, gpointer addr, int gpflags)
-{
-	ERROR_DECL (error);
-	switch (type->type) {
-		case MONO_TYPE_BOOLEAN:
-			mono_wasm_add_typed_value ("bool", NULL, *(gint8*)addr);
-			break;
-		case MONO_TYPE_I1:
-			mono_wasm_add_typed_value ("number", NULL, *(gint8*)addr);
-			break;
-		case MONO_TYPE_U1:
-			mono_wasm_add_typed_value ("number", NULL, *(guint8*)addr);
-			break;
-		case MONO_TYPE_CHAR:
-			mono_wasm_add_typed_value ("char", NULL, *(guint16*)addr);
-			break;
-		case MONO_TYPE_U2:
-			mono_wasm_add_typed_value ("number", NULL, *(guint16*)addr);
-			break;
-		case MONO_TYPE_I2:
-			mono_wasm_add_typed_value ("number", NULL, *(gint16*)addr);
-			break;
-		case MONO_TYPE_I4:
-		case MONO_TYPE_I:
-			mono_wasm_add_typed_value ("number", NULL, *(gint32*)addr);
-			break;
-		case MONO_TYPE_U4:
-		case MONO_TYPE_U:
-			mono_wasm_add_typed_value ("number", NULL, *(guint32*)addr);
-			break;
-		case MONO_TYPE_I8:
-			mono_wasm_add_typed_value ("number", NULL, *(gint64*)addr);
-			break;
-		case MONO_TYPE_U8:
-			mono_wasm_add_typed_value ("number", NULL, *(guint64*)addr);
-			break;
-		case MONO_TYPE_R4:
-			mono_wasm_add_typed_value ("number", NULL, *(float*)addr);
-			break;
-		case MONO_TYPE_R8:
-			mono_wasm_add_typed_value ("number", NULL, *(double*)addr);
-			break;
-		case MONO_TYPE_PTR:
-		case MONO_TYPE_FNPTR: {
-			char *class_name = mono_type_full_name (type);
-			const void *val = *(const void **)addr;
-			char *descr = g_strdup_printf ("(%s) %p", class_name, val);
-
-			EM_ASM ({
-				MONO.mono_wasm_add_typed_value ('pointer', $0, { ptr_addr: $1, klass_addr: $2 });
-			}, descr, val ? addr : 0, val ? mono_class_from_mono_type_internal (type) : 0);
-
-			g_free (descr);
-			g_free (class_name);
-			break;
-		}
-
-		case MONO_TYPE_STRING: {
-			MonoString *str_obj = *(MonoString **)addr;
-			if (!str_obj) {
-				mono_wasm_add_typed_value ("string", NULL, 0);
-			} else {
-				char *str = mono_string_to_utf8_checked_internal (str_obj, error);
-				mono_error_assert_ok (error); /* FIXME report error */
-				mono_wasm_add_typed_value ("string", str, 0);
-				g_free (str);
-			}
-			break;
-		}
-
-		case MONO_TYPE_OBJECT: {
-			MonoObject *obj = *(MonoObject**)addr;
-			if (!obj) {
-				mono_wasm_add_obj_var ("object", NULL, 0);
-				break;
-			}
-			MonoClass *klass = obj->vtable->klass;
-			if (!klass) {
-				// boxed null
-				mono_wasm_add_obj_var ("object", NULL, 0);
-				break;
-			}
-
-			type = m_class_get_byval_arg (klass);
-			if (type->type == MONO_TYPE_OBJECT) {
-				mono_wasm_add_obj_var ("object", "object", get_object_id (obj));
-				break;
-			}
-
-			// Boxed valuetype
-			if (m_class_is_valuetype (klass))
-				addr = mono_object_unbox_internal (obj);
-
-			return describe_value (type, addr, gpflags);
-		}
-
-		case MONO_TYPE_GENERICINST: {
-			MonoClass *klass = mono_class_from_mono_type_internal (type);
-			if (mono_class_is_nullable (klass)) {
-				MonoType *targ = type->data.generic_class->context.class_inst->type_argv [0];
-
-				gpointer nullable_value = NULL;
-				if (nullable_try_get_value (addr, klass, &nullable_value)) {
-					return describe_value (targ, nullable_value, gpflags);
-				} else {
-					char* class_name = mono_type_full_name (type);
-					mono_wasm_add_obj_var (class_name, NULL, 0);
-					g_free (class_name);
-					break;
-				}
-			}
-
-			if (mono_type_generic_inst_is_valuetype (type))
-				goto handle_vtype;
-			/*
-			 * else fallthrough
-			 */
-		}
-
-		case MONO_TYPE_SZARRAY:
-		case MONO_TYPE_ARRAY:
-		case MONO_TYPE_CLASS: {
-			MonoObject *obj = *(MonoObject**)addr;
-			if (!obj) {
-				char *class_name = mono_type_full_name (type);
-				mono_wasm_add_func_var (class_name, NULL, 0);
-				g_free (class_name);
-				return TRUE;
-			}
-			MonoClass *klass = type->data.klass;
-
-			if (m_class_is_valuetype (mono_object_class (obj))) {
-				addr = mono_object_unbox_internal (obj);
-				type = m_class_get_byval_arg (mono_object_class (obj));
-				goto handle_vtype;
-			}
-
-			char *class_name = mono_type_full_name (type);
-			int obj_id = get_object_id (obj);
-
-			if (type-> type == MONO_TYPE_ARRAY || type->type == MONO_TYPE_SZARRAY) {
-				MonoArray *array = (MonoArray *)obj;
-				EM_ASM ({
-					MONO.mono_wasm_add_typed_value ('array', $0, { objectId: $1, length: $2 });
-				}, class_name, obj_id, mono_array_length_internal (array));
-			} else if (m_class_is_delegate (klass) || (type->type == MONO_TYPE_GENERICINST && m_class_is_delegate (type->data.generic_class->container_class))) {
-				MonoMethod *method;
-
-				if (type->type == MONO_TYPE_GENERICINST)
-					klass = type->data.generic_class->container_class;
-
-				method = mono_get_delegate_invoke_internal (klass);
-				if (!method) {
-					mono_wasm_add_func_var (class_name, NULL, -1);
-				} else {
-					MonoMethod *tm = ((MonoDelegate *)obj)->method;
-					char *tm_desc = NULL;
-					if (tm)
-						tm_desc = mono_method_to_desc_for_js (tm, FALSE);
-
-					mono_wasm_add_func_var (class_name, tm_desc, obj_id);
-					g_free (tm_desc);
-				}
-			} else {
-				char *to_string_val = get_to_string_description (class_name, klass, addr);
-				mono_wasm_add_obj_var (class_name, to_string_val, obj_id);
-				g_free (to_string_val);
-			}
-			g_free (class_name);
-			break;
-		}
-
-		handle_vtype:
-		case MONO_TYPE_VALUETYPE: {
-			g_assert (addr);
-			MonoClass *klass = mono_class_from_mono_type_internal (type);
-			char *class_name = mono_type_full_name (type);
-
-			if (m_class_is_enumtype (klass)) {
-				MonoClassField *field;
-				gpointer iter = NULL;
-				const char *p;
-				MonoTypeEnum def_type;
-				guint64 field_value;
-				guint64 value__ = 0xDEAD;
-				GString *enum_members = g_string_new ("");
-				int base_type = mono_class_enum_basetype_internal (klass)->type;
-
-				while ((field = mono_class_get_fields_internal (klass, &iter))) {
-					if (strcmp ("value__", mono_field_get_name (field)) == 0) {
-						value__ = read_enum_value (mono_vtype_get_field_addr (addr, field), base_type);
-						continue;
-					}
-
-					if (!(field->type->attrs & FIELD_ATTRIBUTE_STATIC))
-						continue;
-					if (mono_field_is_deleted (field))
-						continue;
-
-					p = mono_class_get_field_default_value (field, &def_type);
-					/* this is to correctly increment `p` in the blob */
-					/* len = */ mono_metadata_decode_blob_size (p, &p);
-
-					field_value = read_enum_value (p, base_type);
-
-					g_string_append_printf (enum_members, ",%s:%llu", mono_field_get_name (field), field_value);
-				}
-
-				mono_wasm_add_enum_var (class_name, enum_members->str, value__);
-				g_string_free (enum_members, TRUE);
-			} else {
-				char *to_string_val = get_to_string_description (class_name, klass, addr);
-
-				if (gpflags & GPFLAG_EXPAND_VALUETYPES) {
-					int32_t size = mono_class_value_size (klass, NULL);
-					void *value_buf = g_malloc0 (size);
-					mono_value_copy_internal (value_buf, addr, klass);
-
-					EM_ASM ({
-						MONO.mono_wasm_add_typed_value ($0, $1, { toString: $2, value_addr: $3, value_size: $4, klass: $5 });
-					}, "begin_vt", class_name, to_string_val, value_buf, size, klass);
-
-					g_free (value_buf);
-
-					// FIXME: isAsyncLocalThis
-					describe_object_properties_for_klass (addr, klass, FALSE, gpflags);
-					mono_wasm_add_typed_value ("end_vt", NULL, 0);
-				} else {
-					EM_ASM ({
-						MONO.mono_wasm_add_typed_value ($0, $1, { toString: $2 });
-					}, "unexpanded_vt", class_name, to_string_val);
-				}
-				g_free (to_string_val);
-			}
-			g_free (class_name);
-			break;
-		}
-		default: {
-			char *type_name = mono_type_full_name (type);
-			char *msg = g_strdup_printf("can't handle type %s [%p, %x]", type_name, type, type->type);
-			mono_wasm_add_typed_value ("string", msg, 0);
-			g_free (msg);
-			g_free (type_name);
-		}
-	}
-	return TRUE;
-}
-
-static gboolean
-are_getters_allowed (const char *class_name)
-{
-	for (int i = 0; i < G_N_ELEMENTS (all_getters_allowed_class_names); i ++) {
-		if (strcmp (class_name, all_getters_allowed_class_names [i]) == 0)
-			return TRUE;
-	}
-
-	return FALSE;
-}
-
-static gboolean
-invoke_and_describe_getter_value (MonoObject *obj, MonoProperty *p)
-{
-	ERROR_DECL (error);
-	MonoObject *res;
-	MonoObject *exc;
-
-	MonoMethodSignature *sig = mono_method_signature_internal (p->get);
-
-	res = mono_runtime_try_invoke_internal (p->get, obj, NULL, &exc, error);
-	if (!is_ok (error) && exc == NULL)
-		exc = (MonoObject *) mono_error_convert_to_exception (error);
-	if (exc)
-	{
-		const char *class_name = mono_class_full_name (mono_object_class (exc));
-		ERROR_DECL (local_error);
-		char *str = mono_string_to_utf8_checked_internal (((MonoException*)exc)->message, local_error);
-		mono_error_assert_ok (local_error); /* FIXME report error */
-		char *msg = g_strdup_printf("%s: %s", class_name, str);
-		mono_wasm_add_typed_value ("string", msg, 0);
-		g_free (msg);
-		return TRUE;
-	}
-	else if (!res || !m_class_is_valuetype (mono_object_class (res)))
-		return describe_value (sig->ret, &res, GPFLAG_EXPAND_VALUETYPES);
-	else
-		return describe_value (sig->ret, mono_object_unbox_internal (res), GPFLAG_EXPAND_VALUETYPES);
-}
-
-static MonoObject* mono_runtime_try_invoke_internal (MonoMethod *method, void *obj, void **params, MonoObject **exc, MonoError* error)
-{
-	exception_on_runtime_invoke = NULL;
-	MonoObject* res = mono_runtime_try_invoke (method, obj, params, exc, error);
-	if (exception_on_runtime_invoke != NULL)
-		*exc = exception_on_runtime_invoke;
-	exception_on_runtime_invoke = NULL;
-	return res;
-}
-
-static void
-describe_object_properties_for_klass (void *obj, MonoClass *klass, gboolean isAsyncLocalThis, int gpflags)
-{
-	MonoClassField *f;
-	MonoProperty *p;
-	MonoMethodSignature *sig;
-	gboolean is_valuetype;
-	int pnum;
-	char *klass_name;
-	gboolean auto_invoke_getters;
-	gboolean is_own;
-	gboolean only_backing_fields;
-
-	g_assert (klass);
-	MonoClass *start_klass = klass;
-
-	only_backing_fields = gpflags & GPFLAG_ACCESSORS_ONLY;
-	is_valuetype = m_class_is_valuetype(klass);
-	if (is_valuetype)
-		gpflags |= GPFLAG_EXPAND_VALUETYPES;
-
-handle_parent:
-	is_own = (start_klass == klass);
-	klass_name = mono_class_full_name (klass);
-	gpointer iter = NULL;
-	while (obj && (f = mono_class_get_fields_internal (klass, &iter))) {
-		if (isAsyncLocalThis && f->name[0] == '<' && f->name[1] == '>') {
-			if (g_str_has_suffix (f->name, "__this")) {
-				mono_wasm_add_properties_var ("this", f->offset);
-				gpointer field_value = (guint8*)obj + f->offset;
-
-				describe_value (f->type, field_value, gpflags);
-			}
-
-			continue;
-		}
-		if (f->type->attrs & FIELD_ATTRIBUTE_STATIC)
-			continue;
-		if (mono_field_is_deleted (f))
-			continue;
-
-		if (only_backing_fields && !g_str_has_suffix(f->name, "k__BackingField"))
-			continue;
-
-		EM_ASM ({
-			MONO.mono_wasm_add_properties_var ($0, { field_offset: $1, is_own: $2, attr: $3, owner_class: $4 });
-		}, f->name, f->offset, is_own, f->type->attrs, klass_name);
-
-		gpointer field_addr;
-		if (is_valuetype)
-			field_addr = mono_vtype_get_field_addr (obj, f);
-		else
-			field_addr = (guint8*)obj + f->offset;
-
-		describe_value (f->type, field_addr, gpflags);
-	}
-
-	auto_invoke_getters = are_getters_allowed (klass_name);
-	iter = NULL;
-	pnum = 0;
-	while ((p = mono_class_get_properties (klass, &iter))) {
-		if (p->get->name) { //if get doesn't have name means that doesn't have a getter implemented and we don't want to show value, like VS debug
-			if (isAsyncLocalThis && (p->name[0] != '<' || (p->name[0] == '<' &&  p->name[1] == '>')))
-				continue;
-
-			sig = mono_method_signature_internal (p->get);
-			if (sig->param_count != 0) {
-				// getters with params are not shown
-				continue;
-			}
-
-			if (p->get->flags & METHOD_ATTRIBUTE_STATIC)
-				continue;
-
-			EM_ASM ({
-				MONO.mono_wasm_add_properties_var ($0, { field_offset: $1, is_own: $2, attr: $3, owner_class: $4 });
-			}, p->name, pnum, is_own, p->attrs, klass_name);
-
-			gboolean vt_self_type_getter = is_valuetype && mono_class_from_mono_type_internal (sig->ret) == klass;
-			if (auto_invoke_getters && !vt_self_type_getter) {
-				invoke_and_describe_getter_value (obj, p);
-			} else {
-				// not allowed to call the getter here
-				char *ret_class_name = mono_class_full_name (mono_class_from_mono_type_internal (sig->ret));
-
-				mono_wasm_add_typed_value ("getter", ret_class_name, -1);
-
-				g_free (ret_class_name);
-				continue;
-			}
-		}
-		pnum ++;
-	}
-
-	g_free (klass_name);
-
-	// ownProperties
-	// Note: ownProperties should mean that we return members of the klass itself,
-	// but we are going to ignore that here, because otherwise vscode/chrome don't
-	// seem to ask for inherited fields at all.
-	// if (!is_valuetype && !(gpflags & GPFLAG_OWN_PROPERTIES) && (klass = m_class_get_parent (klass)))
-	if (!is_valuetype && (klass = m_class_get_parent (klass)))
-		goto handle_parent;
-}
-
-/*
- * We return a `Target` property only for now.
- * In future, we could add a `MethodInfo` too.
- */
-static gboolean
-describe_delegate_properties (MonoObject *obj)
-{
-	MonoClass *klass = mono_object_class(obj);
-	if (!m_class_is_delegate (klass))
-		return FALSE;
-
-	// Target, like in VS - what is this field supposed to be, anyway??
-	MonoMethod *tm = ((MonoDelegate *)obj)->method;
-	char * sig_desc = mono_method_to_desc_for_js (tm, FALSE);
-
-	mono_wasm_add_properties_var ("Target", -1);
-	mono_wasm_add_func_var (NULL, sig_desc, -1);
-
-	g_free (sig_desc);
-	return TRUE;
-}
-
-static gboolean
-describe_object_properties (guint64 objectId, gboolean isAsyncLocalThis, int gpflags)
-{
-	PRINT_DEBUG_MSG (2, "describe_object_properties %llu, gpflags: %d\n", objectId, gpflags);
-
-	MonoObject *obj = get_object_from_id (objectId);
-	if (!obj)
-		return FALSE;
-
-	if (m_class_is_delegate (mono_object_class (obj))) {
-		// delegates get the same id format as regular objects
-		describe_delegate_properties (obj);
-	} else {
-		describe_object_properties_for_klass (obj, obj->vtable->klass, isAsyncLocalThis, gpflags);
-	}
-
-	return TRUE;
-}
-
-static gboolean
-invoke_getter (void *obj_or_value, MonoClass *klass, const char *name)
-{
-	if (!obj_or_value || !klass || !name) {
-		PRINT_DEBUG_MSG (2, "invoke_getter: none of the arguments can be null");
-		return FALSE;
-	}
-
-	gpointer iter;
-handle_parent:
-	iter = NULL;
-	MonoProperty *p;
-	while ((p = mono_class_get_properties (klass, &iter))) {
-		//if get doesn't have name means that doesn't have a getter implemented and we don't want to show value, like VS debug
-		if (!p->get->name || strcasecmp (p->name, name) != 0)
-			continue;
-
-		invoke_and_describe_getter_value (obj_or_value, p);
-		return TRUE;
-	}
-
-	if ((klass = m_class_get_parent(klass)))
-		goto handle_parent;
-
-	return FALSE;
-}
-
-static gboolean
-describe_array_values (guint64 objectId, int startIdx, int count, int gpflags)
-{
-	if (count == 0)
-		return TRUE;
-
-	int esize;
-	gpointer elem;
-	MonoArray *arr = (MonoArray*) get_object_from_id (objectId);
-	if (!arr)
-		return FALSE;
-
-	MonoClass *klass = mono_object_class (arr);
-	MonoTypeEnum type = m_class_get_byval_arg (klass)->type;
-	if (type != MONO_TYPE_SZARRAY && type != MONO_TYPE_ARRAY) {
-		PRINT_DEBUG_MSG (1, "describe_array_values: object is not an array. type: 0x%x\n", type);
-		return FALSE;
-	}
-
-	int len = arr->max_length;
-	if (len == 0 && startIdx == 0 && count <= 0) {
-		// Nothing to do
-		return TRUE;
-	}
-
-	if (startIdx < 0 || (len > 0 && startIdx >= len)) {
-		PRINT_DEBUG_MSG (1, "describe_array_values: invalid startIdx (%d) for array of length %d\n", startIdx, len);
-		return FALSE;
-	}
-
-	if (count > 0 && (startIdx + count) > len) {
-		PRINT_DEBUG_MSG (1, "describe_array_values: invalid count (%d) for startIdx: %d, and array of length %d\n", count, startIdx, len);
-		return FALSE;
-	}
-
-	esize = mono_array_element_size (klass);
-	int endIdx = count < 0 ? len : startIdx + count;
-
-	for (int i = startIdx; i < endIdx; i ++) {
-		mono_wasm_add_array_item(i);
-		elem = (gpointer*)((char*)arr->vector + (i * esize));
-		describe_value (m_class_get_byval_arg (m_class_get_element_class (klass)), elem, gpflags);
-	}
-	return TRUE;
-}
-
-static void
-describe_async_method_locals (InterpFrame *frame, MonoMethod *method)
-{
-	//Async methods are special in the way that local variables can be lifted to generated class fields
-	gpointer addr = NULL;
-	if (mono_debug_lookup_method_async_debug_info (method)) {
-		addr = mini_get_interp_callbacks ()->frame_get_this (frame);
-		MonoObject *obj = *(MonoObject**)addr;
-		int objId = get_object_id (obj);
-		mono_wasm_set_is_async_method (objId);
-		describe_object_properties (objId, TRUE, GPFLAG_NONE);
-	}
-}
-
-static void
-describe_non_async_this (InterpFrame *frame, MonoMethod *method)
-{
-	gpointer addr = NULL;
-	if (mono_debug_lookup_method_async_debug_info (method))
-		return;
-
-	if (mono_method_signature_internal (method)->hasthis) {
-		addr = mini_get_interp_callbacks ()->frame_get_this (frame);
-		MonoObject *obj = *(MonoObject**)addr;
-		MonoClass *klass = method->klass;
-		MonoType *type = m_class_get_byval_arg (method->klass);
-
-		mono_wasm_add_properties_var ("this", -1);
-
-		if (m_class_is_valuetype (klass)) {
-			describe_value (type, obj, GPFLAG_EXPAND_VALUETYPES);
-		} else {
-			// this is an object, and we can retrieve the valuetypes in it later
-			// through the object id
-			describe_value (type, addr, GPFLAG_NONE);
-		}
-	}
-}
-
-static gboolean
-describe_variable (InterpFrame *frame, MonoMethod *method, MonoMethodHeader *header, int pos, int gpflags)
-{
-	MonoType *type = NULL;
-	gpointer addr = NULL;
-	if (pos < 0) {
-		MonoMethodSignature *sig = mono_method_signature_internal (method);
-		pos = -pos - 1;
-
-		if (pos >= sig->param_count) {
-			PRINT_DEBUG_MSG(1, "BUG: describe_variable, trying to access param indexed %d, but the method (%s) has only %d params\n", pos, method->name, sig->param_count);
-			return FALSE;
-		}
-
-		type = sig->params [pos];
-		addr = mini_get_interp_callbacks ()->frame_get_arg (frame, pos);
-	} else {
-		if (pos >= header->num_locals) {
-			PRINT_DEBUG_MSG(1, "BUG: describe_variable, trying to access local indexed %d, but the method (%s) has only %d locals\n", pos, method->name, header->num_locals);
-			return FALSE;
-		}
-
-		type = header->locals [pos];
-		addr = mini_get_interp_callbacks ()->frame_get_local (frame, pos);
-	}
-
-	PRINT_DEBUG_MSG (2, "adding val %p type 0x%x %s\n", addr, type->type, mono_type_full_name (type));
-
-	return describe_value(type, addr, gpflags);
-}
-
-static gboolean
-decode_value (MonoType *t, guint8 *addr, const char* variableValue)
-{
-	char* endptr;
-	errno = 0;
-	switch (t->type) {
-		case MONO_TYPE_BOOLEAN:
-			if (!strcasecmp (variableValue, "True"))
-				*(guint8*)addr = 1;
-			else if (!strcasecmp (variableValue, "False"))
-				*(guint8*)addr = 0;
-			else 
-				return FALSE;
-			break;
-		case MONO_TYPE_CHAR:
-			if (strlen (variableValue) > 1)
-				return FALSE;
-			*(gunichar2*)addr = variableValue [0];
-			break;
-		case MONO_TYPE_I1: {
-			intmax_t val = strtoimax (variableValue, &endptr, 10);
-			if (errno != 0)
-				return FALSE;
-			if (val >= -128 && val <= 127)
-				*(gint8*)addr = val;
-			else 
-				return FALSE;
-			break;
-		}
-		case MONO_TYPE_U1: {
-			intmax_t val = strtoimax (variableValue, &endptr, 10);
-			if (errno != 0)
-				return FALSE;
-			if (val >= 0 && val <= 255)
-				*(guint8*)addr = val;
-			else 
-				return FALSE;
-			break;
-		}
-		case MONO_TYPE_I2: {
-			intmax_t val = strtoimax (variableValue, &endptr, 10);
-			if (errno != 0)
-				return FALSE;
-			if (val >= -32768 && val <= 32767)
-				*(gint16*)addr = val;
-			else 
-				return FALSE;
-			break;
-		}
-		case MONO_TYPE_U2: {
-			intmax_t val = strtoimax (variableValue, &endptr, 10);
-			if (errno != 0)
-				return FALSE;
-			if (val >= 0 && val <= 65535)
-				*(guint16*)addr = val;
-			else 
-				return FALSE;
-			break;
-		}
-		case MONO_TYPE_I4: {
-			intmax_t val = strtoimax (variableValue, &endptr, 10);
-			if (errno != 0)
-				return FALSE;
-			if (val >= -2147483648 && val <= 2147483647)
-				*(gint32*)addr = val;
-			else 
-				return FALSE;
-			break;
-		}
-		case MONO_TYPE_U4: {
-			intmax_t val = strtoimax (variableValue, &endptr, 10);
-			if (errno != 0)
-				return FALSE;
-			if (val >= 0 && val <= 4294967295)				
-				*(guint32*)addr = val;
-			else 
-				return FALSE;
-			break;
-		}
-		case MONO_TYPE_I8: {
-			long long val = strtoll (variableValue, &endptr, 10);
-			if (errno != 0)
-				return FALSE;
-			*(gint64*)addr = val;
-			break;
-		}
-		case MONO_TYPE_U8: {
-			long long val = strtoll (variableValue, &endptr, 10);
-			if (errno != 0)
-				return FALSE;
-			*(guint64*)addr = val;
-			break;
-		}
-		case MONO_TYPE_R4: {
-			gfloat val = strtof (variableValue, &endptr);
-			if (errno != 0)
-				return FALSE;
-			*(gfloat*)addr = val;
-			break;
-		}
-		case MONO_TYPE_R8: {
-			gdouble val = strtof (variableValue, &endptr);
-			if (errno != 0)
-				return FALSE;
-			*(gdouble*)addr = val;
-			break;
-		}
-		default:
-			return FALSE;
-	}
-	return TRUE;
-}
-
-static gboolean
-set_variable_value_on_frame (MonoStackFrameInfo *info, MonoContext *ctx, gpointer ud)
-{
-	ERROR_DECL (error);
-	SetVariableValueData *data = (SetVariableValueData*)ud;
-	gboolean is_arg = FALSE;
-	MonoType *t = NULL;
-	guint8 *val_buf = NULL;
-
-	++data->cur_frame;
-
-	//skip wrappers
-	if (info->type != FRAME_TYPE_MANAGED && info->type != FRAME_TYPE_INTERP) {
-		return FALSE;
-	}
-
-	if (data->cur_frame != data->target_frame)
-		return FALSE;
-
-	data->found = TRUE;
-
-	InterpFrame *frame = (InterpFrame*)info->interp_frame;
-	MonoMethod *method = frame->imethod->method;
-	MonoMethodSignature *sig = mono_method_signature_internal (method);
-	MonoMethodHeader *header = mono_method_get_header_checked (method, error);
-	
-	if (!header) {
-		mono_error_cleanup(error);
-		data->error = TRUE;
-		return TRUE;
-	}
-
-	if (!sig)
-		goto exit_with_error;
-
-	int pos = data->pos;
-	
-	if (pos < 0) {
-		pos = - pos - 1;
-		if (pos >= sig->param_count) 
-			goto exit_with_error;
-		is_arg = TRUE;
-		t = sig->params [pos];
-	}
-	else {
-		if (pos >= header->num_locals)
-			goto exit_with_error;
-		t = header->locals [pos];
-	}
-	
-	guint8 *addr;
-	if (is_arg)
-		addr = (guint8*)mini_get_interp_callbacks ()->frame_get_arg (frame, pos);
-	else
-		addr = (guint8*)mini_get_interp_callbacks ()->frame_get_local (frame, pos);
-	
-	val_buf = (guint8 *)g_alloca (mono_class_instance_size (mono_class_from_mono_type_internal (t)));
-	
-	if (!decode_value(t, val_buf, data->new_value))
-		goto exit_with_error;
-
-	DbgEngineErrorCode errorCode = mono_de_set_interp_var (t, addr, val_buf);
-	if (errorCode != ERR_NONE) {
-		goto exit_with_error;
-	}
-
-	mono_metadata_free_mh (header);
-	return TRUE;
-
-exit_with_error:	
-	data->error = TRUE;
-	mono_metadata_free_mh (header);
-	return TRUE;
-}
-
-static gboolean
-describe_variables_on_frame (MonoStackFrameInfo *info, MonoContext *ctx, gpointer ud)
-{
-	ERROR_DECL (error);
-	FrameDescData *data = (FrameDescData*)ud;
-
-	++data->cur_frame;
-
-	//skip wrappers
-	if (info->type != FRAME_TYPE_MANAGED && info->type != FRAME_TYPE_INTERP) {
-		return FALSE;
-	}
-
-	if (data->cur_frame != data->target_frame)
-		return FALSE;
-
-	data->found = TRUE;
-
-	InterpFrame *frame = (InterpFrame*)info->interp_frame;
-	g_assert (frame);
-	MonoMethod *method = frame->imethod->method;
-	g_assert (method);
-
-	MonoMethodHeader *header = mono_method_get_header_checked (method, error);
-	mono_error_assert_ok (error); /* FIXME report error */
-
-	for (int i = 0; i < data->len; i++)
-	{
-		if (!describe_variable (frame, method, header, data->pos[i], GPFLAG_EXPAND_VALUETYPES))
-			mono_wasm_add_typed_value("symbol", "<unreadable value>", 0);
-	}
-
-	describe_async_method_locals (frame, method);
-	describe_non_async_this (frame, method);
-
-	mono_metadata_free_mh (header);
-	return TRUE;
-}
-
-EMSCRIPTEN_KEEPALIVE gboolean
-mono_wasm_set_variable_on_frame (int scope, int index, const char* name, const char* value)
-{
-	if (scope < 0)
-		return FALSE;
-
-	SetVariableValueData data;
-	data.target_frame = scope;
-	data.cur_frame = -1;
-	data.pos = index;
-	data.found = FALSE;
-	data.new_value = value;
-	data.error = FALSE;
-
-	mono_walk_stack_with_ctx (set_variable_value_on_frame, NULL, MONO_UNWIND_NONE, &data);
-	return !data.error;
-}
-
-EMSCRIPTEN_KEEPALIVE gboolean
-mono_wasm_get_deref_ptr_value (void *value_addr, MonoClass *klass)
-{
-	MonoType *type = m_class_get_byval_arg (klass);
-	if (type->type != MONO_TYPE_PTR && type->type != MONO_TYPE_FNPTR) {
-		PRINT_DEBUG_MSG (2, "BUG: mono_wasm_get_deref_ptr_value: Expected to get a ptr type, but got 0x%x\n", type->type);
-		return FALSE;
-	}
-
-	mono_wasm_add_properties_var ("deref", -1);
-	return describe_value (type->data.type, value_addr, GPFLAG_EXPAND_VALUETYPES);
-}
-
-//FIXME this doesn't support getting the return value pseudo-var
-EMSCRIPTEN_KEEPALIVE gboolean
-mono_wasm_get_local_vars (int scope, int* pos, int len)
-{
-	if (scope < 0)
-		return FALSE;
-
-	FrameDescData data;
-	data.target_frame = scope;
-	data.cur_frame = -1;
-	data.len = len;
-	data.pos = pos;
-	data.found = FALSE;
-
-	mono_walk_stack_with_ctx (describe_variables_on_frame, NULL, MONO_UNWIND_NONE, &data);
-
-	return data.found;
-}
-
-EMSCRIPTEN_KEEPALIVE gboolean
-mono_wasm_get_object_properties (int object_id, int gpflags)
-{
-	PRINT_DEBUG_MSG (2, "getting properties of object %d, gpflags: %d\n", object_id, gpflags);
-
-	return describe_object_properties (object_id, FALSE, gpflags);
-}
-
-EMSCRIPTEN_KEEPALIVE gboolean
-mono_wasm_get_array_values (int object_id, int start_idx, int count, int gpflags)
-{
-	PRINT_DEBUG_MSG (2, "getting array values %d, startIdx: %d, count: %d, gpflags: 0x%x\n", object_id, start_idx, count, gpflags);
-
-	return describe_array_values (object_id, start_idx, count, gpflags);
-}
-
-EMSCRIPTEN_KEEPALIVE gboolean
-mono_wasm_invoke_getter_on_object (int object_id, const char* name)
-{
-	MonoObject *obj = get_object_from_id (object_id);
-	if (!obj)
-		return FALSE;
-
-	return invoke_getter (obj, mono_object_class (obj), name);
-}
-
-EMSCRIPTEN_KEEPALIVE gboolean
-mono_wasm_set_value_on_object (int object_id, const char* name, const char* value)
-{
-	PRINT_DEBUG_MSG (1,  "mono_wasm_set_value_on_object %d, name: %s, value: %s\n", object_id, name, value);
-	MonoObject *obj = get_object_from_id (object_id);
-	
-	if (!obj || !name) {
-		PRINT_DEBUG_MSG (2, "mono_wasm_set_value_on_object: none of the arguments can be null");
-		return FALSE;
-	}
-	MonoClass* klass = mono_object_class (obj);
-
-	gpointer iter;
-handle_parent:
-	iter = NULL;
-	MonoClassField *f;
-	while ((f = mono_class_get_fields_internal (klass, &iter))) {
-		if (!f->name || strcasecmp (f->name, name) != 0)
-			continue;
-		guint8 *val_buf = (guint8 *)g_alloca (mono_class_instance_size (mono_class_from_mono_type_internal (f->type)));
-	
-		if (!decode_value(f->type, val_buf, value)) {
-			return FALSE;
-		}		
-		DbgEngineErrorCode errorCode = mono_de_set_interp_var (f->type, (guint8*)obj + f->offset, val_buf);
-		if (errorCode != ERR_NONE) {
-			return FALSE;
-		}
-		return TRUE;
-	}
-
-	iter = NULL;
-	MonoProperty *p;
-	MonoObject *exc;
-	ERROR_DECL (error);
-	while ((p = mono_class_get_properties (klass, &iter))) {
-		if (!p->name || strcasecmp (p->name, name) != 0)
-			continue;
-		if (!p->set)
-			break;
-		MonoType *type = mono_method_signature_internal (p->set)->params [0];
-		guint8 *val_buf = (guint8 *)g_alloca (mono_class_instance_size (mono_class_from_mono_type_internal (type)));
-	
-		if (!decode_value(type, val_buf, value)) {
-			return FALSE;
-		}					
-		mono_runtime_try_invoke (p->set, obj, (void **)&val_buf, &exc, error);
-		if (!is_ok (error) && exc == NULL)
-			exc = (MonoObject*) mono_error_convert_to_exception (error);
-		if (exc) {
-			char *error_message = mono_string_to_utf8_checked_internal (((MonoException *)exc)->message, error);
-			if (is_ok (error)) {
-				PRINT_DEBUG_MSG (2, "mono_wasm_set_value_on_object exception: %s\n", error_message);
-				g_free (error_message);
-				mono_error_cleanup (error);			
-			}
-			else {
-				PRINT_DEBUG_MSG (2, "mono_wasm_set_value_on_object exception\n");
-			}
-			return FALSE;
-		}
-		return TRUE;
-	}
-
-	if ((klass = m_class_get_parent(klass)))
-		goto handle_parent;
+	EM_ASM ({
+		MONO.mono_wasm_add_dbg_command_received (1, -1, $0, $1);
+	}, data, len);
+	mono_wasm_save_thread_context();
+	mono_wasm_fire_debugger_agent_message ();	
 	return FALSE;
 }
 
-EMSCRIPTEN_KEEPALIVE gboolean
-mono_wasm_invoke_getter_on_value (void *value, MonoClass *klass, const char *name)
-{
-	PRINT_DEBUG_MSG (2, "mono_wasm_invoke_getter_on_value: v: %p klass: %p, name: %s\n", value, klass, name);
-	if (!klass || !value)
-		return FALSE;
-
-	if (!m_class_is_valuetype (klass)) {
-		PRINT_DEBUG_MSG (2, "mono_wasm_invoke_getter_on_value: klass is not a valuetype. name: %s\n", mono_class_full_name (klass));
-		return FALSE;
-	}
-
-	return invoke_getter (value, klass, name);
-}
-
-EMSCRIPTEN_KEEPALIVE void 
-mono_wasm_set_is_debugger_attached (gboolean is_attached)
-{
-	mono_set_is_debugger_attached (is_attached);
-	if (is_attached && has_pending_lazy_loaded_assemblies)
-	{
-		GPtrArray *assemblies = mono_alc_get_all_loaded_assemblies ();
-		for (int i = 0; i < assemblies->len; ++i) {
-			MonoAssembly *ass = (MonoAssembly*)g_ptr_array_index (assemblies, i);
-			assembly_loaded (NULL, ass);
-		}
-		g_ptr_array_free (assemblies, TRUE);
-		has_pending_lazy_loaded_assemblies = FALSE;
-	}
-}
-
-// Functions required by debugger-state-machine.
-gsize
-mono_debugger_tls_thread_id (DebuggerTlsData *debuggerTlsData)
-{
-	return 1;
-}
-
 #else // HOST_WASM
 
 void
diff --git a/src/mono/mono/mini/mini-x86.c b/src/mono/mono/mini/mini-x86.c
index 5143ea8dc4a135..5c43d7ae72796f 100644
--- a/src/mono/mono/mini/mini-x86.c
+++ b/src/mono/mono/mini/mini-x86.c
@@ -4745,18 +4745,16 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb)
 			x86_movd_reg_xreg (code, ins->dreg, ins->sreg1);
 			break;
 		case OP_EXTRACT_I1:
-		case OP_EXTRACT_U1:
 			x86_movd_reg_xreg (code, ins->dreg, ins->sreg1);
 			if (ins->inst_c0)
 				x86_shift_reg_imm (code, X86_SHR, ins->dreg, ins->inst_c0 * 8);
-			x86_widen_reg (code, ins->dreg, ins->dreg, ins->opcode == OP_EXTRACT_I1, FALSE);
+			x86_widen_reg (code, ins->dreg, ins->dreg, ins->inst_c1 == MONO_TYPE_I1, FALSE);
 			break;
 		case OP_EXTRACT_I2:
-		case OP_EXTRACT_U2:
 			x86_movd_reg_xreg (code, ins->dreg, ins->sreg1);
 			if (ins->inst_c0)
 				x86_shift_reg_imm (code, X86_SHR, ins->dreg, 16);
-			x86_widen_reg (code, ins->dreg, ins->dreg, ins->opcode == OP_EXTRACT_I2, TRUE);
+			x86_widen_reg (code, ins->dreg, ins->dreg, ins->inst_c1 == MONO_TYPE_I2, TRUE);
 			break;
 		case OP_EXTRACT_R8:
 			if (ins->inst_c0)
diff --git a/src/mono/mono/mini/mini.c b/src/mono/mono/mini/mini.c
index b0be59a617fa10..b54bb2cb2a9be5 100644
--- a/src/mono/mono/mini/mini.c
+++ b/src/mono/mono/mini/mini.c
@@ -2917,21 +2917,28 @@ remove_empty_finally_pass (MonoCompile *cfg)
 					empty = FALSE;
 					break;
 				}
-				MONO_BB_FOR_EACH_INS (bb, ins) {
-					// FIXME: OP_MOVE has no side effect, but it can still modify state
-					if (!(ins->opcode == OP_START_HANDLER || ins->opcode == OP_ENDFINALLY || MONO_INS_HAS_NO_SIDE_EFFECT (ins))) {
-						empty = FALSE;
-						break;
-					}
+				if (bb->flags & BB_HAS_SIDE_EFFECTS) {
+					empty = FALSE;
+ 					break;
 				}
-				if (!empty)
-					break;
 				if (bb->out_count == 0)
 					break;
 				if (mono_bb_last_inst (bb, 0)->opcode == OP_ENDFINALLY)
 					break;
 				bb = bb->out_bb [0];
 			}
+			if (empty) {
+				/*
+				 * Avoid doing this in nested clauses, because it might mess up the EH code generated by
+				 * the llvm backend.
+				 */
+				for (int j = 0; j < cfg->header->num_clauses; ++j) {
+					MonoExceptionClause *clause2 = &cfg->header->clauses [j];
+
+					if (i != j && MONO_OFFSET_IN_CLAUSE (clause2, clause->handler_offset))
+						empty = FALSE;
+				}
+			}
 			if (empty) {
 				bb->flags &= ~BB_EXCEPTION_HANDLER;
 				NULLIFY_INS (first);
@@ -3206,6 +3213,12 @@ mini_method_compile (MonoMethod *method, guint32 opts, JitFlags flags, int parts
 
 	if (cfg->compile_llvm)
 		cfg->explicit_null_checks = TRUE;
+	if (cfg->explicit_null_checks && method->wrapper_type == MONO_WRAPPER_OTHER &&
+		(mono_marshal_get_wrapper_info (method)->subtype == WRAPPER_SUBTYPE_GSHAREDVT_IN_SIG ||
+		 mono_marshal_get_wrapper_info (method)->subtype == WRAPPER_SUBTYPE_GSHAREDVT_OUT_SIG)) {
+		/* These wrappers contain loads/stores which can't fail */
+		cfg->explicit_null_checks = FALSE;
+	}
 
 	/*
 	if (!mono_debug_count ())
@@ -3583,8 +3596,8 @@ mini_method_compile (MonoMethod *method, guint32 opts, JitFlags flags, int parts
 		mono_cfg_dump_ir (cfg, "if_conversion");
 	}
 
-	// See the FIXME in the function
-	//remove_empty_finally_pass (cfg);
+	// This still causes failures
+	remove_empty_finally_pass (cfg);
 
 	mono_threads_safepoint ();
 
diff --git a/src/mono/mono/mini/mini.h b/src/mono/mono/mini/mini.h
index d95c4b2cee8444..8d55a61d1239ee 100644
--- a/src/mono/mono/mini/mini.h
+++ b/src/mono/mono/mini/mini.h
@@ -140,6 +140,7 @@ typedef struct SeqPointInfo SeqPointInfo;
 #endif
 
 #define MONO_TYPE_IS_PRIMITIVE(t) ((!(t)->byref && ((((t)->type >= MONO_TYPE_BOOLEAN && (t)->type <= MONO_TYPE_R8) || ((t)->type >= MONO_TYPE_I && (t)->type <= MONO_TYPE_U)))))
+#define MONO_TYPE_IS_VECTOR_PRIMITIVE(t) ((!(t)->byref && ((((t)->type >= MONO_TYPE_I1 && (t)->type <= MONO_TYPE_R8) || ((t)->type >= MONO_TYPE_I && (t)->type <= MONO_TYPE_U)))))
 //XXX this ignores if t is byref
 #define MONO_TYPE_IS_PRIMITIVE_SCALAR(t) ((((((t)->type >= MONO_TYPE_BOOLEAN && (t)->type <= MONO_TYPE_U8) || ((t)->type >= MONO_TYPE_I && (t)->type <= MONO_TYPE_U)))))
 
@@ -629,7 +630,9 @@ enum {
 	BB_EXCEPTION_UNSAFE     = 1 << 3,
 	BB_EXCEPTION_HANDLER    = 1 << 4,
 	/* for Native Client, mark the blocks that can be jumped to indirectly */
-	BB_INDIRECT_JUMP_TARGET = 1 << 5 
+	BB_INDIRECT_JUMP_TARGET = 1 << 5 ,
+	/* Contains code with some side effects */
+	BB_HAS_SIDE_EFFECTS = 1 << 6,
 };
 
 typedef struct MonoMemcpyArgs {
@@ -881,6 +884,7 @@ enum {
 	MONO_INST_GC_CALLSITE = 128,
 	/* On comparisons, mark the branch following the condition as likely to be taken */
 	MONO_INST_LIKELY = 128,
+	MONO_INST_NONULLCHECK   = 128,
 };
 
 #define inst_c0 data.op[0].const_val
@@ -1132,6 +1136,9 @@ typedef struct
 {
 	gpointer addr;
 	gpointer arg;
+	MonoMethod *method;
+	/* InterpMethod* */
+	gpointer interp_method;
 } MonoFtnDesc;
 
 typedef enum {
@@ -2294,7 +2301,7 @@ void              mini_emit_memory_copy_bytes (MonoCompile *cfg, MonoInst *dest,
 void              mini_emit_memory_init_bytes (MonoCompile *cfg, MonoInst *dest, MonoInst *value, MonoInst *size, int ins_flag);
 void              mini_emit_memory_copy (MonoCompile *cfg, MonoInst *dest, MonoInst *src, MonoClass *klass, gboolean native, int ins_flag);
 MonoInst*         mini_emit_array_store (MonoCompile *cfg, MonoClass *klass, MonoInst **sp, gboolean safety_checks);
-MonoInst*         mini_emit_inst_for_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args);
+MonoInst*         mini_emit_inst_for_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args, gboolean *ins_type_initialized);
 MonoInst*         mini_emit_inst_for_ctor (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args);
 MonoInst*         mini_emit_inst_for_field_load (MonoCompile *cfg, MonoClassField *field);
 MonoInst*         mini_handle_enum_has_flag (MonoCompile *cfg, MonoClass *klass, MonoInst *enum_this, int enum_val_reg, MonoInst *enum_flag);
@@ -2931,6 +2938,9 @@ mono_arch_load_function (MonoJitICallId jit_icall_id);
 MonoGenericContext
 mono_get_generic_context_from_stack_frame (MonoJitInfo *ji, gpointer generic_info);
 
+gpointer
+mono_get_generic_info_from_stack_frame (MonoJitInfo *ji, MonoContext *ctx);
+
 MonoMemoryManager* mini_get_default_mem_manager (void);
 
 #endif /* __MONO_MINI_H__ */
diff --git a/src/mono/mono/mini/simd-intrinsics.c b/src/mono/mono/mini/simd-intrinsics.c
index d511ee4663e8cc..b65d8d887cee8f 100644
--- a/src/mono/mono/mini/simd-intrinsics.c
+++ b/src/mono/mono/mini/simd-intrinsics.c
@@ -388,6 +388,10 @@ typedef MonoInst * (* EmitIntrinsicFn) (
 	const SimdIntrinsic *info, int id, MonoTypeEnum arg0_type,
 	gboolean is_64bit);
 
+static const IntrinGroup unsupported_intrin_group [] = {
+	{ "", 0, unsupported, sizeof (unsupported) },
+};
+
 static MonoInst *
 emit_hardware_intrinsics (
 	MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig,
@@ -395,9 +399,8 @@ emit_hardware_intrinsics (
 	EmitIntrinsicFn custom_emit)
 {
 	MonoClass *klass = cmethod->klass;
-	const IntrinGroup *intrin_group = NULL;
+	const IntrinGroup *intrin_group = unsupported_intrin_group;
 	gboolean is_64bit = FALSE;
-	int id = -1;
 	int groups_size = groups_size_bytes / sizeof (groups [0]);
 	for (int i = 0; i < groups_size; ++i) {
 		const IntrinGroup *group = &groups [i];
@@ -407,31 +410,30 @@ emit_hardware_intrinsics (
 		}
 	}
 
-	const SimdIntrinsic *info = NULL;
-	MonoInst *ins = NULL;
 	gboolean supported = FALSE;
 	MonoTypeEnum arg0_type = fsig->param_count > 0 ? get_underlying_type (fsig->params [0]) : MONO_TYPE_VOID;
+	int id = -1;
 	uint16_t op = 0;
 	uint16_t c0 = 0;
-	if (intrin_group) {
-		const SimdIntrinsic *intrinsics = intrin_group->intrinsics;
-		int intrinsics_size = intrin_group->intrinsics_size;
-		MonoCPUFeatures feature = intrin_group->feature;
-
+	const SimdIntrinsic *intrinsics = intrin_group->intrinsics;
+	int intrinsics_size = intrin_group->intrinsics_size;
+	MonoCPUFeatures feature = intrin_group->feature;
+	const SimdIntrinsic *info = lookup_intrins_info ((SimdIntrinsic *) intrinsics, intrinsics_size, cmethod);
+	{
+		if (!info)
+			goto support_probe_complete;
+		id = info->id;
 		// Hardware intrinsics are LLVM-only.
 		if (!COMPILE_LLVM (cfg) && !intrin_group->jit_supported)
 			goto support_probe_complete;
 
-		info = lookup_intrins_info ((SimdIntrinsic *) intrinsics, intrinsics_size, cmethod);
-		if (!info)
-			goto support_probe_complete;
-
-		if (feature)
-			supported = ((mini_get_cpu_features (cfg) & feature) != 0) && (intrin_group->intrinsics != unsupported);
+		if (intrin_group->intrinsics == unsupported)
+			supported = FALSE;
+		else if (feature)
+			supported = (mini_get_cpu_features (cfg) & feature) != 0;
 		else
 			supported = TRUE;
 
-		id = info->id;
 
 		op = info->default_op;
 		c0 = info->default_instc0;
@@ -457,16 +459,16 @@ emit_hardware_intrinsics (
 			op = info->floating_op;
 			c0 = info->floating_instc0;
 		}
-
 	}
 support_probe_complete:
 	if (id == SN_get_IsSupported) {
+		MonoInst *ins = NULL;
 		EMIT_NEW_ICONST (cfg, ins, supported ? 1 : 0);
 		return ins;
 	}
 	if (!supported) {
 		// Can't emit non-supported llvm intrinsics
-		if (!intrin_group || cfg->method != cmethod) {
+		if (cfg->method != cmethod) {
 			// Keep the original call so we end up in the intrinsic method
 			return NULL;
 		} else {
@@ -497,6 +499,46 @@ emit_vector_create_elementwise (
 
 #if defined(TARGET_AMD64) || defined(TARGET_ARM64)
 
+static int
+type_to_xinsert_op (MonoTypeEnum type)
+{
+	switch (type) {
+	case MONO_TYPE_I1: case MONO_TYPE_U1: return OP_XINSERT_I1;
+	case MONO_TYPE_I2: case MONO_TYPE_U2: return OP_XINSERT_I2;
+	case MONO_TYPE_I4: case MONO_TYPE_U4: return OP_XINSERT_I4;
+	case MONO_TYPE_I8: case MONO_TYPE_U8: return OP_XINSERT_I8;
+	case MONO_TYPE_R4: return OP_XINSERT_R4;
+	case MONO_TYPE_R8: return OP_XINSERT_R8;
+	case MONO_TYPE_I: case MONO_TYPE_U:
+#if TARGET_SIZEOF_VOID_P == 8
+		return OP_XINSERT_I8;
+#else
+		return OP_XINSERT_I4;
+#endif
+	default: g_assert_not_reached ();
+	}
+}
+
+static int
+type_to_xextract_op (MonoTypeEnum type)
+{
+	switch (type) {
+	case MONO_TYPE_I1: case MONO_TYPE_U1: return OP_XEXTRACT_I1;
+	case MONO_TYPE_I2: case MONO_TYPE_U2: return OP_XEXTRACT_I2;
+	case MONO_TYPE_I4: case MONO_TYPE_U4: return OP_XEXTRACT_I4;
+	case MONO_TYPE_I8: case MONO_TYPE_U8: return OP_XEXTRACT_I8;
+	case MONO_TYPE_R4: return OP_XEXTRACT_R4;
+	case MONO_TYPE_R8: return OP_XEXTRACT_R8;
+	case MONO_TYPE_I: case MONO_TYPE_U:
+#if TARGET_SIZEOF_VOID_P == 8
+		return OP_XEXTRACT_I8;
+#else
+		return OP_XEXTRACT_I4;
+#endif
+	default: g_assert_not_reached ();
+	}
+}
+
 static guint16 sri_vector_methods [] = {
 	SN_AsByte,
 	SN_AsDouble,
@@ -518,8 +560,7 @@ is_elementwise_create_overload (MonoMethodSignature *fsig, MonoType *ret_type)
 	uint16_t param_count = fsig->param_count;
 	if (param_count < 1) return FALSE;
 	MonoType *type = fsig->params [0];
-	gboolean is_vector_primitive = MONO_TYPE_IS_PRIMITIVE (type) && ((type->type >= MONO_TYPE_I1 && type->type <= MONO_TYPE_R8) || type->type == MONO_TYPE_I || type->type <= MONO_TYPE_U);
-	if (!is_vector_primitive) return FALSE;
+	if (!MONO_TYPE_IS_VECTOR_PRIMITIVE (type)) return FALSE;
 	if (!mono_metadata_type_equal (ret_type, type)) return FALSE;
 	for (uint16_t i = 1; i < param_count; ++i)
 		if (!mono_metadata_type_equal (type, fsig->params [i])) return FALSE;
@@ -560,8 +601,12 @@ emit_sri_vector (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsi
 	case SN_AsSingle:
 	case SN_AsUInt16:
 	case SN_AsUInt32:
-	case SN_AsUInt64:
+	case SN_AsUInt64: {
+		MonoType *etype = get_vector_t_elem_type (fsig->params [0]);
+		if (!MONO_TYPE_IS_VECTOR_PRIMITIVE (etype))
+			return NULL;
 		return emit_simd_ins (cfg, klass, OP_XCAST, args [0]->dreg, -1);
+	}
 	case SN_Create: {
 		MonoType *etype = get_vector_t_elem_type (fsig->ret);
 		if (fsig->param_count == 1 && mono_metadata_type_equal (fsig->params [0], etype))
@@ -756,48 +801,11 @@ emit_sys_numerics_vector_t (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSig
 			return NULL;
 		MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, args [1]->dreg, len);
 		MONO_EMIT_NEW_COND_EXC (cfg, GE_UN, "IndexOutOfRangeException");
-		int opcode = -1;
-		int dreg;
-		gboolean is64 = FALSE;
-		switch (etype->type) {
-		case MONO_TYPE_I8:
-		case MONO_TYPE_U8:
-			opcode = OP_XEXTRACT_I64;
-			is64 = TRUE;
-			dreg = alloc_lreg (cfg);
-			break;
-		case MONO_TYPE_R8:
-			opcode = OP_XEXTRACT_R8;
-			dreg = alloc_freg (cfg);
-			break;
-		case MONO_TYPE_R4:
-			g_assert (cfg->r4fp);
-			opcode = OP_XEXTRACT_R4;
-			dreg = alloc_freg (cfg);
-			break;
-		case MONO_TYPE_I:
-		case MONO_TYPE_U:
-#if TARGET_SIZEOF_VOID_P == 8
-			opcode = OP_XEXTRACT_I64;
-			is64 = TRUE;
-			dreg = alloc_lreg (cfg);
-#else
-			opcode = OP_XEXTRACT_I32;
-			dreg = alloc_ireg (cfg);
-#endif
-			break;
-		default:
-			opcode = OP_XEXTRACT_I32;
-			dreg = alloc_ireg (cfg);
-			break;
-		}
-		MONO_INST_NEW (cfg, ins, opcode);
-		ins->dreg = dreg;
-		ins->sreg1 = load_simd_vreg (cfg, cmethod, args [0], NULL);
-		ins->sreg2 = args [1]->dreg;
-		ins->inst_c0 = etype->type;
-		mini_type_to_eval_stack_type (cfg, etype, ins);
-		MONO_ADD_INS (cfg->cbb, ins);
+		MonoTypeEnum ty = etype->type;
+		int opcode = type_to_xextract_op (ty);
+		int src1 = load_simd_vreg (cfg, cmethod, args [0], NULL);
+		MonoInst *ins = emit_simd_ins (cfg, klass, opcode, src1, args [1]->dreg);
+		ins->inst_c1 = ty;
 		return ins;
 	}
 	case SN_ctor:
@@ -1006,39 +1014,8 @@ emit_sys_numerics_vector_t (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSig
 }
 #endif // TARGET_AMD64
 
-static MonoInst*
-emit_invalid_operation (MonoCompile *cfg, const char* message)
-{
-	mono_cfg_set_exception (cfg, MONO_EXCEPTION_MONO_ERROR);
-	mono_error_set_generic_error (cfg->error, "System", "InvalidOperationException", "%s", message);
-	return NULL;
-}
-
 #ifdef TARGET_ARM64
 
-static int
-type_to_extract_var_op (MonoTypeEnum type)
-{
-	switch (type) {
-	case MONO_TYPE_I1: return OP_EXTRACT_VAR_U1;
-	case MONO_TYPE_U1: return OP_EXTRACT_VAR_I1;
-	case MONO_TYPE_I2: return OP_EXTRACT_VAR_U2;
-	case MONO_TYPE_U2: return OP_EXTRACT_VAR_I2;
-	case MONO_TYPE_I4: case MONO_TYPE_U4: return OP_EXTRACT_VAR_I4;
-	case MONO_TYPE_I8: case MONO_TYPE_U8: return OP_EXTRACT_VAR_I8;
-	case MONO_TYPE_R4: return OP_EXTRACT_VAR_R4;
-	case MONO_TYPE_R8: return OP_EXTRACT_VAR_R8;
-	case MONO_TYPE_I:
-	case MONO_TYPE_U:
-#if TARGET_SIZEOF_VOID_P == 8
-		return OP_EXTRACT_VAR_I8;
-#else
-		return OP_EXTRACT_VAR_I4;
-#endif
-	default: g_assert_not_reached ();
-	}
-}
-
 static SimdIntrinsic armbase_methods [] = {
 	{SN_LeadingSignCount},
 	{SN_LeadingZeroCount},
@@ -1575,7 +1552,8 @@ emit_arm64_intrinsics (
 			switch (id) {
 			case SN_DuplicateSelectedScalarToVector128:
 			case SN_DuplicateSelectedScalarToVector64: {
-				MonoInst *ins = emit_simd_ins (cfg, ret_klass, type_to_extract_var_op (rtype->type), args [0]->dreg, args [1]->dreg);
+				MonoInst *ins = emit_simd_ins (cfg, ret_klass, type_to_xextract_op (rtype->type), args [0]->dreg, args [1]->dreg);
+				ins->inst_c1 = arg0_type;
 				scalar_src_reg = ins->dreg;
 				break;
 			}
@@ -1583,7 +1561,7 @@ emit_arm64_intrinsics (
 			return emit_simd_ins (cfg, ret_klass, type_to_expand_op (rtype), scalar_src_reg, -1);
 		}
 		case SN_Extract: {
-			int extract_op = type_to_extract_var_op (arg0_type);
+			int extract_op = type_to_xextract_op (arg0_type);
 			MonoInst *ins = emit_simd_ins (cfg, klass, extract_op, args [0]->dreg, args [1]->dreg);
 			ins->inst_c1 = arg0_type;
 			return ins;
@@ -1591,13 +1569,12 @@ emit_arm64_intrinsics (
 		case SN_InsertSelectedScalar:
 		case SN_InsertScalar:
 		case SN_Insert: {
+			MonoClass *ret_klass = mono_class_from_mono_type_internal (fsig->ret);
 			int insert_op = 0;
 			int extract_op = 0;
 			switch (arg0_type) {
-			case MONO_TYPE_I1: insert_op = OP_XINSERT_I1; extract_op = OP_EXTRACT_U1; break;
-			case MONO_TYPE_U1: insert_op = OP_XINSERT_I1; extract_op = OP_EXTRACT_I1; break;
-			case MONO_TYPE_I2: insert_op = OP_XINSERT_I2; extract_op = OP_EXTRACT_U2; break;
-			case MONO_TYPE_U2: insert_op = OP_XINSERT_I2; extract_op = OP_EXTRACT_I2; break;
+			case MONO_TYPE_I1: case MONO_TYPE_U1: insert_op = OP_XINSERT_I1; extract_op = OP_EXTRACT_I1; break;
+			case MONO_TYPE_I2: case MONO_TYPE_U2: insert_op = OP_XINSERT_I2; extract_op = OP_EXTRACT_I2; break;
 			case MONO_TYPE_I4: case MONO_TYPE_U4: insert_op = OP_XINSERT_I4; extract_op = OP_EXTRACT_I4; break;
 			case MONO_TYPE_I8: case MONO_TYPE_U8: insert_op = OP_XINSERT_I8; extract_op = OP_EXTRACT_I8; break;
 			case MONO_TYPE_R4: insert_op = OP_XINSERT_R4; extract_op = OP_EXTRACT_R4; break;
@@ -1624,11 +1601,12 @@ emit_arm64_intrinsics (
 			case SN_InsertScalar: {
 				MonoInst *ins = emit_simd_ins (cfg, klass, extract_op, val_src_reg, -1);
 				ins->inst_c0 = 0;
+				ins->inst_c1 = arg0_type;
 				val_src_reg = ins->dreg;
 				break;
 			}
 			}
-			MonoInst *ins = emit_simd_ins (cfg, klass, insert_op, args [0]->dreg, val_src_reg);
+			MonoInst *ins = emit_simd_ins (cfg, ret_klass, insert_op, args [0]->dreg, val_src_reg);
 			ins->sreg3 = args [1]->dreg;
 			ins->inst_c1 = arg0_type;
 			return ins;
@@ -1779,10 +1757,10 @@ static SimdIntrinsic sse_methods [] = {
 	{SN_CompareLessThan, OP_XCOMPARE_FP, CMP_LT},
 	{SN_CompareLessThanOrEqual, OP_XCOMPARE_FP, CMP_LE},
 	{SN_CompareNotEqual, OP_XCOMPARE_FP, CMP_NE},
-	{SN_CompareNotGreaterThan, OP_XCOMPARE_FP, CMP_LE},
-	{SN_CompareNotGreaterThanOrEqual, OP_XCOMPARE_FP, CMP_LT},
-	{SN_CompareNotLessThan, OP_XCOMPARE_FP, CMP_GE},
-	{SN_CompareNotLessThanOrEqual, OP_XCOMPARE_FP, CMP_GT},
+	{SN_CompareNotGreaterThan, OP_XCOMPARE_FP, CMP_LE_UN},
+	{SN_CompareNotGreaterThanOrEqual, OP_XCOMPARE_FP, CMP_LT_UN},
+	{SN_CompareNotLessThan, OP_XCOMPARE_FP, CMP_GE_UN},
+	{SN_CompareNotLessThanOrEqual, OP_XCOMPARE_FP, CMP_GT_UN},
 	{SN_CompareOrdered, OP_XCOMPARE_FP, CMP_ORD},
 	{SN_CompareScalarEqual, OP_SSE_CMPSS, CMP_EQ},
 	{SN_CompareScalarGreaterThan, OP_SSE_CMPSS, CMP_GT},
@@ -1790,10 +1768,10 @@ static SimdIntrinsic sse_methods [] = {
 	{SN_CompareScalarLessThan, OP_SSE_CMPSS, CMP_LT},
 	{SN_CompareScalarLessThanOrEqual, OP_SSE_CMPSS, CMP_LE},
 	{SN_CompareScalarNotEqual, OP_SSE_CMPSS, CMP_NE},
-	{SN_CompareScalarNotGreaterThan, OP_SSE_CMPSS, CMP_LE},
-	{SN_CompareScalarNotGreaterThanOrEqual, OP_SSE_CMPSS, CMP_LT},
-	{SN_CompareScalarNotLessThan, OP_SSE_CMPSS, CMP_GE},
-	{SN_CompareScalarNotLessThanOrEqual, OP_SSE_CMPSS, CMP_GT},
+	{SN_CompareScalarNotGreaterThan, OP_SSE_CMPSS, CMP_LE_UN},
+	{SN_CompareScalarNotGreaterThanOrEqual, OP_SSE_CMPSS, CMP_LT_UN},
+	{SN_CompareScalarNotLessThan, OP_SSE_CMPSS, CMP_GE_UN},
+	{SN_CompareScalarNotLessThanOrEqual, OP_SSE_CMPSS, CMP_GT_UN},
 	{SN_CompareScalarOrdered, OP_SSE_CMPSS, CMP_ORD},
 	{SN_CompareScalarOrderedEqual, OP_SSE_COMISS, CMP_EQ},
 	{SN_CompareScalarOrderedGreaterThan, OP_SSE_COMISS, CMP_GT},
@@ -1871,10 +1849,10 @@ static SimdIntrinsic sse2_methods [] = {
 	{SN_CompareLessThan},
 	{SN_CompareLessThanOrEqual, OP_XCOMPARE_FP, CMP_LE},
 	{SN_CompareNotEqual, OP_XCOMPARE_FP, CMP_NE},
-	{SN_CompareNotGreaterThan, OP_XCOMPARE_FP, CMP_LE},
-	{SN_CompareNotGreaterThanOrEqual, OP_XCOMPARE_FP, CMP_LT},
-	{SN_CompareNotLessThan, OP_XCOMPARE_FP, CMP_GE},
-	{SN_CompareNotLessThanOrEqual, OP_XCOMPARE_FP, CMP_GT},
+	{SN_CompareNotGreaterThan, OP_XCOMPARE_FP, CMP_LE_UN},
+	{SN_CompareNotGreaterThanOrEqual, OP_XCOMPARE_FP, CMP_LT_UN},
+	{SN_CompareNotLessThan, OP_XCOMPARE_FP, CMP_GE_UN},
+	{SN_CompareNotLessThanOrEqual, OP_XCOMPARE_FP, CMP_GT_UN},
 	{SN_CompareOrdered, OP_XCOMPARE_FP, CMP_ORD},
 	{SN_CompareScalarEqual, OP_SSE2_CMPSD, CMP_EQ},
 	{SN_CompareScalarGreaterThan, OP_SSE2_CMPSD, CMP_GT},
@@ -1882,10 +1860,10 @@ static SimdIntrinsic sse2_methods [] = {
 	{SN_CompareScalarLessThan, OP_SSE2_CMPSD, CMP_LT},
 	{SN_CompareScalarLessThanOrEqual, OP_SSE2_CMPSD, CMP_LE},
 	{SN_CompareScalarNotEqual, OP_SSE2_CMPSD, CMP_NE},
-	{SN_CompareScalarNotGreaterThan, OP_SSE2_CMPSD, CMP_LE},
-	{SN_CompareScalarNotGreaterThanOrEqual, OP_SSE2_CMPSD, CMP_LT},
-	{SN_CompareScalarNotLessThan, OP_SSE2_CMPSD, CMP_GE},
-	{SN_CompareScalarNotLessThanOrEqual, OP_SSE2_CMPSD, CMP_GT},
+	{SN_CompareScalarNotGreaterThan, OP_SSE2_CMPSD, CMP_LE_UN},
+	{SN_CompareScalarNotGreaterThanOrEqual, OP_SSE2_CMPSD, CMP_LT_UN},
+	{SN_CompareScalarNotLessThan, OP_SSE2_CMPSD, CMP_GE_UN},
+	{SN_CompareScalarNotLessThanOrEqual, OP_SSE2_CMPSD, CMP_GT_UN},
 	{SN_CompareScalarOrdered, OP_SSE2_CMPSD, CMP_ORD},
 	{SN_CompareScalarOrderedEqual, OP_SSE2_COMISD, CMP_EQ},
 	{SN_CompareScalarOrderedGreaterThan, OP_SSE2_COMISD, CMP_GT},
@@ -2122,10 +2100,7 @@ emit_x86_intrinsics (
 	if (feature == MONO_CPU_X86_SSE) {
 		switch (id) {
 		case SN_Shuffle:
-			if (args [2]->opcode == OP_ICONST)
-				return emit_simd_ins_for_sig (cfg, klass, OP_SSE_SHUFFLE, args [2]->inst_c0, arg0_type, fsig, args);
-			// FIXME: handle non-constant mask (generate a switch)
-			return emit_invalid_operation (cfg, "mask in Sse.Shuffle must be constant");
+			return emit_simd_ins_for_sig (cfg, klass, OP_SSE_SHUFPS, 0, arg0_type, fsig, args);
 		case SN_ConvertScalarToVector128Single: {
 			int op = 0;
 			switch (fsig->params [1]->type) {
@@ -2295,7 +2270,7 @@ emit_x86_intrinsics (
 			return emit_simd_ins_for_sig (cfg, klass, OP_SSE2_PACKUS, -1, arg0_type, fsig, args);
 		case SN_Extract:
 			g_assert (arg0_type == MONO_TYPE_U2);
-			return emit_simd_ins_for_sig (cfg, klass, OP_XEXTRACT_I32, arg0_type, 0, fsig, args);
+			return emit_simd_ins_for_sig (cfg, klass, OP_XEXTRACT_I4, 0, arg0_type, fsig, args);
 		case SN_Insert:
 			g_assert (arg0_type == MONO_TYPE_I2 || arg0_type == MONO_TYPE_U2);
 			return emit_simd_ins_for_sig (cfg, klass, OP_XINSERT_I2, 0, arg0_type, fsig, args);
@@ -2439,9 +2414,7 @@ emit_x86_intrinsics (
 	if (feature == MONO_CPU_X86_SSSE3) {
 		switch (id) {
 		case SN_AlignRight:
-			if (args [2]->opcode == OP_ICONST)
-				return emit_simd_ins_for_sig (cfg, klass, OP_SSSE3_ALIGNR, args [2]->inst_c0, arg0_type, fsig, args);
-			return emit_invalid_operation (cfg, "mask in Ssse3.AlignRight must be constant");
+			return emit_simd_ins_for_sig (cfg, klass, OP_SSSE3_ALIGNR, 0, arg0_type, fsig, args);
 		case SN_HorizontalAdd:
 			if (arg0_type == MONO_TYPE_I2)
 				return emit_simd_ins_for_sig (cfg, klass, OP_XOP_X_X_X, INTRINS_SSE_PHADDW, arg0_type, fsig, args);
@@ -2464,51 +2437,44 @@ emit_x86_intrinsics (
 
 	if (feature == MONO_CPU_X86_SSE41) {
 		switch (id) {
-		case SN_DotProduct:
-			if (args [2]->opcode == OP_ICONST && arg0_type == MONO_TYPE_R4)
-				return emit_simd_ins_for_sig (cfg, klass, OP_SSE41_DPPS_IMM, args [2]->inst_c0, arg0_type, fsig, args);
-			else if (args [2]->opcode == OP_ICONST && arg0_type == MONO_TYPE_R8)
-				return emit_simd_ins_for_sig (cfg, klass, OP_SSE41_DPPD_IMM, args [2]->inst_c0, arg0_type, fsig, args);
-			// FIXME: handle non-constant control byte (generate a switch)
-			return emit_invalid_operation (cfg, "control byte in Sse41.DotProduct must be constant");
+		case SN_DotProduct: {
+			int op = 0;
+			switch (arg0_type) {
+			case MONO_TYPE_R4: op = OP_SSE41_DPPS; break;
+			case MONO_TYPE_R8: op = OP_SSE41_DPPD; break;
+			default: g_assert_not_reached (); break;
+			}
+			return emit_simd_ins_for_sig (cfg, klass, op, 0, arg0_type, fsig, args);
+		}
 		case SN_MultipleSumAbsoluteDifferences:
-			if (args [2]->opcode == OP_ICONST)
-				return emit_simd_ins_for_sig (cfg, klass, OP_SSE41_MPSADBW_IMM, args [2]->inst_c0, arg0_type, fsig, args);
-			// FIXME: handle non-constant control byte (generate a switch)
-			return emit_invalid_operation (cfg, "control byte in Sse41.MultipleSumAbsoluteDifferences must be constant");
+			return emit_simd_ins_for_sig (cfg, klass, OP_SSE41_MPSADBW, 0, arg0_type, fsig, args);
 		case SN_Blend:
-			if (args [2]->opcode == OP_ICONST)
-				return emit_simd_ins_for_sig (cfg, klass, OP_SSE41_BLEND_IMM, args [2]->inst_c0, arg0_type, fsig, args);
-			// FIXME: handle non-constant control byte (generate a switch)
-			return emit_invalid_operation (cfg, "control byte in Sse41.Blend must be constant");
+			return emit_simd_ins_for_sig (cfg, klass, OP_SSE41_BLEND, 0, arg0_type, fsig, args);
 		case SN_BlendVariable:
 			return emit_simd_ins_for_sig (cfg, klass, OP_SSE41_BLENDV, -1, arg0_type, fsig, args);
 		case SN_Extract: {
 			int op = 0;
 			switch (arg0_type) {
-			case MONO_TYPE_U1:
-			case MONO_TYPE_U4:
-			case MONO_TYPE_I4: op = OP_XEXTRACT_I32; break;
-			case MONO_TYPE_I8:
-			case MONO_TYPE_U8: op = OP_XEXTRACT_I64; break;
+			case MONO_TYPE_U1: op = OP_XEXTRACT_I1; break;
+			case MONO_TYPE_U4: case MONO_TYPE_I4: op = OP_XEXTRACT_I4; break;
+			case MONO_TYPE_U8: case MONO_TYPE_I8: op = OP_XEXTRACT_I8; break;
 			case MONO_TYPE_R4: op = OP_XEXTRACT_R4; break;
 			case MONO_TYPE_I:
 			case MONO_TYPE_U:
 #if TARGET_SIZEOF_VOID_P == 8
-				op = OP_XEXTRACT_I64;
+				op = OP_XEXTRACT_I8;
 #else
-				op = OP_XEXTRACT_I32;
+				op = OP_XEXTRACT_I4;
 #endif
 				break;
 			default: g_assert_not_reached(); break;
 			}
-			return emit_simd_ins_for_sig (cfg, klass, op, arg0_type, 0, fsig, args);
+			return emit_simd_ins_for_sig (cfg, klass, op, 0, arg0_type, fsig, args);
+		}
+		case SN_Insert: {
+			int op = arg0_type == MONO_TYPE_R4 ? OP_SSE41_INSERTPS : type_to_xinsert_op (arg0_type);
+			return emit_simd_ins_for_sig (cfg, klass, op, -1, arg0_type, fsig, args);
 		}
-		case SN_Insert:
-			if (args [2]->opcode == OP_ICONST)
-				return emit_simd_ins_for_sig (cfg, klass, OP_SSE41_INSERT, -1, arg0_type, fsig, args);
-			// FIXME: handle non-constant index (generate a switch)
-			return emit_invalid_operation (cfg, "index in Sse41.Insert must be constant");
 		case SN_CeilingScalar:
 		case SN_FloorScalar:
 		case SN_RoundCurrentDirectionScalar:
@@ -2548,10 +2514,7 @@ emit_x86_intrinsics (
 	if (feature == MONO_CPU_X86_PCLMUL) {
 		switch (id) {
 		case SN_CarrylessMultiply: {
-			if (args [2]->opcode == OP_ICONST)
-				return emit_simd_ins_for_sig (cfg, klass, OP_PCLMULQDQ_IMM, args [2]->inst_c0, arg0_type, fsig, args);
-			// FIXME: handle non-constant control byte (generate a switch)
-			return emit_invalid_operation (cfg, "index in Pclmulqdq.CarrylessMultiply must be constant");
+			return emit_simd_ins_for_sig (cfg, klass, OP_PCLMULQDQ, 0, arg0_type, fsig, args);
 		}
 		default:
 			g_assert_not_reached ();
@@ -2562,10 +2525,7 @@ emit_x86_intrinsics (
 	if (feature == MONO_CPU_X86_AES) {
 		switch (id) {
 		case SN_KeygenAssist: {
-			if (args [1]->opcode == OP_ICONST)
-				return emit_simd_ins_for_sig (cfg, klass, OP_AES_KEYGEN_IMM, args [1]->inst_c0, arg0_type, fsig, args);
-			// FIXME: handle non-constant control byte (generate a switch)
-			return emit_invalid_operation (cfg, "control byte in Aes.KeygenAssist must be constant");
+			return emit_simd_ins_for_sig (cfg, klass, OP_AES_KEYGENASSIST, 0, arg0_type, fsig, args);
 		}
 		default:
 			g_assert_not_reached ();
@@ -2590,12 +2550,7 @@ emit_x86_intrinsics (
 	if (feature == MONO_CPU_X86_LZCNT) {
 		switch (id) {
 		case SN_LeadingZeroCount:
-			MONO_INST_NEW (cfg, ins, is_64bit ? OP_LZCNT64 : OP_LZCNT32);
-			ins->dreg = is_64bit ? alloc_lreg (cfg) : alloc_ireg (cfg);
-			ins->sreg1 = args [0]->dreg;
-			ins->type = is_64bit ? STACK_I8 : STACK_I4;
-			MONO_ADD_INS (cfg->cbb, ins);
-			return ins;
+			return emit_simd_ins_for_sig (cfg, klass, is_64bit ? OP_LZCNT64 : OP_LZCNT32, 0, arg0_type, fsig, args);
 		default:
 			return NULL;
 		}
@@ -2612,15 +2567,24 @@ emit_x86_intrinsics (
 			return ins;
 		}
 		case SN_BitFieldExtract: {
+			int ctlreg = args [1]->dreg;
 			if (fsig->param_count == 2) {
-				MONO_INST_NEW (cfg, ins, is_64bit ? OP_BEXTR64 : OP_BEXTR32);
-				ins->dreg = is_64bit ? alloc_lreg (cfg) : alloc_ireg (cfg);
-				ins->sreg1 = args [0]->dreg;
-				ins->sreg2 = args [1]->dreg;
-				ins->type = is_64bit ? STACK_I8 : STACK_I4;
-				MONO_ADD_INS (cfg->cbb, ins);
-				return ins;
+			} else if (fsig->param_count == 3) {
+				MonoInst *ins = NULL;
+				/* This intrinsic is also implemented in managed code.
+				 * TODO: remove this if cross-AOT-assembly inlining works
+				 */
+				int startreg = args [1]->dreg;
+				int lenreg = args [2]->dreg;
+				int dreg1 = alloc_ireg (cfg);
+				EMIT_NEW_BIALU_IMM (cfg, ins, OP_SHL_IMM, dreg1, lenreg, 8);
+				int dreg2 = alloc_ireg (cfg);
+				EMIT_NEW_BIALU (cfg, ins, OP_IOR, dreg2, startreg, dreg1);
+				ctlreg = dreg2;
+			} else {
+				g_assert_not_reached ();
 			}
+			return emit_simd_ins (cfg, klass, is_64bit ? OP_BMI1_BEXTR64 : OP_BMI1_BEXTR32, args [0]->dreg, ctlreg);
 		}
 		case SN_GetMaskUpToLowestSetBit: {
 			// x ^ (x - 1)
@@ -2664,26 +2628,17 @@ emit_x86_intrinsics (
 	}
 	if (feature == MONO_CPU_X86_BMI2) {
 		switch (id) {
-		case SN_MultiplyNoFlags:
+		case SN_MultiplyNoFlags: {
+			int op = 0;
 			if (fsig->param_count == 2) {
-				MONO_INST_NEW (cfg, ins, is_64bit ? OP_MULX_H64 : OP_MULX_H32);
-				ins->dreg = is_64bit ? alloc_lreg (cfg) : alloc_ireg (cfg);
-				ins->sreg1 = args [0]->dreg;
-				ins->sreg2 = args [1]->dreg;
-				ins->type = is_64bit ? STACK_I8 : STACK_I4;
-				MONO_ADD_INS (cfg->cbb, ins);
+				op = is_64bit ? OP_MULX_H64 : OP_MULX_H32;
 			} else if (fsig->param_count == 3) {
-				MONO_INST_NEW (cfg, ins, is_64bit ? OP_MULX_HL64 : OP_MULX_HL32);
-				ins->dreg = is_64bit ? alloc_lreg (cfg) : alloc_ireg (cfg);
-				ins->sreg1 = args [0]->dreg;
-				ins->sreg2 = args [1]->dreg;
-				ins->sreg3 = args [2]->dreg;
-				ins->type = is_64bit ? STACK_I8 : STACK_I4;
-				MONO_ADD_INS (cfg->cbb, ins);
+				op = is_64bit ? OP_MULX_HL64 : OP_MULX_HL32;
 			} else {
 				g_assert_not_reached ();
 			}
-			return ins;
+			return emit_simd_ins_for_sig (cfg, klass, op, 0, 0, fsig, args);
+		}
 		case SN_ZeroHighBits:
 			MONO_INST_NEW (cfg, ins, is_64bit ? OP_BZHI64 : OP_BZHI32);
 			ins->dreg = is_64bit ? alloc_lreg (cfg) : alloc_ireg (cfg);
diff --git a/src/mono/mono/mini/wasm_m2n_invoke.g.h b/src/mono/mono/mini/wasm_m2n_invoke.g.h
index 715070c03fd2e2..6f21c3f9378e76 100644
--- a/src/mono/mono/mini/wasm_m2n_invoke.g.h
+++ b/src/mono/mono/mini/wasm_m2n_invoke.g.h
@@ -1625,6 +1625,36 @@ wasm_invoke_vlii (void *target_func, InterpMethodArguments *margs)
 
 }
 
+static void
+wasm_invoke_iiiil (void *target_func, InterpMethodArguments *margs)
+{
+	typedef int (*T)(int arg_0, int arg_1, int arg_2, gint64 arg_3);
+	T func = (T)target_func;
+	int res = func ((int)(gssize)margs->iargs [0], (int)(gssize)margs->iargs [1], (int)(gssize)margs->iargs [2], get_long_arg (margs, 3));
+	*(int*)margs->retval = res;
+
+}
+
+static void
+wasm_invoke_liiil (void *target_func, InterpMethodArguments *margs)
+{
+	typedef gint64 (*T)(int arg_0, int arg_1, int arg_2, gint64 arg_3);
+	T func = (T)target_func;
+	gint64 res = func ((int)(gssize)margs->iargs [0], (int)(gssize)margs->iargs [1], (int)(gssize)margs->iargs [2], get_long_arg (margs, 3));
+	*(gint64*)margs->retval = res;
+
+}
+
+static void
+wasm_invoke_iill (void *target_func, InterpMethodArguments *margs)
+{
+	typedef int (*T)(int arg_0, gint64 arg_1, gint64 arg_2);
+	T func = (T)target_func;
+	int res = func ((int)(gssize)margs->iargs [0], get_long_arg (margs, 1), get_long_arg (margs, 3));
+	*(int*)margs->retval = res;
+
+}
+
 static const char* interp_to_native_signatures [] = {
 "DD",
 "DDD",
@@ -1718,6 +1748,7 @@ static const char* interp_to_native_signatures [] = {
 "IIIIIIIIIIII",
 "IIIIIIIIIIIII",
 "IIIIIIIIIIIIII",
+"IIIIL",
 "IIIL",
 "IIILIIII",
 "IIILLI",
@@ -1725,6 +1756,7 @@ static const char* interp_to_native_signatures [] = {
 "IILI",
 "IILIIII",
 "IILIIIL",
+"IILL",
 "IILLI",
 "IILLLI",
 "IL",
@@ -1732,6 +1764,7 @@ static const char* interp_to_native_signatures [] = {
 "L",
 "LI",
 "LII",
+"LIIIL",
 "LIL",
 "LILI",
 "LILII",
@@ -1888,6 +1921,7 @@ wasm_invoke_iiiiiiiiiii,
 wasm_invoke_iiiiiiiiiiii,
 wasm_invoke_iiiiiiiiiiiii,
 wasm_invoke_iiiiiiiiiiiiii,
+wasm_invoke_iiiil,
 wasm_invoke_iiil,
 wasm_invoke_iiiliiii,
 wasm_invoke_iiilli,
@@ -1895,6 +1929,7 @@ wasm_invoke_iil,
 wasm_invoke_iili,
 wasm_invoke_iiliiii,
 wasm_invoke_iiliiil,
+wasm_invoke_iill,
 wasm_invoke_iilli,
 wasm_invoke_iillli,
 wasm_invoke_il,
@@ -1902,6 +1937,7 @@ wasm_invoke_ili,
 wasm_invoke_l,
 wasm_invoke_li,
 wasm_invoke_lii,
+wasm_invoke_liiil,
 wasm_invoke_lil,
 wasm_invoke_lili,
 wasm_invoke_lilii,
diff --git a/src/mono/mono/utils/mono-error-internals.h b/src/mono/mono/utils/mono-error-internals.h
index 3fffa6669431c6..76b3e33ee9c2fb 100644
--- a/src/mono/mono/utils/mono-error-internals.h
+++ b/src/mono/mono/utils/mono-error-internals.h
@@ -173,6 +173,7 @@ mono_error_set_type_load_class (MonoError *error, MonoClass *klass, const char *
 void
 mono_error_vset_type_load_class (MonoError *error, MonoClass *klass, const char *msg_format, va_list args);
 
+MONO_COMPONENT_API
 void
 mono_error_set_type_load_name (MonoError *error, const char *type_name, const char *assembly_name, const char *msg_format, ...) MONO_ATTR_FORMAT_PRINTF(4,5);
 
@@ -209,6 +210,7 @@ mono_error_set_not_supported (MonoError *error, const char *msg_format, ...) MON
 void 
 mono_error_set_ambiguous_implementation (MonoError *error, const char *msg_format, ...) MONO_ATTR_FORMAT_PRINTF(2,3);
 
+MONO_COMPONENT_API
 void
 mono_error_set_invalid_operation (MonoError *error, const char *msg_format, ...) MONO_ATTR_FORMAT_PRINTF(2,3);
 
diff --git a/src/mono/mono/utils/mono-logger-internals.h b/src/mono/mono/utils/mono-logger-internals.h
index 48db7fa1750564..bff13285fb6d9a 100644
--- a/src/mono/mono/utils/mono-logger-internals.h
+++ b/src/mono/mono/utils/mono-logger-internals.h
@@ -57,6 +57,7 @@ mono_trace_push (GLogLevelFlags level, MonoTraceMask mask);
 void 
 mono_trace_pop (void);
 
+MONO_COMPONENT_API
 gboolean
 mono_trace_is_traced (GLogLevelFlags level, MonoTraceMask mask);
 
diff --git a/src/mono/mono/utils/mono-threads-coop.h b/src/mono/mono/utils/mono-threads-coop.h
index 47c20c140253aa..975915812946aa 100644
--- a/src/mono/mono/utils/mono-threads-coop.h
+++ b/src/mono/mono/utils/mono-threads-coop.h
@@ -20,7 +20,7 @@
 #include "mono/metadata/icalls.h"
 
 /* JIT specific interface */
-extern volatile size_t mono_polling_required;
+MONO_API_DATA volatile size_t mono_polling_required;
 
 /* Internal API */
 
diff --git a/src/mono/nuget/Microsoft.NET.Runtime.MonoAOTCompiler.Task/README.md b/src/mono/nuget/Microsoft.NET.Runtime.MonoAOTCompiler.Task/README.md
index 108027b8fbc79a..3faa7a5f30c322 100644
--- a/src/mono/nuget/Microsoft.NET.Runtime.MonoAOTCompiler.Task/README.md
+++ b/src/mono/nuget/Microsoft.NET.Runtime.MonoAOTCompiler.Task/README.md
@@ -29,3 +29,27 @@ The `MonoAOTCompiler` MSBuild task is also useful outside the context of `dotnet
     </MonoAOTCompiler>
 </Target>
 ```
+
+------------
+Use `UsingTask` directly
+## In the project file
+```
+<!-- Import the NuGet package into the project -->
+<ItemGroup>
+    <PackageReference Include="Microsoft.NET.Runtime.MonoAOTCompiler.Task" Version="<desired-dotnet-6-sdk-version>" GeneratePathProperty="true" />
+</ItemGroup>
+
+<UsingTask TaskName="MonoAOTCompiler"
+           AssemblyFile="$(PkgMicrosoft_NET_Runtime_MonoAOTCompiler_Task)/tools/<target-framework>/MonoAOTCompiler.dll" />
+
+<!-- Use the MonoAOTCompiler task in a target -->
+<Target>
+    <MonoAOTCompiler 
+        CompilerBinaryPath="$(CompilerBinaryPath)"
+        Assemblies="@(Assemblies)"
+        <!-- Other parameters -->
+        >
+        <Output TaskParameter="CompiledAssemblies" ItemName="CompiledAssemblies" />
+    </MonoAOTCompiler>
+</Target>
+```
\ No newline at end of file
diff --git a/src/mono/nuget/Microsoft.NET.Runtime.RuntimeConfigParser.Task/Sdk/Sdk.props b/src/mono/nuget/Microsoft.NET.Runtime.RuntimeConfigParser.Task/Sdk/Sdk.props
index 90b746e0456a2a..f81ae6a8bde35d 100644
--- a/src/mono/nuget/Microsoft.NET.Runtime.RuntimeConfigParser.Task/Sdk/Sdk.props
+++ b/src/mono/nuget/Microsoft.NET.Runtime.RuntimeConfigParser.Task/Sdk/Sdk.props
@@ -1,6 +1,7 @@
 <Project>
   <PropertyGroup>
-    <RuntimeConfigParserTasksAssemblyPath>$(MSBuildThisFileDirectory)..\tasks\RuntimeConfigParser.dll</RuntimeConfigParserTasksAssemblyPath>
+    <RuntimeConfigParserTasksAssemblyPath Condition="'$(MSBuildRuntimeType)' == 'Core'">$(MSBuildThisFileDirectory)..\tasks\net6.0\RuntimeConfigParser.dll</RuntimeConfigParserTasksAssemblyPath>
+    <RuntimeConfigParserTasksAssemblyPath Condition="'$(MSBuildRuntimeType)' != 'Core'">$(MSBuildThisFileDirectory)..\tasks\net472\RuntimeConfigParser.dll</RuntimeConfigParserTasksAssemblyPath>
   </PropertyGroup>
   <UsingTask TaskName="RuntimeConfigParserTask" AssemblyFile="$(RuntimeConfigParserTasksAssemblyPath)" />
 </Project>
diff --git a/src/mono/nuget/Microsoft.NET.Workload.Mono.Toolchain.Manifest/WorkloadManifest.json.in b/src/mono/nuget/Microsoft.NET.Workload.Mono.Toolchain.Manifest/WorkloadManifest.json.in
index aeb12d50dae529..d783615a908e1a 100644
--- a/src/mono/nuget/Microsoft.NET.Workload.Mono.Toolchain.Manifest/WorkloadManifest.json.in
+++ b/src/mono/nuget/Microsoft.NET.Workload.Mono.Toolchain.Manifest/WorkloadManifest.json.in
@@ -4,38 +4,44 @@
     "microsoft-net-sdk-blazorwebassembly-aot": {
       "description": "Browser Runtime native performance tools",
       "packs": [
-        "Microsoft.NETCore.App.Runtime.Mono.browser-wasm",
-        "Microsoft.NET.Runtime.MonoAOTCompiler.Task",
         "Microsoft.NET.Runtime.WebAssembly.Sdk",
+        "Microsoft.NETCore.App.Runtime.Mono.browser-wasm",
         "Microsoft.NETCore.App.Runtime.AOT.Cross.browser-wasm",
         "Microsoft.NET.Runtime.Emscripten.Node",
         "Microsoft.NET.Runtime.Emscripten.Python",
         "Microsoft.NET.Runtime.Emscripten.Sdk"
       ],
+      "extends": [ "microsoft-net-runtime-mono-tooling" ],
       "platforms": [ "win-x64", "linux-x64", "osx-x64", "osx-arm64" ]
     },
     "microsoft-net-runtime-android": {
       "abstract": true,
-      "description": "Android Mono Runtime and AOT Workload",
+      "description": "Android Mono Runtime",
       "packs": [
-        "Microsoft.NET.Runtime.RuntimeConfigParser.Task",
-        "Microsoft.NET.Runtime.MonoAOTCompiler.Task",
         "Microsoft.NETCore.App.Runtime.Mono.android-arm",
         "Microsoft.NETCore.App.Runtime.Mono.android-arm64",
         "Microsoft.NETCore.App.Runtime.Mono.android-x64",
-        "Microsoft.NETCore.App.Runtime.Mono.android-x86",
+        "Microsoft.NETCore.App.Runtime.Mono.android-x86"
+      ],
+      "extends": [ "microsoft-net-runtime-mono-tooling" ],
+      "platforms": [ "win-x64", "linux-x64", "osx-x64", "osx-arm64" ]
+    },
+    "microsoft-net-runtime-android-aot": {
+      "abstract": true,
+      "description": "Android Mono AOT Workload",
+      "packs": [
+        "Microsoft.NETCore.App.Runtime.AOT.Cross.android-x86",
         "Microsoft.NETCore.App.Runtime.AOT.Cross.android-x64",
         "Microsoft.NETCore.App.Runtime.AOT.Cross.android-arm",
         "Microsoft.NETCore.App.Runtime.AOT.Cross.android-arm64"
       ],
+      "extends": [ "microsoft-net-runtime-android" ],
       "platforms": [ "win-x64", "linux-x64", "osx-x64", "osx-arm64" ]
     },
     "microsoft-net-runtime-ios": {
       "abstract": true,
       "description": "iOS Mono Runtime and AOT Workload",
       "packs": [
-        "Microsoft.NET.Runtime.RuntimeConfigParser.Task",
-        "Microsoft.NET.Runtime.MonoAOTCompiler.Task",
         "Microsoft.NETCore.App.Runtime.Mono.ios-arm",
         "Microsoft.NETCore.App.Runtime.Mono.ios-arm64",
         "Microsoft.NETCore.App.Runtime.Mono.iossimulator",
@@ -45,20 +51,38 @@
         "Microsoft.NETCore.App.Runtime.AOT.Cross.iossimulator",
         "Microsoft.NETCore.App.Runtime.AOT.Cross.iossimulator-x86"
       ],
+      "extends": [ "microsoft-net-runtime-mono-tooling" ],
+      "platforms": [ "osx-arm64", "osx-x64" ]
+    },
+    "microsoft-net-runtime-maccatalyst": {
+      "abstract": true,
+      "description": "MacCatalyst Mono Runtime and AOT Workload",
+      "packs": [
+        "Microsoft.NETCore.App.Runtime.Mono.maccatalyst",
+        "Microsoft.NETCore.App.Runtime.AOT.Cross.maccatalyst"
+      ],
+      "extends": [ "microsoft-net-runtime-mono-tooling" ],
       "platforms": [ "osx-arm64", "osx-x64" ]
     },
     "microsoft-net-runtime-tvos": {
       "abstract": true,
       "description": "tvOS Mono Runtime and AOT Workload",
       "packs": [
-        "Microsoft.NET.Runtime.RuntimeConfigParser.Task",
-        "Microsoft.NET.Runtime.MonoAOTCompiler.Task",
         "Microsoft.NETCore.App.Runtime.Mono.tvos-arm64",
         "Microsoft.NETCore.App.Runtime.Mono.tvossimulator",
         "Microsoft.NETCore.App.Runtime.AOT.Cross.tvos-arm64",
         "Microsoft.NETCore.App.Runtime.AOT.Cross.tvossimulator"
       ],
+      "extends": [ "microsoft-net-runtime-mono-tooling" ],
       "platforms": [ "osx-arm64", "osx-x64" ]
+    },
+    "microsoft-net-runtime-mono-tooling": {
+      "abstract": true,
+      "description": "Shared native build tooling for Mono runtime",
+      "packs": [
+        "Microsoft.NET.Runtime.RuntimeConfigParser.Task",
+        "Microsoft.NET.Runtime.MonoAOTCompiler.Task",
+      ],
     }
   },
   "packs": {
@@ -124,12 +148,20 @@
       "kind": "Sdk",
       "version": "${PackageVersion}",
       "alias-to": {
-        "win-x64": "Microsoft.netcore.app.runtime.aot.win-x64.Cross.android-arm64",
+        "win-x64": "Microsoft.NETCore.App.Runtime.AOT.win-x64.Cross.android-arm64",
         "linux-x64": "Microsoft.NETCore.App.Runtime.AOT.linux-x64.Cross.android-arm64",
         "osx-x64": "Microsoft.NETCore.App.Runtime.AOT.osx-x64.Cross.android-arm64",
         "osx-arm64": "Microsoft.NETCore.App.Runtime.AOT.osx-x64.Cross.android-arm64"
       }
     },
+    "Microsoft.NETCore.App.Runtime.Mono.maccatalyst": {
+      "kind": "framework",
+      "version": "${PackageVersion}",
+      "alias-to": {
+        "osx-arm64": "Microsoft.NETCore.App.Runtime.Mono.maccatalyst-arm64",
+        "osx-x64": "Microsoft.NETCore.App.Runtime.Mono.maccatalyst-x64"
+      }
+    },
     "Microsoft.NETCore.App.Runtime.Mono.ios-arm" : {
       "kind": "framework",
       "version": "${PackageVersion}"
@@ -173,6 +205,14 @@
         "osx-x64": "Microsoft.NETCore.App.Runtime.Mono.tvossimulator-x64"
       }
     },
+    "Microsoft.NETCore.App.Runtime.AOT.Cross.maccatalyst": {
+      "kind": "Sdk",
+      "version": "${PackageVersion}",
+      "alias-to": {
+        "osx-arm64": "Microsoft.NETCore.App.Runtime.AOT.osx-x64.Cross.maccatalyst-arm64",
+        "osx-x64": "Microsoft.NETCore.App.Runtime.AOT.osx-x64.Cross.maccatalyst-x64"
+      }
+    },
     "Microsoft.NETCore.App.Runtime.AOT.Cross.tvossimulator": {
       "kind": "Sdk",
       "version": "${PackageVersion}",
diff --git a/src/mono/nuget/Microsoft.NET.Workload.Mono.Toolchain.Manifest/WorkloadManifest.targets b/src/mono/nuget/Microsoft.NET.Workload.Mono.Toolchain.Manifest/WorkloadManifest.targets
index 2b7dc3d02315e0..ca7309a6612b4e 100644
--- a/src/mono/nuget/Microsoft.NET.Workload.Mono.Toolchain.Manifest/WorkloadManifest.targets
+++ b/src/mono/nuget/Microsoft.NET.Workload.Mono.Toolchain.Manifest/WorkloadManifest.targets
@@ -1,5 +1,5 @@
 <Project>
-    <PropertyGroup Condition="'$(RuntimeIdentifier)' == 'browser-wasm'">
+    <PropertyGroup Condition="'$(RuntimeIdentifier)' == 'browser-wasm' AND '$(UsingBrowserRuntimeWorkload)' == ''">
         <UsingBrowserRuntimeWorkload Condition="'$(RunAOTCompilation)' == 'true' or '$(UsingMicrosoftNETSdkBlazorWebAssembly)' != 'true'" >true</UsingBrowserRuntimeWorkload>
         <UsingBrowserRuntimeWorkload Condition="'$(UsingBrowserRuntimeWorkload)' == ''" >$(WasmNativeWorkload)</UsingBrowserRuntimeWorkload>
     </PropertyGroup>
@@ -10,6 +10,7 @@
 
     <Import Condition="'$(RunAOTCompilation)' == 'true'" Project="Sdk.props" Sdk="Microsoft.NET.Runtime.MonoAOTCompiler.Task" />
 
+    <Import Condition="'$(TargetPlatformIdentifier)' == 'android'" Project="Sdk.props" Sdk="Microsoft.NET.Runtime.RuntimeConfigParser.Task" />
     <ImportGroup Condition="'$(TargetPlatformIdentifier)' == 'android' and '$(RunAOTCompilation)' == 'true'">
         <Import Project="Sdk.props" Sdk="Microsoft.NETCore.App.Runtime.AOT.Cross.android-x86" />
         <Import Project="Sdk.props" Sdk="Microsoft.NETCore.App.Runtime.AOT.Cross.android-x64" />
@@ -17,20 +18,29 @@
         <Import Project="Sdk.props" Sdk="Microsoft.NETCore.App.Runtime.AOT.Cross.android-arm64" />
     </ImportGroup>
 
-    <ImportGroup Condition="'$(TargetPlatformIdentifier)' == 'ios' and '$(RunAOTCompilation)' == 'true'">
+    <ImportGroup Condition="'$(TargetPlatformIdentifier)' == 'ios'">
+        <Import Project="Sdk.props" Sdk="Microsoft.NET.Runtime.RuntimeConfigParser.Task" />
         <Import Project="Sdk.props" Sdk="Microsoft.NETCore.App.Runtime.AOT.Cross.ios-arm" />
         <Import Project="Sdk.props" Sdk="Microsoft.NETCore.App.Runtime.AOT.Cross.ios-arm64" />
     </ImportGroup>
 
-    <ImportGroup Condition="'$(TargetPlatformIdentifier)' == 'tvos' and '$(RunAOTCompilation)' == 'true'">
+    <ImportGroup Condition="'$(TargetPlatformIdentifier)' == 'maccatalyst'">
+        <Import Project="Sdk.props" Sdk="Microsoft.NET.Runtime.RuntimeConfigParser.Task" />
+        <Import Project="Sdk.props" Sdk="Microsoft.NETCore.App.Runtime.AOT.Cross.maccatalyst" />
+    </ImportGroup>
+
+    <ImportGroup Condition="'$(TargetPlatformIdentifier)' == 'tvos'">
+        <Import Project="Sdk.props" Sdk="Microsoft.NET.Runtime.RuntimeConfigParser.Task" />
         <Import Project="Sdk.props" Sdk="Microsoft.NETCore.App.Runtime.AOT.Cross.tvos-arm64" />
     </ImportGroup>
 
-    <ImportGroup Condition="'$(TargetPlatformIdentifier)' == 'iossimulator' and '$(RunAOTCompilation)' == 'true'">
+    <ImportGroup Condition="'$(TargetPlatformIdentifier)' == 'iossimulator'">
+        <Import Project="Sdk.props" Sdk="Microsoft.NET.Runtime.RuntimeConfigParser.Task" />
         <Import Project="Sdk.props" Sdk="Microsoft.NETCore.App.Runtime.AOT.Cross.iossimulator" />
     </ImportGroup>
 
-    <ImportGroup Condition="'$(TargetPlatformIdentifier)' == 'tvossimulator' and '$(RunAOTCompilation)' == 'true'">
+    <ImportGroup Condition="'$(TargetPlatformIdentifier)' == 'tvossimulator'">
+        <Import Project="Sdk.props" Sdk="Microsoft.NET.Runtime.RuntimeConfigParser.Task" />
         <Import Project="Sdk.props" Sdk="Microsoft.NETCore.App.Runtime.AOT.Cross.tvossimulator" />
     </ImportGroup>
 
@@ -39,6 +49,6 @@
         <Import Project="Sdk.props" Sdk="Microsoft.NET.Runtime.Emscripten.Python" Condition="!$([MSBuild]::IsOsPlatform('Linux'))" />
         <Import Project="Sdk.props" Sdk="Microsoft.NET.Runtime.Emscripten.Node" />
         <Import Project="Sdk.props" Sdk="Microsoft.NET.Runtime.Emscripten.Sdk" />
-        <Import Project="Sdk.props" Sdk="Microsoft.NETcore.App.Runtime.AOT.Cross.browser-wasm" />
+        <Import Project="Sdk.props" Sdk="Microsoft.NETCore.App.Runtime.AOT.Cross.browser-wasm" />
     </ImportGroup>
 </Project>
diff --git a/src/mono/sample/Android/AndroidSampleApp.csproj b/src/mono/sample/Android/AndroidSampleApp.csproj
index dd52a30abf241c..8fb25b90b7189d 100644
--- a/src/mono/sample/Android/AndroidSampleApp.csproj
+++ b/src/mono/sample/Android/AndroidSampleApp.csproj
@@ -3,24 +3,12 @@
     <OutputType>Exe</OutputType>
     <EnableDefaultCompileItems>false</EnableDefaultCompileItems>
     <TargetFramework>$(NetCoreAppToolCurrent)</TargetFramework>
-    <EnableTargetingPackDownload>false</EnableTargetingPackDownload>
     <RuntimeIdentifier>android-$(TargetArchitecture)</RuntimeIdentifier>
     <PublishTrimmed>true</PublishTrimmed>
     <TrimMode>Link</TrimMode>
-    <MicrosoftNetCoreAppRuntimePackDir>$(ArtifactsBinDir)microsoft.netcore.app.runtime.$(RuntimeIdentifier)\$(Configuration)\runtimes\android-$(TargetArchitecture)\</MicrosoftNetCoreAppRuntimePackDir>
     <ForceAOT Condition="'$(ForceAOT)' == ''">false</ForceAOT>
   </PropertyGroup>
 
-  <!-- Redirect 'dotnet publish' to in-tree runtime pack -->
-  <Target Name="TrickRuntimePackLocation" AfterTargets="ProcessFrameworkReferences">
-    <ItemGroup>
-      <RuntimePack>
-        <PackageDirectory>$(ArtifactsBinDir)microsoft.netcore.app.runtime.$(RuntimeIdentifier)\$(Configuration)</PackageDirectory>
-      </RuntimePack>
-    </ItemGroup>
-    <Message Text="Packaged ID: %(RuntimePack.PackageDirectory)" Importance="high" />
-  </Target>
-
   <Import Project="$(RepoTasksDir)AotCompilerTask\MonoAOTCompiler.props" />
   <UsingTask TaskName="AndroidAppBuilderTask" AssemblyFile="$(AndroidAppBuilderTasksAssemblyPath)"/>
   <UsingTask TaskName="MonoAOTCompiler" AssemblyFile="$(MonoAOTCompilerTasksAssemblyPath)" />
@@ -59,7 +47,7 @@
     <Message Importance="High" Text="SourceDir: $(OutputPath)" />
 
     <MonoAOTCompiler Condition="'$(ForceAOT)' == 'true'"
-        CompilerBinaryPath="$(MonoAotCrossCompilerPath)"
+        CompilerBinaryPath="@(MonoAotCrossCompiler->WithMetadataValue('RuntimeIdentifier','$(TargetOS.ToLowerInvariant())-$(TargetArchitecture.ToLowerInvariant())'))"
         OutputDir="$(_MobileIntermediateOutputPath)"
         Mode="Full"
         OutputType="AsmOnly"
@@ -75,7 +63,7 @@
         ProjectName="HelloAndroid"
         ForceInterpreter="$(MonoForceInterpreter)"
         ForceAOT="$(ForceAOT)"
-        MonoRuntimeHeaders="$(MicrosoftNetCoreAppRuntimePackDir)\native\include\mono-2.0"
+        MonoRuntimeHeaders="$(MicrosoftNetCoreAppRuntimePackDir)runtimes\android-$(TargetArchitecture)\native\include\mono-2.0"
         Assemblies="@(BundleAssemblies)"
         MainLibraryFileName="$(AssemblyName).dll"
         StripDebugSymbols="$(StripDebugSymbols)"
diff --git a/src/mono/sample/Android/Makefile b/src/mono/sample/Android/Makefile
index 889e31248dc18c..6d59ee860fe8b9 100644
--- a/src/mono/sample/Android/Makefile
+++ b/src/mono/sample/Android/Makefile
@@ -3,8 +3,8 @@ MONO_ARCH?=x64
 DOTNET := ../../../../dotnet.sh
 USE_LLVM=true
 AOT=false
+INTERP=false
 DEPLOY_AND_RUN?=true
-RUNTIME_COMPONENTS=diagnostics_tracing
 
 #If DIAGNOSTIC_PORTS is enabled, RUNTIME_COMPONENTS must also be enabled.
 #If RUNTIME_COMPONENTS is enabled, DIAGNOSTIC_PORTS is optional.
@@ -27,6 +27,7 @@ run:
 	/p:Configuration=$(MONO_CONFIG) \
 	/p:DeployAndRun=$(DEPLOY_AND_RUN) \
 	/p:ForceAOT=$(AOT) \
+	/p:MonoForceInterpreter=$(INTERP) \
 	/p:UseLLVM=$(USE_LLVM) \
 	/p:RunActivity=false \
 	'/p:RuntimeComponents="$(RUNTIME_COMPONENTS)"' \
diff --git a/src/mono/sample/Directory.Build.targets b/src/mono/sample/Directory.Build.targets
new file mode 100644
index 00000000000000..f72d0bc70d5c1f
--- /dev/null
+++ b/src/mono/sample/Directory.Build.targets
@@ -0,0 +1,8 @@
+<Project>
+  <Import Project="$(RepositoryEngineeringDir)targetingpacks.targets" />
+  <Import Project="..\Directory.Build.targets"/>
+
+  <Target Name="PrintRuntimePackLocation" AfterTargets="UpdateTargetingAndRuntimePack">
+    <Message Text="Used runtime pack: %(ResolvedRuntimePack.PackageDirectory)" Importance="high" />
+  </Target>
+</Project>
diff --git a/src/mono/sample/HelloWorld/HelloWorld.csproj b/src/mono/sample/HelloWorld/HelloWorld.csproj
index 15b0ef8697cbc8..db05235fce86c0 100644
--- a/src/mono/sample/HelloWorld/HelloWorld.csproj
+++ b/src/mono/sample/HelloWorld/HelloWorld.csproj
@@ -2,16 +2,5 @@
   <PropertyGroup>
     <OutputType>Exe</OutputType>
     <TargetFramework>$(NetCoreAppToolCurrent)</TargetFramework>
-    <EnableTargetingPackDownload>false</EnableTargetingPackDownload>
   </PropertyGroup>
-
-  <!-- Redirect 'dotnet publish' to in-tree runtime pack -->
-  <Target Name="TrickRuntimePackLocation" AfterTargets="ProcessFrameworkReferences">
-    <ItemGroup>
-      <RuntimePack>
-        <PackageDirectory>$(ArtifactsBinDir)microsoft.netcore.app.runtime.$(RuntimeIdentifier)\$(Configuration)</PackageDirectory>
-      </RuntimePack>
-    </ItemGroup>
-    <Message Text="Packaged ID: %(RuntimePack.PackageDirectory)" Importance="high" />
-  </Target>
 </Project>
diff --git a/src/mono/sample/iOS/Program.csproj b/src/mono/sample/iOS/Program.csproj
index b9718a6bdb5f24..04b2bde9b0b69a 100644
--- a/src/mono/sample/iOS/Program.csproj
+++ b/src/mono/sample/iOS/Program.csproj
@@ -5,8 +5,6 @@
     <TargetFramework>$(NetCoreAppToolCurrent)</TargetFramework>
     <TargetOS Condition="'$(TargetOS)' == ''">iOS</TargetOS>
     <TargetOS Condition="'$(TargetsiOSSimulator)' == 'true'">iOSSimulator</TargetOS>
-    <MicrosoftNetCoreAppRuntimePackDir>$(ArtifactsBinDir)microsoft.netcore.app.runtime.$(TargetOS.ToLower())-$(TargetArchitecture)\$(Configuration)\runtimes\$(TargetOS.ToLower())-$(TargetArchitecture)\</MicrosoftNetCoreAppRuntimePackDir>
-    <EnableTargetingPackDownload>false</EnableTargetingPackDownload>
     <RuntimeIdentifier>$(TargetOS.ToLower())-$(TargetArchitecture)</RuntimeIdentifier>
     <DefineConstants Condition="'$(ArchiveTests)' == 'true'">$(DefineConstants);CI_TEST</DefineConstants>
   </PropertyGroup>
@@ -21,16 +19,6 @@
     <DevTeamProvisioning Condition="'$(TargetOS)' == 'MacCatalyst' and '$(DevTeamProvisioning)' == ''">adhoc</DevTeamProvisioning>
   </PropertyGroup>
 
-  <!-- Redirect 'dotnet publish' to in-tree runtime pack -->
-  <Target Name="TrickRuntimePackLocation" AfterTargets="ProcessFrameworkReferences">
-    <ItemGroup>
-      <RuntimePack>
-        <PackageDirectory>$(ArtifactsBinDir)microsoft.netcore.app.runtime.$(RuntimeIdentifier)\$(Configuration)</PackageDirectory>
-      </RuntimePack>
-    </ItemGroup>
-    <Message Text="Packaged ID: %(RuntimePack.PackageDirectory)" Importance="high" />
-  </Target>
-
   <Import Project="$(RepoTasksDir)AotCompilerTask\MonoAOTCompiler.props" />
   <UsingTask TaskName="AppleAppBuilderTask"
              AssemblyFile="$(AppleAppBuilderTasksAssemblyPath)" />
@@ -64,7 +52,7 @@
 
     <MonoAOTCompiler
         Condition="'$(RunAOTCompilation)' == 'true'"
-        CompilerBinaryPath="$(MonoAotCrossCompilerPath)"
+        CompilerBinaryPath="@(MonoAotCrossCompiler->WithMetadataValue('RuntimeIdentifier','$(TargetOS.ToLowerInvariant())-$(TargetArchitecture.ToLowerInvariant())'))"
         Mode="$(AOTMode)"
         OutputType="AsmOnly"
         Assemblies="@(AotInputAssemblies)"
@@ -80,7 +68,7 @@
         TargetOS="$(TargetOS)"
         Arch="$(TargetArchitecture)"
         ProjectName="HelloiOS"
-        MonoRuntimeHeaders="$(MicrosoftNetCoreAppRuntimePackDir)native\include\mono-2.0"
+        MonoRuntimeHeaders="$(MicrosoftNetCoreAppRuntimePackDir)runtimes\$(TargetOS.ToLower())-$(TargetArchitecture)\native\include\mono-2.0"
         Assemblies="@(BundleAssemblies)"
         MainLibraryFileName="Program.dll"
         GenerateXcodeProject="True"
diff --git a/src/mono/sample/mbr/DeltaHelper/DeltaHelper.csproj b/src/mono/sample/mbr/DeltaHelper/DeltaHelper.csproj
index 47bb08e4c66e96..6a27072a4b5fed 100644
--- a/src/mono/sample/mbr/DeltaHelper/DeltaHelper.csproj
+++ b/src/mono/sample/mbr/DeltaHelper/DeltaHelper.csproj
@@ -1,6 +1,5 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <TargetFramework>$(NetCoreAppToolCurrent)</TargetFramework>
-    <EnableTargetingPackDownload>false</EnableTargetingPackDownload>
   </PropertyGroup>
 </Project>
diff --git a/src/mono/sample/mbr/README.md b/src/mono/sample/mbr/README.md
index 6e78382e103874..f95030266bb6e9 100644
--- a/src/mono/sample/mbr/README.md
+++ b/src/mono/sample/mbr/README.md
@@ -3,26 +3,16 @@
 
 ## Prerequisites
 
-To run the tests you will need to:
-
-1. Build a runtime with the `MonoMetadataUpdate` property set to true: `/p:MonoMetadataUpdate=true`.
-2. Put the [hotreload-delta-gen](https://github.com/dotnet/hotreload-utils/tree/main/src/hotreload-delta-gen) command line tool somewhere on your `PATH`.
-
-   Build the tool with `dotnet publish --self-contained -r <RID>` and then add the `publish/hotreload-delta-gen` directory to your `PATH`.
-   If you don't want to add it to your `PATH`, you can set the `HotReloadDeltaGenFullPath` msbuild property in `DeltaHelper.targets` to the full path name of the published executable.
-
-The tool, runtime changes and samples should work on Mac and Linux.  Windows might work, but it hasn't been tested.
+To run the tests you will need to build a Mono runtime with the `hot_reload` component.
 
 ## Building
 
-Build the runtime with the `/p:MonoMetadataUpdate=true` option.
-
 Both Debug and Release configurations should work.
 
 For desktop:
 
 ```console
-build.sh -s Mono+Libs /p:MonoMetadataUpdate=true
+build.sh -s Mono+Libs
 ```
 
 
diff --git a/src/mono/sample/mbr/apple/AppleDelta.csproj b/src/mono/sample/mbr/apple/AppleDelta.csproj
index 2b040dab21f005..af4ec2b324a10a 100644
--- a/src/mono/sample/mbr/apple/AppleDelta.csproj
+++ b/src/mono/sample/mbr/apple/AppleDelta.csproj
@@ -3,8 +3,6 @@
     <OutputType>Exe</OutputType>
     <OutputPath>bin</OutputPath>
     <TargetFramework>$(NetCoreAppToolCurrent)</TargetFramework>
-    <MicrosoftNetCoreAppRuntimePackDir>$(ArtifactsBinDir)microsoft.netcore.app.runtime.$(TargetOS.ToLower())-$(TargetArchitecture)\$(Configuration)\runtimes\$(TargetOS.ToLower())-$(TargetArchitecture)\</MicrosoftNetCoreAppRuntimePackDir>
-    <EnableTargetingPackDownload>false</EnableTargetingPackDownload>
     <RuntimeIdentifier>$(TargetOS.ToLower())-$(TargetArchitecture)</RuntimeIdentifier>
     <DefineConstants Condition="'$(ArchiveTests)' == 'true'">$(DefineConstants);CI_TEST</DefineConstants>
     <MonoForceInterpreter>true</MonoForceInterpreter>
@@ -29,16 +27,6 @@
     <DevTeamProvisioning Condition="'$(TargetOS)' == 'MacCatalyst' and '$(DevTeamProvisioning)' == ''">-</DevTeamProvisioning>
   </PropertyGroup>
 
-  <!-- Redirect 'dotnet publish' to in-tree runtime pack -->
-  <Target Name="TrickRuntimePackLocation" AfterTargets="ProcessFrameworkReferences">
-    <ItemGroup>
-      <RuntimePack>
-        <PackageDirectory>$(ArtifactsBinDir)microsoft.netcore.app.runtime.$(RuntimeIdentifier)\$(Configuration)</PackageDirectory>
-      </RuntimePack>
-    </ItemGroup>
-    <Message Text="Packaged ID: %(RuntimePack.PackageDirectory)" Importance="high" />
-  </Target>
-
   <Import Project="$(RepoTasksDir)AotCompilerTask\MonoAOTCompiler.props" />
   <UsingTask TaskName="AppleAppBuilderTask"
              AssemblyFile="$(AppleAppBuilderTasksAssemblyPath)" />
@@ -63,7 +51,7 @@
         TargetOS="$(TargetOS)"
         Arch="$(TargetArchitecture)"
         ProjectName="AppleDelta"
-        MonoRuntimeHeaders="$(MicrosoftNetCoreAppRuntimePackDir)native\include\mono-2.0"
+        MonoRuntimeHeaders="$(MicrosoftNetCoreAppRuntimePackDir)runtimes\$(TargetOS.ToLower())-$(TargetArchitecture)\native\include\mono-2.0"
         Assemblies="@(BundleAssemblies)"
 	NativeMainSource="$(MSBuildThisFileDirectory)\main.m"
         MainLibraryFileName="AppleDelta.dll"
diff --git a/src/mono/sample/mbr/browser/index.html b/src/mono/sample/mbr/browser/index.html
index 472cf5f29ea053..eb19b7bb2f5954 100644
--- a/src/mono/sample/mbr/browser/index.html
+++ b/src/mono/sample/mbr/browser/index.html
@@ -29,7 +29,6 @@ <h3 id="header">Wasm Browser Sample</h3>
         },
       };
     </script>
-    <script type="text/javascript" src="mono-config.js"></script>
     <script type="text/javascript" src="runtime.js"></script>
 
     <script defer src="dotnet.js"></script>
diff --git a/src/mono/sample/mbr/browser/runtime.js b/src/mono/sample/mbr/browser/runtime.js
index 0856b8d0e03033..32918aa573a44a 100644
--- a/src/mono/sample/mbr/browser/runtime.js
+++ b/src/mono/sample/mbr/browser/runtime.js
@@ -2,17 +2,29 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 var Module = { 
+    config: null,
+
+    preInit: async function() {
+        Module.config = await MONO.mono_wasm_load_config("./mono-config.json");
+    },
+
+    // Called when the runtime is initialized and wasm is ready
     onRuntimeInitialized: function () {
-        config.loaded_cb = function () {
+        if (!Module.config || Module.config.error) {
+            console.log("An error occured while loading the config file");
+            return;
+        }
+
+        Module.config.loaded_cb = function () {
             App.init ();
         };
-        config.environment_variables = {
+        Module.config.environment_variables = {
             "DOTNET_MODIFIABLE_ASSEMBLIES": "debug"
         };
-        config.fetch_file_cb = function (asset) {
+        Module.config.fetch_file_cb = function (asset) {
             return fetch (asset, { credentials: 'same-origin' });
         }
 
-        MONO.mono_load_runtime_and_bcl_args (config);
+        MONO.mono_load_runtime_and_bcl_args (Module.config);
     },
 };
diff --git a/src/mono/sample/mbr/console/ConsoleDelta.csproj b/src/mono/sample/mbr/console/ConsoleDelta.csproj
index 04059b0272b7f6..eb70ee9df2469d 100644
--- a/src/mono/sample/mbr/console/ConsoleDelta.csproj
+++ b/src/mono/sample/mbr/console/ConsoleDelta.csproj
@@ -2,14 +2,23 @@
   <PropertyGroup>
     <OutputType>Exe</OutputType>
     <TargetFramework>$(NetCoreAppToolCurrent)</TargetFramework>
-    <EnableTargetingPackDownload>false</EnableTargetingPackDownload>
     <EnableDefaultCompileItems>false</EnableDefaultCompileItems>
   </PropertyGroup>
 
+  <PropertyGroup>
+    <!-- to call AsssemblyExtensions.ApplyUpdate we need Optimize=false, EmitDebugInformation=true in all configurations -->
+    <Optimize>false</Optimize>
+    <EmitDebugInformation>true</EmitDebugInformation>
+  </PropertyGroup>
+
   <ItemGroup>
     <ProjectReference Include="..\DeltaHelper\DeltaHelper.csproj" />
   </ItemGroup>
 
+  <ItemGroup>
+    <PackageReference Include="Microsoft.DotNet.HotReload.Utils.Generator.BuildTool" Version="$(MicrosoftDotNetHotReloadUtilsGeneratorBuildToolVersion)" />
+  </ItemGroup>
+
   <ItemGroup>
     <Compile Include="Program.cs" />
     <Compile Include="TestClass.cs" />
@@ -18,21 +27,16 @@
 
   <PropertyGroup>
     <DeltaScript>deltascript.json</DeltaScript>
-    <DeltaCount>1</DeltaCount>
   </PropertyGroup>
 
-  <!-- Redirect 'dotnet publish' to in-tree runtime pack -->
-  <Target Name="TrickRuntimePackLocation" AfterTargets="ProcessFrameworkReferences">
-    <ItemGroup>
-      <RuntimePack>
-        <PackageDirectory>$(ArtifactsBinDir)microsoft.netcore.app.runtime.$(RuntimeIdentifier)\$(BuiltRuntimeConfiguration)</PackageDirectory>
-      </RuntimePack>
-    </ItemGroup>
-    <Message Text="Packaged ID: %(RuntimePack.PackageDirectory)" Importance="high" />
-  </Target>
+  <PropertyGroup Condition="'$(BuiltRuntimeConfiguration)' != ''">
+    <HotReloadDeltaGeneratorExtraArgs>$(HotReloadDeltaGeneratorExtraArgs) -p:BuiltRuntimeConfiguration=$(BuiltRuntimeConfiguration)</HotReloadDeltaGeneratorExtraArgs>
+  </PropertyGroup>
 
+  <Target Name="CodeSignIfNeeded" AfterTargets="Publish" Condition="'$(RuntimeIdentifier)' == 'osx-arm64'">
+    <Message Importance="High" Text="Running codesign -s - -f $(PublishDir)/$(MSBuildProjectName)" />
+    <Exec Command="codesign -s - -f &quot;$(PublishDir)$(MSBuildProjectName)&quot;" />
+  </Target>
 
-  <!-- Set RoslynILDiffFullPath property to the path of roslynildiff -->
-  <Import Project="..\DeltaHelper.targets" />
 
 </Project>
diff --git a/src/mono/sample/wasm/browser-bench/Makefile b/src/mono/sample/wasm/browser-bench/Makefile
index 253163451a4912..d66e71dd077e9e 100644
--- a/src/mono/sample/wasm/browser-bench/Makefile
+++ b/src/mono/sample/wasm/browser-bench/Makefile
@@ -6,6 +6,6 @@ ifneq ($(AOT),)
 override MSBUILD_ARGS+=/p:RunAOTCompilation=true
 endif
 
-PROJECT_NAME=Wasm.Browser.Sample.Bench.csproj
+PROJECT_NAME=Wasm.Browser.Bench.Sample.csproj
 
 run: run-browser
diff --git a/src/mono/sample/wasm/browser-bench/Wasm.Browser.Sample.Bench.csproj b/src/mono/sample/wasm/browser-bench/Wasm.Browser.Bench.Sample.csproj
similarity index 76%
rename from src/mono/sample/wasm/browser-bench/Wasm.Browser.Sample.Bench.csproj
rename to src/mono/sample/wasm/browser-bench/Wasm.Browser.Bench.Sample.csproj
index e25569e8a03adc..684540aa466441 100644
--- a/src/mono/sample/wasm/browser-bench/Wasm.Browser.Sample.Bench.csproj
+++ b/src/mono/sample/wasm/browser-bench/Wasm.Browser.Bench.Sample.csproj
@@ -2,6 +2,7 @@
   <PropertyGroup>
     <WasmCopyAppZipToHelixTestDir Condition="'$(ArchiveTests)' == 'true'">true</WasmCopyAppZipToHelixTestDir>
     <WasmMainJSPath>runtime.js</WasmMainJSPath>
+    <SuppressTrimAnalysisWarnings>true</SuppressTrimAnalysisWarnings>
   </PropertyGroup>
 
   <ItemGroup>
@@ -9,7 +10,7 @@
   </ItemGroup>
 
   <PropertyGroup>
-    <_SampleProject>Wasm.Browser.Sample.Bench.csproj</_SampleProject>
+    <_SampleProject>Wasm.Browser.Bench.Sample.csproj</_SampleProject>
   </PropertyGroup>
 
   <Target Name="RunSample" DependsOnTargets="RunSampleWithBrowser" />
diff --git a/src/mono/sample/wasm/browser-bench/index.html b/src/mono/sample/wasm/browser-bench/index.html
index eebbae65eb1052..5c5271954f1c2c 100644
--- a/src/mono/sample/wasm/browser-bench/index.html
+++ b/src/mono/sample/wasm/browser-bench/index.html
@@ -35,7 +35,7 @@ <h3 id="header">Wasm Browser Sample - Simple Benchmark</h3>
       };
 
       function yieldBench () {
-        let ret = BINDING.call_static_method("[Wasm.Browser.Sample.Bench] Sample.Test:RunBenchmark", []);
+        let ret = BINDING.call_static_method("[Wasm.Browser.Bench.Sample] Sample.Test:RunBenchmark", []);
         document.getElementById("out").innerHTML += ret;
         if (ret.length > 0) {
           document.getElementById("out").innerHTML += "<br>";
@@ -51,7 +51,6 @@ <h3 id="header">Wasm Browser Sample - Simple Benchmark</h3>
         }
       };
     </script>
-    <script type="text/javascript" src="mono-config.js"></script>
     <script type="text/javascript" src="runtime.js"></script>
 
     <script defer src="dotnet.js"></script>
diff --git a/src/mono/sample/wasm/browser-bench/runtime.js b/src/mono/sample/wasm/browser-bench/runtime.js
index a39b0b97b14901..60c383d13cb524 100644
--- a/src/mono/sample/wasm/browser-bench/runtime.js
+++ b/src/mono/sample/wasm/browser-bench/runtime.js
@@ -1,9 +1,20 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
-
 var Module = { 
+    config: null,
+
+    preInit: async function() {
+        Module.config = await MONO.mono_wasm_load_config("./mono-config.json");
+    },
+
+    // Called when the runtime is initialized and wasm is ready
     onRuntimeInitialized: function () {
-        config.loaded_cb = function () {
+        if (!Module.config || Module.config.error) {
+            console.log("An error occured while loading the config file");
+            return;
+        }
+
+        Module.config.loaded_cb = function () {
             try {
                 App.init ();
             } catch (error) {
@@ -11,13 +22,21 @@ var Module = {
                 throw (error);
             }
         };
-        config.fetch_file_cb = function (asset) {
+        Module.config.fetch_file_cb = function (asset) {
             return fetch (asset, { credentials: 'same-origin' });
         }
 
+        if (Module.config.enable_profiler)
+        {
+            Module.config.aot_profiler_options = {
+                write_at:"Sample.Test::StopProfile",
+                send_to: "System.Runtime.InteropServices.JavaScript.Runtime::DumpAotProfileData"
+            }
+        }
+
         try
         {
-            MONO.mono_load_runtime_and_bcl_args (config);
+            MONO.mono_load_runtime_and_bcl_args (Module.config);
         } catch (error) {
             test_exit(1);
             throw(error);
diff --git a/src/mono/sample/wasm/browser-profile/index.html b/src/mono/sample/wasm/browser-profile/index.html
index 50eb0ff28c2efe..de4a5599e94ad0 100644
--- a/src/mono/sample/wasm/browser-profile/index.html
+++ b/src/mono/sample/wasm/browser-profile/index.html
@@ -10,67 +10,8 @@
   <body>
     <h3 id="header">Wasm Browser Sample</h3>
     Result from Sample.Test.TestMeaning: <span id="out"></span>
-    <script type='text/javascript'>
-      var is_testing = false;
-      var onLoad = function() {
-        var url = new URL(decodeURI(window.location));
-        let args = url.searchParams.getAll('arg');
-        is_testing = args !== undefined && (args.find(arg => arg == '--testing') !== undefined);
-      };
 
-      var test_exit = function(exit_code)
-      {
-        if (!is_testing) {
-          console.log(`test_exit: ${exit_code}`);
-          return;
-        }
-
-        /* Set result in a tests_done element, to be read by xharness */
-        var tests_done_elem = document.createElement("label");
-        tests_done_elem.id = "tests_done";
-        tests_done_elem.innerHTML = exit_code.toString();
-        document.body.appendChild(tests_done_elem);
-
-        console.log(`WASM EXIT ${exit_code}`);
-      };
-
-      var App = {
-        init: function () {
-          var ret = BINDING.call_static_method("[Wasm.BrowserProfile.Sample] Sample.Test:TestMeaning", []);
-          document.getElementById("out").innerHTML = ret;
-          console.log ("ready");
-
-          if (is_testing)
-          {
-            console.debug(`ret: ${ret}`);
-            let exit_code = ret == 42 ? 0 : 1;
-            test_exit(exit_code);
-          }
-
-          if (config.enable_profiler) {
-            BINDING.call_static_method("[Wasm.BrowserProfile.Sample] Sample.Test:StopProfile", []);
-            saveProfile();
-          }
-        },
-      };
-
-      function saveProfile() {
-        var a = document.createElement('a');
-        var blob = new Blob([Module.aot_profile_data]);
-        a.href = URL.createObjectURL(blob);
-        a.download = "data.aotprofile";
-        // Append anchor to body.
-        document.body.appendChild(a);
-        a.click();
-
-        // Remove anchor from body
-        document.body.removeChild(a);
-      }
-
-    </script>
-    <script type="text/javascript" src="mono-config.js"></script>
     <script type="text/javascript" src="runtime.js"></script>
-
     <script defer src="dotnet.js"></script>
 
   </body>
diff --git a/src/mono/sample/wasm/browser-profile/runtime.js b/src/mono/sample/wasm/browser-profile/runtime.js
index 1ce1c0b736034c..2c83ff54ef93d0 100644
--- a/src/mono/sample/wasm/browser-profile/runtime.js
+++ b/src/mono/sample/wasm/browser-profile/runtime.js
@@ -1,22 +1,35 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
-var Module = {
+var Module = { 
+    is_testing: false,
+    config: null,
+
+    preInit: async function() {
+        Module.config = await MONO.mono_wasm_load_config("./mono-config.json");
+    },
+
+    // Called when the runtime is initialized and wasm is ready
     onRuntimeInitialized: function () {
-        config.loaded_cb = function () {
+        if (!Module.config || Module.config.error) {
+            console.log("An error occured while loading the config file");
+            return;
+        }
+
+        Module.config.loaded_cb = function () {
             try {
-                App.init ();
+                Module.init();
             } catch (error) {
-                test_exit(1);
+                Module.test_exit(1);
                 throw (error);
             }
         };
-        config.fetch_file_cb = function (asset) {
+        Module.config.fetch_file_cb = function (asset) {
             return fetch (asset, { credentials: 'same-origin' });
         }
 
-        if (config.enable_profiler)
+        if (Module.config.enable_profiler)
         {
-            config.aot_profiler_options = {
+            Module.config.aot_profiler_options = {
                 write_at:"Sample.Test::StopProfile",
                 send_to: "System.Runtime.InteropServices.JavaScript.Runtime::DumpAotProfileData"
             }
@@ -24,10 +37,63 @@ var Module = {
 
         try
         {
-            MONO.mono_load_runtime_and_bcl_args (config);
+            MONO.mono_load_runtime_and_bcl_args (Module.config);
         } catch (error) {
-            test_exit(1);
+            Module.test_exit(1);
             throw(error);
         }
+    },
+
+    init: function () {
+        console.log("not ready yet")
+        var ret = BINDING.call_static_method("[Wasm.BrowserProfile.Sample] Sample.Test:TestMeaning", []);
+        document.getElementById("out").innerHTML = ret;
+        console.log ("ready");
+
+        if (Module.is_testing)
+        {
+          console.debug(`ret: ${ret}`);
+          let exit_code = ret == 42 ? 0 : 1;
+          Module.test_exit(exit_code);
+        }
+
+        if (Module.config.enable_profiler) {
+          BINDING.call_static_method("[Wasm.BrowserProfile.Sample] Sample.Test:StopProfile", []);
+          Module.saveProfile();
+        }
+    },
+
+    onLoad: function() {
+        var url = new URL(decodeURI(window.location));
+        let args = url.searchParams.getAll('arg');
+        Module.is_testing = args !== undefined && (args.find(arg => arg == '--testing') !== undefined);
+    },
+  
+    test_exit: function(exit_code) {
+        if (!Module.is_testing) {
+            console.log(`test_exit: ${exit_code}`);
+            return;
+        }
+
+        /* Set result in a tests_done element, to be read by xharness */
+        var tests_done_elem = document.createElement("label");
+        tests_done_elem.id = "tests_done";
+        tests_done_elem.innerHTML = exit_code.toString();
+        document.body.appendChild(tests_done_elem);
+
+        console.log(`WASM EXIT ${exit_code}`);
+    },
+  
+    saveProfile: function () {
+        var a = document.createElement('a');
+        var blob = new Blob([Module.aot_profile_data]);
+        a.href = URL.createObjectURL(blob);
+        a.download = "data.aotprofile";
+        // Append anchor to body.
+        document.body.appendChild(a);
+        a.click();
+
+        // Remove anchor from body
+        document.body.removeChild(a);
     }
-};
\ No newline at end of file
+};
diff --git a/src/mono/sample/wasm/browser/Wasm.Browser.Sample.csproj b/src/mono/sample/wasm/browser/Wasm.Browser.Sample.csproj
index 2b05836627673c..15386dece90a91 100644
--- a/src/mono/sample/wasm/browser/Wasm.Browser.Sample.csproj
+++ b/src/mono/sample/wasm/browser/Wasm.Browser.Sample.csproj
@@ -1,7 +1,11 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
+    <Configuration>Debug</Configuration>
     <WasmCopyAppZipToHelixTestDir Condition="'$(ArchiveTests)' == 'true'">true</WasmCopyAppZipToHelixTestDir>
     <WasmMainJSPath>runtime.js</WasmMainJSPath>
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>embedded</DebugType>
+    <WasmDebugLevel>1</WasmDebugLevel>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/src/mono/sample/wasm/browser/index.html b/src/mono/sample/wasm/browser/index.html
index bd8e5015a0ee5f..5f170bb38e7bcb 100644
--- a/src/mono/sample/wasm/browser/index.html
+++ b/src/mono/sample/wasm/browser/index.html
@@ -48,7 +48,6 @@ <h3 id="header">Wasm Browser Sample</h3>
         },
       };
     </script>
-    <script type="text/javascript" src="mono-config.js"></script>
     <script type="text/javascript" src="runtime.js"></script>
 
     <script defer src="dotnet.js"></script>
diff --git a/src/mono/sample/wasm/browser/runtime.js b/src/mono/sample/wasm/browser/runtime.js
index a39b0b97b14901..e97feef745a95d 100644
--- a/src/mono/sample/wasm/browser/runtime.js
+++ b/src/mono/sample/wasm/browser/runtime.js
@@ -2,8 +2,21 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 var Module = { 
+
+    config: null,
+
+    preInit: async function() {
+        Module.config = await MONO.mono_wasm_load_config("./mono-config.json");
+    },
+
+    // Called when the runtime is initialized and wasm is ready
     onRuntimeInitialized: function () {
-        config.loaded_cb = function () {
+        if (!Module.config || Module.config.error) {
+            console.log("No config found");
+            return;
+        }
+
+        Module.config.loaded_cb = function () {
             try {
                 App.init ();
             } catch (error) {
@@ -11,13 +24,13 @@ var Module = {
                 throw (error);
             }
         };
-        config.fetch_file_cb = function (asset) {
+        Module.config.fetch_file_cb = function (asset) {
             return fetch (asset, { credentials: 'same-origin' });
         }
 
         try
         {
-            MONO.mono_load_runtime_and_bcl_args (config);
+            MONO.mono_load_runtime_and_bcl_args (Module.config);
         } catch (error) {
             test_exit(1);
             throw(error);
diff --git a/src/mono/wasm/README.md b/src/mono/wasm/README.md
index 0a56117b3e5c14..a44edd53dc3dd1 100644
--- a/src/mono/wasm/README.md
+++ b/src/mono/wasm/README.md
@@ -2,7 +2,7 @@
 
 This depends on `emsdk` to be installed.
 
-## emsdk
+## emsdk on mac
 
 * You can run `make provision-wasm`, which will install it to `$reporoot/src/mono/wasm/emsdk`.
 Note: Irrespective of `$(EMSDK_PATH)`'s value, `provision-wasm` will always install into `$reporoot/src/mono/wasm/emsdk`.
@@ -21,7 +21,9 @@ Make sure to set `EMSDK_PATH` variable, whenever building, or running tests for
 
 Windows build [requirements](https://github.com/dotnet/runtime/blob/main/docs/workflow/requirements/windows-requirements.md)
 
-## Building
+If `EMSDK_PATH` is not set, the `emsdk` should be provisioned automatically during the build.
+
+## Building on mac
 
 * To build the whole thing, with libraries:
 
@@ -33,7 +35,7 @@ Windows build [requirements](https://github.com/dotnet/runtime/blob/main/docs/wo
 
 ### Note: Additional msbuild arguments can be passed with: `make build-all MSBUILD_ARGS="/p:a=b"`
 
-### Windows
+### Bulding on windows
 
 * To build everything
 
@@ -103,7 +105,7 @@ Examples of running tests for individual libraries:
 `.\dotnet.cmd build /t:Test /p:TargetOS=Browser src\libraries\System.Collections.Concurrent\tests`
 `.\dotnet.cmd build /t:Test /p:TargetOS=Browser /p:JSEngine="SpiderMonkey" src\libraries\System.Text.Json\tests`
 
-### Browser tests
+### Browser tests on mac
 
 Or they can be run with a browser (Chrome):
 
@@ -125,7 +127,7 @@ The wrapper script used to actually run these tests, accepts:
 
 ### Note: Additional msbuild arguments can be passed with: `make ..  MSBUILD_ARGS="/p:a=b"`
 
-## Debugger tests
+## Debugger tests on mac
 
 Debugger tests need `Google Chrome` to be installed.
 
diff --git a/src/mono/wasm/build/WasmApp.InTree.props b/src/mono/wasm/build/WasmApp.InTree.props
index 42b7574251468d..e5968f1320a949 100644
--- a/src/mono/wasm/build/WasmApp.InTree.props
+++ b/src/mono/wasm/build/WasmApp.InTree.props
@@ -6,7 +6,6 @@
     <Platform>AnyCPU</Platform>
     <EnableTargetingPackDownload>false</EnableTargetingPackDownload>
     <TargetFramework>$(NetCoreAppToolCurrent)</TargetFramework>
-    <MicrosoftNetCoreAppRuntimePackRidDir>$([MSBuild]::NormalizeDirectory($(ArtifactsBinDir), 'microsoft.netcore.app.runtime.browser-wasm', $(Configuration), 'runtimes', 'browser-wasm'))</MicrosoftNetCoreAppRuntimePackRidDir>
     <EMSDK_PATH Condition="'$(EMSDK_PATH)' == '' and '$(MonoProjectRoot)' != ''">$([MSBuild]::NormalizeDirectory($(MonoProjectRoot), 'wasm', 'emsdk'))</EMSDK_PATH>
     <RunAOTCompilation Condition="'$(RunAOTCompilation)' == ''">false</RunAOTCompilation>
     <PublishTrimmed>true</PublishTrimmed>
diff --git a/src/mono/wasm/build/WasmApp.LocalBuild.props b/src/mono/wasm/build/WasmApp.LocalBuild.props
index f72076b867222f..01003f59172fa3 100644
--- a/src/mono/wasm/build/WasmApp.LocalBuild.props
+++ b/src/mono/wasm/build/WasmApp.LocalBuild.props
@@ -36,8 +36,8 @@
     <MonoAOTCompilerDir>$([MSBuild]::NormalizeDirectory('$(ArtifactsBinDir)', 'MonoAOTCompiler', 'Debug', '$(_NetCoreAppToolCurrent)'))</MonoAOTCompilerDir>
 
     <MonoArtifactsPath>$([MSBuild]::NormalizeDirectory('$(ArtifactsBinDir)', 'mono', '$(TargetOS).$(TargetArchitecture).$(RuntimeConfig)'))</MonoArtifactsPath>
-    <MonoAotCrossCompilerPath>$([MSBuild]::NormalizePath($(MonoArtifactsPath), 'cross', '$(TargetOS.ToLowerInvariant())-$(TargetArchitecture.ToLowerInvariant())', 'mono-aot-cross'))</MonoAotCrossCompilerPath>
-    <MonoAotCrossCompilerPath Condition="$([MSBuild]::IsOSPlatform('WINDOWS'))">$(MonoAotCrossCompilerPath).exe</MonoAotCrossCompilerPath>
+    <_MonoAotCrossCompilerPath>$([MSBuild]::NormalizePath($(MonoArtifactsPath), 'cross', '$(TargetOS.ToLowerInvariant())-$(TargetArchitecture.ToLowerInvariant())', 'mono-aot-cross'))</_MonoAotCrossCompilerPath>
+    <_MonoAotCrossCompilerPath Condition="$([MSBuild]::IsOSPlatform('WINDOWS'))">$(_MonoAotCrossCompilerPath).exe</_MonoAotCrossCompilerPath>
   </PropertyGroup>
 
   <PropertyGroup Condition="'$(RuntimeSrcDir)' == '' and '$(WasmBuildSupportDir)' != ''">
@@ -48,10 +48,14 @@
     <WasmAppBuilderDir>$([MSBuild]::NormalizeDirectory($(BuildBaseDir), 'WasmAppBuilder'))</WasmAppBuilderDir>
     <WasmBuildTasksDir>$([MSBuild]::NormalizeDirectory($(BuildBaseDir), 'WasmBuildTasks'))</WasmBuildTasksDir>
 
-    <MonoAotCrossCompilerPath>$([MSBuild]::NormalizePath($(BuildBaseDir), 'cross', 'mono-aot-cross'))</MonoAotCrossCompilerPath>
-    <MonoAotCrossCompilerPath Condition="$([MSBuild]::IsOSPlatform('WINDOWS'))">$(MonoAotCrossCompilerPath).exe</MonoAotCrossCompilerPath>
+    <_MonoAotCrossCompilerPath>$([MSBuild]::NormalizePath($(BuildBaseDir), 'cross', 'mono-aot-cross'))</_MonoAotCrossCompilerPath>
+    <_MonoAotCrossCompilerPath Condition="$([MSBuild]::IsOSPlatform('WINDOWS'))">$(_MonoAotCrossCompilerPath).exe</_MonoAotCrossCompilerPath>
   </PropertyGroup>
 
+  <ItemGroup>
+    <MonoAotCrossCompiler Include="$(_MonoAotCrossCompilerPath)" RuntimeIdentifier="$(TargetOS.ToLowerInvariant())-$(TargetArchitecture.ToLowerInvariant())" />
+  </ItemGroup>
+
   <PropertyGroup>
     <MicrosoftNetCoreAppRuntimePackRidDir>$([MSBuild]::NormalizeDirectory($(MicrosoftNetCoreAppRuntimePackLocationToUse), 'runtimes', 'browser-wasm'))</MicrosoftNetCoreAppRuntimePackRidDir>
     <WasmAppBuilderTasksAssemblyPath>$([MSBuild]::NormalizePath('$(WasmAppBuilderDir)', 'WasmAppBuilder.dll'))</WasmAppBuilderTasksAssemblyPath>
diff --git a/src/mono/wasm/build/WasmApp.Native.targets b/src/mono/wasm/build/WasmApp.Native.targets
index 5c4ef04bf95720..c034763ca0f258 100644
--- a/src/mono/wasm/build/WasmApp.Native.targets
+++ b/src/mono/wasm/build/WasmApp.Native.targets
@@ -3,6 +3,7 @@
 
   <UsingTask TaskName="PInvokeTableGenerator" AssemblyFile="$(WasmAppBuilderTasksAssemblyPath)" />
   <UsingTask TaskName="IcallTableGenerator" AssemblyFile="$(WasmAppBuilderTasksAssemblyPath)" />
+  <UsingTask TaskName="Microsoft.WebAssembly.Build.Tasks.EmccCompile" AssemblyFile="$(WasmAppBuilderTasksAssemblyPath)" />
 
   <PropertyGroup>
     <_WasmBuildNativeCoreDependsOn>
@@ -150,6 +151,7 @@
            Text="$(_EMSDKMissingErrorMessage) Emscripten SDK is required for building native files." />
 
     <PropertyGroup>
+      <_MonoAotCrossCompilerPath>@(MonoAotCrossCompiler->WithMetadataValue('RuntimeIdentifier','browser-wasm'))</_MonoAotCrossCompilerPath>
       <_EmccDefaultFlagsRsp>$([MSBuild]::NormalizePath($(_WasmRuntimePackSrcDir), 'emcc-default.rsp'))</_EmccDefaultFlagsRsp>
       <WasmNativeStrip Condition="'$(WasmNativeStrip)' == ''">true</WasmNativeStrip>
       <WasmNativeDebugSymbols Condition="'$(WasmNativeDebugSymbols)' == ''">true</WasmNativeDebugSymbols>
@@ -164,7 +166,7 @@
       <_EmccOptimizationFlagDefault Condition="'$(_EmccOptimizationFlagDefault)' == ''">-Oz</_EmccOptimizationFlagDefault>
 
       <EmccCompileOptimizationFlag Condition="'$(EmccCompileOptimizationFlag)' == ''">$(_EmccOptimizationFlagDefault)</EmccCompileOptimizationFlag>
-      <EmccLinkOptimizationFlag    Condition="'$(EmccLinkOptimizationFlag)' == ''"   >$(_EmccOptimizationFlagDefault)</EmccLinkOptimizationFlag>
+      <EmccLinkOptimizationFlag    Condition="'$(EmccLinkOptimizationFlag)' == ''"   >-O0</EmccLinkOptimizationFlag>
     </PropertyGroup>
 
     <ItemGroup>
@@ -172,10 +174,6 @@
       <_EmccCommonFlags Include="$(EmccFlags)" />
       <_EmccCommonFlags Include="-s DISABLE_EXCEPTION_CATCHING=0" />
       <_EmccCommonFlags Include="-g"                                Condition="'$(WasmNativeStrip)' == 'false'" />
-      <_EmccCommonFlags Include="-DENABLE_AOT=1"                    Condition="'$(RunAOTCompilation)' == 'true'" />
-      <_EmccCommonFlags Include="-DDRIVER_GEN=1"                    Condition="'$(RunAOTCompilation)' == 'true'" />
-      <_EmccCommonFlags Include="-DINVARIANT_GLOBALIZATION=1"       Condition="'$(InvariantGlobalization)' == 'true'" />
-      <_EmccCommonFlags Include="-DLINK_ICALLS=1"                   Condition="'$(WasmLinkIcalls)' == 'true'" />
       <_EmccCommonFlags Include="-v"                                Condition="'$(EmccVerbose)' != 'false'" />
     </ItemGroup>
 
@@ -185,11 +183,7 @@
    </PropertyGroup>
 
    <ItemGroup>
-     <_WasmObjectsToBuild Include="$(_WasmRuntimePackSrcDir)\*.c" />
-     <_WasmObjectsToBuild OutputPath="$(_WasmIntermediateOutputPath)%(FileName).o" />
-
      <_DotnetJSSrcFile Include="$(_WasmRuntimePackSrcDir)\*.js" />
-     <_WasmPInvokeModules Include="%(_WasmNativeFileForLinking.FileName)" />
    </ItemGroup>
   </Target>
 
@@ -207,10 +201,10 @@
   </Target>
 
   <Target Name="_GenerateICallTable" Condition="'$(WasmLinkIcalls)' == 'true'">
-    <Error Condition="'$(MonoAotCrossCompilerPath)' == '' or !Exists('$(MonoAotCrossCompilerPath)')"
-           Text="Could not find AOT cross compiler at %24(MonoAotCrossCompilerPath)=$(MonoAotCrossCompilerPath)" />
+    <Error Condition="'$(_MonoAotCrossCompilerPath)' == '' or !Exists('$(_MonoAotCrossCompilerPath)')"
+           Text="Could not find AOT cross compiler at %24(_MonoAotCrossCompilerPath)=$(_MonoAotCrossCompilerPath)" />
 
-    <Exec Command='"$(MonoAotCrossCompilerPath)" --print-icall-table > "$(_WasmRuntimeICallTablePath)"' />
+    <Exec Command='"$(_MonoAotCrossCompilerPath)" --print-icall-table > "$(_WasmRuntimeICallTablePath)"' />
     <IcallTableGenerator
       RuntimeIcallTableFile="$(_WasmRuntimeICallTablePath)"
       Assemblies="@(_WasmAssembliesInternal)"
@@ -226,54 +220,84 @@
       <!-- Adding optimization flag at the top, so it gets precedence -->
       <_EmccCFlags Include="$(EmccCompileOptimizationFlag)" />
       <_EmccCFlags Include="@(_EmccCommonFlags)" />
+
+      <_EmccCFlags Include="-DENABLE_AOT=1"                    Condition="'$(RunAOTCompilation)' == 'true'" />
+      <_EmccCFlags Include="-DDRIVER_GEN=1"                    Condition="'$(RunAOTCompilation)' == 'true'" />
+      <_EmccCFlags Include="-DINVARIANT_GLOBALIZATION=1"       Condition="'$(InvariantGlobalization)' == 'true'" />
+      <_EmccCFlags Include="-DLINK_ICALLS=1"                   Condition="'$(WasmLinkIcalls)' == 'true'" />
       <_EmccCFlags Include="-DCORE_BINDINGS" />
       <_EmccCFlags Include="-DGEN_PINVOKE=1" />
+
       <_EmccCFlags Include="&quot;-I%(_EmccIncludePaths.Identity)&quot;" />
       <_EmccCFlags Include="-g" Condition="'$(WasmNativeDebugSymbols)' == 'true'" />
       <_EmccCFlags Include="-s EXPORTED_FUNCTIONS='[@(_ExportedFunctions->'&quot;%(Identity)&quot;', ',')]'" Condition="@(_ExportedFunctions->Count()) > 0" />
 
       <_EmccCFlags Include="$(EmccExtraCFlags)" />
+
+      <_WasmRuntimePackSrcFile Remove="@(_WasmRuntimePackSrcFile)" />
+      <_WasmRuntimePackSrcFile Include="$(_WasmRuntimePackSrcDir)\*.c" />
+      <_WasmRuntimePackSrcFile ObjectFile="$(_WasmIntermediateOutputPath)%(FileName).o" />
+      <_WasmSourceFileToCompile Include="@(_WasmRuntimePackSrcFile)" />
     </ItemGroup>
 
     <PropertyGroup>
+      <_EmBuilder Condition="$([MSBuild]::IsOSPlatform('WINDOWS'))">embuilder.bat</_EmBuilder>
+      <_EmBuilder Condition="!$([MSBuild]::IsOSPlatform('WINDOWS'))">embuilder.py</_EmBuilder>
       <_EmccCompileRsp>$(_WasmIntermediateOutputPath)emcc-compile.rsp</_EmccCompileRsp>
     </PropertyGroup>
 
     <WriteLinesToFile Lines="@(_EmccCFlags)" File="$(_EmccCompileRsp)" Overwrite="true" WriteOnlyWhenDifferent="true" />
 
+    <!-- warm up the cache -->
+    <Exec Command="$(_EmBuilder) build MINIMAL" EnvironmentVariables="@(EmscriptenEnvVars)" StandardOutputImportance="Low" StandardErrorImportance="Low" />
+
     <Message Text="Compiling native assets with emcc. This may take a while ..." Importance="High" />
-    <Exec Command='emcc "@$(_EmccDefaultFlagsRsp)" "@$(_EmccCompileRsp)" "%(_WasmObjectsToBuild.Identity)" -c -o "%(_WasmObjectsToBuild.OutputPath)"' EnvironmentVariables="@(EmscriptenEnvVars)" />
+    <EmccCompile SourceFiles="@(_WasmSourceFileToCompile)" Arguments='"@$(_EmccDefaultFlagsRsp)" "@$(_EmccCompileRsp)"' EnvironmentVariables="@(EmscriptenEnvVars)" />
   </Target>
 
   <Target Name="_WasmLinkDotNet">
     <ItemGroup>
-      <_WasmRuntimePackNativeLibs Include="$(MicrosoftNetCoreAppRuntimePackRidNativeDir)\*.a" />
-      <_WasmObjects Include="@(_WasmRuntimePackNativeLibs)" />
-      <_WasmObjects Include="@(_WasmObjectsToBuild->'%(OutputPath)')" />
-
       <!-- Adding optimization flag at the top, so it gets precedence -->
       <_EmccLDFlags Include="$(EmccLinkOptimizationFlag)" />
       <_EmccLDFlags Include="@(_EmccCommonFlags)" />
+
       <_EmccLDFlags Include="-s TOTAL_MEMORY=536870912" />
       <_EmccLDFlags Include="$(EmccExtraLDFlags)" />
+    </ItemGroup>
 
-      <_EmccLDFlags Include="--js-library &quot;%(_DotnetJSSrcFile.Identity)&quot;" />
-      <_EmccLDFlags Include="--js-library &quot;%(_WasmExtraJSFile.Identity)&quot;" Condition="'%(_WasmExtraJSFile.Kind)' == 'js-library'" />
+    <EmccCompile
+          Condition="@(_BitCodeFile->Count()) > 0"
+          SourceFiles="@(_BitCodeFile)"
+          Arguments="&quot;@$(_EmccDefaultFlagsRsp)&quot; @(_EmccLDFlags->'%(Identity)', ' ')"
+          EnvironmentVariables="@(EmscriptenEnvVars)" />
 
-      <_EmccLDFlags Include="--pre-js &quot;%(_WasmExtraJSFile.Identity)&quot;"     Condition="'%(_WasmExtraJSFile.Kind)' == 'pre-js'" />
-      <_EmccLDFlags Include="--post-js &quot;%(_WasmExtraJSFile.Identity)&quot;"    Condition="'%(_WasmExtraJSFile.Kind)' == 'post-js'" />
+    <ItemGroup>
+      <!-- order seems to matter -->
+      <_WasmNativeFileForLinking Include="%(_BitcodeFile.ObjectFile)" />
+      <_WasmNativeFileForLinking Include="%(_WasmSourceFileToCompile.ObjectFile)" />
+
+      <!-- libmono* needs to be at the end, since it is used to resolve references the previous .o files -->
+      <_WasmNativeFileForLinking Include="$(MicrosoftNetCoreAppRuntimePackRidNativeDir)\*.a" />
+
+      <_EmccLinkStepArgs Include="@(_EmccLDFlags)" />
+      <_EmccLinkStepArgs Include="--js-library &quot;%(_DotnetJSSrcFile.Identity)&quot;" />
+      <_EmccLinkStepArgs Include="--js-library &quot;%(_WasmExtraJSFile.Identity)&quot;" Condition="'%(_WasmExtraJSFile.Kind)' == 'js-library'" />
+
+      <_EmccLinkStepArgs Include="--pre-js &quot;%(_WasmExtraJSFile.Identity)&quot;"     Condition="'%(_WasmExtraJSFile.Kind)' == 'pre-js'" />
+      <_EmccLinkStepArgs Include="--post-js &quot;%(_WasmExtraJSFile.Identity)&quot;"    Condition="'%(_WasmExtraJSFile.Kind)' == 'post-js'" />
 
-      <_EmccLDFlags Include="&quot;%(_WasmNativeFileForLinking.Identity)&quot;" />
-      <_EmccLDFlags Include="&quot;%(_WasmObjects.Identity)&quot;" />
-      <_EmccLDFlags Include="-o &quot;$(_WasmIntermediateOutputPath)dotnet.js&quot;" />
+      <_EmccLinkStepArgs Include="&quot;%(_WasmNativeFileForLinking.Identity)&quot;" />
+      <_EmccLinkStepArgs Include="-o &quot;$(_WasmIntermediateOutputPath)dotnet.js&quot;" />
     </ItemGroup>
 
     <PropertyGroup>
       <_EmccLinkRsp>$(_WasmIntermediateOutputPath)emcc-link.rsp</_EmccLinkRsp>
     </PropertyGroup>
 
-    <WriteLinesToFile Lines="@(_EmccLDFlags)" File="$(_EmccLinkRsp)" Overwrite="true" WriteOnlyWhenDifferent="true" />
-    <Message Text="Running emcc with @(_EmccLDFlags->'%(Identity)', ' ')" Importance="Low" />
+    <WriteLinesToFile Lines="@(_EmccLinkStepArgs)" File="$(_EmccLinkRsp)" Overwrite="true" WriteOnlyWhenDifferent="true" />
+
+    <Message Text="Linking with emcc. This may take a while ..." Importance="High" />
+    <Message Text="Running emcc with @(_EmccLinkStepArgs->'%(Identity)', ' ')" Importance="Low" />
     <Exec Command='emcc "@$(_EmccDefaultFlagsRsp)" "@$(_EmccLinkRsp)"' EnvironmentVariables="@(EmscriptenEnvVars)" />
 
     <Exec Command='wasm-opt$(_ExeExt) --strip-dwarf "$(_WasmIntermediateOutputPath)dotnet.wasm" -o "$(_WasmIntermediateOutputPath)dotnet.wasm"' Condition="'$(WasmNativeStrip)' == 'true'" IgnoreStandardErrorWarningFormat="true" EnvironmentVariables="@(EmscriptenEnvVars)" />
@@ -288,7 +312,7 @@
 
   <Target Name="_GenerateDriverGenC" Condition="'$(RunAOTCompilation)' != 'true' and '$(WasmProfilers)' != ''">
     <PropertyGroup>
-      <EmccFlags>$(EmccFlags) -DDRIVER_GEN=1</EmccFlags>
+      <EmccExtraCFlags>$(EmccExtraCFlags) -DDRIVER_GEN=1</EmccExtraCFlags>
       <InitAotProfilerCmd>
 void mono_profiler_init_aot (const char *desc)%3B
 EMSCRIPTEN_KEEPALIVE void mono_wasm_load_profiler_aot (const char *desc) { mono_profiler_init_aot (desc)%3B }
@@ -338,8 +362,8 @@ EMSCRIPTEN_KEEPALIVE void mono_wasm_load_profiler_aot (const char *desc) { mono_
     <Error Condition="'@(_WasmAssembliesInternal)' == ''" Text="Item _WasmAssembliesInternal is empty" />
     <Error Condition="'$(_IsEMSDKMissing)' == 'true'"
            Text="$(_EMSDKMissingErrorMessage) Emscripten SDK is required for AOT'ing assemblies." />
-    <Error Condition="'$(MonoAotCrossCompilerPath)' == '' or !Exists('$(MonoAotCrossCompilerPath)')"
-           Text="Could not find AOT cross compiler at %24(MonoAotCrossCompilerPath)=$(MonoAotCrossCompilerPath)" />
+    <Error Condition="'$(_MonoAotCrossCompilerPath)' == '' or !Exists('$(_MonoAotCrossCompilerPath)')"
+           Text="Could not find AOT cross compiler at %24(_MonoAotCrossCompilerPath)=$(_MonoAotCrossCompilerPath)" />
 
     <ItemGroup>
       <MonoAOTCompilerDefaultAotArguments Include="no-opt" />
@@ -352,6 +376,7 @@ EMSCRIPTEN_KEEPALIVE void mono_wasm_load_profiler_aot (const char *desc) { mono_
         <AotArguments>@(MonoAOTCompilerDefaultAotArguments, ';')</AotArguments>
         <ProcessArguments>@(MonoAOTCompilerDefaultProcessArguments, ';')</ProcessArguments>
       </_AotInputAssemblies>
+
       <_AOT_InternalForceInterpretAssemblies Include="@(_WasmAssembliesInternal->WithMetadataValue('_InternalForceInterpret', 'true'))" />
 
       <_WasmAssembliesInternal Remove="@(_WasmAssembliesInternal)" />
@@ -392,7 +417,7 @@ EMSCRIPTEN_KEEPALIVE void mono_wasm_load_profiler_aot (const char *desc) { mono_
     </ItemGroup>
 
     <MonoAOTCompiler
-      CompilerBinaryPath="$(MonoAotCrossCompilerPath)"
+      CompilerBinaryPath="$(_MonoAotCrossCompilerPath)"
       OutputDir="$(_WasmIntermediateOutputPath)"
       Mode="$(AOTMode)"
       OutputType="AsmOnly"
@@ -403,7 +428,7 @@ EMSCRIPTEN_KEEPALIVE void mono_wasm_load_profiler_aot (const char *desc) { mono_
       Profilers="$(WasmProfilers)"
       AotModulesTablePath="$(_WasmIntermediateOutputPath)driver-gen.c"
       UseLLVM="true"
-      DisableParallelAot="true"
+      DisableParallelAot="$(DisableParallelAot)"
       DedupAssembly="$(_WasmDedupAssembly)"
       LLVMDebug="dwarfdebug"
       LLVMPath="$(EmscriptenUpstreamBinPath)" >
@@ -418,12 +443,8 @@ EMSCRIPTEN_KEEPALIVE void mono_wasm_load_profiler_aot (const char *desc) { mono_
 
       <_AOTAssemblies Include="@(_WasmAssembliesInternal)" Condition="'%(_WasmAssembliesInternal._InternalForceInterpret)' != 'true'" />
       <_BitcodeFile Include="%(_WasmAssembliesInternal.LlvmBitcodeFile)" />
-
-      <_WasmNativeFileForLinking Include="@(_BitcodeFile)" />
+      <_BitcodeFile ObjectFile="$(_WasmIntermediateOutputPath)%(FileName).o" />
     </ItemGroup>
-
-    <Error Condition="@(_BitcodeFile->Count()) != @(_AOTAssemblies->Count())"
-           Text="Bug: Number of aot assemblies doesn't match the number of generated bitcode files. BitcodeFiles: @(_BitcodeFile->Count()) vs Assemblies: @(_AOTAssemblies->Count())" />
   </Target>
 
   <!-- '$(ArchiveTests)' != 'true' is to skip on CI for now -->
diff --git a/src/mono/wasm/build/WasmApp.targets b/src/mono/wasm/build/WasmApp.targets
index 2141cce41b69b2..034287436892bf 100644
--- a/src/mono/wasm/build/WasmApp.targets
+++ b/src/mono/wasm/build/WasmApp.targets
@@ -61,11 +61,10 @@
       Public items:
       - @(WasmExtraFilesToDeploy) - Files to copy to $(WasmAppDir).
                                     (relative path can be set via %(TargetPath) metadata)
-      - @(WasmSatelliteAssemblies)
       - @(WasmFilesToIncludeInFileSystem) - Files to include in the vfs
       - @(WasmNativeAsset)        - Native files to be added to `NativeAssets` in the bundle.
 
-      - @(WasmExtraConfig)        - json elements to add to `mono-config.js`
+      - @(WasmExtraConfig)        - json elements to add to `mono-config.json`
                                     Eg. <WasmExtraConfig Include="enable_profiler" Value="true" />
 
                                     - Value attribute can have a number, bool, quoted string, or json string
@@ -115,6 +114,13 @@
     <MakeDir Directories="$(_WasmIntermediateOutputPath)" />
     <ItemGroup>
       <_WasmAssembliesInternal Include="@(WasmAssembliesToBundle->Distinct())" />
+
+      <_WasmSatelliteAssemblies Include="@(_WasmAssembliesInternal)" />
+      <_WasmSatelliteAssemblies Remove="@(_WasmSatelliteAssemblies)" Condition="!$([System.String]::Copy('%(Identity)').EndsWith('.resources.dll'))" />
+      <!-- FIXME: Only include the ones with valid culture name -->
+      <_WasmSatelliteAssemblies CultureName="$([System.IO.Directory]::GetParent('%(Identity)').Name)" />
+
+      <_WasmAssembliesInternal Remove="@(_WasmSatelliteAssemblies)" />
     </ItemGroup>
   </Target>
 
@@ -142,7 +148,7 @@
       MainJS="$(WasmMainJSPath)"
       Assemblies="@(_WasmAssembliesInternal)"
       InvariantGlobalization="$(InvariantGlobalization)"
-      SatelliteAssemblies="@(WasmSatelliteAssemblies)"
+      SatelliteAssemblies="@(_WasmSatelliteAssemblies)"
       FilesToIncludeInFileSystem="@(WasmFilesToIncludeInFileSystem)"
       IcuDataFileName="$(WasmIcuDataFileName)"
       RemoteSources="@(WasmRemoteSources)"
@@ -193,11 +199,5 @@
     <ItemGroup>
       <WasmAssembliesFinal Include="@(_WasmAssembliesInternal)" LlvmBitCodeFile="" />
     </ItemGroup>
-
-    <!-- $(WasmResolveAssembliesBeforeBuild) can add more assemblies, so no point checking the count in that case -->
-    <Error Condition="'$(WasmResolveAssembliesBeforeBuild)' != 'true' and @(WasmAssembliesFinal->Distinct()->Count()) != @(WasmAssembliesToBundle->Distinct()->Count()) and '$(WasmDedup)' != 'true'"
-      Text="Bug: The wasm build started with @(WasmAssembliesToBundle->Count()) assemblies, but completed with @(WasmAssembliesFinal->Count()).
-      WasmAssembliesToBundle: @(WasmAssembliesToBundle)
-      WasmAssembliesFinal: @(WasmAssembliesFinal)" />
   </Target>
 </Project>
diff --git a/src/mono/wasm/data/aot-tests/AOTTestProjectForHelix.proj b/src/mono/wasm/data/aot-tests/ProxyProjectForAOTOnHelix.proj
similarity index 75%
rename from src/mono/wasm/data/aot-tests/AOTTestProjectForHelix.proj
rename to src/mono/wasm/data/aot-tests/ProxyProjectForAOTOnHelix.proj
index f7b9d3fcc4fd0e..cdd5e95a4e2108 100644
--- a/src/mono/wasm/data/aot-tests/AOTTestProjectForHelix.proj
+++ b/src/mono/wasm/data/aot-tests/ProxyProjectForAOTOnHelix.proj
@@ -13,13 +13,18 @@
     <WasmNativeDebugSymbols>true</WasmNativeDebugSymbols>
     <WasmNativeStrip>false</WasmNativeStrip>
     <WasmBuildAppDependsOn>PrepareForWasmBuildApp;$(WasmBuildAppDependsOn)</WasmBuildAppDependsOn>
+
+    <_PropsFile>$(MSBuildThisFileDirectory)$(MSBuildThisFileName).props</_PropsFile>
   </PropertyGroup>
 
-  <Import Project="$(MSBuildThisFileDirectory)$(MSBuildThisFileName).props" />
+  <Import Project="$(_PropsFile)" />
 
   <Target Name="BundleTestWasmApp" DependsOnTargets="WasmBuildApp" />
 
   <Target Name="PrepareForWasmBuildApp">
+    <Message Text="** Building a proxy for the original test project, to AOT on helix. In order to do that, this recreates the original inputs for the *wasm* part of the build. See $(MSBuildThisFullPath), and $(_PropsFile). **"
+             Importance="High" />
+
     <PropertyGroup>
       <WasmAppDir>$(TestRootDir)AppBundle\</WasmAppDir>
       <WasmMainAssemblyFileName>$(OriginalPublishDir)WasmTestRunner.dll</WasmMainAssemblyFileName>
@@ -28,17 +33,15 @@
     </PropertyGroup>
 
     <ItemGroup>
-      <WasmSatelliteAssemblies Include="$(OriginalPublishDir)**\*.resources.dll" />
-      <WasmSatelliteAssemblies CultureName="$([System.IO.Directory]::GetParent('%(Identity)').Name)" />
-
-      <WasmAssembliesToBundle Include="$(OriginalPublishDir)*.dll" />
+      <WasmAssembliesToBundle Include="$(OriginalPublishDir)**\*.dll" />
 
       <_ExtraFiles Include="$(ExtraFilesPath)**\*" />
       <WasmFilesToIncludeInFileSystem Include="@(_ExtraFiles)" TargetPath="%(RecursiveDir)%(FileName)%(Extension)" />
     </ItemGroup>
 
     <ItemGroup Condition="'$(IncludeSatelliteAssembliesInVFS)' == 'true'">
-      <_SatelliteAssembliesForVFS Include="@(WasmSatelliteAssemblies)" />
+      <_SatelliteAssembliesForVFS Include="$(OriginalPublishDir)**\*.resources.dll" />
+      <_SatelliteAssembliesForVFS CultureName="$([System.IO.Directory]::GetParent('%(Identity)').Name)" />
       <_SatelliteAssembliesForVFS TargetPath="%(CultureName)\%(FileName)%(Extension)" />
 
       <WasmFilesToIncludeInFileSystem Include="@(_SatelliteAssembliesForVFS)" />
diff --git a/src/mono/wasm/debugger/BrowserDebugProxy/DebugStore.cs b/src/mono/wasm/debugger/BrowserDebugProxy/DebugStore.cs
index 1f31e044653ab9..81c419e4c5850e 100644
--- a/src/mono/wasm/debugger/BrowserDebugProxy/DebugStore.cs
+++ b/src/mono/wasm/debugger/BrowserDebugProxy/DebugStore.cs
@@ -317,6 +317,7 @@ internal class MethodInfo
 
         public SourceId SourceId => source.SourceId;
 
+        public int DebuggerId { get; set; }
         public string Name { get; }
         public MethodDebugInformation DebugInformation;
         public MethodDefinitionHandle methodDefHandle;
@@ -325,7 +326,7 @@ internal class MethodInfo
         public SourceLocation EndLocation { get; }
         public AssemblyInfo Assembly { get; }
         public int Token { get; }
-
+        public bool IsStatic() => (methodDef.Attributes & MethodAttributes.Static) != 0;
         public MethodInfo(AssemblyInfo assembly, MethodDefinitionHandle methodDefHandle, int token, SourceFile source, TypeInfo type)
         {
             this.Assembly = assembly;
diff --git a/src/mono/wasm/debugger/BrowserDebugProxy/DevToolsHelper.cs b/src/mono/wasm/debugger/BrowserDebugProxy/DevToolsHelper.cs
index e6c77d79b25ea1..6f1ec09317e0ae 100644
--- a/src/mono/wasm/debugger/BrowserDebugProxy/DevToolsHelper.cs
+++ b/src/mono/wasm/debugger/BrowserDebugProxy/DevToolsHelper.cs
@@ -172,50 +172,33 @@ internal class MonoCommands
 
         public MonoCommands(string expression) => this.expression = expression;
 
-        public static MonoCommands GetCallStack() => new MonoCommands("MONO.mono_wasm_get_call_stack()");
-
         public static MonoCommands GetExceptionObject() => new MonoCommands("MONO.mono_wasm_get_exception_object()");
 
-        public static MonoCommands IsRuntimeReady() => new MonoCommands("MONO.mono_wasm_runtime_is_ready");
+        public static MonoCommands GetDebuggerAgentBufferReceived() => new MonoCommands("MONO.mono_wasm_get_dbg_command_info()");
 
-        public static MonoCommands StartSingleStepping(StepKind kind) => new MonoCommands($"MONO.mono_wasm_start_single_stepping ({(int)kind})");
+        public static MonoCommands IsRuntimeReady() => new MonoCommands("MONO.mono_wasm_runtime_is_ready");
 
         public static MonoCommands GetLoadedFiles() => new MonoCommands("MONO.mono_wasm_get_loaded_files()");
 
-        public static MonoCommands ClearAllBreakpoints() => new MonoCommands("MONO.mono_wasm_clear_all_breakpoints()");
-
-        public static MonoCommands GetDetails(DotnetObjectId objectId, JToken args = null) => new MonoCommands($"MONO.mono_wasm_get_details ('{objectId}', {(args ?? "{ }")})");
-
-        public static MonoCommands GetScopeVariables(int scopeId, params VarInfo[] vars)
-        {
-            var var_ids = vars.Select(v => new { index = v.Index, name = v.Name }).ToArray();
-            return new MonoCommands($"MONO.mono_wasm_get_variables({scopeId}, {JsonConvert.SerializeObject(var_ids)})");
-        }
-
-        public static MonoCommands SetVariableValue(int scopeId, int index, string name, string newValue)
+        public static MonoCommands SendDebuggerAgentCommand(int id, int command_set, int command, string command_parameters)
         {
-            return new MonoCommands($"MONO.mono_wasm_set_variable_value({scopeId}, {index}, '{name}', '{newValue}')");
+            return new MonoCommands($"MONO.mono_wasm_send_dbg_command ({id}, {command_set}, {command},'{command_parameters}')");
         }
 
-        public static MonoCommands EvaluateMemberAccess(int scopeId, string expr, params VarInfo[] vars)
+        public static MonoCommands SendDebuggerAgentCommandWithParms(int id, int command_set, int command, string command_parameters, int len, int type, string parm)
         {
-            var var_ids = vars.Select(v => new { index = v.Index, name = v.Name }).ToArray();
-            return new MonoCommands($"MONO.mono_wasm_eval_member_access({scopeId}, {JsonConvert.SerializeObject(var_ids)}, '', '{expr}')");
+            return new MonoCommands($"MONO.mono_wasm_send_dbg_command_with_parms ({id}, {command_set}, {command},'{command_parameters}', {len}, {type}, '{parm}')");
         }
 
-        public static MonoCommands SetBreakpoint(string assemblyName, int methodToken, int ilOffset) => new MonoCommands($"MONO.mono_wasm_set_breakpoint (\"{assemblyName}\", {methodToken}, {ilOffset})");
-
-        public static MonoCommands RemoveBreakpoint(int breakpointId) => new MonoCommands($"MONO.mono_wasm_remove_breakpoint({breakpointId})");
-
-        public static MonoCommands ReleaseObject(DotnetObjectId objectId) => new MonoCommands($"MONO.mono_wasm_release_object('{objectId}')");
-
         public static MonoCommands CallFunctionOn(JToken args) => new MonoCommands($"MONO.mono_wasm_call_function_on ({args.ToString()})");
 
-        public static MonoCommands Resume() => new MonoCommands($"MONO.mono_wasm_debugger_resume ()");
+        public static MonoCommands GetDetails(int objectId, JToken args = null) => new MonoCommands($"MONO.mono_wasm_get_details ({objectId}, {(args ?? "{ }")})");
 
-        public static MonoCommands SetPauseOnExceptions(string state) => new MonoCommands($"MONO.mono_wasm_set_pause_on_exceptions(\"{state}\")");
+        public static MonoCommands Resume() => new MonoCommands($"MONO.mono_wasm_debugger_resume ()");
 
         public static MonoCommands DetachDebugger() => new MonoCommands($"MONO.mono_wasm_detach_debugger()");
+
+        public static MonoCommands ReleaseObject(DotnetObjectId objectId) => new MonoCommands($"MONO.mono_wasm_release_object('{objectId}')");
     }
 
     internal enum MonoErrorCodes
@@ -280,8 +263,8 @@ internal enum BreakpointState
     internal enum StepKind
     {
         Into,
-        Out,
-        Over
+        Over,
+        Out
     }
 
     internal class ExecutionContext
@@ -292,6 +275,7 @@ internal class ExecutionContext
         public TaskCompletionSource<DebugStore> ready;
         public bool IsRuntimeReady => ready != null && ready.Task.IsCompleted;
 
+        public int ThreadId { get; set; }
         public int Id { get; set; }
         public object AuxData { get; set; }
 
diff --git a/src/mono/wasm/debugger/BrowserDebugProxy/MemberReferenceResolver.cs b/src/mono/wasm/debugger/BrowserDebugProxy/MemberReferenceResolver.cs
index 21f8dabdb37a63..c4e578a0a2c920 100644
--- a/src/mono/wasm/debugger/BrowserDebugProxy/MemberReferenceResolver.cs
+++ b/src/mono/wasm/debugger/BrowserDebugProxy/MemberReferenceResolver.cs
@@ -8,6 +8,7 @@
 using Microsoft.Extensions.Logging;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
+using System.IO;
 
 namespace Microsoft.WebAssembly.Diagnostics
 {
@@ -18,7 +19,6 @@ internal class MemberReferenceResolver
         private MonoProxy proxy;
         private ExecutionContext ctx;
         private PerScopeCache scopeCache;
-        private VarInfo[] varIds;
         private ILogger logger;
         private bool locals_fetched;
 
@@ -31,44 +31,99 @@ public MemberReferenceResolver(MonoProxy proxy, ExecutionContext ctx, SessionId
             this.logger = logger;
             scopeCache = ctx.GetCacheForScope(scope_id);
         }
-
-        // Checks Locals, followed by `this`
-        public async Task<JObject> Resolve(string var_name, CancellationToken token)
+        public async Task<JObject> GetValueFromObject(JToken objRet, CancellationToken token)
         {
-            if (scopeCache.Locals.Count == 0 && !locals_fetched)
+            if (objRet["value"]?["className"]?.Value<string>() == "System.Exception")
             {
-                Result scope_res = await proxy.GetScopeProperties(sessionId, scopeId, token);
-                if (scope_res.IsErr)
-                    throw new Exception($"BUG: Unable to get properties for scope: {scopeId}. {scope_res}");
-                locals_fetched = true;
+                if (DotnetObjectId.TryParse(objRet?["value"]?["objectId"]?.Value<string>(), out DotnetObjectId objectId))
+                {
+                    var exceptionObject = await proxy.sdbHelper.GetObjectValues(sessionId, int.Parse(objectId.Value), true, false, false, true, token);
+                    var exceptionObjectMessage = exceptionObject.FirstOrDefault(attr => attr["name"].Value<string>().Equals("_message"));
+                    exceptionObjectMessage["value"]["value"] = objRet["value"]?["className"]?.Value<string>() + ": " + exceptionObjectMessage["value"]?["value"]?.Value<string>();
+                    return exceptionObjectMessage["value"]?.Value<JObject>();
+                }
+                return objRet["value"]?.Value<JObject>();
             }
 
-            if (scopeCache.Locals.TryGetValue(var_name, out JObject obj))
+            if (objRet["value"]?.Value<JObject>() != null)
+                return objRet["value"]?.Value<JObject>();
+            if (objRet["get"]?.Value<JObject>() != null)
             {
-                return obj["value"]?.Value<JObject>();
-            }
+                if (DotnetObjectId.TryParse(objRet?["get"]?["objectIdValue"]?.Value<string>(), out DotnetObjectId objectId))
+                {
+                    var command_params = new MemoryStream();
+                    var command_params_writer = new MonoBinaryWriter(command_params);
+                    command_params_writer.WriteObj(objectId, proxy.sdbHelper);
+                    var ret = await proxy.sdbHelper.InvokeMethod(sessionId, command_params.ToArray(), objRet["get"]["methodId"].Value<int>(), objRet["name"].Value<string>(), token);
+                    return await GetValueFromObject(ret, token);
+                }
 
-            if (scopeCache.MemberReferences.TryGetValue(var_name, out JObject ret))
-                return ret;
-
-            if (varIds == null)
-            {
-                Frame scope = ctx.CallStack.FirstOrDefault(s => s.Id == scopeId);
-                varIds = scope.Method.GetLiveVarsAt(scope.Location.CliLocation.Offset);
             }
+            return null;
+        }
+        // Checks Locals, followed by `this`
+        public async Task<JObject> Resolve(string var_name, CancellationToken token)
+        {
+            string[] parts = var_name.Split(".");
+            JObject rootObject = null;
 
-            Result res = await proxy.SendMonoCommand(sessionId, MonoCommands.EvaluateMemberAccess(scopeId, var_name, varIds), token);
-            if (res.IsOk)
-            {
-                ret = res.Value?["result"]?["value"]?["value"]?.Value<JObject>();
-                scopeCache.MemberReferences[var_name] = ret;
+            if (scopeCache.MemberReferences.TryGetValue(var_name, out JObject ret)) {
+                return ret;
             }
-            else
+            foreach (string part in parts)
             {
-                logger.LogDebug(res.Error.ToString());
-            }
+                string partTrimmed = part.Trim();
+                if (partTrimmed == "")
+                    return null;
+                if (rootObject != null)
+                {
+                    if (rootObject?["subtype"]?.Value<string>() == "null")
+                        return null;
+                    if (DotnetObjectId.TryParse(rootObject?["objectId"]?.Value<string>(), out DotnetObjectId objectId))
+                    {
+                        var root_res_obj = await proxy.RuntimeGetPropertiesInternal(sessionId, objectId, null, token);
+                        var objRet = root_res_obj.FirstOrDefault(objPropAttr => objPropAttr["name"].Value<string>() == partTrimmed);
+                        if (objRet == null)
+                            return null;
 
-            return ret;
+                        rootObject = await GetValueFromObject(objRet, token);
+                    }
+                    continue;
+                }
+                if (scopeCache.Locals.Count == 0 && !locals_fetched)
+                {
+                    Result scope_res = await proxy.GetScopeProperties(sessionId, scopeId, token);
+                    if (scope_res.IsErr)
+                        throw new Exception($"BUG: Unable to get properties for scope: {scopeId}. {scope_res}");
+                    locals_fetched = true;
+                }
+                if (scopeCache.Locals.TryGetValue(partTrimmed, out JObject obj))
+                {
+                    rootObject = obj["value"]?.Value<JObject>();
+                }
+                else if (scopeCache.Locals.TryGetValue("this", out JObject objThis))
+                {
+                    if (partTrimmed == "this")
+                    {
+                        rootObject = objThis?["value"].Value<JObject>();
+                    }
+                    else if (DotnetObjectId.TryParse(objThis?["value"]?["objectId"]?.Value<string>(), out DotnetObjectId objectId))
+                    {
+                        var root_res_obj = await proxy.RuntimeGetPropertiesInternal(sessionId, objectId, null, token);
+                        var objRet = root_res_obj.FirstOrDefault(objPropAttr => objPropAttr["name"].Value<string>() == partTrimmed);
+                        if (objRet != null)
+                        {
+                            rootObject = await GetValueFromObject(objRet, token);
+                        }
+                        else
+                        {
+                            return null;
+                        }
+                    }
+                }
+            }
+            scopeCache.MemberReferences[var_name] = rootObject;
+            return rootObject;
         }
 
     }
diff --git a/src/mono/wasm/debugger/BrowserDebugProxy/MonoProxy.cs b/src/mono/wasm/debugger/BrowserDebugProxy/MonoProxy.cs
index 2cf987da59c37c..a3725334b9d3d0 100644
--- a/src/mono/wasm/debugger/BrowserDebugProxy/MonoProxy.cs
+++ b/src/mono/wasm/debugger/BrowserDebugProxy/MonoProxy.cs
@@ -18,6 +18,7 @@ namespace Microsoft.WebAssembly.Diagnostics
 {
     internal class MonoProxy : DevToolsProxy
     {
+        internal MonoSDBHelper sdbHelper;
         private IList<string> urlSymbolServerList;
         private static HttpClient client = new HttpClient();
         private HashSet<SessionId> sessions = new HashSet<SessionId>();
@@ -28,6 +29,7 @@ internal class MonoProxy : DevToolsProxy
         public MonoProxy(ILoggerFactory loggerFactory, IList<string> urlSymbolServerList) : base(loggerFactory)
         {
             this.urlSymbolServerList = urlSymbolServerList ?? new List<string>();
+            sdbHelper = new MonoSDBHelper(this);
         }
 
         internal ExecutionContext GetContext(SessionId sessionId)
@@ -167,11 +169,15 @@ protected override async Task<bool> AcceptEvent(SessionId sessionId, string meth
                                     await SendCommand(sessionId, "Debugger.resume", new JObject(), token);
                                     return true;
                                 }
-                            case "mono_wasm_fire_bp":
-                            case "_mono_wasm_fire_bp":
-                            case "_mono_wasm_fire_exception":
+                            case "_mono_wasm_fire_debugger_agent_message":
                                 {
-                                    return await OnPause(sessionId, args, token);
+                                    try {
+                                        return await OnReceiveDebuggerAgentEvent(sessionId, args, token);
+                                    }
+                                    catch (Exception) //if the page is refreshed maybe it stops here.
+                                    {
+                                        return false;
+                                    }
                                 }
                         }
                         break;
@@ -405,8 +411,12 @@ protected override async Task<bool> AcceptCommand(MessageId id, string method, J
                         if (!DotnetObjectId.TryParse(args?["objectId"], out DotnetObjectId objectId))
                             break;
 
-                        Result result = await RuntimeGetProperties(id, objectId, args, token);
-                        SendResponse(id, result, token);
+                        var ret = await RuntimeGetPropertiesInternal(id, objectId, args, token);
+                        if (ret == null) {
+                            SendResponse(id, Result.Err($"Unable to RuntimeGetProperties '{objectId}'"), token);
+                        }
+                        else
+                            SendResponse(id, Result.OkFromObject(new { result = ret }), token);
                         return true;
                     }
 
@@ -439,7 +449,7 @@ protected override async Task<bool> AcceptCommand(MessageId id, string method, J
                             }
                         }
                         else
-                            await SendMonoCommand(id, MonoCommands.SetPauseOnExceptions(state), token);
+                            await sdbHelper.EnableExceptions(id, state, token);
                         // Pass this on to JS too
                         return false;
                     }
@@ -454,8 +464,6 @@ protected override async Task<bool> AcceptCommand(MessageId id, string method, J
                     }
                 case "DotnetDebugger.getMethodLocation":
                     {
-                        Console.WriteLine("set-breakpoint-by-method: " + id + " " + args);
-
                         DebugStore store = await RuntimeReady(id, token);
                         string aname = args["assemblyName"]?.Value<string>();
                         string typeName = args["typeName"]?.Value<string>();
@@ -511,31 +519,80 @@ protected override async Task<bool> AcceptCommand(MessageId id, string method, J
                     }
                 case "Runtime.callFunctionOn":
                     {
-                        if (!DotnetObjectId.TryParse(args["objectId"], out DotnetObjectId objectId))
-                            return false;
-
-                        if (objectId.Scheme == "scope")
-                        {
+                        try {
+                            return await CallOnFunction(id, args, token);
+                        }
+                        catch (Exception){
                             SendResponse(id,
                                 Result.Exception(new ArgumentException(
-                                    $"Runtime.callFunctionOn not supported with scope ({objectId}).")),
+                                    $"Runtime.callFunctionOn not supported with ({args["objectId"]}).")),
                                 token);
                             return true;
                         }
-
-                        Result res = await SendMonoCommand(id, MonoCommands.CallFunctionOn(args), token);
-                        JTokenType? res_value_type = res.Value?["result"]?["value"]?.Type;
-
-                        if (res.IsOk && res_value_type == JTokenType.Object || res_value_type == JTokenType.Object)
-                            res = Result.OkFromObject(new { result = res.Value["result"]["value"] });
-
-                        SendResponse(id, res, token);
-                        return true;
                     }
             }
 
             return false;
         }
+        private async Task<bool> CallOnFunction(MessageId id, JObject args, CancellationToken token)
+        {
+            if (!DotnetObjectId.TryParse(args["objectId"], out DotnetObjectId objectId)) {
+                return false;
+            }
+            switch (objectId.Scheme)
+            {
+                case "object":
+                    args["details"]  = await sdbHelper.GetObjectProxy(id, int.Parse(objectId.Value), token);
+                    break;
+                case "valuetype":
+                    args["details"]  = await sdbHelper.GetValueTypeProxy(id, int.Parse(objectId.Value), token);
+                    break;
+                case "pointer":
+                    args["details"]  = await sdbHelper.GetPointerContent(id, int.Parse(objectId.Value), token);
+                    break;
+                case "array":
+                    args["details"]  = await sdbHelper.GetArrayValues(id, int.Parse(objectId.Value), token);
+                    break;
+                case "cfo_res":
+                {
+                    Result cfo_res = await SendMonoCommand(id, MonoCommands.CallFunctionOn(args), token);
+                    cfo_res = Result.OkFromObject(new { result = cfo_res.Value?["result"]?["value"]});
+                    SendResponse(id, cfo_res, token);
+                    return true;
+                }
+                case "scope":
+                {
+                    SendResponse(id,
+                    Result.Exception(new ArgumentException(
+                        $"Runtime.callFunctionOn not supported with scope ({objectId}).")),
+                        token);
+                    return true;
+                }
+                default:
+                    return false;
+            }
+            Result res = await SendMonoCommand(id, MonoCommands.CallFunctionOn(args), token);
+            if (res.IsErr)
+            {
+                SendResponse(id, res, token);
+                return true;
+            }
+            if (res.Value?["result"]?["value"]?["type"] == null) //it means that is not a buffer returned from the debugger-agent
+            {
+                byte[] newBytes = Convert.FromBase64String(res.Value?["result"]?["value"]?["value"]?.Value<string>());
+                var ret_debugger_cmd = new MemoryStream(newBytes);
+                var ret_debugger_cmd_reader = new MonoBinaryReader(ret_debugger_cmd);
+                ret_debugger_cmd_reader.ReadByte(); //number of objects returned.
+                var obj = await sdbHelper.CreateJObjectForVariableValue(id, ret_debugger_cmd_reader, "ret", false, -1, token);
+                /*JTokenType? res_value_type = res.Value?["result"]?["value"]?.Type;*/
+                res = Result.OkFromObject(new { result = obj["value"]});
+                SendResponse(id, res, token);
+                return true;
+            }
+            res = Result.OkFromObject(new { result = res.Value?["result"]?["value"]});
+            SendResponse(id, res, token);
+            return true;
+        }
 
         private async Task<bool> OnSetVariableValue(MessageId id, int scopeId, string varName, JToken varValue, CancellationToken token)
         {
@@ -549,50 +606,59 @@ private async Task<bool> OnSetVariableValue(MessageId id, int scopeId, string va
             var varToSetValue = varIds.FirstOrDefault(v => v.Name == varName);
             if (varToSetValue == null)
                 return false;
-            Result res = await SendMonoCommand(id, MonoCommands.SetVariableValue(scopeId, varToSetValue.Index, varName, varValue["value"].Value<string>()), token);
-            if (res.IsOk)
+            var res = await sdbHelper.SetVariableValue(id, ctx.ThreadId, scopeId, varToSetValue.Index, varValue["value"].Value<string>(), token);
+            if (res)
                 SendResponse(id, Result.Ok(new JObject()), token);
             else
                 SendResponse(id, Result.Err($"Unable to set '{varValue["value"].Value<string>()}' to variable '{varName}'"), token);
             return true;
         }
 
-        private async Task<Result> RuntimeGetProperties(MessageId id, DotnetObjectId objectId, JToken args, CancellationToken token)
+        internal async Task<JToken> RuntimeGetPropertiesInternal(SessionId id, DotnetObjectId objectId, JToken args, CancellationToken token)
         {
-            if (objectId.Scheme == "scope")
+            var accessorPropertiesOnly = false;
+            var ownProperties = false;
+            if (args != null)
             {
-                return await GetScopeProperties(id, int.Parse(objectId.Value), token);
+                if (args["accessorPropertiesOnly"] != null)
+                    accessorPropertiesOnly = args["accessorPropertiesOnly"].Value<bool>();
+                if (args["ownProperties"] != null)
+                    ownProperties = args["ownProperties"].Value<bool>();
             }
-
-            Result res = await SendMonoCommand(id, MonoCommands.GetDetails(objectId, args), token);
-            if (res.IsErr)
-                return res;
-
-            if (objectId.Scheme == "cfo_res")
-            {
-                // Runtime.callFunctionOn result object
-                string value_json_str = res.Value["result"]?["value"]?["__value_as_json_string__"]?.Value<string>();
-                if (value_json_str != null)
+            //Console.WriteLine($"RuntimeGetProperties - {args}");
+            try {
+                switch (objectId.Scheme)
                 {
-                    res = Result.OkFromObject(new
+                    case "scope":
                     {
-                        result = JArray.Parse(value_json_str)
-                    });
-                }
-                else
-                {
-                    res = Result.OkFromObject(new { result = new { } });
+                        var res = await GetScopeProperties(id, int.Parse(objectId.Value), token);
+                        return res.Value?["result"];
+                    }
+                    case "valuetype":
+                        return await sdbHelper.GetValueTypeValues(id, int.Parse(objectId.Value), accessorPropertiesOnly, token);
+                    case "array":
+                        return await sdbHelper.GetArrayValues(id, int.Parse(objectId.Value), token);
+                    case "object":
+                        return await sdbHelper.GetObjectValues(id, int.Parse(objectId.Value), true, false, accessorPropertiesOnly, ownProperties, token);
+                    case "pointer":
+                        return new JArray{await sdbHelper.GetPointerContent(id, int.Parse(objectId.Value), token)};
+                    case "cfo_res":
+                    {
+                        Result res = await SendMonoCommand(id, MonoCommands.GetDetails(int.Parse(objectId.Value), args), token);
+                        string value_json_str = res.Value["result"]?["value"]?["__value_as_json_string__"]?.Value<string>();
+                        return value_json_str != null ? JArray.Parse(value_json_str) : null;
+                    }
+                    default:
+                        return null;
+
                 }
             }
-            else
-            {
-                res = Result.Ok(JObject.FromObject(new { result = res.Value["result"]["value"] }));
+            catch (Exception) {
+                return null;
             }
-
-            return res;
         }
 
-        private async Task<bool> EvaluateCondition(SessionId sessionId, ExecutionContext context, JObject mono_frame, Breakpoint bp, CancellationToken token)
+        private async Task<bool> EvaluateCondition(SessionId sessionId, ExecutionContext context, Frame mono_frame, Breakpoint bp, CancellationToken token)
         {
             if (string.IsNullOrEmpty(bp?.Condition) || mono_frame == null)
                 return true;
@@ -602,8 +668,7 @@ private async Task<bool> EvaluateCondition(SessionId sessionId, ExecutionContext
             if (bp.ConditionAlreadyEvaluatedWithError)
                 return false;
             try {
-                var resolver = new MemberReferenceResolver(this, context, sessionId, mono_frame["frame_id"].Value<int>(), logger);
-
+                var resolver = new MemberReferenceResolver(this, context, sessionId, mono_frame.Id, logger);
                 JObject retValue = await resolver.Resolve(condition, token);
                 if (retValue == null)
                     retValue = await EvaluateExpression.CompileAndRunTheExpression(condition, resolver, token);
@@ -624,172 +689,124 @@ private async Task<bool> EvaluateCondition(SessionId sessionId, ExecutionContext
             }
             return false;
         }
-
-        private async Task<bool> OnPause(SessionId sessionId, JObject args, CancellationToken token)
+        private async Task<bool> SendCallStack(SessionId sessionId, ExecutionContext context, string reason, int thread_id, Breakpoint bp, JObject data, IEnumerable<JObject> orig_callframes, CancellationToken token)
         {
-            //FIXME we should send release objects every now and then? Or intercept those we inject and deal in the runtime
-            Result res = await SendMonoCommand(sessionId, MonoCommands.GetCallStack(), token);
-            IEnumerable<JObject> orig_callframes = args?["callFrames"]?.Values<JObject>();
-            ExecutionContext context = GetContext(sessionId);
-            JObject data = null;
-            string reason = "other";//other means breakpoint
-
-            if (res.IsErr)
-            {
-                //Give up and send the original call stack
-                return false;
-            }
-
-            //step one, figure out where did we hit
-            JToken res_value = res.Value?["result"]?["value"];
-            if (res_value == null || res_value is JValue)
-            {
-                //Give up and send the original call stack
-                return false;
-            }
-
-            Log("verbose", $"call stack (err is {res.Error} value is:\n{res.Value}");
-            int? bp_id = res_value?["breakpoint_id"]?.Value<int>();
-            Log("verbose", $"We just hit bp {bp_id}");
-            if (!bp_id.HasValue)
-            {
-                //Give up and send the original call stack
-                return false;
-            }
-
-            Breakpoint bp = context.BreakpointRequests.Values.SelectMany(v => v.Locations).FirstOrDefault(b => b.RemoteId == bp_id.Value);
-
             var callFrames = new List<object>();
-            foreach (JObject frame in orig_callframes)
-            {
-                string function_name = frame["functionName"]?.Value<string>();
-                string url = frame["url"]?.Value<string>();
-                if ("mono_wasm_fire_bp" == function_name || "_mono_wasm_fire_bp" == function_name ||
-                    "_mono_wasm_fire_exception" == function_name)
+            var frames = new List<Frame>();
+            var command_params = new MemoryStream();
+            var command_params_writer = new MonoBinaryWriter(command_params);
+            command_params_writer.Write(thread_id);
+            command_params_writer.Write(0);
+            command_params_writer.Write(-1);
+            var ret_debugger_cmd_reader = await sdbHelper.SendDebuggerAgentCommand<CmdThread>(sessionId, CmdThread.GetFrameInfo, command_params, token);
+            var frame_count = ret_debugger_cmd_reader.ReadInt32();
+            //Console.WriteLine("frame_count - " + frame_count);
+            for (int j = 0; j < frame_count; j++) {
+                var frame_id = ret_debugger_cmd_reader.ReadInt32();
+                var method_id = ret_debugger_cmd_reader.ReadInt32();
+                var il_pos = ret_debugger_cmd_reader.ReadInt32();
+                var flags = ret_debugger_cmd_reader.ReadByte();
+                var method_token = await sdbHelper.GetMethodToken(sessionId, method_id, token);
+                var assembly_id = await sdbHelper.GetAssemblyIdFromMethod(sessionId, method_id, token);
+                var assembly_name = await sdbHelper.GetAssemblyName(sessionId, assembly_id, token);
+                var method_name = await sdbHelper.GetMethodName(sessionId, method_id, token);
+                DebugStore store = await LoadStore(sessionId, token);
+                AssemblyInfo asm = store.GetAssemblyByName(assembly_name);
+                if (asm == null)
                 {
-                    if ("_mono_wasm_fire_exception" == function_name)
+                    assembly_name = await sdbHelper.GetAssemblyNameFull(sessionId, assembly_id, token); //maybe is a lazy loaded assembly
+                    asm = store.GetAssemblyByName(assembly_name);
+                    if (asm == null)
                     {
-                        Result exception_obj_id = await SendMonoCommand(sessionId, MonoCommands.GetExceptionObject(), token);
-                        JToken res_val = exception_obj_id.Value?["result"]?["value"];
-                        var exception_dotnet_obj_id = new DotnetObjectId("object", res_val?["exception_id"]?.Value<string>());
-                        data = JObject.FromObject(new
-                        {
-                            type = "object",
-                            subtype = "error",
-                            className = res_val?["class_name"]?.Value<string>(),
-                            uncaught = res_val?["uncaught"]?.Value<bool>(),
-                            description = res_val?["message"]?.Value<string>() + "\n",
-                            objectId = exception_dotnet_obj_id.ToString()
-                        });
-                        reason = "exception";
+                        Log("debug", $"Unable to find assembly: {assembly_name}");
+                        continue;
                     }
+                }
 
-                    var frames = new List<Frame>();
-                    IEnumerable<JObject> the_mono_frames = res.Value?["result"]?["value"]?["frames"]?.Values<JObject>();
+                MethodInfo method = asm.GetMethodByToken(method_token);
 
-                    foreach (JObject mono_frame in the_mono_frames)
+                if (method == null && !asm.HasSymbols)
+                {
+                    try
+                    {
+                        method = await LoadSymbolsOnDemand(asm, method_token, sessionId, token);
+                    }
+                    catch (Exception e)
                     {
-                        int frame_id = mono_frame["frame_id"].Value<int>();
-                        int il_pos = mono_frame["il_pos"].Value<int>();
-                        int method_token = mono_frame["method_token"].Value<int>();
-                        string assembly_name = mono_frame["assembly_name"].Value<string>();
+                        Log("info", $"Unable to find il offset: {il_pos} in method token: {method_token} assembly name: {assembly_name} exception: {e}");
+                        continue;
+                    }
+                }
 
-                        // This can be different than `method.Name`, like in case of generic methods
-                        string method_name = mono_frame["method_name"]?.Value<string>();
+                if (method == null)
+                {
+                    Log("debug", $"Unable to find il offset: {il_pos} in method token: {method_token} assembly name: {assembly_name}");
+                    continue;
+                }
 
-                        DebugStore store = await LoadStore(sessionId, token);
-                        AssemblyInfo asm = store.GetAssemblyByName(assembly_name);
-                        if (asm == null)
-                        {
-                            Log("debug", $"Unable to find assembly: {assembly_name}");
-                            continue;
-                        }
+                method.DebuggerId = method_id;
 
-                        MethodInfo method = asm.GetMethodByToken(method_token);
+                SourceLocation location = method?.GetLocationByIl(il_pos);
 
-                        if (method == null && !asm.HasSymbols)
-                        {
-                            try
-                            {
-                                method = await LoadSymbolsOnDemand(asm, method_token, sessionId, token);
-                            }
-                            catch (Exception e)
-                            {
-                                Log("info", $"Unable to find il offset: {il_pos} in method token: {method_token} assembly name: {assembly_name} exception: {e}");
-                                continue;
-                            }
-                        }
+                // When hitting a breakpoint on the "IncrementCount" method in the standard
+                // Blazor project template, one of the stack frames is inside mscorlib.dll
+                // and we get location==null for it. It will trigger a NullReferenceException
+                // if we don't skip over that stack frame.
+                if (location == null)
+                {
+                    continue;
+                }
 
-                        if (method == null)
-                        {
-                            Log("debug", $"Unable to find il offset: {il_pos} in method token: {method_token} assembly name: {assembly_name}");
-                            continue;
-                        }
+                Log("debug", $"frame il offset: {il_pos} method token: {method_token} assembly name: {assembly_name}");
+                Log("debug", $"\tmethod {method_name} location: {location}");
+                frames.Add(new Frame(method, location, frame_id));
 
-                        SourceLocation location = method?.GetLocationByIl(il_pos);
+                callFrames.Add(new
+                {
+                    functionName = method_name,
+                    callFrameId = $"dotnet:scope:{frame_id}",
+                    functionLocation = method.StartLocation.AsLocation(),
 
-                        // When hitting a breakpoint on the "IncrementCount" method in the standard
-                        // Blazor project template, one of the stack frames is inside mscorlib.dll
-                        // and we get location==null for it. It will trigger a NullReferenceException
-                        // if we don't skip over that stack frame.
-                        if (location == null)
-                        {
-                            continue;
-                        }
+                    location = location.AsLocation(),
 
-                        Log("debug", $"frame il offset: {il_pos} method token: {method_token} assembly name: {assembly_name}");
-                        Log("debug", $"\tmethod {method_name} location: {location}");
-                        frames.Add(new Frame(method, location, frame_id));
+                    url = store.ToUrl(location),
 
-                        callFrames.Add(new
+                    scopeChain = new[]
                         {
-                            functionName = method_name,
-                            callFrameId = $"dotnet:scope:{frame_id}",
-                            functionLocation = method.StartLocation.AsLocation(),
-
-                            location = location.AsLocation(),
-
-                            url = store.ToUrl(location),
-
-                            scopeChain = new[]
-                                {
-                                    new
+                            new
+                            {
+                                type = "local",
+                                    @object = new
                                     {
-                                        type = "local",
-                                            @object = new
-                                            {
-                                                @type = "object",
-                                                    className = "Object",
-                                                    description = "Object",
-                                                    objectId = $"dotnet:scope:{frame_id}",
-                                            },
-                                            name = method_name,
-                                            startLocation = method.StartLocation.AsLocation(),
-                                            endLocation = method.EndLocation.AsLocation(),
-                                    }
-                                }
-                        });
-
-                        context.CallStack = frames;
+                                        @type = "object",
+                                            className = "Object",
+                                            description = "Object",
+                                            objectId = $"dotnet:scope:{frame_id}",
+                                    },
+                                    name = method_name,
+                                    startLocation = method.StartLocation.AsLocation(),
+                                    endLocation = method.EndLocation.AsLocation(),
+                            }
+                        }
+                });
 
-                    }
-                    if (!await EvaluateCondition(sessionId, context, the_mono_frames?.First(), bp, token))
-                    {
-                        await SendCommand(sessionId, "Debugger.resume", new JObject(), token);
-                        return true;
-                    }
-                }
-                else if (!(function_name.StartsWith("wasm-function", StringComparison.Ordinal) ||
-                        url.StartsWith("wasm://wasm/", StringComparison.Ordinal)))
-                {
-                    callFrames.Add(frame);
-                }
+                context.CallStack = frames;
+                context.ThreadId = thread_id;
             }
-
             string[] bp_list = new string[bp == null ? 0 : 1];
             if (bp != null)
                 bp_list[0] = bp.StackId;
 
+            foreach (JObject frame in orig_callframes)
+            {
+                string function_name = frame["functionName"]?.Value<string>();
+                string url = frame["url"]?.Value<string>();
+                if (!(function_name.StartsWith("wasm-function", StringComparison.Ordinal) ||
+                        url.StartsWith("wasm://wasm/", StringComparison.Ordinal) || function_name == "_mono_wasm_fire_debugger_agent_message"))
+                {
+                    callFrames.Add(frame);
+                }
+            }
             var o = JObject.FromObject(new
             {
                 callFrames,
@@ -797,10 +814,72 @@ private async Task<bool> OnPause(SessionId sessionId, JObject args, Cancellation
                 data,
                 hitBreakpoints = bp_list,
             });
-
+            if (!await EvaluateCondition(sessionId, context, context.CallStack.First(), bp, token))
+            {
+                await SendCommand(sessionId, "Debugger.resume", new JObject(), token);
+                return true;
+            }
             SendEvent(sessionId, "Debugger.paused", o, token);
+
             return true;
         }
+        private async Task<bool> OnReceiveDebuggerAgentEvent(SessionId sessionId, JObject args, CancellationToken token)
+        {
+            Result res = await SendMonoCommand(sessionId, MonoCommands.GetDebuggerAgentBufferReceived(), token);
+            if (res.IsErr)
+                return false;
+
+            ExecutionContext context = GetContext(sessionId);
+            byte[] newBytes = Convert.FromBase64String(res.Value?["result"]?["value"]?["value"]?.Value<string>());
+            var ret_debugger_cmd = new MemoryStream(newBytes);
+            var ret_debugger_cmd_reader = new MonoBinaryReader(ret_debugger_cmd);
+            ret_debugger_cmd_reader.ReadBytes(11); //skip HEADER_LEN
+            ret_debugger_cmd_reader.ReadByte(); //suspend_policy
+            var number_of_events = ret_debugger_cmd_reader.ReadInt32(); //number of events -> should be always one
+            for (int i = 0 ; i < number_of_events; i++) {
+                var event_kind = (EventKind)ret_debugger_cmd_reader.ReadByte(); //event kind
+                var request_id = ret_debugger_cmd_reader.ReadInt32(); //request id
+                if (event_kind == EventKind.Step)
+                    await sdbHelper.ClearSingleStep(sessionId, request_id, token);
+                int thread_id = ret_debugger_cmd_reader.ReadInt32();
+                switch (event_kind)
+                {
+                    case EventKind.Exception:
+                    {
+                        string reason = "exception";
+                        int object_id = ret_debugger_cmd_reader.ReadInt32();
+                        var caught = ret_debugger_cmd_reader.ReadByte();
+                        var exceptionObject = await sdbHelper.GetObjectValues(sessionId, object_id, true, false, false, true, token);
+                        var exceptionObjectMessage = exceptionObject.FirstOrDefault(attr => attr["name"].Value<string>().Equals("message"));
+                        var data = JObject.FromObject(new
+                        {
+                            type = "object",
+                            subtype = "error",
+                            className = await sdbHelper.GetClassNameFromObject(sessionId, object_id, token),
+                            uncaught = caught == 0,
+                            description = exceptionObjectMessage["value"]["value"].Value<string>(),
+                            objectId = $"dotnet:object:{object_id}"
+                        });
+
+                        var ret = await SendCallStack(sessionId, context, reason, thread_id, null, data, args?["callFrames"]?.Values<JObject>(), token);
+                        return ret;
+                    }
+                    case EventKind.UserBreak:
+                    case EventKind.Step:
+                    case EventKind.Breakpoint:
+                    {
+                        Breakpoint bp = context.BreakpointRequests.Values.SelectMany(v => v.Locations).FirstOrDefault(b => b.RemoteId == request_id);
+                        string reason = "other";//other means breakpoint
+                        int method_id = 0;
+                        if (event_kind != EventKind.UserBreak)
+                            method_id = ret_debugger_cmd_reader.ReadInt32();
+                        var ret = await SendCallStack(sessionId, context, reason, thread_id, bp, null, args?["callFrames"]?.Values<JObject>(), token);
+                        return ret;
+                    }
+                }
+            }
+            return false;
+        }
 
         private async Task<MethodInfo> LoadSymbolsOnDemand(AssemblyInfo asm, int method_token, SessionId sessionId, CancellationToken token)
         {
@@ -877,6 +956,7 @@ private async Task OnResume(MessageId msg_id, CancellationToken token)
             }
 
             //discard managed frames
+            sdbHelper.ClearCache();
             GetContext(msg_id).ClearState();
         }
 
@@ -889,12 +969,9 @@ private async Task<bool> Step(MessageId msg_id, StepKind kind, CancellationToken
             if (context.CallStack.Count <= 1 && kind == StepKind.Out)
                 return false;
 
-            Result res = await SendMonoCommand(msg_id, MonoCommands.StartSingleStepping(kind), token);
-
-            int? ret_code = res.Value?["result"]?["value"]?.Value<int>();
-
-            if (ret_code.HasValue && ret_code.Value == 0)
-            {
+            var step = await sdbHelper.Step(msg_id, context.ThreadId, kind, token);
+            if (step == false) {
+                sdbHelper.ClearCache();
                 context.ClearState();
                 await SendCommand(msg_id, "Debugger.stepOut", new JObject(), token);
                 return false;
@@ -1022,24 +1099,21 @@ internal async Task<Result> GetScopeProperties(SessionId msg_id, int scope_id, C
                     return Result.Err(JObject.FromObject(new { message = $"Could not find scope with id #{scope_id}" }));
 
                 VarInfo[] var_ids = scope.Method.GetLiveVarsAt(scope.Location.CliLocation.Offset);
-                Result res = await SendMonoCommand(msg_id, MonoCommands.GetScopeVariables(scope.Id, var_ids), token);
 
-                //if we fail we just buble that to the IDE (and let it panic over it)
-                if (res.IsErr)
-                    return res;
-
-                JObject[] values = res.Value?["result"]?["value"]?.Values<JObject>().ToArray();
-
-                if (values == null || values.Length == 0)
-                    return Result.OkFromObject(new { result = Array.Empty<object>() });
-
-                PerScopeCache frameCache = ctx.GetCacheForScope(scope_id);
-                foreach (JObject value in values)
+                var values = await sdbHelper.StackFrameGetValues(msg_id, scope.Method, ctx.ThreadId, scope_id, var_ids, token);
+                if (values != null)
                 {
-                    frameCache.Locals[value["name"]?.Value<string>()] = value;
-                }
+                    if (values == null || values.Count == 0)
+                        return Result.OkFromObject(new { result = Array.Empty<object>() });
 
-                return Result.OkFromObject(new { result = values });
+                    PerScopeCache frameCache = ctx.GetCacheForScope(scope_id);
+                    foreach (JObject value in values)
+                    {
+                        frameCache.Locals[value["name"]?.Value<string>()] = value;
+                    }
+                    return Result.OkFromObject(new { result = values });
+                }
+                return Result.OkFromObject(new { result = Array.Empty<object>() });
             }
             catch (Exception exception)
             {
@@ -1055,16 +1129,16 @@ private async Task<Breakpoint> SetMonoBreakpoint(SessionId sessionId, string req
             int method_token = bp.Location.CliLocation.Method.Token;
             int il_offset = bp.Location.CliLocation.Offset;
 
-            Result res = await SendMonoCommand(sessionId, MonoCommands.SetBreakpoint(asm_name, method_token, il_offset), token);
-            int? ret_code = res.Value?["result"]?["value"]?.Value<int>();
+            var assembly_id = await sdbHelper.GetAssemblyId(sessionId, asm_name, token);
+            var method_id = await sdbHelper.GetMethodIdByToken(sessionId, assembly_id, method_token, token);
+            var breakpoint_id = await sdbHelper.SetBreakpoint(sessionId, method_id, il_offset, token);
 
-            if (ret_code.HasValue)
+            if (breakpoint_id > 0)
             {
-                bp.RemoteId = ret_code.Value;
+                bp.RemoteId = breakpoint_id;
                 bp.State = BreakpointState.Active;
                 //Log ("verbose", $"BP local id {bp.LocalId} enabled with remote id {bp.RemoteId}");
             }
-
             return bp;
         }
 
@@ -1072,7 +1146,6 @@ private async Task OnSourceFileAdded(SessionId sessionId, SourceFile source, Exe
         {
             JObject scriptSource = JObject.FromObject(source.ToScriptSource(context.Id, context.AuxData));
             Log("debug", $"sending {source.Url} {context.Id} {sessionId.sessionId}");
-
             SendEvent(sessionId, "Debugger.scriptParsed", scriptSource, token);
 
             foreach (var req in context.BreakpointRequests.Values)
@@ -1084,7 +1157,7 @@ private async Task OnSourceFileAdded(SessionId sessionId, SourceFile source, Exe
             }
         }
 
-        private async Task<DebugStore> LoadStore(SessionId sessionId, CancellationToken token)
+        internal async Task<DebugStore> LoadStore(SessionId sessionId, CancellationToken token)
         {
             ExecutionContext context = GetContext(sessionId);
 
@@ -1123,16 +1196,22 @@ private async Task<DebugStore> RuntimeReady(SessionId sessionId, CancellationTok
             if (Interlocked.CompareExchange(ref context.ready, new TaskCompletionSource<DebugStore>(), null) != null)
                 return await context.ready.Task;
 
-            Result clear_result = await SendMonoCommand(sessionId, MonoCommands.ClearAllBreakpoints(), token);
-            if (clear_result.IsErr)
+            var command_params = new MemoryStream();
+            var ret_debugger_cmd_reader = await sdbHelper.SendDebuggerAgentCommand<CmdEventRequest>(sessionId, CmdEventRequest.ClearAllBreakpoints, command_params, token);
+            if (ret_debugger_cmd_reader == null)
             {
-                Log("verbose", $"Failed to clear breakpoints due to {clear_result}");
+                Log("verbose", $"Failed to clear breakpoints");
             }
 
+<<<<<<< HEAD
             if (context.PauseOnCaught && context.PauseOnUncaught)
                 await SendMonoCommand(sessionId, MonoCommands.SetPauseOnExceptions("all"), token);
             else if (context.PauseOnUncaught)
                 await SendMonoCommand(sessionId, MonoCommands.SetPauseOnExceptions("uncaught"), token);
+=======
+            await sdbHelper.SetProtocolVersion(sessionId, token);
+            await sdbHelper.EnableReceiveUserBreakRequest(sessionId, token);
+>>>>>>> origin/main
 
             DebugStore store = await LoadStore(sessionId, token);
 
@@ -1151,10 +1230,8 @@ private async Task RemoveBreakpoint(MessageId msg_id, JObject args, Cancellation
 
             foreach (Breakpoint bp in breakpointRequest.Locations)
             {
-                Result res = await SendMonoCommand(msg_id, MonoCommands.RemoveBreakpoint(bp.RemoteId), token);
-                int? ret_code = res.Value?["result"]?["value"]?.Value<int>();
-
-                if (ret_code.HasValue)
+                var breakpoint_removed = await sdbHelper.RemoveBreakpoint(msg_id, bp.RemoteId, token);
+                if (breakpoint_removed)
                 {
                     bp.RemoteId = -1;
                     bp.State = BreakpointState.Disabled;
diff --git a/src/mono/wasm/debugger/BrowserDebugProxy/MonoSDBHelper.cs b/src/mono/wasm/debugger/BrowserDebugProxy/MonoSDBHelper.cs
new file mode 100644
index 00000000000000..c296c8501473a5
--- /dev/null
+++ b/src/mono/wasm/debugger/BrowserDebugProxy/MonoSDBHelper.cs
@@ -0,0 +1,1779 @@
+// 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.IO;
+using System.Linq;
+using System.Net;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis;
+using Microsoft.Extensions.Logging;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using System.Net.Http;
+using System.Text.RegularExpressions;
+
+namespace Microsoft.WebAssembly.Diagnostics
+{
+    internal enum TokenType
+    {
+        MdtModule               = 0x00000000,       //
+        MdtTypeRef              = 0x01000000,       //
+        MdtTypeDef              = 0x02000000,       //
+        MdtFieldDef             = 0x04000000,       //
+        MdtMethodDef            = 0x06000000,       //
+        MdtParamDef             = 0x08000000,       //
+        MdtInterfaceImpl        = 0x09000000,       //
+        MdtMemberRef            = 0x0a000000,       //
+        MdtCustomAttribute      = 0x0c000000,       //
+        MdtPermission           = 0x0e000000,       //
+        MdtSignature            = 0x11000000,       //
+        MdtEvent                = 0x14000000,       //
+        MdtProperty             = 0x17000000,       //
+        MdtModuleRef            = 0x1a000000,       //
+        MdtTypeSpec             = 0x1b000000,       //
+        MdtAssembly             = 0x20000000,       //
+        MdtAssemblyRef          = 0x23000000,       //
+        MdtFile                 = 0x26000000,       //
+        MdtExportedType         = 0x27000000,       //
+        MdtManifestResource     = 0x28000000,       //
+        MdtGenericParam         = 0x2a000000,       //
+        MdtMethodSpec           = 0x2b000000,       //
+        MdtGenericParamConstraint = 0x2c000000,
+        MdtString               = 0x70000000,       //
+        MdtName                 = 0x71000000,       //
+        MdtBaseType             = 0x72000000,       // Leave this on the high end value. This does not correspond to metadata table
+    }
+
+    internal enum CommandSet {
+        Vm = 1,
+        ObjectRef = 9,
+        StringRef = 10,
+        Thread = 11,
+        ArrayRef = 13,
+        EventRequest = 15,
+        StackFrame = 16,
+        AppDomain = 20,
+        Assembly = 21,
+        Method = 22,
+        Type = 23,
+        Module = 24,
+        Field = 25,
+        Event = 64,
+        Pointer = 65
+    }
+
+    internal enum EventKind {
+        VmStart = 0,
+        VmDeath = 1,
+        ThreadStart = 2,
+        ThreadDeath = 3,
+        AppDomainCreate = 4,
+        AppDomainUnload = 5,
+        MethodEntry = 6,
+        MethodExit = 7,
+        AssemblyLoad = 8,
+        AssemblyUnload = 9,
+        Breakpoint = 10,
+        Step = 11,
+        TypeLoad = 12,
+        Exception = 13,
+        KeepAlive = 14,
+        UserBreak = 15,
+        UserLog = 16,
+        Crash = 17
+    }
+
+    internal enum ModifierKind {
+        Count = 1,
+        ThreadOnly = 3,
+        LocationOnly = 7,
+        ExceptionOnly = 8,
+        Step = 10,
+        AssemblyOnly = 11,
+        SourceFileOnly = 12,
+        TypeNameOnly = 13
+    }
+
+
+    internal enum SuspendPolicy {
+        None = 0,
+        EventThread = 1,
+        All = 2
+    }
+
+    internal enum CmdVM {
+        Version = 1,
+        AllThreads = 2,
+        Suspend = 3,
+        Resume = 4,
+        Exit = 5,
+        Dispose = 6,
+        InvokeMethod = 7,
+        SetProtocolVersion = 8,
+        AbortInvoke = 9,
+        SetKeepAlive = 10,
+        GetTypesForSourceFile = 11,
+        GetTypes = 12,
+        InvokeMethods = 13,
+        StartBuffering = 14,
+        StopBuffering = 15,
+        VmReadMemory = 16,
+        VmWriteMemory = 17,
+        GetAssemblyByName = 18
+    }
+
+    internal enum CmdFrame {
+        GetValues = 1,
+        GetThis = 2,
+        SetValues = 3,
+        GetDomain = 4,
+        SetThis = 5,
+        GetArgument = 6,
+        GetArguments = 7
+    }
+
+    internal enum CmdEvent {
+        Composite = 100
+    }
+
+    internal enum CmdThread {
+        GetFrameInfo = 1,
+        GetName = 2,
+        GetState = 3,
+        GetInfo = 4,
+        /* FIXME: Merge into GetInfo when the major protocol version is increased */
+        GetId = 5,
+        /* Ditto */
+        GetTid = 6,
+        SetIp = 7,
+        GetElapsedTime = 8
+    }
+
+    internal enum CmdEventRequest {
+        Set = 1,
+        Clear = 2,
+        ClearAllBreakpoints = 3
+    }
+
+    internal enum CmdAppDomain {
+        GetRootDomain = 1,
+        GetFriendlyName = 2,
+        GetAssemblies = 3,
+        GetEntryAssembly = 4,
+        CreateString = 5,
+        GetCorLib = 6,
+        CreateBoxedValue = 7,
+        CreateByteArray = 8,
+    }
+
+    internal enum CmdAssembly {
+        GetLocation = 1,
+        GetEntryPoint = 2,
+        GetManifestModule = 3,
+        GetObject = 4,
+        GetType = 5,
+        GetName = 6,
+        GetDomain = 7,
+        GetMetadataBlob = 8,
+        GetIsDynamic = 9,
+        GetPdbBlob = 10,
+        GetTypeFromToken = 11,
+        GetMethodFromToken = 12,
+        HasDebugInfo = 13,
+    }
+
+    internal enum CmdModule {
+        GetInfo = 1,
+        ApplyChanges = 2,
+    }
+
+    internal enum CmdPointer{
+        GetValue = 1
+    }
+
+    internal enum CmdMethod {
+        GetName = 1,
+        GetDeclaringType = 2,
+        GetDebugInfo = 3,
+        GetParamInfo = 4,
+        GetLocalsInfo = 5,
+        GetInfo = 6,
+        GetBody = 7,
+        ResolveToken = 8,
+        GetCattrs = 9,
+        MakeGenericMethod = 10,
+        Token = 11,
+        Assembly = 12,
+        ClassToken = 13,
+        AsyncDebugInfo = 14,
+        GetNameFull = 15
+    }
+
+    internal enum CmdType {
+        GetInfo = 1,
+        GetMethods = 2,
+        GetFields = 3,
+        GetValues = 4,
+        GetObject = 5,
+        GetSourceFiles = 6,
+        SetValues = 7,
+        IsAssignableFrom = 8,
+        GetProperties = 9,
+        GetCattrs = 10,
+        GetFieldCattrs = 11,
+        GetPropertyCattrs = 12,
+        /* FIXME: Merge into GetSourceFiles when the major protocol version is increased */
+        GetSourceFiles2 = 13,
+        /* FIXME: Merge into GetValues when the major protocol version is increased */
+        GetValues2 = 14,
+        GetMethodsByNameFlags = 15,
+        GetInterfaces = 16,
+        GetInterfacesMap = 17,
+        IsInitialized = 18,
+        CreateInstance = 19,
+        GetValueSize = 20,
+        GetValuesICorDbg = 21,
+        GetParents = 22
+    }
+
+    internal enum CmdArray {
+        GetLength = 1,
+        GetValues = 2,
+        SetValues = 3,
+        RefGetType = 4
+    }
+
+
+    internal enum CmdField {
+        GetInfo = 1
+    }
+
+    internal enum CmdString {
+        GetValue = 1,
+        GetLength = 2,
+        GetChars = 3
+    }
+
+    internal enum CmdObject {
+        RefGetType = 1,
+        RefGetValues = 2,
+        RefIsCollected = 3,
+        RefGetAddress = 4,
+        RefGetDomain = 5,
+        RefSetValues = 6,
+        RefGetInfo = 7,
+        GetValuesICorDbg = 8,
+        RefDelegateGetMethod = 9,
+        RefIsDelegate = 10
+    }
+
+    internal enum ElementType {
+        End             = 0x00,
+        Void            = 0x01,
+        Boolean         = 0x02,
+        Char            = 0x03,
+        I1              = 0x04,
+        U1              = 0x05,
+        I2              = 0x06,
+        U2              = 0x07,
+        I4              = 0x08,
+        U4              = 0x09,
+        I8              = 0x0a,
+        U8              = 0x0b,
+        R4              = 0x0c,
+        R8              = 0x0d,
+        String          = 0x0e,
+        Ptr             = 0x0f,
+        ByRef           = 0x10,
+        ValueType       = 0x11,
+        Class           = 0x12,
+        Var             = 0x13,
+        Array           = 0x14,
+        GenericInst     = 0x15,
+        TypedByRef      = 0x16,
+        I               = 0x18,
+        U               = 0x19,
+        FnPtr           = 0x1b,
+        Object          = 0x1c,
+        SzArray         = 0x1d,
+        MVar            = 0x1e,
+        CModReqD        = 0x1f,
+        CModOpt         = 0x20,
+        Internal        = 0x21,
+        Modifier        = 0x40,
+        Sentinel        = 0x41,
+        Pinned          = 0x45,
+
+        Type            = 0x50,
+        Boxed           = 0x51,
+        Enum            = 0x55
+    }
+
+    internal enum ValueTypeId {
+        Null = 0xf0,
+        Type = 0xf1,
+        VType = 0xf2,
+        FixedArray = 0xf3
+    }
+    internal enum MonoTypeNameFormat{
+        FormatIL,
+        FormatReflection,
+        FullName,
+        AssemblyQualified
+    }
+
+    internal enum StepFilter {
+        None = 0,
+        StaticCtor = 1,
+        DebuggerHidden = 2,
+        DebuggerStepThrough = 4,
+        DebuggerNonUserCode = 8
+    }
+
+    internal class MonoBinaryReader : BinaryReader
+    {
+        public MonoBinaryReader(Stream stream) : base(stream) {}
+
+        internal static unsafe void PutBytesBE (byte *dest, byte *src, int count)
+        {
+            int i = 0;
+
+            if (BitConverter.IsLittleEndian){
+                dest += count;
+                for (; i < count; i++)
+                    *(--dest) = *src++;
+            } else {
+                for (; i < count; i++)
+                    *dest++ = *src++;
+            }
+        }
+
+        public override string ReadString()
+        {
+            var valueLen = ReadInt32();
+            char[] value = new char[valueLen];
+            Read(value, 0, valueLen);
+            return new string(value);
+        }
+        public unsafe long ReadLong()
+        {
+            byte[] data = new byte[8];
+            Read(data, 0, 8);
+
+            long ret;
+            fixed (byte *src = &data[0]){
+                PutBytesBE ((byte *) &ret, src, 8);
+            }
+
+            return ret;
+        }
+        public override unsafe sbyte ReadSByte()
+        {
+            byte[] data = new byte[4];
+            Read(data, 0, 4);
+
+            int ret;
+            fixed (byte *src = &data[0]){
+                PutBytesBE ((byte *) &ret, src, 4);
+            }
+            return (sbyte)ret;
+        }
+
+        public unsafe byte ReadUByte()
+        {
+            byte[] data = new byte[4];
+            Read(data, 0, 4);
+
+            int ret;
+            fixed (byte *src = &data[0]){
+                PutBytesBE ((byte *) &ret, src, 4);
+            }
+            return (byte)ret;
+        }
+
+        public override unsafe int ReadInt32()
+        {
+            byte[] data = new byte[4];
+            Read(data, 0, 4);
+            int ret;
+            fixed (byte *src = &data[0]){
+                PutBytesBE ((byte *) &ret, src, 4);
+            }
+            return ret;
+        }
+
+        public override unsafe double ReadDouble()
+        {
+            byte[] data = new byte[8];
+            Read(data, 0, 8);
+
+            double ret;
+            fixed (byte *src = &data[0]){
+                PutBytesBE ((byte *) &ret, src, 8);
+            }
+            return ret;
+        }
+
+        public override unsafe uint ReadUInt32()
+        {
+            byte[] data = new byte[4];
+            Read(data, 0, 4);
+
+            uint ret;
+            fixed (byte *src = &data[0]){
+                PutBytesBE ((byte *) &ret, src, 4);
+            }
+            return ret;
+        }
+        public unsafe ushort ReadUShort()
+        {
+            byte[] data = new byte[4];
+            Read(data, 0, 4);
+
+            uint ret;
+            fixed (byte *src = &data[0]){
+                PutBytesBE ((byte *) &ret, src, 4);
+            }
+            return (ushort)ret;
+        }
+    }
+
+    internal class MonoBinaryWriter : BinaryWriter
+    {
+        public MonoBinaryWriter(Stream stream) : base(stream) {}
+        public void WriteString(string val)
+        {
+            Write(val.Length);
+            Write(val.ToCharArray());
+        }
+        public void WriteLong(long val)
+        {
+            Write((int)((val >> 32) & 0xffffffff));
+            Write((int)((val >> 0) & 0xffffffff));
+        }
+        public override void Write(int val)
+        {
+            byte[] bytes = BitConverter.GetBytes(val);
+            Array.Reverse(bytes, 0, bytes.Length);
+            Write(bytes);
+        }
+        public void WriteObj(DotnetObjectId objectId, MonoSDBHelper sdbHelper)
+        {
+            if (objectId.Scheme == "object")
+            {
+                Write((byte)ElementType.Class);
+                Write(int.Parse(objectId.Value));
+            }
+            if (objectId.Scheme == "valuetype")
+            {
+                Write(sdbHelper.valueTypes[int.Parse(objectId.Value)].valueTypeBuffer);
+            }
+        }
+    }
+    internal class FieldTypeClass
+    {
+        public int Id { get; }
+        public string Name { get; }
+        public int TypeId { get; }
+        public FieldTypeClass(int id, string name, int typeId)
+        {
+            Id = id;
+            Name = name;
+            TypeId = typeId;
+        }
+    }
+    internal class ValueTypeClass
+    {
+        public byte[] valueTypeBuffer;
+        public JArray valueTypeJson;
+        public JArray valueTypeJsonProps;
+        public int typeId;
+        public JArray valueTypeProxy;
+        public string valueTypeVarName;
+        public bool valueTypeAutoExpand;
+        public int Id;
+        public ValueTypeClass(string varName, byte[] buffer, JArray json, int id, bool expand_properties, int valueTypeId)
+        {
+            valueTypeBuffer = buffer;
+            valueTypeJson = json;
+            typeId = id;
+            valueTypeJsonProps = null;
+            valueTypeProxy = null;
+            valueTypeVarName = varName;
+            valueTypeAutoExpand = expand_properties;
+            Id = valueTypeId;
+        }
+    }
+    internal class PointerValue
+    {
+        public long address;
+        public int typeId;
+        public string varName;
+        public PointerValue(long address, int typeId, string varName)
+        {
+            this.address = address;
+            this.typeId = typeId;
+            this.varName = varName;
+        }
+
+    }
+    internal class MonoSDBHelper
+    {
+        internal Dictionary<int, ValueTypeClass> valueTypes = new Dictionary<int, ValueTypeClass>();
+        internal Dictionary<int, PointerValue> pointerValues = new Dictionary<int, PointerValue>();
+        private static int debugger_object_id;
+        private static int cmd_id;
+        private static int GetId() {return cmd_id++;}
+        private MonoProxy proxy;
+        private static int MINOR_VERSION = 61;
+        private static int MAJOR_VERSION = 2;
+        public MonoSDBHelper(MonoProxy proxy)
+        {
+            this.proxy = proxy;
+        }
+
+        public void ClearCache()
+        {
+            valueTypes = new Dictionary<int, ValueTypeClass>();
+            pointerValues = new Dictionary<int, PointerValue>();
+        }
+
+        public async Task<bool> SetProtocolVersion(SessionId sessionId, CancellationToken token)
+        {
+            var command_params = new MemoryStream();
+            var command_params_writer = new MonoBinaryWriter(command_params);
+            command_params_writer.Write(MAJOR_VERSION);
+            command_params_writer.Write(MINOR_VERSION);
+
+            var ret_debugger_cmd_reader = await SendDebuggerAgentCommand<CmdVM>(sessionId, CmdVM.SetProtocolVersion, command_params, token);
+            return true;
+        }
+        public async Task<bool> EnableReceiveUserBreakRequest(SessionId sessionId, CancellationToken token)
+        {
+            var command_params = new MemoryStream();
+            var command_params_writer = new MonoBinaryWriter(command_params);
+            command_params_writer.Write((byte)EventKind.UserBreak);
+            command_params_writer.Write((byte)SuspendPolicy.None);
+            command_params_writer.Write((byte)0);
+            var ret_debugger_cmd_reader = await SendDebuggerAgentCommand<CmdEventRequest>(sessionId, CmdEventRequest.Set, command_params, token);
+            return true;
+        }
+        internal async Task<MonoBinaryReader> SendDebuggerAgentCommandInternal(SessionId sessionId, int command_set, int command, MemoryStream parms, CancellationToken token)
+        {
+            Result res = await proxy.SendMonoCommand(sessionId, MonoCommands.SendDebuggerAgentCommand(GetId(), command_set, command, Convert.ToBase64String(parms.ToArray())), token);
+            if (res.IsErr) {
+                throw new Exception($"SendDebuggerAgentCommand Error - {(CommandSet)command_set} - {command}");
+            }
+            byte[] newBytes = Convert.FromBase64String(res.Value?["result"]?["value"]?["value"]?.Value<string>());
+            var ret_debugger_cmd = new MemoryStream(newBytes);
+            var ret_debugger_cmd_reader = new MonoBinaryReader(ret_debugger_cmd);
+            return ret_debugger_cmd_reader;
+        }
+
+        internal CommandSet GetCommandSetForCommand<T>(T command) =>
+            command switch {
+                CmdVM => CommandSet.Vm,
+                CmdObject => CommandSet.ObjectRef,
+                CmdString => CommandSet.StringRef,
+                CmdThread => CommandSet.Thread,
+                CmdArray => CommandSet.ArrayRef,
+                CmdEventRequest => CommandSet.EventRequest,
+                CmdFrame => CommandSet.StackFrame,
+                CmdAppDomain => CommandSet.AppDomain,
+                CmdAssembly => CommandSet.Assembly,
+                CmdMethod => CommandSet.Method,
+                CmdType => CommandSet.Type,
+                CmdModule => CommandSet.Module,
+                CmdField => CommandSet.Field,
+                CmdEvent => CommandSet.Event,
+                CmdPointer => CommandSet.Pointer,
+                _ => throw new Exception ("Unknown CommandSet")
+            };
+
+        internal Task<MonoBinaryReader> SendDebuggerAgentCommand<T>(SessionId sessionId, T command, MemoryStream parms, CancellationToken token) where T : Enum =>
+            SendDebuggerAgentCommandInternal(sessionId, (int)GetCommandSetForCommand(command), (int)(object)command, parms, token);
+
+        internal Task<MonoBinaryReader> SendDebuggerAgentCommandWithParms<T>(SessionId sessionId, T command, MemoryStream parms, int type, string extraParm, CancellationToken token) where T : Enum =>
+            SendDebuggerAgentCommandWithParmsInternal(sessionId, (int)GetCommandSetForCommand(command), (int)(object)command, parms, type, extraParm, token);
+
+        internal async Task<MonoBinaryReader> SendDebuggerAgentCommandWithParmsInternal(SessionId sessionId, int command_set, int command, MemoryStream parms, int type, string extraParm, CancellationToken token)
+        {
+            Result res = await proxy.SendMonoCommand(sessionId, MonoCommands.SendDebuggerAgentCommandWithParms(GetId(), command_set, command, Convert.ToBase64String(parms.ToArray()), parms.ToArray().Length, type, extraParm), token);
+            if (res.IsErr) {
+                throw new Exception("SendDebuggerAgentCommandWithParms Error");
+            }
+            byte[] newBytes = Convert.FromBase64String(res.Value?["result"]?["value"]?["value"]?.Value<string>());
+            var ret_debugger_cmd = new MemoryStream(newBytes);
+            var ret_debugger_cmd_reader = new MonoBinaryReader(ret_debugger_cmd);
+            return ret_debugger_cmd_reader;
+        }
+
+        public async Task<int> GetMethodToken(SessionId sessionId, int method_id, CancellationToken token)
+        {
+            var command_params = new MemoryStream();
+            var command_params_writer = new MonoBinaryWriter(command_params);
+            command_params_writer.Write(method_id);
+
+            var ret_debugger_cmd_reader = await SendDebuggerAgentCommand<CmdMethod>(sessionId, CmdMethod.Token, command_params, token);
+            return ret_debugger_cmd_reader.ReadInt32() & 0xffffff; //token
+        }
+
+        public async Task<int> GetMethodIdByToken(SessionId sessionId, int assembly_id, int method_token, CancellationToken token)
+        {
+            var command_params = new MemoryStream();
+            var command_params_writer = new MonoBinaryWriter(command_params);
+            command_params_writer.Write(assembly_id);
+            command_params_writer.Write(method_token | (int)TokenType.MdtMethodDef);
+            var ret_debugger_cmd_reader = await SendDebuggerAgentCommand<CmdAssembly>(sessionId, CmdAssembly.GetMethodFromToken, command_params, token);
+            return ret_debugger_cmd_reader.ReadInt32();
+        }
+
+        public async Task<int> GetAssemblyIdFromMethod(SessionId sessionId, int method_id, CancellationToken token)
+        {
+            var command_params = new MemoryStream();
+            var command_params_writer = new MonoBinaryWriter(command_params);
+            command_params_writer.Write(method_id);
+
+            var ret_debugger_cmd_reader = await SendDebuggerAgentCommand<CmdMethod>(sessionId, CmdMethod.Assembly, command_params, token);
+            return ret_debugger_cmd_reader.ReadInt32(); //assembly_id
+        }
+
+        public async Task<int> GetAssemblyId(SessionId sessionId, string asm_name, CancellationToken token)
+        {
+            var command_params = new MemoryStream();
+            var command_params_writer = new MonoBinaryWriter(command_params);
+            command_params_writer.WriteString(asm_name);
+
+            var ret_debugger_cmd_reader = await SendDebuggerAgentCommand<CmdVM>(sessionId, CmdVM.GetAssemblyByName, command_params, token);
+            return ret_debugger_cmd_reader.ReadInt32();
+        }
+
+        public async Task<string> GetAssemblyName(SessionId sessionId, int assembly_id, CancellationToken token)
+        {
+            var command_params = new MemoryStream();
+            var command_params_writer = new MonoBinaryWriter(command_params);
+            command_params_writer.Write(assembly_id);
+
+            var ret_debugger_cmd_reader = await SendDebuggerAgentCommand<CmdAssembly>(sessionId, CmdAssembly.GetLocation, command_params, token);
+            return ret_debugger_cmd_reader.ReadString();
+        }
+
+
+        public async Task<string> GetAssemblyNameFull(SessionId sessionId, int assembly_id, CancellationToken token)
+        {
+            var command_params = new MemoryStream();
+            var command_params_writer = new MonoBinaryWriter(command_params);
+            command_params_writer.Write(assembly_id);
+
+            var ret_debugger_cmd_reader = await SendDebuggerAgentCommand<CmdAssembly>(sessionId, CmdAssembly.GetName, command_params, token);
+            var name = ret_debugger_cmd_reader.ReadString();
+            return name.Remove(name.IndexOf(",")) + ".dll";
+        }
+
+        public async Task<string> GetMethodName(SessionId sessionId, int method_id, CancellationToken token)
+        {
+            var command_params = new MemoryStream();
+            var command_params_writer = new MonoBinaryWriter(command_params);
+            command_params_writer.Write(method_id);
+
+            var ret_debugger_cmd_reader = await SendDebuggerAgentCommand<CmdMethod>(sessionId, CmdMethod.GetNameFull, command_params, token);
+            var methodName = ret_debugger_cmd_reader.ReadString();
+            return methodName.Substring(methodName.IndexOf(":")+1);
+        }
+
+        public async Task<bool> MethodIsStatic(SessionId sessionId, int method_id, CancellationToken token)
+        {
+            var command_params = new MemoryStream();
+            var command_params_writer = new MonoBinaryWriter(command_params);
+            command_params_writer.Write(method_id);
+
+            var ret_debugger_cmd_reader = await SendDebuggerAgentCommand<CmdMethod>(sessionId, CmdMethod.GetInfo, command_params, token);
+            var flags = ret_debugger_cmd_reader.ReadInt32();
+            return (flags & 0x0010) > 0; //check method is static
+        }
+
+        public async Task<int> GetParamCount(SessionId sessionId, int method_id, CancellationToken token)
+        {
+            var command_params = new MemoryStream();
+            var command_params_writer = new MonoBinaryWriter(command_params);
+            command_params_writer.Write(method_id);
+
+            var ret_debugger_cmd_reader = await SendDebuggerAgentCommand<CmdMethod>(sessionId, CmdMethod.GetParamInfo, command_params, token);
+            ret_debugger_cmd_reader.ReadInt32();
+            int param_count = ret_debugger_cmd_reader.ReadInt32();
+            return param_count;
+        }
+
+        public async Task<string> GetReturnType(SessionId sessionId, int method_id, CancellationToken token)
+        {
+            var command_params = new MemoryStream();
+            var command_params_writer = new MonoBinaryWriter(command_params);
+            command_params_writer.Write(method_id);
+
+            var ret_debugger_cmd_reader = await SendDebuggerAgentCommand<CmdMethod>(sessionId, CmdMethod.GetParamInfo, command_params, token);
+            ret_debugger_cmd_reader.ReadInt32();
+            ret_debugger_cmd_reader.ReadInt32();
+            ret_debugger_cmd_reader.ReadInt32();
+            var retType = ret_debugger_cmd_reader.ReadInt32();
+            var ret = await GetTypeName(sessionId, retType, token);
+            return ret;
+        }
+
+        public async Task<string> GetParameters(SessionId sessionId, int method_id, CancellationToken token)
+        {
+            var command_params = new MemoryStream();
+            var command_params_writer = new MonoBinaryWriter(command_params);
+            command_params_writer.Write(method_id);
+
+            var ret_debugger_cmd_reader = await SendDebuggerAgentCommand<CmdMethod>(sessionId, CmdMethod.GetParamInfo, command_params, token);
+            ret_debugger_cmd_reader.ReadInt32();
+            var paramCount = ret_debugger_cmd_reader.ReadInt32();
+            ret_debugger_cmd_reader.ReadInt32();
+            var retType = ret_debugger_cmd_reader.ReadInt32();
+            var parameters = "(";
+            for (int i = 0 ; i < paramCount; i++)
+            {
+                var paramType = ret_debugger_cmd_reader.ReadInt32();
+                parameters += await GetTypeName(sessionId, paramType, token);
+                parameters = parameters.Replace("System.Func", "Func");
+                if (i + 1 < paramCount)
+                    parameters += ",";
+            }
+            parameters += ")";
+            return parameters;
+        }
+
+        public async Task<int> SetBreakpoint(SessionId sessionId, int method_id, long il_offset, CancellationToken token)
+        {
+            var command_params = new MemoryStream();
+            var command_params_writer = new MonoBinaryWriter(command_params);
+            command_params_writer.Write((byte)EventKind.Breakpoint);
+            command_params_writer.Write((byte)SuspendPolicy.None);
+            command_params_writer.Write((byte)1);
+            command_params_writer.Write((byte)ModifierKind.LocationOnly);
+            command_params_writer.Write(method_id);
+            command_params_writer.WriteLong(il_offset);
+            var ret_debugger_cmd_reader = await SendDebuggerAgentCommand<CmdEventRequest>(sessionId, CmdEventRequest.Set, command_params, token);
+            return ret_debugger_cmd_reader.ReadInt32();
+        }
+
+        public async Task<bool> RemoveBreakpoint(SessionId sessionId, int breakpoint_id, CancellationToken token)
+        {
+            var command_params = new MemoryStream();
+            var command_params_writer = new MonoBinaryWriter(command_params);
+            command_params_writer.Write((byte)EventKind.Breakpoint);
+            command_params_writer.Write((int) breakpoint_id);
+
+            var ret_debugger_cmd_reader = await SendDebuggerAgentCommand<CmdEventRequest>(sessionId, CmdEventRequest.Clear, command_params, token);
+
+            if (ret_debugger_cmd_reader != null)
+                return true;
+            return false;
+        }
+
+        public async Task<bool> Step(SessionId sessionId, int thread_id, StepKind kind, CancellationToken token)
+        {
+            var command_params = new MemoryStream();
+            var command_params_writer = new MonoBinaryWriter(command_params);
+            command_params_writer.Write((byte)EventKind.Step);
+            command_params_writer.Write((byte)SuspendPolicy.None);
+            command_params_writer.Write((byte)1);
+            command_params_writer.Write((byte)ModifierKind.Step);
+            command_params_writer.Write(thread_id);
+            command_params_writer.Write((int)0);
+            command_params_writer.Write((int)kind);
+            command_params_writer.Write((int)(StepFilter.StaticCtor | StepFilter.DebuggerHidden)); //filter
+            var ret_debugger_cmd_reader = await SendDebuggerAgentCommand<CmdEventRequest>(sessionId, CmdEventRequest.Set, command_params, token);
+            if (ret_debugger_cmd_reader == null)
+                return false;
+            var isBPOnManagedCode = ret_debugger_cmd_reader.ReadInt32();
+            if (isBPOnManagedCode == 0)
+                return false;
+            return true;
+        }
+
+        public async Task<bool> ClearSingleStep(SessionId sessionId, int req_id, CancellationToken token)
+        {
+            var command_params = new MemoryStream();
+            var command_params_writer = new MonoBinaryWriter(command_params);
+            command_params_writer.Write((byte)EventKind.Step);
+            command_params_writer.Write((int) req_id);
+
+            var ret_debugger_cmd_reader = await SendDebuggerAgentCommand<CmdEventRequest>(sessionId, CmdEventRequest.Clear, command_params, token);
+
+            if (ret_debugger_cmd_reader != null)
+                return true;
+            return false;
+        }
+
+        public async Task<List<FieldTypeClass>> GetTypeFields(SessionId sessionId, int type_id, CancellationToken token)
+        {
+            var ret = new List<FieldTypeClass>();
+            var command_params = new MemoryStream();
+            var command_params_writer = new MonoBinaryWriter(command_params);
+            command_params_writer.Write(type_id);
+
+            var ret_debugger_cmd_reader = await SendDebuggerAgentCommand<CmdType>(sessionId, CmdType.GetFields, command_params, token);
+            var nFields = ret_debugger_cmd_reader.ReadInt32();
+
+            for (int i = 0 ; i < nFields; i++)
+            {
+                int fieldId = ret_debugger_cmd_reader.ReadInt32(); //fieldId
+                string fieldNameStr = ret_debugger_cmd_reader.ReadString();
+                int typeId = ret_debugger_cmd_reader.ReadInt32(); //typeId
+                ret_debugger_cmd_reader.ReadInt32(); //attrs
+                if (fieldNameStr.Contains("k__BackingField"))
+                {
+                    fieldNameStr = fieldNameStr.Replace("k__BackingField", "");
+                    fieldNameStr = fieldNameStr.Replace("<", "");
+                    fieldNameStr = fieldNameStr.Replace(">", "");
+                }
+                ret.Add(new FieldTypeClass(fieldId, fieldNameStr, typeId));
+            }
+            return ret;
+        }
+        public string ReplaceCommonClassNames(string className)
+        {
+            className = className.Replace("System.String", "string");
+            className = className.Replace("System.Boolean", "bool");
+            className = className.Replace("System.Char", "char");
+            className = className.Replace("System.Int32", "int");
+            className = className.Replace("System.Object", "object");
+            className = className.Replace("System.Void", "void");
+            className = className.Replace("System.Byte", "byte");
+            return className;
+        }
+        public async Task<string> GetTypeName(SessionId sessionId, int type_id, CancellationToken token)
+        {
+            var command_params = new MemoryStream();
+            var command_params_writer = new MonoBinaryWriter(command_params);
+            command_params_writer.Write(type_id);
+            command_params_writer.Write((int) MonoTypeNameFormat.FormatReflection);
+            var ret_debugger_cmd_reader = await SendDebuggerAgentCommand<CmdType>(sessionId, CmdType.GetInfo, command_params, token);
+
+            ret_debugger_cmd_reader.ReadString();
+
+            ret_debugger_cmd_reader.ReadString();
+
+            string className = ret_debugger_cmd_reader.ReadString();
+
+            className = className.Replace("+", ".");
+            className = Regex.Replace(className, @"`\d+", "");
+            className = className.Replace("[]", "__SQUARED_BRACKETS__");
+            className = className.Replace("[", "<");
+            className = className.Replace("]", ">");
+            className = className.Replace("__SQUARED_BRACKETS__", "[]");
+            className = className.Replace(",", ", ");
+            className = ReplaceCommonClassNames(className);
+            return className;
+        }
+
+        public async Task<string> GetStringValue(SessionId sessionId, int string_id, CancellationToken token)
+        {
+            var command_params = new MemoryStream();
+            var command_params_writer = new MonoBinaryWriter(command_params);
+            command_params_writer.Write(string_id);
+
+            var ret_debugger_cmd_reader = await SendDebuggerAgentCommand<CmdString>(sessionId, CmdString.GetValue, command_params, token);
+            var isUtf16 = ret_debugger_cmd_reader.ReadByte();
+            if (isUtf16 == 0) {
+                return ret_debugger_cmd_reader.ReadString();
+            }
+            return null;
+        }
+        public async Task<int> GetArrayLength(SessionId sessionId, int object_id, CancellationToken token)
+        {
+            var command_params = new MemoryStream();
+            var command_params_writer = new MonoBinaryWriter(command_params);
+            command_params_writer.Write(object_id);
+            var ret_debugger_cmd_reader = await SendDebuggerAgentCommand<CmdArray>(sessionId, CmdArray.GetLength, command_params, token);
+            var length = ret_debugger_cmd_reader.ReadInt32();
+            length = ret_debugger_cmd_reader.ReadInt32();
+            return length;
+        }
+        public async Task<List<int>> GetTypeIdFromObject(SessionId sessionId, int object_id, bool withParents, CancellationToken token)
+        {
+            List<int> ret = new List<int>();
+            var command_params = new MemoryStream();
+            var command_params_writer = new MonoBinaryWriter(command_params);
+            command_params_writer.Write(object_id);
+
+            var ret_debugger_cmd_reader = await SendDebuggerAgentCommand<CmdObject>(sessionId, CmdObject.RefGetType, command_params, token);
+            var type_id = ret_debugger_cmd_reader.ReadInt32();
+            ret.Add(type_id);
+            if (withParents)
+            {
+                command_params = new MemoryStream();
+                command_params_writer = new MonoBinaryWriter(command_params);
+                command_params_writer.Write(type_id);
+                ret_debugger_cmd_reader = await SendDebuggerAgentCommand<CmdType>(sessionId, CmdType.GetParents, command_params, token);
+                var parentsCount = ret_debugger_cmd_reader.ReadInt32();
+                for (int i = 0 ; i < parentsCount; i++)
+                {
+                    ret.Add(ret_debugger_cmd_reader.ReadInt32());
+                }
+            }
+            return ret;
+        }
+
+        public async Task<string> GetClassNameFromObject(SessionId sessionId, int object_id, CancellationToken token)
+        {
+            var type_id = await GetTypeIdFromObject(sessionId, object_id, false, token);
+            return await GetTypeName(sessionId, type_id[0], token);
+        }
+
+        public async Task<int> GetMethodIdByName(SessionId sessionId, int type_id, string method_name, CancellationToken token)
+        {
+            var ret = new List<string>();
+            var command_params = new MemoryStream();
+            var command_params_writer = new MonoBinaryWriter(command_params);
+            command_params_writer.Write((int)type_id);
+            command_params_writer.WriteString(method_name);
+            command_params_writer.Write((int)(0x10 | 4)); //instance methods
+            command_params_writer.Write((int)1); //case sensitive
+            var ret_debugger_cmd_reader = await SendDebuggerAgentCommand<CmdType>(sessionId, CmdType.GetMethodsByNameFlags, command_params, token);
+            var nMethods = ret_debugger_cmd_reader.ReadInt32();
+            return ret_debugger_cmd_reader.ReadInt32();
+        }
+
+        public async Task<bool> IsDelegate(SessionId sessionId, int objectId, CancellationToken token)
+        {
+            var ret = new List<string>();
+            var command_params = new MemoryStream();
+            var command_params_writer = new MonoBinaryWriter(command_params);
+            command_params_writer.Write((int)objectId);
+            var ret_debugger_cmd_reader = await SendDebuggerAgentCommand<CmdObject>(sessionId, CmdObject.RefIsDelegate, command_params, token);
+            return ret_debugger_cmd_reader.ReadByte() == 1;
+        }
+
+        public async Task<int> GetDelegateMethod(SessionId sessionId, int objectId, CancellationToken token)
+        {
+            var ret = new List<string>();
+            var command_params = new MemoryStream();
+            var command_params_writer = new MonoBinaryWriter(command_params);
+            command_params_writer.Write((int)objectId);
+            var ret_debugger_cmd_reader = await SendDebuggerAgentCommand<CmdObject>(sessionId, CmdObject.RefDelegateGetMethod, command_params, token);
+            return ret_debugger_cmd_reader.ReadInt32();
+        }
+
+        public async Task<string> GetDelegateMethodDescription(SessionId sessionId, int objectId, CancellationToken token)
+        {
+            var methodId = await GetDelegateMethod(sessionId, objectId, token);
+
+            var command_params = new MemoryStream();
+            var command_params_writer = new MonoBinaryWriter(command_params);
+            command_params_writer.Write(methodId);
+            //Console.WriteLine("methodId - " + methodId);
+            if (methodId == 0)
+                return "";
+            var ret_debugger_cmd_reader = await SendDebuggerAgentCommand<CmdMethod>(sessionId, CmdMethod.GetName, command_params, token);
+            var methodName = ret_debugger_cmd_reader.ReadString();
+
+            var returnType = await GetReturnType(sessionId, methodId, token);
+            var parameters = await GetParameters(sessionId, methodId, token);
+
+            return $"{returnType} {methodName} {parameters}";
+        }
+        public async Task<JObject> InvokeMethod(SessionId sessionId, byte[] valueTypeBuffer, int method_id, string varName, CancellationToken token)
+        {
+            MemoryStream parms = new MemoryStream();
+            var command_params_writer = new MonoBinaryWriter(parms);
+            command_params_writer.Write(method_id);
+            command_params_writer.Write(valueTypeBuffer);
+            command_params_writer.Write(0);
+            var ret_debugger_cmd_reader = await SendDebuggerAgentCommand<CmdVM>(sessionId, CmdVM.InvokeMethod, parms, token);
+            ret_debugger_cmd_reader.ReadByte(); //number of objects returned.
+            return await CreateJObjectForVariableValue(sessionId, ret_debugger_cmd_reader, varName, false, -1, token);
+        }
+        public async Task<JArray> CreateJArrayForProperties(SessionId sessionId, int typeId, byte[] object_buffer, JArray attributes, bool isAutoExpandable, string objectId, bool isOwn, CancellationToken token)
+        {
+            JArray ret = new JArray();
+            var command_params = new MemoryStream();
+            var command_params_writer = new MonoBinaryWriter(command_params);
+            command_params_writer.Write(typeId);
+
+            var ret_debugger_cmd_reader = await SendDebuggerAgentCommand<CmdType>(sessionId, CmdType.GetProperties, command_params, token);
+            var nProperties = ret_debugger_cmd_reader.ReadInt32();
+            for (int i = 0 ; i < nProperties; i++)
+            {
+                ret_debugger_cmd_reader.ReadInt32(); //propertyId
+                string propertyNameStr = ret_debugger_cmd_reader.ReadString();
+                var getMethodId = ret_debugger_cmd_reader.ReadInt32();
+                ret_debugger_cmd_reader.ReadInt32(); //setmethod
+                var attrs = ret_debugger_cmd_reader.ReadInt32(); //attrs
+                if (getMethodId == 0 || await GetParamCount(sessionId, getMethodId, token) != 0 || await MethodIsStatic(sessionId, getMethodId, token))
+                    continue;
+                JObject propRet = null;
+                if (attributes.Where(attribute => attribute["name"].Value<string>().Equals(propertyNameStr)).Any())
+                    continue;
+                if (isAutoExpandable)
+                {
+                    try {
+                        propRet = await InvokeMethod(sessionId, object_buffer, getMethodId, propertyNameStr, token);
+                    }
+                    catch (Exception)
+                    {
+                        continue;
+                    }
+                }
+                else
+                {
+                    propRet = JObject.FromObject(new {
+                            get = new
+                            {
+                                type = "function",
+                                objectId = $"{objectId}:method_id:{getMethodId}",
+                                className = "Function",
+                                description = "get " + propertyNameStr + " ()",
+                                methodId = getMethodId,
+                                objectIdValue = objectId
+                            },
+                            name = propertyNameStr
+                        });
+                }
+                if (isOwn)
+                    propRet["isOwn"] = true;
+                ret.Add(propRet);
+            }
+            return ret;
+        }
+        public async Task<JObject> GetPointerContent(SessionId sessionId, int pointerId, CancellationToken token)
+        {
+            var ret = new List<string>();
+            var command_params = new MemoryStream();
+            var command_params_writer = new MonoBinaryWriter(command_params);
+            command_params_writer.WriteLong(pointerValues[pointerId].address);
+            command_params_writer.Write(pointerValues[pointerId].typeId);
+            var ret_debugger_cmd_reader = await SendDebuggerAgentCommand<CmdPointer>(sessionId, CmdPointer.GetValue, command_params, token);
+            var varName = pointerValues[pointerId].varName;
+            if (int.TryParse(varName, out _))
+                varName = $"[{varName}]";
+            return await CreateJObjectForVariableValue(sessionId, ret_debugger_cmd_reader, "*" + varName, false, -1, token);
+        }
+        public async Task<JArray> GetPropertiesValuesOfValueType(SessionId sessionId, int valueTypeId, CancellationToken token)
+        {
+            JArray ret = new JArray();
+            var valueType = valueTypes[valueTypeId];
+            var command_params = new MemoryStream();
+            var command_params_writer = new MonoBinaryWriter(command_params);
+            command_params_writer.Write(valueType.typeId);
+            var ret_debugger_cmd_reader = await SendDebuggerAgentCommand<CmdType>(sessionId, CmdType.GetParents, command_params, token);
+            var parentsCount = ret_debugger_cmd_reader.ReadInt32();
+            List<int> typesToGetProperties = new List<int>();
+            typesToGetProperties.Add(valueType.typeId);
+            for (int i = 0 ; i < parentsCount; i++)
+            {
+                typesToGetProperties.Add(ret_debugger_cmd_reader.ReadInt32());
+            }
+            for (int i = 0 ; i < typesToGetProperties.Count; i++)
+            {
+                var properties = await CreateJArrayForProperties(sessionId, typesToGetProperties[i], valueType.valueTypeBuffer, valueType.valueTypeJson, valueType.valueTypeAutoExpand, $"dotnet:valuetype:{valueType.Id}", i == 0, token);
+                ret = new JArray(ret.Union(properties));
+            }
+
+            return ret;
+        }
+
+        public bool AutoExpandable(string className) {
+            if (className == "System.DateTime" ||
+                className == "System.DateTimeOffset" ||
+                className == "System.TimeSpan")
+                return true;
+            return false;
+        }
+
+        public bool AutoInvokeToString(string className) {
+            if (className == "System.DateTime" ||
+                className == "System.DateTimeOffset" ||
+                className == "System.TimeSpan" ||
+                className == "System.Decimal"  ||
+                className == "System.Guid")
+                return true;
+            return false;
+        }
+
+        public JObject CreateJObject<T>(T value, string type, string description, bool writable, string className = null, string objectId = null, string __custom_type = null, string subtype = null, bool isValueType = false, bool expanded = false, bool isEnum = false)
+        {
+            var ret = JObject.FromObject(new {
+                    value = new
+                    {
+                        type,
+                        value,
+                        description
+                    },
+                    writable
+                });
+            if (__custom_type != null)
+                ret["value"]["__custom_type"] = __custom_type;
+            if (className != null)
+                ret["value"]["className"] = className;
+            if (objectId != null)
+                ret["value"]["objectId"] = objectId;
+            if (subtype != null)
+                ret["value"]["subtype"] = subtype;
+            if (isValueType)
+                ret["value"]["isValueType"] = isValueType;
+            if (expanded)
+                ret["value"]["expanded"] = expanded;
+            if (isEnum)
+                ret["value"]["isEnum"] = isEnum;
+            return ret;
+
+        }
+        public JObject CreateJObjectForBoolean(int value)
+        {
+            return CreateJObject<bool>(value == 0 ? false : true, "boolean", value == 0 ? "false" : "true", true);
+        }
+
+        public JObject CreateJObjectForNumber<T>(T value)
+        {
+            return CreateJObject<T>(value, "number", value.ToString(), true);
+        }
+
+        public JObject CreateJObjectForChar(int value)
+        {
+            var description = $"{value.ToString()} '{Convert.ToChar(value)}'";
+            return CreateJObject<string>(description, "symbol", description, true);
+        }
+
+        public async Task<JObject> CreateJObjectForPtr(SessionId sessionId, ElementType etype, MonoBinaryReader ret_debugger_cmd_reader, string name, CancellationToken token)
+        {
+            string type;
+            string value;
+            long valueAddress = ret_debugger_cmd_reader.ReadLong();
+            var typeId = ret_debugger_cmd_reader.ReadInt32();
+            var className = "";
+            if (etype == ElementType.FnPtr)
+                className = "(*())"; //to keep the old behavior
+            else
+                className = "(" + await GetTypeName(sessionId, typeId, token) + ")";
+
+            int pointerId = 0;
+            if (valueAddress != 0 && className != "(void*)")
+            {
+                pointerId = Interlocked.Increment(ref debugger_object_id);
+                type = "object";
+                value =  className;
+                pointerValues[pointerId] = new PointerValue(valueAddress, typeId, name);
+            }
+            else
+            {
+                type = "symbol";
+                value = className + " " + valueAddress;
+            }
+            return CreateJObject<string>(value, type, value, false, className, $"dotnet:pointer:{pointerId}", "pointer");
+        }
+
+        public async Task<JObject> CreateJObjectForString(SessionId sessionId, MonoBinaryReader ret_debugger_cmd_reader, CancellationToken token)
+        {
+            var string_id = ret_debugger_cmd_reader.ReadInt32();
+            var value = await GetStringValue(sessionId, string_id, token);
+            return CreateJObject<string>(value, "string", value, false);
+        }
+
+        public async Task<JObject> CreateJObjectForArray(SessionId sessionId, MonoBinaryReader ret_debugger_cmd_reader, CancellationToken token)
+        {
+            var objectId = ret_debugger_cmd_reader.ReadInt32();
+            var value = await GetClassNameFromObject(sessionId, objectId, token);
+            var length = await GetArrayLength(sessionId, objectId, token);
+            return CreateJObject<string>(null, "object", $"{value.ToString()}({length})", false, value.ToString(), "dotnet:array:" + objectId, null, "array");
+        }
+
+        public async Task<JObject> CreateJObjectForObject(SessionId sessionId, MonoBinaryReader ret_debugger_cmd_reader, int typeIdFromAttribute, CancellationToken token)
+        {
+            var objectId = ret_debugger_cmd_reader.ReadInt32();
+            var className = "";
+            var type_id = await GetTypeIdFromObject(sessionId, objectId, false, token);
+            className = await GetTypeName(sessionId, type_id[0], token);
+            var description = className.ToString();
+            if (await IsDelegate(sessionId, objectId, token))
+            {
+                if (typeIdFromAttribute != -1)
+                {
+                    className = await GetTypeName(sessionId, typeIdFromAttribute, token);
+                }
+
+                description = await GetDelegateMethodDescription(sessionId, objectId, token);
+                if (description == "")
+                {
+                    return CreateJObject<string>(className.ToString(), "symbol", className.ToString(), false);
+                }
+            }
+            return CreateJObject<string>(null, "object", description, false, className, $"dotnet:object:{objectId}");
+        }
+
+        public async Task<JObject> CreateJObjectForValueType(SessionId sessionId, MonoBinaryReader ret_debugger_cmd_reader, string name, long initialPos, CancellationToken token)
+        {
+            JObject fieldValueType = null;
+            var isEnum = ret_debugger_cmd_reader.ReadByte();
+            var isBoxed = ret_debugger_cmd_reader.ReadByte() == 1;
+            var typeId = ret_debugger_cmd_reader.ReadInt32();
+            var className = await GetTypeName(sessionId, typeId, token);
+            var description = className;
+            var numFields = ret_debugger_cmd_reader.ReadInt32();
+            var fields = await GetTypeFields(sessionId, typeId, token);
+            JArray valueTypeFields = new JArray();
+            if (className.IndexOf("System.Nullable<") == 0) //should we call something on debugger-agent to check???
+            {
+                ret_debugger_cmd_reader.ReadByte(); //ignoring the boolean type
+                var isNull = ret_debugger_cmd_reader.ReadInt32();
+                var value = await CreateJObjectForVariableValue(sessionId, ret_debugger_cmd_reader, name, false, -1, token);
+                if (isNull != 0)
+                    return value;
+                else
+                    return CreateJObject<string>(null, "object", className, false, className, null, null, "null", true);
+            }
+            for (int i = 0; i < numFields ; i++)
+            {
+                fieldValueType = await CreateJObjectForVariableValue(sessionId, ret_debugger_cmd_reader, fields.ElementAt(i).Name, true, fields.ElementAt(i).TypeId, token);
+                valueTypeFields.Add(fieldValueType);
+            }
+
+            long endPos = ret_debugger_cmd_reader.BaseStream.Position;
+            var valueTypeId = Interlocked.Increment(ref debugger_object_id);
+
+            ret_debugger_cmd_reader.BaseStream.Position = initialPos;
+            byte[] valueTypeBuffer = new byte[endPos - initialPos];
+            ret_debugger_cmd_reader.Read(valueTypeBuffer, 0, (int)(endPos - initialPos));
+            ret_debugger_cmd_reader.BaseStream.Position = endPos;
+            valueTypes[valueTypeId] = new ValueTypeClass(name, valueTypeBuffer, valueTypeFields, typeId, AutoExpandable(className), valueTypeId);
+            if (AutoInvokeToString(className) || isEnum == 1) {
+                int method_id = await GetMethodIdByName(sessionId, typeId, "ToString", token);
+                var retMethod = await InvokeMethod(sessionId, valueTypeBuffer, method_id, "methodRet", token);
+                description = retMethod["value"]?["value"].Value<string>();
+                if (className.Equals("System.Guid"))
+                    description = description.ToUpper(); //to keep the old behavior
+            }
+            else if (isBoxed && numFields == 1) {
+                return fieldValueType;
+            }
+            return CreateJObject<string>(null, "object", description, false, className, $"dotnet:valuetype:{valueTypeId}", null, null, true, true, isEnum == 1);
+        }
+
+        public async Task<JObject> CreateJObjectForNull(SessionId sessionId, MonoBinaryReader ret_debugger_cmd_reader, CancellationToken token)
+        {
+            string className = "";
+            ElementType variableType = (ElementType)ret_debugger_cmd_reader.ReadByte();
+            switch (variableType)
+            {
+                case ElementType.String:
+                case ElementType.Class:
+                {
+                    var type_id = ret_debugger_cmd_reader.ReadInt32();
+                    className = await GetTypeName(sessionId, type_id, token);
+                    break;
+
+                }
+                case ElementType.SzArray:
+                case ElementType.Array:
+                {
+                    ElementType byte_type = (ElementType)ret_debugger_cmd_reader.ReadByte();
+                    var rank = ret_debugger_cmd_reader.ReadInt32();
+                    if (byte_type == ElementType.Class) {
+                        var internal_type_id = ret_debugger_cmd_reader.ReadInt32();
+                    }
+                    var type_id = ret_debugger_cmd_reader.ReadInt32();
+                    className = await GetTypeName(sessionId, type_id, token);
+                    break;
+                }
+                default:
+                {
+                    var type_id = ret_debugger_cmd_reader.ReadInt32();
+                    className = await GetTypeName(sessionId, type_id, token);
+                    break;
+                }
+            }
+            return CreateJObject<string>(null, "object", className, false, className, null, null, "null");
+        }
+
+        public async Task<JObject> CreateJObjectForVariableValue(SessionId sessionId, MonoBinaryReader ret_debugger_cmd_reader, string name, bool isOwn, int typeIdFromAttribute, CancellationToken token)
+        {
+            long initialPos = ret_debugger_cmd_reader == null ? 0 : ret_debugger_cmd_reader.BaseStream.Position;
+            ElementType etype = (ElementType)ret_debugger_cmd_reader.ReadByte();
+            JObject ret = null;
+            switch (etype) {
+                case ElementType.I:
+                case ElementType.U:
+                case ElementType.Void:
+                case (ElementType)ValueTypeId.Type:
+                case (ElementType)ValueTypeId.VType:
+                case (ElementType)ValueTypeId.FixedArray:
+                    ret = new JObject{{"Type", "void"}};
+                    break;
+                case ElementType.Boolean:
+                {
+                    var value = ret_debugger_cmd_reader.ReadInt32();
+                    ret = CreateJObjectForBoolean(value);
+                    break;
+                }
+                case ElementType.I1:
+                {
+                    var value = ret_debugger_cmd_reader.ReadSByte();
+                    ret = CreateJObjectForNumber<int>(value);
+                    break;
+                }
+                case ElementType.I2:
+                case ElementType.I4:
+                {
+                    var value = ret_debugger_cmd_reader.ReadInt32();
+                    ret = CreateJObjectForNumber<int>(value);
+                    break;
+                }
+                case ElementType.U1:
+                {
+                    var value = ret_debugger_cmd_reader.ReadUByte();
+                    ret = CreateJObjectForNumber<int>(value);
+                    break;
+                }
+                case ElementType.U2:
+                {
+                    var value = ret_debugger_cmd_reader.ReadUShort();
+                    ret = CreateJObjectForNumber<int>(value);
+                    break;
+                }
+                case ElementType.U4:
+                {
+                    var value = ret_debugger_cmd_reader.ReadUInt32();
+                    ret = CreateJObjectForNumber<uint>(value);
+                    break;
+                }
+                case ElementType.R4:
+                {
+                    float value = BitConverter.Int32BitsToSingle(ret_debugger_cmd_reader.ReadInt32());
+                    ret = CreateJObjectForNumber<float>(value);
+                    break;
+                }
+                case ElementType.Char:
+                {
+                    var value = ret_debugger_cmd_reader.ReadInt32();
+                    ret = CreateJObjectForChar(value);
+                    break;
+                }
+                case ElementType.I8:
+                {
+                    long value = ret_debugger_cmd_reader.ReadLong();
+                    ret = CreateJObjectForNumber<long>(value);
+                    break;
+                }
+                case ElementType.U8:
+                {
+                    ulong high = (ulong) ret_debugger_cmd_reader.ReadInt32();
+                    ulong low = (ulong) ret_debugger_cmd_reader.ReadInt32();
+                    var value = ((high << 32) | low);
+                    ret = CreateJObjectForNumber<ulong>(value);
+                    break;
+                }
+                case ElementType.R8:
+                {
+                    double value = ret_debugger_cmd_reader.ReadDouble();
+                    ret = CreateJObjectForNumber<double>(value);
+                    break;
+                }
+                case ElementType.FnPtr:
+                case ElementType.Ptr:
+                {
+                    ret = await CreateJObjectForPtr(sessionId, etype, ret_debugger_cmd_reader, name, token);
+                    break;
+                }
+                case ElementType.String:
+                {
+                    ret = await CreateJObjectForString(sessionId, ret_debugger_cmd_reader, token);
+                    break;
+                }
+                case ElementType.SzArray:
+                case ElementType.Array:
+                {
+                    ret = await CreateJObjectForArray(sessionId, ret_debugger_cmd_reader, token);
+                    break;
+                }
+                case ElementType.Class:
+                case ElementType.Object:
+                {
+                    ret = await CreateJObjectForObject(sessionId, ret_debugger_cmd_reader, typeIdFromAttribute, token);
+                    break;
+                }
+                case ElementType.ValueType:
+                {
+                    ret = await CreateJObjectForValueType(sessionId, ret_debugger_cmd_reader, name, initialPos, token);
+                    break;
+                }
+                case (ElementType)ValueTypeId.Null:
+                {
+                    ret = await CreateJObjectForNull(sessionId, ret_debugger_cmd_reader, token);
+                    break;
+                }
+            }
+            if (isOwn)
+                ret["isOwn"] = true;
+            ret["name"] = name;
+            return ret;
+        }
+
+        public async Task<bool> IsAsyncMethod(SessionId sessionId, int methodId, CancellationToken token)
+        {
+            var command_params = new MemoryStream();
+            var command_params_writer = new MonoBinaryWriter(command_params);
+            command_params_writer.Write(methodId);
+
+            var ret_debugger_cmd_reader = await SendDebuggerAgentCommand<CmdMethod>(sessionId, CmdMethod.AsyncDebugInfo, command_params, token);
+            return ret_debugger_cmd_reader.ReadByte() == 1 ; //token
+        }
+
+        public async Task<JArray> StackFrameGetValues(SessionId sessionId, MethodInfo method, int thread_id, int frame_id, VarInfo[] var_ids, CancellationToken token)
+        {
+            var command_params = new MemoryStream();
+            var command_params_writer = new MonoBinaryWriter(command_params);
+            MonoBinaryReader ret_debugger_cmd_reader = null;
+            command_params_writer.Write(thread_id);
+            command_params_writer.Write(frame_id);
+            command_params_writer.Write(var_ids.Length);
+            foreach (var var in var_ids)
+            {
+                command_params_writer.Write(var.Index);
+            }
+
+            if (await IsAsyncMethod(sessionId, method.DebuggerId, token))
+            {
+                ret_debugger_cmd_reader = await SendDebuggerAgentCommand<CmdFrame>(sessionId, CmdFrame.GetThis, command_params, token);
+                ret_debugger_cmd_reader.ReadByte(); //ignore type
+                var objectId = ret_debugger_cmd_reader.ReadInt32();
+                var asyncLocals = await GetObjectValues(sessionId, objectId, true, false, false, false, token);
+                asyncLocals = new JArray(asyncLocals.Where( asyncLocal => !asyncLocal["name"].Value<string>().Contains("<>") || asyncLocal["name"].Value<string>().EndsWith("__this")));
+                foreach (var asyncLocal in asyncLocals)
+                {
+                    if (asyncLocal["name"].Value<string>().EndsWith("__this"))
+                        asyncLocal["name"] = "this";
+                    else if (asyncLocal["name"].Value<string>().Contains("<"))
+                        asyncLocal["name"] = Regex.Match(asyncLocal["name"].Value<string>(), @"\<([^)]*)\>").Groups[1].Value;
+                }
+                return asyncLocals;
+            }
+
+            JArray locals = new JArray();
+            ret_debugger_cmd_reader = await SendDebuggerAgentCommand<CmdFrame>(sessionId, CmdFrame.GetValues, command_params, token);
+            foreach (var var in var_ids)
+            {
+                var var_json = await CreateJObjectForVariableValue(sessionId, ret_debugger_cmd_reader, var.Name, false, -1, token);
+                locals.Add(var_json);
+            }
+            if (!method.IsStatic())
+            {
+                ret_debugger_cmd_reader = await SendDebuggerAgentCommand<CmdFrame>(sessionId, CmdFrame.GetThis, command_params, token);
+                var var_json = await CreateJObjectForVariableValue(sessionId, ret_debugger_cmd_reader, "this", false, -1, token);
+                var_json.Add("fieldOffset", -1);
+                locals.Add(var_json);
+            }
+            return locals;
+
+        }
+
+        public async Task<JArray> GetValueTypeValues(SessionId sessionId, int valueTypeId, bool accessorPropertiesOnly, CancellationToken token)
+        {
+            if (valueTypes[valueTypeId].valueTypeJsonProps == null)
+            {
+                valueTypes[valueTypeId].valueTypeJsonProps = await GetPropertiesValuesOfValueType(sessionId, valueTypeId, token);
+            }
+            if (accessorPropertiesOnly)
+                return valueTypes[valueTypeId].valueTypeJsonProps;
+            var ret = new JArray(valueTypes[valueTypeId].valueTypeJson.Union(valueTypes[valueTypeId].valueTypeJsonProps));
+            return ret;
+        }
+
+        public async Task<JArray> GetValueTypeProxy(SessionId sessionId, int valueTypeId, CancellationToken token)
+        {
+            if (valueTypes[valueTypeId].valueTypeProxy != null)
+                return valueTypes[valueTypeId].valueTypeProxy;
+            valueTypes[valueTypeId].valueTypeProxy = new JArray(valueTypes[valueTypeId].valueTypeJson);
+
+            var command_params = new MemoryStream();
+            var command_params_writer = new MonoBinaryWriter(command_params);
+            command_params_writer.Write(valueTypes[valueTypeId].typeId);
+
+            var ret_debugger_cmd_reader = await SendDebuggerAgentCommand<CmdType>(sessionId, CmdType.GetProperties, command_params, token);
+            var nProperties = ret_debugger_cmd_reader.ReadInt32();
+
+            for (int i = 0 ; i < nProperties; i++)
+            {
+                ret_debugger_cmd_reader.ReadInt32(); //propertyId
+                string propertyNameStr = ret_debugger_cmd_reader.ReadString();
+
+                var getMethodId = ret_debugger_cmd_reader.ReadInt32();
+                ret_debugger_cmd_reader.ReadInt32(); //setmethod
+                ret_debugger_cmd_reader.ReadInt32(); //attrs
+                if (await MethodIsStatic(sessionId, getMethodId, token))
+                    continue;
+                var command_params_to_proxy = new MemoryStream();
+                var command_params_writer_to_proxy = new MonoBinaryWriter(command_params_to_proxy);
+                command_params_writer_to_proxy.Write(getMethodId);
+                command_params_writer_to_proxy.Write(valueTypes[valueTypeId].valueTypeBuffer);
+                command_params_writer_to_proxy.Write(0);
+                valueTypes[valueTypeId].valueTypeProxy.Add(JObject.FromObject(new {
+                            get = JObject.FromObject(new {
+                                commandSet = CommandSet.Vm,
+                                command = CmdVM.InvokeMethod,
+                                buffer = Convert.ToBase64String(command_params_to_proxy.ToArray()),
+                                length = command_params_to_proxy.ToArray().Length
+                                }),
+                            name = propertyNameStr
+                        }));
+            }
+            return valueTypes[valueTypeId].valueTypeProxy;
+        }
+
+        public async Task<JArray> GetArrayValues(SessionId sessionId, int arrayId, CancellationToken token)
+        {
+            var length = await GetArrayLength(sessionId, arrayId, token);
+            var command_params = new MemoryStream();
+            var command_params_writer = new MonoBinaryWriter(command_params);
+            command_params_writer.Write(arrayId);
+            command_params_writer.Write(0);
+            command_params_writer.Write(length);
+            var ret_debugger_cmd_reader = await SendDebuggerAgentCommand<CmdArray>(sessionId, CmdArray.GetValues, command_params, token);
+            JArray array = new JArray();
+            for (int i = 0 ; i < length ; i++)
+            {
+                var var_json = await CreateJObjectForVariableValue(sessionId, ret_debugger_cmd_reader, i.ToString(), false, -1, token);
+                array.Add(var_json);
+            }
+            return array;
+        }
+        public async Task<bool> EnableExceptions(SessionId sessionId, string state, CancellationToken token)
+        {
+
+            var command_params = new MemoryStream();
+            var command_params_writer = new MonoBinaryWriter(command_params);
+            command_params_writer.Write((byte)EventKind.Exception);
+            command_params_writer.Write((byte)SuspendPolicy.None);
+            command_params_writer.Write((byte)1);
+            command_params_writer.Write((byte)ModifierKind.ExceptionOnly);
+            command_params_writer.Write(0); //exc_class
+            if (state == "all")
+                command_params_writer.Write((byte)1); //caught
+            else
+                command_params_writer.Write((byte)0); //caught
+            if (state == "uncaught" || state == "all")
+                command_params_writer.Write((byte)1); //uncaught
+            else
+                command_params_writer.Write((byte)0); //uncaught
+            command_params_writer.Write((byte)1);//subclasses
+            command_params_writer.Write((byte)0);//not_filtered_feature
+            command_params_writer.Write((byte)0);//everything_else
+            var ret_debugger_cmd_reader = await SendDebuggerAgentCommand<CmdEventRequest>(sessionId, CmdEventRequest.Set, command_params, token);
+            return true;
+        }
+        public async Task<JArray> GetObjectValues(SessionId sessionId, int objectId, bool withProperties, bool withSetter, bool accessorPropertiesOnly, bool ownProperties, CancellationToken token)
+        {
+            var typeId = await GetTypeIdFromObject(sessionId, objectId, true, token);
+            var className = await GetTypeName(sessionId, typeId[0], token);
+            JArray ret = new JArray();
+            if (await IsDelegate(sessionId, objectId, token))
+            {
+                var description = await GetDelegateMethodDescription(sessionId, objectId, token);
+
+                var obj = JObject.FromObject(new {
+                            value = new
+                            {
+                                type = "symbol",
+                                value = description,
+                                description
+                            },
+                            name = "Target"
+                        });
+                ret.Add(obj);
+                return ret;
+            }
+            for (int i = 0; i < typeId.Count; i++)
+            {
+                if (!accessorPropertiesOnly)
+                {
+                    var fields = await GetTypeFields(sessionId, typeId[i], token);
+                    JArray objectFields = new JArray();
+
+                    var command_params = new MemoryStream();
+                    var command_params_writer = new MonoBinaryWriter(command_params);
+                    command_params_writer.Write(objectId);
+                    command_params_writer.Write(fields.Count);
+                    foreach (var field in fields)
+                    {
+                            command_params_writer.Write(field.Id);
+                    }
+
+                    var ret_debugger_cmd_reader = await SendDebuggerAgentCommand<CmdObject>(sessionId, CmdObject.RefGetValues, command_params, token);
+
+                    foreach (var field in fields)
+                    {
+                        long initialPos = ret_debugger_cmd_reader.BaseStream.Position;
+                        int valtype = ret_debugger_cmd_reader.ReadByte();
+                        ret_debugger_cmd_reader.BaseStream.Position = initialPos;
+                        var fieldValue = await CreateJObjectForVariableValue(sessionId, ret_debugger_cmd_reader, field.Name, i == 0, field.TypeId, token);
+
+                        if (ret.Where(attribute => attribute["name"].Value<string>().Equals(fieldValue["name"].Value<string>())).Any()) {
+                            continue;
+                        }
+                        if (withSetter)
+                        {
+                            var command_params_to_set = new MemoryStream();
+                            var command_params_writer_to_set = new MonoBinaryWriter(command_params_to_set);
+                            command_params_writer_to_set.Write(objectId);
+                            command_params_writer_to_set.Write(1);
+                            command_params_writer_to_set.Write(field.Id);
+
+                            fieldValue.Add("set", JObject.FromObject(new {
+                                        commandSet = CommandSet.ObjectRef,
+                                        command = CmdObject.RefSetValues,
+                                        buffer = Convert.ToBase64String(command_params_to_set.ToArray()),
+                                        valtype,
+                                        length = command_params_to_set.ToArray().Length
+                                }));
+                        }
+                        objectFields.Add(fieldValue);
+                    }
+                    ret = new JArray(ret.Union(objectFields));
+                }
+                if (!withProperties)
+                    return ret;
+                var command_params_obj = new MemoryStream();
+                var command_params_obj_writer = new MonoBinaryWriter(command_params_obj);
+                command_params_obj_writer.WriteObj(new DotnetObjectId("object", $"{objectId}"), this);
+                var props = await CreateJArrayForProperties(sessionId, typeId[i], command_params_obj.ToArray(), ret, false, $"dotnet:object:{objectId}", i == 0, token);
+                ret = new JArray(ret.Union(props));
+
+                // ownProperties
+                // Note: ownProperties should mean that we return members of the klass itself,
+                // but we are going to ignore that here, because otherwise vscode/chrome don't
+                // seem to ask for inherited fields at all.
+                //if (ownProperties)
+                    //break;
+                /*if (accessorPropertiesOnly)
+                    break;*/
+            }
+            if (accessorPropertiesOnly)
+            {
+                var retAfterRemove = new JArray();
+                List<List<FieldTypeClass>> allFields = new List<List<FieldTypeClass>>();
+                for (int i = 0; i < typeId.Count; i++)
+                {
+                    var fields = await GetTypeFields(sessionId, typeId[i], token);
+                    allFields.Add(fields);
+                }
+                foreach (var item in ret)
+                {
+                    bool foundField = false;
+                    for (int j = 0 ; j <  allFields.Count; j++)
+                    {
+                        foreach (var field in allFields[j])
+                        {
+                            if (field.Name.Equals(item["name"].Value<string>())) {
+                                if (item["isOwn"] == null || (item["isOwn"].Value<bool>() && j == 0) || !item["isOwn"].Value<bool>())
+                                    foundField = true;
+                                break;
+                            }
+                        }
+                        if (foundField)
+                            break;
+                    }
+                    if (!foundField) {
+                        retAfterRemove.Add(item);
+                    }
+                }
+                ret = retAfterRemove;
+            }
+            return ret;
+        }
+
+        public async Task<JArray> GetObjectProxy(SessionId sessionId, int objectId, CancellationToken token)
+        {
+            var ret = await GetObjectValues(sessionId, objectId, false, true, false, false, token);
+            var typeIds = await GetTypeIdFromObject(sessionId, objectId, true, token);
+            foreach (var typeId in typeIds)
+            {
+                var command_params = new MemoryStream();
+                var command_params_writer = new MonoBinaryWriter(command_params);
+                command_params_writer.Write(typeId);
+
+                var ret_debugger_cmd_reader = await SendDebuggerAgentCommand<CmdType>(sessionId, CmdType.GetProperties, command_params, token);
+                var nProperties = ret_debugger_cmd_reader.ReadInt32();
+                for (int i = 0 ; i < nProperties; i++)
+                {
+                    ret_debugger_cmd_reader.ReadInt32(); //propertyId
+                    string propertyNameStr = ret_debugger_cmd_reader.ReadString();
+                    var getMethodId = ret_debugger_cmd_reader.ReadInt32();
+                    var setMethodId = ret_debugger_cmd_reader.ReadInt32(); //setmethod
+                    var attrValue = ret_debugger_cmd_reader.ReadInt32(); //attrs
+                    //Console.WriteLine($"{propertyNameStr} - {attrValue}");
+                    if (ret.Where(attribute => attribute["name"].Value<string>().Equals(propertyNameStr)).Any())
+                    {
+                        var attr = ret.Where(attribute => attribute["name"].Value<string>().Equals(propertyNameStr)).First();
+
+                        var command_params_to_set = new MemoryStream();
+                        var command_params_writer_to_set = new MonoBinaryWriter(command_params_to_set);
+                        command_params_writer_to_set.Write(setMethodId);
+                        command_params_writer_to_set.Write((byte)ElementType.Class);
+                        command_params_writer_to_set.Write(objectId);
+                        command_params_writer_to_set.Write(1);
+                        if (attr["set"] != null)
+                        {
+                            attr["set"] = JObject.FromObject(new {
+                                        commandSet = CommandSet.Vm,
+                                        command = CmdVM.InvokeMethod,
+                                        buffer = Convert.ToBase64String(command_params_to_set.ToArray()),
+                                        valtype = attr["set"]["valtype"],
+                                        length = command_params_to_set.ToArray().Length
+                                });
+                        }
+                        continue;
+                    }
+                    else
+                    {
+                        var command_params_to_get = new MemoryStream();
+                        var command_params_writer_to_get = new MonoBinaryWriter(command_params_to_get);
+                        command_params_writer_to_get.Write(getMethodId);
+                        command_params_writer_to_get.Write((byte)ElementType.Class);
+                        command_params_writer_to_get.Write(objectId);
+                        command_params_writer_to_get.Write(0);
+
+                        ret.Add(JObject.FromObject(new {
+                                get = JObject.FromObject(new {
+                                    commandSet = CommandSet.Vm,
+                                    command = CmdVM.InvokeMethod,
+                                    buffer = Convert.ToBase64String(command_params_to_get.ToArray()),
+                                    length = command_params_to_get.ToArray().Length
+                                    }),
+                                name = propertyNameStr
+                            }));
+                    }
+                    if (await MethodIsStatic(sessionId, getMethodId, token))
+                        continue;
+                }
+            }
+            return ret;
+        }
+
+        public async Task<bool> SetVariableValue(SessionId sessionId, int thread_id, int frame_id, int varId, string newValue, CancellationToken token)
+        {
+            var command_params = new MemoryStream();
+            var command_params_writer = new MonoBinaryWriter(command_params);
+            MonoBinaryReader ret_debugger_cmd_reader = null;
+            command_params_writer.Write(thread_id);
+            command_params_writer.Write(frame_id);
+            command_params_writer.Write(1);
+            command_params_writer.Write(varId);
+            JArray locals = new JArray();
+            ret_debugger_cmd_reader = await SendDebuggerAgentCommand<CmdFrame>(sessionId, CmdFrame.GetValues, command_params, token);
+            int etype = ret_debugger_cmd_reader.ReadByte();
+            try
+            {
+                ret_debugger_cmd_reader = await SendDebuggerAgentCommandWithParms<CmdFrame>(sessionId, CmdFrame.SetValues, command_params, etype, newValue, token);
+            }
+            catch (Exception)
+            {
+                return false;
+            }
+
+            return true;
+        }
+    }
+}
diff --git a/src/mono/wasm/debugger/DebuggerTestSuite/AssignmentTests.cs b/src/mono/wasm/debugger/DebuggerTestSuite/AssignmentTests.cs
index 00f917c8dc5731..1afa97939d5ef1 100644
--- a/src/mono/wasm/debugger/DebuggerTestSuite/AssignmentTests.cs
+++ b/src/mono/wasm/debugger/DebuggerTestSuite/AssignmentTests.cs
@@ -33,7 +33,7 @@ public class AssignmentTests : DebuggerTestBase
             { "MONO_TYPE_U2",          TNumber(0),                                              TNumber(1) },
             { "MONO_TYPE_U4",          TNumber(0),                                              TNumber(1) },
             { "MONO_TYPE_U8",          TNumber(0),                                              TNumber(1) },
-            { "MONO_TYPE_R4",          TNumber(0),                                              TNumber("3.1414999961853027") },
+            { "MONO_TYPE_R4",          TNumber(0),                                              TNumber("3.1415") }, //this is also the value that we see if we debug using VS
             { "MONO_TYPE_R8",          TNumber(0),                                              TNumber("3.1415") },
         };
 
diff --git a/src/mono/wasm/debugger/DebuggerTestSuite/DebuggerTestBase.cs b/src/mono/wasm/debugger/DebuggerTestSuite/DebuggerTestBase.cs
index 9b41983812074b..3d9106959c812e 100644
--- a/src/mono/wasm/debugger/DebuggerTestSuite/DebuggerTestBase.cs
+++ b/src/mono/wasm/debugger/DebuggerTestSuite/DebuggerTestBase.cs
@@ -706,7 +706,6 @@ internal async Task CheckValue(JToken actual_val, JToken exp_val, string label)
 
                     var exp_val_str = jp.Value.Value<string>();
                     bool null_or_empty_exp_val = String.IsNullOrEmpty(exp_val_str);
-
                     var actual_field_val = actual_val?.Values<JProperty>()?.FirstOrDefault(a_jp => a_jp.Name == jp.Name);
                     var actual_field_val_str = actual_field_val?.Value?.Value<string>();
                     if (null_or_empty_exp_val && String.IsNullOrEmpty(actual_field_val_str))
diff --git a/src/mono/wasm/debugger/DebuggerTestSuite/MonoJsTests.cs b/src/mono/wasm/debugger/DebuggerTestSuite/MonoJsTests.cs
index e2b796062e3086..4054c6a2cea11f 100644
--- a/src/mono/wasm/debugger/DebuggerTestSuite/MonoJsTests.cs
+++ b/src/mono/wasm/debugger/DebuggerTestSuite/MonoJsTests.cs
@@ -13,85 +13,6 @@ namespace DebuggerTests
 {
     public class MonoJsTests : DebuggerTestBase
     {
-        [Fact]
-        public async Task FixupNameValueObjectsWithMissingParts()
-        {
-            var bp1_res = await SetBreakpointInMethod("debugger-test.dll", "Math", "IntAdd", 3);
-
-            var names = new JObject[]
-            {
-                    JObject.FromObject(new { name = "Abc" }),
-                    JObject.FromObject(new { name = "Def" }),
-                    JObject.FromObject(new { name = "Xyz" })
-            };
-
-            var values = new JObject[]
-            {
-                    JObject.FromObject(new { value = TObject("testclass") }),
-                    JObject.FromObject(new { value = TString("test string") }),
-            };
-
-            var getters = new JObject[]
-            {
-                    GetterRes("xyz"),
-                    GetterRes("unattached")
-            };
-
-            var list = new[] { names[0], names[1], values[0], names[2], getters[0], getters[1] };
-            var res = await cli.SendCommand($"Runtime.evaluate", JObject.FromObject(new { expression = $"MONO._fixup_name_value_objects({JsonConvert.SerializeObject(list)})", returnByValue = true }), token);
-            Assert.True(res.IsOk);
-
-            await CheckProps(res.Value["result"]["value"], new
-            {
-                Abc = TSymbol("<unreadable value>"),
-                Def = TObject("testclass"),
-                Xyz = TGetter("xyz")
-            }, "#1", num_fields: 4);
-
-            JObject.DeepEquals(getters[1], res.Value["result"]["value"].Values<JObject>().ToArray()[3]);
-
-            static JObject GetterRes(string name) => JObject.FromObject(new
-            {
-                get = new
-                {
-                    className = "Function",
-                    description = $"get {name} () {{}}",
-                    type = "function"
-                }
-            });
-        }
-
-        [Fact]
-        public async Task GetParamsAndLocalsWithInvalidIndices()
-        {
-            var bp1_res = await SetBreakpointInMethod("debugger-test.dll", "Math", "IntAdd", 3);
-            var pause_location = await EvaluateAndCheck(
-                "window.setTimeout(function() { invoke_static_method('[debugger-test] Math:IntAdd', 1, 2); })",
-                null, -1, -1, "IntAdd");
-
-            var scope_id = pause_location["callFrames"][0]["callFrameId"].Value<string>();
-            var scope = int.Parse(scope_id.Split(new[] { ':' }, StringSplitOptions.RemoveEmptyEntries)[2]);
-
-            var var_ids = new[]
-            {
-                    new { index = 0, name = "one" },
-                    new { index = -12, name = "bad0" },
-                    new { index = 1231, name = "bad1" }
-                };
-
-            var expression = $"MONO.mono_wasm_get_variables({scope}, {JsonConvert.SerializeObject(var_ids)})";
-
-            var res = await cli.SendCommand($"Runtime.evaluate", JObject.FromObject(new { expression, returnByValue = true }), token);
-            Assert.True(res.IsOk);
-
-            await CheckProps(res.Value["result"]?["value"], new
-            {
-                one = TNumber(3),
-                bad0 = TSymbol("<unreadable value>"),
-                bad1 = TSymbol("<unreadable value>")
-            }, "results");
-        }
-
         [Fact]
         public async Task InvalidScopeId()
         {
diff --git a/src/mono/wasm/debugger/DebuggerTestSuite/Tests.cs b/src/mono/wasm/debugger/DebuggerTestSuite/Tests.cs
index a671ed2b7c1816..468ca4d628d376 100644
--- a/src/mono/wasm/debugger/DebuggerTestSuite/Tests.cs
+++ b/src/mono/wasm/debugger/DebuggerTestSuite/Tests.cs
@@ -641,43 +641,6 @@ await CompareObjectPropertiesFor(frame_locals, "this",
 
            });
 
-        [Fact]
-        public async Task InvalidValueTypeData()
-        {
-            await CheckInspectLocalsAtBreakpointSite(
-                "dotnet://debugger-test.dll/debugger-test.cs", 85, 8,
-                "OuterMethod",
-                "window.setTimeout(function() { invoke_static_method ('[debugger-test] Math:OuterMethod'); })",
-                wait_for_event_fn: async (pause_location) =>
-               {
-                   var new_id = await CreateNewId(@"MONO._new_or_add_id_props ({ scheme: 'valuetype', idArgs: { containerId: 1 }, props: { klass: 3, value64: 4 }});");
-                   await _invoke_getter(new_id, "NonExistant", expect_ok: false);
-
-                   new_id = await CreateNewId(@"MONO._new_or_add_id_props ({ scheme: 'valuetype', idArgs: { containerId: 1 }, props: { klass: 3 }});");
-                   await _invoke_getter(new_id, "NonExistant", expect_ok: false);
-
-                   new_id = await CreateNewId(@"MONO._new_or_add_id_props ({ scheme: 'valuetype', idArgs: { containerId: 1 }, props: { klass: 3, value64: 'AA' }});");
-                   await _invoke_getter(new_id, "NonExistant", expect_ok: false);
-               });
-
-            async Task<string> CreateNewId(string expr)
-            {
-                var res = await cli.SendCommand("Runtime.evaluate", JObject.FromObject(new { expression = expr }), token);
-                Assert.True(res.IsOk, "Expected Runtime.evaluate to succeed");
-                AssertEqual("string", res.Value["result"]?["type"]?.Value<string>(), "Expected Runtime.evaluate to return a string type result");
-                return res.Value["result"]?["value"]?.Value<string>();
-            }
-
-            async Task<Result> _invoke_getter(string obj_id, string property_name, bool expect_ok)
-            {
-                var expr = $"MONO._invoke_getter ('{obj_id}', '{property_name}')";
-                var res = await cli.SendCommand("Runtime.evaluate", JObject.FromObject(new { expression = expr }), token);
-                AssertEqual(expect_ok, res.IsOk, "Runtime.evaluate result not as expected for {expr}");
-
-                return res;
-            }
-        }
-
         [Fact]
         public async Task MulticastDelegateTest() => await CheckInspectLocalsAtBreakpointSite(
             "MulticastDelegateTestClass", "Test", 5, "Test",
@@ -746,7 +709,7 @@ public async Task PreviousFrameForAReflectedCall() => await CheckInspectLocalsAt
 
                  await CheckProps(frame_locals, new
                  {
-                     mi = TObject("System.Reflection.MethodInfo"),
+                     mi = TObject("System.Reflection.RuntimeMethodInfo"), //this is what is returned when debugging desktop apps using VS
                      dt = TDateTime(new DateTime(4210, 3, 4, 5, 6, 7)),
                      i = TNumber(4),
                      strings = TArray("string[]", 1),
diff --git a/src/mono/wasm/debugger/tests/debugger-test/debugger-driver.html b/src/mono/wasm/debugger/tests/debugger-test/debugger-driver.html
index 87ba804792ef39..b1bfcd859d0644 100644
--- a/src/mono/wasm/debugger/tests/debugger-test/debugger-driver.html
+++ b/src/mono/wasm/debugger/tests/debugger-test/debugger-driver.html
@@ -83,7 +83,6 @@
 			return App.int_add (a, b);
 		}
       </script>
-      <script type="text/javascript" src="mono-config.js"></script>
       <script type="text/javascript" src="runtime-debugger.js"></script>
       <script type="text/javascript" src="other.js"></script>
       <script async type="text/javascript" src="dotnet.js"></script>
diff --git a/src/mono/wasm/debugger/tests/debugger-test/runtime-debugger.js b/src/mono/wasm/debugger/tests/debugger-test/runtime-debugger.js
index 4c641eb2c6a0d7..360aa9b8b3036d 100644
--- a/src/mono/wasm/debugger/tests/debugger-test/runtime-debugger.js
+++ b/src/mono/wasm/debugger/tests/debugger-test/runtime-debugger.js
@@ -2,8 +2,20 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 var Module = { 
-	onRuntimeInitialized: function () {
-		config.loaded_cb = function () {
+    config: null,
+
+    preInit: async function() {
+        Module.config = await MONO.mono_wasm_load_config("./mono-config.json");
+    },
+
+    // Called when the runtime is initialized and wasm is ready
+    onRuntimeInitialized: function () {
+		if (!Module.config || Module.config.error) {
+            console.log("An error occured while loading the config file");
+            return;
+        }
+
+		Module.config.loaded_cb = function () {
 			App.init ();
 		};
 		// For custom logging patch the functions below
@@ -15,6 +27,6 @@ var Module = {
 		MONO.mono_wasm_setenv ("MONO_LOG_LEVEL", "debug");
 		MONO.mono_wasm_setenv ("MONO_LOG_MASK", "all");
 		*/
-		MONO.mono_load_runtime_and_bcl_args (config)
+		MONO.mono_load_runtime_and_bcl_args (Module.config)
 	},
 };
diff --git a/src/mono/wasm/runtime-test.js b/src/mono/wasm/runtime-test.js
index 74aa1083c033d1..8b3395f4ec50e8 100644
--- a/src/mono/wasm/runtime-test.js
+++ b/src/mono/wasm/runtime-test.js
@@ -204,14 +204,16 @@ function loadScript (url)
 	}
 }
 
-loadScript ("mono-config.js");
-
 var Module = {
 	mainScriptUrlOrBlob: "dotnet.js",
-
+	config: null,
 	print,
 	printErr,
 
+    preInit: async function() {
+        Module.config = await MONO.mono_wasm_load_config("./mono-config.json");
+    },
+
 	onAbort: function(x) {
 		print ("ABORT: " + x);
 		var err = new Error();
@@ -230,7 +232,7 @@ var Module = {
 			Module.ccall ('mono_wasm_enable_on_demand_gc', 'void', ['number'], [0]);
 		}
 
-		config.loaded_cb = function () {
+		Module.config.loaded_cb = function () {
 			let wds = FS.stat (working_dir);
 			if (wds === undefined || !FS.isDir (wds.mode)) {
 				fail_exec (`Could not find working directory ${working_dir}`);
@@ -240,13 +242,13 @@ var Module = {
 			FS.chdir (working_dir);
 			App.init ();
 		};
-		config.fetch_file_cb = function (asset) {
+		Module.config.fetch_file_cb = function (asset) {
 			// console.log("fetch_file_cb('" + asset + "')");
 			// for testing purposes add BCL assets to VFS until we special case File.Open
 			// to identify when an assembly from the BCL is being open and resolve it correctly.
 			/*
 			var content = new Uint8Array (read (asset, 'binary'));
-			var path = asset.substr(config.deploy_prefix.length);
+			var path = asset.substr(Module.config.deploy_prefix.length);
 			writeContentToFile(content, path);
 			*/
 
@@ -280,10 +282,9 @@ var Module = {
 			}
 		};
 
-		MONO.mono_load_runtime_and_bcl_args (config);
+		MONO.mono_load_runtime_and_bcl_args (Module.config);
 	},
 };
-
 loadScript ("dotnet.js");
 
 const IGNORE_PARAM_COUNT = -1;
diff --git a/src/mono/wasm/runtime/binding_support.js b/src/mono/wasm/runtime/binding_support.js
index 3951da52101b43..6f0040fe598cbf 100644
--- a/src/mono/wasm/runtime/binding_support.js
+++ b/src/mono/wasm/runtime/binding_support.js
@@ -154,8 +154,7 @@ var BindingSupportLib = {
 			this._interned_string_full_root_buffers = [];
 			this._interned_string_current_root_buffer = null;
 			this._interned_string_current_root_buffer_count = 0;
-			this._interned_string_table = new Map ();
-			this._managed_pointer_to_interned_string_table = new Map ();
+			this._interned_js_string_table = new Map ();
 		},
 
 		// Ensures the string is already interned on both the managed and JavaScript sides,
@@ -165,7 +164,7 @@ var BindingSupportLib = {
 				return this._empty_string;
 
 			var ptr = this.js_string_to_mono_string_interned (string);
-			var result = this._managed_pointer_to_interned_string_table.get (ptr);
+			var result = MONO.interned_string_table.get (ptr);
 			return result;
 		},
 
@@ -199,8 +198,10 @@ var BindingSupportLib = {
 			if (!ptr)
 				throw new Error ("mono_wasm_intern_string produced a null pointer");
 
-			this._interned_string_table.set (string, ptr);
-			this._managed_pointer_to_interned_string_table.set (ptr, string);
+			this._interned_js_string_table.set (string, ptr);
+			if (!MONO.interned_string_table)
+				MONO.interned_string_table = new Map();
+			MONO.interned_string_table.set (ptr, string);
 
 			if ((string.length === 0) && !this._empty_string_ptr)
 				this._empty_string_ptr = ptr;
@@ -216,7 +217,7 @@ var BindingSupportLib = {
 			if ((text.length === 0) && this._empty_string_ptr)
 				return this._empty_string_ptr;
 
-			var ptr = this._interned_string_table.get (string);
+			var ptr = this._interned_js_string_table.get (string);
 			if (ptr)
 				return ptr;
 
@@ -243,7 +244,7 @@ var BindingSupportLib = {
 			//  very expensive. Because we can not guarantee it won't happen, try to minimize
 			//  the cost of this and prevent performance issues for large strings
 			if (string.length <= 256) {
-				var interned = this._interned_string_table.get (string);
+				var interned = this._interned_js_string_table.get (string);
 				if (interned)
 					return interned;
 			}
@@ -279,20 +280,13 @@ var BindingSupportLib = {
 		},
 
 		_get_string_from_intern_table: function (mono_obj) {
-			return this._managed_pointer_to_interned_string_table.get (mono_obj);
+			if (!MONO.interned_string_table)
+				return undefined;
+			return MONO.interned_string_table.get (mono_obj);
 		},
 
-		conv_string: function (mono_obj, interned) {
-			var interned_instance = this._get_string_from_intern_table(mono_obj);
-			if (interned_instance !== undefined)
-				return interned_instance;
-
-			var result = MONO.string_decoder.copy (mono_obj);
-			if (interned) {
-				// This string is interned on the managed side but we didn't have it in our cache.
-				this._store_string_in_intern_table (result, mono_obj, false);
-			}
-			return result;
+		conv_string: function (mono_obj) {
+			return MONO.string_decoder.copy (mono_obj);
 		},
 
 		is_nested_array: function (ele) {
@@ -419,9 +413,8 @@ var BindingSupportLib = {
 					// TODO: Fix this once emscripten offers HEAPI64/HEAPU64 or can return them
 					throw new Error ("int64 not available");
 				case 3: // string
-					return this.conv_string (mono_obj, false);
 				case 29: // interned string
-					return this.conv_string (mono_obj, true);
+					return this.conv_string (mono_obj);
 				case 4: //vts
 					throw new Error ("no idea on how to unbox value types");
 				case 5: // delegate
@@ -441,7 +434,7 @@ var BindingSupportLib = {
 				case 18:
 					throw new Error ("Marshalling of primitive arrays are not supported.  Use the corresponding TypedArray instead.");
 				case 20: // clr .NET DateTime
-					var dateValue = this.call_method(this.get_date_value, null, "md", [ mono_obj ]);
+					var dateValue = this.call_method(this.get_date_value, null, "m", [ mono_obj ]);
 					return new Date(dateValue);
 				case 21: // clr .NET DateTimeOffset
 					var dateoffsetValue = this._object_to_string (mono_obj);
@@ -1205,7 +1198,7 @@ var BindingSupportLib = {
 			if (exception === 0)
 				return null;
 
-			var msg = this.conv_string (result, false);
+			var msg = this.conv_string (result);
 			var err = new Error (msg); //the convention is that invoke_method ToString () any outgoing exception
 			// console.warn ("error", msg, "at location", err.stack);
 			return err;
@@ -1695,8 +1688,8 @@ var BindingSupportLib = {
 			return BINDING.js_string_to_mono_string ("Invalid JS object handle '" + js_handle + "'");
 		}
 
-		var js_name = BINDING.conv_string (method_name, false);
-		if (!js_name) {
+		var js_name = BINDING.unbox_mono_obj (method_name);
+		if (!js_name || (typeof(js_name) !== "string")) {
 			setValue (is_exception, 1, "i32");
 			return BINDING.js_string_to_mono_string ("Invalid method name object '" + method_name + "'");
 		}
@@ -1729,7 +1722,7 @@ var BindingSupportLib = {
 			return BINDING.js_string_to_mono_string ("Invalid JS object handle '" + js_handle + "'");
 		}
 
-		var js_name = BINDING.conv_string (property_name, false);
+		var js_name = BINDING.conv_string (property_name);
 		if (!js_name) {
 			setValue (is_exception, 1, "i32");
 			return BINDING.js_string_to_mono_string ("Invalid property name object '" + js_name + "'");
@@ -1760,7 +1753,7 @@ var BindingSupportLib = {
 			return BINDING.js_string_to_mono_string ("Invalid JS object handle '" + js_handle + "'");
 		}
 
-		var property = BINDING.conv_string (property_name, false);
+		var property = BINDING.conv_string (property_name);
 		if (!property) {
 			setValue (is_exception, 1, "i32");
 			return BINDING.js_string_to_mono_string ("Invalid property name object '" + property_name + "'");
@@ -1844,7 +1837,7 @@ var BindingSupportLib = {
 	mono_wasm_get_global_object: function(global_name, is_exception) {
 		BINDING.bindings_lazy_init ();
 
-		var js_name = BINDING.conv_string (global_name, false);
+		var js_name = BINDING.conv_string (global_name);
 
 		var globalObj;
 
@@ -1902,7 +1895,7 @@ var BindingSupportLib = {
 	mono_wasm_new: function (core_name, args, is_exception) {
 		BINDING.bindings_lazy_init ();
 
-		var js_name = BINDING.conv_string (core_name, false);
+		var js_name = BINDING.conv_string (core_name);
 
 		if (!js_name) {
 			setValue (is_exception, 1, "i32");
diff --git a/src/mono/wasm/runtime/driver.c b/src/mono/wasm/runtime/driver.c
index 7a2e0fc4fb7159..ca98e347dd120b 100644
--- a/src/mono/wasm/runtime/driver.c
+++ b/src/mono/wasm/runtime/driver.c
@@ -98,29 +98,19 @@ mono_wasm_invoke_js (MonoString *str, int *is_exception)
 	if (str == NULL)
 		return NULL;
 
-	int is_interned = mono_string_instance_is_interned (str);
-	mono_unichar2 *native_chars = mono_string_chars (str);
-	int native_len = mono_string_length (str) * 2;
-	int native_res_len;
+	int native_res_len = 0;
 	int *p_native_res_len = &native_res_len;
 
 	mono_unichar2 *native_res = (mono_unichar2*)EM_ASM_INT ({
-		var str;
-		// If the expression is interned, use binding_support's intern table implementation to
-		//  avoid decoding it again unless necessary
-		// We could technically use conv_string for both cases here, but it's more expensive
-		//  than using decode directly in the case where the expression isn't interned
-		if ($4)
-			str = BINDING.conv_string($5, true);
-		else
-			str = MONO.string_decoder.decode ($0, $0 + $1);
+		var js_str = MONO.string_decoder.copy ($0);
 
 		try {
-			var res = eval (str);
-			if (res === null || res == undefined)
-				return 0;
-			res = res.toString ();
+			var res = eval (js_str);
 			setValue ($2, 0, "i32");
+			if (res === null || res === undefined)
+				return 0;
+			else
+				res = res.toString ();
 		} catch (e) {
 			res = e.toString();
 			setValue ($2, 1, "i32");
@@ -139,9 +129,9 @@ mono_wasm_invoke_js (MonoString *str, int *is_exception)
 		}
 		var buff = Module._malloc((res.length + 1) * 2);
 		stringToUTF16 (res, buff, (res.length + 1) * 2);
-		setValue ($3, res.length, "i32");
+		setValue ($1, res.length, "i32");
 		return buff;
-	}, (int)native_chars, native_len, is_exception, p_native_res_len, is_interned, (int)str);
+	}, (int)str, p_native_res_len, is_exception);
 
 	if (native_res == NULL)
 		return NULL;
@@ -191,6 +181,9 @@ wasm_trace_logger (const char *log_domain, const char *log_level, const char *me
 				break;
 		}
 	}, log_level, message, fatal, log_domain, user_data);
+
+	if (fatal)
+		exit (1);
 }
 
 typedef uint32_t target_mword;
@@ -728,6 +721,7 @@ mono_wasm_string_get_utf8 (MonoString *str)
 	return mono_string_to_utf8 (str); //XXX JS is responsible for freeing this
 }
 
+// Deprecated
 EMSCRIPTEN_KEEPALIVE void
 mono_wasm_string_convert (MonoString *str)
 {
@@ -1129,3 +1123,26 @@ mono_wasm_intern_string (MonoString *string)
 {
 	return mono_string_intern (string);
 }
+
+EMSCRIPTEN_KEEPALIVE void
+mono_wasm_string_get_data (
+	MonoString *string, mono_unichar2 **outChars, int *outLengthBytes, int *outIsInterned
+) {
+	if (!string) {
+		if (outChars)
+			*outChars = 0;
+		if (outLengthBytes)
+			*outLengthBytes = 0;
+		if (outIsInterned)
+			*outIsInterned = 1;
+		return;
+	}
+
+	if (outChars)
+		*outChars = mono_string_chars (string);
+	if (outLengthBytes)
+		*outLengthBytes = mono_string_length (string) * 2;
+	if (outIsInterned)
+		*outIsInterned = mono_string_instance_is_interned (string);
+	return;
+}
diff --git a/src/mono/wasm/runtime/library_mono.js b/src/mono/wasm/runtime/library_mono.js
index 685aaaf375d85e..84fb5684abd801 100644
--- a/src/mono/wasm/runtime/library_mono.js
+++ b/src/mono/wasm/runtime/library_mono.js
@@ -86,6 +86,7 @@ var MonoSupportLib = {
 			module ["mono_wasm_new_root"] = MONO.mono_wasm_new_root.bind(MONO);
 			module ["mono_wasm_new_roots"] = MONO.mono_wasm_new_roots.bind(MONO);
 			module ["mono_wasm_release_roots"] = MONO.mono_wasm_release_roots.bind(MONO);
+			module ["mono_wasm_load_config"] = MONO.mono_wasm_load_config.bind(MONO);
 		},
 
 		_base64Converter: {
@@ -487,15 +488,54 @@ var MonoSupportLib = {
 		mono_text_decoder: undefined,
 		string_decoder: {
 			copy: function (mono_string) {
-				if (mono_string == 0)
+				if (mono_string === 0)
 					return null;
 
-				if (!this.mono_wasm_string_convert)
-					this.mono_wasm_string_convert = Module.cwrap ("mono_wasm_string_convert", null, ['number']);
+				if (!this.mono_wasm_string_root)
+					this.mono_wasm_string_root = MONO.mono_wasm_new_root ();
+				this.mono_wasm_string_root.value = mono_string;
+
+				if (!this.mono_wasm_string_get_data)
+					this.mono_wasm_string_get_data = Module.cwrap ("mono_wasm_string_get_data", null, ['number', 'number', 'number', 'number']);
+				
+				if (!this.mono_wasm_string_decoder_buffer)
+					this.mono_wasm_string_decoder_buffer = Module._malloc(12);
+				
+				let ppChars = this.mono_wasm_string_decoder_buffer + 0,
+					pLengthBytes = this.mono_wasm_string_decoder_buffer + 4,
+					pIsInterned = this.mono_wasm_string_decoder_buffer + 8;
+				
+				this.mono_wasm_string_get_data (mono_string, ppChars, pLengthBytes, pIsInterned);
+
+				// TODO: Is this necessary?
+				if (!this.mono_wasm_empty_string)
+					this.mono_wasm_empty_string = "";
+
+				let result = this.mono_wasm_empty_string;
+				let lengthBytes = Module.HEAP32[pLengthBytes / 4],
+					pChars = Module.HEAP32[ppChars / 4],
+					isInterned = Module.HEAP32[pIsInterned / 4];
+
+				if (pLengthBytes && pChars) {
+					if (
+						isInterned && 
+						MONO.interned_string_table && 
+						MONO.interned_string_table.has(mono_string)
+					) {
+						result = MONO.interned_string_table.get(mono_string);
+						// console.log("intern table cache hit", mono_string, result.length);
+					} else {
+						result = this.decode(pChars, pChars + lengthBytes, false);
+						if (isInterned) {
+							if (!MONO.interned_string_table)
+								MONO.interned_string_table = new Map();
+							// console.log("interned", mono_string, result.length);
+							MONO.interned_string_table.set(mono_string, result);
+						}
+					}						
+				}
 
-				this.mono_wasm_string_convert (mono_string);
-				var result = this.result;
-				this.result = undefined;
+				this.mono_wasm_string_root.value = 0;
 				return result;
 			},
 			decode: function (start, end, save) {
@@ -525,484 +565,52 @@ var MonoSupportLib = {
 			},
 		},
 
-		mono_wasm_get_exception_object: function() {
-			var exception_obj = MONO.active_exception;
-			MONO.active_exception = null;
-			return exception_obj ;
-		},
-
-		mono_wasm_get_call_stack: function() {
-			if (!this.mono_wasm_current_bp_id)
-				this.mono_wasm_current_bp_id = Module.cwrap ("mono_wasm_current_bp_id", 'number');
-			if (!this.mono_wasm_enum_frames)
-				this.mono_wasm_enum_frames = Module.cwrap ("mono_wasm_enum_frames", null);
-
-			var bp_id = this.mono_wasm_current_bp_id ();
-			this.active_frames = [];
-			this.mono_wasm_enum_frames ();
-
-			var the_frames = this.active_frames;
-			this.active_frames = [];
-			return {
-				"breakpoint_id": bp_id,
-				"frames": the_frames,
-			};
-		},
-
-		_fixup_name_value_objects: function (var_list) {
-			let out_list = [];
-
-			var i = 0;
-			while (i < var_list.length) {
-				let o = var_list [i];
-				const this_has_name = o.name !== undefined;
-				let next_has_value_or_get_set = false;
-
-				if (i + 1 < var_list.length) {
-					const next = var_list [i+1];
-					next_has_value_or_get_set = next.value !== undefined || next.get !== undefined || next.set !== undefined;
-				}
-
-				if (!this_has_name) {
-					// insert the object as-is
-					// Eg. in case of locals, the names are added
-					// later
-					i ++;
-				} else if (next_has_value_or_get_set) {
-					// found a {name} followed by a {value/get}
-					o = Object.assign (o, var_list [i + 1]);
-					i += 2;
-				} else {
-					// missing value/get, so add a placeholder one
-					o.value = {
-						type: "symbol",
-						value: "<unreadable value>",
-						description: "<unreadable value>"
-					};
-					i ++;
-				}
-
-				out_list.push (o);
-			}
-
-			return out_list;
-		},
-
-		_filter_automatic_properties: function (props, accessors_only=false) {
-			// Note: members in @props, have derived class members, followed by
-			//       those from parent classes
-
-			// Note: Auto-properties have backing fields, named with a special suffix.
-			//       @props here will have the backing field, *and* the getter.
-			//
-			//       But we want to return only one name/value pair:
-			//          [name of the auto-property] = value of the backing field
-
-			let getters = {};
-			let all_fields_except_backing_fields = {};
-			let backing_fields = {};
-
-			// Split props into the 3 groups - backing_fields, getters, and all_fields_except_backing_fields
-			props.forEach(p => {
-				if (p.name === undefined) {
-					console.debug(`Bug: Found a member with no name. Skipping it. p: ${JSON.stringify(p)}`);
-					return;
-				}
-
-				if (p.name.endsWith('k__BackingField')) {
-					const auto_prop_name = p.name.replace ('k__BackingField', '')
-						.replace ('<', '')
-						.replace ('>', '');
-
-					// Only take the first one, as that is overriding others
-					if (!(auto_prop_name in backing_fields))
-						backing_fields[auto_prop_name] = Object.assign(p, { name: auto_prop_name });
-
-				} else if (p.get !== undefined) {
-					// if p wasn't overridden by a getter or a field,
-					// from a more derived class
-					if (!(p.name in getters) && !(p.name in all_fields_except_backing_fields))
-						getters[p.name] = p;
-
-				} else if (!(p.name in all_fields_except_backing_fields)) {
-					all_fields_except_backing_fields[p.name] = p;
-				}
-			});
-
-			// Filter/merge backing fields, and getters
-			Object.values(backing_fields).forEach(backing_field => {
-				const auto_prop_name = backing_field.name;
-				const getter = getters[auto_prop_name];
-
-				if (getter === undefined) {
-					// backing field with no getter
-					// eg. when a field overrides/`new string foo=..`
-					//     an autoproperty
-					return;
+		mono_wasm_add_dbg_command_received: function(res_ok, id, buffer, buffer_len) {
+			const assembly_data = new Uint8Array(Module.HEAPU8.buffer, buffer, buffer_len);
+			const base64String = MONO._base64Converter.toBase64StringImpl(assembly_data);
+			const buffer_obj = {
+				res_ok,
+				res: {
+						id,
+						value: base64String
 				}
-
-				if (auto_prop_name in all_fields_except_backing_fields) {
-					delete getters[auto_prop_name];
-				} else if (getter.__args.owner_class === backing_field.__args.owner_class) {
-					// getter+backing_field are from the same class.
-					// Add the backing_field value as a field
-					all_fields_except_backing_fields[auto_prop_name] = backing_field;
-
-					// .. and drop the auto-prop getter
-					delete getters[auto_prop_name];
-				}
-			});
-
-			if (accessors_only)
-				return Object.values(getters);
-
-			return Object.values(all_fields_except_backing_fields).concat(Object.values(getters));
-		},
-
-		/** Given `dotnet:object:foo:bar`,
-		 * returns { scheme:'object', value: 'foo:bar' }
-		 *
-		 * Given `dotnet:pointer:{ b: 3 }`
-		 * returns { scheme:'object', value: '{b:3}`, o: {b:3}
-		 *
-		 * @param  {string} idStr
-		 * @param  {boolean} [throwOnError=false]
-		 *
-		 * @returns {WasmId}
-		 */
-		_parse_object_id: function (idStr, throwOnError = false) {
-			if (idStr === undefined || idStr == "" || !idStr.startsWith ('dotnet:')) {
-				if (throwOnError)
-					throw new Error (`Invalid id: ${idStr}`);
-
-				return undefined;
-			}
-
-			const [, scheme, ...rest] = idStr.split(':');
-			let res = {
-				scheme,
-				value: rest.join (':'),
-				idStr,
-				o: {}
-			};
-
-			try {
-				res.o = JSON.parse(res.value);
-			// eslint-disable-next-line no-empty
-			} catch (e) {}
-
-			return res;
-		},
-
-        _resolve_member_by_name: function (base_object, base_name, expr_parts) {
-            if (base_object === undefined || base_object.value === undefined)
-                throw new Error(`Bug: base_object is undefined`);
-
-            if (base_object.value.type === 'object' && base_object.value.subtype === 'null')
-                throw new ReferenceError(`Null reference: ${base_name} is null`);
-
-            if (base_object.value.type !== 'object')
-                throw new ReferenceError(`'.' is only supported on non-primitive types. Failed on '${base_name}'`);
-
-            if (expr_parts.length == 0)
-                throw new Error(`Invalid member access expression`);//FIXME: need the full expression here
-
-            const root = expr_parts[0];
-            const props = this.mono_wasm_get_details(base_object.value.objectId, {});
-            let resObject = props.find(l => l.name == root);
-            if (resObject !== undefined) {
-                if (resObject.value === undefined && resObject.get !== undefined)
-                    resObject = this._invoke_getter(base_object.value.objectId, root);
-            }
-
-            if (resObject === undefined || expr_parts.length == 1)
-                return resObject;
-            else {
-                expr_parts.shift();
-                return this._resolve_member_by_name(resObject, root, expr_parts);
-            }
-        },
-
-        mono_wasm_eval_member_access: function (scope, var_list, rootObjectId, expr) {
-            if (expr === undefined || expr.length == 0)
-                throw new Error(`expression argument required`);
-
-            let parts = expr.split('.');
-            if (parts.length == 0)
-                throw new Error(`Invalid member access expression: ${expr}`);
-
-            const root = parts[0];
-
-            const locals = this.mono_wasm_get_variables(scope, var_list);
-            let rootObject = locals.find(l => l.name === root);
-            if (rootObject === undefined) {
-                // check `this`
-                const thisObject = locals.find(l => l.name == "this");
-                if (thisObject === undefined)
-                    throw new ReferenceError(`Could not find ${root} in locals, and no 'this' found.`);
-
-                const thisProps = this.mono_wasm_get_details(thisObject.value.objectId, {});
-                rootObject = thisProps.find(tp => tp.name == root);
-                if (rootObject === undefined)
-                    throw new ReferenceError(`Could not find ${root} in locals, or in 'this'`);
-
-                if (rootObject.value === undefined && rootObject.get !== undefined)
-                    rootObject = this._invoke_getter(thisObject.value.objectId, root);
-            }
-
-            parts.shift();
-
-            if (parts.length == 0)
-                return rootObject;
-
-            if (rootObject === undefined || rootObject.value === undefined)
-                throw new Error(`Could not get a value for ${root}`);
-
-            return this._resolve_member_by_name(rootObject, root, parts);
-		},
-
-		mono_wasm_set_variable_value: function (scope, index, name, newValue) {
-			console.debug (">> mono_wasm_set_variable_value " + name + " - " + newValue);
-			var ret = this._c_fn_table.mono_wasm_set_variable_on_frame_wrapper(scope, index, name, newValue);
-			if (ret == false)
-				throw new Error(`Could not get a value for ${name}`);
-            return ret;
-        },
-
-		/**
-		 * @param  {WasmId} id
-		 * @returns {object[]}
-		 */
-		_get_vt_properties: function (id, args={}) {
-			let entry = this._get_id_props (id.idStr);
-
-			if (entry === undefined || entry.members === undefined) {
-				if (!isNaN (id.o.containerId)) {
-					// We are expanding, so get *all* the members.
-					// Which ones to return based on @args, can be determined
-					// at the time of return
-					this._get_object_properties (id.o.containerId, { expandValueTypes: true });
-				} else if (!isNaN (id.o.arrayId))
-					this._get_array_values (id, Number (id.o.arrayIdx), 1, true);
-				else
-					throw new Error (`Invalid valuetype id (${id.idStr}). Can't get properties for it.`);
-			}
-
-			// Let's try again
-			entry = this._get_id_props (id.idStr);
-
-			if (entry !== undefined && entry.members !== undefined) {
-				if (args.accessorPropertiesOnly === true)
-					return entry.accessors;
-
-				return entry.members;
 			}
-
-			throw new Error (`Unknown valuetype id: ${id.idStr}. Failed to get properties for it.`);
+			MONO.commands_received = buffer_obj;
 		},
 
-		/**
-		 *
-		 * @callback GetIdArgsCallback
-		 * @param {object} var
-		 * @param {number} idx
-		 * @returns {object}
-		 */
-
-		/**
-		 * @param  {object[]} vars
-		 * @param  {GetIdArgsCallback} getIdArgs
-		 * @returns {object}
-		 */
-		_assign_vt_ids: function (vars, getIdArgs)
+		mono_wasm_send_dbg_command_with_parms: function (id, command_set, command, command_parameters, length, valtype, newvalue)
 		{
-			vars.forEach ((v, i) => {
-				// we might not have a `.value`, like in case of getters which have a `.get` instead
-				const value = v.value;
-				if (value === undefined || !value.isValueType)
-					return;
-
-				if (value.objectId !== undefined)
-					throw new Error (`Bug: Trying to assign valuetype id, but the var already has one: ${v}`);
-
-				value.objectId = this._new_or_add_id_props ({ scheme: 'valuetype', idArgs: getIdArgs (v, i), props: value._props });
-				delete value._props;
-			});
-
-			return vars;
-		},
-
-		//
-		// @var_list: [ { index: <var_id>, name: <var_name> }, .. ]
-		mono_wasm_get_variables: function(scope, var_list) {
-			const numBytes = var_list.length * Int32Array.BYTES_PER_ELEMENT;
-			const ptr = Module._malloc(numBytes);
-			let heapBytes = new Int32Array(Module.HEAP32.buffer, ptr, numBytes);
-			for (let i=0; i<var_list.length; i++) {
-				heapBytes[i] = var_list[i].index;
-			}
-
-			this._async_method_objectId = 0;
-			let { res_ok, res } = this.mono_wasm_get_local_vars_info (scope, heapBytes.byteOffset, var_list.length);
-			Module._free(heapBytes.byteOffset);
+			const dataHeap = new Uint8Array (Module.HEAPU8.buffer, command_parameters, command_parameters.length);
+			dataHeap.set (new Uint8Array (this._base64_to_uint8 (command_parameters)));
+			this._c_fn_table.mono_wasm_send_dbg_command_with_parms_wrapper (id, command_set, command, dataHeap.byteOffset, length, valtype, newvalue.toString());
+			let { res_ok, res } = MONO.commands_received;
 			if (!res_ok)
-				throw new Error (`Failed to get locals for scope ${scope}`);
-
-			if (this._async_method_objectId != 0)
-				this._assign_vt_ids (res, v => ({ containerId: this._async_method_objectId, fieldOffset: v.fieldOffset }));
-
-			for (let i in res) {
-				const res_name = res [i].name;
-				if (this._async_method_objectId != 0) {
-					//Async methods are special in the way that local variables can be lifted to generated class fields
-					//value of "this" comes here either
-					if (res_name !== undefined && res_name.indexOf ('>') > 0) {
-						// For async methods, we get the names too, so use that
-						// ALTHOUGH, the name wouldn't have `<>` for method args
-						res [i].name = res_name.substring (1, res_name.indexOf ('>'));
-					}
-				} else if (res_name === undefined && var_list [i] !== undefined) {
-					// For non-async methods, we just have the var id, but we have the name
-					// from the caller
-					res [i].name = var_list [i].name;
-				}
-			}
-
-			this._post_process_details(res);
+				throw new Error (`Failed on mono_wasm_invoke_method_debugger_agent_with_parms`);
 			return res;
 		},
 
-		// Keep in sync with the flags in mini-wasm-debugger.c
-		_get_properties_args_to_gpflags: function (args) {
-			let gpflags =0;
-			/*
-				Disabled for now. Instead, we ask debugger.c to return
-				~all~ the members, and then handle the filtering in mono.js .
-
-			if (args.ownProperties)
-				gpflags |= 1;
-			if (args.accessorPropertiesOnly)
-				gpflags |= 2;
-			*/
-			if (args.expandValueTypes)
-				gpflags |= 4;
-
-			return gpflags;
-		},
+		mono_wasm_send_dbg_command: function (id, command_set, command, command_parameters)
+		{
+			const dataHeap = new Uint8Array (Module.HEAPU8.buffer, command_parameters, command_parameters.length);
+			dataHeap.set (new Uint8Array (this._base64_to_uint8 (command_parameters)));
 
-		/**
-		 * @param  {number} idNum
-		 * @param  {boolean} expandValueTypes
-		 * @returns {object}
-		 */
-		_get_object_properties: function(idNum, args={}) {
-			let gpflags = this._get_properties_args_to_gpflags (args);
+			this._c_fn_table.mono_wasm_send_dbg_command_wrapper (id, command_set, command, dataHeap.byteOffset, command_parameters.length);
 
-			let { res_ok, res } = this.mono_wasm_get_object_properties_info (idNum, gpflags);
+			let { res_ok, res } = MONO.commands_received;
 			if (!res_ok)
-				throw new Error (`Failed to get properties for ${idNum}`);
-
-			res = MONO._filter_automatic_properties (res, args.accessorPropertiesOnly === true);
-			res = this._assign_vt_ids (res, v => ({ containerId: idNum, fieldOffset: v.fieldOffset }));
-			res = this._post_process_details (res);
-
+				throw new Error (`Failed on mono_wasm_send_dbg_command`);
 			return res;
-		},
 
-		/**
-		 * @param  {WasmId} id
-		 * @param  {number} [startIdx=0]
-		 * @param  {number} [count=-1]
-		 * @param  {boolean} [expandValueTypes=false]
-		 * @returns {object[]}
-		 */
-		_get_array_values: function (id, startIdx = 0, count = -1, expandValueTypes = false) {
-			if (isNaN (id.o.arrayId) || isNaN (startIdx))
-				throw new Error (`Invalid array id: ${id.idStr}`);
+		},
 
-			let gpflags = this._get_properties_args_to_gpflags({ expandValueTypes });
-			let { res_ok, res } = this.mono_wasm_get_array_values_info (id.o.arrayId, startIdx, count, gpflags);
+		mono_wasm_get_dbg_command_info: function ()
+		{
+			let { res_ok, res } =  MONO.commands_received;
 			if (!res_ok)
-				throw new Error (`Failed to get properties for array id ${id.idStr}`);
-
-			res = this._assign_vt_ids (res, (_, i) => ({ arrayId: id.o.arrayId, arrayIdx: Number (startIdx) + i}));
-
-			for (let i = 0; i < res.length; i ++) {
-				let value = res [i].value;
-				if (value.objectId !== undefined && value.objectId.startsWith("dotnet:pointer"))
-					this._new_or_add_id_props ({ objectId: value.objectId, props: { varName: `[${i}]` } });
-			}
-			res = this._post_process_details (res);
+				throw new Error (`Failed on mono_wasm_get_dbg_command_info`);
 			return res;
 		},
 
-		_post_process_details: function (details) {
-			if (details == undefined)
-				return {};
-
-			if (details.length > 0)
-				this._extract_and_cache_value_types(details);
-
-			// remove __args added by add_properties_var
-			details.forEach(d => delete d.__args);
-			return details;
-		},
-
-		/**
-		 * Gets the next id number to use for generating ids
-		 *
-		 * @returns {number}
-		 */
-		_next_id: function () {
-			return ++this._next_id_var;
-		},
-
-		_extract_and_cache_value_types: function (var_list) {
-			if (var_list == undefined || !Array.isArray (var_list) || var_list.length == 0)
-				return var_list;
-
-			for (let i in var_list) {
-				let value = var_list [i].value;
-				if (value === undefined)
-					continue;
-
-				if (value.objectId !== undefined && value.objectId.startsWith ("dotnet:pointer:")) {
-					let ptr_args = this._get_id_props (value.objectId);
-					if (ptr_args === undefined)
-						throw new Error (`Bug: Expected to find an entry for pointer id: ${value.objectId}`);
-
-					// It might have been already set in some cases, like arrays
-					// where the name would be `0`, but we want `[0]` for pointers,
-					// so the deref would look like `*[0]`
-					ptr_args.varName = ptr_args.varName || var_list [i].name;
-				}
-
-				if (value.type != "object" || value.isValueType != true || value.expanded != true) // undefined would also give us false
-					continue;
-
-				if (value.members === undefined) {
-					// this could happen for valuetypes that maybe
-					// we were not able to describe, like `ref` parameters
-					// So, skip that
-					continue;
-				}
-
-				// Generate objectId for expanded valuetypes
-				value.objectId = value.objectId || this._new_or_add_id_props ({ scheme: 'valuetype' });
-
-				this._extract_and_cache_value_types (value.members);
-
-				const accessors = value.members.filter(m => m.get !== undefined);
-				const new_props = Object.assign ({ members: value.members, accessors }, value.__extra_vt_props);
-
-				this._new_or_add_id_props ({ objectId: value.objectId, props: new_props });
-				delete value.members;
-				delete value.__extra_vt_props;
-			}
-
-			return var_list;
-		},
-
 		_get_cfo_res_details: function (objectId, args) {
 			if (!(objectId in this._call_function_res_cache))
 				throw new Error(`Could not find any object with id ${objectId}`);
@@ -1061,116 +669,8 @@ var MonoSupportLib = {
 			return { __value_as_json_string__: JSON.stringify (res_details) };
 		},
 
-		/**
-		 * Generates a new id, and a corresponding entry for associated properties
-		 *    like `dotnet:pointer:{ a: 4 }`
-		 * The third segment of that `{a:4}` is the idArgs parameter
-		 *
-		 * Only `scheme` or `objectId` can be set.
-		 * if `scheme`, then a new id is generated, and it's properties set
-		 * if `objectId`, then it's properties are updated
-		 *
-		 * @param {object} args
-		 * @param  {string} [args.scheme=undefined] scheme second part of `dotnet:pointer:..`
-		 * @param  {string} [args.objectId=undefined] objectId
-		 * @param  {object} [args.idArgs={}] The third segment of the objectId
-		 * @param  {object} [args.props={}] Properties for the generated id
-		 *
-		 * @returns {string} generated/updated id string
-		 */
-		_new_or_add_id_props: function ({ scheme = undefined, objectId = undefined, idArgs = {}, props = {} }) {
-			if (scheme === undefined && objectId === undefined)
-				throw new Error (`Either scheme or objectId must be given`);
-
-			if (scheme !== undefined && objectId !== undefined)
-				throw new Error (`Both scheme, and objectId cannot be given`);
-
-			if (objectId !== undefined && Object.entries (idArgs).length > 0)
-				throw new Error (`Both objectId, and idArgs cannot be given`);
-
-			if (Object.entries (idArgs).length == 0) {
-				// We want to generate a new id, only if it doesn't have other
-				// attributes that it can use to uniquely identify.
-				// Eg, we don't do this for `dotnet:valuetype:{containerId:4, fieldOffset: 24}`
-				idArgs.num = this._next_id ();
-			}
-
-			let idStr;
-			if (objectId !== undefined) {
-				idStr = objectId;
-				const old_props = this._id_table [idStr];
-				if (old_props === undefined)
-					throw new Error (`ObjectId not found in the id table: ${idStr}`);
-
-				this._id_table [idStr] = Object.assign (old_props, props);
-			} else {
-				idStr = `dotnet:${scheme}:${JSON.stringify (idArgs)}`;
-				this._id_table [idStr] = props;
-			}
-
-			return idStr;
-		},
-
-		/**
-		 * @param  {string} objectId
-		 * @returns {object}
-		 */
-		_get_id_props: function (objectId) {
-			return this._id_table [objectId];
-		},
-
-		_get_deref_ptr_value: function (objectId) {
-			const ptr_args = this._get_id_props (objectId);
-			if (ptr_args === undefined)
-				throw new Error (`Unknown pointer id: ${objectId}`);
-
-			if (ptr_args.ptr_addr == 0 || ptr_args.klass_addr == 0)
-				throw new Error (`Both ptr_addr and klass_addr need to be non-zero, to dereference a pointer. objectId: ${objectId}`);
-
-			const value_addr = new DataView (Module.HEAPU8.buffer).getUint32 (ptr_args.ptr_addr, /* littleEndian */ true);
-			let { res_ok, res } = this.mono_wasm_get_deref_ptr_value_info (value_addr, ptr_args.klass_addr);
-			if (!res_ok)
-				throw new Error (`Failed to dereference pointer ${objectId}`);
-
-			if (res.length > 0) {
-				if (ptr_args.varName === undefined)
-					throw new Error (`Bug: no varName found for the pointer. objectId: ${objectId}`);
-
-				res [0].name = `*${ptr_args.varName}`;
-			}
-
-			res = this._post_process_details (res);
-			return res;
-		},
-
 		mono_wasm_get_details: function (objectId, args={}) {
-			let id = this._parse_object_id (objectId, true);
-
-			switch (id.scheme) {
-				case "object": {
-					if (isNaN (id.value))
-						throw new Error (`Invalid objectId: ${objectId}. Expected a numeric id.`);
-
-					args.expandValueTypes = false;
-					return this._get_object_properties(id.value, args);
-				}
-
-				case "array":
-					return this._get_array_values (id);
-
-				case "valuetype":
-					return this._get_vt_properties(id, args);
-
-				case "cfo_res":
-					return this._get_cfo_res_details (objectId, args);
-
-				case "pointer": {
-					return this._get_deref_ptr_value (objectId);
-				}
-
-				default:
-					throw new Error(`Unknown object id format: ${objectId}`);
-			}
+				return this._get_cfo_res_details (`dotnet:cfo_res:${objectId}`, args);
 		},
 
 		_cache_call_function_res: function (obj) {
@@ -1184,105 +684,33 @@ var MonoSupportLib = {
 				delete this._cache_call_function_res[objectId];
 		},
 
-		/**
-		 * @param  {string} objectIdStr objectId
-		 * @param  {string} name property name
-		 * @returns {object} return value
-		 */
-		_invoke_getter: function (objectIdStr, name) {
-			const id = this._parse_object_id (objectIdStr);
-			if (id === undefined)
-				throw new Error (`Invalid object id: ${objectIdStr}`);
-
-			let getter_res;
-			if (id.scheme == 'object') {
-				if (isNaN (id.o) || id.o < 0)
-					throw new Error (`Invalid object id: ${objectIdStr}`);
-
-				let { res_ok, res } = this.mono_wasm_invoke_getter_on_object_info (id.o, name);
-				if (!res_ok)
-					throw new Error (`Invoking getter on ${objectIdStr} failed`);
-
-				getter_res = res;
-			} else if (id.scheme == 'valuetype') {
-				const id_props = this._get_id_props (objectIdStr);
-				if (id_props === undefined)
-					throw new Error (`Unknown valuetype id: ${objectIdStr}`);
-
-				if (typeof id_props.value64 !== 'string' || isNaN (id_props.klass))
-					throw new Error (`Bug: Cannot invoke getter on ${objectIdStr}, because of missing or invalid klass/value64 fields. idProps: ${JSON.stringify (id_props)}`);
-
-				const dataPtr = Module._malloc (id_props.value64.length);
-				const dataHeap = new Uint8Array (Module.HEAPU8.buffer, dataPtr, id_props.value64.length);
-				dataHeap.set (new Uint8Array (this._base64_to_uint8 (id_props.value64)));
-
-				let { res_ok, res } = this.mono_wasm_invoke_getter_on_value_info (dataHeap.byteOffset, id_props.klass, name);
-				Module._free (dataHeap.byteOffset);
-
-				if (!res_ok) {
-					console.debug (`Invoking getter on valuetype ${objectIdStr}, with props: ${JSON.stringify (id_props)} failed`);
-					throw new Error (`Invoking getter on valuetype ${objectIdStr} failed`);
-				}
-				getter_res = res;
-			} else {
-				throw new Error (`Only object, and valuetypes supported for getters, id: ${objectIdStr}`);
-			}
-
-			getter_res = MONO._post_process_details (getter_res);
-			return getter_res.length > 0 ? getter_res [0] : {};
-		},
-
-		/**
-		 * @param  {string} objectIdStr objectId
-		 * @param  {string} name property name
-		 * @returns {object} return true if it works and false if it doesn't
-		 */
-		_set_value_on_object: function (objectIdStr, name, newvalue) {
-			const id = this._parse_object_id (objectIdStr);
-			if (id === undefined)
-				throw new Error (`Invalid object id: ${objectIdStr}`);
-
-			let setter_res;
-			if (id.scheme == 'object') {
-				if (isNaN (id.o) || id.o < 0)
-					throw new Error (`Invalid object id: ${objectIdStr}`);
-
-				var ret = this._c_fn_table.mono_wasm_set_value_on_object_wrapper (id.o, name, newvalue);
-				if (!ret)
-					throw new Error (`Invoking setter on ${objectIdStr} failed`);
-
-				setter_res = ret;
-			}
-			else
-				throw new Error (`Only object is supported for setters, id: ${objectIdStr}`);
-			return setter_res;
-		},
-
-		_create_proxy_from_object_id: function (objectId) {
-			const details = this.mono_wasm_get_details(objectId);
-
+		_create_proxy_from_object_id: function (objectId, details) {
 			if (objectId.startsWith ('dotnet:array:'))
-				return details.map (p => p.value);
+			{
+				let ret = details.map (p => p.value);
+				return ret;
+			}
 
 			let proxy = {};
 			Object.keys (details).forEach (p => {
 				var prop = details [p];
 				if (prop.get !== undefined) {
-					// TODO: `set`
-
 					Object.defineProperty (proxy,
 							prop.name,
-							{ get () { return MONO._invoke_getter (objectId, prop.name); } }
+							{ get () { return MONO.mono_wasm_send_dbg_command(-1, prop.get.commandSet, prop.get.command, prop.get.buffer, prop.get.length); },
+							set: function (newValue) { MONO.mono_wasm_send_dbg_command_with_parms(-1, prop.set.commandSet, prop.set.command, prop.set.buffer, prop.set.length, prop.set.valtype, newValue); return MONO.commands_received.res_ok;}}
+					);
+				} else if (prop.set !== undefined ){
+					Object.defineProperty (proxy,
+						prop.name,
+						{ get () { return prop.value; },
+						  set: function (newValue) { MONO.mono_wasm_send_dbg_command_with_parms(-1, prop.set.commandSet, prop.set.command, prop.set.buffer, prop.set.length, prop.set.valtype, newValue); return MONO.commands_received.res_ok;}}
 					);
 				} else {
 					proxy [prop.name] = prop.value;
 				}
 			});
-
-			const handler1 = {
-				set (obj, prop, newValue) {return MONO._set_value_on_object (objectId, prop, newValue.toString());},
-			};
-			return new Proxy(proxy, handler1);
+			return proxy;
 		},
 
 		mono_wasm_call_function_on: function (request) {
@@ -1290,6 +718,7 @@ var MonoSupportLib = {
 				throw new Error (`"arguments" should be an array, but was ${request.arguments}`);
 
 			const objId = request.objectId;
+			const details = request.details;
 			let proxy;
 
 			if (objId.startsWith ('dotnet:cfo_res:')) {
@@ -1298,7 +727,7 @@ var MonoSupportLib = {
 				else
 					throw new Error (`Unknown object id ${objId}`);
 			} else {
-				proxy = this._create_proxy_from_object_id (objId);
+				proxy = this._create_proxy_from_object_id (objId, details);
 			}
 
 			const fn_args = request.arguments != undefined ? request.arguments.map(a => JSON.stringify(a.value)) : [];
@@ -1308,22 +737,19 @@ var MonoSupportLib = {
 			if (fn_res === undefined)
 				return { type: "undefined" };
 
-			if (fn_res === null || (fn_res.subtype === 'null' && fn_res.value === undefined))
-				return fn_res;
-
-			// primitive type
 			if (Object (fn_res) !== fn_res)
-				return fn_res;
-
-			// return .value, if it is a primitive type
-			if (fn_res.value !== undefined && Object (fn_res.value.value) !== fn_res.value.value)
-				return fn_res.value;
+			{
+				if (typeof(fn_res) == "object" && fn_res == null)
+					return { type: typeof(fn_res), subtype: `${fn_res}`, value: null };
+				return { type: typeof(fn_res), description: `${fn_res}`, value: `${fn_res}`};
+			}
 
-			if (request.returnByValue)
+			if (request.returnByValue && fn_res.subtype == undefined)
 				return {type: "object", value: fn_res};
-
-			const fn_res_id = this._cache_call_function_res (fn_res);
 			if (Object.getPrototypeOf (fn_res) == Array.prototype) {
+
+				const fn_res_id = this._cache_call_function_res (fn_res);
+
 				return {
 					type: "object",
 					subtype: "array",
@@ -1331,9 +757,15 @@ var MonoSupportLib = {
 					description: `Array(${fn_res.length})`,
 					objectId: fn_res_id
 				};
-			} else {
-				return { type: "object", className: "Object", description: "Object", objectId: fn_res_id };
 			}
+			if (fn_res.value !== undefined || fn_res.subtype !== undefined) {
+				return fn_res;
+			}
+
+			if (fn_res == proxy)
+				return { type: "object", className: "Object", description: "Object", objectId: objId };
+			const fn_res_id = this._cache_call_function_res (fn_res);
+			return { type: "object", className: "Object", description: "Object", objectId: fn_res_id };
 		},
 
 		_clear_per_step_state: function () {
@@ -1345,31 +777,6 @@ var MonoSupportLib = {
 			this._clear_per_step_state ();
 		},
 
-		mono_wasm_start_single_stepping: function (kind) {
-			console.debug (">> mono_wasm_start_single_stepping " + kind);
-			if (!this.mono_wasm_setup_single_step)
-				this.mono_wasm_setup_single_step = Module.cwrap ("mono_wasm_setup_single_step", 'number', [ 'number']);
-
-			this._clear_per_step_state ();
-
-			return this.mono_wasm_setup_single_step (kind);
-		},
-
-		mono_wasm_set_pause_on_exceptions: function (state) {
-			if (!this.mono_wasm_pause_on_exceptions)
-				this.mono_wasm_pause_on_exceptions = Module.cwrap ("mono_wasm_pause_on_exceptions", 'number', [ 'number']);
-			var state_enum = 0;
-			switch (state) {
-				case 'uncaught':
-					state_enum = 1; //EXCEPTION_MODE_UNCAUGHT
-					break;
-				case 'all':
-					state_enum = 2; //EXCEPTION_MODE_ALL
-					break;
-			}
-			return this.mono_wasm_pause_on_exceptions (state_enum);
-		},
-
 		mono_wasm_detach_debugger: function () {
 			if (!this.mono_wasm_set_is_debugger_attached)
 				this.mono_wasm_set_is_debugger_attached = Module.cwrap ('mono_wasm_set_is_debugger_attached', 'void', ['bool']);
@@ -1421,14 +828,9 @@ var MonoSupportLib = {
 			this._call_function_res_cache = {};
 
 			this._c_fn_table = {};
-			this._register_c_var_fn ('mono_wasm_get_object_properties',   	'bool', [ 'number', 'number' ]);
-			this._register_c_var_fn ('mono_wasm_get_array_values',        	'bool', [ 'number', 'number', 'number', 'number' ]);
-			this._register_c_var_fn ('mono_wasm_invoke_getter_on_object', 	'bool', [ 'number', 'string' ]);
-			this._register_c_var_fn ('mono_wasm_invoke_getter_on_value',  	'bool', [ 'number', 'number', 'string' ]);
-			this._register_c_var_fn ('mono_wasm_get_local_vars',          	'bool', [ 'number', 'number', 'number']);
-			this._register_c_var_fn ('mono_wasm_get_deref_ptr_value',     	'bool', [ 'number', 'number']);
-			this._register_c_fn     ('mono_wasm_set_value_on_object',     	'bool', [ 'number', 'string', 'string' ]);
-			this._register_c_fn     ('mono_wasm_set_variable_on_frame', 'bool', [ 'number', 'number', 'string', 'string']);
+			this._register_c_fn     ('mono_wasm_send_dbg_command',							'bool', [ 'number', 'number', 'number', 'number', 'number' ]);
+			this._register_c_fn     ('mono_wasm_send_dbg_command_with_parms', 				'bool', [ 'number', 'number', 'number', 'number', 'number', 'number', 'string' ]);
+
 			// DO NOT REMOVE - magic debugger init function
 			if (globalThis.dotnetDebugger)
 				debugger;
@@ -1436,20 +838,6 @@ var MonoSupportLib = {
 				console.debug ("mono_wasm_runtime_ready", "fe00e07a-5519-4dfe-b35a-f867dbaf2e28");
 		},
 
-		mono_wasm_set_breakpoint: function (assembly, method_token, il_offset) {
-			if (!this.mono_wasm_set_bp)
-				this.mono_wasm_set_bp = Module.cwrap ('mono_wasm_set_breakpoint', 'number', ['string', 'number', 'number']);
-
-			return this.mono_wasm_set_bp (assembly, method_token, il_offset)
-		},
-
-		mono_wasm_remove_breakpoint: function (breakpoint_id) {
-			if (!this.mono_wasm_del_bp)
-				this.mono_wasm_del_bp = Module.cwrap ('mono_wasm_remove_breakpoint', 'number', ['number']);
-
-			return this.mono_wasm_del_bp (breakpoint_id);
-		},
-
 		// Set environment variable NAME to VALUE
 		// Should be called before mono_load_runtime_and_bcl () in most cases
 		mono_wasm_setenv: function (name, value) {
@@ -1960,78 +1348,6 @@ var MonoSupportLib = {
 			return MONO.loaded_assets;
 		},
 
-		mono_wasm_clear_all_breakpoints: function() {
-			if (!this.mono_clear_bps)
-				this.mono_clear_bps = Module.cwrap ('mono_wasm_clear_all_breakpoints', null);
-
-			this.mono_clear_bps ();
-		},
-
-		mono_wasm_add_null_var: function(className)
-		{
-			let fixed_class_name = MONO._mono_csharp_fixup_class_name(Module.UTF8ToString (className));
-			if (!fixed_class_name) {
-				// Eg, when a @className is passed from js itself, like
-				// mono_wasm_add_null_var ("string")
-				fixed_class_name = className;
-			}
-			MONO.var_info.push ({value: {
-				type: "object",
-				className: fixed_class_name,
-				description: fixed_class_name,
-				subtype: "null"
-			}});
-		},
-
-		_mono_wasm_add_string_var: function(var_value) {
-			if (var_value === 0) {
-				MONO.mono_wasm_add_null_var ("string");
-				return;
-			}
-
-			MONO.var_info.push({
-				value: {
-					type: "string",
-					value: var_value,
-					description: var_value
-				}
-			});
-		},
-
-		_mono_wasm_add_getter_var: function(className) {
-			const fixed_class_name = MONO._mono_csharp_fixup_class_name (className);
-			var name;
-			if (MONO.var_info.length > 0)
-				name = MONO.var_info [MONO.var_info.length - 1].name;
-			name = (name === undefined) ? "" : name;
-
-			MONO.var_info.push({
-				get: {
-					className: "Function",
-					description: `get ${name} () {}`,
-					type: "function",
-				}
-			});
-		},
-
-		_mono_wasm_add_array_var: function(className, objectId, length) {
-			const fixed_class_name = MONO._mono_csharp_fixup_class_name(className);
-			if (objectId == 0) {
-				MONO.mono_wasm_add_null_var (fixed_class_name);
-				return;
-			}
-
-			MONO.var_info.push({
-				value: {
-					type: "object",
-					subtype: "array",
-					className: fixed_class_name,
-					description: `${fixed_class_name}(${length})`,
-					objectId: this._new_or_add_id_props ({ scheme: 'array', idArgs: { arrayId: objectId } })
-				}
-			});
-		},
-
 		// FIXME: improve
 		_base64_to_uint8: function (base64String) {
 			const byteCharacters = atob (base64String);
@@ -2043,215 +1359,6 @@ var MonoSupportLib = {
 			return new Uint8Array (byteNumbers);
 		},
 
-		_begin_value_type_var: function(className, args) {
-			if (args === undefined || (typeof args !== 'object')) {
-				console.debug (`_begin_value_type_var: Expected an args object`);
-				return;
-			}
-
-			const fixed_class_name = MONO._mono_csharp_fixup_class_name(className);
-			const toString = args.toString;
-			const base64String = btoa (String.fromCharCode (...new Uint8Array (Module.HEAPU8.buffer, args.value_addr, args.value_size)));
-			const vt_obj = {
-				value: {
-					type            : "object",
-					className       : fixed_class_name,
-					description     : (toString === 0 ? fixed_class_name: Module.UTF8ToString (toString)),
-					expanded        : true,
-					isValueType     : true,
-					__extra_vt_props: { klass: args.klass, value64: base64String },
-					members         : []
-				}
-			};
-			if (MONO._vt_stack.length == 0)
-				MONO._old_var_info = MONO.var_info;
-
-			MONO.var_info = vt_obj.value.members;
-			MONO._vt_stack.push (vt_obj);
-		},
-
-		_end_value_type_var: function() {
-			let top_vt_obj_popped = MONO._vt_stack.pop ();
-			top_vt_obj_popped.value.members = MONO._filter_automatic_properties (
-								MONO._fixup_name_value_objects (top_vt_obj_popped.value.members));
-
-			if (MONO._vt_stack.length == 0) {
-				MONO.var_info = MONO._old_var_info;
-				MONO.var_info.push(top_vt_obj_popped);
-			} else {
-				var top_obj = MONO._vt_stack [MONO._vt_stack.length - 1];
-				top_obj.value.members.push (top_vt_obj_popped);
-				MONO.var_info = top_obj.value.members;
-			}
-		},
-
-		_add_valuetype_unexpanded_var: function(className, args) {
-			if (args === undefined || (typeof args !== 'object')) {
-				console.debug (`_add_valuetype_unexpanded_var: Expected an args object`);
-				return;
-			}
-
-			const fixed_class_name = MONO._mono_csharp_fixup_class_name (className);
-			const toString = args.toString;
-
-			MONO.var_info.push ({
-				value: {
-					type: "object",
-					className: fixed_class_name,
-					description: (toString === 0 ? fixed_class_name : Module.UTF8ToString (toString)),
-					isValueType: true
-				}
-			});
-		},
-
-		mono_wasm_add_properties_var: function (name, args) {
-			if (typeof args !== 'object')
-				args = { field_offset: args };
-
-			if (args.owner_class !== undefined && args.owner_class !== 0)
-				args.owner_class = Module.UTF8ToString(args.owner_class);
-
-			let name_obj = {
-				name: Module.UTF8ToString (name),
-				fieldOffset: args.field_offset,
-				__args: args
-			};
-			if (args.is_own)
-				name_obj.isOwn = true;
-
-			MONO.var_info.push(name_obj);
-		},
-
-		mono_wasm_add_typed_value: function (type, str_value, value) {
-			let type_str = type;
-			if (typeof type != 'string')
-				type_str = Module.UTF8ToString (type);
-
-			if (str_value !== 0)
-				str_value = Module.UTF8ToString (str_value);
-
-			switch (type_str) {
-			case "bool": {
-				const v = value != 0;
-				MONO.var_info.push ({
-					value: {
-						type: "boolean",
-						value: v,
-						description: v.toString ()
-					},
-					writable:true
-				});
-				break;
-			}
-
-			case "char": {
-				const v = `${value} '${String.fromCharCode (value)}'`;
-				MONO.var_info.push ({
-					value: {
-						type: "symbol",
-						value: v,
-						description: v
-					},
-					writable:true
-				});
-				break;
-			}
-
-			case "number":
-				MONO.var_info.push ({
-					value: {
-						type: "number",
-						value: value,
-						description: '' + value
-					},
-					writable:true
-				});
-				break;
-
-			case "string":
-				MONO._mono_wasm_add_string_var (str_value);
-				break;
-
-			case "getter":
-				MONO._mono_wasm_add_getter_var (str_value);
-				break;
-
-			case "array":
-				MONO._mono_wasm_add_array_var (str_value, value.objectId, value.length);
-				break;
-
-			case "begin_vt":
-				MONO._begin_value_type_var (str_value, value);
-				break;
-
-			case "end_vt":
-				MONO._end_value_type_var ();
-				break;
-
-			case "unexpanded_vt":
-				MONO._add_valuetype_unexpanded_var (str_value, value);
-				break;
-
-			case "pointer": {
-				const fixed_value_str = MONO._mono_csharp_fixup_class_name (str_value);
-				if (value.klass_addr == 0 || value.ptr_addr == 0 || fixed_value_str.startsWith ('(void*')) {
-					// null or void*, which we can't deref
-					MONO.var_info.push({
-						value: {
-							type: "symbol",
-							value: fixed_value_str,
-							description: fixed_value_str
-						}
-					});
-				} else {
-					MONO.var_info.push({
-						value: {
-							type: "object",
-							className: fixed_value_str,
-							description: fixed_value_str,
-							objectId: this._new_or_add_id_props ({ scheme: 'pointer', props: value })
-						}
-					});
-				}
-				}
-				break;
-
-			case "symbol": {
-				if (typeof value === 'object' && value.isClassName)
-					str_value = MONO._mono_csharp_fixup_class_name (str_value);
-
-				MONO.var_info.push ({
-					value: {
-						type: "symbol",
-						value: str_value,
-						description: str_value
-					}
-				});
-				}
-				break;
-
-			default: {
-				const msg = `'${str_value}' ${value}`;
-
-				MONO.var_info.push ({
-					value: {
-						type: "symbol",
-						value: msg,
-						description: msg
-					}
-				});
-				break;
-				}
-			}
-		},
-
-		_mono_csharp_fixup_class_name: function(className)
-		{
-			// Fix up generic names like Foo`2<int, string> to Foo<int, string>
-			// and nested class names like Foo/Bar to Foo.Bar
-			return className.replace(/\//g, '.').replace(/`\d+/g, '');
-		},
-
 		mono_wasm_load_data_archive: function (data, prefix) {
 			if (data.length < 8)
 				return false;
@@ -2323,133 +1430,35 @@ var MonoSupportLib = {
 
 			console.debug('mono_wasm_debug_event_raised:aef14bca-5519-4dfe-b35a-f867abc123ae', JSON.stringify(event), JSON.stringify(args));
 		},
-	},
 
-	mono_wasm_add_typed_value: function (type, str_value, value) {
-		MONO.mono_wasm_add_typed_value (type, str_value, value);
-	},
-
-	mono_wasm_add_properties_var: function(name, args) {
-		MONO.mono_wasm_add_properties_var (name, args);
-	},
-
-	mono_wasm_set_is_async_method: function(objectId) {
-		MONO._async_method_objectId = objectId;
-	},
-
-	mono_wasm_add_enum_var: function(className, members, value) {
-		// FIXME: flags
-		//
-
-		// group0: Monday:0
-		// group1: Monday
-		// group2: 0
-		const re = new RegExp (`[,]?([^,:]+):(${value}(?=,)|${value}$)`, 'g')
-		const members_str = Module.UTF8ToString (members);
-
-		const match = re.exec(members_str);
-		const member_name = match == null ? ('' + value) : match [1];
-
-		const fixed_class_name = MONO._mono_csharp_fixup_class_name(Module.UTF8ToString (className));
-		MONO.var_info.push({
-			value: {
-				type: "object",
-				className: fixed_class_name,
-				description: member_name,
-				isEnum: true
-			}
-		});
-	},
-
-	mono_wasm_add_array_item: function(position) {
-		MONO.var_info.push({
-			name: `${position}`
-		});
-	},
-
-	mono_wasm_add_obj_var: function(className, toString, objectId) {
-		if (objectId == 0) {
-			MONO.mono_wasm_add_null_var (className);
-			return;
-		}
-
-		const fixed_class_name = MONO._mono_csharp_fixup_class_name(Module.UTF8ToString (className));
-		MONO.var_info.push({
-			value: {
-				type: "object",
-				className: fixed_class_name,
-				description: (toString === 0 ? fixed_class_name : Module.UTF8ToString (toString)),
-				objectId: "dotnet:object:"+ objectId,
-			}
-		});
-	},
-
-	/*
-	 * @className, and @targetName are in the following format:
-	 *
-	 *  <ret_type>:[<comma separated list of arg types>]:<method name>
-	 */
-	mono_wasm_add_func_var: function (className, targetName, objectId) {
-		if (objectId == 0) {
-			MONO.mono_wasm_add_null_var (
-				MONO._mono_csharp_fixup_class_name (Module.UTF8ToString (className)));
-			return;
-		}
-
-		function args_to_sig (args_str) {
-			var parts = args_str.split (":");
-			// TODO: min length = 3?
-			parts = parts.map (a => MONO._mono_csharp_fixup_class_name (a));
-
-			// method name at the end
-			var method_name = parts.pop ();
-
-			// ret type at the beginning
-			var ret_sig = parts [0];
-			var args_sig = parts.splice (1).join (', ');
-			return `${ret_sig} ${method_name} (${args_sig})`;
-		}
-		let tgt_sig;
-		if (targetName != 0)
-			tgt_sig = args_to_sig (Module.UTF8ToString (targetName));
-
-		const type_name = MONO._mono_csharp_fixup_class_name (Module.UTF8ToString (className));
-		if (tgt_sig === undefined)
-			tgt_sig = type_name;
-
-		if (objectId == -1 || targetName === 0) {
-			// Target property
-			MONO.var_info.push ({
-				value: {
-					type: "symbol",
-					value: tgt_sig,
-					description: tgt_sig,
-				}
-			});
-		} else {
-			MONO.var_info.push ({
-				value: {
-					type: "object",
-					className: type_name,
-					description: tgt_sig,
-					objectId: "dotnet:object:" + objectId,
+		/**
+		 * Loads the mono config file (typically called mono-config.json) asynchroniously
+		 * Note: the run dependencies are so emsdk actually awaits it in order.
+		 *
+		 * @param {string} configFilePath - relative path to the config file
+		 * @throws Will throw an error if the config file loading fails
+		 */
+		mono_wasm_load_config: async function (configFilePath) {
+			Module.addRunDependency(configFilePath);	
+			try {
+				let config = null;
+				// NOTE: when we add nodejs make sure to include the nodejs fetch package
+				if (ENVIRONMENT_IS_WEB) {
+					const configRaw = await fetch(configFilePath);
+					config = await configRaw.json();
+				}else if (ENVIRONMENT_IS_NODE) {
+					config = require(configFilePath);
+				} else { // shell or worker
+					config = JSON.parse(read(configFilePath)); // read is a v8 debugger command
 				}
-			});
+				return config;
+			} catch(e) {
+				return {message: "failed to load config file", error: e};
+			} finally {
+				Module.removeRunDependency(configFilePath);
+			}
 		}
 	},
-
-	mono_wasm_add_frame: function(il, method, frame_id, assembly_name, method_full_name) {
-		var parts = Module.UTF8ToString (method_full_name).split (":", 2);
-		MONO.active_frames.push( {
-			il_pos: il,
-			method_token: method,
-			assembly_name: Module.UTF8ToString (assembly_name),
-			// Extract just the method name from `{class_name}:{method_name}`
-			method_name: parts [parts.length - 1],
-			frame_id
-		});
-	},
-
 	schedule_background_exec: function () {
 		++MONO.pump_count;
 		if (typeof globalThis.setTimeout === 'function') {
@@ -2473,21 +1482,11 @@ var MonoSupportLib = {
 		}
 	},
 
-	mono_wasm_fire_bp: function () {
+	mono_wasm_fire_debugger_agent_message: function () {
 		// eslint-disable-next-line no-debugger
 		debugger;
 	},
 
-	mono_wasm_fire_exception: function (exception_id, message, class_name, uncaught) {
-		MONO.active_exception = {
-			exception_id: exception_id,
-			message     : Module.UTF8ToString (message),
-			class_name  : Module.UTF8ToString (class_name),
-			uncaught    : uncaught
-		};
-		debugger;
-	},
-
 	mono_wasm_asm_loaded: function (assembly_name, assembly_ptr, assembly_len, pdb_ptr, pdb_len) {
 		// Only trigger this codepath for assemblies loaded after app is ready
 		if (MONO.mono_wasm_runtime_is_ready !== true)
@@ -2510,7 +1509,7 @@ var MonoSupportLib = {
 			assembly_b64,
 			pdb_b64
 		});
-	},
+	}
 };
 
 autoAddDeps(MonoSupportLib, '$MONO')
diff --git a/src/mono/wasm/wasm.proj b/src/mono/wasm/wasm.proj
index bcdf4eae40a7ae..489d88259f5f3e 100644
--- a/src/mono/wasm/wasm.proj
+++ b/src/mono/wasm/wasm.proj
@@ -7,22 +7,13 @@
     <PackageRID>browser-wasm</PackageRID>
     <NativeBinDir>$([MSBuild]::NormalizeDirectory('$(ArtifactsBinDir)', 'native', '$(NetCoreAppCurrent)-$(TargetOS)-$(Configuration)-$(TargetArchitecture)'))</NativeBinDir>
     <ICULibDir>$([MSBuild]::NormalizeDirectory('$(PkgMicrosoft_NETCore_Runtime_ICU_Transport)', 'runtimes', 'browser-wasm', 'native', 'lib'))</ICULibDir>
-    <MicrosoftNetCoreAppRuntimePackDir>$([MSBuild]::NormalizeDirectory('$(ArtifactsBinDir)', 'microsoft.netcore.app.runtime.$(PackageRID)', '$(Configuration)'))</MicrosoftNetCoreAppRuntimePackDir>
-    <MicrosoftNetCoreAppRuntimePackRidDir>$([MSBuild]::NormalizeDirectory('$(MicrosoftNetCoreAppRuntimePackDir)', 'runtimes', '$(PackageRID)'))</MicrosoftNetCoreAppRuntimePackRidDir>
-    <MicrosoftNetCoreAppRuntimePackNativeDir>$([MSBuild]::NormalizeDirectory('$(MicrosoftNetCoreAppRuntimePackRidDir)', 'native'))</MicrosoftNetCoreAppRuntimePackNativeDir>
     <WasmEnableES6 Condition="'$(WasmEnableES6)' == ''">false</WasmEnableES6>
     <FilterSystemTimeZones Condition="'$(FilterSystemTimeZones)' == ''">false</FilterSystemTimeZones>
-    <WasmEnableMetadataUpdate Condition="'$(MonoMetadataUpdate)' == 'true'">true</WasmEnableMetadataUpdate>
     <EmccCmd>emcc</EmccCmd>
     <WasmObjDir>$(ArtifactsObjDir)wasm</WasmObjDir>
     <_EmccDefaultsRspPath>$(NativeBinDir)src\emcc-default.rsp</_EmccDefaultsRspPath>
   </PropertyGroup>
 
-  <PropertyGroup>
-    <!-- TODO: set to "false" for publishing/production builds -->
-    <MonoMetadataUpdate Condition="'$(MonoMetadataUpdate)' == ''">true</MonoMetadataUpdate>
-  </PropertyGroup>
-
   <Target Name="CheckEnv">
     <Error Condition="'$(TargetArchitecture)' != 'wasm'" Text="Expected TargetArchitecture==wasm, got '$(TargetArchitecture)'"/>
     <Error Condition="'$(TargetOS)' != 'Browser'" Text="Expected TargetOS==Browser, got '$(TargetOS)'"/>
@@ -87,8 +78,6 @@
     <ItemGroup Condition="'$(OS)' != 'Windows_NT'">
       <_EmccFlags Include="--profiling-funcs" />
       <_EmccFlags Include="@(_EmccCommonFlags)" />
-
-      <_EmccFlags Include="-DENABLE_METADATA_UPDATE=1" Condition="'$(WasmEnableMetadataUpdate)' == 'true'" />
     </ItemGroup>
 
     <ItemGroup Condition="'$(OS)' == 'Windows_NT'">
@@ -245,7 +234,7 @@
     <Copy SourceFiles="runtime/driver.c;
                        runtime/pinvoke.c;
                        runtime/corebindings.c;
-                       runtime/binding_support.js; 
+                       runtime/binding_support.js;
                        runtime/dotnet_support.js;
                        runtime/library_mono.js;
                        $(SystemNativeDir)\pal_random.js;"
diff --git a/src/native/corehost/deps_format.cpp b/src/native/corehost/deps_format.cpp
index f0beb6ed7e54ed..8ab0f22caff2cb 100644
--- a/src/native/corehost/deps_format.cpp
+++ b/src/native/corehost/deps_format.cpp
@@ -84,7 +84,7 @@ void deps_json_t::reconcile_libraries_with_targets(
                 size_t pos = lib_name.find(_X("/"));
                 entry.library_name = lib_name.substr(0, pos);
                 entry.library_version = lib_name.substr(pos + 1);
-                entry.library_type = pal::to_lower(library.value[_X("type")].GetString());
+                entry.library_type = to_lower(library.value[_X("type")].GetString());
                 entry.library_hash = hash;
                 entry.library_path = library_path;
                 entry.library_hash_path = library_hash_path;
diff --git a/src/native/corehost/fxr/command_line.cpp b/src/native/corehost/fxr/command_line.cpp
index 082f81d802c128..deb80b38b7f522 100644
--- a/src/native/corehost/fxr/command_line.cpp
+++ b/src/native/corehost/fxr/command_line.cpp
@@ -86,7 +86,7 @@ namespace
         while (arg_i < argc)
         {
             const pal::char_t* arg = argv[arg_i];
-            pal::string_t arg_lower = pal::to_lower(arg);
+            pal::string_t arg_lower = to_lower(arg);
             const auto &iter = std::find_if(known_opts.cbegin(), known_opts.cend(),
                 [&](const known_options &opt) { return arg_lower == get_host_option(opt).option; });
             if (iter == known_opts.cend())
diff --git a/src/native/corehost/fxr_resolver.cpp b/src/native/corehost/fxr_resolver.cpp
index d457047ddc8f9f..6e1356457d49ae 100644
--- a/src/native/corehost/fxr_resolver.cpp
+++ b/src/native/corehost/fxr_resolver.cpp
@@ -65,10 +65,10 @@ bool fxr_resolver::try_get_path(const pal::string_t& root_path, pal::string_t* o
         return true;
     }
 
-    // For framework-dependent apps, use DOTNET_ROOT
+    // For framework-dependent apps, use DOTNET_ROOT_<ARCH>
     pal::string_t default_install_location;
-    pal::string_t dotnet_root_env_var_name = get_dotnet_root_env_var_name();
-    if (get_file_path_from_env(dotnet_root_env_var_name.c_str(), out_dotnet_root))
+    pal::string_t dotnet_root_env_var_name;
+    if (get_dotnet_root_from_env(&dotnet_root_env_var_name, out_dotnet_root))
     {
         trace::info(_X("Using environment variable %s=[%s] as runtime location."), dotnet_root_env_var_name.c_str(), out_dotnet_root->c_str());
     }
@@ -134,7 +134,7 @@ bool fxr_resolver::try_get_path(const pal::string_t& root_path, pal::string_t* o
 #endif // !FEATURE_APPHOST && !FEATURE_LIBHOST
 }
 
-bool fxr_resolver::try_get_path_from_dotnet_root(const pal::string_t &dotnet_root, pal::string_t *out_fxr_path)
+bool fxr_resolver::try_get_path_from_dotnet_root(const pal::string_t& dotnet_root, pal::string_t* out_fxr_path)
 {
     pal::string_t fxr_dir = dotnet_root;
     append_path(&fxr_dir, _X("host"));
@@ -148,7 +148,7 @@ bool fxr_resolver::try_get_path_from_dotnet_root(const pal::string_t &dotnet_roo
     return get_latest_fxr(std::move(fxr_dir), out_fxr_path);
 }
 
-bool fxr_resolver::try_get_existing_fxr(pal::dll_t *out_fxr, pal::string_t *out_fxr_path)
+bool fxr_resolver::try_get_existing_fxr(pal::dll_t* out_fxr, pal::string_t* out_fxr_path)
 {
     if (!pal::get_loaded_library(LIBFXR_NAME, "hostfxr_main", out_fxr, out_fxr_path))
         return false;
diff --git a/src/native/corehost/hostmisc/pal.h b/src/native/corehost/hostmisc/pal.h
index 27daf76c72723e..b6622cd5dff52b 100644
--- a/src/native/corehost/hostmisc/pal.h
+++ b/src/native/corehost/hostmisc/pal.h
@@ -104,13 +104,13 @@
 namespace pal
 {
 #if defined(_WIN32)
-    #ifdef EXPORT_SHARED_API
-        #define SHARED_API extern "C" __declspec(dllexport)
-    #else
-        #define SHARED_API extern "C"
-    #endif
+#ifdef EXPORT_SHARED_API
+#define SHARED_API extern "C" __declspec(dllexport)
+#else
+#define SHARED_API extern "C"
+#endif
 
-    #define STDMETHODCALLTYPE __stdcall
+#define STDMETHODCALLTYPE __stdcall
 
     typedef wchar_t char_t;
     typedef std::wstring string_t;
@@ -151,13 +151,13 @@ namespace pal
     inline int strcasecmp(const char_t* str1, const char_t* str2) { return ::_wcsicmp(str1, str2); }
     inline int strncmp(const char_t* str1, const char_t* str2, size_t len) { return ::wcsncmp(str1, str2, len); }
     inline int strncasecmp(const char_t* str1, const char_t* str2, size_t len) { return ::_wcsnicmp(str1, str2, len); }
-    inline int pathcmp(const pal::string_t &path1, const pal::string_t &path2) { return strcasecmp(path1.c_str(), path2.c_str()); }
+    inline int pathcmp(const pal::string_t& path1, const pal::string_t& path2) { return strcasecmp(path1.c_str(), path2.c_str()); }
     inline string_t to_string(int value) { return std::to_wstring(value); }
 
     inline size_t strlen(const char_t* str) { return ::wcslen(str); }
 
 #pragma warning(suppress : 4996)  // error C4996: '_wfopen': This function or variable may be unsafe.
-    inline FILE * file_open(const string_t& path, const char_t* mode) { return ::_wfopen(path.c_str(), mode); }
+    inline FILE* file_open(const string_t& path, const char_t* mode) { return ::_wfopen(path.c_str(), mode); }
 
     inline void file_vprintf(FILE* f, const char_t* format, va_list vl) { ::vfwprintf(f, format, vl); ::fputwc(_X('\n'), f); }
     inline void err_fputs(const char_t* message) { ::fputws(message, stderr); ::fputwc(_X('\n'), stderr); }
@@ -170,32 +170,32 @@ namespace pal
     // Suppressing warning since the 'safe' version requires an input buffer that is unnecessary for
     // uses of this function.
 #pragma warning(suppress : 4996) //  error C4996: '_wcserror': This function or variable may be unsafe.
-    inline const char_t* strerror(int errnum){ return ::_wcserror(errnum); }
+    inline const char_t* strerror(int errnum) { return ::_wcserror(errnum); }
 
     bool pal_utf8string(const string_t& str, std::vector<char>* out);
     bool pal_clrstring(const string_t& str, std::vector<char>* out);
     bool clr_palstring(const char* cstr, string_t* out);
 
     inline bool mkdir(const char_t* dir, int mode) { return CreateDirectoryW(dir, NULL) != 0; }
-    inline bool rmdir (const char_t* path) { return RemoveDirectoryW(path) != 0; }
+    inline bool rmdir(const char_t* path) { return RemoveDirectoryW(path) != 0; }
     inline int rename(const char_t* old_name, const char_t* new_name) { return ::_wrename(old_name, new_name); }
     inline int remove(const char_t* path) { return ::_wremove(path); }
     inline bool munmap(void* addr, size_t length) { return UnmapViewOfFile(addr) != 0; }
     inline int get_pid() { return GetCurrentProcessId(); }
     inline void sleep(uint32_t milliseconds) { Sleep(milliseconds); }
 #else
-    #ifdef EXPORT_SHARED_API
-        #define SHARED_API extern "C" __attribute__((__visibility__("default")))
-    #else
-        #define SHARED_API extern "C"
-    #endif
-
-    #define __cdecl    /* nothing */
-    #define __stdcall  /* nothing */
-    #if !defined(TARGET_FREEBSD)
-        #define __fastcall /* nothing */
-    #endif
-    #define STDMETHODCALLTYPE __stdcall
+#ifdef EXPORT_SHARED_API
+#define SHARED_API extern "C" __attribute__((__visibility__("default")))
+#else
+#define SHARED_API extern "C"
+#endif
+
+#define __cdecl    /* nothing */
+#define __stdcall  /* nothing */
+#if !defined(TARGET_FREEBSD)
+#define __fastcall /* nothing */
+#endif
+#define STDMETHODCALLTYPE __stdcall
 
     typedef char char_t;
     typedef std::string string_t;
@@ -219,7 +219,7 @@ namespace pal
     inline string_t to_string(int value) { return std::to_string(value); }
 
     inline size_t strlen(const char_t* str) { return ::strlen(str); }
-    inline FILE * file_open(const string_t& path, const char_t* mode) { return fopen(path.c_str(), mode); }
+    inline FILE* file_open(const string_t& path, const char_t* mode) { return fopen(path.c_str(), mode); }
     inline void file_vprintf(FILE* f, const char_t* format, va_list vl) { ::vfprintf(f, format, vl); ::fputc('\n', f); }
     inline void err_fputs(const char_t* message) { ::fputs(message, stderr); ::fputc(_X('\n'), stderr); }
     inline void out_vprintf(const char_t* format, va_list vl) { ::vfprintf(stdout, format, vl); ::fputc('\n', stdout); }
@@ -237,7 +237,6 @@ namespace pal
     inline bool munmap(void* addr, size_t length) { return ::munmap(addr, length) == 0; }
     inline int get_pid() { return getpid(); }
     inline void sleep(uint32_t milliseconds) { usleep(milliseconds * 1000); }
-
 #endif
 
     inline int snwprintf(char_t* buffer, size_t count, const char_t* format, ...)
@@ -252,10 +251,8 @@ namespace pal
     string_t get_timestamp();
 
     bool getcwd(string_t* recv);
-    string_t to_lower(const char_t* in);
-
 
-    inline void file_flush(FILE *f) { std::fflush(f); }
+    inline void file_flush(FILE* f) { std::fflush(f); }
     inline void err_flush() { std::fflush(stderr); }
     inline void out_flush() { std::fflush(stdout); }
 
@@ -283,7 +280,7 @@ namespace pal
     bool get_own_module_path(string_t* recv);
     bool get_method_module_path(string_t* recv, void* method);
     bool get_module_path(dll_t mod, string_t* recv);
-    bool get_current_module(dll_t *mod);
+    bool get_current_module(dll_t* mod);
     bool getenv(const char_t* name, string_t* recv);
     bool get_default_servicing_directory(string_t* recv);
 
@@ -307,7 +304,7 @@ namespace pal
 
     int xtoi(const char_t* input);
 
-    bool get_loaded_library(const char_t *library_name, const char *symbol_name, /*out*/ dll_t *dll, /*out*/ string_t *path);
+    bool get_loaded_library(const char_t* library_name, const char* symbol_name, /*out*/ dll_t* dll, /*out*/ string_t* path);
     bool load_library(const string_t* path, dll_t* dll);
     proc_t get_symbol(dll_t library, const char* name);
     void unload_library(dll_t library);
diff --git a/src/native/corehost/hostmisc/pal.unix.cpp b/src/native/corehost/hostmisc/pal.unix.cpp
index 2db2dd8488f562..411298a08f4cef 100644
--- a/src/native/corehost/hostmisc/pal.unix.cpp
+++ b/src/native/corehost/hostmisc/pal.unix.cpp
@@ -50,13 +50,6 @@
 #error "Don't know how to obtain max path on this platform"
 #endif
 
-pal::string_t pal::to_lower(const pal::char_t* in)
-{
-    pal::string_t ret = in;
-    std::transform(ret.begin(), ret.end(), ret.begin(), ::tolower);
-    return ret;
-}
-
 pal::string_t pal::get_timestamp()
 {
     std::time_t t = std::time(nullptr);
@@ -75,7 +68,7 @@ bool pal::touch_file(const pal::string_t& path)
         trace::warning(_X("open(%s) failed in %s"), path.c_str(), _STRINGIFY(__FUNCTION__));
         return false;
     }
-    (void) close(fd);
+    (void)close(fd);
     return true;
 }
 
@@ -146,12 +139,12 @@ bool pal::getcwd(pal::string_t* recv)
 
 namespace
 {
-    bool get_loaded_library_from_proc_maps(const pal::char_t *library_name, pal::dll_t *dll, pal::string_t *path)
+    bool get_loaded_library_from_proc_maps(const pal::char_t* library_name, pal::dll_t* dll, pal::string_t* path)
     {
-        char *line = nullptr;
+        char* line = nullptr;
         size_t lineLen = 0;
         ssize_t read;
-        FILE *file = pal::file_open(_X("/proc/self/maps"), _X("r"));
+        FILE* file = pal::file_open(_X("/proc/self/maps"), _X("r"));
         if (file == nullptr)
             return false;
 
@@ -192,10 +185,10 @@ namespace
 }
 
 bool pal::get_loaded_library(
-    const char_t *library_name,
-    const char *symbol_name,
-    /*out*/ dll_t *dll,
-    /*out*/ pal::string_t *path)
+    const char_t* library_name,
+    const char* symbol_name,
+    /*out*/ dll_t* dll,
+    /*out*/ pal::string_t* path)
 {
     pal::string_t library_name_local;
 #if defined(TARGET_OSX)
@@ -340,7 +333,7 @@ bool pal::get_default_servicing_directory(string_t* recv)
 bool is_read_write_able_directory(pal::string_t& dir)
 {
     return pal::realpath(&dir) &&
-           (access(dir.c_str(), R_OK | W_OK | X_OK) == 0);
+        (access(dir.c_str(), R_OK | W_OK | X_OK) == 0);
 }
 
 bool get_extraction_base_parent_directory(pal::string_t& directory)
@@ -388,18 +381,41 @@ bool pal::get_global_dotnet_dirs(std::vector<pal::string_t>* recv)
 
 bool pal::get_dotnet_self_registered_config_location(pal::string_t* recv)
 {
-    *recv = _X("/etc/dotnet/install_location");
+    recv->assign(_X("/etc/dotnet/install_location"));
 
     //  ***Used only for testing***
     pal::string_t environment_install_location_override;
     if (test_only_getenv(_X("_DOTNET_TEST_INSTALL_LOCATION_FILE_PATH"), &environment_install_location_override))
     {
-        *recv = environment_install_location_override;
+        recv->assign(environment_install_location_override);
     }
 
     return true;
 }
 
+namespace
+{
+    bool get_line_from_file(FILE* pFile, pal::string_t& line)
+    {
+        line = pal::string_t();
+        char buffer[256];
+        while (fgets(buffer, sizeof(buffer), pFile))
+        {
+            line += (pal::char_t*)buffer;
+            size_t len = line.length();
+
+            // fgets includes the newline character in the string - so remove it.
+            if (len > 0 && line[len - 1] == '\n')
+            {
+                line.pop_back();
+                break;
+            }
+        }
+
+        return !line.empty();
+    }
+}
+
 bool pal::get_dotnet_self_registered_dir(pal::string_t* recv)
 {
     recv->clear();
@@ -424,35 +440,60 @@ bool pal::get_dotnet_self_registered_dir(pal::string_t* recv)
     FILE* install_location_file = pal::file_open(install_location_file_path, "r");
     if (install_location_file == nullptr)
     {
-        trace::verbose(_X("The install_location file failed to open."));
+        trace::error(_X("The install_location file ['%s'] failed to open: %s."), install_location_file_path.c_str(), pal::strerror(errno));
         return false;
     }
 
-    bool result = false;
+    pal::string_t install_location;
+    int current_line = 0;
+    bool is_first_line = true, install_location_found = false;
 
-    char buf[PATH_MAX];
-    char* install_location = fgets(buf, sizeof(buf), install_location_file);
-    if (install_location != nullptr)
+    while (get_line_from_file(install_location_file, install_location))
     {
-        size_t len = pal::strlen(install_location);
+        current_line++;
+        size_t arch_sep = install_location.find(_X('='));
+        if (arch_sep == pal::string_t::npos)
+        {
+            if (is_first_line)
+            {
+                recv->assign(install_location);
+                install_location_found = true;
+                trace::verbose(_X("Found install location path '%s'."), install_location.c_str());
+            }
+            else
+            {
+                trace::warning(_X("Found unprefixed install location path '%s' on line %d."), install_location.c_str(), current_line);
+                trace::warning(_X("Only the first line in '%s' may not have an architecture prefix."), install_location_file_path.c_str());
+            }
+
+            is_first_line = false;
+            continue;
+        }
+
+        pal::string_t arch_prefix = install_location.substr(0, arch_sep);
+        pal::string_t path_to_location = install_location.substr(arch_sep + 1);
 
-        // fgets includes the newline character in the string - so remove it.
-        if (len > 0 && len < PATH_MAX && install_location[len - 1] == '\n')
+        trace::verbose(_X("Found architecture-specific install location path: '%s' ('%s')."), path_to_location.c_str(), arch_prefix.c_str());
+        if (pal::strcasecmp(arch_prefix.c_str(), get_arch()) == 0)
         {
-            install_location[len - 1] = '\0';
+            recv->assign(path_to_location);
+            install_location_found = true;
+            trace::verbose(_X("Found architecture-specific install location path matching the current host architecture ('%s'): '%s'."), arch_prefix.c_str(), path_to_location.c_str());
+            break;
         }
 
-        trace::verbose(_X("Using install location '%s'."), install_location);
-        *recv = install_location;
-        result = true;
+        is_first_line = false;
     }
-    else
+
+    fclose(install_location_file);
+    if (!install_location_found)
     {
-        trace::verbose(_X("The install_location file first line could not be read."));
+        trace::warning(_X("Did not find any install location in '%s'."), install_location_file_path.c_str());
+        return false;
     }
 
-    fclose(install_location_file);
-    return result;
+    trace::verbose(_X("Using install location '%s'."), recv->c_str());
+    return true;
 }
 
 bool pal::get_default_installation_dir(pal::string_t* recv)
@@ -467,17 +508,17 @@ bool pal::get_default_installation_dir(pal::string_t* recv)
     //  ***************************
 
 #if defined(TARGET_OSX)
-     recv->assign(_X("/usr/local/share/dotnet"));
+    recv->assign(_X("/usr/local/share/dotnet"));
 #else
-     recv->assign(_X("/usr/share/dotnet"));
+    recv->assign(_X("/usr/share/dotnet"));
 #endif
-     return true;
+    return true;
 }
 
 pal::string_t trim_quotes(pal::string_t stringToCleanup)
 {
-    pal::char_t quote_array[2] = {'\"', '\''};
-    for (size_t index = 0; index < sizeof(quote_array)/sizeof(quote_array[0]); index++)
+    pal::char_t quote_array[2] = { '\"', '\'' };
+    for (size_t index = 0; index < sizeof(quote_array) / sizeof(quote_array[0]); index++)
     {
         size_t pos = stringToCleanup.find(quote_array[index]);
         while (pos != std::string::npos)
@@ -553,11 +594,11 @@ pal::string_t pal::get_current_os_rid_platform()
 
     if (ret == 0)
     {
-        char *pos = strchr(str, '.');
+        char* pos = strchr(str, '.');
         if (pos)
         {
             ridOS.append(_X("freebsd."))
-                 .append(str, pos - str);
+                .append(str, pos - str);
         }
     }
 
@@ -589,7 +630,7 @@ pal::string_t pal::get_current_os_rid_platform()
     if (strncmp(utsname_obj.version, "omnios", strlen("omnios")) == 0)
     {
         ridOS.append(_X("omnios."))
-             .append(utsname_obj.version, strlen("omnios-r"), 2); // e.g. omnios.15
+            .append(utsname_obj.version, strlen("omnios-r"), 2); // e.g. omnios.15
     }
     else if (strncmp(utsname_obj.version, "illumos-", strlen("illumos-")) == 0)
     {
@@ -598,7 +639,7 @@ pal::string_t pal::get_current_os_rid_platform()
     else if (strncmp(utsname_obj.version, "joyent_", strlen("joyent_")) == 0)
     {
         ridOS.append(_X("smartos."))
-             .append(utsname_obj.version, strlen("joyent_"), 4); // e.g. smartos.2020
+            .append(utsname_obj.version, strlen("joyent_"), 4); // e.g. smartos.2020
     }
 
     return ridOS;
@@ -621,11 +662,11 @@ pal::string_t pal::get_current_os_rid_platform()
         return ridOS;
     }
 
-    char *pos = strchr(utsname_obj.version, '.');
+    char* pos = strchr(utsname_obj.version, '.');
     if (pos)
     {
         ridOS.append(_X("solaris."))
-             .append(utsname_obj.version, pos - utsname_obj.version); // e.g. solaris.11
+            .append(utsname_obj.version, pos - utsname_obj.version); // e.g. solaris.11
     }
 
     return ridOS;
@@ -771,7 +812,7 @@ bool pal::get_own_executable_path(pal::string_t* recv)
 bool pal::get_own_module_path(string_t* recv)
 {
     Dl_info info;
-    if (dladdr((void *)&pal::get_own_module_path, &info) == 0)
+    if (dladdr((void*)&pal::get_own_module_path, &info) == 0)
         return false;
 
     recv->assign(info.dli_fname);
@@ -793,7 +834,7 @@ bool pal::get_module_path(dll_t module, string_t* recv)
     return false;
 }
 
-bool pal::get_current_module(dll_t *mod)
+bool pal::get_current_module(dll_t* mod)
 {
     return false;
 }
@@ -876,31 +917,31 @@ static void readdir(const pal::string_t& path, const pal::string_t& pattern, boo
                 }
                 break;
 
-            // Handle symlinks and file systems that do not support d_type
+                // Handle symlinks and file systems that do not support d_type
             case DT_LNK:
             case DT_UNKNOWN:
-                {
-                    struct stat sb;
+            {
+                struct stat sb;
 
-                    if (fstatat(dirfd(dir), entry->d_name, &sb, 0) == -1)
-                    {
-                        continue;
-                    }
+                if (fstatat(dirfd(dir), entry->d_name, &sb, 0) == -1)
+                {
+                    continue;
+                }
 
-                    if (onlydirectories)
-                    {
-                        if (!S_ISDIR(sb.st_mode))
-                        {
-                            continue;
-                        }
-                        break;
-                    }
-                    else if (!S_ISREG(sb.st_mode) && !S_ISDIR(sb.st_mode))
+                if (onlydirectories)
+                {
+                    if (!S_ISDIR(sb.st_mode))
                     {
                         continue;
                     }
+                    break;
                 }
-                break;
+                else if (!S_ISREG(sb.st_mode) && !S_ISDIR(sb.st_mode))
+                {
+                    continue;
+                }
+            }
+            break;
 
             default:
                 continue;
diff --git a/src/native/corehost/hostmisc/pal.windows.cpp b/src/native/corehost/hostmisc/pal.windows.cpp
index 8a9e35a3236f0e..c992f92da8294e 100644
--- a/src/native/corehost/hostmisc/pal.windows.cpp
+++ b/src/native/corehost/hostmisc/pal.windows.cpp
@@ -26,7 +26,7 @@ bool GetModuleFileNameWrapper(HMODULE hModule, pal::string_t* recv)
         return false;
 
     path.resize(dwModuleFileName);
-    *recv = path;
+    recv->assign(path);
     return true;
 }
 
@@ -40,13 +40,6 @@ bool GetModuleHandleFromAddress(void *addr, HMODULE *hModule)
     return (res != FALSE);
 }
 
-pal::string_t pal::to_lower(const pal::char_t* in)
-{
-    pal::string_t ret = in;
-    std::transform(ret.begin(), ret.end(), ret.begin(), ::towlower);
-    return ret;
-}
-
 pal::string_t pal::get_timestamp()
 {
     std::time_t t = std::time(nullptr);
@@ -339,7 +332,7 @@ bool pal::get_dotnet_self_registered_config_location(pal::string_t* recv)
     const pal::char_t* value;
     get_dotnet_install_location_registry_path(&key_hive, &sub_key, &value);
 
-    *recv = (key_hive == HKEY_CURRENT_USER ? _X("HKCU\\") : _X("HKLM\\")) + sub_key + _X("\\") + value;
+    recv->assign((key_hive == HKEY_CURRENT_USER ? _X("HKCU\\") : _X("HKLM\\")) + sub_key + _X("\\") + value);
     return true;
 #endif
 }
diff --git a/src/native/corehost/hostmisc/utils.cpp b/src/native/corehost/hostmisc/utils.cpp
index 055b4f6a31dd81..abf1aeee89e0a1 100644
--- a/src/native/corehost/hostmisc/utils.cpp
+++ b/src/native/corehost/hostmisc/utils.cpp
@@ -161,7 +161,7 @@ void remove_trailing_dir_seperator(pal::string_t* dir)
 
 void replace_char(pal::string_t* path, pal::char_t match, pal::char_t repl)
 {
-	size_t pos = 0;
+    size_t pos = 0;
     while ((pos = path->find(match, pos)) != pal::string_t::npos)
     {
         (*path)[pos] = repl;
@@ -170,7 +170,7 @@ void replace_char(pal::string_t* path, pal::char_t match, pal::char_t repl)
 
 pal::string_t get_replaced_char(const pal::string_t& path, pal::char_t match, pal::char_t repl)
 {
-	size_t pos = path.find(match);
+    size_t pos = path.find(match);
     if (pos == pal::string_t::npos)
     {
         return path;
@@ -241,7 +241,7 @@ bool get_env_shared_store_dirs(std::vector<pal::string_t>* dirs, const pal::stri
     return true;
 }
 
-bool get_global_shared_store_dirs(std::vector<pal::string_t>*  dirs, const pal::string_t& arch, const pal::string_t& tfm)
+bool get_global_shared_store_dirs(std::vector<pal::string_t>* dirs, const pal::string_t& arch, const pal::string_t& tfm)
 {
     std::vector<pal::string_t> global_dirs;
     if (!pal::get_global_dotnet_dirs(&global_dirs))
@@ -348,14 +348,26 @@ bool try_stou(const pal::string_t& str, unsigned* num)
     return true;
 }
 
-pal::string_t get_dotnet_root_env_var_name()
+bool get_dotnet_root_from_env(pal::string_t* dotnet_root_env_var_name, pal::string_t* recv)
 {
+    *dotnet_root_env_var_name = _X("DOTNET_ROOT_");
+    dotnet_root_env_var_name->append(to_upper(get_arch()));
+    if (get_file_path_from_env(dotnet_root_env_var_name->c_str(), recv))
+        return true;
+
+#if defined(WIN32)
     if (pal::is_running_in_wow64())
     {
-        return pal::string_t(_X("DOTNET_ROOT(x86)"));
+        *dotnet_root_env_var_name = _X("DOTNET_ROOT(x86)");
+        if (get_file_path_from_env(dotnet_root_env_var_name->c_str(), recv))
+            return true;
     }
+#endif
 
-    return pal::string_t(_X("DOTNET_ROOT"));
+    // If no architecture-specific environment variable was set
+    // fallback to the default DOTNET_ROOT.
+    *dotnet_root_env_var_name = _X("DOTNET_ROOT");
+    return get_file_path_from_env(dotnet_root_env_var_name->c_str(), recv);
 }
 
 /**
@@ -402,7 +414,7 @@ void get_runtime_config_paths(const pal::string_t& path, const pal::string_t& na
     trace::verbose(_X("Runtime config is cfg=%s dev=%s"), cfg->c_str(), dev_cfg->c_str());
 }
 
-pal::string_t get_dotnet_root_from_fxr_path(const pal::string_t &fxr_path)
+pal::string_t get_dotnet_root_from_fxr_path(const pal::string_t& fxr_path)
 {
     // If coreclr exists next to hostfxr, assume everything is local (e.g. self-contained)
     pal::string_t fxr_dir = get_directory(fxr_path);
@@ -414,7 +426,7 @@ pal::string_t get_dotnet_root_from_fxr_path(const pal::string_t &fxr_path)
     return get_directory(get_directory(fxr_root));
 }
 
-pal::string_t get_download_url(const pal::char_t *framework_name, const pal::char_t *framework_version)
+pal::string_t get_download_url(const pal::char_t* framework_name, const pal::char_t* framework_version)
 {
     pal::string_t url = DOTNET_CORE_APPLAUNCH_URL _X("?");
     if (framework_name != nullptr && pal::strlen(framework_name) > 0)
@@ -441,6 +453,18 @@ pal::string_t get_download_url(const pal::char_t *framework_name, const pal::cha
     return url;
 }
 
+pal::string_t to_lower(const pal::char_t* in) {
+    pal::string_t ret = in;
+    std::transform(ret.begin(), ret.end(), ret.begin(), ::tolower);
+    return ret;
+}
+
+pal::string_t to_upper(const pal::char_t* in) {
+    pal::string_t ret = in;
+    std::transform(ret.begin(), ret.end(), ret.begin(), ::toupper);
+    return ret;
+}
+
 #define TEST_ONLY_MARKER "d38cc827-e34f-4453-9df4-1e796e9f1d07"
 
 // Retrieves environment variable which is only used for testing.
diff --git a/src/native/corehost/hostmisc/utils.h b/src/native/corehost/hostmisc/utils.h
index d0dc381b69cca1..b4e31b599fac1a 100644
--- a/src/native/corehost/hostmisc/utils.h
+++ b/src/native/corehost/hostmisc/utils.h
@@ -43,16 +43,19 @@ void get_framework_and_sdk_locations(const pal::string_t& dotnet_dir, std::vecto
 bool get_file_path_from_env(const pal::char_t* env_key, pal::string_t* recv);
 size_t index_of_non_numeric(const pal::string_t& str, size_t i);
 bool try_stou(const pal::string_t& str, unsigned* num);
-pal::string_t get_dotnet_root_env_var_name();
+bool get_dotnet_root_from_env(pal::string_t* used_dotnet_root_env_var_name, pal::string_t* recv);
 pal::string_t get_deps_from_app_binary(const pal::string_t& app_base, const pal::string_t& app);
 pal::string_t get_runtime_config_path(const pal::string_t& path, const pal::string_t& name);
 pal::string_t get_runtime_config_dev_path(const pal::string_t& path, const pal::string_t& name);
 void get_runtime_config_paths(const pal::string_t& path, const pal::string_t& name, pal::string_t* cfg, pal::string_t* dev_cfg);
-pal::string_t get_dotnet_root_from_fxr_path(const pal::string_t &fxr_path);
+pal::string_t get_dotnet_root_from_fxr_path(const pal::string_t& fxr_path);
 
 // Get a download URL for a specific framework and version
 // If no framework is specified, a download URL for the runtime is returned
-pal::string_t get_download_url(const pal::char_t *framework_name = nullptr, const pal::char_t *framework_version = nullptr);
+pal::string_t get_download_url(const pal::char_t* framework_name = nullptr, const pal::char_t* framework_version = nullptr);
+
+pal::string_t to_lower(const pal::char_t* in);
+pal::string_t to_upper(const pal::char_t* in);
 
 // Retrieves environment variable which is only used for testing.
 // This will return the value of the variable only if the product binary is stamped
@@ -63,7 +66,7 @@ bool test_only_getenv(const pal::char_t* name, pal::string_t* recv);
 class propagate_error_writer_t
 {
 public:
-    typedef trace::error_writer_fn(__cdecl *set_error_writer_fn)(trace::error_writer_fn error_writer);
+    typedef trace::error_writer_fn(__cdecl* set_error_writer_fn)(trace::error_writer_fn error_writer);
 
 private:
     set_error_writer_fn m_set_error_writer;
diff --git a/src/native/corehost/test/nativehost/nativehost.cpp b/src/native/corehost/test/nativehost/nativehost.cpp
index b323f95a82949a..80280b7bdbbeb9 100644
--- a/src/native/corehost/test/nativehost/nativehost.cpp
+++ b/src/native/corehost/test/nativehost/nativehost.cpp
@@ -40,7 +40,7 @@ int main(const int argc, const pal::char_t *argv[])
         // args: ... [<explicit_load>] [<assembly_path>] [<dotnet_root>] [<hostfxr_to_load>]
         bool explicit_load = false;
         if (argc >= 3)
-            explicit_load = pal::strcmp(pal::to_lower(argv[2]).c_str(), _X("true")) == 0;
+            explicit_load = pal::strcmp(to_lower(argv[2]).c_str(), _X("true")) == 0;
 
         const pal::char_t *assembly_path = nullptr;
         if (argc >= 4 && pal::strcmp(argv[3], _X("nullptr")) != 0)
@@ -117,7 +117,7 @@ int main(const int argc, const pal::char_t *argv[])
         if (static_cast<StatusCode>(res) == StatusCode::Success)
         {
             std::cout << "get_hostfxr_path succeeded" << std::endl;
-            std::cout << "hostfxr_path: " << tostr(pal::to_lower(fxr_path.c_str())).data() << std::endl;
+            std::cout << "hostfxr_path: " << tostr(to_lower(fxr_path.c_str())).data() << std::endl;
             return EXIT_SUCCESS;
         }
         else
diff --git a/src/native/eventpipe/ds-eventpipe-protocol.c b/src/native/eventpipe/ds-eventpipe-protocol.c
index b8f27a81d38d8f..6405e42b0f67ff 100644
--- a/src/native/eventpipe/ds-eventpipe-protocol.c
+++ b/src/native/eventpipe/ds-eventpipe-protocol.c
@@ -426,6 +426,7 @@ eventpipe_protocol_helper_collect_tracing (
 		payload->serialization_format,
 		true,
 		ds_ipc_stream_get_stream_ref (stream),
+		NULL,
 		NULL);
 
 	if (session_id == 0) {
@@ -475,6 +476,7 @@ eventpipe_protocol_helper_collect_tracing_2 (
 		payload->serialization_format,
 		payload->rundown_requested,
 		ds_ipc_stream_get_stream_ref (stream),
+		NULL,
 		NULL);
 
 	if (session_id == 0) {
diff --git a/src/native/eventpipe/ds-process-protocol.c b/src/native/eventpipe/ds-process-protocol.c
index 2ce9ddc4fc44a2..75886a79ff3c25 100644
--- a/src/native/eventpipe/ds-process-protocol.c
+++ b/src/native/eventpipe/ds-process-protocol.c
@@ -53,6 +53,12 @@ process_protocol_helper_get_process_info (
 	DiagnosticsIpcMessage *message,
 	DiagnosticsIpcStream *stream);
 
+static
+bool
+process_protocol_helper_get_process_info_2 (
+	DiagnosticsIpcMessage *message,
+	DiagnosticsIpcStream *stream);
+
 static
 bool
 process_protocol_helper_get_process_env (
@@ -191,6 +197,143 @@ ds_process_info_payload_fini (DiagnosticsProcessInfoPayload *payload)
 	;
 }
 
+/*
+ * DiagnosticsProcessInfo2Payload.
+ */
+
+static
+uint16_t
+process_info_2_payload_get_size (DiagnosticsProcessInfo2Payload *payload)
+{
+	// see IPC spec @ https://github.com/dotnet/diagnostics/blob/master/documentation/design-docs/ipc-protocol.md
+	// for definition of serialization format
+
+	// uint64_t ProcessId;  -> 8 bytes
+	// GUID RuntimeCookie;  -> 16 bytes
+	// LPCWSTR CommandLine; -> 4 bytes + strlen * sizeof(WCHAR)
+	// LPCWSTR OS;          -> 4 bytes + strlen * sizeof(WCHAR)
+	// LPCWSTR Arch;        -> 4 bytes + strlen * sizeof(WCHAR)
+	// LPCWSTR managed_entrypoint_assembly_name;	-> 4 bytes + strlen * sizeof(WCHAR)
+	// LPCWSTR clr_product_version; 				-> 4 bytes + strlen * sizeof(WCHAR)
+
+	EP_ASSERT (payload != NULL);
+
+	size_t size = 0;
+	size += sizeof(payload->process_id);
+	size += sizeof(payload->runtime_cookie);
+
+	size += sizeof(uint32_t);
+	size += (payload->command_line != NULL) ?
+		(ep_rt_utf16_string_len (payload->command_line) + 1) * sizeof(ep_char16_t) : 0;
+
+	size += sizeof(uint32_t);
+	size += (payload->os != NULL) ?
+		(ep_rt_utf16_string_len (payload->os) + 1) * sizeof(ep_char16_t) : 0;
+
+	size += sizeof(uint32_t);
+	size += (payload->arch != NULL) ?
+		(ep_rt_utf16_string_len (payload->arch) + 1) * sizeof(ep_char16_t) : 0;
+
+	size += sizeof(uint32_t);
+	size += (payload->managed_entrypoint_assembly_name != NULL) ?
+		(ep_rt_utf16_string_len (payload->managed_entrypoint_assembly_name) + 1) * sizeof(ep_char16_t) : 0;
+
+	size += sizeof(uint32_t);
+	size += (payload->clr_product_version != NULL) ?
+		(ep_rt_utf16_string_len (payload->clr_product_version) + 1) * sizeof(ep_char16_t) : 0;
+
+	EP_ASSERT (size <= UINT16_MAX);
+	return (uint16_t)size;
+}
+
+static
+bool
+process_info_2_payload_flatten (
+	void *payload,
+	uint8_t **buffer,
+	uint16_t *size)
+{
+	DiagnosticsProcessInfo2Payload *process_info = (DiagnosticsProcessInfo2Payload*)payload;
+
+	EP_ASSERT (payload != NULL);
+	EP_ASSERT (buffer != NULL);
+	EP_ASSERT (*buffer != NULL);
+	EP_ASSERT (size != NULL);
+	EP_ASSERT (process_info_2_payload_get_size (process_info) == *size);
+
+	// see IPC spec @ https://github.com/dotnet/diagnostics/blob/master/documentation/design-docs/ipc-protocol.md
+	// for definition of serialization format
+
+	bool success = true;
+
+	// uint64_t ProcessId;
+	memcpy (*buffer, &process_info->process_id, sizeof (process_info->process_id));
+	*buffer += sizeof (process_info->process_id);
+	*size -= sizeof (process_info->process_id);
+
+	// GUID RuntimeCookie;
+	memcpy(*buffer, &process_info->runtime_cookie, sizeof (process_info->runtime_cookie));
+	*buffer += sizeof (process_info->runtime_cookie);
+	*size -= sizeof (process_info->runtime_cookie);
+
+	// LPCWSTR CommandLine;
+	success &= ds_ipc_message_try_write_string_utf16_t (buffer, size, process_info->command_line);
+
+	// LPCWSTR OS;
+	if (success)
+		success &= ds_ipc_message_try_write_string_utf16_t (buffer, size, process_info->os);
+
+	// LPCWSTR Arch;
+	if (success)
+		success &= ds_ipc_message_try_write_string_utf16_t (buffer, size, process_info->arch);
+
+	// LPCWSTR managed_entrypoint_assembly_name;
+	if (success)
+		success &= ds_ipc_message_try_write_string_utf16_t (buffer, size, process_info->managed_entrypoint_assembly_name);
+
+	// LPCWSTR clr_product_version;
+	if (success)
+		success &= ds_ipc_message_try_write_string_utf16_t (buffer, size, process_info->clr_product_version);
+
+	// Assert we've used the whole buffer we were given
+	EP_ASSERT(*size == 0);
+
+	return success;
+}
+
+DiagnosticsProcessInfo2Payload *
+ds_process_info_2_payload_init (
+	DiagnosticsProcessInfo2Payload *payload,
+	const ep_char16_t *command_line,
+	const ep_char16_t *os,
+	const ep_char16_t *arch,
+	uint32_t process_id,
+	const uint8_t *runtime_cookie,
+	const ep_char16_t *managed_entrypoint_assembly_name,
+	const ep_char16_t *clr_product_version)
+{
+	ep_return_null_if_nok (payload != NULL);
+
+	payload->command_line = command_line;
+	payload->os = os;
+	payload->arch = arch;
+	payload->process_id = process_id;
+	payload->managed_entrypoint_assembly_name = managed_entrypoint_assembly_name;
+	payload->clr_product_version = clr_product_version;
+
+	if (runtime_cookie)
+		memcpy (&payload->runtime_cookie, runtime_cookie, EP_GUID_SIZE);
+
+	return payload;
+}
+
+void
+ds_process_info_2_payload_fini (DiagnosticsProcessInfo2Payload *payload)
+{
+	;
+}
+
+
 /*
  * DiagnosticsEnvironmentInfoPayload.
  */
@@ -386,6 +529,78 @@ process_protocol_helper_get_process_info (
 	ep_exit_error_handler ();
 }
 
+static
+bool
+process_protocol_helper_get_process_info_2 (
+	DiagnosticsIpcMessage *message,
+	DiagnosticsIpcStream *stream)
+{
+	EP_ASSERT (message != NULL);
+	EP_ASSERT (stream != NULL);
+
+	bool result = false;
+	ep_char16_t *command_line = NULL;
+	ep_char16_t *os_info = NULL;
+	ep_char16_t *arch_info = NULL;
+	ep_char16_t *managed_entrypoint_assembly_name = NULL;
+	ep_char16_t *clr_product_version = NULL;
+	DiagnosticsProcessInfo2Payload payload;
+	DiagnosticsProcessInfo2Payload *process_info_2_payload = NULL;
+
+	command_line = ep_rt_utf8_to_utf16_string (ep_rt_diagnostics_command_line_get (), -1);
+	ep_raise_error_if_nok (command_line != NULL);
+
+	os_info = ep_rt_utf8_to_utf16_string (ep_event_source_get_os_info (), -1);
+	ep_raise_error_if_nok (os_info != NULL);
+
+	arch_info = ep_rt_utf8_to_utf16_string (ep_event_source_get_arch_info (), -1);
+	ep_raise_error_if_nok (arch_info != NULL);
+
+	managed_entrypoint_assembly_name = ep_rt_utf8_to_utf16_string (ep_rt_entrypoint_assembly_name_get_utf8 (), -1);
+	ep_raise_error_if_nok (managed_entrypoint_assembly_name != NULL);
+
+	clr_product_version = ep_rt_utf8_to_utf16_string (ep_rt_runtime_version_get_utf8 (), -1);
+	ep_raise_error_if_nok (clr_product_version != NULL);
+
+	process_info_2_payload = ds_process_info_2_payload_init (
+		&payload,
+		command_line,
+		os_info,
+		arch_info,
+		ep_rt_current_process_get_id (),
+		ds_ipc_advertise_cookie_v1_get (),
+		managed_entrypoint_assembly_name,
+		clr_product_version);
+	ep_raise_error_if_nok (process_info_2_payload != NULL);
+
+	ep_raise_error_if_nok (ds_ipc_message_initialize_buffer (
+		message,
+		ds_ipc_header_get_generic_success (),
+		(void *)process_info_2_payload,
+		process_info_2_payload_get_size (process_info_2_payload),
+		process_info_2_payload_flatten));
+
+	ep_raise_error_if_nok (ds_ipc_message_send (message, stream));
+
+	result = true;
+
+ep_on_exit:
+	ds_process_info_2_payload_fini (process_info_2_payload);
+	ep_rt_utf16_string_free (arch_info);
+	ep_rt_utf16_string_free (os_info);
+	ep_rt_utf16_string_free (command_line);
+	ep_rt_utf16_string_free (managed_entrypoint_assembly_name);
+	ep_rt_utf16_string_free (clr_product_version);
+	ds_ipc_stream_free (stream);
+	return result;
+
+ep_on_error:
+	EP_ASSERT (!result);
+	ds_ipc_message_send_error (stream, DS_IPC_E_FAIL);
+	DS_LOG_WARNING_0 ("Failed to send DiagnosticsIPC response");
+	ep_exit_error_handler ();
+}
+
 static
 bool
 process_protocol_helper_get_process_env (
@@ -566,6 +781,9 @@ ds_process_protocol_helper_handle_ipc_message (
 		break;
 	case DS_PROCESS_COMMANDID_SET_ENV_VAR:
 		result = process_protocol_helper_set_environment_variable (message, stream);
+        break;
+	case DS_PROCESS_COMMANDID_GET_PROCESS_INFO_2:
+		result = process_protocol_helper_get_process_info_2 (message, stream);
 		break;
 	default:
 		result = process_protocol_helper_unknown_command (message, stream);
diff --git a/src/native/eventpipe/ds-process-protocol.h b/src/native/eventpipe/ds-process-protocol.h
index 1b2c279aeee14a..ac145c0bd1dbef 100644
--- a/src/native/eventpipe/ds-process-protocol.h
+++ b/src/native/eventpipe/ds-process-protocol.h
@@ -58,6 +58,56 @@ ds_process_info_payload_init (
 void
 ds_process_info_payload_fini (DiagnosticsProcessInfoPayload *payload);
 
+/*
+* DiagnosticsProcessInfo2Payload
+*/
+
+// command = 0x0400
+#if defined(DS_INLINE_GETTER_SETTER) || defined(DS_IMPL_PROCESS_PROTOCOL_GETTER_SETTER)
+struct _DiagnosticsProcessInfo2Payload {
+#else
+struct _DiagnosticsProcessInfo2Payload_Internal {
+#endif
+	// The protocol buffer is defined as:
+	// X, Y, Z means encode bytes for X followed by bytes for Y followed by bytes for Z
+	// uint = 4 little endian bytes
+	// long = 8 little endian bytes
+	// GUID = 16 little endian bytes
+	// wchar = 2 little endian bytes, UTF16 encoding
+	// array<T> = uint length, length # of Ts
+	// string = (array<char> where the last char must = 0) or (length = 0)
+
+	// ProcessInfo = long pid, GUID runtimeCookie, string cmdline, string OS, string arch, string managed entrypoint assembly path, string clr product version
+	uint64_t process_id;
+	const ep_char16_t *command_line;
+	const ep_char16_t *os;
+	const ep_char16_t *arch;
+	uint8_t runtime_cookie [EP_GUID_SIZE];
+	const ep_char16_t *managed_entrypoint_assembly_name;
+	const ep_char16_t *clr_product_version;
+
+};
+
+#if !defined(DS_INLINE_GETTER_SETTER) && !defined(DS_IMPL_PROCESS_PROTOCOL_GETTER_SETTER)
+struct _DiagnosticsProcessInfo2Payload {
+	uint8_t _internal [sizeof (struct _DiagnosticsProcessInfo2Payload_Internal)];
+};
+#endif
+
+DiagnosticsProcessInfo2Payload *
+ds_process_info_2_payload_init (
+	DiagnosticsProcessInfo2Payload *payload,
+	const ep_char16_t *command_line,
+	const ep_char16_t *os,
+	const ep_char16_t *arch,
+	uint32_t process_id,
+	const uint8_t *runtime_cookie,
+	const ep_char16_t *managed_entrypoint_assembly_name,
+	const ep_char16_t *clr_product_version);
+
+void
+ds_process_info_2_payload_fini (DiagnosticsProcessInfo2Payload *payload);
+
 /*
 * DiagnosticsEnvironmentInfoPayload
 */
@@ -125,4 +175,3 @@ ds_process_protocol_helper_handle_ipc_message (
 
 #endif /* ENABLE_PERFTRACING */
 #endif /* __DIAGNOSTICS_PROCESS_PROTOCOL_H__ */
-
diff --git a/src/native/eventpipe/ds-types.h b/src/native/eventpipe/ds-types.h
index 243951d243dce5..fc5d3e1a2ecccc 100644
--- a/src/native/eventpipe/ds-types.h
+++ b/src/native/eventpipe/ds-types.h
@@ -29,6 +29,7 @@ typedef struct _DiagnosticsPort DiagnosticsPort;
 typedef struct _DiagnosticsPortBuilder DiagnosticsPortBuilder;
 typedef struct _DiagnosticsPortVtable DiagnosticsPortVtable;
 typedef struct _DiagnosticsProcessInfoPayload DiagnosticsProcessInfoPayload;
+typedef struct _DiagnosticsProcessInfo2Payload DiagnosticsProcessInfo2Payload;
 typedef struct _EventPipeCollectTracingCommandPayload EventPipeCollectTracingCommandPayload;
 typedef struct _EventPipeCollectTracing2CommandPayload EventPipeCollectTracing2CommandPayload;
 typedef struct _EventPipeStopTracingCommandPayload EventPipeStopTracingCommandPayload;
@@ -67,6 +68,7 @@ typedef enum {
 	DS_PROCESS_COMMANDID_RESUME_RUNTIME = 0x01,
 	DS_PROCESS_COMMANDID_GET_PROCESS_ENV = 0x02,
 	DS_PROCESS_COMMANDID_SET_ENV_VAR = 0x03,
+	DS_PROCESS_COMMANDID_GET_PROCESS_INFO_2 = 0x04
 	// future
 } DiagnosticsProcessCommandId;
 
diff --git a/src/native/eventpipe/ep-rt.h b/src/native/eventpipe/ep-rt.h
index 405bb4fb038ccc..d043710f46c1a6 100644
--- a/src/native/eventpipe/ep-rt.h
+++ b/src/native/eventpipe/ep-rt.h
@@ -600,6 +600,14 @@ static
 void
 ep_rt_os_environment_get_utf16 (ep_rt_env_array_utf16_t *env_array);
 
+static
+const ep_char8_t *
+ep_rt_entrypoint_assembly_name_get_utf8 (void);
+
+static
+const ep_char8_t *
+ep_rt_runtime_version_get_utf8 (void);
+
 /*
 * Lock
 */
diff --git a/src/native/eventpipe/ep-session.c b/src/native/eventpipe/ep-session.c
index 2f8a55b20b0fbc..60a5fe0cb25832 100644
--- a/src/native/eventpipe/ep-session.c
+++ b/src/native/eventpipe/ep-session.c
@@ -71,11 +71,11 @@ EP_RT_DEFINE_THREAD_FUNC (streaming_thread)
 		ep_rt_wait_event_set (&session->rt_thread_shutdown_event);
 	EP_GCX_PREEMP_EXIT
 
+	session->streaming_thread = NULL;
+
 	if (!success)
 		ep_disable ((EventPipeSessionID)session);
 
-	session->streaming_thread = NULL;
-
 	return (ep_rt_thread_start_func_return_t)0;
 }
 
@@ -132,7 +132,8 @@ ep_session_alloc (
 	uint32_t circular_buffer_size_in_mb,
 	const EventPipeProviderConfiguration *providers,
 	uint32_t providers_len,
-	EventPipeSessionSynchronousCallback sync_callback)
+	EventPipeSessionSynchronousCallback sync_callback,
+	void *callback_additional_data)
 {
 	EP_ASSERT (index < EP_MAX_NUMBER_OF_SESSIONS);
 	EP_ASSERT (format < EP_SERIALIZATION_FORMAT_COUNT);
@@ -159,6 +160,7 @@ ep_session_alloc (
 	instance->format = format;
 	instance->rundown_requested = rundown_requested;
 	instance->synchronous_callback = sync_callback;
+	instance->callback_additional_data = callback_additional_data;
 
 	// Hard coded 10MB for now, we'll probably want to make
 	// this configurable later.
@@ -473,7 +475,8 @@ ep_session_write_event (
 				related_activity_id,
 				event_thread,
 				stack == NULL ? 0 : ep_stack_contents_get_size (stack),
-				stack == NULL ? NULL : (uintptr_t *)ep_stack_contents_get_pointer (stack));
+				stack == NULL ? NULL : (uintptr_t *)ep_stack_contents_get_pointer (stack),
+				session->callback_additional_data);
 			result = true;
 		} else {
 			EP_ASSERT (session->buffer_manager != NULL);
diff --git a/src/native/eventpipe/ep-session.h b/src/native/eventpipe/ep-session.h
index 48087ed23c1746..a38adc4e73cc0b 100644
--- a/src/native/eventpipe/ep-session.h
+++ b/src/native/eventpipe/ep-session.h
@@ -35,6 +35,8 @@ struct _EventPipeSession_Internal {
 	EventPipeFile *file;
 	// For synchoronous sessions.
 	EventPipeSessionSynchronousCallback synchronous_callback;
+	// Additional data to pass to the callback
+	void *callback_additional_data;
 	// Start date and time in UTC.
 	ep_system_timestamp_t session_start_time;
 	// Start timestamp.
@@ -85,7 +87,8 @@ ep_session_alloc (
 	uint32_t circular_buffer_size_in_mb,
 	const EventPipeProviderConfiguration *providers,
 	uint32_t providers_len,
-	EventPipeSessionSynchronousCallback sync_callback);
+	EventPipeSessionSynchronousCallback sync_callback,
+	void *callback_additional_data);
 
 void
 ep_session_free (EventPipeSession *session);
diff --git a/src/native/eventpipe/ep-types-forward.h b/src/native/eventpipe/ep-types-forward.h
index 6b5a70b134f6c7..a40ab0cad0cc4b 100644
--- a/src/native/eventpipe/ep-types-forward.h
+++ b/src/native/eventpipe/ep-types-forward.h
@@ -201,7 +201,8 @@ typedef void (*EventPipeSessionSynchronousCallback)(
 	const uint8_t *related_activity_id,
 	/*ep_rt_thread_handle_t*/ void *event_thread,
 	uint32_t stack_frames_len,
-	uintptr_t *stack_frames);
+	uintptr_t *stack_frames,
+    void *additional_data);
 
 typedef bool (*EventPipeIpcStreamFactorySuspendedPortsCallback)(void);
 
diff --git a/src/native/eventpipe/ep.c b/src/native/eventpipe/ep.c
index 28bdb702ee9780..38c1e1a69b43e7 100644
--- a/src/native/eventpipe/ep.c
+++ b/src/native/eventpipe/ep.c
@@ -56,7 +56,8 @@ enable (
 	bool rundown_requested,
 	IpcStream *stream,
 	EventPipeProviderCallbackDataQueue *provider_callback_data_queue,
-	EventPipeSessionSynchronousCallback sync_callback);
+	EventPipeSessionSynchronousCallback sync_callback,
+	void *callback_additional_data);
 
 static
 void
@@ -423,7 +424,8 @@ enable (
 	bool rundown_requested,
 	IpcStream *stream,
 	EventPipeProviderCallbackDataQueue *provider_callback_data_queue,
-	EventPipeSessionSynchronousCallback sync_callback)
+	EventPipeSessionSynchronousCallback sync_callback,
+	void *callback_additional_data)
 {
 	EP_ASSERT (format < EP_SERIALIZATION_FORMAT_COUNT);
 	EP_ASSERT (session_type == EP_SESSION_TYPE_SYNCHRONOUS || circular_buffer_size_in_mb > 0);
@@ -450,7 +452,8 @@ enable (
 		circular_buffer_size_in_mb,
 		providers,
 		providers_len,
-		sync_callback);
+		sync_callback,
+		callback_additional_data);
 
 	ep_raise_error_if_nok (session != NULL && ep_session_is_valid (session));
 
@@ -854,6 +857,7 @@ enable_default_session_via_env_variables (void)
 			EP_SERIALIZATION_FORMAT_NETTRACE_V4,
 			true,
 			NULL,
+			NULL,
 			NULL);
 
 		if (session_id)
@@ -904,7 +908,8 @@ ep_enable (
 	EventPipeSerializationFormat format,
 	bool rundown_requested,
 	IpcStream *stream,
-	EventPipeSessionSynchronousCallback sync_callback)
+	EventPipeSessionSynchronousCallback sync_callback,
+	void *callback_additional_data)
 {
 	ep_return_zero_if_nok (format < EP_SERIALIZATION_FORMAT_COUNT);
 	ep_return_zero_if_nok (session_type == EP_SESSION_TYPE_SYNCHRONOUS || circular_buffer_size_in_mb > 0);
@@ -934,7 +939,8 @@ ep_enable (
 			rundown_requested,
 			stream,
 			provider_callback_data_queue,
-			sync_callback);
+			sync_callback,
+			callback_additional_data);
 	EP_LOCK_EXIT (section1)
 
 	while (ep_provider_callback_data_queue_try_dequeue (provider_callback_data_queue, &provider_callback_data)) {
@@ -961,7 +967,8 @@ ep_enable_2 (
 	EventPipeSerializationFormat format,
 	bool rundown_requested,
 	IpcStream *stream,
-	EventPipeSessionSynchronousCallback sync_callback)
+	EventPipeSessionSynchronousCallback sync_callback,
+	void *callback_additional_data)
 {
 	const ep_char8_t *providers_config_to_parse = providers_config;
 	int32_t providers_len = 0;
@@ -1038,7 +1045,8 @@ ep_enable_2 (
 		format,
 		rundown_requested,
 		stream,
-		sync_callback);
+		sync_callback,
+		callback_additional_data);
 
 ep_on_exit:
 
diff --git a/src/native/eventpipe/ep.h b/src/native/eventpipe/ep.h
index eb0e6a75ac99a6..f70abd4354a102 100644
--- a/src/native/eventpipe/ep.h
+++ b/src/native/eventpipe/ep.h
@@ -181,7 +181,8 @@ ep_enable (
 	EventPipeSerializationFormat format,
 	bool rundown_requested,
 	IpcStream *stream,
-	EventPipeSessionSynchronousCallback sync_callback);
+	EventPipeSessionSynchronousCallback sync_callback,
+	void *callback_additional_data);
 
 EventPipeSessionID
 ep_enable_2 (
@@ -192,7 +193,8 @@ ep_enable_2 (
 	EventPipeSerializationFormat format,
 	bool rundown_requested,
 	IpcStream *stream,
-	EventPipeSessionSynchronousCallback sync_callback);
+	EventPipeSessionSynchronousCallback sync_callback,
+	void *callback_additional_data);
 
 void
 ep_disable (EventPipeSessionID id);
diff --git a/src/tasks/AndroidAppBuilder/ApkBuilder.cs b/src/tasks/AndroidAppBuilder/ApkBuilder.cs
index ca7c4922ddbbcb..b979ba316b33d9 100644
--- a/src/tasks/AndroidAppBuilder/ApkBuilder.cs
+++ b/src/tasks/AndroidAppBuilder/ApkBuilder.cs
@@ -5,6 +5,7 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Text;
 using Microsoft.Build.Framework;
 
 public class ApkBuilder
@@ -122,18 +123,29 @@ public class ApkBuilder
             throw new ArgumentException($"{buildToolsFolder} was not found.");
         }
 
-        var assemblerFiles = new List<string>();
+        var assemblerFiles = new StringBuilder();
+        var assemblerFilesToLink = new StringBuilder();
         foreach (ITaskItem file in Assemblies)
         {
             // use AOT files if available
             var obj = file.GetMetadata("AssemblerFile");
+            var llvmObj = file.GetMetadata("LlvmObjectFile");
+
             if (!string.IsNullOrEmpty(obj))
             {
-                assemblerFiles.Add(obj);
+                var name = Path.GetFileNameWithoutExtension(obj);
+                assemblerFiles.AppendLine($"add_library({name} OBJECT {obj})");
+                assemblerFilesToLink.AppendLine($"    {name}");
+            }
+
+            if (!string.IsNullOrEmpty(llvmObj))
+            {
+                var name = Path.GetFileNameWithoutExtension(llvmObj);
+                assemblerFilesToLink.AppendLine($"    {llvmObj}");
             }
         }
 
-        if (ForceAOT && !assemblerFiles.Any())
+        if (ForceAOT && assemblerFiles.Length == 0)
         {
             throw new InvalidOperationException("Need list of AOT files.");
         }
@@ -261,12 +273,9 @@ public class ApkBuilder
             nativeLibraries += $"    {monoRuntimeLib}{Environment.NewLine}";
         }
 
-        string aotSources = "";
-        foreach (string asm in assemblerFiles)
-        {
-            // these libraries are linked via modules.c
-            aotSources += $"    {asm}{Environment.NewLine}";
-        }
+        nativeLibraries += assemblerFilesToLink.ToString();
+
+        string aotSources = assemblerFiles.ToString();
 
         string cmakeLists = Utils.GetEmbeddedResource("CMakeLists-android.txt")
             .Replace("%MonoInclude%", monoRuntimeHeaders)
@@ -486,7 +495,7 @@ private static string GetLatestBuildTools(string androidSdkDir)
     {
         string? buildTools = Directory.GetDirectories(Path.Combine(androidSdkDir, "build-tools"))
             .Select(Path.GetFileName)
-            .Where(file => !file!.Contains("-"))
+            .Where(file => !file!.Contains('-'))
             .Select(file => { Version.TryParse(Path.GetFileName(file), out Version? version); return version; })
             .OrderByDescending(v => v)
             .FirstOrDefault()?.ToString();
diff --git a/src/tasks/AndroidAppBuilder/Templates/CMakeLists-android.txt b/src/tasks/AndroidAppBuilder/Templates/CMakeLists-android.txt
index c74d4625af0fa0..7b602ad6a30292 100644
--- a/src/tasks/AndroidAppBuilder/Templates/CMakeLists-android.txt
+++ b/src/tasks/AndroidAppBuilder/Templates/CMakeLists-android.txt
@@ -9,12 +9,19 @@ if(NOT USE_LLVM)
     add_compile_options(-no-integrated-as)
 endif()
 
+# Prevent the warning: shared library text segment is not shareable which is treated as an error
+if (NOT ANDROID_ABI STREQUAL "arm64-v8a")
+    add_link_options(-Wl,--no-warn-shared-textrel)
+endif()
+
 add_library(
     monodroid
     SHARED
     monodroid.c
     %AotModulesSource%
-    %AotSources%)
+)
+
+%AotSources%
 
 %Defines%
 
diff --git a/src/tasks/AotCompilerTask/MonoAOTCompiler.cs b/src/tasks/AotCompilerTask/MonoAOTCompiler.cs
index 52d37fe900e0f8..cb3876cfc9c36f 100644
--- a/src/tasks/AotCompilerTask/MonoAOTCompiler.cs
+++ b/src/tasks/AotCompilerTask/MonoAOTCompiler.cs
@@ -417,8 +417,17 @@ private bool PrecompileLibrary(ITaskItem assemblyItem, string? monoPaths)
         try
         {
             // run the AOT compiler
-            Utils.RunProcess(CompilerBinaryPath, string.Join(" ", processArgs), envVariables, assemblyDir, silent: false,
-                    outputMessageImportance: MessageImportance.Low, debugMessageImportance: MessageImportance.Low);
+            (int exitCode, string output) = Utils.TryRunProcess(CompilerBinaryPath,
+                                                                string.Join(" ", processArgs),
+                                                                envVariables,
+                                                                assemblyDir,
+                                                                silent: false,
+                                                                debugMessageImportance: MessageImportance.Low);
+            if (exitCode != 0)
+            {
+                Log.LogError($"Precompiling failed for {assembly}: {output}");
+                return false;
+            }
         }
         catch (Exception ex)
         {
diff --git a/src/tasks/AotCompilerTask/MonoAOTCompiler.props b/src/tasks/AotCompilerTask/MonoAOTCompiler.props
index 097758ae0c783b..159c01ff3f27bb 100644
--- a/src/tasks/AotCompilerTask/MonoAOTCompiler.props
+++ b/src/tasks/AotCompilerTask/MonoAOTCompiler.props
@@ -14,7 +14,10 @@
     <MonoAOTCompilerDefaultProcessArguments Include="-O=gsharedvt" />
   </ItemGroup>
   <ItemGroup Condition="'$(TargetOS)' == 'Android'">
-    <MonoAOTCompilerDefaultAotArguments Condition="'$(TargetArchitecture)' == 'arm'" Include="mtriple=armv7-linux-gnueabi-thumbv7s" />
+    <MonoAOTCompilerDefaultAotArguments Condition="'$(TargetArchitecture)' == 'arm'" Include="mtriple=armv7-linux-gnueabi" />
+    <MonoAOTCompilerDefaultAotArguments Condition="'$(TargetArchitecture)' == 'arm64'" Include="mtriple=aarch64-linux-android" />
+    <MonoAOTCompilerDefaultAotArguments Condition="'$(TargetArchitecture)' == 'x86'" Include="mtriple=i686-linux-android" />
+    <MonoAOTCompilerDefaultAotArguments Condition="'$(TargetArchitecture)' == 'x64'" Include="mtriple=x86_64-linux-android" />
     <MonoAOTCompilerDefaultAotArguments Include="static" />
     <!-- Default trampolines run out for libraries tests -->
     <MonoAOTCompilerDefaultAotArguments Include="nimt-trampolines=2000" />
diff --git a/src/tasks/Common/Utils.cs b/src/tasks/Common/Utils.cs
index 5cb001a633429d..ea2aba607dd8e0 100644
--- a/src/tasks/Common/Utils.cs
+++ b/src/tasks/Common/Utils.cs
@@ -5,6 +5,7 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.IO;
+using System.Runtime.InteropServices;
 using System.Text;
 using Microsoft.Build.Framework;
 using Microsoft.Build.Utilities;
@@ -21,6 +22,49 @@ public static string GetEmbeddedResource(string file)
         return reader.ReadToEnd();
     }
 
+    public static (int exitCode, string output) RunShellCommand(string command,
+                                        IDictionary<string, string> envVars,
+                                        string workingDir,
+                                        MessageImportance debugMessageImportance=MessageImportance.Low)
+    {
+        string scriptFileName = CreateTemporaryBatchFile(command);
+        (string shell, string args) = RuntimeInformation.IsOSPlatform(OSPlatform.Windows)
+                                                    ? ("cmd", $"/c \"{scriptFileName}\"")
+                                                    : ("/bin/sh", $"\"{scriptFileName}\"");
+
+        Logger?.LogMessage(debugMessageImportance, $"Running {command} via script {scriptFileName}:");
+        Logger?.LogMessage(debugMessageImportance, File.ReadAllText(scriptFileName));
+
+        return TryRunProcess(shell,
+                             args,
+                             envVars,
+                             workingDir,
+                             silent: false,
+                             debugMessageImportance);
+
+        static string CreateTemporaryBatchFile(string command)
+        {
+            string extn = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? ".cmd" : ".sh";
+            string file = Path.Combine(Path.GetTempPath(), $"tmp{Guid.NewGuid():N}{extn}");
+
+            using StreamWriter sw = new(file);
+            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+            {
+                sw.WriteLine("setlocal");
+                sw.WriteLine("set errorlevel=dummy");
+                sw.WriteLine("set errorlevel=");
+            }
+            else
+            {
+                // Use sh rather than bash, as not all 'nix systems necessarily have Bash installed
+                sw.WriteLine("#!/bin/sh");
+            }
+
+            sw.WriteLine(command);
+            return file;
+        }
+    }
+
     public static string RunProcess(
         string path,
         string args = "",
@@ -28,12 +72,32 @@ public static string RunProcess(
         string? workingDir = null,
         bool ignoreErrors = false,
         bool silent = true,
-        MessageImportance outputMessageImportance=MessageImportance.High,
         MessageImportance debugMessageImportance=MessageImportance.High)
     {
-        LogInfo($"Running: {path} {args}", debugMessageImportance);
+        (int exitCode, string output) = TryRunProcess(
+                                            path,
+                                            args,
+                                            envVars,
+                                            workingDir,
+                                            silent,
+                                            debugMessageImportance);
+
+        if (exitCode != 0 && !ignoreErrors)
+            throw new Exception("Error: Process returned non-zero exit code: " + output);
+
+        return output;
+    }
+
+    public static (int, string) TryRunProcess(
+        string path,
+        string args = "",
+        IDictionary<string, string>? envVars = null,
+        string? workingDir = null,
+        bool silent = true,
+        MessageImportance debugMessageImportance=MessageImportance.High)
+    {
+        Logger?.LogMessage(debugMessageImportance, $"Running: {path} {args}");
         var outputBuilder = new StringBuilder();
-        var errorBuilder = new StringBuilder();
         var processStartInfo = new ProcessStartInfo
         {
             FileName = path,
@@ -47,7 +111,7 @@ public static string RunProcess(
         if (workingDir != null)
             processStartInfo.WorkingDirectory = workingDir;
 
-        LogInfo($"Using working directory: {workingDir ?? Environment.CurrentDirectory}", debugMessageImportance);
+        Logger?.LogMessage(debugMessageImportance, $"Using working directory: {workingDir ?? Environment.CurrentDirectory}");
 
         if (envVars != null)
         {
@@ -69,37 +133,55 @@ public static string RunProcess(
         {
             lock (s_SyncObj)
             {
+                if (string.IsNullOrEmpty(e.Data))
+                    return;
+
                 if (!silent)
-                {
                     LogWarning(e.Data);
-                    outputBuilder.AppendLine(e.Data);
-                }
-                errorBuilder.AppendLine(e.Data);
+                outputBuilder.AppendLine(e.Data);
             }
         };
         process.OutputDataReceived += (sender, e) =>
         {
             lock (s_SyncObj)
             {
+                if (string.IsNullOrEmpty(e.Data))
+                    return;
+
                 if (!silent)
-                {
-                    LogInfo(e.Data, outputMessageImportance);
-                    outputBuilder.AppendLine(e.Data);
-                }
+                    Logger?.LogMessage(debugMessageImportance, e.Data);
+                outputBuilder.AppendLine(e.Data);
             }
         };
         process.BeginOutputReadLine();
         process.BeginErrorReadLine();
         process.WaitForExit();
 
-        if (process.ExitCode != 0)
+        Logger?.LogMessage(debugMessageImportance, $"Exit code: {process.ExitCode}");
+        return (process.ExitCode, outputBuilder.ToString().Trim('\r', '\n'));
+    }
+
+    internal static string CreateTemporaryBatchFile(string command)
+    {
+        string extn = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? ".cmd" : ".sh";
+        string file = Path.Combine(Path.GetTempPath(), $"tmp{Guid.NewGuid():N}{extn}");
+
+        using StreamWriter sw = new(file);
+        if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
         {
-            Logger?.LogMessage(MessageImportance.High, $"Exit code: {process.ExitCode}");
-            if (!ignoreErrors)
-                throw new Exception("Error: Process returned non-zero exit code: " + errorBuilder);
+                sw.WriteLine("setlocal");
+                sw.WriteLine("set errorlevel=dummy");
+                sw.WriteLine("set errorlevel=");
         }
+        else
+        {
+            // Use sh rather than bash, as not all 'nix systems necessarily have Bash installed
+            sw.WriteLine("#!/bin/sh");
+        }
+
+        sw.WriteLine(command);
 
-        return outputBuilder.ToString().Trim('\r', '\n');
+        return file;
     }
 
 #if NETCOREAPP
diff --git a/src/tasks/WasmAppBuilder/EmccCompile.cs b/src/tasks/WasmAppBuilder/EmccCompile.cs
new file mode 100644
index 00000000000000..b175c62c2ee11f
--- /dev/null
+++ b/src/tasks/WasmAppBuilder/EmccCompile.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;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.Build.Framework;
+using Microsoft.Build.Utilities;
+
+#nullable enable
+
+namespace Microsoft.WebAssembly.Build.Tasks
+{
+    /// <summary>
+    /// This is meant to *compile* source files only. It is *not* a general purpose
+    /// `emcc` invocation task.
+    ///
+    /// It runs `emcc` for each source file, and with output to `%(SourceFiles.ObjectFile)`
+    ///
+    /// </summary>
+    public class EmccCompile : Microsoft.Build.Utilities.Task
+    {
+        [NotNull]
+        [Required]
+        public ITaskItem[]? SourceFiles            { get; set; }
+
+        public ITaskItem[]? EnvironmentVariables   { get; set; }
+        public bool         DisableParallelCompile { get; set; }
+        public string       Arguments              { get; set; } = string.Empty;
+        public string?      WorkingDirectory       { get; set; }
+
+        [Output]
+        public ITaskItem[]? OutputFiles            { get; private set; }
+
+        private string? _tempPath;
+
+        public override bool Execute()
+        {
+            if (SourceFiles.Length == 0)
+            {
+                Log.LogError($"No SourceFiles to compile");
+                return false;
+            }
+
+            ITaskItem? badItem = SourceFiles.FirstOrDefault(sf => string.IsNullOrEmpty(sf.GetMetadata("ObjectFile")));
+            if (badItem != null)
+            {
+                Log.LogError($"Source file {badItem.ItemSpec} is missing ObjectFile metadata.");
+                return false;
+            }
+
+            IDictionary<string, string> envVarsDict = GetEnvironmentVariablesDict();
+            ConcurrentBag<ITaskItem> outputItems = new();
+            try
+            {
+                Log.LogMessage(MessageImportance.Low, "Using environment variables:");
+                foreach (var kvp in envVarsDict)
+                    Log.LogMessage(MessageImportance.Low, $"\t{kvp.Key} = {kvp.Value}");
+
+                string workingDir = Environment.CurrentDirectory;
+                Log.LogMessage(MessageImportance.Low, $"Using working directory: {workingDir}");
+
+                _tempPath = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
+                Directory.CreateDirectory(_tempPath);
+
+                int allowedParallelism = Math.Min(SourceFiles.Length, Environment.ProcessorCount);
+#if false // Enable this when we bump msbuild to 16.1.0
+                if (BuildEngine is IBuildEngine9 be9)
+                    allowedParallelism = be9.RequestCores(allowedParallelism);
+#endif
+
+                if (DisableParallelCompile || allowedParallelism == 1)
+                {
+                    foreach (ITaskItem srcItem in SourceFiles)
+                    {
+                        if (!ProcessSourceFile(srcItem))
+                            return false;
+                    }
+                }
+                else
+                {
+                    ParallelLoopResult result = Parallel.ForEach(SourceFiles,
+                                                    new ParallelOptions { MaxDegreeOfParallelism = allowedParallelism },
+                                                    (srcItem, state) =>
+                    {
+                        if (!ProcessSourceFile(srcItem))
+                            state.Stop();
+                    });
+
+                    if (!result.IsCompleted && !Log.HasLoggedErrors)
+                        Log.LogError("Unknown failed occured while compiling");
+                }
+            }
+            finally
+            {
+                if (!string.IsNullOrEmpty(_tempPath))
+                    Directory.Delete(_tempPath, true);
+            }
+
+            OutputFiles = outputItems.ToArray();
+            return !Log.HasLoggedErrors;
+
+            bool ProcessSourceFile(ITaskItem srcItem)
+            {
+                string srcFile = srcItem.ItemSpec;
+                string objFile = srcItem.GetMetadata("ObjectFile");
+
+                try
+                {
+                    string command = $"emcc {Arguments} -c -o {objFile} {srcFile}";
+                    (int exitCode, string output) = Utils.RunShellCommand(command, envVarsDict, workingDir: Environment.CurrentDirectory);
+
+                    if (exitCode != 0)
+                    {
+                        Log.LogError($"Failed to compile {srcFile} -> {objFile}: {output}");
+                        return false;
+                    }
+
+                    ITaskItem newItem = new TaskItem(objFile);
+                    newItem.SetMetadata("SourceFile", srcFile);
+                    outputItems.Add(newItem);
+
+                    return true;
+                }
+                catch (Exception ex)
+                {
+                    Log.LogError($"Failed to compile {srcFile} -> {objFile}: {ex.Message}");
+                    return false;
+                }
+            }
+        }
+
+        private IDictionary<string, string> GetEnvironmentVariablesDict()
+        {
+            Dictionary<string, string> envVarsDict = new();
+            if (EnvironmentVariables == null)
+                return envVarsDict;
+
+            foreach (var item in EnvironmentVariables)
+            {
+                var parts = item.ItemSpec.Split(new char[] {'='}, 2, StringSplitOptions.None);
+                if (parts.Length == 0)
+                    continue;
+
+                string key = parts[0];
+                string value = parts.Length > 1 ? parts[1] : string.Empty;
+
+                envVarsDict[key] = value;
+            }
+
+            return envVarsDict;
+        }
+    }
+}
diff --git a/src/tasks/WasmAppBuilder/WasmAppBuilder.cs b/src/tasks/WasmAppBuilder/WasmAppBuilder.cs
index 9ef7679c292b66..46c0174148be25 100644
--- a/src/tasks/WasmAppBuilder/WasmAppBuilder.cs
+++ b/src/tasks/WasmAppBuilder/WasmAppBuilder.cs
@@ -3,16 +3,11 @@
 
 using System;
 using System.Collections.Generic;
-using System.Collections.Immutable;
-using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using System.Linq;
-using System.Text;
-using System.Text.Encodings.Web;
 using System.Text.Json;
 using System.Text.Json.Serialization;
-using System.Reflection;
 using Microsoft.Build.Framework;
 using Microsoft.Build.Utilities;
 
@@ -51,7 +46,7 @@ public class WasmAppBuilder : Task
     public ITaskItem[]? ExtraFilesToDeploy { get; set; }
 
     // <summary>
-    // Extra json elements to add to mono-config.js
+    // Extra json elements to add to mono-config.json
     //
     // Metadata:
     // - Value: can be a number, bool, quoted string, or json string
@@ -189,6 +184,13 @@ public override bool Execute ()
             {
                 string culture = assembly.GetMetadata("CultureName") ?? string.Empty;
                 string fullPath = assembly.GetMetadata("Identity");
+                if (string.IsNullOrEmpty(culture))
+                {
+                    Log.LogWarning($"Missing CultureName metadata for satellite assembly {fullPath}");
+                    continue;
+                }
+                // FIXME: validate the culture?
+
                 string name = Path.GetFileName(fullPath);
                 string directory = Path.Combine(AppDir, config.AssemblyRoot, culture);
                 Directory.CreateDirectory(directory);
@@ -246,11 +248,11 @@ public override bool Execute ()
             config.Extra[name] = valueObject;
         }
 
-        string monoConfigPath = Path.Combine(AppDir, "mono-config.js");
+        string monoConfigPath = Path.Combine(AppDir, "mono-config.json");
         using (var sw = File.CreateText(monoConfigPath))
         {
             var json = JsonSerializer.Serialize (config, new JsonSerializerOptions { WriteIndented = true });
-            sw.Write($"config = {json};");
+            sw.Write(json);
         }
         _fileWrites.Add(monoConfigPath);
 
diff --git a/src/tasks/WasmAppBuilder/WasmAppBuilder.csproj b/src/tasks/WasmAppBuilder/WasmAppBuilder.csproj
index 23074621b89730..b27176e2774006 100644
--- a/src/tasks/WasmAppBuilder/WasmAppBuilder.csproj
+++ b/src/tasks/WasmAppBuilder/WasmAppBuilder.csproj
@@ -14,6 +14,8 @@
   </ItemGroup>
 
   <ItemGroup>
+    <Compile Include="..\Common\Utils.cs" />
+
     <PackageReference Include="Microsoft.Build" Version="$(RefOnlyMicrosoftBuildVersion)" />
     <PackageReference Include="Microsoft.Build.Framework" Version="$(RefOnlyMicrosoftBuildFrameworkVersion)" />
     <PackageReference Include="Microsoft.Build.Tasks.Core" Version="$(RefOnlyMicrosoftBuildTasksCoreVersion)" />
diff --git a/src/tasks/WasmBuildTasks/GenerateAOTProps.cs b/src/tasks/WasmBuildTasks/GenerateAOTProps.cs
index 8e6c9c3142a9b9..83d2901a0f4559 100644
--- a/src/tasks/WasmBuildTasks/GenerateAOTProps.cs
+++ b/src/tasks/WasmBuildTasks/GenerateAOTProps.cs
@@ -17,10 +17,35 @@ public class GenerateAOTProps : Task
         [Required]
         public ITaskItem[]? Properties { get; set; }
 
+        public ITaskItem[] Items { get; set; } = Array.Empty<ITaskItem>();
+
         [NotNull]
         [Required]
         public string? OutputFile { get; set; }
 
+        private const string s_originalItemNameMetadata = "OriginalItemName__";
+        private const string s_conditionToUseMetadata = "ConditionToUse__";
+        private static readonly HashSet<string> s_metdataNamesToSkip = new()
+        {
+            "FullPath",
+            "RootDir",
+            "Filename",
+            "Extension",
+            "RelativeDir",
+            "Directory",
+            "RecursiveDir",
+            "Identity",
+            "ModifiedTime",
+            "CreatedTime",
+            "AccessedTime",
+            "DefiningProjectFullPath",
+            "DefiningProjectDirectory",
+            "DefiningProjectName",
+            "DefiningProjectExtension",
+            s_originalItemNameMetadata,
+            s_conditionToUseMetadata
+        };
+
         public override bool Execute()
         {
             var outDir = Path.GetDirectoryName(OutputFile);
@@ -30,21 +55,50 @@ public override bool Execute()
             StringBuilder sb = new();
 
             sb.AppendLine("<Project>");
-            sb.AppendLine("    <PropertyGroup>");
+            sb.AppendLine("\t<PropertyGroup>");
 
-            foreach (var prop in Properties)
+            foreach (ITaskItem2 prop in Properties)
             {
-                string value = prop.ItemSpec;
+                string value = prop.EvaluatedIncludeEscaped;
                 string? name = prop.GetMetadata("Name");
-                string? condition = prop.GetMetadata("ConditionToUse");
+                string? condition = prop.GetMetadataValueEscaped(s_conditionToUseMetadata);
 
                 if (!string.IsNullOrEmpty(condition))
-                    sb.AppendLine($"        <{name} Condition=\"{condition}\">{value}</{name}>");
+                    sb.AppendLine($"\t\t<{name} Condition=\"{condition}\">{value}</{name}>");
                 else
-                    sb.AppendLine($"        <{name}>{value}</{name}>");
+                    sb.AppendLine($"\t\t<{name}>{value}</{name}>");
+            }
+
+            sb.AppendLine("\t</PropertyGroup>");
+
+            sb.AppendLine("\t<ItemGroup>");
+            foreach (ITaskItem2 item in Items)
+            {
+                string value = item.EvaluatedIncludeEscaped;
+                string name = item.GetMetadata(s_originalItemNameMetadata);
+
+                if (string.IsNullOrEmpty(name))
+                {
+                    Log.LogError($"Item {value} is missing {s_originalItemNameMetadata} metadata, for the item name");
+                    return false;
+                }
+
+                sb.AppendLine($"\t\t<{name} Include=\"{value}\"");
+
+                string? condition = item.GetMetadataValueEscaped(s_conditionToUseMetadata);
+                if (!string.IsNullOrEmpty(condition))
+                    sb.AppendLine($"\t\t\tCondition=\"{condition}\"");
+
+                foreach (string mdName in item.MetadataNames)
+                {
+                    if (!s_metdataNamesToSkip.Contains(mdName))
+                        sb.AppendLine($"\t\t\t{mdName}=\"{item.GetMetadataValueEscaped(mdName)}\"");
+                }
+
+                sb.AppendLine($"\t\t/>");
             }
 
-            sb.AppendLine("    </PropertyGroup>");
+            sb.AppendLine("\t</ItemGroup>");
             sb.AppendLine("</Project>");
 
             File.WriteAllText(OutputFile, sb.ToString());
diff --git a/src/tests/BuildWasmApps/Wasm.Build.Tests/BuildTestBase.cs b/src/tests/BuildWasmApps/Wasm.Build.Tests/BuildTestBase.cs
index b5f1f7e0b95f73..b87ff5c70bfc24 100644
--- a/src/tests/BuildWasmApps/Wasm.Build.Tests/BuildTestBase.cs
+++ b/src/tests/BuildWasmApps/Wasm.Build.Tests/BuildTestBase.cs
@@ -8,9 +8,11 @@
 using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using System.Linq;
+using System.Reflection;
 using System.Text;
 using Xunit;
 using Xunit.Abstractions;
+using Xunit.Sdk;
 
 #nullable enable
 
@@ -29,7 +31,6 @@ public abstract class BuildTestBase : IClassFixture<SharedBuildPerTestClassFixtu
         protected static readonly string s_emsdkPath;
         protected static readonly bool s_skipProjectCleanup;
         protected static readonly string s_xharnessRunnerCommand;
-
         protected string? _projectDir;
         protected readonly ITestOutputHelper _testOutput;
         protected string _logPath;
@@ -139,10 +140,17 @@ public BuildTestBase(ITestOutputHelper output, SharedBuildPerTestClassFixture bu
                     .WithRunHosts(host)
                     .UnwrapItemsAsArrays();
 
-        protected void RunAndTestWasmApp(BuildArgs buildArgs, RunHost host, string id, Action<string> test, string? buildDir=null, int expectedExitCode=0, string? args=null)
+        protected string RunAndTestWasmApp(BuildArgs buildArgs,
+                                           RunHost host,
+                                           string id,
+                                           Action<string>? test=null,
+                                           string? buildDir = null,
+                                           int expectedExitCode = 0,
+                                           string? args = null,
+                                           Dictionary<string, string>? envVars = null)
         {
             buildDir ??= _projectDir;
-            Dictionary<string, string>? envVars = new();
+            envVars ??= new();
             envVars["XHARNESS_DISABLE_COLORED_OUTPUT"] = "true";
             if (buildArgs.AOT)
             {
@@ -180,6 +188,11 @@ protected void RunAndTestWasmApp(BuildArgs buildArgs, RunHost host, string id, A
                 Assert.DoesNotContain("AOT: image 'System.Private.CoreLib' found.", output);
                 Assert.DoesNotContain($"AOT: image '{buildArgs.ProjectName}' found.", output);
             }
+
+            if (test != null)
+                test(output);
+
+            return output;
         }
 
         protected static string RunWithXHarness(string testCommand, string testLogPath, string projectName, string bundleDir,
@@ -209,6 +222,8 @@ protected static string RunWithXHarness(string testCommand, string testLogPath,
             args.Append($" --run {projectName}.dll");
             args.Append($" {appArgs ?? string.Empty}");
 
+            _testOutput.WriteLine(string.Empty);
+            _testOutput.WriteLine($"---------- Running with {testCommand} ---------");
             var (exitCode, output) = RunProcess("dotnet", _testOutput,
                                         args: args.ToString(),
                                         workingDir: bundleDir,
@@ -251,14 +266,21 @@ protected static void InitProjectDir(string dir)
                 <WasmMainJSPath>runtime-test.js</WasmMainJSPath>
                 ##EXTRA_PROPERTIES##
               </PropertyGroup>
+              <ItemGroup>
+                ##EXTRA_ITEMS##
+              </ItemGroup>
+              ##INSERT_AT_END##
             </Project>";
 
-        protected static BuildArgs GetBuildArgsWith(BuildArgs buildArgs, string? extraProperties=null, string projectTemplate=SimpleProjectTemplate)
+        protected static BuildArgs ExpandBuildArgs(BuildArgs buildArgs, string extraProperties="", string extraItems="", string insertAtEnd="", string projectTemplate=SimpleProjectTemplate)
         {
             if (buildArgs.AOT)
-                extraProperties = $"{extraProperties}\n<RunAOTCompilation>true</RunAOTCompilation>\n";
+                extraProperties = $"{extraProperties}\n<RunAOTCompilation>true</RunAOTCompilation>\n<EmccVerbose>false</EmccVerbose>\n";
 
-            string projectContents = projectTemplate.Replace("##EXTRA_PROPERTIES##", extraProperties ?? string.Empty);
+            string projectContents = projectTemplate
+                                        .Replace("##EXTRA_PROPERTIES##", extraProperties)
+                                        .Replace("##EXTRA_ITEMS##", extraItems)
+                                        .Replace("##INSERT_AT_END##", insertAtEnd);
             return buildArgs with { ProjectFileContents = projectContents };
         }
 
@@ -273,10 +295,10 @@ protected static BuildArgs GetBuildArgsWith(BuildArgs buildArgs, string? extraPr
         {
             if (useCache && _buildContext.TryGetBuildFor(buildArgs, out BuildProduct? product))
             {
-                Console.WriteLine ($"Using existing build found at {product.BuildPath}, with build log at {product.LogFile}");
+                Console.WriteLine ($"Using existing build found at {product.ProjectDir}, with build log at {product.LogFile}");
 
-                Assert.True(product.Result, $"Found existing build at {product.BuildPath}, but it had failed. Check build log at {product.LogFile}");
-                _projectDir = product.BuildPath;
+                Assert.True(product.Result, $"Found existing build at {product.ProjectDir}, but it had failed. Check build log at {product.LogFile}");
+                _projectDir = product.ProjectDir;
 
                 // use this test's id for the run logs
                 _logPath = Path.Combine(s_logRoot, id);
@@ -297,7 +319,6 @@ protected static BuildArgs GetBuildArgsWith(BuildArgs buildArgs, string? extraPr
                 throw new Exception("_projectDir should be set, to use createProject=false");
             }
 
-
             StringBuilder sb = new();
             sb.Append("publish");
             sb.Append(s_defaultBuildArgs);
@@ -305,6 +326,7 @@ protected static BuildArgs GetBuildArgsWith(BuildArgs buildArgs, string? extraPr
             sb.Append($" /p:Configuration={buildArgs.Config}");
 
             string logFilePath = Path.Combine(_logPath, $"{buildArgs.ProjectName}.binlog");
+            _testOutput.WriteLine($"-------- Building ---------");
             _testOutput.WriteLine($"Binlog path: {logFilePath}");
             sb.Append($" /bl:\"{logFilePath}\" /v:minimal /nologo");
             if (buildArgs.ExtraBuildArgs != null)
@@ -347,7 +369,7 @@ protected static void AssertBasicAppBundle(string bundleDir, string projectName,
                 "runtime.js",
                 "dotnet.timezones.blat",
                 "dotnet.wasm",
-                "mono-config.js",
+                "mono-config.json",
                 "dotnet.js",
                 "run-v8.sh"
             });
@@ -378,8 +400,14 @@ protected static void AssertDotNetWasmJs(string bundleDir, bool fromRuntimePack)
         {
             string nativeDir = GetRuntimeNativeDir();
 
-            AssertFile(Path.Combine(nativeDir, "dotnet.wasm"), Path.Combine(bundleDir, "dotnet.wasm"), "Expected dotnet.wasm to be same as the runtime pack", same: fromRuntimePack);
-            AssertFile(Path.Combine(nativeDir, "dotnet.js"), Path.Combine(bundleDir, "dotnet.js"), "Expected dotnet.js to be same as the runtime pack", same: fromRuntimePack);
+            AssertNativeFile("dotnet.wasm");
+            AssertNativeFile("dotnet.js");
+
+            void AssertNativeFile(string file)
+                => AssertFile(Path.Combine(nativeDir, file),
+                              Path.Combine(bundleDir, file),
+                              $"Expected {file} to be {(fromRuntimePack ? "the same as" : "different from")} the runtime pack",
+                              same: fromRuntimePack);
         }
 
         protected static void AssertFilesDontExist(string dir, string[] filenames, string? label = null)
@@ -464,6 +492,7 @@ public static (int exitCode, string buildOutput) RunProcess(string path,
             _testOutput.WriteLine($"Running {path} {args}");
             Console.WriteLine($"Running: {path}: {args}");
             Console.WriteLine($"WorkingDirectory: {workingDir}");
+            _testOutput.WriteLine($"WorkingDirectory: {workingDir}");
             StringBuilder outputBuilder = new ();
             var processStartInfo = new ProcessStartInfo
             {
@@ -584,7 +613,7 @@ public static int Main()
 
   <Target Name=""PrepareForWasmBuild"">
     <ItemGroup>
-      <WasmAssembliesToBundle Include=""$(TargetDir)publish\*.dll"" />
+      <WasmAssembliesToBundle Include=""$(TargetDir)publish\**\*.dll"" />
     </ItemGroup>
   </Target>
 
@@ -594,5 +623,5 @@ public static int Main()
     }
 
     public record BuildArgs(string ProjectName, string Config, bool AOT, string ProjectFileContents, string? ExtraBuildArgs);
-    public record BuildProduct(string BuildPath, string LogFile, bool Result);
+    public record BuildProduct(string ProjectDir, string LogFile, bool Result);
  }
diff --git a/src/tests/BuildWasmApps/Wasm.Build.Tests/InvariantGlobalizationTests.cs b/src/tests/BuildWasmApps/Wasm.Build.Tests/InvariantGlobalizationTests.cs
index 6d01f20a8420e8..753f8c40c2af7d 100644
--- a/src/tests/BuildWasmApps/Wasm.Build.Tests/InvariantGlobalizationTests.cs
+++ b/src/tests/BuildWasmApps/Wasm.Build.Tests/InvariantGlobalizationTests.cs
@@ -49,7 +49,7 @@ private void TestInvariantGlobalization(BuildArgs buildArgs, bool? invariantGlob
                 extraProperties = $"{extraProperties}<InvariantGlobalization>{invariantGlobalization}</InvariantGlobalization>";
 
             buildArgs = buildArgs with { ProjectName = projectName };
-            buildArgs = GetBuildArgsWith(buildArgs, extraProperties);
+            buildArgs = ExpandBuildArgs(buildArgs, extraProperties);
 
             if (dotnetWasmFromRuntimePack == null)
                 dotnetWasmFromRuntimePack = !(buildArgs.AOT || buildArgs.Config == "Release");
@@ -76,8 +76,8 @@ public static int Main()
                         hasIcudt: invariantGlobalization == null || invariantGlobalization.Value == false);
 
             string expectedOutputString = invariantGlobalization == true
-                                            ? "False - en (ES)"
-                                            : "True - Invariant Language (Invariant Country)";
+                                            ? "True - Invariant Language (Invariant Country)"
+                                            : "False - es (ES)";
             RunAndTestWasmApp(buildArgs, expectedExitCode: 42,
                                 test: output => Assert.Contains(expectedOutputString, output), host: host, id: id);
         }
diff --git a/src/tests/BuildWasmApps/Wasm.Build.Tests/MainWithArgsTests.cs b/src/tests/BuildWasmApps/Wasm.Build.Tests/MainWithArgsTests.cs
index df920577cea01b..b97a0490d2e872 100644
--- a/src/tests/BuildWasmApps/Wasm.Build.Tests/MainWithArgsTests.cs
+++ b/src/tests/BuildWasmApps/Wasm.Build.Tests/MainWithArgsTests.cs
@@ -77,7 +77,7 @@ void TestMainWithArgs(string projectNamePrefix,
             string programText = projectContents.Replace("##CODE##", code);
 
             buildArgs = buildArgs with { ProjectName = projectName, ProjectFileContents = programText };
-            buildArgs = GetBuildArgsWith(buildArgs);
+            buildArgs = ExpandBuildArgs(buildArgs);
             if (dotnetWasmFromRuntimePack == null)
                 dotnetWasmFromRuntimePack = !(buildArgs.AOT || buildArgs.Config == "Release");
 
diff --git a/src/tests/BuildWasmApps/Wasm.Build.Tests/NativeBuildTests.cs b/src/tests/BuildWasmApps/Wasm.Build.Tests/NativeBuildTests.cs
index da7b33d0a0c351..9f87757175c970 100644
--- a/src/tests/BuildWasmApps/Wasm.Build.Tests/NativeBuildTests.cs
+++ b/src/tests/BuildWasmApps/Wasm.Build.Tests/NativeBuildTests.cs
@@ -39,7 +39,7 @@ public void Relinking_ErrorWhenMissingEMSDK(BuildArgs buildArgs, string emsdkPat
                             ProjectName = projectName,
                             ExtraBuildArgs = $"/p:EMSDK_PATH={emsdkPath}"
             };
-            buildArgs = GetBuildArgsWith(buildArgs, extraProperties: "<WasmBuildNative>true</WasmBuildNative>");
+            buildArgs = ExpandBuildArgs(buildArgs, extraProperties: "<WasmBuildNative>true</WasmBuildNative>");
 
             (_, string buildOutput) = BuildProject(buildArgs,
                         initProject: () => File.WriteAllText(Path.Combine(_projectDir!, "Program.cs"), s_mainReturns42),
@@ -54,7 +54,7 @@ private void NativeBuild(string projectNamePrefix, string projectContents, Build
             string projectName = $"{projectNamePrefix}_{buildArgs.Config}_{buildArgs.AOT}";
 
             buildArgs = buildArgs with { ProjectName = projectName, ProjectFileContents = projectContents };
-            buildArgs = GetBuildArgsWith(buildArgs, extraProperties: "<WasmBuildNative>true</WasmBuildNative>");
+            buildArgs = ExpandBuildArgs(buildArgs, extraProperties: "<WasmBuildNative>true</WasmBuildNative>");
             Console.WriteLine ($"-- args: {buildArgs}, name: {projectName}");
 
             BuildProject(buildArgs,
diff --git a/src/tests/BuildWasmApps/Wasm.Build.Tests/RebuildTests.cs b/src/tests/BuildWasmApps/Wasm.Build.Tests/RebuildTests.cs
index aebaa43ba5d97d..ecbcbdd75c05c2 100644
--- a/src/tests/BuildWasmApps/Wasm.Build.Tests/RebuildTests.cs
+++ b/src/tests/BuildWasmApps/Wasm.Build.Tests/RebuildTests.cs
@@ -27,7 +27,7 @@ public void NoOpRebuild(BuildArgs buildArgs, bool nativeRelink, RunHost host, st
             bool dotnetWasmFromRuntimePack = !nativeRelink && !buildArgs.AOT;
 
             buildArgs = buildArgs with { ProjectName = projectName };
-            buildArgs = GetBuildArgsWith(buildArgs, $"<WasmBuildNative>{(nativeRelink ? "true" : "false")}</WasmBuildNative>");
+            buildArgs = ExpandBuildArgs(buildArgs, $"<WasmBuildNative>{(nativeRelink ? "true" : "false")}</WasmBuildNative>");
 
             BuildProject(buildArgs,
                         initProject: () => File.WriteAllText(Path.Combine(_projectDir!, "Program.cs"), s_mainReturns42),
diff --git a/src/tests/BuildWasmApps/Wasm.Build.Tests/SatelliteAssembliesTests.cs b/src/tests/BuildWasmApps/Wasm.Build.Tests/SatelliteAssembliesTests.cs
new file mode 100644
index 00000000000000..e9d973650dcae6
--- /dev/null
+++ b/src/tests/BuildWasmApps/Wasm.Build.Tests/SatelliteAssembliesTests.cs
@@ -0,0 +1,179 @@
+// 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.IO;
+using System.Linq;
+using Xunit;
+using Xunit.Abstractions;
+
+#nullable enable
+
+namespace Wasm.Build.Tests
+{
+    public class SatelliteAssembliesTests : BuildTestBase
+    {
+        public SatelliteAssembliesTests(ITestOutputHelper output, SharedBuildPerTestClassFixture buildContext)
+            : base(output, buildContext)
+        {
+        }
+
+        public static IEnumerable<object?[]> SatelliteAssemblyTestData(bool aot, bool relinking, RunHost host)
+            => ConfigWithAOTData(aot)
+                    .Multiply(
+                        new object?[] { relinking, "es-ES", "got: hola" },
+                        new object?[] { relinking, null,    "got: hello" },
+                        new object?[] { relinking, "ja-JP", "got: \u3053\u3093\u306B\u3061\u306F" })
+                    .WithRunHosts(host)
+                    .UnwrapItemsAsArrays();
+
+        [Theory]
+        [MemberData(nameof(SatelliteAssemblyTestData), parameters: new object[] { /*aot*/ false, /*relinking*/ false, RunHost.All })]
+        [MemberData(nameof(SatelliteAssemblyTestData), parameters: new object[] { /*aot*/ false, /*relinking*/ true,  RunHost.All })]
+        [MemberData(nameof(SatelliteAssemblyTestData), parameters: new object[] { /*aot*/ true,  /*relinking*/ false, RunHost.All })]
+        public void ResourcesFromMainAssembly(BuildArgs buildArgs,
+                                              bool nativeRelink,
+                                              string? argCulture,
+                                              string expectedOutput,
+                                              RunHost host,
+                                              string id)
+        {
+            string projectName = $"sat_asm_from_main_asm";
+            bool dotnetWasmFromRuntimePack = !nativeRelink && !buildArgs.AOT;
+
+            buildArgs = buildArgs with { ProjectName = projectName };
+            buildArgs = ExpandBuildArgs(buildArgs,
+                                        projectTemplate: s_resourcesProjectTemplate,
+                                        extraProperties: $"<WasmBuildNative>{(nativeRelink ? "true" : "false")}</WasmBuildNative>",
+                                        extraItems: $"<EmbeddedResource Include=\"..\\resx\\*\" />");
+
+            BuildProject(buildArgs,
+                        initProject: () => CreateProgramForCultureTest($"{projectName}.words", "TestClass"),
+                        dotnetWasmFromRuntimePack: dotnetWasmFromRuntimePack,
+                        id: id);
+
+            string output = RunAndTestWasmApp(
+                                buildArgs, expectedExitCode: 42,
+                                args: argCulture,
+                                host: host, id: id);
+
+            Assert.Contains(expectedOutput, output);
+        }
+
+        [Theory]
+        [MemberData(nameof(SatelliteAssemblyTestData), parameters: new object[] { /*aot*/ false, /*relinking*/ false, RunHost.All })]
+        [MemberData(nameof(SatelliteAssemblyTestData), parameters: new object[] { /*aot*/ false, /*relinking*/ true,  RunHost.All })]
+        [MemberData(nameof(SatelliteAssemblyTestData), parameters: new object[] { /*aot*/ true,  /*relinking*/ false, RunHost.All })]
+        public void ResourcesFromProjectReference(BuildArgs buildArgs,
+                                                  bool nativeRelink,
+                                                  string? argCulture,
+                                                  string expectedOutput,
+                                                  RunHost host,
+                                                  string id)
+        {
+            string projectName = $"sat_asm_proj_ref";
+            bool dotnetWasmFromRuntimePack = !nativeRelink && !buildArgs.AOT;
+
+            buildArgs = buildArgs with { ProjectName = projectName };
+            buildArgs = ExpandBuildArgs(buildArgs,
+                                        projectTemplate: s_resourcesProjectTemplate,
+                                        extraProperties: $"<WasmBuildNative>{(nativeRelink ? "true" : "false")}</WasmBuildNative>",
+                                        extraItems: $"<ProjectReference Include=\"..\\LibraryWithResources\\LibraryWithResources.csproj\" />");
+
+            BuildProject(buildArgs,
+                        initProject: () => CreateProgramForCultureTest("LibraryWithResources.words", "LibraryWithResources.Class1"),
+                        dotnetWasmFromRuntimePack: dotnetWasmFromRuntimePack,
+                        id: id);
+
+            string output = RunAndTestWasmApp(buildArgs,
+                                              expectedExitCode: 42,
+                                              args: argCulture,
+                                              host: host, id: id);
+
+            Assert.Contains(expectedOutput, output);
+        }
+
+#pragma warning disable xUnit1026
+        [Theory]
+        [BuildAndRun(host: RunHost.None, aot: true)]
+        public void CheckThatSatelliteAssembliesAreNotAOTed(BuildArgs buildArgs, string id)
+        {
+            string projectName = $"check_sat_asm_not_aot";
+            buildArgs = buildArgs with { ProjectName = projectName };
+            buildArgs = ExpandBuildArgs(buildArgs,
+                                        projectTemplate: s_resourcesProjectTemplate,
+                                        extraProperties: $@"
+                                            <EmccCompileOptimizationFlag>-O0</EmccCompileOptimizationFlag>
+                                            <EmccLinkOptimizationFlag>-O0</EmccLinkOptimizationFlag>",
+                                        extraItems: $"<EmbeddedResource Include=\"..\\resx\\*\" />");
+
+            System.Console.WriteLine ($"--- aot: {buildArgs.AOT}");
+            BuildProject(buildArgs,
+                        initProject: () => CreateProgramForCultureTest($"{projectName}.words", "TestClass"),
+                        dotnetWasmFromRuntimePack: false,
+                        id: id);
+
+            var bitCodeFileNames = Directory.GetFileSystemEntries(Path.Combine(_projectDir!, "obj"), "*.dll.bc", SearchOption.AllDirectories)
+                                    .Select(path => Path.GetFileName(path))
+                                    .ToArray();
+
+            // sanity check, in case we change file extensions
+            Assert.Contains($"{projectName}.dll.bc", bitCodeFileNames);
+
+            Assert.Empty(bitCodeFileNames.Where(file => file.EndsWith(".resources.dll.bc")));
+        }
+#pragma warning restore xUnit1026
+
+        private void CreateProgramForCultureTest(string resourceName, string typeName)
+            => File.WriteAllText(Path.Combine(_projectDir!, "Program.cs"),
+                                s_cultureResourceTestProgram
+                                    .Replace("##RESOURCE_NAME##", resourceName)
+                                    .Replace("##TYPE_NAME##", typeName));
+
+        private const string s_resourcesProjectTemplate =
+            @$"<Project Sdk=""Microsoft.NET.Sdk"">
+              <PropertyGroup>
+                <TargetFramework>{s_targetFramework}</TargetFramework>
+                <OutputType>Exe</OutputType>
+                <WasmGenerateRunV8Script>true</WasmGenerateRunV8Script>
+                <WasmMainJSPath>runtime-test.js</WasmMainJSPath>
+                ##EXTRA_PROPERTIES##
+              </PropertyGroup>
+              <ItemGroup>
+                ##EXTRA_ITEMS##
+              </ItemGroup>
+              ##INSERT_AT_END##
+            </Project>";
+
+        private static string s_cultureResourceTestProgram = @"
+using System;
+using System.Runtime.CompilerServices;
+using System.Globalization;
+using System.Resources;
+using System.Threading;
+
+namespace ResourcesTest
+{
+    public class TestClass
+    {
+        public static int Main(string[] args)
+        {
+            if (args.Length == 1)
+            {
+                string cultureToTest = args[0];
+                var newCulture = new CultureInfo(cultureToTest);
+                Thread.CurrentThread.CurrentCulture = newCulture;
+                Thread.CurrentThread.CurrentUICulture = newCulture;
+            }
+
+            var currentCultureName = Thread.CurrentThread.CurrentCulture.Name;
+
+            var rm = new ResourceManager(""##RESOURCE_NAME##"", typeof(##TYPE_NAME##).Assembly);
+            Console.WriteLine($""For '{currentCultureName}' got: {rm.GetString(""hello"")}"");
+
+            return 42;
+        }
+    }
+}";
+    }
+}
diff --git a/src/tests/BuildWasmApps/Wasm.Build.Tests/SharedBuildPerTestClassFixture.cs b/src/tests/BuildWasmApps/Wasm.Build.Tests/SharedBuildPerTestClassFixture.cs
index a491d972af28c5..e84a151bd5b02d 100644
--- a/src/tests/BuildWasmApps/Wasm.Build.Tests/SharedBuildPerTestClassFixture.cs
+++ b/src/tests/BuildWasmApps/Wasm.Build.Tests/SharedBuildPerTestClassFixture.cs
@@ -20,7 +20,7 @@ public void CacheBuild(BuildArgs buildArgs, BuildProduct product)
 
         public void RemoveFromCache(string buildPath)
         {
-            KeyValuePair<BuildArgs, BuildProduct>? foundKvp = _buildPaths.Where(kvp => kvp.Value.BuildPath == buildPath).SingleOrDefault();
+            KeyValuePair<BuildArgs, BuildProduct>? foundKvp = _buildPaths.Where(kvp => kvp.Value.ProjectDir == buildPath).SingleOrDefault();
             if (foundKvp == null)
                 throw new Exception($"Could not find build path {buildPath} in cache to remove.");
 
@@ -36,7 +36,7 @@ public void Dispose()
             Console.WriteLine ($"============== DELETING THE BUILDS =============");
             foreach (var kvp in _buildPaths.Values)
             {
-                RemoveDirectory(kvp.BuildPath);
+                RemoveDirectory(kvp.ProjectDir);
             }
         }
 
diff --git a/src/tests/BuildWasmApps/Wasm.Build.Tests/Wasm.Build.Tests.csproj b/src/tests/BuildWasmApps/Wasm.Build.Tests/Wasm.Build.Tests.csproj
index 9ed56506d799fd..20a1972430746f 100644
--- a/src/tests/BuildWasmApps/Wasm.Build.Tests/Wasm.Build.Tests.csproj
+++ b/src/tests/BuildWasmApps/Wasm.Build.Tests/Wasm.Build.Tests.csproj
@@ -9,6 +9,7 @@
     <TestFramework>xunit</TestFramework>
     <WasmGenerateAppBundle>false</WasmGenerateAppBundle>
     <EnableDefaultItems>true</EnableDefaultItems>
+    <EnableDefaultEmbeddedResourceItems>false</EnableDefaultEmbeddedResourceItems>
     <DefineConstants Condition="'$(ContinuousIntegrationBuild)' != 'true'">TEST_DEBUG_CONFIG_ALSO</DefineConstants>
     <!-- This project should not build against the live built .NETCoreApp targeting pack as it contributes to the build itself. -->
     <UseLocalTargetingRuntimePack>false</UseLocalTargetingRuntimePack>
@@ -20,8 +21,6 @@
   <PropertyGroup Condition="'$(ContinuousIntegrationBuild)' == 'true'">
     <_PreCommand Condition="'$(OS)' != 'Windows_NT'">WasmBuildSupportDir=%24{HELIX_CORRELATION_PAYLOAD}/build</_PreCommand>
     <_PreCommand Condition="'$(OS)' == 'Windows_NT'">set WasmBuildSupportDir=%HELIX_CORRELATION_PAYLOAD%/build &amp;</_PreCommand>
-    <_PreCommand Condition="'$(OS)' != 'Windows_NT'">$(_PreCommand) DOTNET_SYSTEM_GLOBALIZATION_INVARIANT=1</_PreCommand>
-    <_PreCommand Condition="'$(OS)' == 'Windows_NT'">$(_PreCommand) set DOTNET_SYSTEM_GLOBALIZATION_INVARIANT=1 &amp;</_PreCommand>
   </PropertyGroup>
 
   <PropertyGroup>
@@ -38,5 +37,7 @@
 
   <ItemGroup>
     <None Include="$(RepoRoot)\src\mono\wasm\runtime-test.js" CopyToOutputDirectory="PreserveNewest" />
+
+    <None Include="..\testassets\**\*" CopyToOutputDirectory="PreserveNewest" />
   </ItemGroup>
 </Project>
diff --git a/src/tests/BuildWasmApps/Wasm.Build.Tests/WasmBuildAppTest.cs b/src/tests/BuildWasmApps/Wasm.Build.Tests/WasmBuildAppTest.cs
index 3778d1fcdaae30..e426c9523d9f79 100644
--- a/src/tests/BuildWasmApps/Wasm.Build.Tests/WasmBuildAppTest.cs
+++ b/src/tests/BuildWasmApps/Wasm.Build.Tests/WasmBuildAppTest.cs
@@ -72,7 +72,7 @@ public void AOT_ErrorWhenMissingEMSDK(BuildArgs buildArgs, string emsdkPath, str
                             ProjectName = projectName,
                             ExtraBuildArgs = $"/p:EMSDK_PATH={emsdkPath}"
             };
-            buildArgs = GetBuildArgsWith(buildArgs);
+            buildArgs = ExpandBuildArgs(buildArgs);
 
             (_, string buildOutput) = BuildProject(buildArgs,
                         initProject: () => File.WriteAllText(Path.Combine(_projectDir!, "Program.cs"), s_mainReturns42),
@@ -88,6 +88,9 @@ public class TestClass {
                 public static int Main()
                 {
                     Console.WriteLine($""tc: {Environment.TickCount}, tc64: {Environment.TickCount64}"");
+
+                    // if this gets printed, then we didn't crash!
+                    Console.WriteLine(""Hello, World!"");
                     return 42;
                 }
             }";
@@ -109,11 +112,11 @@ void TestMain(string projectName,
                       BuildArgs buildArgs,
                       RunHost host,
                       string id,
-                      string? extraProperties = null,
+                      string extraProperties = "",
                       bool? dotnetWasmFromRuntimePack = null)
         {
             buildArgs = buildArgs with { ProjectName = projectName };
-            buildArgs = GetBuildArgsWith(buildArgs, extraProperties);
+            buildArgs = ExpandBuildArgs(buildArgs, extraProperties);
 
             if (dotnetWasmFromRuntimePack == null)
                 dotnetWasmFromRuntimePack = !(buildArgs.AOT || buildArgs.Config == "Release");
diff --git a/src/tests/BuildWasmApps/testassets/LibraryWithResources/Class1.cs b/src/tests/BuildWasmApps/testassets/LibraryWithResources/Class1.cs
new file mode 100644
index 00000000000000..4674bfd7d0b342
--- /dev/null
+++ b/src/tests/BuildWasmApps/testassets/LibraryWithResources/Class1.cs
@@ -0,0 +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;
+
+namespace LibraryWithResources
+{
+    public class Class1
+    {
+    }
+}
diff --git a/src/tests/BuildWasmApps/testassets/LibraryWithResources/Directory.Build.props b/src/tests/BuildWasmApps/testassets/LibraryWithResources/Directory.Build.props
new file mode 100644
index 00000000000000..058246e4086204
--- /dev/null
+++ b/src/tests/BuildWasmApps/testassets/LibraryWithResources/Directory.Build.props
@@ -0,0 +1 @@
+<Project />
diff --git a/src/tests/BuildWasmApps/testassets/LibraryWithResources/Directory.Build.targets b/src/tests/BuildWasmApps/testassets/LibraryWithResources/Directory.Build.targets
new file mode 100644
index 00000000000000..058246e4086204
--- /dev/null
+++ b/src/tests/BuildWasmApps/testassets/LibraryWithResources/Directory.Build.targets
@@ -0,0 +1 @@
+<Project />
diff --git a/src/tests/BuildWasmApps/testassets/LibraryWithResources/LibraryWithResources.csproj b/src/tests/BuildWasmApps/testassets/LibraryWithResources/LibraryWithResources.csproj
new file mode 100644
index 00000000000000..91961dd7d6b422
--- /dev/null
+++ b/src/tests/BuildWasmApps/testassets/LibraryWithResources/LibraryWithResources.csproj
@@ -0,0 +1,10 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net5.0</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <EmbeddedResource Include="..\resx\*" />
+  </ItemGroup>
+</Project>
diff --git a/src/tests/BuildWasmApps/testassets/resx/words.es-ES.resx b/src/tests/BuildWasmApps/testassets/resx/words.es-ES.resx
new file mode 100644
index 00000000000000..775397b15a2b9f
--- /dev/null
+++ b/src/tests/BuildWasmApps/testassets/resx/words.es-ES.resx
@@ -0,0 +1,127 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    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
+            : and then encoded with base64 encoding.
+    -->
+  <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">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <data name="bye" xml:space="preserve">
+    <value>ciao</value>
+  </data>
+  <assembly alias="System.Windows.Forms" name="System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
+  <data name="hello" xml:space="preserve">
+    <value>hola</value>
+  </data>
+</root>
diff --git a/src/tests/BuildWasmApps/testassets/resx/words.ja-JP.resx b/src/tests/BuildWasmApps/testassets/resx/words.ja-JP.resx
new file mode 100644
index 00000000000000..c843811244c256
--- /dev/null
+++ b/src/tests/BuildWasmApps/testassets/resx/words.ja-JP.resx
@@ -0,0 +1,127 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    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
+            : and then encoded with base64 encoding.
+    -->
+  <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">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <data name="bye" xml:space="preserve">
+    <value>さようなら</value>
+  </data>
+  <assembly alias="System.Windows.Forms" name="System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
+  <data name="hello" xml:space="preserve">
+    <value>こんにちは</value>
+  </data>
+</root>
diff --git a/src/tests/BuildWasmApps/testassets/resx/words.resx b/src/tests/BuildWasmApps/testassets/resx/words.resx
new file mode 100644
index 00000000000000..c3d5a787420866
--- /dev/null
+++ b/src/tests/BuildWasmApps/testassets/resx/words.resx
@@ -0,0 +1,127 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    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
+            : and then encoded with base64 encoding.
+    -->
+  <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">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <data name="bye" xml:space="preserve">
+    <value>bye</value>
+  </data>
+  <assembly alias="System.Windows.Forms" name="System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
+  <data name="hello" xml:space="preserve">
+    <value>hello</value>
+  </data>
+</root>
diff --git a/src/tests/Common/CLRTest.CrossGen.targets b/src/tests/Common/CLRTest.CrossGen.targets
index 244377228d2078..a5b98a2e45a5ac 100644
--- a/src/tests/Common/CLRTest.CrossGen.targets
+++ b/src/tests/Common/CLRTest.CrossGen.targets
@@ -37,7 +37,7 @@ WARNING:   When setting properties based on their current state (for example:
         <![CDATA[
 
 if [ "$(AlwaysUseCrossGen2)" == "true" ]; then
-    export RunCrossGen=
+    unset RunCrossGen
     export RunCrossGen2=1
     export CompositeBuildMode=1
 fi
diff --git a/src/tests/Common/CLRTest.Execute.Bash.targets b/src/tests/Common/CLRTest.Execute.Bash.targets
index 9b71d716404508..cb28cbfac5e5a1 100644
--- a/src/tests/Common/CLRTest.Execute.Bash.targets
+++ b/src/tests/Common/CLRTest.Execute.Bash.targets
@@ -325,8 +325,6 @@ if [ ! -z ${RunCrossGen+x} ]%3B then
   TakeLock
 fi
 
-export MONO_ENV_OPTIONS=--llvm
-
 echo $LAUNCHER $ExePath %24(printf "'%s' " "${CLRTestExecutionArguments[@]}")
 $LAUNCHER $ExePath "${CLRTestExecutionArguments[@]}"
 
@@ -363,7 +361,7 @@ else
 	HARNESS_RUNNER="xharness"
 fi
 
-$__Command $HARNESS_RUNNER android test --instrumentation="net.dot.MonoRunner" --package-name="net.dot.$__Category" --app="$__TestBinaryBase/$__Category.apk" --output-directory=`$HELIX_WORKITEM_UPLOAD_ROOT` --arg=entrypoint:libname=$(MsBuildProjectName).dll --expected-exit-code=100 -v
+$__Command $HARNESS_RUNNER android run --instrumentation="net.dot.MonoRunner" --package-name="net.dot.$__Category" --app="$__TestBinaryBase/$__Category.apk" --output-directory="$__OutputDir" --arg=entrypoint:libname=$(MsBuildProjectName).dll --expected-exit-code=100 -v
 CLRTestExitCode=$?
 
 # Exist code of xharness is zero when tests finished successfully
diff --git a/src/tests/Common/CLRTest.Execute.Batch.targets b/src/tests/Common/CLRTest.Execute.Batch.targets
index 8653cb2669a167..bdebae3acdadf7 100644
--- a/src/tests/Common/CLRTest.Execute.Batch.targets
+++ b/src/tests/Common/CLRTest.Execute.Batch.targets
@@ -329,7 +329,7 @@ IF NOT "%XHARNESS_CLI_PATH%"=="" (
   set HARNESS_RUNNER=xharness
 )
 
-%__Command% %HARNESS_RUNNER% android test --instrumentation="net.dot.MonoRunner" --package-name="net.dot.%__Category%" --app="%__TestBinaryBase%\%__Category%.apk" --output-directory="%HELIX_WORKITEM_UPLOAD_ROOT%" --arg=entrypoint:libname=$(MsBuildProjectName).dll --expected-exit-code=100 -v
+%__Command% %HARNESS_RUNNER% android run --instrumentation="net.dot.MonoRunner" --package-name="net.dot.%__Category%" --app="%__TestBinaryBase%\%__Category%.apk" --output-directory="%__OutputDir%" --arg=entrypoint:libname=$(MsBuildProjectName).dll --expected-exit-code=100 -v
 set CLRTestExitCode=!ERRORLEVEL!
 set CLRTestExpectedExitCode=0
     ]]></BatchCLRTestLaunchCmds>
diff --git a/src/tests/Common/Coreclr.TestWrapper/Coreclr.TestWrapper.csproj b/src/tests/Common/Coreclr.TestWrapper/Coreclr.TestWrapper.csproj
index 457206e7b404c5..9e76cb9c5fafea 100644
--- a/src/tests/Common/Coreclr.TestWrapper/Coreclr.TestWrapper.csproj
+++ b/src/tests/Common/Coreclr.TestWrapper/Coreclr.TestWrapper.csproj
@@ -9,6 +9,7 @@
 
   <ItemGroup>
     <Compile Include="CoreclrTestWrapperLib.cs" />
+    <Compile Include="MobileAppHandler.cs" />
   </ItemGroup>
 
 </Project>
diff --git a/src/tests/Common/Coreclr.TestWrapper/CoreclrTestWrapperLib.cs b/src/tests/Common/Coreclr.TestWrapper/CoreclrTestWrapperLib.cs
index 074eb1a2df3c99..da13ad2492e676 100644
--- a/src/tests/Common/Coreclr.TestWrapper/CoreclrTestWrapperLib.cs
+++ b/src/tests/Common/Coreclr.TestWrapper/CoreclrTestWrapperLib.cs
@@ -284,7 +284,7 @@ static unsafe IEnumerable<Process> FindChildProcessesByName(Process process, str
             return children;
         }
 
-        public int RunTest(string executable, string outputFile, string errorFile, string category, string testBinaryBase)
+        public int RunTest(string executable, string outputFile, string errorFile, string category, string testBinaryBase, string outputDir)
         {
             Debug.Assert(outputFile != errorFile);
 
@@ -321,6 +321,7 @@ public int RunTest(string executable, string outputFile, string errorFile, strin
                 process.StartInfo.RedirectStandardError = true;
                 process.StartInfo.EnvironmentVariables.Add("__Category", category);
                 process.StartInfo.EnvironmentVariables.Add("__TestBinaryBase", testBinaryBase);
+                process.StartInfo.EnvironmentVariables.Add("__OutputDir", outputDir);
 
                 DateTime startTime = DateTime.Now;
                 process.Start();
diff --git a/src/tests/Common/Coreclr.TestWrapper/MobileAppHandler.cs b/src/tests/Common/Coreclr.TestWrapper/MobileAppHandler.cs
new file mode 100644
index 00000000000000..b712246c6f3405
--- /dev/null
+++ b/src/tests/Common/Coreclr.TestWrapper/MobileAppHandler.cs
@@ -0,0 +1,137 @@
+using System;
+using System.IO;
+using System.Diagnostics;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CoreclrTestLib
+{
+    public class MobileAppHandler
+    {
+        public void InstallMobileApp(string platform, string category, string testBinaryBase, string reportBase)
+        {
+            HandleMobileApp("install", platform, category, testBinaryBase, reportBase);
+        }
+
+        public void UninstallMobileApp(string platform, string category, string testBinaryBase, string reportBase)
+        {
+            HandleMobileApp("uninstall", platform, category, testBinaryBase, reportBase);
+        }
+
+        private static void HandleMobileApp(string action, string platform, string category, string testBinaryBase, string reportBase)
+        {
+            //install or uninstall mobile app
+            string outputFile = Path.Combine(reportBase, action, $"{category}_{action}.output.txt");
+            string errorFile = Path.Combine(reportBase, action, $"{category}_{action}.error.txt");
+            string dotnetCmd_raw = System.Environment.GetEnvironmentVariable("__TestDotNetCmd");
+            string dotnetCmd;
+            string xharnessCmd_raw = System.Environment.GetEnvironmentVariable("XHARNESS_CLI_PATH");
+            string xharnessCmd;
+            string cmdStr;
+            string appExtension;
+            int timeout = 600000; // Set timeout to 4 mins, because the installation on Android arm64/32 devices could take up to 10 mins on CI
+
+            if(String.IsNullOrEmpty(dotnetCmd_raw))
+            {
+                dotnetCmd = "dotnet";
+            }
+            else
+            {
+                dotnetCmd = dotnetCmd_raw;
+            }
+
+            if(String.IsNullOrEmpty(xharnessCmd_raw))
+            {
+                xharnessCmd = "xharness";
+            }
+            else
+            {
+                xharnessCmd = $"exec {xharnessCmd_raw}";
+            }
+
+            if(platform == "android")
+            {
+                appExtension = "apk";
+            }
+            else
+            {
+                appExtension = "app";
+            }
+
+            cmdStr = $"{dotnetCmd} {xharnessCmd} {platform} {action} --package-name=net.dot.{category} --app={testBinaryBase}/{category}.{appExtension} --output-directory={reportBase}/install";
+
+            Directory.CreateDirectory(Path.Combine(reportBase, action));
+            var outputStream = new FileStream(outputFile, FileMode.Create);
+            var errorStream = new FileStream(errorFile, FileMode.Create);
+
+            using (var outputWriter = new StreamWriter(outputStream))
+            using (var errorWriter = new StreamWriter(errorStream))
+            using (Process process = new Process())
+            {
+                if (OperatingSystem.IsWindows())
+                {
+                    process.StartInfo.FileName = "cmd.exe";
+                }
+                else
+                {
+                    process.StartInfo.FileName = "/bin/bash";
+                }
+
+                process.StartInfo.Arguments = ConvertCmd2Arg(cmdStr);
+                process.StartInfo.UseShellExecute = false;
+                process.StartInfo.RedirectStandardOutput = true;
+                process.StartInfo.RedirectStandardError = true;
+
+                DateTime startTime = DateTime.Now;
+                process.Start();
+
+                var cts = new CancellationTokenSource();
+                Task copyOutput = process.StandardOutput.BaseStream.CopyToAsync(outputStream, 4096, cts.Token);
+                Task copyError = process.StandardError.BaseStream.CopyToAsync(errorStream, 4096, cts.Token);
+
+                if (process.WaitForExit(timeout))
+                {
+                    Task.WaitAll(copyOutput, copyError);
+                }
+                else
+                {
+                    //Time out
+                    DateTime endTime = DateTime.Now;
+
+                    try
+                    {
+                        cts.Cancel();
+                    }
+                    catch {}
+
+                    outputWriter.WriteLine("\ncmdLine:{0} Timed Out (timeout in milliseconds: {1}, start: {2}, end: {3})",
+                            cmdStr, timeout, startTime.ToString(), endTime.ToString());
+                    errorWriter.WriteLine("\ncmdLine:{0} Timed Out (timeout in milliseconds: {1}, start: {2}, end: {3})",
+                            cmdStr, timeout, startTime.ToString(), endTime.ToString());
+                    
+                    process.Kill(entireProcessTree: true);
+                }
+
+                outputWriter.Flush();
+                errorWriter.Flush();
+            }
+        }
+
+        private static string ConvertCmd2Arg(string cmd)
+        {
+            cmd.Replace("\"", "\"\"");
+
+            string cmdPrefix;
+            if(OperatingSystem.IsWindows())
+            {
+                cmdPrefix = "/c";
+            }
+            else
+            {
+                cmdPrefix = "-c";
+            }
+            
+            return $"{cmdPrefix} \"{cmd}\"";
+        }
+    }
+}
diff --git a/src/tests/Common/helixpublishwitharcade.proj b/src/tests/Common/helixpublishwitharcade.proj
index 2fb397b3d92c15..b98bd8e8289b17 100644
--- a/src/tests/Common/helixpublishwitharcade.proj
+++ b/src/tests/Common/helixpublishwitharcade.proj
@@ -39,7 +39,7 @@
         PALTestsDir=$(_PALTestsDir)
       </_PropertiesToPass>
 
-      
+
       <_PropertiesToPass Condition="'$(TargetOS)' == 'Browser' Or '$(TargetOS)' == 'Android'">
         $(_PropertiesToPass);
         IncludeDotNetCli=$(IncludeDotNetCli);
@@ -47,7 +47,7 @@
         DotNetCliPackageType=$(DotNetCliPackageType);
         DotNetCliVersion=$(DotNetCliVersion)
       </_PropertiesToPass>
-    </PropertyGroup>  
+    </PropertyGroup>
     <Message Text="DotNetCliVersion: $(DotNetCliVersion)" Importance="High" />
     <Message Text="DotNetCliPackageType: $(DotNetCliPackageType)" Importance="High" />
     <Message Text="HelixRuntimeRid: $(HelixRuntimeRid)" Importance="High" />
@@ -95,7 +95,7 @@
     <IncludeDotNetCli>true</IncludeDotNetCli>
     <DotNetCliPackageType>runtime</DotNetCliPackageType>
     <DotNetCliVersion>$(BundledNETCoreAppPackageVersion)</DotNetCliVersion>
-    <DotNetCliRuntime>$(HelixRuntimeRid)</DotNetCliRuntime> 
+    <DotNetCliRuntime>$(HelixRuntimeRid)</DotNetCliRuntime>
   </PropertyGroup>
 
   <PropertyGroup Condition="'$(TargetOS)' == 'Browser' Or '$(TargetOS)' == 'Android'">
@@ -168,7 +168,7 @@
       <!-- Remove the managed pdbs from our payloads.
            This is for performance reasons to reduce our helix payload size  -->
       <ReducedPayloadFiles Include="@(_PayloadFiles)" Condition=" '%(Extension)' != '.pdb' " />
-      
+
       <ReducedPayloadFilesFinal Include="@(ReducedPayloadFiles)" Condition=" '%(Extension)' != '.sh' and '$(TestWrapperTargetsWindows)' == 'true' "/>
       <ReducedPayloadFilesFinal Include="@(ReducedPayloadFiles)" Condition=" '%(Extension)' != '.cmd' and '$(TestWrapperTargetsWindows)' != 'true' "/>
     </ItemGroup>
@@ -194,7 +194,7 @@
     <ItemGroup>
       <_PayloadGroups Include="$(PayloadGroups)" />
       <_ProjectsToBuild Include="testenvironment.proj">
-        <Properties>Scenario=$(Scenario);TestEnvFileName=$(PayloadsRootDirectory)%(_PayloadGroups.Identity)\$(TestEnvFileName);TargetsWindows=$(TestWrapperTargetsWindows)</Properties>
+        <Properties>Scenario=$(Scenario);TestEnvFileName=$(PayloadsRootDirectory)%(_PayloadGroups.Identity)\$(TestEnvFileName);TargetsWindows=$(TestWrapperTargetsWindows);RuntimeVariant=$(_RuntimeVariant)</Properties>
       </_ProjectsToBuild>
     </ItemGroup>
 
@@ -202,7 +202,7 @@
   </Target>
 
   <Target Name="PreparePALTestArchive">
-    <Exec Condition="'$(PALTestsDir)' != '' and '$(TestWrapperTargetsWindows)' != 'true'" 
+    <Exec Condition="'$(PALTestsDir)' != '' and '$(TestWrapperTargetsWindows)' != 'true'"
           WorkingDirectory="$(PALTestsDir)"
           Command="tar -czvf $(PayloadsRootDirectory)paltests.tar.gz `ls -A`"/>
   </Target>
@@ -234,7 +234,7 @@
     <RunCrossGen2 Condition=" '$(RunCrossGen2)' != 'true' ">false</RunCrossGen2>
     <LongRunningGCTests Condition=" '$(LongRunningGCTests)' != 'true' ">false</LongRunningGCTests>
     <GcSimulatorTests Condition=" '$(GcSimulatorTests)' != 'true' ">false</GcSimulatorTests>
-    <TestRunNamePrefix Condition="'$(RuntimeFlavorDisplayName)' != ''">$(RuntimeFlavorDisplayName) </TestRunNamePrefix> 
+    <TestRunNamePrefix Condition="'$(RuntimeFlavorDisplayName)' != ''">$(RuntimeFlavorDisplayName) </TestRunNamePrefix>
     <TestRunNamePrefix Condition=" '$(RunCrossGen)' == 'true' ">R2R </TestRunNamePrefix>
     <TestRunNamePrefix Condition=" '$(RunCrossGen2)' == 'true' ">R2R-CG2 </TestRunNamePrefix>
     <TestRunNamePrefix Condition=" '$(Scenario)' == 'normal' ">$(TestRunNamePrefix)$(TargetOS) $(TargetArchitecture) $(Configuration) @ </TestRunNamePrefix>
@@ -251,10 +251,11 @@
   <!-- WARNING: HelixPreCommand ItemGroup is intentionally minimal and should be kept that way. -->
 
   <ItemGroup Condition=" '$(TestWrapperTargetsWindows)' == 'true' ">
+    <HelixPreCommand Include="taskkill.exe /f /im corerun.exe"/>
     <HelixPreCommand Include="set CORE_ROOT=%HELIX_CORRELATION_PAYLOAD%" />
     <!-- Set _NT_SYMBOL_PATH so VM _ASSERTE() asserts can find the symbol files when doing stack walks -->
     <HelixPreCommand Include="set _NT_SYMBOL_PATH=%HELIX_CORRELATION_PAYLOAD%\PDB" />
-    <HelixPreCommand Include="set RunCrossGen=1" Condition=" '$(RunCrossGen)' == 'true' " />
+    <HelixPreCommand Include="set RunCrossGen2=1" Condition=" '$(RunCrossGen)' == 'true' " />
     <HelixPreCommand Include="set RunCrossGen2=1" Condition=" '$(RunCrossGen2)' == 'true' " />
     <HelixPreCommand Include="set CompositeBuildMode=1" Condition=" '$(CompositeBuildMode)' == 'true' " />
     <HelixPreCommand Include="set RunningLongGCTests=1" Condition=" '$(LongRunningGCTests)' == 'true' " />
@@ -268,9 +269,13 @@
     <HelixPreCommand Include="type %__TestEnv%" />
   </ItemGroup>
 
+  <ItemGroup Condition=" '$(TestWrapperTargetsWindows)' == 'true' ">
+    <HelixPostCommand Include="taskkill.exe /f /im corerun.exe"/>
+  </ItemGroup>
+
   <ItemGroup Condition=" '$(TestWrapperTargetsWindows)' != 'true' ">
     <HelixPreCommand Include="export CORE_ROOT=$HELIX_CORRELATION_PAYLOAD" />
-    <HelixPreCommand Include="export RunCrossGen=1" Condition=" '$(RunCrossGen)' == 'true' " />
+    <HelixPreCommand Include="export RunCrossGen2=1" Condition=" '$(RunCrossGen)' == 'true' " />
     <HelixPreCommand Include="export RunCrossGen2=1" Condition=" '$(RunCrossGen2)' == 'true' " />
     <HelixPreCommand Include="export CompositeBuildMode=1" Condition=" '$(CompositeBuildMode)' == 'true' " />
     <HelixPreCommand Include="export RunningLongGCTests=1" Condition=" '$(LongRunningGCTests)' == 'true' " />
@@ -286,6 +291,7 @@
 
   <PropertyGroup>
     <HelixPreCommands>@(HelixPreCommand)</HelixPreCommands>
+    <HelixPostCommands>@(HelixPostCommand)</HelixPostCommands>
   </PropertyGroup>
 
   <PropertyGroup Condition=" '$(TestWrapperTargetsWindows)' == 'true' ">
diff --git a/src/tests/Common/override.targets b/src/tests/Common/override.targets
index 544d5745bb0229..c646cf60c0c219 100644
--- a/src/tests/Common/override.targets
+++ b/src/tests/Common/override.targets
@@ -14,7 +14,7 @@
   >
 
     <ItemGroup>
-      <ReferencePath Include="$(RepoRoot)\artifacts\bin\coreclr\$(TargetOS).$(TargetArchitecture).$(Configuration)\System.Private.CoreLib.dll" />
+      <ReferencePath Include="$(RepoRoot)\artifacts\bin\coreclr\$(TargetOS).$(TargetArchitecture).$(Configuration)\IL\System.Private.CoreLib.dll" />
     </ItemGroup>
   </Target>
 
diff --git a/src/tests/Common/scripts/scripts.csproj b/src/tests/Common/scripts/scripts.csproj
deleted file mode 100644
index c7b9426b098610..00000000000000
--- a/src/tests/Common/scripts/scripts.csproj
+++ /dev/null
@@ -1,33 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <Import Project="$([MSBuild]::GetPathOfFileAbove(Directory.Build.props))" />
-  <ItemGroup>
-    <PackageReference Include="Microsoft.DotNet.xunit.performance.run.core">
-      <Version>1.0.0-alpha-build0040</Version>
-    </PackageReference>
-    <PackageReference Include="Microsoft.DotNet.xunit.performance.analysis.cli">
-      <Version>1.0.0-alpha-build0040</Version>
-    </PackageReference>
-    <PackageReference Include="Microsoft.DotNet.xunit.performance.runner.cli">
-      <Version>1.0.0-alpha-build0040</Version>
-    </PackageReference>
-    <PackageReference Include="Microsoft.DotNet.xunit.performance">
-      <Version>1.0.0-alpha-build0040</Version>
-    </PackageReference>
-    <PackageReference Include="Microsoft.DotNet.XUnitConsoleRunner">
-      <Version>$(MicrosoftDotNetXUnitConsoleRunnerVersion)</Version>
-    </PackageReference>
-    <PackageReference Include="Microsoft.DotNet.BuildTools.TestSuite">
-      <Version>1.0.0-prerelease-00629-04</Version>
-    </PackageReference> 
-  </ItemGroup>
-  <PropertyGroup>
-    <TargetFramework>netstandard1.3</TargetFramework>
-    <TargetFrameworkIdentifier>.NETStandard</TargetFrameworkIdentifier>
-    <RuntimeIdentifiers>win7-x86;win7-x64</RuntimeIdentifiers>
-    <IsTestProject>false</IsTestProject>
-  </PropertyGroup>
-  <Import Project="$([MSBuild]::GetPathOfFileAbove(Directory.Build.targets))" />
-  <Target Name="Build"
-     DependsOnTargets="ResolveReferences" /> 
-</Project>
diff --git a/src/tests/Common/testenvironment.proj b/src/tests/Common/testenvironment.proj
index b1a359d90283bf..37392b57df478c 100644
--- a/src/tests/Common/testenvironment.proj
+++ b/src/tests/Common/testenvironment.proj
@@ -193,7 +193,7 @@
       <_TestEnvFileLine Include="@(_COMPlusVariable->'set %(Identity)=%(Value)')"  />
 
       <!-- Mono interpreter -->
-      <_TestEnvFileLine Include="set MONO_ENV_OPTIONS=--interpreter" Condition="'$(Scenario)' == 'interpreter'" />
+      <_TestEnvFileLine Condition="'$(RuntimeVariant)' == 'monointerpreter'" Include="set MONO_ENV_OPTIONS=--interpreter" />
 
       <!-- CLR interpreter -->
       <_TestEnvFileLine Condition="'$(Scenario)' == 'clrinterpreter'" Include="set COMPlus_Interpret=%2A" /> <!-- %2A is asterisk / wildcard -->
@@ -208,7 +208,10 @@
       <_TestEnvFileLine Include="@(_COMPlusVariable->'export %(Identity)=%(Value)')"  />
 
       <!-- Mono interpreter -->
-      <_TestEnvFileLine Include="export MONO_ENV_OPTIONS=--interpreter" Condition="'$(Scenario)' == 'interpreter'" />
+      <_TestEnvFileLine Condition="'$(RuntimeVariant)' == 'monointerpreter'" Include="export MONO_ENV_OPTIONS=--interpreter" />
+
+      <!-- Hack: Use Mono LLVM JIT when JIT-compiling the non-AOT-compiled parts of the runtime tests -->
+      <_TestEnvFileLine Condition="'$(RuntimeVariant)' == 'llvmaot'" Include="export MONO_ENV_OPTIONS=--llvm" />
 
       <!-- CLR interpreter -->
       <_TestEnvFileLine Condition="'$(Scenario)' == 'clrinterpreter'" Include="export COMPlus_Interpret=%2A" /> <!-- %2A is asterisk / wildcard -->
diff --git a/src/tests/FunctionalTests/Android/Device_Emulator/AOT_LLVM/Android.Device_Emulator.Aot_Llvm.Test.csproj b/src/tests/FunctionalTests/Android/Device_Emulator/AOT_LLVM/Android.Device_Emulator.Aot_Llvm.Test.csproj
new file mode 100644
index 00000000000000..3ec5bf5e4b63d1
--- /dev/null
+++ b/src/tests/FunctionalTests/Android/Device_Emulator/AOT_LLVM/Android.Device_Emulator.Aot_Llvm.Test.csproj
@@ -0,0 +1,17 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <MonoForceInterpreter>false</MonoForceInterpreter>
+    <RunAOTCompilation>true</RunAOTCompilation>
+    <TestRuntime>true</TestRuntime>
+    <TargetFrameworks>$(NetCoreAppCurrent)</TargetFrameworks>
+    <MainLibraryFileName>Android.Device_Emulator.Aot_Llvm.Test.dll</MainLibraryFileName>
+    <ExpectedExitCode>42</ExpectedExitCode>
+    <EnableAggressiveTrimming>true</EnableAggressiveTrimming>
+    <MonoEnableLLVM>true</MonoEnableLLVM>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Include="Program.cs" />
+  </ItemGroup>
+</Project>
diff --git a/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/MockHostTypes/Host.cs b/src/tests/FunctionalTests/Android/Device_Emulator/AOT_LLVM/Program.cs
similarity index 53%
rename from src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/MockHostTypes/Host.cs
rename to src/tests/FunctionalTests/Android/Device_Emulator/AOT_LLVM/Program.cs
index 31e4aa91efb7e8..7dcc0f375db878 100644
--- a/src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/MockHostTypes/Host.cs
+++ b/src/tests/FunctionalTests/Android/Device_Emulator/AOT_LLVM/Program.cs
@@ -3,10 +3,11 @@
 
 using System;
 
-namespace MockHostTypes
+public static class Program
 {
-    public class Host : IHost
+    public static int Main(string[] args)
     {
-        public IServiceProvider Services { get; } = new ServiceProvider();
+        Console.WriteLine("Hello, Android!"); // logcat
+        return 42;
     }
 }
diff --git a/src/tests/FunctionalTests/WebAssembly/Browser/AOT/index.html b/src/tests/FunctionalTests/WebAssembly/Browser/AOT/index.html
index efab9ac4324a21..642987d23c5e2b 100644
--- a/src/tests/FunctionalTests/WebAssembly/Browser/AOT/index.html
+++ b/src/tests/FunctionalTests/WebAssembly/Browser/AOT/index.html
@@ -47,7 +47,6 @@ <h3 id="header">Wasm Browser Sample</h3>
         },
       };
     </script>
-    <script type="text/javascript" src="mono-config.js"></script>
     <script type="text/javascript" src="runtime.js"></script>
 
     <script defer src="dotnet.js"></script>
diff --git a/src/tests/FunctionalTests/WebAssembly/Browser/AOT/runtime.js b/src/tests/FunctionalTests/WebAssembly/Browser/AOT/runtime.js
index a39b0b97b14901..65cba13a9b126b 100644
--- a/src/tests/FunctionalTests/WebAssembly/Browser/AOT/runtime.js
+++ b/src/tests/FunctionalTests/WebAssembly/Browser/AOT/runtime.js
@@ -2,8 +2,21 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 var Module = { 
+
+    config: null,
+
+    preInit: async function() {
+        Module.config = await MONO.mono_wasm_load_config("./mono-config.json");
+    },
+
     onRuntimeInitialized: function () {
-        config.loaded_cb = function () {
+        if (!Module.config || Module.config.error) {
+            console.log("No config found");
+            test_exit(1);
+            throw(Module.config.error);
+        }
+
+        Module.config.loaded_cb = function () {
             try {
                 App.init ();
             } catch (error) {
@@ -11,13 +24,13 @@ var Module = {
                 throw (error);
             }
         };
-        config.fetch_file_cb = function (asset) {
+        Module.config.fetch_file_cb = function (asset) {
             return fetch (asset, { credentials: 'same-origin' });
         }
 
         try
         {
-            MONO.mono_load_runtime_and_bcl_args (config);
+            MONO.mono_load_runtime_and_bcl_args (Module.config);
         } catch (error) {
             test_exit(1);
             throw(error);
diff --git a/src/tests/FunctionalTests/WebAssembly/Browser/NormalInterp/index.html b/src/tests/FunctionalTests/WebAssembly/Browser/NormalInterp/index.html
index 03f68679a5b85c..9de05f5031b325 100644
--- a/src/tests/FunctionalTests/WebAssembly/Browser/NormalInterp/index.html
+++ b/src/tests/FunctionalTests/WebAssembly/Browser/NormalInterp/index.html
@@ -47,7 +47,6 @@ <h3 id="header">Wasm Browser Sample</h3>
         },
       };
     </script>
-    <script type="text/javascript" src="mono-config.js"></script>
     <script type="text/javascript" src="runtime.js"></script>
 
     <script defer src="dotnet.js"></script>
diff --git a/src/tests/FunctionalTests/WebAssembly/Browser/NormalInterp/runtime.js b/src/tests/FunctionalTests/WebAssembly/Browser/NormalInterp/runtime.js
index a39b0b97b14901..1a8abf503fb33f 100644
--- a/src/tests/FunctionalTests/WebAssembly/Browser/NormalInterp/runtime.js
+++ b/src/tests/FunctionalTests/WebAssembly/Browser/NormalInterp/runtime.js
@@ -2,8 +2,21 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 var Module = { 
+
+    config: null,
+
+    preInit: async function() {
+        Module.config = await MONO.mono_wasm_load_config("./mono-config.json");
+    },
+
     onRuntimeInitialized: function () {
-        config.loaded_cb = function () {
+        if (!Module.config || Module.config.error) {
+            console.log("No config found");
+            test_exit(1);
+            throw(Module.config.error);
+        }
+        
+        Module.config.loaded_cb = function () {
             try {
                 App.init ();
             } catch (error) {
@@ -11,13 +24,13 @@ var Module = {
                 throw (error);
             }
         };
-        config.fetch_file_cb = function (asset) {
+        Module.config.fetch_file_cb = function (asset) {
             return fetch (asset, { credentials: 'same-origin' });
         }
 
         try
         {
-            MONO.mono_load_runtime_and_bcl_args (config);
+            MONO.mono_load_runtime_and_bcl_args (Module.config);
         } catch (error) {
             test_exit(1);
             throw(error);
diff --git a/src/tests/GC/Scenarios/LeakWheel/leakwheel.csproj b/src/tests/GC/Scenarios/LeakWheel/leakwheel.csproj
index d0dca8486ab8a6..ceda84368bf25f 100644
--- a/src/tests/GC/Scenarios/LeakWheel/leakwheel.csproj
+++ b/src/tests/GC/Scenarios/LeakWheel/leakwheel.csproj
@@ -2,6 +2,7 @@
   <PropertyGroup>
     <OutputType>Exe</OutputType>
     <GCStressIncompatible>true</GCStressIncompatible>
+    <CLRTestPriority>1</CLRTestPriority>
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="leakwheel.cs" />
diff --git a/src/tests/Interop/COM/Activator/ActivatorBuiltInComDisabled.csproj b/src/tests/Interop/COM/Activator/ActivatorBuiltInComDisabled.csproj
new file mode 100644
index 00000000000000..6a4ee3cc1d8d92
--- /dev/null
+++ b/src/tests/Interop/COM/Activator/ActivatorBuiltInComDisabled.csproj
@@ -0,0 +1,34 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <ReferenceSystemPrivateCoreLib>true</ReferenceSystemPrivateCoreLib>
+    <RequiresMockHostPolicy>true</RequiresMockHostPolicy>
+    <!-- The test fails casting from ClassFromA from the default ALC to type IGetTypeFromC from a custom ALC -->
+    <UnloadabilityIncompatible>true</UnloadabilityIncompatible>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="Program.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\NETServer\NETServer.csproj" />
+    <ProjectReference Include="Servers\AssemblyA.csproj" />
+    <ProjectReference Include="Servers\AssemblyB.csproj" />
+    <ProjectReference Include="Servers\AssemblyC.csproj" />
+    <ProjectReference Include="Servers\AssemblyContracts.csproj" />
+  </ItemGroup>
+  <!-- Set up an isolated directory for the server assemblies -->
+  <Target Name="SetUpIsolatedDirectory" AfterTargets="CopyFilesToOutputDirectory">
+    <PropertyGroup>
+      <ServerAssemblyDest>$(OutDir)/Servers</ServerAssemblyDest>
+    </PropertyGroup>
+    <ItemGroup>
+      <ServerAssembly Include="$(OutDir)/AssemblyA.*" />
+      <ServerAssembly Include="$(OutDir)/AssemblyB.*" />
+      <ServerAssembly Include="$(OutDir)/AssemblyC.*" />
+    </ItemGroup>
+    <Move SourceFiles="@(ServerAssembly)" DestinationFolder="$(ServerAssemblyDest)" />
+  </Target>
+  <ItemGroup>
+    <RuntimeHostConfigurationOption Include="System.Runtime.InteropServices.BuiltInComInterop.IsSupported" Value="false" />
+  </ItemGroup>
+</Project>
diff --git a/src/tests/Interop/COM/Activator/Program.cs b/src/tests/Interop/COM/Activator/Program.cs
index fd525aaf2e905a..04049e79c2a828 100644
--- a/src/tests/Interop/COM/Activator/Program.cs
+++ b/src/tests/Interop/COM/Activator/Program.cs
@@ -32,12 +32,11 @@ static void InvalidInterfaceRequest()
                 "Non-IClassFactory request should fail");
         }
 
-        static void NonrootedAssemblyPath()
+        static void NonrootedAssemblyPath(bool builtInComDisabled)
         {
             Console.WriteLine($"Running {nameof(NonrootedAssemblyPath)}...");
 
-            ArgumentException e = Assert.Throws<ArgumentException>(
-                () =>
+            Action action = () =>
                 {
                     var cxt = new ComActivationContext()
                     {
@@ -45,16 +44,23 @@ static void NonrootedAssemblyPath()
                         AssemblyPath = "foo.dll"
                     };
                     ComActivator.GetClassFactoryForType(cxt);
-                },
-                "Non-root assembly path should not be valid");
+                };
+
+            if (!builtInComDisabled)
+            {
+                Assert.Throws<ArgumentException>(action, "Non-root assembly path should not be valid");
+            }
+            else
+            {
+                Assert.Throws<NotSupportedException>(action, "Built-in COM has been disabled via a feature switch");
+            }
         }
 
-        static void ClassNotRegistered()
+        static void ClassNotRegistered(bool builtInComDisabled)
         {
             Console.WriteLine($"Running {nameof(ClassNotRegistered)}...");
 
-            COMException e = Assert.Throws<COMException>(
-                () =>
+            Action action = () =>
                 {
                     var CLSID_NotRegistered = new Guid("328FF83E-3F6C-4BE9-A742-752562032925"); // Random GUID
                     var cxt = new ComActivationContext()
@@ -64,14 +70,21 @@ static void ClassNotRegistered()
                         AssemblyPath = @"C:\foo.dll"
                     };
                     ComActivator.GetClassFactoryForType(cxt);
-                },
-                "Class should not be found");
+                };
 
-            const int CLASS_E_CLASSNOTAVAILABLE = unchecked((int)0x80040111);
-            Assert.AreEqual(CLASS_E_CLASSNOTAVAILABLE, e.HResult, "Unexpected HRESULT");
+            if (!builtInComDisabled)
+            {
+                COMException e = Assert.Throws<COMException>(action, "Class should not be found");
+                const int CLASS_E_CLASSNOTAVAILABLE = unchecked((int)0x80040111);
+                Assert.AreEqual(CLASS_E_CLASSNOTAVAILABLE, e.HResult, "Unexpected HRESULT");
+            }
+            else
+            {
+                Assert.Throws<NotSupportedException>(action, "Built-in COM has been disabled via a feature switch");
+            }
         }
 
-        static void ValidateAssemblyIsolation()
+        static void ValidateAssemblyIsolation(bool builtInComDisabled)
         {
             Console.WriteLine($"Running {nameof(ValidateAssemblyIsolation)}...");
 
@@ -103,6 +116,13 @@ static void ValidateAssemblyIsolation()
                     TypeName = "ClassFromA"
                 };
 
+                if (builtInComDisabled)
+                {
+                    Assert.Throws<NotSupportedException>(
+                        () => ComActivator.GetClassFactoryForType(cxt), "Built-in COM has been disabled via a feature switch");
+                    return;
+                }
+
                 var factory = (IClassFactory)ComActivator.GetClassFactoryForType(cxt);
 
                 IntPtr svrRaw;
@@ -259,11 +279,23 @@ static int Main(string[] doNotUse)
         {
             try
             {
+                bool builtInComDisabled = false;
+                var comConfig = AppContext.GetData("System.Runtime.InteropServices.BuiltInComInterop.IsSupported");
+                if (comConfig != null && !bool.Parse(comConfig.ToString()))
+                {
+                    builtInComDisabled = true;
+                }
+                Console.WriteLine($"Built-in COM Disabled?: {builtInComDisabled}");
+
                 InvalidInterfaceRequest();
-                ClassNotRegistered();
-                NonrootedAssemblyPath();
-                ValidateAssemblyIsolation();
-                ValidateUserDefinedRegistrationCallbacks();
+                ClassNotRegistered(builtInComDisabled);
+                NonrootedAssemblyPath(builtInComDisabled);
+                ValidateAssemblyIsolation(builtInComDisabled);
+                if (!builtInComDisabled)
+                {
+                    // We don't test this scenario with builtInComDisabled since it is covered by ValidateAssemblyIsolation() above
+                    ValidateUserDefinedRegistrationCallbacks();
+                }
             }
             catch (Exception e)
             {
diff --git a/src/tests/Interop/COM/NETClients/Aggregation/Program.cs b/src/tests/Interop/COM/NETClients/Aggregation/Program.cs
index ee1984f5842cce..2072b41a01184e 100644
--- a/src/tests/Interop/COM/NETClients/Aggregation/Program.cs
+++ b/src/tests/Interop/COM/NETClients/Aggregation/Program.cs
@@ -21,6 +21,12 @@ static void ValidateNativeOuter()
             var managedInner = new ManagedInner();
             var nativeOuter = (AggregationTesting)managedInner;
 
+            Assert.IsTrue(typeof(ManagedInner).IsCOMObject);
+            Assert.IsTrue(typeof(AggregationTestingClass).IsCOMObject);
+            Assert.IsFalse(typeof(AggregationTesting).IsCOMObject);
+            Assert.IsTrue(Marshal.IsComObject(managedInner));
+            Assert.IsTrue(Marshal.IsComObject(nativeOuter));
+
             Assert.IsTrue(nativeOuter.IsAggregated());
             Assert.IsTrue(nativeOuter.AreAggregated(managedInner, nativeOuter));
             Assert.IsFalse(nativeOuter.AreAggregated(nativeOuter, new object()));
diff --git a/src/tests/Interop/COM/NETClients/ComDisabled/App.manifest b/src/tests/Interop/COM/NETClients/ComDisabled/App.manifest
new file mode 100644
index 00000000000000..6bd83fd63f7cee
--- /dev/null
+++ b/src/tests/Interop/COM/NETClients/ComDisabled/App.manifest
@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="utf-8"?>
+<assembly manifestVersion="1.0" xmlns="urn:schemas-microsoft-com:asm.v1">
+  <assemblyIdentity
+    type="win32"
+    name="NetPrimitivesClient"
+    version="1.0.0.0" />
+
+  <dependency>
+    <dependentAssembly>
+      <!-- RegFree COM -->
+      <assemblyIdentity
+          type="win32"
+          name="COMNativeServer.X"
+          version="1.0.0.0"/>
+    </dependentAssembly>
+  </dependency>
+
+</assembly>
diff --git a/src/tests/Interop/COM/NETClients/ComDisabled/NETClientComDisabled.csproj b/src/tests/Interop/COM/NETClients/ComDisabled/NETClientComDisabled.csproj
new file mode 100644
index 00000000000000..fc9a84c0109ab4
--- /dev/null
+++ b/src/tests/Interop/COM/NETClients/ComDisabled/NETClientComDisabled.csproj
@@ -0,0 +1,19 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <ApplicationManifest>App.manifest</ApplicationManifest>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="Program.cs" />
+    <Compile Include="../../ServerContracts/Server.CoClasses.cs" />
+    <Compile Include="../../ServerContracts/Server.Contracts.cs" />
+    <Compile Include="../../ServerContracts/ServerGuids.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="../../NativeServer/CMakeLists.txt" />
+    <ProjectReference Include="$(TestSourceDir)Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
+  </ItemGroup>
+  <ItemGroup>
+    <RuntimeHostConfigurationOption Include="System.Runtime.InteropServices.BuiltInComInterop.IsSupported" Value="false" />
+  </ItemGroup>
+</Project>
diff --git a/src/tests/Interop/COM/NETClients/ComDisabled/Program.cs b/src/tests/Interop/COM/NETClients/ComDisabled/Program.cs
new file mode 100644
index 00000000000000..8f25b3dbcf8701
--- /dev/null
+++ b/src/tests/Interop/COM/NETClients/ComDisabled/Program.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.
+
+namespace NetClient
+{
+    using System;
+    using System.Threading;
+    using System.Runtime.InteropServices;
+    using System.Runtime.CompilerServices;
+
+    class Program
+    {
+        static int Main(string[] doNotUse)
+        {
+            // RegFree COM is not supported on Windows Nano
+            if (TestLibrary.Utilities.IsWindowsNanoServer)
+            {
+                return 100;
+            }
+
+            try
+            {
+                var server = (Server.Contract.Servers.NumericTesting)new Server.Contract.Servers.NumericTestingClass();
+            }
+            catch (NotSupportedException) when (OperatingSystem.IsWindows())
+            {
+                return 100;
+            }
+            catch (PlatformNotSupportedException) when (!OperatingSystem.IsWindows())
+            {
+                return 100;
+            }
+
+            return 101;
+        }
+    }
+}
diff --git a/src/tests/Interop/COM/NETClients/ConsumeNETServer/Program.cs b/src/tests/Interop/COM/NETClients/ConsumeNETServer/Program.cs
index a78274eb9c8aa3..1bade41b255d92 100644
--- a/src/tests/Interop/COM/NETClients/ConsumeNETServer/Program.cs
+++ b/src/tests/Interop/COM/NETClients/ConsumeNETServer/Program.cs
@@ -24,6 +24,9 @@ static void Validate_Activation()
 
             // The CoClass should be the activated type, _not_ the activation interface.
             Assert.AreEqual(test.GetType(), typeof(CoClass.ConsumeNETServerTestingClass));
+            Assert.IsTrue(typeof(CoClass.ConsumeNETServerTestingClass).IsCOMObject);
+            Assert.IsFalse(typeof(CoClass.ConsumeNETServerTesting).IsCOMObject);
+            Assert.IsTrue(Marshal.IsComObject(test));
         }
 
         static void Validate_CCW_Wasnt_Unwrapped()
diff --git a/src/tests/Interop/LayoutClass/LayoutClassNative.cpp b/src/tests/Interop/LayoutClass/LayoutClassNative.cpp
index 7798ffb5cf0a21..ff0ff5b904f8ee 100644
--- a/src/tests/Interop/LayoutClass/LayoutClassNative.cpp
+++ b/src/tests/Interop/LayoutClass/LayoutClassNative.cpp
@@ -108,6 +108,12 @@ DLL_EXPORT BOOL STDMETHODCALLTYPE SimpleNestedLayoutClassByValue(NestedLayoutCla
     return SimpleSeqLayoutClassByRef(&v.str);
 }
 
+extern "C"
+DLL_EXPORT BOOL STDMETHODCALLTYPE PointersEqual(void* ptr, void* ptr2)
+{
+    return ptr == ptr2 ? TRUE : FALSE;
+}
+
 extern "C"
 DLL_EXPORT void __cdecl Invalid(...)
 {
diff --git a/src/tests/Interop/LayoutClass/LayoutClassTest.cs b/src/tests/Interop/LayoutClass/LayoutClassTest.cs
index 2181bb30528d44..b333c7ddd98517 100644
--- a/src/tests/Interop/LayoutClass/LayoutClassTest.cs
+++ b/src/tests/Interop/LayoutClass/LayoutClassTest.cs
@@ -174,6 +174,12 @@ class StructureTests
         [DllImport("LayoutClassNative", EntryPoint = SimpleBlittableSeqLayoutClass_UpdateField)]
         private static extern bool SealedBlittableSeqLayoutClassByOutAttr([Out] SealedBlittable p);
 
+        [DllImport("LayoutClassNative")]
+        private static extern bool PointersEqual(SealedBlittable obj, ref int field);
+
+        [DllImport("LayoutClassNative")]
+        private static extern bool PointersEqual(Blittable obj, ref int field);
+
         [DllImport("LayoutClassNative")]
         private static extern bool SimpleNestedLayoutClassByValue(NestedLayout p);
 
@@ -280,6 +286,20 @@ public static void SealedBlittableClassByOutAttr()
             ValidateSealedBlittableClassInOut(SealedBlittableSeqLayoutClassByOutAttr);
         }
 
+        public static void SealedBlittablePinned()
+        {
+            Console.WriteLine($"Running {nameof(SealedBlittablePinned)}...");
+            var blittable = new SealedBlittable(1);
+            Assert.IsTrue(PointersEqual(blittable, ref blittable.a));
+        }
+
+        public static void BlittablePinned()
+        {
+            Console.WriteLine($"Running {nameof(BlittablePinned)}...");
+            var blittable = new Blittable(1);
+            Assert.IsTrue(PointersEqual(blittable, ref blittable.a));
+        }
+
         public static void NestedLayoutClass()
         {
             Console.WriteLine($"Running {nameof(NestedLayoutClass)}...");
@@ -317,6 +337,8 @@ public static int Main(string[] argv)
                 SealedBlittableClassByOutAttr();
                 NestedLayoutClass();
                 RecursiveNativeLayout();
+                SealedBlittablePinned();
+                BlittablePinned();
             }
             catch (Exception e)
             {
diff --git a/src/tests/Interop/ObjectiveC/ObjectiveCMarshalAPI/ObjectiveCMarshalAPI.csproj b/src/tests/Interop/ObjectiveC/ObjectiveCMarshalAPI/ObjectiveCMarshalAPI.csproj
index 9a81c001eb8cd3..7ae26166948d11 100644
--- a/src/tests/Interop/ObjectiveC/ObjectiveCMarshalAPI/ObjectiveCMarshalAPI.csproj
+++ b/src/tests/Interop/ObjectiveC/ObjectiveCMarshalAPI/ObjectiveCMarshalAPI.csproj
@@ -4,6 +4,8 @@
     <!-- Test unsupported outside of OSX -->
     <CLRTestTargetUnsupported Condition="'$(TargetsOSX)' != 'true'">true</CLRTestTargetUnsupported>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <!-- Disable under GCStress. Tracking: https://github.com/dotnet/runtime/issues/53359 -->
+    <GCStressIncompatible>true</GCStressIncompatible>
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="Program.cs" />
diff --git a/src/tests/Interop/PInvoke/Generics/CMakeLists.txt b/src/tests/Interop/PInvoke/Generics/CMakeLists.txt
index ebb09a85e7b049..9d6a3f34adc1b2 100644
--- a/src/tests/Interop/PInvoke/Generics/CMakeLists.txt
+++ b/src/tests/Interop/PInvoke/Generics/CMakeLists.txt
@@ -1,5 +1,5 @@
-project (GenericsNative) 
-include ("${CLR_INTEROP_TEST_ROOT}/Interop.cmake") 
+project (GenericsNative)
+include ("${CLR_INTEROP_TEST_ROOT}/Interop.cmake")
 if(CLR_CMAKE_TARGET_ARCH_I386)
   add_definitions(-DTARGET_X86)
   add_definitions(-DTARGET_XARCH)
@@ -17,6 +17,16 @@ if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
   # The ABI for passing parameters with 32-byte alignment has changed in GCC 4.6
   add_compile_options(-Wno-psabi)
 endif()
+if (MSVC)
+  # The MSVC require explicitly ask for AVX2 so define would be present.
+  add_compile_options(/arch:AVX2)
+else()
+  if (NOT CLR_CMAKE_TARGET_ARCH_ARM64 AND NOT CLR_CMAKE_TARGET_ARCH_ARM)
+    # We need -march=native so we can detect if AVX2 is present.
+    # ARM does not like that option too and it make no sense to have this detection there.
+    add_compile_options(-march=native)
+  endif()
+endif()
 set(SOURCES
   GenericsNative.IUnknown.cpp
   GenericsNative.NullableB.cpp
@@ -87,4 +97,4 @@ set(SOURCES
   GenericsNative.VectorU.cpp
 )
 add_library (GenericsNative SHARED ${SOURCES})
-install (TARGETS GenericsNative DESTINATION bin) 
+install (TARGETS GenericsNative DESTINATION bin)
diff --git a/src/tests/Interop/PInvoke/Generics/GenericsNative.Vector256B.cpp b/src/tests/Interop/PInvoke/Generics/GenericsNative.Vector256B.cpp
index 619067ab205d2c..895d5d2a40372a 100644
--- a/src/tests/Interop/PInvoke/Generics/GenericsNative.Vector256B.cpp
+++ b/src/tests/Interop/PInvoke/Generics/GenericsNative.Vector256B.cpp
@@ -8,9 +8,15 @@
 
 #if defined(TARGET_XARCH)
     #include <immintrin.h>
+#elif defined(TARGET_ARMARCH)
+    // Intentionally empty
+#else
+    #error Unsupported target architecture
+#endif
 
+#if defined(__AVX2__)
     typedef __m256i Vector256B;
-#elif defined(TARGET_ARMARCH)
+#else
     typedef struct {
         bool e00;
         bool e01;
@@ -45,8 +51,6 @@
         bool e30;
         bool e31;
     } Vector256B;
-#else
-    #error Unsupported target architecture
 #endif
 
 static Vector256B Vector256BValue = { };
diff --git a/src/tests/Interop/PInvoke/Generics/GenericsNative.Vector256C.cpp b/src/tests/Interop/PInvoke/Generics/GenericsNative.Vector256C.cpp
index acb15d74e0e5ff..e1b55e13dbe56b 100644
--- a/src/tests/Interop/PInvoke/Generics/GenericsNative.Vector256C.cpp
+++ b/src/tests/Interop/PInvoke/Generics/GenericsNative.Vector256C.cpp
@@ -8,9 +8,15 @@
 
 #if defined(TARGET_XARCH)
     #include <immintrin.h>
+#elif defined(TARGET_ARMARCH)
+    // Intentionally empty
+#else
+    #error Unsupported target architecture
+#endif
 
+#if defined(__AVX2__)
     typedef __m256i Vector256C;
-#elif defined(TARGET_ARMARCH)
+#else
     typedef struct {
         char16_t e00;
         char16_t e01;
@@ -29,8 +35,6 @@
         char16_t e14;
         char16_t e15;
     } Vector256C;
-#else
-    #error Unsupported target architecture
 #endif
 
 static Vector256C Vector256CValue = { };
diff --git a/src/tests/Interop/PInvoke/Generics/GenericsNative.Vector256D.cpp b/src/tests/Interop/PInvoke/Generics/GenericsNative.Vector256D.cpp
index 4fa3d0c6a03017..769004e10cb605 100644
--- a/src/tests/Interop/PInvoke/Generics/GenericsNative.Vector256D.cpp
+++ b/src/tests/Interop/PInvoke/Generics/GenericsNative.Vector256D.cpp
@@ -8,17 +8,21 @@
 
 #if defined(TARGET_XARCH)
     #include <immintrin.h>
-
-    typedef __m256d Vector256D;
 #elif defined(TARGET_ARMARCH)
+    // Intentionally empty
+#else
+    #error Unsupported target architecture
+#endif
+
+#if defined(__AVX2__)
+    typedef __m256 Vector256D;
+#else
     typedef struct {
         double e00;
         double e01;
         double e02;
         double e03;
     } Vector256D;
-#else
-    #error Unsupported target architecture
 #endif
 
 static Vector256D Vector256DValue = { };
diff --git a/src/tests/Interop/PInvoke/Generics/GenericsNative.Vector256F.cpp b/src/tests/Interop/PInvoke/Generics/GenericsNative.Vector256F.cpp
index 966e1ab73d623e..c261ca25ab7b5a 100644
--- a/src/tests/Interop/PInvoke/Generics/GenericsNative.Vector256F.cpp
+++ b/src/tests/Interop/PInvoke/Generics/GenericsNative.Vector256F.cpp
@@ -8,9 +8,15 @@
 
 #if defined(TARGET_XARCH)
     #include <immintrin.h>
+#elif defined(TARGET_ARMARCH)
+    // Intentionally empty
+#else
+    #error Unsupported target architecture
+#endif
 
+#if defined(__AVX2__)
     typedef __m256 Vector256F;
-#elif defined(TARGET_ARMARCH)
+#else
     typedef struct {
         float e00;
         float e01;
@@ -21,8 +27,6 @@
         float e06;
         float e07;
     } Vector256F;
-#else
-    #error Unsupported target architecture
 #endif
 
 static Vector256F Vector256FValue = { };
diff --git a/src/tests/Interop/PInvoke/Generics/GenericsNative.Vector256L.cpp b/src/tests/Interop/PInvoke/Generics/GenericsNative.Vector256L.cpp
index 7df630881a19b9..62fc21a6d4eb8e 100644
--- a/src/tests/Interop/PInvoke/Generics/GenericsNative.Vector256L.cpp
+++ b/src/tests/Interop/PInvoke/Generics/GenericsNative.Vector256L.cpp
@@ -8,17 +8,21 @@
 
 #if defined(TARGET_XARCH)
     #include <immintrin.h>
+#elif defined(TARGET_ARMARCH)
+    // Intentionally empty
+#else
+    #error Unsupported target architecture
+#endif
 
+#if defined(__AVX2__)
     typedef __m256i Vector256L;
-#elif defined(TARGET_ARMARCH)
+#else
     typedef struct {
         int64_t e00;
         int64_t e01;
         int64_t e02;
         int64_t e03;
     } Vector256L;
-#else
-    #error Unsupported target architecture
 #endif
 
 static Vector256L Vector256LValue = { };
diff --git a/src/tests/Interop/PInvoke/Generics/GenericsNative.Vector256U.cpp b/src/tests/Interop/PInvoke/Generics/GenericsNative.Vector256U.cpp
index 9f4918843cb919..99fe029d3eefa3 100644
--- a/src/tests/Interop/PInvoke/Generics/GenericsNative.Vector256U.cpp
+++ b/src/tests/Interop/PInvoke/Generics/GenericsNative.Vector256U.cpp
@@ -8,9 +8,15 @@
 
 #if defined(TARGET_XARCH)
     #include <immintrin.h>
+#elif defined(TARGET_ARMARCH)
+    // Intentionally empty
+#else
+    #error Unsupported target architecture
+#endif
 
+#if defined(__AVX2__)
     typedef __m256i Vector256U;
-#elif defined(TARGET_ARMARCH)
+#else
     typedef struct {
         uint32_t e00;
         uint32_t e01;
@@ -21,8 +27,6 @@
         uint32_t e06;
         uint32_t e07;
     } Vector256U;
-#else
-    #error Unsupported target architecture
 #endif
 
 static Vector256U Vector256UValue = { };
diff --git a/src/tests/Interop/PInvoke/Variant/VariantTest.cs b/src/tests/Interop/PInvoke/Variant/VariantTest.cs
index e15814a9cb6e0c..b7ee1710a4d6fd 100644
--- a/src/tests/Interop/PInvoke/Variant/VariantTest.cs
+++ b/src/tests/Interop/PInvoke/Variant/VariantTest.cs
@@ -6,7 +6,20 @@
 using TestLibrary;
 using static VariantNative;
 
-#pragma warning disable CS0612, CS0618
+// Class used to validate the IClassX generation path doesn't fail.
+// Support for this scenario is extremely limited so we simply validate
+// it continues be generated and can be marshalled to native.
+//
+// This class must be marked public in order for the IDispatch path for
+// field access to be validated.
+public class GenerateIClassX
+{
+    public int FieldPrimitive;
+    public System.Collections.Generic.List<int> FieldWithGeneric;
+    public object FieldRefType;
+    public DateTime FieldValueType;
+}
+
 partial class Test
 {
     private const byte NumericValue = 15;
@@ -41,10 +54,28 @@ private unsafe static void TestByValue(bool hasComSupport)
         Assert.IsTrue(Marshal_ByValue_Null(DBNull.Value));
         Assert.IsTrue(Marshal_ByValue_Missing(System.Reflection.Missing.Value));
         Assert.IsTrue(Marshal_ByValue_Empty(null));
+
         if (hasComSupport)
         {
             Assert.IsTrue(Marshal_ByValue_Object(new object()));
             Assert.IsTrue(Marshal_ByValue_Object_IUnknown(new UnknownWrapper(new object())));
+            Assert.IsTrue(Marshal_ByValue_Object(new GenerateIClassX()));
+            Assert.IsTrue(Marshal_ByValue_Object_IUnknown(new UnknownWrapper(new GenerateIClassX())));
+        }
+        else
+        {
+            Assert.Throws<NotSupportedException>(
+                    () =>
+                    {
+                        Marshal_ByValue_Object(new object());
+                    },
+                    "Built-in COM has been disabled via a feature switch");
+            Assert.Throws<NotSupportedException>(
+                    () =>
+                    {
+                        Marshal_ByValue_Object_IUnknown(new UnknownWrapper(new object()));
+                    },
+                    "Built-in COM has been disabled via a feature switch");
         }
 
         Assert.Throws<ArgumentException>(() => Marshal_ByValue_Invalid(TimeSpan.Zero));
@@ -123,6 +154,29 @@ private unsafe static void TestByRef(bool hasComSupport)
 
             obj = new UnknownWrapper(new object());
             Assert.IsTrue(Marshal_ByRef_Object_IUnknown(ref obj));
+
+            obj = new GenerateIClassX();
+            Assert.IsTrue(Marshal_ByRef_Object(ref obj));
+
+            obj = new UnknownWrapper(new GenerateIClassX());
+            Assert.IsTrue(Marshal_ByRef_Object_IUnknown(ref obj));
+        }
+        else
+        {
+            Assert.Throws<NotSupportedException>(
+                    () =>
+                    {
+                        obj = new object();
+                        Marshal_ByRef_Object(ref obj);
+                    },
+                    "Built-in COM has been disabled via a feature switch");
+            Assert.Throws<NotSupportedException>(
+                    () =>
+                    {
+                        obj = new UnknownWrapper(new object());
+                        Marshal_ByRef_Object_IUnknown(ref obj);
+                    },
+                    "Built-in COM has been disabled via a feature switch");
         }
 
         obj = DecimalValue;
@@ -209,6 +263,29 @@ private unsafe static void TestFieldByValue(bool hasComSupport)
 
             wrapper.value = new UnknownWrapper(new object());
             Assert.IsTrue(Marshal_Struct_ByValue_Object_IUnknown(wrapper));
+
+            wrapper.value = new GenerateIClassX();
+            Assert.IsTrue(Marshal_Struct_ByValue_Object(wrapper));
+
+            wrapper.value = new UnknownWrapper(new GenerateIClassX());
+            Assert.IsTrue(Marshal_Struct_ByValue_Object_IUnknown(wrapper));
+        }
+        else
+        {
+            Assert.Throws<NotSupportedException>(
+                () =>
+                {
+                    wrapper.value = new object();
+                    Marshal_Struct_ByValue_Object(wrapper);
+                },
+                "Built-in COM has been disabled via a feature switch");
+            Assert.Throws<NotSupportedException>(
+                () =>
+                {
+                    wrapper.value = new UnknownWrapper(new object());
+                    Marshal_Struct_ByValue_Object_IUnknown(wrapper);
+                },
+                "Built-in COM has been disabled via a feature switch");
         }
     }
 
@@ -283,6 +360,29 @@ private unsafe static void TestFieldByRef(bool hasComSupport)
 
             wrapper.value = new UnknownWrapper(new object());
             Assert.IsTrue(Marshal_Struct_ByRef_Object_IUnknown(ref wrapper));
+
+            wrapper.value = new GenerateIClassX();
+            Assert.IsTrue(Marshal_Struct_ByRef_Object(ref wrapper));
+
+            wrapper.value = new UnknownWrapper(new GenerateIClassX());
+            Assert.IsTrue(Marshal_Struct_ByRef_Object_IUnknown(ref wrapper));
+        }
+        else
+        {
+            Assert.Throws<NotSupportedException>(
+                    () =>
+                    {
+                        wrapper.value = new object();
+                        Marshal_Struct_ByRef_Object(ref wrapper);
+                    },
+                    "Built-in COM has been disabled via a feature switch");
+            Assert.Throws<NotSupportedException>(
+                    () =>
+                    {
+                        wrapper.value = new UnknownWrapper(new object());
+                        Marshal_Struct_ByRef_Object_IUnknown(ref wrapper);
+                    },
+                    "Built-in COM has been disabled via a feature switch");
         }
     }
 }
diff --git a/src/tests/Interop/SuppressGCTransition/SuppressGCTransitionTest.cs b/src/tests/Interop/SuppressGCTransition/SuppressGCTransitionTest.cs
index 2c494865bef64b..b33941eade4726 100644
--- a/src/tests/Interop/SuppressGCTransition/SuppressGCTransitionTest.cs
+++ b/src/tests/Interop/SuppressGCTransition/SuppressGCTransitionTest.cs
@@ -94,7 +94,7 @@ private static IntPtr GetNativeLibrary()
             $"lib{nameof(SuppressGCTransitionNative)}.dylib",
         };
 
-        string binDir = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
+        string binDir = AppContext.BaseDirectory;
         foreach (var ln in libNames)
         {
             if (NativeLibrary.TryLoad(Path.Combine(binDir, ln), out IntPtr mod))
diff --git a/src/tests/Interop/common/CheckGCMode.cs b/src/tests/Interop/common/CheckGCMode.cs
index e895cd594713e6..e3c6da3518aa33 100644
--- a/src/tests/Interop/common/CheckGCMode.cs
+++ b/src/tests/Interop/common/CheckGCMode.cs
@@ -3,6 +3,7 @@
 
 using System;
 using System.Reflection;
+using System.Runtime.InteropServices;
 
 using TestLibrary;
 
@@ -13,8 +14,7 @@ internal static void Initialize(delegate* <delegate* unmanaged<int>, void> setIs
     {
         // GetIsInCooperativeGCModeFunctionPointer is conditionally included based on the runtime build configuration,
         // so we check for its existence and only do the explicit mode validation if it is available.
-        Type marshalType = typeof(object).Assembly.GetType(typeof(System.Runtime.InteropServices.Marshal).FullName);
-        MethodInfo getFunctionPtr = marshalType.GetMethod("GetIsInCooperativeGCModeFunctionPointer", BindingFlags.NonPublic | BindingFlags.Static);
+        MethodInfo getFunctionPtr = typeof(Marshal).GetMethod("GetIsInCooperativeGCModeFunctionPointer", BindingFlags.NonPublic | BindingFlags.Static);
         if (getFunctionPtr != null)
         {
             var isInCooperativeModeFunc = (delegate* unmanaged<int>)(IntPtr)getFunctionPtr.Invoke(null, null);
diff --git a/src/tests/JIT/Regression/JitBlue/Runtime_52320/Runtime_52320.cs b/src/tests/JIT/Regression/JitBlue/Runtime_52320/Runtime_52320.cs
new file mode 100644
index 00000000000000..31b7b9dc749e4c
--- /dev/null
+++ b/src/tests/JIT/Regression/JitBlue/Runtime_52320/Runtime_52320.cs
@@ -0,0 +1,28 @@
+// 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.CompilerServices;
+using System.Diagnostics;
+
+namespace Runtime_52320
+{
+    public class Program
+    {
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        private static bool UseAsgOpt(int a)
+        {
+            Unsafe.InitBlock(ref Unsafe.As<int, byte>(ref a), 0, 2);
+            return a == 1 << 20;
+        }
+        static int Main(string[] args)
+        {
+            bool res = UseAsgOpt(1 << 20);
+            Debug.Assert(res);
+            if (!res)
+            {
+                return 101;
+            }
+            return 100;
+        }
+    }
+}
diff --git a/src/tests/JIT/Regression/JitBlue/Runtime_52320/Runtime_52320.csproj b/src/tests/JIT/Regression/JitBlue/Runtime_52320/Runtime_52320.csproj
new file mode 100644
index 00000000000000..570644f1dbcb7e
--- /dev/null
+++ b/src/tests/JIT/Regression/JitBlue/Runtime_52320/Runtime_52320.csproj
@@ -0,0 +1,8 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="$(MSBuildProjectName).cs" />
+  </ItemGroup>
+</Project>
diff --git a/src/tests/JIT/SIMD/VectorSum.cs b/src/tests/JIT/SIMD/VectorSum.cs
new file mode 100644
index 00000000000000..0a6bf6796a0ac5
--- /dev/null
+++ b/src/tests/JIT/SIMD/VectorSum.cs
@@ -0,0 +1,77 @@
+// 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.Numerics;
+using System.Runtime.Intrinsics.Arm;
+using System.Runtime.Intrinsics.X86;
+
+internal partial class VectorTest
+{
+    private const int Pass = 100;
+    private const int Fail = -1;
+
+    private class VectorSumTest<T> where T : struct, IComparable<T>, IEquatable<T>
+    {
+        public static int VectorSum(T a, T b)
+        {
+            Vector<T> A = new Vector<T>(a);
+            T B = Vector.Sum(A);
+
+            if (!(CheckValue<T>(B, b)))
+            {
+                return Fail;
+            }
+            return Pass;
+        }
+    }
+
+    private static int Main()
+    {
+        int returnVal = Pass;
+
+        if (VectorSumTest<float>.VectorSum(1, (float)Vector<float>.Count) != Pass) returnVal = Fail;
+        if (VectorSumTest<double>.VectorSum(1, (double)Vector<double>.Count) != Pass) returnVal = Fail;
+        if (VectorSumTest<int>.VectorSum(1, (int)Vector<int>.Count) != Pass) returnVal = Fail;
+        if (VectorSumTest<long>.VectorSum(1, (long)Vector<long>.Count) != Pass) returnVal = Fail;
+        if (VectorSumTest<ushort>.VectorSum(1, (ushort)Vector<ushort>.Count) != Pass) returnVal = Fail;
+        if (VectorSumTest<byte>.VectorSum(1, (byte)Vector<byte>.Count) != Pass) returnVal = Fail;
+        if (VectorSumTest<short>.VectorSum(-1, (short)(-Vector<short>.Count)) != Pass) returnVal = Fail;
+        if (VectorSumTest<sbyte>.VectorSum(-1, (sbyte)(-Vector<sbyte>.Count)) != Pass) returnVal = Fail;
+        if (VectorSumTest<uint>.VectorSum(0x41000000u, 0x41000000u * (uint)Vector<uint>.Count) != Pass) returnVal = Fail;
+        if (VectorSumTest<ulong>.VectorSum(0x4100000000000000ul, 0x4100000000000000ul * (uint)Vector<ulong>.Count) != Pass) returnVal = Fail;
+        if (VectorSumTest<nint>.VectorSum(1, (nint)Vector<nint>.Count) != Pass) returnVal = Fail;
+        if (VectorSumTest<nuint>.VectorSum(0x41000000u, 0x41000000u * (nuint)(uint)Vector<nuint>.Count) != Pass) returnVal = Fail;
+
+        JitLog jitLog = new JitLog();
+
+        if (Sse3.IsSupported || AdvSimd.IsSupported)
+        {
+            if (!jitLog.Check("Sum", "Single")) returnVal = Fail;
+            if (!jitLog.Check("Sum", "Double")) returnVal = Fail;
+        }
+
+        if (Ssse3.IsSupported || AdvSimd.IsSupported)
+        {
+            if (!jitLog.Check("Sum", "Int16")) returnVal = Fail;
+            if (!jitLog.Check("Sum", "Int32")) returnVal = Fail;
+            if (!jitLog.Check("Sum", "UInt16")) returnVal = Fail;
+            if (!jitLog.Check("Sum", "UInt32")) returnVal = Fail;
+        }
+
+        if (AdvSimd.IsSupported)
+        {
+            if (!jitLog.Check("Sum", "Byte")) returnVal = Fail;
+            if (!jitLog.Check("Sum", "Int64")) returnVal = Fail;
+            if (!jitLog.Check("Sum", "IntPtr")) returnVal = Fail;
+            if (!jitLog.Check("Sum", "SByte")) returnVal = Fail;
+            if (!jitLog.Check("Sum", "UInt64")) returnVal = Fail;
+            if (!jitLog.Check("Sum", "UIntPtr")) returnVal = Fail;
+        }
+
+        jitLog.Dispose();
+
+        return returnVal;
+    }
+}
diff --git a/src/tests/JIT/SIMD/VectorSum_r.csproj b/src/tests/JIT/SIMD/VectorSum_r.csproj
new file mode 100644
index 00000000000000..56a3fade41a3b7
--- /dev/null
+++ b/src/tests/JIT/SIMD/VectorSum_r.csproj
@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+  </PropertyGroup>
+  <PropertyGroup>
+    <DebugType>None</DebugType>
+    <Optimize />
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="VectorSum.cs" />
+    <Compile Include="VectorUtil.cs" />
+  </ItemGroup>
+</Project>
diff --git a/src/tests/JIT/SIMD/VectorSum_ro.csproj b/src/tests/JIT/SIMD/VectorSum_ro.csproj
new file mode 100644
index 00000000000000..3a4794cd56acd7
--- /dev/null
+++ b/src/tests/JIT/SIMD/VectorSum_ro.csproj
@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+  </PropertyGroup>
+  <PropertyGroup>
+    <DebugType>None</DebugType>
+    <Optimize>True</Optimize>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="VectorSum.cs" />
+    <Compile Include="VectorUtil.cs" />
+  </ItemGroup>
+</Project>
diff --git a/src/tests/JIT/opt/Devirtualization/GitHub_51918.cs b/src/tests/JIT/opt/Devirtualization/GitHub_51918.cs
new file mode 100644
index 00000000000000..0191f2f86b03b1
--- /dev/null
+++ b/src/tests/JIT/opt/Devirtualization/GitHub_51918.cs
@@ -0,0 +1,61 @@
+using System;
+
+public interface IGeneric<T>
+{
+    int InterfaceMethod();
+}
+
+public interface IMakeClassMethodSealedVirtual
+{
+    int ClassMethod();
+}
+
+public class GenericClass<A,B> : IMakeClassMethodSealedVirtual
+{
+    public static int _sv1;
+    public static int _sv2;
+
+    public int _v1;
+    public int _v2;
+
+    public GenericClass()
+    {
+        _v1 = _sv1++;
+        _v2 = _sv2++;
+    }
+
+    public int ClassMethod()
+    {
+        return _v1 - _v2;
+    }
+
+    public InnerClass GetInnerClass() => new InnerClass(this);
+  
+    public sealed class InnerClass : IGeneric<A>
+    {
+        GenericClass<A,B> _localPointer;
+
+        public InnerClass(GenericClass<A,B> pointer)
+        {
+            _localPointer = pointer;
+        }
+
+        public int InterfaceMethod() => _localPointer.ClassMethod();
+    }
+}
+
+public class GitHub_51918
+{
+    public static int Main()
+    {
+        IGeneric<int> genInterface = new GenericClass<int, string>().GetInnerClass();
+        // Validate that two levels of inlining we don't behave incorrectly due to generic
+        // canonicalization. (Devirtualize the interface call, and then devirtualize/inline
+        // the call to ClassMethod)
+        Console.WriteLine(genInterface.InterfaceMethod());
+        if (genInterface.InterfaceMethod() == 0)
+            return 100;
+
+        return 1;
+    }
+}
diff --git a/src/tests/hosting/stress/testset1/simple1.csproj b/src/tests/JIT/opt/Devirtualization/GitHub_51918.csproj
similarity index 56%
rename from src/tests/hosting/stress/testset1/simple1.csproj
rename to src/tests/JIT/opt/Devirtualization/GitHub_51918.csproj
index fa67791de7f907..76c35b1994db99 100644
--- a/src/tests/hosting/stress/testset1/simple1.csproj
+++ b/src/tests/JIT/opt/Devirtualization/GitHub_51918.csproj
@@ -1,11 +1,13 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
     <CLRTestPriority>1</CLRTestPriority>
   </PropertyGroup>
+  <PropertyGroup>
+    <DebugType>None</DebugType>
+    <Optimize>True</Optimize>
+  </PropertyGroup>
   <ItemGroup>
-    <Compile Include="simple1.cs" />
+    <Compile Include="GitHub_51918.cs" />
   </ItemGroup>
 </Project>
diff --git a/src/tests/JIT/opt/Devirtualization/generic_noinline.cs b/src/tests/JIT/opt/Devirtualization/generic_noinline.cs
new file mode 100644
index 00000000000000..541478c8312385
--- /dev/null
+++ b/src/tests/JIT/opt/Devirtualization/generic_noinline.cs
@@ -0,0 +1,30 @@
+// 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;
+
+class Program
+{
+    static int Main()
+    {
+        MyStruct<Atom> s = default;
+
+        // RyuJIT can devirtualize this, but NoInlining prevents the inline
+        // This checks that we properly pass the instantiation context to the shared generic method.
+        return ((IFoo)s).GetTheType() == typeof(Atom) ? 100 : -1;
+    }
+}
+
+interface IFoo
+{
+    Type GetTheType();
+}
+
+struct MyStruct<T> : IFoo
+{
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    Type IFoo.GetTheType() => typeof(T);
+}
+
+class Atom { }
diff --git a/src/tests/JIT/opt/Devirtualization/generic_noinline.csproj b/src/tests/JIT/opt/Devirtualization/generic_noinline.csproj
new file mode 100644
index 00000000000000..80b62656678a80
--- /dev/null
+++ b/src/tests/JIT/opt/Devirtualization/generic_noinline.csproj
@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <CLRTestPriority>0</CLRTestPriority>
+  </PropertyGroup>
+  <PropertyGroup>
+    <DebugType>PdbOnly</DebugType>
+    <Optimize>True</Optimize>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="generic_noinline.cs" />
+  </ItemGroup>
+</Project>
diff --git a/src/tests/Loader/binding/tracing/BinderTracingTest.targets b/src/tests/Loader/binding/tracing/BinderTracingTest.targets
index 732b2ce139923b..426a5556093f14 100644
--- a/src/tests/Loader/binding/tracing/BinderTracingTest.targets
+++ b/src/tests/Loader/binding/tracing/BinderTracingTest.targets
@@ -40,9 +40,9 @@
       <AssemblyToLoadResourceCulture>fr-FR</AssemblyToLoadResourceCulture>
     </PropertyGroup>
     <ItemGroup>
-      <SatelliteAssembliesToMove Include="$(OutDir)/AssemblyToLoad_*.resources.*" />
+      <SatelliteAssembliesToMove Include="$(OutDir)/**/AssemblyToLoad_*.resources.*" />
       <AssembliesToCopy Include="$(OutDir)/AssemblyToLoad.dll" />
-      <AssembliesToMove Include="$(OutDir)/AssemblyToLoad_*.*" Exclude="@(SatelliteAssembliesToMove)" />
+      <AssembliesToMove Include="$(OutDir)/AssemblyToLoad_*.*" />
       <AssembliesToMove Include="$(OutDir)/AssemblyToLoadDependency.*" />
     </ItemGroup>
     <Copy SourceFiles="@(AssembliesToCopy)" DestinationFolder="$(OutDir)/DependentAssemblies" />
diff --git a/src/tests/Loader/classloader/regressions/dd52/runtest.cs b/src/tests/Loader/classloader/regressions/dd52/runtest.cs
index 7b22f093f0d6b7..6b9e3a6d9166f3 100644
--- a/src/tests/Loader/classloader/regressions/dd52/runtest.cs
+++ b/src/tests/Loader/classloader/regressions/dd52/runtest.cs
@@ -9,13 +9,26 @@ public class Test
    public static int Main()
    {
       Console.WriteLine();
+      bool failed = false;
 
 
       C28<int> obj405 = new C28<int>();
 
 
       Console.WriteLine(obj405.M28());
+      if (obj405.M28() != 54)
+      {
+          failed = true;
+          Console.WriteLine("FAIL");
+      }
+
       Console.WriteLine(obj405.M3());
+      if (obj405.M3() != 54)
+      {
+          failed = true;
+          Console.WriteLine("FAIL");
+      }
+
       Console.WriteLine();
 
 
@@ -23,18 +36,46 @@ public static int Main()
 
 
       Console.WriteLine(obj433.M28());
+      if (obj433.M28() != 56)
+      {
+          failed = true;
+          Console.WriteLine("FAIL");
+      }
 
       Console.WriteLine(obj433.M3());
+      if (obj433.M3() != 56)
+      {
+          failed = true;
+          Console.WriteLine("FAIL");
+      }
 
 
       C29 obj434 = new C29();
 
 
       Console.WriteLine(obj434.M28());
+      if (obj434.M28() != 56)
+      {
+          failed = true;
+          Console.WriteLine("FAIL");
+      }
       Console.WriteLine(obj434.M3());
+      if (obj434.M3() != 56)
+      {
+          failed = true;
+          Console.WriteLine("FAIL");
+      }
       Console.WriteLine();
       Console.WriteLine("PASS");
 
-      return 100;
+      if (failed)
+      {
+          return 1;
+      }
+      else
+      {
+          Console.WriteLine("PASS");
+          return 100;
+      }
    }
 }
diff --git a/src/tests/baseservices/TieredCompilation/BasicTestWithMcj.csproj b/src/tests/baseservices/TieredCompilation/BasicTestWithMcj.csproj
index be0451e46b4e1f..a25cf031089641 100644
--- a/src/tests/baseservices/TieredCompilation/BasicTestWithMcj.csproj
+++ b/src/tests/baseservices/TieredCompilation/BasicTestWithMcj.csproj
@@ -4,6 +4,8 @@
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <Optimize>true</Optimize>
     <CLRTestPriority>0</CLRTestPriority>
+    <!-- Disable test for GCStress. Tracking: https://github.com/dotnet/runtime/issues/54203 -->
+    <GCStressIncompatible>true</GCStressIncompatible>
     <!-- Generated shell script and corresponding assembly have different names -->
     <CLRTestTargetUnsupported Condition="'$(TargetOS)' == 'Android'">true</CLRTestTargetUnsupported>
   </PropertyGroup>
@@ -22,13 +24,13 @@
     <CLRTestBatchPreCommands><![CDATA[
 $(CLRTestBatchPreCommands)
 mkdir r2r
-"%CORE_ROOT%\crossgen" -ReadyToRun -Platform_Assemblies_Paths "%CORE_ROOT%" -out r2r\$(MSBuildProjectName).dll $(MSBuildProjectName).dll
+"%CORE_ROOT%\corerun" %CORE_ROOT%\crossgen2\crossgen2.dll --out r2r\$(MSBuildProjectName).dll $(MSBuildProjectName).dll -r %CORE_ROOT%\*.dll
 set CLRCustomTestLauncher=RunBasicTestWithMcj.cmd --runCustomTest
 ]]></CLRTestBatchPreCommands>
     <BashCLRTestPreCommands><![CDATA[
 $(BashCLRTestPreCommands)
 mkdir r2r
-"$CORE_ROOT/crossgen" -ReadyToRun -Platform_Assemblies_Paths "$CORE_ROOT" -out r2r/$(MSBuildProjectName).dll $(MSBuildProjectName).dll
+"$CORE_ROOT/corerun" $CORE_ROOT/crossgen2/crossgen2.dll --out r2r/$(MSBuildProjectName).dll $(MSBuildProjectName).dll -r $CORE_ROOT/*.dll
 chmod +x ./RunBasicTestWithMcj.sh
 export CLRCustomTestLauncher="./RunBasicTestWithMcj.sh --runCustomTest"
 ]]></BashCLRTestPreCommands>
diff --git a/src/tests/baseservices/threading/threadstatic/threadstatic08.cs b/src/tests/baseservices/threading/threadstatic/threadstatic08.cs
new file mode 100644
index 00000000000000..daad2427f71625
--- /dev/null
+++ b/src/tests/baseservices/threading/threadstatic/threadstatic08.cs
@@ -0,0 +1,38 @@
+// 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.Threading;
+
+public struct Struct
+{
+    public uint a;
+    public uint b;
+}
+
+public class Program
+{
+    [ThreadStatic]
+    private static Struct TSStruct;
+
+    public static int Main(string[] args)
+    {
+        if(TSStruct.a != 0 || TSStruct.b != 0)
+            return 101;
+
+        Struct str = new Struct ();
+        str.a = 0xdeadbeef;
+        str.b = 0xba5eba11;
+
+        TSStruct = str;
+        if(TSStruct.a != 0xdeadbeef || TSStruct.b != 0xba5eba11)
+            return 102;
+
+        Struct str2 = TSStruct;
+        if(str2.a != 0xdeadbeef || str2.b != 0xba5eba11)
+            return 103;
+
+        Console.WriteLine("Test Succeeded.");
+        return 100;
+    }
+}
diff --git a/src/tests/baseservices/threading/threadstatic/threadstatic08.csproj b/src/tests/baseservices/threading/threadstatic/threadstatic08.csproj
new file mode 100644
index 00000000000000..53521da250db75
--- /dev/null
+++ b/src/tests/baseservices/threading/threadstatic/threadstatic08.csproj
@@ -0,0 +1,9 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <CLRTestPriority>0</CLRTestPriority>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="threadstatic08.cs" />
+  </ItemGroup>
+</Project>
diff --git a/src/tests/build.cmd b/src/tests/build.cmd
index 18a85d6ae62214..cb8834ad0b021c 100644
--- a/src/tests/build.cmd
+++ b/src/tests/build.cmd
@@ -47,9 +47,9 @@ set __SkipTestWrappers=
 set __BuildTestWrappersOnly=
 set __SkipNative=
 set __TargetsWindows=1
-set __DoCrossgen=
 set __DoCrossgen2=
 set __CompositeBuildMode=
+set __TestBuildMode=
 set __CreatePdb=
 set __CopyNativeTestBinaries=0
 set __CopyNativeProjectsAfterCombinedTestBuild=true
@@ -100,7 +100,6 @@ if /i "%1" == "buildtestwrappersonly" (set __SkipNative=1&set __SkipManaged=1&se
 
 if /i "%1" == "-msbuild"              (set __Ninja=0&set processedArgs=!processedArgs! %1&shift&goto Arg_Loop)
 if /i "%1" == "buildagainstpackages"  (echo error: Remove /BuildAgainstPackages switch&&exit /b1)
-if /i "%1" == "crossgen"              (set __DoCrossgen=1&set __TestBuildMode=crossgen&set processedArgs=!processedArgs! %1&shift&goto Arg_Loop)
 if /i "%1" == "crossgen2"             (set __DoCrossgen2=1&set __TestBuildMode=crossgen2&set processedArgs=!processedArgs! %1&shift&goto Arg_Loop)
 if /i "%1" == "composite"             (set __CompositeBuildMode=1&set __DoCrossgen2=1&set __TestBuildMode=crossgen2&set processedArgs=!processedArgs! %1&shift&goto Arg_Loop)
 if /i "%1" == "pdb"                   (set __CreatePdb=1&shift&goto Arg_Loop)
@@ -506,23 +505,7 @@ REM ============================================================================
 if defined __SkipCrossgenFramework goto SkipCrossgen
 if defined __BuildTestWrappersOnly goto SkipCrossgen
 
-set __CrossgenArg = ""
-if defined __DoCrossgen (
-    set __CrossgenArg="/p:Crossgen=true"
-    if "%__TargetsWindows%" == "1" (
-        echo %__MsgPrefix%Running crossgen on framework assemblies in CORE_ROOT: %CORE_ROOT%
-        call :PrecompileFX
-        if ERRORLEVEL 1 (
-            echo %__ErrMsgPrefix%%__MsgPrefix%Error: crossgen precompilation of framework assemblies failed
-            exit /b 1
-        )
-    ) else (
-        echo "%__MsgPrefix%Crossgen only supported on Windows, for now"
-    )
-)
-
 if defined __DoCrossgen2 (
-    set __CrossgenArg="/p:Crossgen2=true"
     echo %__MsgPrefix%Running crossgen2 on framework assemblies in CORE_ROOT: %CORE_ROOT%
     call :PrecompileFX
     if ERRORLEVEL 1 (
@@ -555,14 +538,17 @@ echo.
 echo.-? -h -help --help: view this message.
 echo Build architecture: one of x64, x86, arm, arm64 ^(default: x64^).
 echo Build type: one of Debug, Checked, Release ^(default: Debug^).
+echo skipgeneratelayout: Do not generate the Core_Root layout
 echo skipmanaged: skip the managed tests build
 echo skipnative: skip the native tests build
 echo skiprestorepackages: skip package restore
-echo crossgen: Precompiles the framework managed assemblies
+echo skiptestwrappers: skip generating test wrappers
+echo buildtestwrappersonly: generate test wrappers without building managed or native test components or generating layouts
 echo copynativeonly: Only copy the native test binaries to the managed output. Do not build the native or managed tests.
-echo skipgeneratelayout: Do not generate the Core_Root layout
+echo crossgen2: Precompiles the framework managed assemblies
+echo composite: Precompiles the framework managed assemblies in composite build mode
+echo pdb: create PDB files when precompiling the framework managed assemblies
 echo generatelayoutonly: Generate the Core_Root layout without building managed or native test components
-echo targetsNonWindows:
 echo Exclude- Optional parameter - specify location of default exclusion file ^(defaults to tests\issues.targets if not specified^)
 echo     Set to "" to disable default exclusion file.
 echo -- ... : all arguments following this tag will be passed directly to msbuild.
@@ -591,32 +577,20 @@ if defined __CompositeBuildMode (
 )
 
 set __CrossgenDir=%__BinDir%
-if defined __DoCrossgen (
-    if /i "%__BuildArch%" == "arm" (
-        set __CrossgenDir=!__CrossgenDir!\x86
-    )
-    if /i "%__BuildArch%" == "arm64" (
-        set __CrossgenDir=!__CrossgenDir!\x64
-    )
-    set __CrossgenCmd=%__CrossgenCmd% --crossgen --nocrossgen2 --crossgen-path "!__CrossgenDir!\crossgen.exe"
-) else (
-    if /i "%__BuildArch%" == "arm" (
-        set __CrossgenDir=!__CrossgenDir!\x64
-    )
-    if /i "%__BuildArch%" == "arm64" (
-        set __CrossgenDir=!__CrossgenDir!\x64
-    )
-    if /i "%__BuildArch%" == "x86" (
-        set __CrossgenDir=!__CrossgenDir!\x64
-    )
-    set __CrossgenCmd=%__CrossgenCmd% --verify-type-and-field-layout --crossgen2-path "!__CrossgenDir!\crossgen2\crossgen2.dll"
+if /i "%__BuildArch%" == "arm" (
+    set __CrossgenDir=!__CrossgenDir!\x64
+)
+if /i "%__BuildArch%" == "arm64" (
+    set __CrossgenDir=!__CrossgenDir!\x64
 )
+if /i "%__BuildArch%" == "x86" (
+    set __CrossgenDir=!__CrossgenDir!\x64
+)
+set __CrossgenCmd=%__CrossgenCmd% --verify-type-and-field-layout --crossgen2-path "!__CrossgenDir!\crossgen2\crossgen2.dll"
 
 echo Running %__CrossgenCmd%
 call %__CrossgenCmd%
-set /a __exitCode = !errorlevel!
-
-if %__exitCode% neq 0 (
+if %errorlevel% neq 0 (
     echo Failed to crossgen the framework
     exit /b 1
 )
diff --git a/src/tests/build.proj b/src/tests/build.proj
index edcddbc297ebe9..d1ce4ab95ba51a 100644
--- a/src/tests/build.proj
+++ b/src/tests/build.proj
@@ -1,14 +1,12 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<Project DefaultTargets="Build">
   <Import Project="Directory.Build.props" />
 
   <ItemGroup>
     <Project Include="$(MSBuildThisFileDirectory)Common\dirs.proj" />
   </ItemGroup>
 
-  <Import Project="$(RepoRoot)\src\tests\Directory.Build.targets" />
-
-  <Import Project="$(RepoRoot)\src\tests\Common\dir.traversal.targets" />
+  <Import Project="Directory.Build.targets" />
+  <Import Project="Common\dir.traversal.targets" />
 
   <PropertyGroup>
     <TraversalBuildDependsOn>
@@ -18,18 +16,17 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <RestoreProjects Include="$(MSBuildThisFileDirectory)Common\scripts\scripts.csproj" />
-    <RestoreProjects Include="$(MSBuildThisFileDirectory)Common\test_dependencies_fs\test_dependencies.fsproj" />
-    <RestoreProjects Include="$(MSBuildThisFileDirectory)Common\test_dependencies\test_dependencies.csproj" />
-    <RestoreProjects Include="$(MSBuildThisFileDirectory)Common\CoreCLRTestLibrary\CoreCLRTestLibrary.csproj" />
-    <RestoreProjects Include="$(MSBuildThisFileDirectory)Common\external\external.csproj" />
-    <RestoreProjects Include="$(MSBuildThisFileDirectory)Common\ilasm\ilasm.ilproj" />
+    <RestoreProjects Include="Common\test_dependencies_fs\test_dependencies.fsproj" />
+    <RestoreProjects Include="Common\test_dependencies\test_dependencies.csproj" />
+    <RestoreProjects Include="Common\CoreCLRTestLibrary\CoreCLRTestLibrary.csproj" />
+    <RestoreProjects Include="Common\external\external.csproj" />
+    <RestoreProjects Include="Common\ilasm\ilasm.ilproj" />
   </ItemGroup>
 
   <Target Name="BuildTargetingPack" AfterTargets="BatchRestorePackages" Condition="$(__SkipTargetingPackBuild) != 'true'">
     <Message Text="Building Targeting Pack" Importance="High" />
-    <Error  Text="TargetOS has not been specified. Please do that then run build again."  Condition="'$(TargetOS)' == 'AnyOS'" />
-    <MSBuild Projects="$(MSBuildThisFileDirectory)Common\external\external.csproj"
+    <Error Text="TargetOS has not been specified. Please do that then run build again." Condition="'$(TargetOS)' == 'AnyOS'" />
+    <MSBuild Projects="Common\external\external.csproj"
              Targets="Build" />
   </Target>
 
diff --git a/src/tests/build.sh b/src/tests/build.sh
index 0d15d53b53910e..da6fa03e1cfcff 100755
--- a/src/tests/build.sh
+++ b/src/tests/build.sh
@@ -133,8 +133,7 @@ generate_layout()
     build_MSBuild_projects "Tests_Overlay_Managed" "$__RepoRootDir/src/tests/run.proj" "Creating test overlay" "/t:CreateTestOverlay"
 
     # Precompile framework assemblies with crossgen if required
-    if [[ "$__DoCrossgen" != 0 || "$__DoCrossgen2" != 0 ]]; then
-        chmod +x "$__CrossgenExe"
+    if [[ "$__DoCrossgen2" != 0 ]]; then
         if [[ "$__SkipCrossgenFramework" == 0 ]]; then
             precompile_coreroot_fx
         fi
@@ -171,11 +170,7 @@ precompile_coreroot_fx()
         crossgenDir="$crossgenDir/$__HostArch"
     fi
 
-    if [[ "$__DoCrossgen" != 0 ]]; then
-        crossgenCmd="$crossgenCmd --crossgen --nocrossgen2 --crossgen-path \"$crossgenDir/crossgen\""
-    else
-        crossgenCmd="$crossgenCmd --verify-type-and-field-layout --crossgen2-path \"$crossgenDir/crossgen2/crossgen2.dll\""
-    fi
+    crossgenCmd="$crossgenCmd --verify-type-and-field-layout --crossgen2-path \"$crossgenDir/crossgen2/crossgen2.dll\""
 
     echo "Running $crossgenCmd"
     eval $crossgenCmd
@@ -191,17 +186,6 @@ precompile_coreroot_fx()
     return 0
 }
 
-declare -a skipCrossGenFiles
-
-function is_skip_crossgen_test {
-    for skip in "${skipCrossGenFiles[@]}"; do
-        if [[ "$1" == "$skip" ]]; then
-            return 0
-        fi
-    done
-    return 1
-}
-
 build_Tests()
 {
     echo "${__MsgPrefix}Building Tests..."
@@ -447,7 +431,6 @@ usage_list+=("-buildtestwrappersonly: only build the test wrappers.")
 usage_list+=("-copynativeonly: Only copy the native test binaries to the managed output. Do not build the native or managed tests.")
 usage_list+=("-generatelayoutonly: only pull down dependencies and build coreroot.")
 
-usage_list+=("-crossgen: Precompiles the framework managed assemblies in coreroot.")
 usage_list+=("-crossgen2: Precompiles the framework managed assemblies in coreroot using the Crossgen2 compiler.")
 usage_list+=("-priority1: include priority=1 tests in the build.")
 usage_list+=("-allTargets: Build managed tests for all target platforms.")
@@ -480,11 +463,6 @@ handle_arguments_local() {
             __SkipCrossgenFramework=1
             ;;
 
-        crossgen|-crossgen)
-            __DoCrossgen=1
-            __TestBuildMode=crossgen
-            ;;
-
         crossgen2|-crossgen2)
             __DoCrossgen2=1
             __TestBuildMode=crossgen2
@@ -559,9 +537,9 @@ __CopyNativeProjectsAfterCombinedTestBuild=true
 __CopyNativeTestBinaries=0
 __CrossBuild=0
 __DistroRid=""
-__DoCrossgen=0
 __DoCrossgen2=0
 __CompositeBuildMode=0
+__TestBuildMode=
 __DotNetCli="$__RepoRootDir/dotnet.sh"
 __GenerateLayoutOnly=
 __IsMSBuildOnNETCoreSupported=0
@@ -607,18 +585,9 @@ __TestDir="$__RepoRootDir/src/tests"
 __TestWorkingDir="$__RootBinDir/tests/coreclr/$__OSPlatformConfig"
 __IntermediatesDir="$__RootBinDir/obj/coreclr/$__OSPlatformConfig"
 __TestIntermediatesDir="$__RootBinDir/tests/coreclr/obj/$__OSPlatformConfig"
-__CrossComponentBinDir="$__BinDir"
 __CrossCompIntermediatesDir="$__IntermediatesDir/crossgen"
 __MonoBinDir="$__RootBinDir/bin/mono/$__OSPlatformConfig"
 
-__CrossArch="$__HostArch"
-if [[ "$__CrossBuild" == 1 ]]; then
-    __CrossComponentBinDir="$__CrossComponentBinDir/$__CrossArch"
-fi
-__CrossgenCoreLibLog="$__LogsDir/CrossgenCoreLib_$__TargetOS.$BuildArch.$__BuildType.log"
-__CrossgenExe="$__CrossComponentBinDir/crossgen"
-__Crossgen2Dll="$__CrossComponentBinDir/crossgen2/crossgen2.dll"
-
 # CI_SPECIFIC - On CI machines, $HOME may not be set. In such a case, create a subfolder and set the variable to it.
 # This is needed by CLI to function.
 if [[ -z "$HOME" ]]; then
diff --git a/src/tests/hosting/stress/testset1/csgen.1.cs b/src/tests/hosting/stress/testset1/csgen.1.cs
deleted file mode 100644
index 8180ae2f851c4c..00000000000000
--- a/src/tests/hosting/stress/testset1/csgen.1.cs
+++ /dev/null
@@ -1,461 +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.Collections;
-using System.Runtime.InteropServices;
-
-#pragma warning disable 1717
-#pragma warning disable 0219
-
-public enum TestEnum
-{
-	red = 1,
-	green = 2,
-	blue = 4,
-}
-
-public class AA<TA, TB> where TA:  IComparable 
-{
-	public TB m_agboGeneric1;
-	public static void Static1(Array param1, ref TB param2, ulong[,,] param3, ref 
-		byte param4)
-	{
-		if (App.m_bFwd1)
-			goto label1;
-		label1:
-		while (App.m_bFwd1)
-		{
-			TestEnum[,] local1 = (new TestEnum[28u, 111u]);
-			long local2 = App.m_lFwd2;
-			if (App.m_bFwd1)
-				param3 = param3;
-			else
-			{
-				uint local3 = 51u;
-				TestEnum[,,][,][] local4 = (new TestEnum[116u, 1u, 102u][,][]);
-				do
-				{
-					throw new NullReferenceException();
-				}
-				while(App.m_bFwd1);
-				param1 = param1;
-				local2 -= local2;
-				if (App.m_bFwd1)
-					try
-					{
-						Array[,][,][,,][][,][,][][] local5 = (new Array[83u, 103u]
-							[,][,,][][,][,][][]);
-						Array[,,] local6 = (new Array[30u, 6u, 41u]);
-						param3[34, 110, 27] = App.m_ulFwd3;
-						param1 = param1;
-						local6[80, 2, 50] = param1;
-						local1[63, 60] = TestEnum.red;
-					}
-					catch (NullReferenceException)
-					{
-						bool local7 = true;
-						if (local7)
-							continue;
-					}
-				else
-					if (App.m_bFwd1)
-						if (App.m_bFwd1)
-							local3 = local3;
-						else
-							local2 -= local2;
-			}
-			param2 = param2;
-			try
-			{
-				char[,,][,,,,,] local8 = (new char[35u, 100u, 38u][,,,,,]);
-				char[,] local9 = (new char[97u, 33u]);
-				ulong local10 = App.m_ulFwd3;
-				param4 = param4;
-				param3 = (new ulong[63u, 9u, 18u]);
-				if (App.m_bFwd1)
-					do
-					{
-						param4 = param4;
-						local9 = (new char[125u, 118u]);
-						try
-						{
-							while (App.m_bFwd1)
-							{
-								do
-								{
-									TestEnum local11 = 0;
-									BB[] local12 = new BB[]{new BB() };
-									object[][] local13 = (new object[33u][]);
-								}
-								while(App.m_bFwd1);
-								continue;
-							}
-							try
-							{
-								BB[,,][,,][][] local14 = (new BB[76u, 111u, 60u][,,][][]);
-							}
-							finally
-							{
-							}
-							while (App.m_bFwd1)
-							{
-							}
-						}
-						catch (Exception)
-						{
-						}
-						if (App.m_bFwd1)
-							do
-							{
-							}
-							while(App.m_bFwd1);
-					}
-					while(App.m_bFwd1);
-				return;
-			}
-			catch (InvalidOperationException)
-			{
-			}
-			try
-			{
-			}
-			catch (Exception)
-			{
-			}
-		}
-		do
-		{
-		}
-		while(App.m_bFwd1);
-		;
-	}
-	public static bool[,,,] Static2(bool[,][,,] param1, ref ulong[] param2, TA 
-		param3, TB param4, TA param5, TB param6)
-	{
-		ulong local15 = App.m_ulFwd3;
-		param3 = param5;
-		local15 = local15;
-		for (App.m_byFwd4-=App.m_byFwd4; App.m_bFwd1; App.m_iFwd5++)
-		{
-			BB[][,,][,,,] local16 = new BB[][,,][,,,]{(new BB[115u, 22u, 97u][,,,]), 
-				(new BB[71u, 101u, 72u][,,,]), (new BB[94u, 124u, 8u][,,,]) };
-			TestEnum[,,,,] local17 = (new TestEnum[62u, 63u, 7u, 49u, 79u]);
-			for (App.m_fFwd6=50.0f; App.m_bFwd1; App.m_iFwd5*=121)
-			{
-				sbyte local18 = App.m_sbyFwd7;
-				ushort local19 = App.m_ushFwd8;
-				for (App.m_lFwd2=App.m_lFwd2; App.m_bFwd1; App.m_chFwd9-='\x09')
-				{
-					continue;
-				}
-			}
-			do
-			{
-				BB[,][][][,,][] local20 = (new BB[90u, 91u][][][,,][]);
-				for (App.m_iFwd5--; App.m_bFwd1; App.m_byFwd4++)
-				{
-					BB[,] local21 = (new BB[124u, 91u]);
-					long[,][,][][,] local22 = (new long[115u, 83u][,][][,]);
-					for (App.m_shFwd10=App.m_shFwd10; App.m_bFwd1; App.m_ushFwd8++)
-					{
-						char[][][,,] local23 = new char[][][,,]{ };
-						TestEnum[,,][,][,,,][] local24 = (new TestEnum[29u, 90u, 44u][,][,,,][]);
-						object[][] local25 = new object[][]{(new object[92u]), new object[]{null, 
-							null, null, null } };
-						try
-						{
-							ulong local26 = App.m_ulFwd3;
-							while (App.m_bFwd1)
-							{
-								ushort[,] local27 = (new ushort[35u, 110u]);
-								long[,] local28 = (new long[73u, 43u]);
-								param4 = param4;
-								throw new IndexOutOfRangeException();
-							}
-							if (App.m_bFwd1)
-								for (App.m_fFwd6+=7.0f; App.m_bFwd1; App.m_byFwd4++)
-								{
-									throw new DivideByZeroException();
-								}
-						}
-						catch (DivideByZeroException)
-						{
-							do
-							{
-								try
-								{
-									local21[123, 75].m_axField1[73] = new Array[][,,,]{(new Array[102u, 56u
-										, 82u, 63u]) };
-								}
-								finally
-								{
-								}
-								local22 = local22;
-								try
-								{
-								}
-								catch (DivideByZeroException)
-								{
-								}
-								try
-								{
-								}
-								catch (IndexOutOfRangeException)
-								{
-								}
-							}
-							while(App.m_bFwd1);
-							throw new NullReferenceException();
-						}
-						while (App.m_bFwd1)
-						{
-						}
-					}
-					do
-					{
-					}
-					while(App.m_bFwd1);
-					do
-					{
-					}
-					while(App.m_bFwd1);
-					local15 = local15;
-				}
-				while (App.m_bFwd1)
-				{
-				}
-				while (App.m_bFwd1)
-				{
-				}
-				throw new InvalidOperationException();
-			}
-			while(App.m_bFwd1);
-		}
-		param5 = param5;
-		return (new bool[38u, 121u, 77u, 3u]);
-	}
-	public static sbyte Static3(uint param1, ref short param2)
-	{
-		BB local29 = new BB();
-		try
-		{
-			param1 -= 33u;
-		}
-		catch (NullReferenceException)
-		{
-			ulong[] local30 = (new ulong[122u]);
-			byte local31 = App.m_byFwd4;
-			for (App.m_lFwd2++; App.m_bFwd1; App.m_chFwd9-='\x6c')
-			{
-				TestEnum[,,][][] local32 = (new TestEnum[109u, 121u, 75u][][]);
-				ushort[,,,,][][][] local33 = (new ushort[44u, 28u, 97u, 45u, 88u][][][]);
-				throw new Exception();
-			}
-			goto label2;
-		}
-		label2:
-		return App.m_sbyFwd7;
-	}
-	public static int Static4(TB param1, ref Array[][,,][,,] param2, ref TB param3
-		, char param4)
-	{
-		ushort[,,][,][][] local34 = (new ushort[18u, 54u, 39u][,][][]);
-		short local35 = App.m_shFwd10;
-		return 80;
-	}
-}
-
-public struct BB
-{
-	public Array[][][,,,] m_axField1;
-	public static void Static1(double[][,,] param1, ref bool param2, TestEnum 
-		param3, ref float param4)
-	{
-		if (param2)
-			param2 = param2;
-		else
-		{
-			for (App.m_ushFwd8+=App.m_ushFwd8; param2; App.m_ushFwd8++)
-			{
-				sbyte[][] local36 = new sbyte[][]{(new sbyte[14u]) };
-				ushort[,,] local37 = (new ushort[113u, 103u, 65u]);
-				String local38 = "108";
-				param2 = param2;
-			}
-			while (param2)
-			{
-				while (param2)
-				{
-					ushort local39 = App.m_ushFwd8;
-					if (param2)
-						try
-						{
-							BB local40 = new BB();
-							ushort local41 = App.m_ushFwd8;
-							local41 += local41;
-							do
-							{
-								for (App.m_byFwd4++; param2; App.m_lFwd2*=App.m_lFwd2)
-								{
-									ulong[,][][] local42 = (new ulong[60u, 24u][][]);
-									Array local43 = App.m_xFwd11;
-									try
-									{
-										Array[] local44 = (new Array[100u]);
-										int local45 = 17;
-										BB[][,][,][][,][] local46 = new BB[][,][,][][,][]{ };
-										local43 = local43;
-									}
-									catch (Exception)
-									{
-										String[,,,,] local47 = (new String[91u, 102u, 91u, 75u, 88u]);
-										Array[,][] local48 = (new Array[125u, 114u][]);
-										object local49 = null;
-										for (App.m_chFwd9+='\x2b'; param2; App.m_chFwd9++)
-										{
-											param2 = true;
-											local39 += local39;
-											try
-											{
-												param2 = param2;
-											}
-											finally
-											{
-											}
-										}
-										while (param2)
-										{
-										}
-									}
-									local40 = new BB();
-									while (param2)
-									{
-									}
-									while (param2)
-									{
-									}
-								}
-								try
-								{
-								}
-								catch (Exception)
-								{
-								}
-								return;
-							}
-							while(param2);
-							local40.m_axField1[10][53][56, 118, 114, 54] = App.m_xFwd11;
-						}
-						catch (InvalidOperationException)
-						{
-						}
-					else
-						throw new Exception();
-					do
-					{
-					}
-					while(param2);
-				}
-				if (param2)
-					try
-					{
-					}
-					catch (Exception)
-					{
-					}
-				try
-				{
-				}
-				catch (Exception)
-				{
-				}
-			}
-			param3 = 0;
-		}
-		while (param2)
-		{
-		}
-		if (param2)
-			throw new DivideByZeroException();
-		param4 /= param4;
-		;
-	}
-}
-
-public class App
-{
-	public static int Main()
-	{
-		try
-		{
-			AA<char, bool>.Static1(
-				App.m_xFwd11,
-				ref App.m_agboFwd12,
-				(new ulong[50u, 40u, 98u]),
-				ref App.m_byFwd4 );
-		}
-		catch (Exception)
-		{
-		}
-		try
-		{
-			AA<char, bool>.Static2(
-				(new bool[72u, 126u][,,]),
-				ref App.m_aulFwd13,
-				App.m_gcFwd14,
-				App.m_agboFwd12,
-				App.m_gcFwd14,
-				App.m_agboFwd12 );
-		}
-		catch (Exception)
-		{
-		}
-		try
-		{
-			AA<char, bool>.Static3(
-				34u,
-				ref App.m_shFwd10 );
-		}
-		catch (Exception)
-		{
-		}
-		try
-		{
-			AA<char, bool>.Static4(
-				App.m_agboFwd12,
-				ref App.m_axFwd15,
-				ref App.m_agboFwd12,
-				'\x50' );
-		}
-		catch (Exception)
-		{
-		}
-		try
-		{
-			BB.Static1(
-				(new double[101u][,,]),
-				ref App.m_bFwd1,
-				TestEnum.red,
-				ref App.m_fFwd6 );
-		}
-		catch (Exception)
-		{
-		}
-		return 100;
-	}
-	public static bool m_bFwd1;
-	public static long m_lFwd2;
-	public static ulong m_ulFwd3;
-	public static byte m_byFwd4;
-	public static int m_iFwd5;
-	public static float m_fFwd6;
-	public static sbyte m_sbyFwd7;
-	public static ushort m_ushFwd8;
-	public static char m_chFwd9;
-	public static short m_shFwd10;
-	public static Array m_xFwd11;
-	public static bool m_agboFwd12;
-	public static ulong[] m_aulFwd13;
-	public static char m_gcFwd14;
-	public static Array[][,,][,,] m_axFwd15;
-}
diff --git a/src/tests/hosting/stress/testset1/csgen.1.csproj b/src/tests/hosting/stress/testset1/csgen.1.csproj
deleted file mode 100644
index 4790db1844ad1a..00000000000000
--- a/src/tests/hosting/stress/testset1/csgen.1.csproj
+++ /dev/null
@@ -1,14 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-  <PropertyGroup>
-    <OutputType>Exe</OutputType>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <ItemGroup>
-    <Compile Include="csgen.1.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <NoWarn Include="162" />
-  </ItemGroup>
-</Project>
diff --git a/src/tests/hosting/stress/testset1/simple1.cs b/src/tests/hosting/stress/testset1/simple1.cs
deleted file mode 100644
index 6ff1af913af0cf..00000000000000
--- a/src/tests/hosting/stress/testset1/simple1.cs
+++ /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.
-using System;
-
-// Do a simple 5 dimensional Jagged array.
-
-class Simple_Array_Test
-{
-	public static int Main( String[] args )
-	{
-		Console.WriteLine("Starting...");
-		int SIZE = 10;
-
-	//Create an array that is jagged.
-	// in last 2d, the array looks like:
-	//  Int32
-	//  Int32 Int32 
-	//  Int32 Int32 Int32 
-	//  Int32 Int32 Int32 Int32 
-	//  Int32 Int32 Int32 Int32 Int32 
-	//
-
-		Int32 [][][][][] foo = new Int32[SIZE][][][][];
-		int i,j,k,l,m;
-                Int64 sum=0;
-
-		for(i=0;i<SIZE;i++)
-		{
-			foo[i] = new Int32[i][][][];
-			for(j=0;j<i;j++)
-			{
-				foo[i][j] = new Int32[j][][];
-				for(k=0;k<j;k++)
-				{
-					foo[i][j][k] = new Int32[k][];
-					for(l=0;l<k;l++)
-					{
-						foo[i][j][k][l] = new Int32[l];
-						for(m=0;m<l;m++)
-						{
-							foo[i][j][k][l][m] = i*j*k*l*m;
-						}
-					}
-				}
-			}
-		}
-
-		for(i=0;i<SIZE;i++)
-			for(j=0;j<i;j++)
-				for(k=0;k<j;k++)
-					for(l=0;l<k;l++)
-					 for(m=0;m<l;m++)
-					 { 
-					  //Console.Write(" "+foo[i][j][k][l][m].ToString());
-                                          sum+=foo[i][j][k][l][m];
-					 }
-                if(sum==269325)
-                {
- 		  Console.WriteLine("Everything Worked!");
-        	  return 100;
-                }
-                else
-                {
- 		  Console.WriteLine("Something is broken!");
-        	  return 1;
-                }
-        
-	}
-}
diff --git a/src/tests/issues.targets b/src/tests/issues.targets
index 91b540fe4f18fc..06867ff7ee8a1f 100644
--- a/src/tests/issues.targets
+++ b/src/tests/issues.targets
@@ -572,21 +572,12 @@
         <ExcludeList Include="$(XunitTestBinBase)/JIT/Regression/CLR-x86-JIT/V1-M13-RTM/b91248/b91248/*">
             <Issue>https://github.com/dotnet/runtime/issues/12979</Issue>
         </ExcludeList>
-        <ExcludeList Include="$(XunitTestBinBase)/JIT/Regression/JitBlue/Runtime_34170/Runtime_34170/*">
-            <Issue>https://github.com/dotnet/runtime/issues/53560</Issue>
-        </ExcludeList>
         <ExcludeList Include="$(XunitTestBinBase)/JIT/Directed/PREFIX/unaligned/4/arglist_Target_ARM/*">
             <Issue>https://github.com/dotnet/runtime/issues/12979</Issue>
         </ExcludeList>
         <ExcludeList Include="$(XunitTestBinBase)/JIT/jit64/mcc/interop/mcc_i10/*">
             <Issue>https://github.com/dotnet/runtime/issues/12979</Issue>
         </ExcludeList>
-        <ExcludeList Include="$(XunitTestBinBase)/JIT/SIMD/Ldfld_ro/*">
-            <Issue>https://github.com/dotnet/runtime/issues/53561</Issue>
-        </ExcludeList>
-        <ExcludeList Include="$(XunitTestBinBase)/JIT/SIMD/Ldfld_r/*">
-            <Issue>https://github.com/dotnet/runtime/issues/53561</Issue>
-        </ExcludeList>
     </ItemGroup>
 
     <!-- Windows arm64 specific excludes -->
@@ -729,46 +720,6 @@
         </ExcludeList>
     </ItemGroup>
 
-    <!-- MacOS arm64 specific -->
-    <ItemGroup Condition="'$(XunitTestBinBase)' != '' and '$(TargetOS)' == 'OSX' and '$(TargetArchitecture)' == 'arm64' and '$(RuntimeFlavor)' == 'coreclr'">
-        <!-- Hard failures -->
-        <ExcludeList Include="$(XunitTestBinBase)/Regressions/coreclr/GitHub_35000/test35000/*">
-            <Issue>https://github.com/dotnet/runtime/issues/47294</Issue>
-        </ExcludeList>
-        <ExcludeList Include="$(XunitTestBinBase)/JIT/Stress/ABI/pinvokes_d/*">
-            <Issue>https://github.com/dotnet/runtime/issues/47294</Issue>
-        </ExcludeList>
-        <ExcludeList Include="$(XunitTestBinBase)/JIT/Stress/ABI/pinvokes_do/*">
-            <Issue>https://github.com/dotnet/runtime/issues/47294</Issue>
-        </ExcludeList>
-        <!-- Tracing failures -->
-        <ExcludeList Include="$(XunitTestBinBase)/tracing/eventpipe/eventsourceerror/eventsourceerror/*">
-            <Issue>https://github.com/dotnet/runtime/issues/48786</Issue>
-        </ExcludeList>
-        <!-- Intermittent failures disable to improve pass rate -->
-        <ExcludeList Include="$(XunitTestBinBase)/baseservices/exceptions/regressions/Dev11/154243/dynamicmethodliveness/*">
-            <Issue>https://github.com/dotnet/runtime/issues/46365</Issue>
-        </ExcludeList>
-        <ExcludeList Include="$(XunitTestBinBase)/GC/Regressions/Github/runtime_32848/*">
-            <Issue>https://github.com/dotnet/runtime/issues/46365</Issue>
-        </ExcludeList>
-        <ExcludeList Include="$(XunitTestBinBase)/JIT/Generics/Coverage/**">
-            <Issue>https://github.com/dotnet/runtime/issues/46365</Issue>
-        </ExcludeList>
-        <ExcludeList Include="$(XunitTestBinBase)Loader/classloader/TypeGeneratorTests/**">
-            <Issue>https://github.com/dotnet/runtime/issues/46365</Issue>
-        </ExcludeList>
-        <ExcludeList Include="$(XunitTestBinBase)tracing/eventcounter/**">
-            <Issue>https://github.com/dotnet/runtime/issues/50238</Issue>
-        </ExcludeList>
-        <ExcludeList Include="$(XunitTestBinBase)readytorun/crossgen2/**">
-            <Issue>https://github.com/dotnet/runtime/issues/49365</Issue>
-        </ExcludeList>
-        <ExcludeList Include="$(XunitTestBinBase)readytorun/determinism/crossgen2determinism/**">
-            <Issue>https://github.com/dotnet/runtime/issues/52529</Issue>
-        </ExcludeList>
-    </ItemGroup>
-
     <!-- Tests that need to be triaged for vararg usage as that is not supported -->
     <!-- Note these will only be excluded for unix platforms on all runtimes -->
     <ItemGroup Condition="'$(XunitTestBinBase)' != '' and '$(TargetsWindows)' != 'true' ">
@@ -962,7 +913,7 @@
     </ItemGroup>
 
     <!-- Crossgen2 specific -->
-    <ItemGroup Condition="'$(XunitTestBinBase)' != '' and '$(TestBuildMode)' == 'crossgen2' and '$(RuntimeFlavor)' == 'coreclr'">
+    <ItemGroup Condition="'$(XunitTestBinBase)' != '' and ('$(TestBuildMode)' == 'crossgen2' or '$(TestBuildMode)' == 'crossgen') and '$(RuntimeFlavor)' == 'coreclr'">
         <ExcludeList Include="$(XunitTestBinBase)/baseservices/TieredCompilation/BasicTest_DefaultMode_R2r/*">
             <Issue>https://github.com/dotnet/runtime/issues/38291</Issue>
         </ExcludeList>
@@ -1029,6 +980,15 @@
         <ExcludeList Include="$(XunitTestBinBase)/Loader/classloader/regressions/dev10_715437/dev10_715437/*">
             <Issue>https://github.com/dotnet/runtime/issues/43498</Issue>
         </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)/JIT/Regression/JitBlue/Runtime_34170/Runtime_34170/*">
+            <Issue>https://github.com/dotnet/runtime/issues/53560</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)/JIT/SIMD/Ldfld_ro/*">
+            <Issue>https://github.com/dotnet/runtime/issues/53561</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)/JIT/SIMD/Ldfld_r/*">
+            <Issue>https://github.com/dotnet/runtime/issues/53561</Issue>
+        </ExcludeList>
     </ItemGroup>
 
     <!-- run.proj finds all the *.cmd/*.sh scripts in a test folder and creates corresponding test methods.
@@ -1043,6 +1003,17 @@
 
     <!-- Known failures for mono runtime on *all* architectures/operating systems in *all* runtime modes -->
     <ItemGroup Condition="'$(RuntimeFlavor)' == 'mono'" >
+        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Sse2.X64/StoreNonTemporal_r/**">
+            <Issue>https://github.com/dotnet/runtime/issues/54176</Issue>
+        </ExcludeList>
+        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Sse2.X64/StoreNonTemporal_ro/**">
+            <Issue>https://github.com/dotnet/runtime/issues/54176</Issue>
+        </ExcludeList>
+        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Sse42.X64/Crc32_*/**">
+            <Issue>https://github.com/dotnet/runtime/issues/54185</Issue>
+        </ExcludeList>
+
+
         <ExcludeList Include="$(XunitTestBinBase)/JIT/Directed/Convert/value_numbering_checked_casts_of_constants/*">
             <Issue>https://github.com/dotnet/runtime/issues/51323</Issue>
         </ExcludeList>
@@ -1052,12 +1023,6 @@
         <ExcludeList Include="$(XunitTestBinBase)/JIT/opt/Devirtualization/Comparer_get_Default/*">
             <Issue>https://github.com/dotnet/runtime/issues/48190</Issue>
         </ExcludeList>
-        <ExcludeList Include="$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/AvxVnni/**">
-            <Issue>Mono crashes when new unsupported intrinsic groups are added, https://github.com/dotnet/runtime/issues/53078</Issue>
-        </ExcludeList>
-        <ExcludeList Include="$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/AvxVnni_Vector128/**">
-            <Issue>Mono crashes when new unsupported intrinsic groups are added, https://github.com/dotnet/runtime/issues/53078</Issue>
-        </ExcludeList>
         <ExcludeList Include="$(XunitTestBinBase)/JIT/Directed/DynamicPgo/**">
             <Issue>Mono doesn't have a dynamic pgo or tiered compilation infrastructure</Issue>
         </ExcludeList>
@@ -1071,12 +1036,6 @@
         <ExcludeList Include="$(XunitTestBinBase)/Regressions/coreclr/Runtimelab_578/arr/*">
             <Issue>https://github.com/dotnet/runtime/issues/47458</Issue>
         </ExcludeList>
-        <ExcludeList Include="$(XunitTestBinBase)/JIT/HardwareIntrinsics/General/Regression/GitHub_43569/**">
-            <Issue>https://github.com/dotnet/runtime/issues/43676</Issue>
-        </ExcludeList>
-        <ExcludeList Include="$(XunitTestBinBase)/JIT/HardwareIntrinsics/General/Regression/GitHub_47236/**">
-            <Issue>https://github.com/dotnet/runtime/issues/43676</Issue>
-        </ExcludeList>
         <ExcludeList Include="$(XunitTestBinBase)/baseservices/TieredCompilation/BasicTestWithMcj/*">
             <Issue>Tests features specific to coreclr</Issue>
         </ExcludeList>
@@ -1095,42 +1054,7 @@
         <ExcludeList Include="$(XunitTestBinBase)/Interop/StringMarshalling/BSTR/BSTRTest/**">
             <Issue>Crashes during LLVM AOT compilation.</Issue>
         </ExcludeList>
-        <ExcludeList Include="$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Regression/GitHub_17073/**">
-            <Issue>Crashes during LLVM AOT compilation.</Issue>
-        </ExcludeList>
-
-        <ExcludeList Include="$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Sse3/LoadDquVector128_r/**">
-            <Issue>Crashes during LLVM AOT compilation.</Issue>
-        </ExcludeList>
-        <ExcludeList Include="$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Sse3/LoadDquVector128_ro/**">
-            <Issue>Crashes during LLVM AOT compilation.</Issue>
-        </ExcludeList>
 
-        <ExcludeList Include="$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/General/VectorArray_r/**">
-            <Issue>Crashes during LLVM AOT compilation.</Issue>
-        </ExcludeList>
-        <ExcludeList Include="$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/General/VectorArray_ro/**">
-            <Issue>Crashes during LLVM AOT compilation.</Issue>
-        </ExcludeList>
-        <ExcludeList Include="$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/General/VectorRet_r/**">
-            <Issue>Crashes during LLVM AOT compilation.</Issue>
-        </ExcludeList>
-        <ExcludeList Include="$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/General/VectorRet_ro/**">
-            <Issue>Crashes during LLVM AOT compilation.</Issue>
-        </ExcludeList>
-        <ExcludeList Include="$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/General/VectorUnused_r/**">
-            <Issue>Crashes during LLVM AOT compilation.</Issue>
-        </ExcludeList>
-        <ExcludeList Include="$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/General/VectorUnused_ro/**">
-            <Issue>Crashes during LLVM AOT compilation.</Issue>
-        </ExcludeList>
-
-        <ExcludeList Include="$(XunitTestBinBase)/JIT/HardwareIntrinsics/General/Vector128/Vector128_ro/**">
-            <Issue>Crashes during LLVM AOT compilation.</Issue>
-        </ExcludeList>
-        <ExcludeList Include="$(XunitTestBinBase)/JIT/HardwareIntrinsics/General/Vector128/Vector128_r/**">
-            <Issue>Crashes during LLVM AOT compilation.</Issue>
-        </ExcludeList>
         <ExcludeList Include="$(XunitTestBinBase)/Loader/classloader/MethodImpl/CovariantReturns/Structs/IncompatibleOverride/**">
             <Issue>Crashes during LLVM AOT compilation.</Issue>
         </ExcludeList>
@@ -1373,60 +1297,6 @@
         <ExcludeList Include="$(XunitTestBinBase)/JIT/Directed/newarr/newarr/**">
             <Issue>needs triage</Issue>
         </ExcludeList>
-        <ExcludeList Include="$(XunitTestBinBase)/JIT/HardwareIntrinsics/General/Vector128_1/Vector128_1_r/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include="$(XunitTestBinBase)/JIT/HardwareIntrinsics/General/Vector128_1/Vector128_1_ro/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include="$(XunitTestBinBase)/JIT/HardwareIntrinsics/General/Vector256/Vector256_r/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include="$(XunitTestBinBase)/JIT/HardwareIntrinsics/General/Vector256/Vector256_ro/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include="$(XunitTestBinBase)/JIT/HardwareIntrinsics/General/Vector256_1/Vector256_1_r/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include="$(XunitTestBinBase)/JIT/HardwareIntrinsics/General/Vector256_1/Vector256_1_ro/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include="$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/General/IsSupported_r/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include="$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/General/IsSupported_ro/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include="$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Lzcnt.X64/Lzcnt.X64_r/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include="$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Lzcnt.X64/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include="$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Lzcnt/Lzcnt_r/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include="$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Lzcnt/Lzcnt_ro/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include="$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Popcnt.X64/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include="$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Popcnt.X64/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include="$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Popcnt/Popcnt_r/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include="$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Popcnt/Popcnt_ro/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include="$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Regression/GitHub_17957/GitHub_17957_r/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include="$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Regression/GitHub_17957/GitHub_17957_ro/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
         <ExcludeList Include="$(XunitTestBinBase)/JIT/IL_Conformance/Old/Conformance_Base/conv_ovf_r8_i4/**">
             <Issue>needs triage</Issue>
         </ExcludeList>
@@ -1768,180 +1638,6 @@
         <ExcludeList Include = "$(XunitTestBinBase)/Interop/DllImportAttribute/ExactSpelling/ExactSpellingTest/**">
             <Issue>needs triage</Issue>
         </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Aes/Aes_r/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Aes/Aes_ro/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Avx/Avx_r/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Avx/Avx_ro/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Avx/ConvertToVector_r/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Avx/ConvertToVector_ro/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Avx2/Avx2_r/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Avx2/Avx2_ro/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256_r/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256_ro/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Avx2_r/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Avx2_ro/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Avx_Vector128/Avx_r/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Avx_Vector128/Avx_ro/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Bmi1.X64/Bmi1.X64_r/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Bmi1.X64/Bmi1.X64_ro/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Bmi1/Bmi1_r/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Bmi1/Bmi1_ro/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Bmi2.X64/Bmi2.X64_r/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Bmi2.X64/Bmi2.X64_ro/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Bmi2/Bmi2_r/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Bmi2/Bmi2_ro/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Fma_Vector128/Fma_r/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Fma_Vector128/Fma_ro/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Fma_Vector256/Fma_r/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Fma_Vector256/Fma_ro/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Pclmulqdq/Pclmulqdq_r/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Pclmulqdq/Pclmulqdq_ro/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Sse.X64/Sse.X64_r/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Sse.X64/Sse.X64_ro/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Sse/Sse_r/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Sse/Sse_ro/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Sse2.X64/Sse2.X64_r/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Sse2.X64/Sse2.X64_ro/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Sse2.X64/StoreNonTemporal_r/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Sse2.X64/StoreNonTemporal_ro/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Sse2/Sse2_r/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Sse2/Sse2_ro/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Sse3/Sse3_r/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Sse3/Sse3_ro/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Sse41.X64/Sse41.X64_r/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Sse41.X64/Sse41.X64_ro/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128_r/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128_ro/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Sse41/MinHorizontal_r/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Sse41/MinHorizontal_ro/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Sse41/MultipleSumAbsoluteDifferences_r/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Sse41/MultipleSumAbsoluteDifferences_ro/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Sse41/Sse41_r/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Sse41/Sse41_ro/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Sse41_Overloaded/Sse41_Overloaded_r/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Sse41_Overloaded/Sse41_Overloaded_ro/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Sse42.X64/Crc32_r/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Sse42.X64/Crc32_ro/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Sse42/Sse42_r/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Sse42/Sse42_ro/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Ssse3/Ssse3_r/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/X86/Ssse3/Ssse3_ro/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Stress/ABI/pinvokes_d/**">
             <Issue>needs triage</Issue>
         </ExcludeList>
@@ -1992,22 +1688,19 @@
             <Issue>needs triage</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/jit64/localloc/ehverify/eh07_large/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/GC/Scenarios/LeakWheel/leakwheel/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54395</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/jit64/verif/sniff/fg/ver_fg_13/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54396</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Methodical/VT/callconv/_il_reljumper3/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54374</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Methodical/NaN/r4nanconv_il_d/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54381</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/Loader/classloader/Statics/Misc/LiteralStatic/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54374</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Regression/CLR-x86-JIT/V1-M12-Beta2/b59952/b59952/**">
             <Issue>needs triage</Issue>
@@ -2025,7 +1718,7 @@
             <Issue>needs triage</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Regression/CLR-x86-JIT/V1-M09.5-PDC/b27883/b27883/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54394</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Regression/CLR-x86-JIT/V1-M12-Beta2/b34953/b34953/**">
             <Issue>needs triage</Issue>
@@ -2034,16 +1727,16 @@
             <Issue>needs triage</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Directed/coverage/importer/Desktop/badendfinally_il_d/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54371</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Regression/CLR-x86-JIT/V1-M09.5-PDC/b30869/b30869/**">
             <Issue>needs triage</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Regression/CLR-x86-JIT/V1-M12-Beta2/b70964/b70964/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54381</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Regression/CLR-x86-JIT/V1-M12-Beta2/b63726/b63726/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54381</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Directed/coverage/importer/Desktop/volatilstind_il_r/**">
             <Issue>needs triage</Issue>
@@ -2055,13 +1748,13 @@
             <Issue>needs triage</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Regression/CLR-x86-JIT/V1-M11-Beta1/b47093/b47093/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54381</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Directed/coverage/importer/Desktop/ceeillegal_il_d/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54372</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Methodical/NaN/r4nanconv_il_r/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54381</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Regression/CLR-x86-JIT/V1-M11-Beta1/b45956/b45956/**">
             <Issue>needs triage</Issue>
@@ -2073,7 +1766,7 @@
             <Issue>needs triage</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Directed/coverage/importer/ceeillegal/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54372</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Regression/CLR-x86-JIT/V1-M09.5-PDC/b30892/b30892/**">
             <Issue>needs triage</Issue>
@@ -2082,25 +1775,25 @@
             <Issue>needs triage</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Regression/CLR-x86-JIT/V1-M11-Beta1/b44879/b44879/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54381</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Regression/CLR-x86-JIT/V1-M11-Beta1/b27873/b27873/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54381</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Directed/coverage/importer/Desktop/badendfinally_il_r/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54371</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Regression/CLR-x86-JIT/V1-M12-Beta2/b71179/b71179/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54381</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Regression/CLR-x86-JIT/V1-M12-Beta2/b37578/b37578/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54381</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Directed/coverage/importer/badendfinally/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54371</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Directed/coverage/importer/Desktop/ceeillegal_il_r/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54372</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Regression/CLR-x86-JIT/V1-M09.5-PDC/b28597/b28597/**">
             <Issue>needs triage</Issue>
@@ -2112,19 +1805,19 @@
             <Issue>needs triage</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Regression/CLR-x86-JIT/V1-M12-Beta2/b32614/b32614/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54381</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Regression/CLR-x86-JIT/V1-M12-Beta2/b50027/b50027/**">
             <Issue>needs triage</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/Regressions/coreclr/22386/debug3/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54374</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Regression/CLR-x86-JIT/V1-M12-Beta2/b35354/b35354/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54381</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Regression/JitBlue/DevDiv_605447/DevDiv_605447/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54391</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Regression/VS-ia64-JIT/V1.2-M02/b102844/b102844/**">
             <Issue>needs triage</Issue>
@@ -2136,10 +1829,10 @@
             <Issue>needs triage</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Regression/JitBlue/DevDiv_362706/DevDiv_362706/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54391</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Regression/VS-ia64-JIT/V2.0-Beta2/b309576/b309576/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54391</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Regression/JitBlue/DevDiv_578214/DevDiv_578214/**">
             <Issue>needs triage</Issue>
@@ -2166,7 +1859,7 @@
             <Issue>needs triage</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Regression/JitBlue/DevDiv_710234/DevDiv_710234/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54381</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Methodical/Invoke/SEH/_il_dbgcatchfinally_ind/**">
             <Issue>needs triage</Issue>
@@ -2214,13 +1907,13 @@
             <Issue>needs triage</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Regression/JitBlue/GitHub_24846/GitHub_24846/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54392</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Methodical/Boxing/boxunbox/_il_dbghuge_filter/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54388</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Regression/VS-ia64-JIT/M00/b108366/b108366/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54393</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Methodical/Boxing/boxunbox/_il_relhuge_filter/**">
             <Issue>needs triage</Issue>
@@ -2232,7 +1925,7 @@
             <Issue>needs triage</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Regression/CLR-x86-JIT/V1.2-M01/b00722/b00722/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54393</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Methodical/Boxing/boxunbox/_il_reltailcall/**">
             <Issue>needs triage</Issue>
@@ -2241,10 +1934,10 @@
             <Issue>needs triage</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Regression/JitBlue/DevDiv_487699/DevDiv_487699/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54393</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Methodical/Boxing/boxunbox/_il_dbgtailcall/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54388</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Methodical/eh/finallyexec/loopinfinally_r/**">
             <Issue>needs triage</Issue>
@@ -2259,13 +1952,13 @@
             <Issue>needs triage</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Regression/JitBlue/DevDiv_405852/DevDiv_405852/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54392</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Regression/JitBlue/DevDiv_544983/DevDiv_544983/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54393</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/CodeGenBringUpTests/Localloc_do/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54359</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Directed/Misc/function_pointer/MutualThdRecur-fptr/**">
             <Issue>needs triage</Issue>
@@ -2280,16 +1973,16 @@
             <Issue>needs triage</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Regression/CLR-x86-JIT/V1.2-M01/b13452/b13452/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54392</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Methodical/eh/finallyexec/catchrettoinnertry_cs_d/**">
             <Issue>needs triage</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/IL_Conformance/Old/Conformance_Base/div_r8/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54375</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Directed/tailcall/tailcall/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54374</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Methodical/Invoke/deep/_il_reldeep1/**">
             <Issue>needs triage</Issue>
@@ -2324,17 +2017,11 @@
         <ExcludeList Include = "$(XunitTestBinBase)/GC/Scenarios/Dynamo/dynamo/**">
             <Issue>needs triage</Issue>
         </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/Regression/JitBlue/GitHub_24846/GitHub_24846/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Methodical/Boxing/boxunbox/_il_dbghuge_filter/**">
             <Issue>needs triage</Issue>
         </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/Regression/VS-ia64-JIT/M00/b108366/b108366/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Methodical/Boxing/boxunbox/_il_relhuge_filter/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54388</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/jit64/rtchecks/overflow/overflow03_div/**">
             <Issue>needs triage</Issue>
@@ -2342,17 +2029,11 @@
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Methodical/eh/finallyexec/catchrettoinnertry_cs_ro/**">
             <Issue>needs triage</Issue>
         </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/Regression/CLR-x86-JIT/V1.2-M01/b00722/b00722/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Methodical/Boxing/boxunbox/_il_reltailcall/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54388</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Methodical/Coverage/b39946/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/Regression/JitBlue/DevDiv_487699/DevDiv_487699/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54388</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Methodical/Boxing/boxunbox/_il_dbgtailcall/**">
             <Issue>needs triage</Issue>
@@ -2400,10 +2081,7 @@
             <Issue>needs triage</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Regression/CLR-x86-JIT/V2.0-Beta2/b353858/b353858/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/Methodical/eh/basics/throwinclassconstructor_r/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54393</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/SIMD/VectorMatrix_ro/**">
             <Issue>needs triage</Issue>
@@ -2411,14 +2089,8 @@
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Methodical/eh/interactions/strswitchfinal_d/**">
             <Issue>needs triage</Issue>
         </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/Regression/JitBlue/DevDiv_405852/DevDiv_405852/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/Regression/JitBlue/DevDiv_544983/DevDiv_544983/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/CodeGenBringUpTests/Localloc_do/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54359</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Directed/Misc/function_pointer/MutualThdRecur-fptr/**">
             <Issue>needs triage</Issue>
@@ -2432,98 +2104,86 @@
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Methodical/localloc/verify/verify01_small/**">
             <Issue>needs triage</Issue>
         </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/Regression/CLR-x86-JIT/V1.2-M01/b13452/b13452/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Methodical/eh/finallyexec/catchrettoinnertry_cs_d/**">
             <Issue>needs triage</Issue>
         </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/IL_Conformance/Old/Conformance_Base/div_r8/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/Directed/tailcall/tailcall/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/Loader/classloader/DefaultInterfaceMethods/diamondshape/diamondshape_r/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54399</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Methodical/localloc/verify/verify01_dynamic/**">
             <Issue>needs triage</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/CodeGenBringUpTests/Localloc_r/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54359</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/CodeGenBringUpTests/Localloc_ro/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54359</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/IL_Conformance/Old/Conformance_Base/neg_r4/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54376</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/CodeGenBringUpTests/Localloc_d/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54359</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Regression/CLR-x86-JIT/V1-M09.5-PDC/b25459/b25459/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54393</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Directed/zeroinit/init_struct/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54373</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Methodical/eh/basics/throwinclassconstructor_do/**">
             <Issue>needs triage</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Directed/pinvoke/tail/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54373</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Regression/CLR-x86-JIT/V1-M11-Beta1/b39946/b39946/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54393</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/baseservices/varargs/varargsupport/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54401</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/baseservices/varargs/varargsupport_r/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54401</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Regression/VS-ia64-JIT/M00/b109878/b109878/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54392</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/IL_Conformance/Old/Conformance_Base/add_r4/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54376</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Regression/VS-ia64-JIT/M00/b92726/b92726/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54392</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/Loader/classloader/DefaultInterfaceMethods/diamondshape/diamondshape_d/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54399</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Directed/coverage/importer/Desktop/volatilldind_il_d/**">
             <Issue>needs triage</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/IL_Conformance/Old/Conformance_Base/mul_r4/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54376</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Regression/CLR-x86-JIT/V1-M12-Beta2/b84909/b84909/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54392</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Directed/coverage/importer/Desktop/volatilldind_il_r/**">
             <Issue>needs triage</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/IL_Conformance/Old/Conformance_Base/rem_r4/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/IL_Conformance/Old/Conformance_Base/rem_r4/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54376</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/IL_Conformance/Old/Conformance_Base/ckfinite_r4/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54376</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/IL_Conformance/Old/Conformance_Base/div_r4/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54376</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/IL_Conformance/Old/Conformance_Base/sub_r4/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54376</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/IL_Conformance/Old/Conformance_Base/ldc_ckfinite_r4/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54376</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Directed/coverage/importer/volatilldind/**">
             <Issue>needs triage</Issue>
@@ -2532,19 +2192,25 @@
             <Issue>needs triage</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Performance/CodeQuality/Burgers/Burgers/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54358</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/Interop/StructMarshalling/ReversePInvoke/MarshalSeqStruct/DelegatePInvoke/DelegatePInvokeTest/**">
             <Issue>needs triage</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Methodical/eh/basics/throwinfilter_d/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54389</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Methodical/eh/basics/throwinfilter_r/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54389</Issue>
         </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)JIT/IL_Conformance/Old/Base/ckfinite/**">
-            <Issue>needs triage</Issue>
+            <Issue>https://github.com/dotnet/runtime/issues/54376</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)/JIT/HardwareIntrinsics/General/Vector128_1/Vector128_1_r/**">
+            <Issue>https://github.com/dotnet/runtime/issues/54374e</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)/JIT/HardwareIntrinsics/General/Vector128_1/Vector128_1_ro/**">
+            <Issue>https://github.com/dotnet/runtime/issues/54374</Issue>
         </ExcludeList>
         <!-- End interpreter issues -->
     </ItemGroup>
@@ -2574,6 +2240,13 @@
         <ExcludeList Include = "$(XunitTestBinBase)/GC/Scenarios/Dynamo/dynamo/**">
             <Issue> needs triage </Issue>
         </ExcludeList>
+
+        <ExcludeList Include="$(XunitTestBinBase)/JIT/Regression/CLR-x86-JIT/V1.1-M1-Beta1/b143840/b143840/*">
+            <Issue>https://github.com/dotnet/runtime/issues/48914</Issue>
+        </ExcludeList>
+        <ExcludeList Include = "$(XunitTestBinBase)/GC/Features/Finalizer/finalizeother/finalizearray/**">
+            <Issue>https://github.com/dotnet/runtime/issues/54113</Issue>
+        </ExcludeList>
     </ItemGroup>
 
     <ItemGroup Condition=" '$(RuntimeFlavor)' == 'mono' and '$(TargetArchitecture)' == 'arm64' and '$(TargetsWindows)' != 'true' " >
@@ -2589,13 +2262,7 @@
         <ExcludeList Include="$(XunitTestBinBase)/Loader/classloader/generics/Variance/IL/vsw543506/**">
             <Issue>Doesn't compile with LLVM AOT.</Issue>
         </ExcludeList>
-        <ExcludeList Include="$(XunitTestBinBase)/JIT/Regression/CLR-x86-JIT/V1.1-M1-Beta1/b143840/b143840/*">
-            <Issue>https://github.com/dotnet/runtime/issues/48914</Issue>
-        </ExcludeList>
 
-        <ExcludeList Include = "$(XunitTestBinBase)/GC/Features/Finalizer/finalizeother/finalizearray/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Methodical/eh/finallyexec/loopinfinally_ro/**">
             <Issue>needs triage</Issue>
         </ExcludeList>
@@ -2710,12 +2377,6 @@
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/IL_Conformance/Old/Base/ckfinite/**">
             <Issue>needs triage</Issue>
         </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/Arm/ArmBase/ArmBase_r/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/Arm/Aes/Aes_r/**">
-            <Issue>needs triage</Issue>
-        </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/IL_Conformance/Old/Conformance_Base/div_r4/**">
             <Issue>needs triage</Issue>
         </ExcludeList>
@@ -2740,6 +2401,13 @@
 
 
     <ItemGroup Condition=" '$(TargetArchitecture)' == 'wasm' " >
+        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/General/Vector256_1/**">
+            <Issue>https://github.com/dotnet/runtime/issues/54122</Issue>
+        </ExcludeList>
+        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/General/Vector128_1/**">
+            <Issue>https://github.com/dotnet/runtime/issues/54122</Issue>
+        </ExcludeList>
+
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/opt/ThrowHelper/NonVoidThrowHelper/**">
             <Issue>https://github.com/dotnet/runtime/issues/48819</Issue>
         </ExcludeList>
@@ -3472,32 +3140,11 @@
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Regression/JitBlue/DevDiv_461649/DevDiv_461649/**">
             <Issue>https://github.com/dotnet/runtime/issues/53353</Issue>
         </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/GC/Scenarios/LeakWheel/leakwheel/**">
-            <Issue>long running test https://github.com/dotnet/runtime/issues/53386</Issue>
-        </ExcludeList>
     </ItemGroup>
 
     <ItemGroup Condition=" $(TargetOS) == 'Android' And '$(TargetArchitecture)' == 'arm64' " >
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/HardwareIntrinsics/**">
-            <Issue>https://github.com/dotnet/runtime/issues/45568 (workitem JIT.HardwareIntrinsics)</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/Methodical/**">
-            <Issue>https://github.com/dotnet/runtime/issues/45568 (workitem JIT.Methodical*)</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/IL_Conformance/**">
-            <Issue>https://github.com/dotnet/runtime/issues/45568 (workitem JIT.IL_Conformance)</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/SIMD/**">
-            <Issue>https://github.com/dotnet/runtime/issues/45568 (workitem JIT)</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/opt/**">
-            <Issue>https://github.com/dotnet/runtime/issues/45568 (workitem JIT)</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/JIT/Regression/**">
-            <Issue>https://github.com/dotnet/runtime/issues/45568 (workitem JIT.Regression.CLR-x86-JIT.V1-M12-M13)</Issue>
-        </ExcludeList>
-        <ExcludeList Include = "$(XunitTestBinBase)/GC/Scenarios/**">
-            <Issue>https://github.com/dotnet/runtime/issues/45568 (workitem PayloadGroup0)</Issue>
+        <ExcludeList Include = "$(XunitTestBinBase)/JIT/Performance/CodeQuality/BenchmarksGame/fannkuch-redux/fannkuch-redux-5/**">
+            <Issue>https://github.com/dotnet/runtime/issues/52781</Issue>
         </ExcludeList>
     </ItemGroup>
 </Project>
diff --git a/src/tests/profiler/native/gcbasicprofiler/gcbasicprofiler.cpp b/src/tests/profiler/native/gcbasicprofiler/gcbasicprofiler.cpp
index 68fcf9c8b44d5b..a9f28011eb02bf 100644
--- a/src/tests/profiler/native/gcbasicprofiler/gcbasicprofiler.cpp
+++ b/src/tests/profiler/native/gcbasicprofiler/gcbasicprofiler.cpp
@@ -50,9 +50,6 @@ HRESULT GCBasicProfiler::Shutdown()
     return S_OK;
 }
 
-// filler for empty generations: x86 - 0xc; ia64 - 0x18
-#define GEN_FILLER 0x18
-
 HRESULT GCBasicProfiler::GarbageCollectionStarted(int cGenerations, BOOL generationCollected[], COR_PRF_GC_REASON reason)
 {
     SHUTDOWNGUARD();
@@ -69,59 +66,66 @@ HRESULT GCBasicProfiler::GarbageCollectionStarted(int cGenerations, BOOL generat
     if(_gcStarts == 1)
     {
         ULONG nObjectRanges;
-        const ULONG cRanges = 32;
-        COR_PRF_GC_GENERATION_RANGE objectRanges[cRanges];
-
-        HRESULT hr = pCorProfilerInfo->GetGenerationBounds(cRanges, &nObjectRanges, objectRanges);
-        if (FAILED(hr))
+        bool fHeapAlloc = false;
+        COR_PRF_GC_GENERATION_RANGE* pObjectRanges = nullptr;
         {
-            _failures++;
-            printf("GCBasicProfiler::GarbageCollectionStarted: FAIL: GetGenerationBounds hr=0x%x\n", hr);
-            return S_OK;
+            const ULONG cRanges = 32;
+            COR_PRF_GC_GENERATION_RANGE objectRangesStackBuffer[cRanges];
+
+            HRESULT hr = pCorProfilerInfo->GetGenerationBounds(cRanges, &nObjectRanges, objectRangesStackBuffer);
+            if (FAILED(hr))
+            {
+                _failures++;
+                printf("GCBasicProfiler::GarbageCollectionStarted: FAIL: GetGenerationBounds hr=0x%x\n", hr);
+                return S_OK;
+            }
+            if (nObjectRanges <= cRanges)
+            {
+                pObjectRanges = objectRangesStackBuffer;
+            }
         }
 
-        // Assuming an initial gc heap like this.
-        //
-        // Generation: 3	Start: 1ee1000	Length: 2030	Reserved: fff000	// big objects
-        // Generation: 2	Start: 7a8d0bbc Length: 1fd1c	Reserved: 1fd1c		// frozen objects (per module)
-        // Generation: 2	Start: 3120004	Length: c		Reserved: c			// debug build only, internal
-        // Generation: 2	Start: 5ba29b7c	Length: 465f0	Reserved: 465f0		// frozen objects (per module)
-        // Generation: 2	Start: ee1000	Length: c		Reserved: c			// empty, with filler
-        // Generation: 1	Start: ee100c	Length: c		Reserved: c			// empty, with filler
-        // Generation: 0	Start: ee1018	Length: 15b8	Reserved: ffefe8	// new objects
-
-        // loop through generations from 0 to 3
+        if (pObjectRanges == nullptr)
+        {
+            pObjectRanges = new COR_PRF_GC_GENERATION_RANGE[nObjectRanges];
+            if (pObjectRanges == nullptr)
+            {
+                _failures++;
+                printf("Couldn't allocate buffer for generation ranges\n");
+                return S_OK;
+            }
+            fHeapAlloc = true;
+
+            ULONG nObjectRanges2;
+            HRESULT hr = pCorProfilerInfo->GetGenerationBounds(nObjectRanges, &nObjectRanges2, pObjectRanges);
+            if (FAILED(hr) || nObjectRanges != nObjectRanges2)
+            {
+                _failures++;
+                printf("GCBasicProfiler::GarbageCollectionStarted: FAIL: GetGenerationBounds hr=0x%x, %d != %d\n", hr, nObjectRanges, nObjectRanges2);
+                return S_OK;
+            }
+        }
+        // loop through all ranges
         for (int i = nObjectRanges - 1; i >= 0; i--)
         {
-            switch (objectRanges[i].generation)
+            if (0 > pObjectRanges[i].generation || pObjectRanges[i].generation > 4)
             {
-            case 0:
-            case 3:
-            case 4:
-                // no useful verification
-                break;
-            case 1:
-                if (objectRanges[i].rangeLength > GEN_FILLER)
-                {
-                    _failures++;
-                    printf("GCBasicProfiler::GarbageCollectionStarted: FAIL: Expected initial gen1 rangeLength <= 0x%x. rangeLength=0x%p\n",
-                        GEN_FILLER, (void*)objectRanges[i].rangeLength);
-                }
-                if (objectRanges[i].rangeLengthReserved > GEN_FILLER)
-                {
-                    _failures++;
-                    printf("GCBasicProfiler::GarbageCollectionStarted: FAIL: Expected initial gen1 rangeLengthReserved <= 0x%x. rangeLengthReserved=0x%p\n",
-                        GEN_FILLER, (void*)objectRanges[i].rangeLengthReserved);
-                }
-                break;
-            case 2:
-                break;
-            default:
                 _failures++;
-                printf("GCBasicProfiler::GarbageCollectionStarted: FAIL: invalid generation: %d\n",objectRanges[i].generation);
+                printf("GCBasicProfiler::GarbageCollectionStarted: FAIL: invalid generation: %d\n",pObjectRanges[i].generation);
             }
         }
+        if (nObjectRanges > 3 && pObjectRanges[2].generation == 2 && pObjectRanges[2].rangeLength == 0x18 && pObjectRanges[2].generation == 1)
+        {
+            if (pObjectRanges[3].rangeLength != 0x18)
+            {
+                _failures++;
+                printf("GCBasicProfiler::GarbageCollectionStarted: FAIL: in the first GC for the segment case, gen 1 should have size 0x18");
+            }
+        }
+        if (fHeapAlloc)
+            delete[] pObjectRanges;
     }
+
     return S_OK;
 }
 
diff --git a/src/tests/readytorun/tests/mainv1.csproj b/src/tests/readytorun/tests/mainv1.csproj
index 8587289faf1054..032c89953606e9 100644
--- a/src/tests/readytorun/tests/mainv1.csproj
+++ b/src/tests/readytorun/tests/mainv1.csproj
@@ -3,6 +3,8 @@
     <OutputType>exe</OutputType>
     <CLRTestKind>BuildAndRun</CLRTestKind>
     <CrossGenTest>false</CrossGenTest>
+    <!-- Disabled under GCStress. Tracking issue: https://github.com/dotnet/runtime/issues/54203 -->
+    <GCStressIncompatible>true</GCStressIncompatible>
   </PropertyGroup>
   <ItemGroup>
     <ProjectReference Include="fieldgetter.ilproj" />
@@ -27,11 +29,9 @@ if not exist test.dll (
     echo FAILED to copy test.dll
     exit /b 1
 )
-if defined RunCrossGen2 (
-  %Core_Root%\CoreRun.exe %Core_Root%\crossgen2\crossgen2.dll -r:%Core_Root%\*.dll -r:%25CD% -o:test.ni.dll test.dll
-) else (
-  %Core_Root%\crossgen /readytorun /platform_assemblies_paths %Core_Root%%3B%25CD% /out test.ni.dll test.dll 
-)
+
+%Core_Root%\CoreRun.exe %Core_Root%\crossgen2\crossgen2.dll -r:%Core_Root%\*.dll -r:%25CD% -o:test.ni.dll test.dll
+
 set CrossGenStatus=!ERRORLEVEL!
 IF NOT !CrossGenStatus!==0 (
     ECHO Crossgen failed with exitcode - !CrossGenStatus!
@@ -41,11 +41,9 @@ if not exist test.ni.dll (
     echo FAILED to build test.ni.dll
     exit /b 1
 )
-if defined RunCrossGen2 (
-  %Core_Root%\CoreRun.exe %Core_Root%\crossgen2\crossgen2.dll -r:%Core_Root%\*.dll -r:%25CD% -o:fieldgetter.ni.dll fieldgetter.dll 
-) else (
-  %Core_Root%\crossgen /readytorun /platform_assemblies_paths %Core_Root%%3B%25CD% /out fieldgetter.ni.dll fieldgetter.dll 
-)
+
+%Core_Root%\CoreRun.exe %Core_Root%\crossgen2\crossgen2.dll -r:%Core_Root%\*.dll -r:%25CD% -o:fieldgetter.ni.dll fieldgetter.dll 
+
 set CrossGenStatus=!ERRORLEVEL!
 IF NOT !CrossGenStatus!==0 (
     ECHO Crossgen failed with exitcode - !CrossGenStatus!
@@ -55,11 +53,9 @@ if not exist fieldgetter.ni.dll (
     echo FAILED to build fieldgetter.ni.dll
     exit /b 1
 )
-if defined RunCrossGen2 (
-  %Core_Root%\CoreRun.exe %Core_Root%\crossgen2\crossgen2.dll -r:%Core_Root%\*.dll -r:%25CD% -o:mainv1.ni.dll mainv1.dll
-) else (
-  %Core_Root%\crossgen /readytorun /platform_assemblies_paths %Core_Root%%3B%25CD% /out mainv1.ni.dll mainv1.dll
-)
+
+%Core_Root%\CoreRun.exe %Core_Root%\crossgen2\crossgen2.dll -r:%Core_Root%\*.dll -r:%25CD% -o:mainv1.ni.dll mainv1.dll
+
 set CrossGenStatus=!ERRORLEVEL!
 IF NOT !CrossGenStatus!==0 (
     ECHO Crossgen failed with exitcode - !CrossGenStatus!
@@ -84,11 +80,8 @@ then
   echo Failed to copy test.dll
   exit 1
 fi
-if [ ! -z "$RunCrossGen2" ]; then
-  $CORE_ROOT/corerun $CORE_ROOT/crossgen2/crossgen2.dll -r:$CORE_ROOT/*.dll -r:`pwd` -o:test.ni.dll test.dll
-else
-  $CORE_ROOT/crossgen -readytorun -platform_assemblies_paths $CORE_ROOT:`pwd` -out test.ni.dll test.dll
-fi
+$CORE_ROOT/corerun $CORE_ROOT/crossgen2/crossgen2.dll -r:$CORE_ROOT/*.dll -r:`pwd` -o:test.ni.dll test.dll
+
 __cgExitCode=$?
 if [ $__cgExitCode -ne 0 ]
 then
@@ -100,11 +93,9 @@ then
   echo Failed to build test.ni.dll
   exit 1
 fi
-if [ ! -z "$RunCrossGen2" ]; then
-  $CORE_ROOT/corerun $CORE_ROOT/crossgen2/crossgen2.dll -r:$CORE_ROOT/*.dll -r:`pwd` -o:fieldgetter.ni.dll fieldgetter.dll
-else
-  $CORE_ROOT/crossgen -readytorun -platform_assemblies_paths $CORE_ROOT:`pwd` -out fieldgetter.ni.dll fieldgetter.dll
-fi
+
+$CORE_ROOT/corerun $CORE_ROOT/crossgen2/crossgen2.dll -r:$CORE_ROOT/*.dll -r:`pwd` -o:fieldgetter.ni.dll fieldgetter.dll
+
 __cgExitCode=$?
 if [ $__cgExitCode -ne 0 ]
 then
@@ -116,11 +107,9 @@ then
   echo Failed to build fieldgetter.ni.dll
   exit 1
 fi
-if [ ! -z "$RunCrossGen2" ]; then
-  $CORE_ROOT/corerun $CORE_ROOT/crossgen2/crossgen2.dll -r:$CORE_ROOT/*.dll -r:`pwd` -o:mainv1.ni.dll mainv1.dll
-else
-  $CORE_ROOT/crossgen -readytorun -platform_assemblies_paths $CORE_ROOT:`pwd` -out mainv1.ni.dll mainv1.dll
-fi
+
+$CORE_ROOT/corerun $CORE_ROOT/crossgen2/crossgen2.dll -r:$CORE_ROOT/*.dll -r:`pwd` -o:mainv1.ni.dll mainv1.dll
+
 __cgExitCode=$?
 if [ $__cgExitCode -ne 0 ]
 then
diff --git a/src/tests/readytorun/tests/mainv2.csproj b/src/tests/readytorun/tests/mainv2.csproj
index 9207507d02e13b..a60c79cf464dab 100644
--- a/src/tests/readytorun/tests/mainv2.csproj
+++ b/src/tests/readytorun/tests/mainv2.csproj
@@ -3,6 +3,8 @@
     <OutputType>exe</OutputType>
     <CLRTestKind>BuildAndRun</CLRTestKind>
     <CrossGenTest>false</CrossGenTest>
+    <!-- Disabled under GCStress. Tracking issue: https://github.com/dotnet/runtime/issues/54203 -->
+    <GCStressIncompatible>true</GCStressIncompatible>
   </PropertyGroup>
   <ItemGroup>
     <ProjectReference Include="fieldgetter.ilproj" />
@@ -25,11 +27,9 @@ if not exist test.dll (
     echo FAILED to copy test.dll
     exit /b 1
 )
-if defined RunCrossGen2 (
-  %Core_Root%\CoreRun.exe %Core_Root%\crossgen2\crossgen2.dll -r:%Core_Root%\*.dll -r:%25CD% -o:mainv2.ni.dll mainv2.dll
-) else (
-  %Core_Root%\crossgen /readytorun /platform_assemblies_paths %Core_Root%%3B%25CD% /out mainv2.ni.dll mainv2.dll
-)
+
+%Core_Root%\CoreRun.exe %Core_Root%\crossgen2\crossgen2.dll -r:%Core_Root%\*.dll -r:%25CD% -o:mainv2.ni.dll mainv2.dll
+
 set CrossGenStatus=!ERRORLEVEL!
 IF NOT !CrossGenStatus!==0 (
     ECHO Crossgen failed with exitcode - !CrossGenStatus!
@@ -39,11 +39,9 @@ if not exist mainv2.ni.dll (
     echo FAILED to build mainv2.ni.dll
     exit /b 1
 )
-if defined RunCrossGen2 (
-  %Core_Root%\CoreRun.exe %Core_Root%\crossgen2\crossgen2.dll -r:%Core_Root%\*.dll -r:%25CD% -o:fieldgetter.ni.dll fieldgetter.dll 
-) else (
-  %Core_Root%\crossgen /readytorun /platform_assemblies_paths %Core_Root%%3B%25CD% /out fieldgetter.ni.dll fieldgetter.dll 
-)
+
+%Core_Root%\CoreRun.exe %Core_Root%\crossgen2\crossgen2.dll -r:%Core_Root%\*.dll -r:%25CD% -o:fieldgetter.ni.dll fieldgetter.dll 
+
 set CrossGenStatus=!ERRORLEVEL!
 IF NOT !CrossGenStatus!==0 (
     ECHO Crossgen failed with exitcode - !CrossGenStatus!
@@ -63,11 +61,9 @@ if not exist test.dll (
     echo FAILED to copy test.dll
     exit /b 1
 )
-if defined RunCrossGen2 (
-  %Core_Root%\CoreRun.exe %Core_Root%\crossgen2\crossgen2.dll -r:%Core_Root%\*.dll -r:%25CD% -o:test.ni.dll test.dll 
-) else (
-  %Core_Root%\crossgen /readytorun /platform_assemblies_paths %Core_Root%%3B%25CD% /out test.ni.dll test.dll 
-)
+
+%Core_Root%\CoreRun.exe %Core_Root%\crossgen2\crossgen2.dll -r:%Core_Root%\*.dll -r:%25CD% -o:test.ni.dll test.dll 
+
 set CrossGenStatus=!ERRORLEVEL!
 IF NOT !CrossGenStatus!==0 (
     ECHO Crossgen failed with exitcode - !CrossGenStatus!
@@ -92,11 +88,9 @@ then
   echo Failed to copy test.dll
   exit 1
 fi
-if [ ! -z "$RunCrossGen2" ]; then
-  $CORE_ROOT/corerun $CORE_ROOT/crossgen2/crossgen2.dll -r:$CORE_ROOT/*.dll -r:`pwd` -o:mainv2.ni.dll mainv2.dll
-else
-  $CORE_ROOT/crossgen -readytorun -platform_assemblies_paths $CORE_ROOT:`pwd` -out mainv2.ni.dll mainv2.dll
-fi
+
+$CORE_ROOT/corerun $CORE_ROOT/crossgen2/crossgen2.dll -r:$CORE_ROOT/*.dll -r:`pwd` -o:mainv2.ni.dll mainv2.dll
+
 __cgExitCode=$?
 if [ $__cgExitCode -ne 0 ]
 then
@@ -108,11 +102,9 @@ then
   echo Failed to build mainv2.ni.dll
   exit 1
 fi
-if [ ! -z "$RunCrossGen2" ]; then
-  $CORE_ROOT/corerun $CORE_ROOT/crossgen2/crossgen2.dll -r:$CORE_ROOT/*.dll -r:`pwd` -o:fieldgetter.ni.dll fieldgetter.dll
-else
-  $CORE_ROOT/crossgen -readytorun -platform_assemblies_paths $CORE_ROOT:`pwd` -out fieldgetter.ni.dll fieldgetter.dll
-fi
+
+$CORE_ROOT/corerun $CORE_ROOT/crossgen2/crossgen2.dll -r:$CORE_ROOT/*.dll -r:`pwd` -o:fieldgetter.ni.dll fieldgetter.dll
+
 __cgExitCode=$?
 if [ $__cgExitCode -ne 0 ]
 then
@@ -136,11 +128,9 @@ then
   echo Failed to copy test.dll
   exit 1
 fi
-if [ ! -z "$RunCrossGen2" ]; then
-  $CORE_ROOT/corerun $CORE_ROOT/crossgen2/crossgen2.dll -r:$CORE_ROOT/*.dll -r:`pwd` -o:test.ni.dll test.dll
-else
-  $CORE_ROOT/crossgen -readytorun -platform_assemblies_paths $CORE_ROOT:`pwd` -out test.ni.dll test.dll
-fi
+
+$CORE_ROOT/corerun $CORE_ROOT/crossgen2/crossgen2.dll -r:$CORE_ROOT/*.dll -r:`pwd` -o:test.ni.dll test.dll
+
 __cgExitCode=$?
 if [ $__cgExitCode -ne 0 ]
 then
diff --git a/src/tests/run.cmd b/src/tests/run.cmd
index 98f90f3344a701..3f1e762df09e99 100644
--- a/src/tests/run.cmd
+++ b/src/tests/run.cmd
@@ -26,8 +26,6 @@ set __msbuildExtraArgs=
 set __LongGCTests=
 set __GCSimulatorTests=
 set __IlasmRoundTrip=
-set __DoCrossgen=
-set __CrossgenAltJit=
 set __PrintLastResultsOnly=
 set RunInUnloadableContext=
 
@@ -50,13 +48,8 @@ if /i "%1" == "debug"                                   (set __BuildType=Debug&s
 if /i "%1" == "release"                                 (set __BuildType=Release&shift&goto Arg_Loop)
 if /i "%1" == "checked"                                 (set __BuildType=Checked&shift&goto Arg_Loop)
 
-if /i "%1" == "vs2017"                                  (set __VSVersion=%1&shift&goto Arg_Loop)
-if /i "%1" == "vs2019"                                  (set __VSVersion=%1&shift&goto Arg_Loop)
-
 if /i "%1" == "TestEnv"                                 (set __TestEnv=%2&shift&shift&goto Arg_Loop)
 if /i "%1" == "sequential"                              (set __Sequential=1&shift&goto Arg_Loop)
-if /i "%1" == "crossgen"                                (set __DoCrossgen=1&shift&goto Arg_Loop)
-if /i "%1" == "crossgenaltjit"                          (set __DoCrossgen=1&set __CrossgenAltJit=%2&shift&shift&goto Arg_Loop)
 if /i "%1" == "longgc"                                  (set __LongGCTests=1&shift&goto Arg_Loop)
 if /i "%1" == "gcsimulator"                             (set __GCSimulatorTests=1&shift&goto Arg_Loop)
 if /i "%1" == "jitstress"                               (set COMPlus_JitStress=%2&shift&shift&goto Arg_Loop)
@@ -66,10 +59,8 @@ if /i "%1" == "jitforcerelocs"                          (set COMPlus_ForceRelocs
 if /i "%1" == "ilasmroundtrip"                          (set __IlasmRoundTrip=1&shift&goto Arg_Loop)
 
 if /i "%1" == "printlastresultsonly"                    (set __PrintLastResultsOnly=1&shift&goto Arg_Loop)
-if /i "%1" == "runcrossgentests"                        (set RunCrossGen=true&shift&goto Arg_Loop)
 if /i "%1" == "runcrossgen2tests"                       (set RunCrossGen2=true&shift&goto Arg_Loop)
 REM This test feature is currently intentionally undocumented
-if /i "%1" == "runlargeversionbubblecrossgentests"      (set RunCrossGen=true&set CrossgenLargeVersionBubble=true&shift&goto Arg_Loop)
 if /i "%1" == "runlargeversionbubblecrossgen2tests"     (set RunCrossGen2=true&set CrossgenLargeVersionBubble=true&shift&goto Arg_Loop)
 if /i "%1" == "link"                                    (set DoLink=true&set ILLINK=%2&shift&shift&goto Arg_Loop)
 if /i "%1" == "gcname"                                  (set COMPlus_GCName=%2&shift&shift&goto Arg_Loop)
@@ -138,18 +129,10 @@ if defined __Sequential (
     set __RuntestPyArgs=%__RuntestPyArgs% --sequential
 )
 
-if defined RunCrossGen (
-    set __RuntestPyArgs=%__RuntestPyArgs% --run_crossgen_tests
-)
-
 if defined RunCrossGen2 (
     set __RuntestPyArgs=%__RuntestPyArgs% --run_crossgen2_tests
 )
 
-if defined __DoCrossgen (
-    set __RuntestPyArgs=%__RuntestPyArgs% --precompile_core_root
-)
-
 if defined CrossgenLargeVersionBubble (
     set __RuntestPyArgs=%__RuntestPyArgs% --large_version_bubble
 )
@@ -242,14 +225,6 @@ call :SetTestEnvironment
 call :ResolveDependencies
 if errorlevel 1 exit /b 1
 
-if defined __DoCrossgen (
-    echo %__MsgPrefix%Running crossgen on framework assemblies
-    call :PrecompileFX
-)
-
-REM Delete the unecessary mscorlib.ni file.
-if exist %CORE_ROOT%\mscorlib.ni.dll del %CORE_ROOT%\mscorlib.ni.dll
-
 ::Check if the test Binaries are built
 if not exist %XunitTestBinBase% (
     echo %__MsgPrefix%Error: Ensure the Test Binaries are built and are present at %XunitTestBinBase%.
@@ -286,52 +261,6 @@ echo     %__TestRunHtmlLog%
 echo     %__TestRunXmlLog%
 exit /b 0
 
-REM =========================================================================================
-REM ===
-REM === Compile the managed assemblies in Core_ROOT before running the tests
-REM ===
-REM =========================================================================================
-
-:PrecompileAssembly
-
-REM Skip mscorlib since it is already precompiled.
-if /I "%3" == "mscorlib.dll" exit /b 0
-if /I "%3" == "mscorlib.ni.dll" exit /b 0
-
-"%1\crossgen.exe" /nologo /Platform_Assemblies_Paths "%CORE_ROOT%" "%2" >nul 2>nul
-set /a __exitCode = %errorlevel%
-if "%__exitCode%" == "-2146230517" (
-    echo %2 is not a managed assembly.
-    exit /b 0
-)
-
-if %__exitCode% neq 0 (
-    echo Unable to precompile %2
-    exit /b 0
-)
-
-echo %__MsgPrefix%Successfully precompiled %2
-exit /b 0
-
-:PrecompileFX
-setlocal
-
-if defined __CrossgenAltJit (
-    REM Set altjit flags for the crossgen run. Note that this entire crossgen section is within a setlocal/endlocal scope,
-    REM so we don't need to save or unset these afterwards.
-    echo %__MsgPrefix%Setting altjit environment variables for %__CrossgenAltJit%.
-    set COMPlus_AltJit=*
-    set COMPlus_AltJitNgen=*
-    set COMPlus_AltJitName=%__CrossgenAltJit%
-    set COMPlus_AltJitAssertOnNYI=1
-    set COMPlus_NoGuiOnAssert=1
-    set COMPlus_ContinueOnAssert=0
-)
-
-for %%F in (%CORE_ROOT%\*.dll) do call :PrecompileAssembly "%CORE_ROOT%" "%%F" %%~nF%%~xF
-endlocal
-exit /b 0
-
 REM =========================================================================================
 REM ===
 REM === Subroutine to invoke msbuild.
@@ -447,12 +376,8 @@ echo.
 echo./? -? /h -h /help -help   - View this message.
 echo ^<build_architecture^>      - Specifies build architecture: x64, x86, arm, or arm64 ^(default: x64^).
 echo ^<build_type^>              - Specifies build type: Debug, Release, or Checked ^(default: Debug^).
-echo VSVersion ^<vs_version^>    - VS2017 or VS2019 ^(default: VS2019^).
 echo TestEnv ^<test_env_script^> - Run a custom script before every test to set custom test environment settings.
 echo sequential                - Run tests sequentially (no parallelism).
-echo crossgen                  - Precompile ^(crossgen^) the managed assemblies in CORE_ROOT before running the tests.
-echo crossgenaltjit ^<altjit^>   - Precompile ^(crossgen^) the managed assemblies in CORE_ROOT before running the tests, using the given altjit.
-echo RunCrossgenTests          - Runs ReadytoRun tests
 echo RunCrossgen2Tests         - Runs ReadytoRun tests compiled with Crossgen2
 echo jitstress ^<n^>             - Runs the tests with COMPlus_JitStress=n
 echo jitstressregs ^<n^>         - Runs the tests with COMPlus_JitStressRegs=n
diff --git a/src/tests/run.proj b/src/tests/run.proj
index 21e2573eedcc17..a64233555d2064 100644
--- a/src/tests/run.proj
+++ b/src/tests/run.proj
@@ -120,11 +120,25 @@ $(_XunitEpilog)
     <PackageReference Include="Microsoft.DotNet.XUnitConsoleRunner" Version="$(MicrosoftDotNetXUnitConsoleRunnerVersion)" />
   </ItemGroup>
 
+  <ItemGroup>
+    <Content Include="xunit.runner.json" CopyToOutputDirectory="PreserveNewest" />
+  </ItemGroup>
+
   <Import Sdk="Microsoft.NET.Sdk" Project="Sdk.targets" />
 
 </Project>
 ]]>
       </XunitWrapperGenCsProj>
+      <XunitRunnerConfig>
+        <![CDATA[
+{
+    "diagnosticMessages": true,
+    "longRunningTestSeconds": 120,
+    "shadowCopy": false,
+    "preEnumerateTheories": false
+}
+]]>
+      </XunitRunnerConfig>
     </PropertyGroup>
 
     <!-- <Exec Command="md" -->
@@ -141,6 +155,12 @@ $(_XunitEpilog)
       File="$(XunitWrapperSrcDir)\$(XunitWrapper).csproj"
       Lines="$(XunitWrapperGenCsProj)"
       Overwrite="true" />
+
+    <!-- Write the file -->
+    <WriteLinesToFile
+      File="$(XunitWrapperSrcDir)\xunit.runner.json"
+      Lines="$(XunitRunnerConfig)"
+      Overwrite="true" />
   </Target>
 
   <Target Name="BuildXunitWrapper">
@@ -161,9 +181,13 @@ $(_XunitEpilog)
       <Category Condition="'$(RunningOnUnix)' == 'true'" >$([System.String]::Copy('$(CategoryWithSlash)').Replace('/','.'))</Category>
       <XunitWrapper>$(Category).XUnitWrapper</XunitWrapper>
       <XunitWrapperSrcDir>$(XunitWrapperGeneratedCSDirBase)$(Category)</XunitWrapperSrcDir>
+      <MobilePlatform Condition=" '$(TargetOS)' == 'Android' ">android</MobilePlatform>
+      <MobilePlatform Condition=" '$(TargetOS)' == 'iOS' Or '$(TargetOS)' == 'iOSSimulator' ">apple</MobilePlatform>
+      <IsMobile>false</IsMobile>
+      <IsMobile Condition=" '$(TargetOS)' == 'Android' Or '$(TargetOS)' == 'iOS' Or '$(TargetOS)' == 'iOSSimulator' ">true</IsMobile>
     </PropertyGroup>
     <PropertyGroup>
-      <_XunitProlog Condition=" '$(_XunitProlog)'=='' ">
+      <_XunitProlog Condition=" '$(_XunitProlog)'=='' and '$(IsMobile)'=='false' ">
         <![CDATA[
 using Xunit%3B
 using Xunit.Abstractions%3B
@@ -184,36 +208,109 @@ namespace $([System.String]::Copy($(Category)).Replace(".","_").Replace("\","").
             internal static string testBinaryBase%3B
             internal static string coreRoot%3B
             internal static string category%3B
+            internal static string helixUploadRoot%3B
 
             static _Global()
             {
-                reportBase = System.Environment.GetEnvironmentVariable(%22XunitTestReportDirBase%22)%3B
-                testBinaryBase = System.IO.Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location)%3B
-                coreRoot = System.Environment.GetEnvironmentVariable(%22CORE_ROOT%22)%3B
+                reportBase = Environment.GetEnvironmentVariable(%22XunitTestReportDirBase%22)%3B
+                testBinaryBase = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location)%3B
+                coreRoot = Environment.GetEnvironmentVariable(%22CORE_ROOT%22)%3B
                 category = "$([System.String]::Copy($(Category)).Replace(".","_").Replace("\","").Replace("-","_"))"%3B
+                helixUploadRoot = Environment.GetEnvironmentVariable(%22HELIX_WORKITEM_UPLOAD_ROOT%22)%3B
+                if (!String.IsNullOrEmpty(helixUploadRoot)) {
+                    reportBase = Path.Combine(Path.GetFullPath(helixUploadRoot), "Reports")%3B
+                }
 
                 if (String.IsNullOrEmpty(reportBase)) {
-                    reportBase = System.IO.Path.Combine(testBinaryBase, "Reports")%3B
+                    reportBase = Path.Combine(testBinaryBase, "Reports")%3B
                 }
                 else
                 {
-                    reportBase = System.IO.Path.GetFullPath(reportBase)%3B
+                    reportBase = Path.GetFullPath(reportBase)%3B
                 }
 
                 if (String.IsNullOrEmpty(coreRoot)) {
                     throw new ArgumentException("Environment variable CORE_ROOT is not set")%3B
                 }
 
-                coreRoot = System.IO.Path.GetFullPath(coreRoot)%3B
+                coreRoot = Path.GetFullPath(coreRoot)%3B
 
-                string operatingSystem = System.Environment.GetEnvironmentVariable("OS")%3B
+                string operatingSystem = Environment.GetEnvironmentVariable("OS")%3B
                 runningInWindows = (operatingSystem != null && operatingSystem.StartsWith("Windows"))%3B
             }
         }
-
 ]]>
       </_XunitProlog>
+      <_XunitProlog Condition=" '$(_XunitProlog)'=='' and '$(IsMobile)'=='true' ">
+        <![CDATA[
+using Xunit%3B
+using Xunit.Abstractions%3B
+using System%3B
+using System.Collections.Generic%3B
+using System.Diagnostics%3B
+using System.Reflection%3B
+using System.Text.RegularExpressions%3B
+using CoreclrTestLib%3B
+using System.IO%3B
+
+namespace $([System.String]::Copy($(Category)).Replace(".","_").Replace("\","").Replace("-","_"))
+{
+        public class _Global : IDisposable
+        {
+            public bool runningInWindows%3B
+            public string reportBase%3B
+            public string testBinaryBase%3B
+            public string coreRoot%3B
+            public string category%3B
+            public string helixUploadRoot%3B
+            public MobileAppHandler handler = new MobileAppHandler()%3B
+
+            public _Global()
+            {
+                reportBase = Environment.GetEnvironmentVariable(%22XunitTestReportDirBase%22)%3B
+                testBinaryBase = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location)%3B
+                coreRoot = Environment.GetEnvironmentVariable(%22CORE_ROOT%22)%3B
+                category = "$([System.String]::Copy($(Category)).Replace(".","_").Replace("\","").Replace("-","_"))"%3B
+                helixUploadRoot = Environment.GetEnvironmentVariable(%22HELIX_WORKITEM_UPLOAD_ROOT%22)%3B
+                if (!String.IsNullOrEmpty(helixUploadRoot)) {
+                    reportBase = Path.Combine(Path.GetFullPath(helixUploadRoot), "Reports")%3B
+                }
+
+                if (String.IsNullOrEmpty(reportBase)) {
+                    reportBase = Path.Combine(testBinaryBase, %22Reports%22)%3B
+                }
+                else
+                {
+                    reportBase = Path.GetFullPath(reportBase)%3B
+                }
+
+                if (String.IsNullOrEmpty(coreRoot)) {
+                    throw new ArgumentException("Environment variable CORE_ROOT is not set")%3B
+                }
+
+                coreRoot = Path.GetFullPath(coreRoot)%3B
+
+                string operatingSystem = Environment.GetEnvironmentVariable("OS")%3B
+                runningInWindows = (operatingSystem != null && operatingSystem.StartsWith("Windows"))%3B
+
+                handler.InstallMobileApp(%22$(MobilePlatform)%22, category, testBinaryBase, reportBase)%3B
+            }
 
+            public void Dispose()
+            {
+                handler.UninstallMobileApp(%22$(MobilePlatform)%22, category, testBinaryBase, reportBase)%3B
+            }
+        }
+
+        [CollectionDefinition("Runtime test collection")]
+        public class RuntimeTestCollection : ICollectionFixture<_Global>
+        {
+            // This class has no code, and is never created. Its purpose is simply
+            // to be the place to apply [CollectionDefinition] and all the
+            // ICollectionFixture<> interfaces.
+        }
+]]>
+      </_XunitProlog>
       <_XunitEpilog Condition=" '$(_XunitEpilog)'=='' ">
       <![CDATA[
 }
@@ -246,7 +343,7 @@ namespace $([System.String]::Copy($(Category)).Replace(".","_").Replace("\","").
         <FactName Condition="'$(RunningOnUnix)' == 'true'" >_$([MSBuild]::ValueOrDefault(%(AllCMDs.RelativeToCMDDIR),"").Replace(".","_").Replace("/","_").Replace("-","_"))</FactName>
         <ClassName Condition="'$(RunningOnUnix)' == 'true'" >_$([MSBuild]::ValueOrDefault(%(AllCMDs.RelativeToCMDDIR), '').Replace($(TestScriptExtension),'').Replace('.','_').Replace('/','_').Replace('-','_'))</ClassName>
         <TestGroup>%(AllCMDs.TestGroup)</TestGroup>
-        <XUnitFact >
+        <XUnitFact Condition=" '$(IsMobile)'=='false' ">
           <![CDATA[
 
         public class %(AllCommands.ClassName)
@@ -266,6 +363,7 @@ namespace $([System.String]::Copy($(Category)).Replace(".","_").Replace("\","").
                 string outputFile = null%3B
                 string errorFile = null%3B
                 string testExecutable = null%3B
+                string outputDir = null%3B
                 Exception infraEx = null%3B
 
                 try
@@ -276,6 +374,7 @@ namespace $([System.String]::Copy($(Category)).Replace(".","_").Replace("\","").
                   errorFile = System.IO.Path.GetFullPath(_Global.reportBase + testSubfolder + @"%(AllCMDs.FileName).error.txt")%3B
                   testExecutable = System.IO.Path.GetFullPath(_Global.testBinaryBase + @"$([System.String]::Copy('%(AllCMDs.FullPath)').Replace("$(_CMDDIR)",''))")%3B
                   $(TestExecutableReplacement)
+                  outputDir = System.IO.Path.GetDirectoryName(outputFile)%3B
 
                   if (!_Global.runningInWindows) {
                       testExecutable = testExecutable.Replace(".cmd", ".sh")%3B
@@ -283,7 +382,7 @@ namespace $([System.String]::Copy($(Category)).Replace(".","_").Replace("\","").
 
                   System.IO.Directory.CreateDirectory(_Global.reportBase + testSubfolder)%3B
 
-                  ret = wrapper.RunTest(testExecutable, outputFile, errorFile, _Global.category, _Global.testBinaryBase)%3B
+                  ret = wrapper.RunTest(testExecutable, outputFile, errorFile, _Global.category, _Global.testBinaryBase, outputDir)%3B
                 }
                 catch (Exception ex)
                 {
@@ -342,10 +441,117 @@ namespace $([System.String]::Copy($(Category)).Replace(".","_").Replace("\","").
                         output.WriteLine(line)%3B
                     }
 
+                    Assert.True(ret == CoreclrTestWrapperLib.EXIT_SUCCESS_CODE, string.Join(Environment.NewLine, testOutput))%3B
+                }
+            }
+        }
+
+        ]]>
+        </XUnitFact>
+        <XUnitFact Condition=" '$(IsMobile)'=='true' ">
+          <![CDATA[
+        [Collection("Runtime test collection")]
+        public class %(AllCommands.ClassName)
+        {
+            private readonly ITestOutputHelper output%3B
+            _Global globalVar%3B
+
+            public %(AllCommands.ClassName)(ITestOutputHelper output, _Global globalVar)
+            {
+                this.output = output%3B
+                this.globalVar = globalVar%3B
+            }
+
+            [Fact(DisplayName=@"%(AllCommands.DisplayName)")]
+            [Trait("TestGroup", "%(AllCommands.TestGroup)")]
+            public void %(AllCommands.FactName)()
+            {
+                int ret = -100%3B
+                string outputFile = null%3B
+                string errorFile = null%3B
+                string testExecutable = null%3B
+                string outputDir = null%3B
+                Exception infraEx = null%3B
+
+                try
+                {
+                  CoreclrTestWrapperLib wrapper = new CoreclrTestWrapperLib()%3B
+                  string testSubfolder = @"\$(Category)\$([System.String]::Copy('%(AllCMDs.RelativeDir)').Replace("$(_CMDDIR)$([System.IO.Path]::DirectorySeparatorChar)",''))"%3B
+                  outputFile = System.IO.Path.GetFullPath(globalVar.reportBase + testSubfolder + @"%(AllCMDs.FileName).output.txt")%3B
+                  errorFile = System.IO.Path.GetFullPath(globalVar.reportBase + testSubfolder + @"%(AllCMDs.FileName).error.txt")%3B
+                  testExecutable = System.IO.Path.GetFullPath(globalVar.testBinaryBase + @"$([System.String]::Copy('%(AllCMDs.FullPath)').Replace("$(_CMDDIR)",''))")%3B
+                  $(TestExecutableReplacement)
+                  outputDir = System.IO.Path.GetDirectoryName(outputFile)%3B
+
+                  if (!globalVar.runningInWindows) {
+                      testExecutable = testExecutable.Replace(".cmd", ".sh")%3B
+                  }
+
+                  System.IO.Directory.CreateDirectory(globalVar.reportBase + testSubfolder)%3B
+
+                  ret = wrapper.RunTest(testExecutable, outputFile, errorFile, globalVar.category, globalVar.testBinaryBase, outputDir)%3B
+                }
+                catch (Exception ex)
+                {
+                    infraEx = ex%3B
+                }
+
+                if (infraEx != null)
+                {
+                    Assert.True(false, "Test Infrastructure Failure: " + infraEx.ToString())%3B
+                }
+                else
+                {
+                    List<string> testOutput = new List<string>()%3B
+
+                    try
+                    {
+                        testOutput.AddRange(System.IO.File.ReadAllLines(errorFile))%3B
+                    }
+                    catch (Exception ex)
+                    {
+                        testOutput.Add("Unable to read error file: " + errorFile)%3B
+                        testOutput.Add(ex.ToString())%3B
+                    }
+
+                    testOutput.Add(string.Empty)%3B
+                    testOutput.Add("Return code:      " + ret)%3B
+                    testOutput.Add("Raw output file:      " + outputFile)%3B
+                    testOutput.Add("Raw output:")%3B
+
+                    try
+                    {
+                        testOutput.AddRange(System.IO.File.ReadAllLines(outputFile))%3B
+                    }
+                    catch(Exception ex)
+                    {
+                        testOutput.Add("Unable to read output file: " + outputFile)%3B
+                        testOutput.Add(ex.ToString())%3B
+                    }
+
+                    testOutput.Add("To run the test:")%3B
+                    testOutput.Add("> set CORE_ROOT=" + globalVar.coreRoot)%3B
+                    testOutput.Add("> " + testExecutable)%3B
+
+                    var unicodeControlCharsRegex = new Regex("%5C%5Cp{C}+")%3B
+
+                    // Remove all characters that have no visual or spatial representation.
+                    for (int i = 0%3B i < testOutput.Count%3B i++)
+                    {
+                        string line = testOutput[i]%3B
+                        line = unicodeControlCharsRegex.Replace(line, string.Empty)%3B
+                        testOutput[i] = line%3B
+                    }
+
+                    foreach (string line in testOutput)
+                    {
+                        output.WriteLine(line)%3B
+                    }
+
                     // Add Android app running log to testOutput
                     if (ret != CoreclrTestWrapperLib.EXIT_SUCCESS_CODE)
                     {
-                        string androidLogFile = System.IO.Path.Combine(System.IO.Path.GetDirectoryName(testExecutable), "adb-logcat-net.dot." + _Global.category + ".log")%3B
+                        string androidLogFile = System.IO.Path.Combine(outputDir, "adb-logcat-net.dot." + globalVar.category + "-net.dot.MonoRunner.log")%3B
                         if(File.Exists(androidLogFile))
                         {
                             testOutput.AddRange(System.IO.File.ReadAllLines(androidLogFile))%3B
@@ -356,7 +562,6 @@ namespace $([System.String]::Copy($(Category)).Replace(".","_").Replace("\","").
                 }
             }
         }
-
         ]]>
         </XUnitFact>
       </AllCommands>
@@ -394,13 +599,13 @@ namespace $([System.String]::Copy($(Category)).Replace(".","_").Replace("\","").
       <MonoAotOption Include="mattr=neon" />
     </ItemGroup>
     <ItemGroup Condition="'$(TargetArchitecture)' == 'x64'">
-      <!--
       <MonoAotOption Include="mattr=sse4.2" />
       <MonoAotOption Include="mattr=popcnt" />
       <MonoAotOption Include="mattr=lzcnt" />
       <MonoAotOption Include="mattr=bmi" />
       <MonoAotOption Include="mattr=bmi2" />
-      -->
+      <MonoAotOption Include="mattr=pclmul" />
+      <MonoAotOption Include="mattr=aes" />
     </ItemGroup>
     <PropertyGroup>
       <MonoAotOptions>@(MonoAotOption->'%(Identity)', ',')</MonoAotOptions>
@@ -443,6 +648,8 @@ namespace $([System.String]::Copy($(Category)).Replace(".","_").Replace("\","").
       <AndroidAbi Condition="'$(TargetArchitecture)' == 'arm'">armeabi-v7a</AndroidAbi>
       <AndroidAbi Condition="'$(TargetArchitecture)' == 'x64'">x86_64</AndroidAbi>
       <AndroidAbi Condition="'$(TargetArchitecture)' == 'x86'">x86</AndroidAbi>
+      <MonoInterp>false</MonoInterp>
+      <MonoInterp Condition="'$(RuntimeVariant)' == 'monointerpreter'">true</MonoInterp>
     </PropertyGroup>
 
     <RemoveDir Directories="$(AppDir)" />
@@ -478,14 +685,16 @@ namespace $([System.String]::Copy($(Category)).Replace(".","_").Replace("\","").
         ProjectName="$(Category)"
         MonoRuntimeHeaders="$(MicrosoftNetCoreAppRuntimePackDir)/native/include/mono-2.0"
         StripDebugSymbols="$(StripDebugSymbols)"
+        ForceInterpreter="$(MonoInterp)"
         AppDir="$(BuildDir)"
         OutputDir="$(AppDir)">
         <Output TaskParameter="ApkBundlePath" PropertyName="ApkBundlePath" />
         <Output TaskParameter="ApkPackageId" PropertyName="ApkPackageId" />
     </AndroidAppBuilderTask>
     <Move SourceFiles="$(ApkBundlePath)" DestinationFiles="$(FinalApkPath)" />
-    <Message Importance="High" Text="Apk:       $(FinalApkPath)"/>
-    <Message Importance="High" Text="PackageId: $(ApkPackageId)"/>
+    <Message Importance="High" Text="Apk:        $(FinalApkPath)"/>
+    <Message Importance="High" Text="PackageId:  $(ApkPackageId)"/>
+    <Message Importance="High" Text="MonoInterp: $(MonoInterp)"/>
     <!-- delete the BuildDir in CI builds to save disk space on build agents since they're no longer needed -->
     <RemoveDir Condition="'$(ContinuousIntegrationBuild)' == 'true'" Directories="$(BuildDir)" />
   </Target>
diff --git a/src/tests/run.py b/src/tests/run.py
index 8de44fefeffb4f..c6750a248bded6 100755
--- a/src/tests/run.py
+++ b/src/tests/run.py
@@ -84,7 +84,6 @@
 parser.add_argument("-core_root", dest="core_root", nargs='?', default=None)
 parser.add_argument("-runtime_repo_location", dest="runtime_repo_location", default=os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))))
 parser.add_argument("-test_env", dest="test_env", default=None)
-parser.add_argument("-crossgen_altjit", dest="crossgen_altjit", default=None)
 
 # Optional arguments which change execution.
 
@@ -92,11 +91,9 @@
 parser.add_argument("--long_gc", dest="long_gc", action="store_true", default=False)
 parser.add_argument("--gcsimulator", dest="gcsimulator", action="store_true", default=False)
 parser.add_argument("--ilasmroundtrip", dest="ilasmroundtrip", action="store_true", default=False)
-parser.add_argument("--run_crossgen_tests", dest="run_crossgen_tests", action="store_true", default=False)
 parser.add_argument("--run_crossgen2_tests", dest="run_crossgen2_tests", action="store_true", default=False)
 parser.add_argument("--large_version_bubble", dest="large_version_bubble", action="store_true", default=False)
-parser.add_argument("--precompile_core_root", dest="precompile_core_root", action="store_true", default=False)
-parser.add_argument("--skip_test_run", dest="skip_test_run", action="store_true", default=False, help="Does not run tests. Useful in conjunction with --precompile_core_root")
+parser.add_argument("--skip_test_run", dest="skip_test_run", action="store_true", default=False, help="Does not run tests.")
 parser.add_argument("--sequential", dest="sequential", action="store_true", default=False)
 
 parser.add_argument("--analyze_results_only", dest="analyze_results_only", action="store_true", default=False)
@@ -842,9 +839,6 @@ def run_tests(args,
         test_env_script_path  : Path to script to use to set the test environment, if any.
     """
 
-    if args.precompile_core_root:
-        precompile_core_root(args)
-
     if args.skip_test_run:
         return
 
@@ -869,11 +863,6 @@ def run_tests(args,
         print("Setting RunningIlasmRoundTrip=1")
         os.environ["RunningIlasmRoundTrip"] = "1"
 
-    if args.run_crossgen_tests:
-        print("Running tests R2R")
-        print("Setting RunCrossGen=true")
-        os.environ["RunCrossGen"] = "true"
-
     if args.run_crossgen2_tests:
         print("Running tests R2R (Crossgen2)")
         print("Setting RunCrossGen2=true")
@@ -962,11 +951,6 @@ def setup_args(args):
                               lambda arg: True,
                               "Error setting analyze_results_only")
 
-    coreclr_setup_args.verify(args,
-                              "crossgen_altjit",
-                              lambda arg: True,
-                              "Error setting crossgen_altjit")
-
     coreclr_setup_args.verify(args,
                               "rid",
                               lambda arg: True,
@@ -997,21 +981,11 @@ def setup_args(args):
                               lambda arg: True,
                               "Error setting large_version_bubble")
 
-    coreclr_setup_args.verify(args,
-                              "run_crossgen_tests",
-                              lambda arg: True,
-                              "Error setting run_crossgen_tests")
-
     coreclr_setup_args.verify(args,
                               "run_crossgen2_tests",
                               lambda unused: True,
                               "Error setting run_crossgen2_tests")
 
-    coreclr_setup_args.verify(args,
-                              "precompile_core_root",
-                              lambda arg: True,
-                              "Error setting precompile_core_root")
-
     coreclr_setup_args.verify(args,
                               "skip_test_run",
                               lambda arg: True,
@@ -1044,7 +1018,6 @@ def setup_args(args):
     print("core_root                : %s" % coreclr_setup_args.core_root)
     print("test_location            : %s" % coreclr_setup_args.test_location)
 
-    coreclr_setup_args.crossgen_path = os.path.join(coreclr_setup_args.core_root, "crossgen%s" % (".exe" if coreclr_setup_args.host_os == "windows" else ""))
     coreclr_setup_args.corerun_path = os.path.join(coreclr_setup_args.core_root, "corerun%s" % (".exe" if coreclr_setup_args.host_os == "windows" else ""))
     coreclr_setup_args.dotnetcli_script_path = os.path.join(coreclr_setup_args.runtime_repo_location, "dotnet%s" % (".cmd" if coreclr_setup_args.host_os == "windows" else ".sh"))
     coreclr_setup_args.coreclr_tests_dir = os.path.join(coreclr_setup_args.coreclr_dir, "tests")
@@ -1054,92 +1027,6 @@ def setup_args(args):
 
     return coreclr_setup_args
 
-def precompile_core_root(args):
-    """ Precompile all of the assemblies in the core_root directory
-
-    Args:
-        args
-    """
-
-    skip_list = [
-        ".*xunit.*",
-        ".*api-ms-win-core.*",
-        ".*api-ms-win.*",
-        ".*System.Private.CoreLib.*"
-    ]
-
-    unix_skip_list = [
-        ".*mscorlib.*",
-        ".*System.Runtime.WindowsRuntime.*",
-        ".*System.Runtime.WindowsRuntime.UI.Xaml.*",
-        ".*R2RDump.dll.*"
-    ]
-
-    arm64_unix_skip_list = [
-        ".*Microsoft.CodeAnalysis.VisualBasic.*",
-        ".*System.Net.NameResolution.*",
-        ".*System.Net.Sockets.*",
-        ".*System.Net.Primitives.*"
-    ]
-
-    if args.host_os != "windows":
-        skip_list += unix_skip_list
-
-        if args.arch == "arm64":
-            skip_list += arm64_unix_skip_list
-
-    assert os.path.isdir(args.test_location)
-    assert os.path.isdir(args.core_root)
-
-    def call_crossgen(file, env):
-        assert os.path.isfile(args.crossgen_path)
-        command = [args.crossgen_path, "/Platform_Assemblies_Paths", args.core_root, file]
-
-        proc = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=env)
-        proc.communicate()
-
-        return_code = proc.returncode
-
-        if return_code == -2146230517:
-            print("%s is not a managed assembly." % file)
-            return False
-
-        if return_code != 0:
-            print("Unable to precompile %s (%d)" % (file, return_code))
-            return False
-
-        print("Successfully precompiled %s" % file)
-        return True
-
-    print("Precompiling all assemblies in %s" % args.core_root)
-    print("")
-
-    env = os.environ.copy()
-
-    if not args.crossgen_altjit is None:
-        env["COMPlus_AltJit"]="*"
-        env["COMPlus_AltJitNgen"]="*"
-        env["COMPlus_AltJitName"]=args.crossgen_altjit
-        env["COMPlus_AltJitAssertOnNYI"]="1"
-        env["COMPlus_NoGuiOnAssert"]="1"
-        env["COMPlus_ContinueOnAssert"]="0"
-
-    dlls = [os.path.join(args.core_root, item) for item in os.listdir(args.core_root) if item.endswith("dll") and "mscorlib" not in item]
-
-    def in_skip_list(item):
-        found = False
-        for skip_re in skip_list:
-            if re.match(skip_re, item.lower()) is not None:
-                found = True
-        return found
-
-    dlls = [dll for dll in dlls if not in_skip_list(dll)]
-
-    for dll in dlls:
-        call_crossgen(dll, env)
-
-    print("")
-
 if sys.version_info.major < 3:
     def to_unicode(s):
         return unicode(s, "utf-8")
diff --git a/src/tests/run.sh b/src/tests/run.sh
index bfa564d4cee6e0..362d42027f2027 100755
--- a/src/tests/run.sh
+++ b/src/tests/run.sh
@@ -17,8 +17,6 @@ function print_usage {
     echo '  --testRootDir=<path>             : Root directory of the test build (e.g. runtime/artifacts/tests/windows.x64.Debug).'
     echo '  --disableEventLogging            : Disable the events logged by both VM and Managed Code'
     echo '  --sequential                     : Run tests sequentially (default is to run in parallel).'
-    echo '  --crossgen                       : Precompiles the framework managed assemblies'
-    echo '  --runcrossgentests               : Runs the ReadyToRun tests' 
     echo '  --runcrossgen2tests              : Runs the ReadyToRun tests compiled with Crossgen2' 
     echo '  --jitstress=<n>                  : Runs the tests with COMPlus_JitStress=n'
     echo '  --jitstressregs=<n>              : Runs the tests with COMPlus_JitStressRegs=n'
@@ -94,7 +92,6 @@ limitedCoreDumps=
 
 # Handle arguments
 verbose=0
-doCrossgen=0
 ilasmroundtrip=
 printLastResultsOnly=
 runSequential=0
@@ -140,9 +137,6 @@ do
         --printLastResultsOnly)
             printLastResultsOnly=1
             ;;
-        --crossgen)
-            doCrossgen=1
-            ;;
         --jitstress=*)
             export COMPlus_JitStress=${i#*=}
             ;;
@@ -168,9 +162,6 @@ do
         --disableEventLogging)
             ((disableEventLogging = 1))
             ;;
-        --runcrossgentests)
-            export RunCrossGen=1
-            ;;
         --runcrossgen2tests)
             export RunCrossGen2=1
             ;;
@@ -281,18 +272,10 @@ if [ ! -z "$printLastResultsOnly" ]; then
     runtestPyArguments+=("--analyze_results_only")
 fi
 
-if [ ! -z "$RunCrossGen" ]; then
-    runtestPyArguments+=("--run_crossgen_tests")
-fi
-
 if [ ! -z "$RunCrossGen2" ]; then
     runtestPyArguments+=("--run_crossgen2_tests")
 fi
 
-if (($doCrossgen!=0)); then
-    runtestPyArguments+=("--precompile_core_root")
-fi
-
 if [ "$limitedCoreDumps" == "ON" ]; then
     runtestPyArguments+=("--limited_core_dumps")
 fi
diff --git a/src/tests/tracing/eventcounter/gh53564.cs b/src/tests/tracing/eventcounter/gh53564.cs
new file mode 100644
index 00000000000000..4b2b5907abbe0c
--- /dev/null
+++ b/src/tests/tracing/eventcounter/gh53564.cs
@@ -0,0 +1,109 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+#if USE_MDT_EVENTSOURCE
+using Microsoft.Diagnostics.Tracing;
+#else
+using System.Diagnostics.Tracing;
+#endif
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Diagnostics;
+
+namespace gh53564Tests
+{
+    public class RuntimeCounterListener : EventListener
+    {
+        public RuntimeCounterListener(){}
+
+        private DateTime? setToZeroTimestamp = null;
+        private DateTime? mostRecentTimestamp = null;
+        private ManualResetEvent setToZero = new ManualResetEvent(initialState: false);
+        public ManualResetEvent ReadyToVerify { get; } = new ManualResetEvent(initialState: false);
+
+        protected override void OnEventSourceCreated(EventSource source)
+        {
+            if (source.Name.Equals("System.Runtime"))
+            {
+                Dictionary<string, string> refreshInterval = new Dictionary<string, string>();
+
+                Console.WriteLine($"[{DateTime.UtcNow:hh:mm:ss.fff}] OnEventSourceCreated :: Setting interval to 1");
+                // first set interval to 1 seconds
+                refreshInterval["EventCounterIntervalSec"] = "1";
+                EnableEvents(source, EventLevel.Informational, (EventKeywords)(-1), refreshInterval);
+
+                // wait a moment to get some events
+                Thread.Sleep(TimeSpan.FromSeconds(3));
+
+                // then set interval to 0
+                Console.WriteLine($"[{DateTime.UtcNow:hh:mm:ss.fff}] OnEventSourceCreated :: Setting interval to 0");
+                refreshInterval["EventCounterIntervalSec"] = "0";
+                EnableEvents(source, EventLevel.Informational, (EventKeywords)(-1), refreshInterval);
+                setToZeroTimestamp = DateTime.UtcNow + TimeSpan.FromSeconds(1); // Stash timestamp 1 second after setting to 0
+                setToZero.Set();
+
+                // then attempt to set interval back to 1
+                Thread.Sleep(TimeSpan.FromSeconds(3));
+                Console.WriteLine($"[{DateTime.UtcNow:hh:mm:ss.fff}] OnEventSourceCreated :: Setting interval to 1");
+                refreshInterval["EventCounterIntervalSec"] = "1";
+                EnableEvents(source, EventLevel.Informational, (EventKeywords)(-1), refreshInterval);
+            }
+        }
+
+        protected override void OnEventWritten(EventWrittenEventArgs eventData)
+        {
+            if (!ReadyToVerify.WaitOne(0))
+            {
+                mostRecentTimestamp = eventData.TimeStamp;
+                if (setToZero.WaitOne(0) && mostRecentTimestamp > setToZeroTimestamp)
+                {
+                    Console.WriteLine($"[{DateTime.UtcNow:hh:mm:ss.fff}] OnEventWritten :: Setting ReadyToVerify");
+                    ReadyToVerify.Set();
+                }
+            }
+        }
+
+        public bool Verify()
+        {
+            if (!ReadyToVerify.WaitOne(0))
+                return false;
+
+            Console.WriteLine($"[{DateTime.UtcNow:hh:mm:ss.fff}] Verify :: Verifying");
+            Console.WriteLine($"[{DateTime.UtcNow:hh:mm:ss.fff}]   setToZeroTimestamp = {setToZeroTimestamp?.ToString("hh:mm:ss.fff") ?? "NULL"}");
+            Console.WriteLine($"[{DateTime.UtcNow:hh:mm:ss.fff}]   mostRecentTimestamp = {mostRecentTimestamp?.ToString("hh:mm:ss.fff") ?? "NULL"}");
+
+            return (setToZeroTimestamp is null || mostRecentTimestamp is null) ? false : setToZeroTimestamp < mostRecentTimestamp;
+        }
+    }
+
+    public partial class TestRuntimeEventCounter
+    {
+        public static int Main(string[] args)
+        {
+            // Create an EventListener.
+            using (RuntimeCounterListener myListener = new RuntimeCounterListener())
+            {
+                if (myListener.ReadyToVerify.WaitOne(TimeSpan.FromSeconds(30)))
+                {
+                    if (myListener.Verify())
+                    {
+                        Console.WriteLine("Test passed");
+                        return 100;
+                    }
+                    else
+                    {
+                        Console.WriteLine($"Test Failed - did not see one or more of the expected runtime counters.");
+                        return 1;
+                    }
+                }
+                else
+                {
+                    Console.WriteLine("Test Failed - timed out waiting for reset");
+                    return 1;
+                }
+            }
+        }
+    }
+}
diff --git a/src/tests/tracing/eventcounter/gh53564.csproj b/src/tests/tracing/eventcounter/gh53564.csproj
new file mode 100644
index 00000000000000..5c2b810ee7c115
--- /dev/null
+++ b/src/tests/tracing/eventcounter/gh53564.csproj
@@ -0,0 +1,17 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <CLRTestKind>BuildAndRun</CLRTestKind>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <CLRTestPriority>0</CLRTestPriority>
+    <GCStressIncompatible>true</GCStressIncompatible>
+    <!-- This test is timing sensitive and JIT timing affects the results of the test -->
+    <JitOptimizationSensitive>true</JitOptimizationSensitive>
+    <!-- This test has a secondary thread with an infinite loop -->
+    <UnloadabilityIncompatible>true</UnloadabilityIncompatible>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="gh53564.cs" />
+    <ProjectReference Include="../common/common.csproj" />
+  </ItemGroup>
+</Project>
diff --git a/src/tests/tracing/eventpipe/common/IpcUtils.cs b/src/tests/tracing/eventpipe/common/IpcUtils.cs
index 6f60368894d7e9..b3448f704f238b 100644
--- a/src/tests/tracing/eventpipe/common/IpcUtils.cs
+++ b/src/tests/tracing/eventpipe/common/IpcUtils.cs
@@ -339,6 +339,53 @@ string ParseString(ref int start, ref int end)
         }
     }
 
+    public class ProcessInfo2
+    {
+        // uint64_t ProcessId;
+        // GUID RuntimeCookie;
+        // LPCWSTR CommandLine;
+        // LPCWSTR OS;
+        // LPCWSTR Arch;
+        public UInt64 ProcessId;
+        public Guid RuntimeCookie;
+        public string Commandline;
+        public string OS;
+        public string Arch;
+        public string ManagedEntrypointAssemblyName;
+        public string ClrProductVersion;
+
+        public static ProcessInfo2 TryParse(byte[] buf)
+        {
+            var info = new ProcessInfo2();
+            int start = 0;
+            int end = 8; /* sizeof(uint64_t) */
+            info.ProcessId = BitConverter.ToUInt64(buf[start..end]);
+
+            start = end;
+            end = start + 16; /* sizeof(guid) */
+            info.RuntimeCookie = new Guid(buf[start..end]);
+
+            string ParseString(ref int start, ref int end)
+            {
+                start = end;
+                end = start + 4; /* sizeof(uint32_t) */
+                uint nChars = BitConverter.ToUInt32(buf[start..end]);
+
+                start = end;
+                end = start + ((int)nChars * sizeof(char));
+                return System.Text.Encoding.Unicode.GetString(buf[start..end]).TrimEnd('\0');
+            }
+
+            info.Commandline = ParseString(ref start, ref end);
+            info.OS = ParseString(ref start, ref end);
+            info.Arch = ParseString(ref start, ref end);
+            info.ManagedEntrypointAssemblyName = ParseString(ref start, ref end);
+            info.ClrProductVersion = ParseString(ref start, ref end);
+
+            return info;
+        }
+    }
+
     public class IpcClient
     {
         public static IpcMessage SendMessage(Stream stream, IpcMessage message)
diff --git a/src/tests/tracing/eventpipe/processenvironment/processenvironment.csproj b/src/tests/tracing/eventpipe/processenvironment/processenvironment.csproj
index 8633e6ca18836e..97976e33e50c49 100644
--- a/src/tests/tracing/eventpipe/processenvironment/processenvironment.csproj
+++ b/src/tests/tracing/eventpipe/processenvironment/processenvironment.csproj
@@ -8,6 +8,8 @@
     <UnloadabilityIncompatible>true</UnloadabilityIncompatible>
     <JitOptimizationSensitive>true</JitOptimizationSensitive>
     <IlasmRoundTripIncompatible>true</IlasmRoundTripIncompatible>
+    <!-- Disable under GCStress. Tracking: https://github.com/dotnet/runtime/issues/51477 -->
+    <GCStressIncompatible>true</GCStressIncompatible>
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="$(MSBuildProjectName).cs" />
diff --git a/src/tests/tracing/eventpipe/processinfo2/processinfo2.cs b/src/tests/tracing/eventpipe/processinfo2/processinfo2.cs
new file mode 100644
index 00000000000000..08a10821041185
--- /dev/null
+++ b/src/tests/tracing/eventpipe/processinfo2/processinfo2.cs
@@ -0,0 +1,235 @@
+// 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.Diagnostics.Tracing;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Reflection;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Diagnostics.Tools.RuntimeClient;
+using Microsoft.Diagnostics.Tracing;
+using Tracing.Tests.Common;
+
+namespace Tracing.Tests.ProcessInfoValidation
+{
+    public class ProcessInfoValidation
+    {
+        public static string NormalizeCommandLine(string cmdline)
+        {
+            // ASSUMPTION: double quotes (") and single quotes (') are used for paths with spaces
+            // ASSUMPTION: This test will only have two parts to the commandline
+
+            // check for quotes in first part
+            var parts = new List<string>();
+            bool isQuoted = false;
+            int start = 0;
+
+            for (int i = 0; i < cmdline.Length; i++)
+            {
+                if (isQuoted)
+                {
+                    if (cmdline[i] == '"' || cmdline[i] == '\'')
+                    {
+                        parts.Add(cmdline.Substring(start, i - start));
+                        isQuoted = false;
+                        start = i + 1;
+                    }
+                }
+                else if (cmdline[i] == '"' || cmdline[i] == '\'')
+                {
+                    isQuoted = true;
+                    start = i + 1;
+                }
+                else if (cmdline[i] == ' ')
+                {
+                    parts.Add(cmdline.Substring(start, i - start));
+                    start = i + 1;
+                }
+                else if (i == cmdline.Length - 1)
+                {
+                    parts.Add(cmdline.Substring(start));
+                }
+            }
+
+            string normalizedCommandLine = parts
+                .Where(part => !string.IsNullOrWhiteSpace(part))
+                .Select(part => (new FileInfo(part)).FullName)
+                .Aggregate((s1, s2) => string.Join(' ', s1, s2));
+
+            // Tests are run out of /tmp on Mac and linux, but on Mac /tmp is actually a symlink that points to /private/tmp.
+            // This isn't represented in the output from FileInfo.FullName unfortunately, so we'll fake that completion in that case.
+            if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX) && normalizedCommandLine.StartsWith("/tmp/"))
+                normalizedCommandLine = "/private" + normalizedCommandLine;
+
+            return normalizedCommandLine;
+        }
+
+        public static int Main(string[] args)
+        {
+
+            Process currentProcess = Process.GetCurrentProcess();
+            int pid = currentProcess.Id;
+            Logger.logger.Log($"Test PID: {pid}");
+
+            Stream stream = ConnectionHelper.GetStandardTransport(pid);
+
+            // 0x04 = ProcessCommandSet, 0x04 = ProcessInfo2
+            var processInfoMessage = new IpcMessage(0x04, 0x04);
+            Logger.logger.Log($"Wrote: {processInfoMessage}");
+            IpcMessage response = IpcClient.SendMessage(stream, processInfoMessage);
+            Logger.logger.Log($"Received: <omitted>");
+
+            Utils.Assert(response.Header.CommandSet == 0xFF, $"Response must have Server command set. Expected: 0xFF, Received: 0x{response.Header.CommandSet:X2}"); // server
+            Utils.Assert(response.Header.CommandId == 0x00, $"Response must have OK command id. Expected: 0x00, Received: 0x{response.Header.CommandId:X2}"); // OK
+
+            // Parse payload
+            // uint64_t ProcessId;
+            // GUID RuntimeCookie;
+            // LPCWSTR CommandLine;
+            // LPCWSTR OS;
+            // LPCWSTR Arch;
+
+            int totalSize = response.Payload.Length;
+            Logger.logger.Log($"Total size of Payload = {totalSize} bytes");
+
+            // VALIDATE PID
+            int start = 0;
+            int end = start + 8 /* sizeof(uint63_t) */;
+            UInt64 processId = BitConverter.ToUInt64(response.Payload[start..end]);
+            Utils.Assert((int)processId == pid, $"PID in process info must match. Expected: {pid}, Received: {processId}");
+            Logger.logger.Log($"pid: {processId}");
+
+            // VALIDATE RUNTIME COOKIE
+            start = end;
+            end = start + 16 /* sizeof(GUID) */;
+            Guid runtimeCookie = new Guid(response.Payload[start..end]);
+            Logger.logger.Log($"runtimeCookie: {runtimeCookie}");
+
+            // VALIDATE COMMAND LINE
+            start = end;
+            end = start + 4 /* sizeof(uint32_t) */;
+            UInt32 commandLineLength = BitConverter.ToUInt32(response.Payload[start..end]);
+            Logger.logger.Log($"commandLineLength: {commandLineLength}");
+
+            start = end;
+            end = start + ((int)commandLineLength * sizeof(char));
+            Utils.Assert(end <= totalSize, $"String end can't exceed payload size. Expected: <{totalSize}, Received: {end} (decoded length: {commandLineLength})");
+            Logger.logger.Log($"commandLine bytes: [ {response.Payload[start..end].Select(b => b.ToString("X2") + " ").Aggregate(string.Concat)}]");
+            string commandLine = System.Text.Encoding.Unicode.GetString(response.Payload[start..end]).TrimEnd('\0');
+            Logger.logger.Log($"commandLine: \"{commandLine}\"");
+
+            // The following logic is tailored to this specific test where the cmdline _should_ look like the following:
+            // /path/to/corerun /path/to/processinfo.dll
+            // or
+            // "C:\path\to\CoreRun.exe" C:\path\to\processinfo.dll
+            string currentProcessCommandLine = $"{currentProcess.MainModule.FileName} {System.Reflection.Assembly.GetExecutingAssembly().Location}";
+            string receivedCommandLine = NormalizeCommandLine(commandLine);
+
+            Utils.Assert(currentProcessCommandLine.Equals(receivedCommandLine, StringComparison.OrdinalIgnoreCase), $"CommandLine must match current process. Expected: {currentProcessCommandLine}, Received: {receivedCommandLine} (original: {commandLine})");
+
+            // VALIDATE OS
+            start = end;
+            end = start + 4 /* sizeof(uint32_t) */;
+            UInt32 OSLength = BitConverter.ToUInt32(response.Payload[start..end]);
+            Logger.logger.Log($"OSLength: {OSLength}");
+
+            start = end;
+            end = start + ((int)OSLength * sizeof(char));
+            Utils.Assert(end <= totalSize, $"String end can't exceed payload size. Expected: <{totalSize}, Received: {end} (decoded length: {OSLength})");
+            Logger.logger.Log($"OS bytes: [ {response.Payload[start..end].Select(b => b.ToString("X2") + " ").Aggregate(string.Concat)}]");
+            string OS = System.Text.Encoding.Unicode.GetString(response.Payload[start..end]).TrimEnd('\0');
+            Logger.logger.Log($"OS: \"{OS}\"");
+
+            // see eventpipeeventsource.cpp for these values
+            string expectedOSValue = null;
+            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+            {
+                expectedOSValue = "Windows";
+            }
+            else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
+            {
+                expectedOSValue = "macOS";
+            }
+            else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
+            {
+                expectedOSValue = "Linux";
+            }
+            else
+            {
+                expectedOSValue = "Unknown";
+            }
+
+            Utils.Assert(expectedOSValue.Equals(OS), $"OS must match current Operating System. Expected: \"{expectedOSValue}\", Received: \"{OS}\"");
+
+            // VALIDATE ARCH
+            start = end;
+            end = start + 4 /* sizeof(uint32_t) */;
+            UInt32 archLength = BitConverter.ToUInt32(response.Payload[start..end]);
+            Logger.logger.Log($"archLength: {archLength}");
+
+            start = end;
+            end = start + ((int)archLength * sizeof(char));
+            Utils.Assert(end <= totalSize, $"String end can't exceed payload size. Expected: <{totalSize}, Received: {end} (decoded length: {archLength})");
+            Logger.logger.Log($"arch bytes: [ {response.Payload[start..end].Select(b => b.ToString("X2") + " ").Aggregate(string.Concat)}]");
+            string arch = System.Text.Encoding.Unicode.GetString(response.Payload[start..end]).TrimEnd('\0');
+            Logger.logger.Log($"arch: \"{arch}\"");
+
+            // see eventpipeeventsource.cpp for these values
+            string expectedArchValue = RuntimeInformation.ProcessArchitecture switch
+            {
+                Architecture.X86 => "x86",
+                Architecture.X64 => "x64",
+                Architecture.Arm => "arm32",
+                Architecture.Arm64 => "arm64",
+                _ => "Unknown"
+            };
+
+            Utils.Assert(expectedArchValue.Equals(arch), $"OS must match current Operating System. Expected: \"{expectedArchValue}\", Received: \"{arch}\"");
+
+            // VALIDATE ManagedEntrypointAssemblyName
+            start = end;
+            end = start + 4 /* sizeof(uint32_t) */;
+            UInt32 managedEntrypointAssemblyNameLength = BitConverter.ToUInt32(response.Payload[start..end]);
+            Logger.logger.Log($"managedEntrypointAssemblyNameLength: {managedEntrypointAssemblyNameLength}");
+
+            start = end;
+            end = start + ((int)managedEntrypointAssemblyNameLength * sizeof(char));
+            Utils.Assert(end <= totalSize, $"String end can't exceed payload size. Expected: <{totalSize}, Received: {end} (decoded length: {managedEntrypointAssemblyNameLength})");
+            Logger.logger.Log($"ManagedEntrypointAssemblyName bytes: [ {response.Payload[start..end].Select(b => b.ToString("X2") + " ").Aggregate(string.Concat)}]");
+            string managedEntrypointAssemblyName = System.Text.Encoding.Unicode.GetString(response.Payload[start..end]).TrimEnd('\0');
+            Logger.logger.Log($"ManagedEntrypointAssemblyName: \"{managedEntrypointAssemblyName}\"");
+
+            string expectedManagedEntrypointAssemblyName = System.Reflection.Assembly.GetExecutingAssembly().GetName().Name;
+
+            Utils.Assert(expectedManagedEntrypointAssemblyName.Equals(managedEntrypointAssemblyName), $"ManagedEntrypointAssemblyName must match. Expected: \"{expectedManagedEntrypointAssemblyName}\", received: \"{managedEntrypointAssemblyName}\"");
+
+            // VALIDATE ClrProductVersion
+            start = end;
+            end = start + 4 /* sizeof(uint32_t) */;
+            UInt32 clrProductVersionSize = BitConverter.ToUInt32(response.Payload[start..end]);
+            Logger.logger.Log($"clrProductVersionSize: {clrProductVersionSize}");
+
+            start = end;
+            end = start + ((int)clrProductVersionSize * sizeof(char));
+            Utils.Assert(end <= totalSize, $"String end can't exceed payload size. Expected: <{totalSize}, Received: {end} (decoded length: {clrProductVersionSize})");
+            Logger.logger.Log($"ClrProductVersion bytes: [ {response.Payload[start..end].Select(b => b.ToString("X2") + " ").Aggregate(string.Concat)}]");
+            string clrProductVersion = System.Text.Encoding.Unicode.GetString(response.Payload[start..end]).TrimEnd('\0');
+            Logger.logger.Log($"ClrProductVersion: \"{clrProductVersion}\"");
+
+            string expectedClrProductVersion = typeof(object).Assembly.GetCustomAttribute<AssemblyInformationalVersionAttribute>()?.InformationalVersion;
+
+            Utils.Assert(expectedClrProductVersion.Equals(clrProductVersion), $"ClrProductVersion must match. Expected: \"{expectedClrProductVersion}\", received: \"{clrProductVersion}\"");
+
+            Utils.Assert(end == totalSize, $"Full payload should have been read. Expected: {totalSize}, Received: {end}");
+
+            Logger.logger.Log($"\n{{\n\tprocessId: {processId},\n\truntimeCookie: {runtimeCookie},\n\tcommandLine: {commandLine},\n\tOS: {OS},\n\tArch: {arch},\n\tManagedEntrypointAssemblyName: {managedEntrypointAssemblyName},\n\tClrProductVersion: {clrProductVersion}\n}}");
+
+            return 100;
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/tests/tracing/eventpipe/processinfo2/processinfo2.csproj b/src/tests/tracing/eventpipe/processinfo2/processinfo2.csproj
new file mode 100644
index 00000000000000..69e7a9fba00c24
--- /dev/null
+++ b/src/tests/tracing/eventpipe/processinfo2/processinfo2.csproj
@@ -0,0 +1,19 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFrameworkIdentifier>.NETCoreApp</TargetFrameworkIdentifier>
+    <OutputType>exe</OutputType>
+    <CLRTestKind>BuildAndRun</CLRTestKind>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <CLRTestPriority>0</CLRTestPriority>
+    <UnloadabilityIncompatible>true</UnloadabilityIncompatible>
+    <JitOptimizationSensitive>true</JitOptimizationSensitive>
+    <!-- ilasm round-trip testing doesn't work, as test expects unchanged assembly name.
+         Issue: https://github.com/dotnet/runtime/issues/39935
+    -->
+    <IlasmRoundTripIncompatible>true</IlasmRoundTripIncompatible>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="$(MSBuildProjectName).cs" />
+    <ProjectReference Include="../common/common.csproj" />
+  </ItemGroup>
+</Project>