diff --git a/eng/Subsets.props b/eng/Subsets.props
index 337bca6fa63caf..318ffc4179c8ec 100644
--- a/eng/Subsets.props
+++ b/eng/Subsets.props
@@ -168,7 +168,7 @@
 
     <!-- Define AllSubsets to include all available subsets including OnDemand ones -->
     <AllSubsetsExpansion>clr.nativeprereqs+clr.iltools+clr.runtime+clr.native+clr.aot+clr.nativeaotlibs+clr.nativeaotruntime+clr.crossarchtools</AllSubsetsExpansion>
-    <AllSubsetsExpansion>$(AllSubsetsExpansion)+clr.paltests+clr.paltestlist+clr.hosts+clr.jit+clr.alljits+clr.alljitscommunity+clr.spmi+clr.corelib+clr.nativecorelib+clr.tools+clr.toolstests+clr.packages</AllSubsetsExpansion>
+    <AllSubsetsExpansion>$(AllSubsetsExpansion)+clr.paltests+clr.paltestlist+clr.hosts+clr.jit+clr.alljits+clr.alljitscommunity+clr.spmi+clr.corelib+clr.nativecorelib+clr.tools+clr.toolstests+clr.r2rtests+clr.packages</AllSubsetsExpansion>
     <AllSubsetsExpansion Condition="$([MSBuild]::IsOsPlatform(Windows))">$(AllSubsetsExpansion)+linuxdac+alpinedac</AllSubsetsExpansion>
     <AllSubsetsExpansion>$(AllSubsetsExpansion)+mono.runtime+provision.emsdk+mono.aotcross+mono.corelib+mono.manifests+mono.packages+mono.tools+mono.wasmruntime+mono.wasiruntime+mono.wasmworkload+mono.mscordbi</AllSubsetsExpansion>
     <AllSubsetsExpansion>$(AllSubsetsExpansion)+tools.illink+tools.cdac+tools.illinktests+tools.cdactests+tools.cdacdumptests</AllSubsetsExpansion>
@@ -232,6 +232,7 @@
     <SubsetName Include="Clr.NativeCoreLib" Description="Run crossgen on System.Private.CoreLib library for CoreCLR." />
     <SubsetName Include="Clr.Tools" Description="Managed tools that support CoreCLR development and testing." />
     <SubsetName Include="Clr.ToolsTests" OnDemand="true" Description="Unit tests for the clr.tools subset." />
+    <SubsetName Include="Clr.R2RTests" OnDemand="true" Description="Unit tests for crossgen2 (ReadyToRun compiler)." />
     <SubsetName Include="Clr.Packages" Description="The projects that produce NuGet packages for the CoreCLR runtime, crossgen, and IL tools." />
     <SubsetName Include="LinuxDac" Condition="$([MSBuild]::IsOsPlatform(Windows))" OnDemand="true" Description="The cross-OS Windows->libc-based Linux DAC. Skipped on x86." />
     <SubsetName Include="AlpineDac" Condition="$([MSBuild]::IsOsPlatform(Windows))" OnDemand="true" Description="The cross-OS Windows->musl-libc-based Linux DAC. Skipped on x86" />
@@ -393,7 +394,6 @@
 
   <ItemGroup>
     <!-- crossgen2/ILC have dependencies on the JITs, so build them if the cross component includes crossgen2/ILC. -->
-    <_CrossToolSubset Condition="'$(_BuildCrossComponents)' == 'true' and '$(TargetArchitecture)' != 'wasm' and $(_subset.Contains('+clr.toolstests+'))" Include="ClrAllJitsSubset=true" />
     <_CrossToolSubset Condition="'$(_BuildCrossComponents)' == 'true' and '$(TargetArchitecture)' != 'wasm' and ($(_subset.Contains('+clr.tools+')) or $(_subset.Contains('+clr.nativecorelib+')) or $(_subset.Contains('+clr.crossarchtools+')))" Include="ClrJitSubset=true" />
     <!-- When targeting WebAssembly, only build the wasm JIT for the cross component. -->
     <_CrossToolSubset Condition="'$(_BuildCrossComponents)' == 'true' and '$(TargetArchitecture)' == 'wasm' and ($(_subset.Contains('+clr.tools+')) or $(_subset.Contains('+clr.nativecorelib+')) or $(_subset.Contains('+clr.crossarchtools+')))" Include="ClrWasmJitSubset=true" />
@@ -519,14 +519,17 @@
       Test="true" Category="clr" Condition="'$(DotNetBuildSourceOnly)' != 'true' and '$(NativeAotSupported)' == 'true'"/>
     <ProjectToBuild Include="$(CoreClrProjectRoot)tools\aot\ILCompiler.Trimming.Tests\ILCompiler.Trimming.Tests.csproj"
       Test="true" Category="clr" Condition="'$(DotNetBuildSourceOnly)' != 'true' and '$(NativeAotSupported)' == 'true'"/>
-    <ProjectToBuild Include="$(CoreClrProjectRoot)tools\aot\ILCompiler.ReadyToRun.Tests\ILCompiler.ReadyToRun.Tests.csproj"
-      Test="true" Category="clr" Condition="'$(DotNetBuildSourceOnly)' != 'true' and '$(NativeAotSupported)' == 'true'"/>
     <ProjectToBuild Include="$(CoreClrProjectRoot)tools\ILVerification.Tests\ILVerification.Tests.csproj"
       Test="true" Category="clr" Condition="'$(DotNetBuildSourceOnly)' != 'true'"/>
     <ProjectToBuild Include="$(CoreClrProjectRoot)tools\ILTrim.Tests\ILTrim.Tests.csproj"
       Test="true" Category="clr" Condition="'$(DotNetBuildSourceOnly)' != 'true'"/>
   </ItemGroup>
 
+  <ItemGroup Condition="$(_subset.Contains('+clr.r2rtests+'))">
+    <ProjectToBuild Include="$(CoreClrProjectRoot)tools\aot\ILCompiler.ReadyToRun.Tests\ILCompiler.ReadyToRun.Tests.csproj"
+      Test="true" Category="clr" Condition="'$(DotNetBuildSourceOnly)' != 'true'"/>
+  </ItemGroup>
+
   <PropertyGroup Condition="$(_subset.Contains('+tools.cdac+'))">
     <_CDacToolsBuilt Condition="'$(_CDacToolsBuilt)' != 'true'">true</_CDacToolsBuilt>
   </PropertyGroup>
diff --git a/eng/pipelines/runtime.yml b/eng/pipelines/runtime.yml
index af2fc6e3392cf5..53dc7851765d6d 100644
--- a/eng/pipelines/runtime.yml
+++ b/eng/pipelines/runtime.yml
@@ -232,6 +232,7 @@ extends:
                 eq(variables['wasmDarcDependenciesChanged'], true),
                 eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_tools_illink.containsChange'], true),
                 eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_wasm_coreclr_runtimetests.containsChange'], true),
+                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
                 eq(variables['isRollingBuild'], true))
 
       - template: /eng/pipelines/common/platform-matrix.yml
@@ -951,6 +952,166 @@ extends:
                 eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_tools_illink.containsChange'], true),
                 eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_tools_cdac.containsChange'], true),
                 eq(variables['isRollingBuild'], true))
+
+      # The R2R test suite compiles for one target per run: the test assembly itself always runs on
+      # the build machine, while crossgen2 and the shared framework it compiles against are staged
+      # for whatever the build targets. Each leg therefore needs only its own target's artifacts,
+      # and test cases the target cannot compile are skipped rather than failed.
+      - template: /eng/pipelines/common/platform-matrix.yml
+        parameters:
+          jobTemplate: /eng/pipelines/common/global-build-job.yml
+          buildConfig: checked
+          platforms:
+          - linux_x64
+          jobParameters:
+            dependsOn:
+            - build_linux_x64_checked_CoreCLR_ReleaseLibraries
+            timeoutInMinutes: 120
+            nameSuffix: CLR_R2R_Tests_linux_x64
+            buildArgs: -s clr.r2rtests -lc Release -c $(_BuildConfig) -test
+            enablePublishTestResults: true
+            testResultsFormat: 'xunit'
+            preBuildSteps:
+              - template: /eng/pipelines/common/download-artifact-step.yml
+                parameters:
+                  artifactName: CoreCLR_ReleaseLibraries_BuildArtifacts_linux_x64_Checked
+                  artifactFileName: CoreCLR_ReleaseLibraries_BuildArtifacts_linux_x64_Checked$(archiveExtension)
+                  unpackFolder: $(Build.SourcesDirectory)/artifacts/bin
+                  cleanUnpackFolder: false
+                  overwriteExistingFiles: true
+                  displayName: Download linux-x64 artifacts
+            condition: >-
+              or(
+                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
+                eq(variables['isRollingBuild'], true))
+
+      - template: /eng/pipelines/common/platform-matrix.yml
+        parameters:
+          jobTemplate: /eng/pipelines/common/global-build-job.yml
+          buildConfig: checked
+          platforms:
+          - linux_x64
+          variables:
+            - name: _osParameter
+              value: -os browser
+            - name: _archParameter
+              value: -arch wasm
+          jobParameters:
+            dependsOn:
+            - build_browser_wasm_linux_checked_CoreCLR_ReleaseLibraries
+            timeoutInMinutes: 120
+            nameSuffix: CLR_R2R_Tests_browser_wasm
+            buildArgs: -s clr.r2rtests -lc Release -c $(_BuildConfig) -test
+            enablePublishTestResults: true
+            testResultsFormat: 'xunit'
+            preBuildSteps:
+              - template: /eng/pipelines/common/download-artifact-step.yml
+                parameters:
+                  artifactName: CoreCLR_ReleaseLibraries_BuildArtifacts_browser_wasm_linux_Checked
+                  artifactFileName: CoreCLR_ReleaseLibraries_BuildArtifacts_browser_wasm_linux_Checked$(archiveExtension)
+                  unpackFolder: $(Build.SourcesDirectory)/artifacts/bin
+                  cleanUnpackFolder: false
+                  overwriteExistingFiles: true
+                  displayName: Download browser-wasm artifacts
+            condition: >-
+              or(
+                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
+                eq(variables['isRollingBuild'], true))
+
+      - template: /eng/pipelines/common/platform-matrix.yml
+        parameters:
+          jobTemplate: /eng/pipelines/common/global-build-job.yml
+          buildConfig: checked
+          platforms:
+          - linux_x64
+          variables:
+            - name: _archParameter
+              value: -arch arm
+          jobParameters:
+            dependsOn:
+            - build_linux_arm_checked_CoreCLR_ReleaseLibraries
+            timeoutInMinutes: 120
+            nameSuffix: CLR_R2R_Tests_linux_arm
+            buildArgs: -s clr.r2rtests -lc Release -c $(_BuildConfig) -test
+            enablePublishTestResults: true
+            testResultsFormat: 'xunit'
+            preBuildSteps:
+              - template: /eng/pipelines/common/download-artifact-step.yml
+                parameters:
+                  artifactName: CoreCLR_ReleaseLibraries_BuildArtifacts_linux_arm_Checked
+                  artifactFileName: CoreCLR_ReleaseLibraries_BuildArtifacts_linux_arm_Checked$(archiveExtension)
+                  unpackFolder: $(Build.SourcesDirectory)/artifacts/bin
+                  cleanUnpackFolder: false
+                  overwriteExistingFiles: true
+                  displayName: Download linux-arm artifacts
+            condition: >-
+              or(
+                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
+                eq(variables['isRollingBuild'], true))
+
+      - template: /eng/pipelines/common/platform-matrix.yml
+        parameters:
+          jobTemplate: /eng/pipelines/common/global-build-job.yml
+          buildConfig: checked
+          platforms:
+          - linux_x64
+          variables:
+            - name: _osParameter
+              value: -os ios
+            - name: _archParameter
+              value: -arch arm64
+          jobParameters:
+            timeoutInMinutes: 120
+            nameSuffix: CLR_R2R_Tests_ios_arm64
+            # No prebuilt artifact can supply this leg: the iOS jobs run on macOS, so their cross
+            # components are Mach-O and unusable here. The cross components are built from source
+            # instead - they target the build host (linux-x64), not iOS, so no Apple SDK is needed.
+            # libs.sfx rather than libs, because libs.native does require the Apple SDK.
+            buildArgs: -s clr.crossarchtools+clr.corelib+libs.sfx -rf CoreCLR -lc Release -c $(_BuildConfig)
+            enablePublishTestResults: true
+            testResultsFormat: 'xunit'
+            postBuildSteps:
+              # A separate invocation because clr.r2rtests is ordered ahead of libs.sfx in
+              # Subsets.props, so a single build would run the tests before their inputs exist.
+              - template: /eng/pipelines/common/templates/global-build-step.yml
+                parameters:
+                  buildArgs: -s clr.r2rtests -rf CoreCLR -lc Release -c $(_BuildConfig) -test
+                  displayName: Build and run R2R tests
+            condition: >-
+              or(
+                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
+                eq(variables['isRollingBuild'], true))
+
+      # The only leg with a Windows host, which the two --pdb test cases require: crossgen2 writes
+      # Windows PDBs through Microsoft.DiaSymReader.Native, which is restored for Windows only.
+      - template: /eng/pipelines/common/platform-matrix.yml
+        parameters:
+          jobTemplate: /eng/pipelines/common/global-build-job.yml
+          buildConfig: checked
+          platforms:
+          - windows_x64
+          jobParameters:
+            dependsOn:
+            - build_windows_x64_checked_CoreCLR_ReleaseLibraries
+            timeoutInMinutes: 120
+            nameSuffix: CLR_R2R_Tests_windows_x64
+            buildArgs: -s clr.r2rtests -lc Release -c $(_BuildConfig) -test
+            enablePublishTestResults: true
+            testResultsFormat: 'xunit'
+            preBuildSteps:
+              - template: /eng/pipelines/common/download-artifact-step.yml
+                parameters:
+                  artifactName: CoreCLR_ReleaseLibraries_BuildArtifacts_windows_x64_Checked
+                  artifactFileName: CoreCLR_ReleaseLibraries_BuildArtifacts_windows_x64_Checked$(archiveExtension)
+                  unpackFolder: $(Build.SourcesDirectory)/artifacts/bin
+                  cleanUnpackFolder: false
+                  overwriteExistingFiles: true
+                  displayName: Download windows-x64 artifacts
+            condition: >-
+              or(
+                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
+                eq(variables['isRollingBuild'], true))
+
       #
       # Build CrossDacs
       #
diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun.Tests/ILCompiler.ReadyToRun.Tests.csproj b/src/coreclr/tools/aot/ILCompiler.ReadyToRun.Tests/ILCompiler.ReadyToRun.Tests.csproj
index 9969de865e5fe9..1c77956d8bbe6b 100644
--- a/src/coreclr/tools/aot/ILCompiler.ReadyToRun.Tests/ILCompiler.ReadyToRun.Tests.csproj
+++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun.Tests/ILCompiler.ReadyToRun.Tests.csproj
@@ -1,17 +1,22 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
+  <!-- Set TargetOS and TargetArchitecture to control what JIT and corelib the tests will give to crossgen2 -->
+  <!-- Setting TargetRid will not work -->
+
   <PropertyGroup>
     <AssemblyName>ILCompiler.ReadyToRun.Tests</AssemblyName>
     <TargetFramework>$(NetCoreAppToolCurrent)</TargetFramework>
     <Nullable>enable</Nullable>
-    <IsPackable>false</IsPackable>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <Platforms>x64;x86</Platforms>
-    <PlatformTarget>AnyCPU</PlatformTarget>
-    <RuntimeIdentifiers>linux-x64;win-x64;osx-x64</RuntimeIdentifiers>
-    <Configurations>Debug;Release;Checked</Configurations>
-    <CopyLocalLockFileAssemblies>true</CopyLocalLockFileAssemblies>
     <TestRunnerAdditionalArguments>-notrait category=failing</TestRunnerAdditionalArguments>
+    <!-- These tests build for AnyCPU, but the assets copied for crossgen compilations within the
+         tests are tied to the outer runtime build's Target -->
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <RuntimeIdentifier>$(NETCoreSdkRuntimeIdentifier)</RuntimeIdentifier>
+    <AppendRuntimeIdentifierToOutputPath>false</AppendRuntimeIdentifierToOutputPath>
+    <!-- Set the output path based on the RID of the outer build (the one used in crossgen
+         compilations that run inside the tests), not this test's RID
+         Some tests are skipped based on CoreCLRConfiguration, so also include that in output path -->
+    <OutputPath>$(BaseOutputPath)$(Configuration)\$(CoreCLRConfiguration)_CLR\$(TargetRid)\</OutputPath>
   </PropertyGroup>
 
   <ItemGroup>
@@ -21,93 +26,49 @@
 
   <ItemGroup>
     <ProjectReference Include="../ILCompiler.Reflection.ReadyToRun/ILCompiler.Reflection.ReadyToRun.csproj" />
-    <!-- Aliased because it redefines the ReadyToRun* constant enums that
-         ILCompiler.Reflection.ReadyToRun already brings into the global namespace. -->
     <ProjectReference Include="../ILCompiler.ReadyToRun/ILCompiler.ReadyToRun.csproj" Aliases="crossgen2" />
-    <ProjectReference Include="../crossgen2/crossgen2_inbuild.csproj" ReferenceOutputAssembly="false">
-      <!-- crossgen2 is a CoreCLR artifact, so publish it in the CoreCLR configuration. This keeps it
-           alongside the other CoreCLR artifacts the test consumes (System.Private.CoreLib, the JITs)
-           even when this test project is built in a different configuration than CoreCLR was (e.g.
-           CoreCLR built Release via 'clr -rc release', but the test built/run as Debug). Mirrors the
-           CoreLib SetConfiguration pattern in eng/references.targets. -->
-      <SetConfiguration Condition="'$(Configuration)' == '$(CoreCLRConfiguration)'">CopyAllJitLibrariesToAotCompilerOutput=true</SetConfiguration>
-      <SetConfiguration Condition="'$(Configuration)' != '$(CoreCLRConfiguration)'">Configuration=$(CoreCLRConfiguration);CopyAllJitLibrariesToAotCompilerOutput=true</SetConfiguration>
+    <ProjectReference Include="../crossgen2/crossgen2_inbuild.csproj" ReferenceOutputAssembly="false" OutputItemType="Crossgen2InbuildOutputItems" Private="false">
+      <SetConfiguration>Configuration=$(CoreCLRConfiguration);CopyAllJitLibrariesToAotCompilerOutput=true;TargetArchitecture=$(TargetArchitecture);TargetOS=$(TargetOS)</SetConfiguration>
     </ProjectReference>
   </ItemGroup>
 
-  <!-- HACK: We run runtime.proj inline to build the wasm JIT and then Copy it directly into
-       crossgen2_inbuild's publish dir. This is hacky for two reasons:
-         1. crossgen2_inbuild's <Content> glob for clrjits is evaluated at project-load time,
-            before this target runs, so on a clean tree the glob misses the freshly installed
-            JITs and the direct Copy is the only thing that reliably gets the file there.
-         2. We reach into another project's publish dir instead of flowing outputs through the
-            ProjectReference protocol.
-       Ideally this would be replaced by a proper ProjectReference setup where the wasm JIT and
-       crossgen2's other dependencies flow into our own output dir via GetCopyToOutputDirectoryItems,
-       and R2RTest.Crossgen2Dir points at the test's bin dir instead of crossgen2_inbuild's publish dir.
-
-       In cross builds JITs land in $(CoreCLRArtifactsPath)$(BuildArchitecture)/; we mirror
-       eng/Subsets.props's cross-tool stanza so install/read paths agree.
-       Hooks into ResolveProjectReferences so it fires for `dotnet build` (and CI's `build.sh -test`,
-       which builds before testing). `dotnet build /t:test` alone won't trigger it. -->
-  <PropertyGroup>
-    <_BuildJitsCrossArch Condition="'$(CrossBuild)' == 'true' or '$(BuildArchitecture)' != '$(TargetArchitecture)' or '$(HostOS)' != '$(TargetOS)' or '$(TargetsLinuxBionic)' == 'true' or '$(EnableNativeSanitizers)' != ''">true</_BuildJitsCrossArch>
-    <_BuildJitsProperties>ClrAllJitsSubset=true;ClrWasmJitSubset=true;Configuration=$(CoreCLRConfiguration)</_BuildJitsProperties>
-    <_BuildJitsProperties Condition="!$([MSBuild]::IsOsPlatform(Windows))">$(_BuildJitsProperties);Ninja=true</_BuildJitsProperties>
-    <_BuildJitsProperties Condition="'$(_BuildJitsCrossArch)' == 'true'">$(_BuildJitsProperties);HostArchitecture=$(BuildArchitecture);HostCrossOS=$(HostOS);CrossBuild=false;BuildSubdirectory=$(BuildArchitecture);CMakeArgs=$(CMakeArgs) -DCLR_CROSS_COMPONENTS_BUILD=1;PgoInstrument=false;NoPgoOptimize=true</_BuildJitsProperties>
-  </PropertyGroup>
-
-  <Target Name="BuildAllJitsForReadyToRunTests"
-          BeforeTargets="ResolveProjectReferences"
-          Condition="'$(DesignTimeBuild)' != 'true'">
-    <MSBuild Projects="$(CoreClrProjectRoot)runtime.proj"
-             Targets="Build"
-             Properties="$(_BuildJitsProperties)" />
-
-    <PropertyGroup>
-      <_WasmJitCrossHostArchSubdir Condition="'$(_BuildJitsCrossArch)' == 'true'">$(BuildArchitecture)/</_WasmJitCrossHostArchSubdir>
-      <_WasmJitFileName>$(HostLibPrefix)clrjit_universal_wasm_$(BuildArchitecture)$(HostLibSuffix)</_WasmJitFileName>
-      <_WasmJitSourcePath>$(CoreCLRArtifactsPath)$(_WasmJitCrossHostArchSubdir)$(_WasmJitFileName)</_WasmJitSourcePath>
-      <_Crossgen2InbuildPublishDir>$(CoreCLRArtifactsPath)$(BuildArchitecture)/crossgen2/</_Crossgen2InbuildPublishDir>
-    </PropertyGroup>
-    <Copy SourceFiles="$(_WasmJitSourcePath)"
-          DestinationFolder="$(_Crossgen2InbuildPublishDir)"
-          SkipUnchangedFiles="true" />
-  </Target>
-
-  <!-- Test case source files are embedded as resources so we can compile them with Roslyn at test time.
-       Exclude subdirectory sources from compilation since they are compiled in-memory by R2RTestCaseCompiler. -->
   <ItemGroup>
     <Compile Remove="TestCases/*/**/*.cs" />
     <EmbeddedResource Include="TestCases/**/*.cs" LogicalName="%(RecursiveDir)%(Filename)%(Extension)" />
   </ItemGroup>
 
-  <!-- Pass build-time paths to test runtime via RuntimeHostConfigurationOption -->
+  <Target Name="SetupCopyCrossgen2CompilationAssets"
+          BeforeTargets="AssignTargetPaths"
+          DependsOnTargets="ResolveProjectReferences"
+          Condition="'$(DesignTimeBuild)' != 'true'">
+    <Error Condition="'@(Crossgen2InbuildOutputItems)' == ''"
+           Text="crossgen2_inbuild published no files. This is a build authoring error; the ProjectReference should have built it." />
+    <Error Condition="!Exists('$(LibrariesSharedFrameworkBinArtifactsPath)')"
+           Text="The 'libs' subset must be built for $(TargetOS)-$(TargetArchitecture) before building this project. Missing artifacts: $(LibrariesSharedFrameworkBinArtifactsPath). Configuration: '$(LibrariesConfiguration)'." />
+    <Error Condition="!Exists('$(CoreCLRArtifactsPath)IL/System.Private.CoreLib.dll')"
+           Text="The 'clr.corelib' subset must be built for $(TargetOS)-$(TargetArchitecture) before building this project. Missing artifacts: $(CoreCLRArtifactsPath)IL/System.Private.CoreLib.dll. Configuration: '$(CoreCLRConfiguration)'." />
+
+    <ItemGroup>
+      <_SharedFrameworkAssembly Include="$(LibrariesSharedFrameworkBinArtifactsPath)*.dll" />
+      <_SharedFrameworkAssembly Include="$(CoreCLRArtifactsPath)IL/System.Private.CoreLib.dll" />
+    </ItemGroup>
+
+    <ItemGroup>
+      <!-- Filename Metadata may differ from the filename of OutputPath. We want to copy the file using the actual filename of the output path. -->
+      <Content Include="@(Crossgen2InbuildOutputItems->'%(OutputPath)')"
+               CopyToOutputDirectory="PreserveNewest"
+               TargetPath="crossgen2/$([System.IO.Path]::GetFileName('%(Crossgen2InbuildOutputItems.OutputPath)'))" />
+
+      <Content Include="@(_SharedFrameworkAssembly)"
+               CopyToOutputDirectory="PreserveNewest"
+               TargetPath="libraries/%(Filename)%(Extension)" />
+    </ItemGroup>
+  </Target>
+
   <ItemGroup>
-    <RuntimeHostConfigurationOption Include="R2RTest.Crossgen2Dir">
-      <Value>$(CoreCLRArtifactsPath)/$(BuildArchitecture)/crossgen2</Value>
-    </RuntimeHostConfigurationOption>
-    <RuntimeHostConfigurationOption Include="R2RTest.RuntimePackDir">
-      <Value>$(MicrosoftNetCoreAppRuntimePackRidLibTfmDir)</Value>
-    </RuntimeHostConfigurationOption>
-    <RuntimeHostConfigurationOption Include="R2RTest.RuntimePackNativeDir">
-      <Value>$(MicrosoftNetCoreAppRuntimePackNativeDir)</Value>
-    </RuntimeHostConfigurationOption>
-    <RuntimeHostConfigurationOption Include="R2RTest.RefPackDir">
-      <Value>$(MicrosoftNetCoreAppRefPackRefDir)</Value>
-    </RuntimeHostConfigurationOption>
-    <RuntimeHostConfigurationOption Include="R2RTest.CoreCLRArtifactsDir">
-      <Value>$(CoreCLRArtifactsPath)</Value>
-    </RuntimeHostConfigurationOption>
-    <RuntimeHostConfigurationOption Include="R2RTest.TargetArchitecture">
-      <Value>$(TargetArchitecture)</Value>
-    </RuntimeHostConfigurationOption>
-    <RuntimeHostConfigurationOption Include="R2RTest.TargetOS">
-      <Value>$(TargetOS)</Value>
-    </RuntimeHostConfigurationOption>
-    <RuntimeHostConfigurationOption Include="R2RTest.CoreCLRConfiguration">
-      <Value>$(CoreCLRConfiguration)</Value>
-    </RuntimeHostConfigurationOption>
+    <RuntimeHostConfigurationOption Include="R2RTest.CoreCLRConfiguration" Value="$(CoreCLRConfiguration)" />
+    <RuntimeHostConfigurationOption Include="R2RTest.TargetOS" Value="$(TargetOS)" />
+    <RuntimeHostConfigurationOption Include="R2RTest.TargetArchitecture" Value="$(TargetArchitecture)" />
   </ItemGroup>
 
 </Project>
diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun.Tests/TestCases/R2RTestSuites.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun.Tests/TestCases/R2RTestSuites.cs
index 9bde75896d70a5..fc25e2a448c02a 100644
--- a/src/coreclr/tools/aot/ILCompiler.ReadyToRun.Tests/TestCases/R2RTestSuites.cs
+++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun.Tests/TestCases/R2RTestSuites.cs
@@ -29,7 +29,7 @@ public R2RTestSuites(ITestOutputHelper output)
         _output = output;
     }
 
-    [Fact]
+    [ConditionalFact(typeof(TestPaths), nameof(TestPaths.IsNotWasmTarget))]
     public void BasicCrossModuleInlining()
     {
         var inlineableLib = new CompiledAssembly
@@ -62,7 +62,7 @@ static void Validate(ReadyToRunReader reader)
         }
     }
 
-    [Fact]
+    [ConditionalFact(typeof(TestPaths), nameof(TestPaths.IsWasmTarget))]
     public void WasmWebcilModule()
     {
         var wasmWebcilModule = new CompiledAssembly
@@ -77,13 +77,6 @@ public void WasmWebcilModule()
                 new(nameof(WasmWebcilModule), [new CrossgenAssembly(wasmWebcilModule)])
                 {
                     OutputFileExtension = ".wasm",
-                    AdditionalArgs =
-                    {
-                        "--targetarch",
-                        "wasm",
-                        "--targetos",
-                        "browser",
-                    },
                     Validate = Validate,
                 },
             ]));
@@ -128,7 +121,7 @@ static void Validate(ReadyToRunReader reader)
         }
     }
 
-    [Fact]
+    [ConditionalFact(typeof(TestPaths), nameof(TestPaths.IsWasmTarget))]
     public void WasmSimdModule()
     {
         var wasmSimdModule = new CompiledAssembly
@@ -143,13 +136,6 @@ public void WasmSimdModule()
                 new(nameof(WasmSimdModule), [new CrossgenAssembly(wasmSimdModule)])
                 {
                     OutputFileExtension = ".wasm",
-                    AdditionalArgs =
-                    {
-                        "--targetarch",
-                        "wasm",
-                        "--targetos",
-                        "browser",
-                    },
                     Validate = Validate,
                 },
             ]));
@@ -209,7 +195,7 @@ static WebcilImageReader.WasmFunctionInfo ResolveWasmBody(
         }
     }
 
-    [Fact]
+    [ConditionalFact(typeof(TestPaths), nameof(TestPaths.IsNotWasmTarget))]
     public void RuntimeFunctionsSectionSizeExcludesSentinel()
     {
         var lib = new CompiledAssembly
@@ -242,7 +228,7 @@ static void Validate(ReadyToRunReader reader)
         }
     }
 
-    [Fact]
+    [ConditionalFact(typeof(TestPaths), nameof(TestPaths.IsArmTarget))]
     public void ArmThumbBitRelocationTargets()
     {
         var inlineableLib = new CompiledAssembly
@@ -266,7 +252,6 @@ public void ArmThumbBitRelocationTargets()
                     new CrossgenAssembly(inlineableLib) { Kind = Crossgen2InputKind.Reference },
                 ])
                 {
-                    Options = [Crossgen2Option.TargetArchArm],
                     Validate = Validate,
                 },
             ]));
@@ -279,7 +264,7 @@ static void Validate(ReadyToRunReader reader)
     }
 
     // JitStressProcedureSplitting is only available in Debug/Checked JIT builds.
-    [ConditionalFact(typeof(TestPaths), nameof(TestPaths.IsNotReleaseCoreCLR))]
+    [ConditionalFact(typeof(TestPaths), nameof(TestPaths.IsNotReleaseCoreCLR), nameof(TestPaths.IsArmTarget))]
     public void ArmThumbBitHotColdRuntimeFunctions()
     {
         var hotColdSplitting = new CompiledAssembly
@@ -295,7 +280,6 @@ public void ArmThumbBitHotColdRuntimeFunctions()
                 {
                     Options =
                     [
-                        Crossgen2Option.TargetArchArm,
                         Crossgen2Option.Optimize,
                         Crossgen2Option.HotColdSplitting,
                     ],
@@ -315,7 +299,7 @@ static void Validate(ReadyToRunReader reader)
         }
     }
 
-    [Fact]
+    [ConditionalFact(typeof(TestPaths), nameof(TestPaths.IsNotWasmTarget))]
     public void TransitiveReferences()
     {
         var externalLib = new CompiledAssembly()
@@ -358,7 +342,7 @@ public void TransitiveReferences()
             ]));
     }
 
-    [Fact]
+    [ConditionalFact(typeof(TestPaths), nameof(TestPaths.IsNotWasmTarget))]
     public void AsyncCrossModuleInlining()
     {
         var asyncInlineableLib = new CompiledAssembly
@@ -398,7 +382,7 @@ static void Validate(ReadyToRunReader reader)
         }
     }
 
-    [Fact]
+    [ConditionalFact(typeof(TestPaths), nameof(TestPaths.IsNotWasmTarget))]
     public void CompositeBasic()
     {
         var compositeLib = new CompiledAssembly
@@ -434,7 +418,7 @@ static void Validate(ReadyToRunReader reader)
         }
     }
 
-    [Fact]
+    [ConditionalFact(typeof(TestPaths), nameof(TestPaths.IsNotWasmTarget))]
     public void CompositeManifestAssemblyMvidsAreAligned()
     {
         var compositeLib = new CompiledAssembly
@@ -470,9 +454,11 @@ static void Validate(ReadyToRunReader reader)
         }
     }
 
-    public static bool IsWindows => System.OperatingSystem.IsWindows();
-
-    [ConditionalFact(nameof(IsWindows))]
+    /// <summary>
+    /// Requires a Windows host for <c>--pdb</c> (see <see cref="TestPaths.IsWindowsHost"/>), and a
+    /// Windows target because the padding being verified is in the composite PE image.
+    /// </summary>
+    [ConditionalFact(typeof(TestPaths), nameof(TestPaths.IsWindowsHost), nameof(TestPaths.IsWindowsTarget))]
     public void CompositeManifestAssemblyMvidsArePaddedWhenPdbPresent()
     {
         var compositeLib = new CompiledAssembly
@@ -522,7 +508,7 @@ static void Validate(ReadyToRunReader reader)
     /// boundary. When they landed on an unaligned RVA the runtime faulted on ARM32 (which does not
     /// permit unaligned multi-word loads) during coreclr_initialize; x64/arm64 tolerated it.
     /// </summary>
-    [Fact]
+    [ConditionalFact(typeof(TestPaths), nameof(TestPaths.IsNotWasmTarget))]
     public void CompositeManifestSectionsAreAligned()
     {
         var compositeLib = new CompiledAssembly
@@ -561,10 +547,11 @@ static void Validate(ReadyToRunReader reader)
     /// <summary>
     /// Complements <see cref="CompositeManifestSectionsAreAligned"/> using the same trigger as the
     /// MVID-table test: --pdb emits an odd-sized debug directory section that shifts the manifest
-    /// sections off a 4-byte boundary without the fix. Windows-only because it relies on Windows PDB
-    /// generation.
+    /// sections off a 4-byte boundary without the fix. Requires a Windows host for <c>--pdb</c>
+    /// (see <see cref="TestPaths.IsWindowsHost"/>), and a Windows target because the padding being
+    /// verified is in the composite PE image.
     /// </summary>
-    [ConditionalFact(nameof(IsWindows))]
+    [ConditionalFact(typeof(TestPaths), nameof(TestPaths.IsWindowsHost), nameof(TestPaths.IsWindowsTarget))]
     public void CompositeManifestSectionsArePaddedWhenPdbPresent()
     {
         var compositeLib = new CompiledAssembly
@@ -601,7 +588,7 @@ static void Validate(ReadyToRunReader reader)
         }
     }
 
-    [Fact]
+    [ConditionalFact(typeof(TestPaths), nameof(TestPaths.IsNotWasmTarget))]
     public void RuntimeAsyncMethodEmission()
     {
         var runtimeAsyncMethodEmission = new CompiledAssembly
@@ -639,7 +626,7 @@ static void Validate(ReadyToRunReader reader)
     /// It must also strip a non-async Task-returning method whose async variant has already been
     /// compiled, since the IL is no longer needed at runtime.
     /// </summary>
-    [Fact]
+    [ConditionalFact(typeof(TestPaths), nameof(TestPaths.IsNotWasmTarget))]
     public void RuntimeAsyncStripILBodiesPreservesTaskReturningIL()
     {
         var stripILBodies = new CompiledAssembly
@@ -659,7 +646,6 @@ public void RuntimeAsyncStripILBodiesPreservesTaskReturningIL()
                 new(nameof(RuntimeAsyncStripILBodiesPreservesTaskReturningIL), [new CrossgenAssembly(stripILBodies)])
                 {
                     Options = [Crossgen2Option.Composite, Crossgen2Option.Optimize, Crossgen2Option.StripILBodies],
-                    AdditionalArgs = ["--targetarch:x64"],
                     Validate = Validate,
                 },
             ]));
@@ -695,7 +681,7 @@ static void Validate(ReadyToRunReader reader)
         }
     }
 
-    [Fact]
+    [ConditionalFact(typeof(TestPaths), nameof(TestPaths.IsIosArm64Target))]
     public void AppleMobileStripILBodiesUsesFixedInstructionSet()
     {
         var stripILBodies = new CompiledAssembly
@@ -715,7 +701,6 @@ public void AppleMobileStripILBodiesUsesFixedInstructionSet()
                 new(nameof(AppleMobileStripILBodiesUsesFixedInstructionSet), [new CrossgenAssembly(stripILBodies)])
                 {
                     Options = [Crossgen2Option.Composite, Crossgen2Option.Optimize, Crossgen2Option.StripILBodies],
-                    AdditionalArgs = ["--targetos:ios", "--targetarch:arm64"],
                     Validate = Validate,
                 },
             ]));
@@ -744,7 +729,7 @@ static void Validate(ReadyToRunReader reader)
     /// produce ContinuationLayout fixups encoding the GC ref map.
     /// PR #124203: Resumption stubs for methods with suspension points.
     /// </summary>
-    [Fact]
+    [ConditionalFact(typeof(TestPaths), nameof(TestPaths.IsNotWasmTarget))]
     public void RuntimeAsyncContinuationLayout()
     {
         var runtimeAsyncContinuationLayout = new CompiledAssembly
@@ -783,7 +768,7 @@ static void Validate(ReadyToRunReader reader)
     /// PR #125420: [ASYNC] variant generation for devirtualizable async call patterns
     /// (sealed class and interface dispatch through AsyncAwareVirtualMethodResolutionAlgorithm).
     /// </summary>
-    [Fact]
+    [ConditionalFact(typeof(TestPaths), nameof(TestPaths.IsNotWasmTarget))]
     public void RuntimeAsyncDevirtualize()
     {
         var runtimeAsyncDevirtualize = new CompiledAssembly
@@ -818,7 +803,7 @@ static void Validate(ReadyToRunReader reader)
     /// PR #124203: Async methods without yield points may omit resumption stubs.
     /// Validates that no-yield async methods still produce [ASYNC] variants.
     /// </summary>
-    [Fact]
+    [ConditionalFact(typeof(TestPaths), nameof(TestPaths.IsNotWasmTarget))]
     public void RuntimeAsyncNoYield()
     {
         var runtimeAsyncNoYield = new CompiledAssembly
@@ -855,7 +840,7 @@ static void Validate(ReadyToRunReader reader)
     /// --determinism-stress), each compiled method should have exactly one
     /// ResumptionStubEntryPoint fixup.
     /// </summary>
-    [Fact]
+    [ConditionalFact(typeof(TestPaths), nameof(TestPaths.IsNotWasmTarget))]
     public void RuntimeAsyncResumptionStubFixupDedup()
     {
         var asm = new CompiledAssembly
@@ -898,7 +883,7 @@ static void Validate(ReadyToRunReader reader)
     /// PR #121679: MutableModule async references + cross-module inlining
     /// of runtime-async methods with cross-module dependency.
     /// </summary>
-    [Fact]
+    [ConditionalFact(typeof(TestPaths), nameof(TestPaths.IsNotWasmTarget))]
     public void RuntimeAsyncCrossModule()
     {
         var asyncDepLib = new CompiledAssembly
@@ -957,7 +942,7 @@ static void Validate(ReadyToRunReader reader)
     /// Validates that inlining info (CrossModuleInlineInfo or InliningInfo2) is
     /// properly populated (CompositeBasic only validates ManifestRef).
     /// </summary>
-    [Fact]
+    [ConditionalFact(typeof(TestPaths), nameof(TestPaths.IsNotWasmTarget))]
     public void CompositeCrossModuleInlining()
     {
         var inlineableLib = new CompiledAssembly
@@ -999,7 +984,7 @@ static void Validate(ReadyToRunReader reader)
     /// assemblies does NOT produce a CrossModuleInlineInfo section. CrossModuleInlineInfo only records
     /// inlining where the inlinee module is outside the compiled image's version bubble
     /// </summary>
-    [Fact]
+    [ConditionalFact(typeof(TestPaths), nameof(TestPaths.IsNotWasmTarget))]
     public void CompositeDoesNotProduceCrossModuleInliningInfo()
     {
         var inlineableLib = new CompiledAssembly
@@ -1046,7 +1031,7 @@ static void Validate(ReadyToRunReader reader)
     /// comes from an assembly outside the version bubble (passed as a Reference with
     /// --opt-cross-module).
     /// </summary>
-    [Fact]
+    [ConditionalFact(typeof(TestPaths), nameof(TestPaths.IsNotWasmTarget))]
     public void CompositeProducesCrossModuleInliningInfoForExternalReference()
     {
         var inlineableLib = new CompiledAssembly
@@ -1098,7 +1083,7 @@ static void Validate(ReadyToRunReader reader)
     /// Composite mode with runtime-async methods in both assemblies.
     /// Validates async variants exist in composite output.
     /// </summary>
-    [Fact]
+    [ConditionalFact(typeof(TestPaths), nameof(TestPaths.IsNotWasmTarget))]
     public void CompositeAsync()
     {
         var asyncCompositeLib = new CompiledAssembly
@@ -1143,7 +1128,7 @@ static void Validate(ReadyToRunReader reader)
     /// Verifies that, in composite mode, awaitless async candidates ARE inlined into
     /// their callers.
     /// </summary>
-    [Fact]
+    [ConditionalFact(typeof(TestPaths), nameof(TestPaths.IsNotWasmTarget))]
     public void CompositeAsyncInliningMatrix()
     {
         var asyncInlineCandidatesLib = new CompiledAssembly
@@ -1193,7 +1178,7 @@ static void Validate(ReadyToRunReader reader)
     /// https://github.com/dotnet/runtime/pull/126904 added support for ensuring the OwningType signature modifier is emitted
     /// for these methods.
     /// </summary>
-    [Fact]
+    [ConditionalFact(typeof(TestPaths), nameof(TestPaths.IsNotWasmTarget))]
     public void CompositeAsyncGenericTypes()
     {
         var asyncGenericTypeLib = new CompiledAssembly
@@ -1258,7 +1243,7 @@ static void Validate(ReadyToRunReader reader)
     /// captures GC refs across await points. Validates that ContinuationLayout
     /// fixups correctly reference cross-module types via MutableModule tokens.
     /// </summary>
-    [Fact]
+    [ConditionalFact(typeof(TestPaths), nameof(TestPaths.IsNotWasmTarget))]
     public void AsyncCrossModuleContinuation()
     {
         var asyncDepLibCont = new CompiledAssembly
@@ -1313,7 +1298,7 @@ static void Validate(ReadyToRunReader reader)
     /// Two-step compilation: composite A+B, then non-composite C referencing A.
     /// Exercises the multi-compilation model.
     /// </summary>
-    [Fact]
+    [ConditionalFact(typeof(TestPaths), nameof(TestPaths.IsNotWasmTarget))]
     public void MultiStepCompositeAndNonComposite()
     {
         var libA = new CompiledAssembly
@@ -1378,7 +1363,7 @@ public void MultiStepCompositeAndNonComposite()
     /// Composite + runtime-async + cross-module devirtualization.
     /// Interface defined in AsyncInterfaceLib, call sites in CompositeAsyncDevirtMain.
     /// </summary>
-    [Fact]
+    [ConditionalFact(typeof(TestPaths), nameof(TestPaths.IsNotWasmTarget))]
     public void CompositeAsyncDevirtualize()
     {
         var asyncInterfaceLib = new CompiledAssembly
@@ -1426,7 +1411,7 @@ static void Validate(ReadyToRunReader reader)
     /// devirtualizes to a sealed receiver. Resolving the callee's async-variant thunk must unwrap it
     /// to the underlying EcmaMethod.
     /// </summary>
-    [Fact]
+    [ConditionalFact(typeof(TestPaths), nameof(TestPaths.IsNotWasmTarget))]
     public void CompositeAsyncDevirtNonAsyncCallee()
     {
         // Compiled WITHOUT runtime-async so the awaited virtuals get synthesized async-variant thunks.
@@ -1473,7 +1458,7 @@ static void Validate(ReadyToRunReader reader)
     /// Composite with 3 assemblies in A→B→C transitive chain.
     /// Validates manifest refs for all three and transitive inlining.
     /// </summary>
-    [Fact]
+    [ConditionalFact(typeof(TestPaths), nameof(TestPaths.IsNotWasmTarget))]
     public void CompositeTransitive()
     {
         var externalLib = new CompiledAssembly
@@ -1521,7 +1506,7 @@ static void Validate(ReadyToRunReader reader)
     /// Non-composite runtime-async + transitive cross-module inlining.
     /// Chain: AsyncTransitiveMain → AsyncTransitiveLib → AsyncExternalLib.
     /// </summary>
-    [Fact]
+    [ConditionalFact(typeof(TestPaths), nameof(TestPaths.IsNotWasmTarget))]
     public void AsyncCrossModuleTransitive()
     {
         var asyncExternalLib = new CompiledAssembly
@@ -1582,7 +1567,7 @@ static void Validate(ReadyToRunReader reader)
     /// Composite + runtime-async + transitive (3 assemblies).
     /// Full combination of composite, async, and transitive references.
     /// </summary>
-    [Fact]
+    [ConditionalFact(typeof(TestPaths), nameof(TestPaths.IsNotWasmTarget))]
     public void CompositeAsyncTransitive()
     {
         var asyncExternalLib = new CompiledAssembly
@@ -1641,7 +1626,7 @@ static void Validate(ReadyToRunReader reader)
     /// Step 1: Composite of async libs. Step 2: Non-composite consumer
     /// with cross-module inlining of async methods.
     /// </summary>
-    [Fact]
+    [ConditionalFact(typeof(TestPaths), nameof(TestPaths.IsNotWasmTarget))]
     public void MultiStepCompositeAndNonCompositeAsync()
     {
         var asyncDepLib = new CompiledAssembly
@@ -1712,7 +1697,7 @@ public void MultiStepCompositeAndNonCompositeAsync()
     /// CrossModuleInlineInfo section, exercising the absolute-index encoding
     /// (not delta-encoded) for cross-module inliner entries.
     /// </summary>
-    [Fact]
+    [ConditionalFact(typeof(TestPaths), nameof(TestPaths.IsNotWasmTarget))]
     public void CrossModuleGenericMultiInliner()
     {
         var crossModuleGenericLib = new CompiledAssembly
@@ -1758,7 +1743,7 @@ static void Validate(ReadyToRunReader reader)
         }
     }
 
-    [Fact]
+    [ConditionalFact(typeof(TestPaths), nameof(TestPaths.IsNotWasmTarget))]
     public void VirtualMethodGenericsNonGVM()
     {
         var nonGvmLib = new CompiledAssembly
@@ -1803,7 +1788,7 @@ static void Validate(ReadyToRunReader reader)
         }
     }
 
-    [Fact]
+    [ConditionalFact(typeof(TestPaths), nameof(TestPaths.IsNotWasmTarget))]
     public void VirtualMethodGenericsGVM()
     {
         var gvmLib = new CompiledAssembly
@@ -1848,7 +1833,7 @@ static void Validate(ReadyToRunReader reader)
         }
     }
 
-    [Fact]
+    [ConditionalFact(typeof(TestPaths), nameof(TestPaths.IsNotWasmTarget))]
     public void VirtualMethodGenericsGenericLookup()
     {
         var genericLookupLib = new CompiledAssembly
diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun.Tests/TestCasesRunner/R2RDriver.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun.Tests/TestCasesRunner/R2RDriver.cs
index c1da793302ad01..059f522b6d0f34 100644
--- a/src/coreclr/tools/aot/ILCompiler.ReadyToRun.Tests/TestCasesRunner/R2RDriver.cs
+++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun.Tests/TestCasesRunner/R2RDriver.cs
@@ -32,7 +32,6 @@ internal enum Crossgen2Option
     InputBubble,
     HotColdSplitting,
     Optimize,
-    TargetArchArm,
     StripILBodies,
 }
 
@@ -59,7 +58,6 @@ internal static class Crossgen2OptionsExtensions
         Crossgen2Option.InputBubble => $"--input-bubble",
         Crossgen2Option.HotColdSplitting => $"--hot-cold-splitting",
         Crossgen2Option.Optimize => $"--optimize",
-        Crossgen2Option.TargetArchArm => $"--targetarch:arm",
         Crossgen2Option.StripILBodies => $"--strip-il-bodies",
         _ => throw new ArgumentOutOfRangeException(nameof(kind)),
     };
@@ -83,29 +81,23 @@ internal sealed class R2RDriver
 {
     private static readonly TimeSpan ProcessTimeout = TimeSpan.FromMinutes(2);
     private readonly ITestOutputHelper _output;
-    private readonly TestPaths _paths;
 
-    public R2RDriver(ITestOutputHelper output, TestPaths paths)
+    public R2RDriver(ITestOutputHelper output)
     {
         _output = output;
-        _paths = paths;
-
-        if (!File.Exists(_paths.Crossgen2Exe))
-            throw new FileNotFoundException($"crossgen2 executable not found at {_paths.Crossgen2Exe}");
     }
 
     /// <summary>
-    /// Runs crossgen2 with the given arguments.
+    /// Runs the crossgen2 that compiles for this build's target RID with the given arguments.
     /// </summary>
     public R2RCompilationResult Compile(List<string> args)
     {
-        var fullArgs = new List<string>(args);
-        return RunCrossgen2(fullArgs);
+        return RunCrossgen2(TestPaths.Crossgen2Exe, new List<string>(args));
     }
 
-    private R2RCompilationResult RunCrossgen2(List<string> crossgen2Args)
+    private R2RCompilationResult RunCrossgen2(string crossgen2Exe, List<string> crossgen2Args)
     {
-        var psi = new ProcessStartInfo(_paths.Crossgen2Exe, crossgen2Args)
+        var psi = new ProcessStartInfo(crossgen2Exe, crossgen2Args)
         {
             RedirectStandardOutput = true,
             RedirectStandardError = true,
@@ -119,7 +111,7 @@ private R2RCompilationResult RunCrossgen2(List<string> crossgen2Args)
             psi.Environment[envVar] = null;
         }
 
-        string commandLine = $"{_paths.Crossgen2Exe} {string.Join(" ", crossgen2Args)}";
+        string commandLine = $"{crossgen2Exe} {string.Join(" ", crossgen2Args)}";
         _output.WriteLine($"  crossgen2 command: {commandLine}");
 
         using var process = Process.Start(psi)!;
diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun.Tests/TestCasesRunner/R2RResultChecker.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun.Tests/TestCasesRunner/R2RResultChecker.cs
index 68fd1d518bd545..522472920c4f1d 100644
--- a/src/coreclr/tools/aot/ILCompiler.ReadyToRun.Tests/TestCasesRunner/R2RResultChecker.cs
+++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun.Tests/TestCasesRunner/R2RResultChecker.cs
@@ -1186,11 +1186,15 @@ public static bool MethodILIsPresent(string msilFilePath, string declaringType,
 /// </summary>
 internal sealed class SimpleAssemblyResolver : IAssemblyResolver
 {
-    private readonly TestPaths _paths;
+    private readonly Dictionary<string, string> _assemblyPaths;
 
-    public SimpleAssemblyResolver(TestPaths paths)
+    public SimpleAssemblyResolver(IEnumerable<string> referencePaths)
     {
-        _paths = paths;
+        _assemblyPaths = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+        foreach (string referencePath in referencePaths)
+        {
+            _assemblyPaths[Path.GetFileNameWithoutExtension(referencePath)] = referencePath;
+        }
     }
 
     public IAssemblyMetadata? FindAssembly(MetadataReader metadataReader, AssemblyReferenceHandle assemblyReferenceHandle, string parentFile)
@@ -1209,10 +1213,12 @@ public SimpleAssemblyResolver(TestPaths paths)
 
         string candidate = Path.Combine(dir, simpleName + ".dll");
         if (!File.Exists(candidate))
-            candidate = Path.Combine(_paths.RuntimePackDir, simpleName + ".dll");
+        {
+            if (!_assemblyPaths.TryGetValue(simpleName, out string? referencePath) || referencePath is null)
+                return null;
 
-        if (!File.Exists(candidate))
-            return null;
+            candidate = referencePath;
+        }
 
         return new SimpleAssemblyMetadata(candidate);
     }
diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun.Tests/TestCasesRunner/R2RTestCaseCompiler.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun.Tests/TestCasesRunner/R2RTestCaseCompiler.cs
index 7bd12c8887fe59..476ac89c09ce6e 100644
--- a/src/coreclr/tools/aot/ILCompiler.ReadyToRun.Tests/TestCasesRunner/R2RTestCaseCompiler.cs
+++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun.Tests/TestCasesRunner/R2RTestCaseCompiler.cs
@@ -19,26 +19,13 @@ internal sealed class R2RTestCaseCompiler
 {
     private readonly List<MetadataReference> _frameworkReferences;
 
-    public R2RTestCaseCompiler(TestPaths paths)
+    public R2RTestCaseCompiler(List<string> references)
     {
         _frameworkReferences = new List<MetadataReference>();
 
-        // Add reference assemblies from the ref pack (needed for Roslyn compilation)
-        string refPackDir = paths.RefPackDir;
-        if (Directory.Exists(refPackDir))
+        foreach (string refPath in references)
         {
-            foreach (string refPath in Directory.EnumerateFiles(refPackDir, "*.dll"))
-            {
-                _frameworkReferences.Add(MetadataReference.CreateFromFile(refPath));
-            }
-        }
-        else
-        {
-            // Fallback to runtime pack implementation assemblies
-            foreach (string refPath in paths.GetFrameworkReferencePaths())
-            {
-                _frameworkReferences.Add(MetadataReference.CreateFromFile(refPath));
-            }
+            _frameworkReferences.Add(MetadataReference.CreateFromFile(refPath));
         }
     }
 
diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun.Tests/TestCasesRunner/R2RTestRunner.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun.Tests/TestCasesRunner/R2RTestRunner.cs
index f466fd20d336e7..4fdb38bc20efbf 100644
--- a/src/coreclr/tools/aot/ILCompiler.ReadyToRun.Tests/TestCasesRunner/R2RTestRunner.cs
+++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun.Tests/TestCasesRunner/R2RTestRunner.cs
@@ -180,12 +180,10 @@ public void SetOutputDir(string outputDir)
 internal sealed class R2RTestRunner
 {
     private readonly ITestOutputHelper _output;
-    private readonly TestPaths _paths;
 
     public R2RTestRunner(ITestOutputHelper output)
     {
         _output = output;
-        _paths = new TestPaths(output);
     }
 
     /// <summary>
@@ -208,19 +206,19 @@ public void Run(R2RTestCase testCase)
             var assemblyPaths = CompileAllAssemblies(assembliesToCompile);
 
             // Step 2: Run each crossgen2 compilation and validate
-            var driver = new R2RDriver(_output, _paths);
-            var refPaths = BuildReferencePaths();
+            var driver = new R2RDriver(_output);
+            List<string> refPaths = BuildReferencePaths();
 
             foreach(var compilation in testCase.Compilations)
             {
                 string outputPath = RunCrossgenCompilation(
-                    testCase.Name, compilation, driver, compilation.FilePath, refPaths, assemblyPaths);
+                    testCase.Name, compilation, driver, compilation.FilePath, assemblyPaths);
 
                 if (compilation.Validate is not null)
                 {
                     Assert.True(File.Exists(outputPath), $"R2R image not found: {outputPath}");
                     _output.WriteLine($"  Validating R2R image: {outputPath}");
-                    var reader = new ReadyToRunReader(new SimpleAssemblyResolver(_paths), outputPath);
+                    var reader = new ReadyToRunReader(new SimpleAssemblyResolver(refPaths), outputPath);
                     compilation.Validate(reader);
                 }
             }
@@ -238,9 +236,10 @@ public void Run(R2RTestCase testCase)
     private Dictionary<string, string> CompileAllAssemblies(
         IEnumerable<CompiledAssembly> assemblies)
     {
-        var compiler = new R2RTestCaseCompiler(_paths);
         var paths = new Dictionary<string, string>();
 
+        var defaultReferences = BuildReferencePaths();
+        var compiler = new R2RTestCaseCompiler(defaultReferences);
         foreach (var asm in assemblies)
         {
             var sources = asm.SourceResourceNames
@@ -256,7 +255,7 @@ private Dictionary<string, string> CompileAllAssemblies(
                 additionalReferences: asm.References.Select(r => r.FilePath).ToList(),
                 features: asm.Features.Count > 0 ? asm.Features : null);
             paths[asm.AssemblyName] = ilPath;
-            _output.WriteLine($"  Roslyn compiled '{asm.AssemblyName}' -> {ilPath}");
+            _output.WriteLine($"Roslyn compiled '{asm.AssemblyName}' -> {ilPath}");
         }
 
         return paths;
@@ -275,7 +274,6 @@ private static string RunCrossgenCompilation(
         CrossgenCompilation compilation,
         R2RDriver driver,
         string outputFile,
-        List<string> refPaths,
         Dictionary<string, string> assemblyPaths)
     {
         var args = new List<string>();
@@ -311,11 +309,13 @@ private static string RunCrossgenCompilation(
         foreach (var option in compilation.Options)
             args.Add(option.ToArg());
 
+        args.AddRange(["--targetos", TestPaths.TargetOS, "--targetarch", TestPaths.TargetArchitecture]);
+
         // Caller-supplied raw args (for options that take values, e.g. --determinism-stress=N)
         args.AddRange(compilation.AdditionalArgs);
 
-        // Global refs (runtime pack + System.Private.CoreLib)
-        AddRefArgs(args, refPaths);
+        // Global refs (shared framework + System.Private.CoreLib)
+        AddRefArgs(args);
 
         EnsureDirectoryExists(Path.GetDirectoryName(outputFile));
 
@@ -330,27 +330,28 @@ private static string RunCrossgenCompilation(
         return outputFile;
     }
 
-    private static void AddRefArgs(List<string> args, List<string> refPaths)
+    /// <summary>
+    /// Adds the shared framework references for crossgen2 as a single directory wildcard.
+    /// </summary>
+    private static void AddRefArgs(List<string> args)
     {
-        foreach (string refPath in refPaths)
-        {
-            args.Add("-r");
-            args.Add(refPath);
-        }
+        args.Add("-r");
+        args.Add(Path.Combine(TestPaths.LibrariesDir, "*.dll"));
     }
 
-    private List<string> BuildReferencePaths()
+    /// <summary>
+    /// Builds the explicit reference paths used for Roslyn compilation and for resolving assemblies
+    /// when reading back an R2R image, from the shared framework IL assemblies staged for this
+    /// build's target RID. crossgen2 takes the same assemblies as a wildcard; see <see cref="AddRefArgs"/>.
+    /// </summary>
+    private static List<string> BuildReferencePaths()
     {
-        var paths = new List<string>();
-
-        paths.Add(Path.Combine(_paths.RuntimePackDir, "*.dll"));
+        string librariesDir = TestPaths.LibrariesDir;
 
-        string spcl = _paths.SystemPrivateCoreLibPath;
-        Assert.True(File.Exists(spcl),
-            $"System.Private.CoreLib.dll not found at '{spcl}'. " +
-            $"Searched RuntimePackNativeDir='{_paths.RuntimePackNativeDir}' and " +
-            $"CoreCLRArtifactsDir='{_paths.CoreCLRArtifactsDir}'");
-        paths.Add(spcl);
+        List<string> paths = [.. Directory.GetFiles(librariesDir, "*.dll")];
+        Assert.True(
+            paths.Exists(p => Path.GetFileName(p) == "System.Private.CoreLib.dll"),
+            $"System.Private.CoreLib.dll not found in staged references: {librariesDir}");
 
         return paths;
     }
diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun.Tests/TestCasesRunner/TestPaths.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun.Tests/TestCasesRunner/TestPaths.cs
index f028b442cf8e86..8df61102255e4f 100644
--- a/src/coreclr/tools/aot/ILCompiler.ReadyToRun.Tests/TestCasesRunner/TestPaths.cs
+++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun.Tests/TestCasesRunner/TestPaths.cs
@@ -2,225 +2,83 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
-using System.Collections.Generic;
 using System.IO;
 using System.Runtime.InteropServices;
-using System.Text.RegularExpressions;
-using Xunit.Abstractions;
 
 namespace ILCompiler.ReadyToRun.Tests.TestCasesRunner;
 
 /// <summary>
-/// Provides paths to build artifacts needed by the test infrastructure.
-/// All paths come from RuntimeHostConfigurationOption items in the csproj.
+/// Provides paths to build artifacts needed by the test infrastructure, and the target and host
+/// predicates that gate test cases.
 /// </summary>
-internal sealed class TestPaths
+internal static class TestPaths
 {
-    private readonly ITestOutputHelper _output;
-
-    public TestPaths(ITestOutputHelper output)
-    {
-        _output = output;
-    }
-
     private static string GetRequiredConfig(string key)
     {
         return AppContext.GetData(key) as string
             ?? throw new InvalidOperationException($"Missing RuntimeHostConfigurationOption '{key}'. Was the project built with the correct properties?");
     }
 
-    /// <summary>
-    /// Tries to find an existing directory by swapping the build configuration path segment
-    /// (Debug, Release, Checked) in the path. Returns the first match, or the original
-    /// path if no fallback exists.
-    /// </summary>
-    private string ProbeConfigFallback(string dir)
-    {
-        if (Directory.Exists(dir))
-            return dir;
+    private static string Crossgen2ExeName => RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? "crossgen2.exe" : "crossgen2";
 
-        foreach (string fallbackConfig in new[] { "Release", "Checked", "Debug" })
-        {
-            string fallback = Regex.Replace(
-                dir, @"(?<=[/\\])(Debug|Release|Checked)(?=[/\\])", fallbackConfig);
-            if (fallback != dir && Directory.Exists(fallback))
-            {
-                _output.WriteLine($"[TestPaths] '{dir}' not found; falling back to '{fallback}'");
-                return fallback;
-            }
-        }
+    public static string SystemPrivateCoreLibPath => Path.Combine(LibrariesDir, "System.Private.CoreLib.dll");
 
-        return dir;
-    }
+    public static string TargetOS => GetRequiredConfig("R2RTest.TargetOS");
+    public static string TargetArchitecture => GetRequiredConfig("R2RTest.TargetArchitecture");
 
-    /// <summary>
-    /// Like <see cref="ProbeConfigFallback"/> but for paths where the configuration name
-    /// is embedded in a dot-delimited segment (e.g. <c>linux.x64.Checked</c>).
-    /// </summary>
-    private string ProbeDottedConfigFallback(string dir)
-    {
-        if (Directory.Exists(dir))
-            return dir;
+    private static string TargetRid => $"{TargetOS}-{TargetArchitecture}";
 
-        foreach (string fallbackConfig in new[] { "Checked", "Release", "Debug" })
-        {
-            string fallback = Regex.Replace(
-                dir, @"\.(Debug|Release|Checked)([/\\])", $".{fallbackConfig}$2");
-            if (fallback != dir && Directory.Exists(fallback))
-            {
-                _output.WriteLine($"[TestPaths] '{dir}' not found; falling back to '{fallback}'");
-                return fallback;
-            }
-        }
+    public static bool IsWasmTarget => TargetArchitecture == "wasm";
 
-        return dir;
-    }
+    public static bool IsNotWasmTarget => !IsWasmTarget;
 
-    /// <summary>
-    /// Path to the crossgen2 output directory (contains the self-contained crossgen2 executable and clrjit).
-    /// e.g. artifacts/bin/coreclr/linux.x64.Checked/x64/crossgen2/
-    /// Falls back to Checked or Release if the configured path doesn't exist.
-    /// </summary>
-    public string Crossgen2Dir
-    {
-        get
-        {
-            string dir = GetRequiredConfig("R2RTest.Crossgen2Dir");
-            if (!File.Exists(Path.Combine(dir, Crossgen2ExeName)))
-            {
-                string fallback = ProbeDottedConfigFallback(dir);
-                if (File.Exists(Path.Combine(fallback, Crossgen2ExeName)))
-                    return fallback;
-            }
+    public static bool IsArmTarget => TargetArchitecture is "arm" or "armel";
 
-            return dir;
-        }
-    }
+    public static bool IsWindowsTarget => TargetOS is "windows" or "win";
 
-    private static string Crossgen2ExeName =>
-        RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? "crossgen2.exe" : "crossgen2";
+    public static bool IsIosArm64Target => TargetOS is "ios" && TargetArchitecture is "arm64";
 
-    /// <summary>
-    /// Path to the self-contained crossgen2 executable (from crossgen2_inbuild).
-    /// </summary>
-    public string Crossgen2Exe => Path.Combine(Crossgen2Dir, Crossgen2ExeName);
+    public static bool IsWindowsHost => OperatingSystem.IsWindows();
 
     /// <summary>
-    /// Path to the runtime pack managed assemblies directory.
-    /// e.g. artifacts/bin/microsoft.netcore.app.runtime.linux-x64/Release/runtimes/linux-x64/lib/net11.0/
-    /// Falls back to a different build configuration if the path doesn't exist.
+    /// Path to the crossgen2 that compiles for this build's target.
     /// </summary>
-    public string RuntimePackDir
+    public static string Crossgen2Exe
     {
         get
         {
-            string dir = GetRequiredConfig("R2RTest.RuntimePackDir");
-            return ProbeConfigFallback(dir);
-        }
-    }
-
-    /// <summary>
-    /// Path to the runtime pack native directory (contains System.Private.CoreLib.dll and native runtime).
-    /// e.g. artifacts/bin/microsoft.netcore.app.runtime.linux-x64/Release/runtimes/linux-x64/native/
-    /// Falls back to a different build configuration if the path doesn't exist.
-    /// </summary>
-    public string RuntimePackNativeDir
-    {
-        get
-        {
-            string dir = GetRequiredConfig("R2RTest.RuntimePackNativeDir");
-            return ProbeConfigFallback(dir);
-        }
-    }
-
-    /// <summary>
-    /// Path to System.Private.CoreLib.dll. It lives in the runtime pack native/ dir in full builds
-    /// (placed by externals.csproj BinPlace during libs.pretest), but partial builds that skip
-    /// libs.pretest only have it in the CoreCLR artifacts directory.
-    /// </summary>
-    public string SystemPrivateCoreLibPath
-    {
-        get
-        {
-            string path = Path.Combine(RuntimePackNativeDir, "System.Private.CoreLib.dll");
-            if (!File.Exists(path))
+            string exe = Path.Combine(AppContext.BaseDirectory, "crossgen2", Crossgen2ExeName);
+            if (!File.Exists(exe))
             {
-                string fallback = Path.Combine(CoreCLRArtifactsDir, "System.Private.CoreLib.dll");
-                if (File.Exists(fallback))
-                {
-                    _output.WriteLine($"[TestPaths] '{path}' not found; falling back to '{fallback}'");
-                    return fallback;
-                }
+                throw new FileNotFoundException(
+                    $"No crossgen2 staged for {TargetRid} at '{exe}'. Build the clr and libs subsets for " +
+                    $"{TargetRid}, then rebuild this test project.");
             }
 
-            return path;
-        }
-    }
-
-    /// <summary>
-    /// Path to the CoreCLR artifacts directory (contains native bits like corerun).
-    /// e.g. artifacts/bin/coreclr/linux.x64.Checked/
-    /// Falls back to Checked or Release if the configured path doesn't exist.
-    /// </summary>
-    public string CoreCLRArtifactsDir
-    {
-        get
-        {
-            string dir = GetRequiredConfig("R2RTest.CoreCLRArtifactsDir");
-            return ProbeDottedConfigFallback(dir);
+            return exe;
         }
     }
 
-    public static string TargetArchitecture => GetRequiredConfig("R2RTest.TargetArchitecture");
-    public static string TargetOS => GetRequiredConfig("R2RTest.TargetOS");
-    public static string CoreCLRConfiguration => GetRequiredConfig("R2RTest.CoreCLRConfiguration");
-    public static bool IsReleaseCoreCLR => string.Equals(CoreCLRConfiguration, "Release", StringComparison.OrdinalIgnoreCase);
-    public static bool IsNotReleaseCoreCLR => !IsReleaseCoreCLR;
-
     /// <summary>
-    /// Path to the reference assembly pack (for Roslyn compilation).
-    /// e.g. artifacts/bin/microsoft.netcore.app.ref/ref/net11.0/
+    /// Directory holding the shared framework IL assemblies crossgen2 compiles against.
     /// </summary>
-    public string RefPackDir
+    public static string LibrariesDir
     {
         get
         {
-            string dir = GetRequiredConfig("R2RTest.RefPackDir");
+            string dir = Path.Combine(AppContext.BaseDirectory, "libraries");
             if (!Directory.Exists(dir))
             {
-                // Try the artifacts/bin/ref/net* fallback
-                string artifactsBin = Path.GetFullPath(Path.Combine(CoreCLRArtifactsDir, "..", ".."));
-                string refDir = Path.Combine(artifactsBin, "ref");
-                if (Directory.Exists(refDir))
-                {
-                    foreach (string subDir in Directory.GetDirectories(refDir, "net*"))
-                    {
-                        if (File.Exists(Path.Combine(subDir, "System.Runtime.dll")))
-                        {
-                            _output.WriteLine($"[TestPaths] '{dir}' not found; falling back to '{subDir}'");
-                            return subDir;
-                        }
-                    }
-                }
+                throw new DirectoryNotFoundException(
+                    $"No shared framework assemblies staged for {TargetRid} at '{dir}'. Build the clr and " +
+                    $"libs subsets for {TargetRid}, then rebuild this test project.");
             }
 
             return dir;
         }
     }
 
-    /// <summary>
-    /// Returns the target triple string for crossgen2 (e.g. "linux-x64").
-    /// </summary>
-    public static string TargetTriple => $"{TargetOS.ToLowerInvariant()}-{TargetArchitecture.ToLowerInvariant()}";
-
-    /// <summary>
-    /// Returns all framework reference assembly paths (*.dll in the runtime pack).
-    /// </summary>
-    public IEnumerable<string> GetFrameworkReferencePaths()
-    {
-        if (!Directory.Exists(RuntimePackDir))
-            throw new DirectoryNotFoundException($"Runtime pack directory not found: {RuntimePackDir}");
-
-        return Directory.EnumerateFiles(RuntimePackDir, "*.dll");
-    }
+    public static string CoreCLRConfiguration => GetRequiredConfig("R2RTest.CoreCLRConfiguration");
+    public static bool IsReleaseCoreCLR => string.Equals(CoreCLRConfiguration, "Release", StringComparison.OrdinalIgnoreCase);
+    public static bool IsNotReleaseCoreCLR => !IsReleaseCoreCLR;
 }
diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun.Tests/WasmArgumentLayoutTests.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun.Tests/WasmArgumentLayoutTests.cs
index 2629202df34758..ec327918b2f1ef 100644
--- a/src/coreclr/tools/aot/ILCompiler.ReadyToRun.Tests/WasmArgumentLayoutTests.cs
+++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun.Tests/WasmArgumentLayoutTests.cs
@@ -26,8 +26,12 @@ namespace ILCompiler.ReadyToRun.Tests;
 
 /// <summary>
 /// Unit tests for the wasm argument layout crossgen2 computes. These drive the compiler's type
-/// system directly, so they need neither a wasm JIT nor a runtime to execute against.
+/// system directly, so they need neither a wasm JIT nor a runtime to execute against. They do
+/// need a wasm System.Private.CoreLib, though: the type system context they build is always a
+/// wasm one, but the corelib it reads comes from whatever the outer build targets, so on any
+/// other target they would be computing wasm layouts from the wrong assembly.
 /// </summary>
+[ConditionalClass(typeof(TestPaths), nameof(TestPaths.IsWasmTarget))]
 public class WasmArgumentLayoutTests
 {
     private const string Vector128OfT = "Vector128`1";
@@ -548,7 +552,7 @@ private static MethodSignature MakeProbeSignature(ReadyToRunCompilerContext cont
     /// </summary>
     private ReadyToRunCompilerContext CreateWasmContext()
     {
-        string coreLibPath = new TestPaths(_output).SystemPrivateCoreLibPath;
+        string coreLibPath = TestPaths.SystemPrivateCoreLibPath;
         Assert.True(File.Exists(coreLibPath), $"System.Private.CoreLib.dll not found at '{coreLibPath}'");
 
         InstructionSetSupport instructionSetSupport = new(default, default, TargetArchitecture.Wasm32);