Subsets.props

<Project>

  <!--
    This file defines the list of projects to build and divides them into subsets. In ordinary
    situations, you should perform a full build by running 'build.cmd' or './build.sh'. This ensures
    the projects are sequenced correctly so the outputs and test results are what you would expect.

    Examples:

      ./build.sh host.native

        This builds only the .NET host.

      ./build.sh libs+host.native

        This builds the .NET host and also the manged libraries portion.
        A space ' ' or '+' are the delimiters between multiple subsets to build.

      ./build.sh -test host.tests

        This builds and executes the installer test projects. (The '-test' argument is an Arcade SDK argument
        that indicates tests should be run. Otherwise, they'll only be built.)
  -->

  <!-- Determine the primary runtime flavor. This is usually CoreCLR, except on
       platforms (like s390x) where only Mono is supported. The primary runtime
       flavor is used to decide when to build the hosts and installers. -->
  <PropertyGroup>
    <!-- Determine if the CoreCLR runtime can build/run for the specified target. -->
    <_CoreCLRSupportedOS Condition="'$(TargetsMobile)' != 'true' and '$(TargetsLinuxBionic)' != 'true'">true</_CoreCLRSupportedOS>

    <!-- Android 32-bit builds blocked by https://github.com/dotnet/runtime/issues/111665 -->
    <_CoreCLRSupportedOS Condition="'$(TargetsAndroid)' == 'true' and '$(TargetArchitecture)' != 'arm' and '$(TargetArchitecture)' != 'x86'">true</_CoreCLRSupportedOS>

    <_CoreCLRSupportedArch Condition="'$(TargetArchitecture)' != 'armv6' and '$(TargetArchitecture)' != 'ppc64le' and '$(TargetArchitecture)' != 's390x'">true</_CoreCLRSupportedArch>
    <CoreCLRSupported Condition="'$(_CoreCLRSupportedOS)' == 'true' and '$(_CoreCLRSupportedArch)' == 'true'">true</CoreCLRSupported>

    <!-- Determine if the Mono runtime can build/run for the specified target. -->
    <_MonoSupportedOS>true</_MonoSupportedOS>
    <_MonoSupportedArch Condition="!('$(TargetOS)' == 'windows' and '$(TargetArchitecture)' == 'arm64') and !('$(TargetsLinuxMusl)' == 'true' and ('$(TargetArchitecture)' == 'arm' or '$(TargetArchitecture)' == 'arm64')) and !('$(TargetsLinuxBionic)' == 'true' and '$(TargetArchitecture)' == 'arm')">true</_MonoSupportedArch>
    <MonoSupported Condition="'$(_MonoSupportedOS)' == 'true' and '$(_MonoSupportedArch)' == 'true'">true</MonoSupported>

    <!-- Determine if the Mono AOT compiler can run on the target (cross-targeting other RIDs) -->
    <_MonoAotCrossSupportedOS Condition="'$(TargetsMobile)' != 'true' and '$(TargetsLinuxBionic)' != 'true'">true</_MonoAotCrossSupportedOS>
    <_MonoAotCrossSupportedArch Condition="'$(TargetArchitecture)' == 'x64' or '$(TargetArchitecture)' == 'arm64'">true</_MonoAotCrossSupportedArch>
    <MonoAOTCrossCompilerSupported Condition="'$(_MonoAotCrossSupportedOS)' == 'true' and '$(_MonoAotCrossSupportedArch)' == 'true'">true</MonoAOTCrossCompilerSupported>

    <!-- Determine if the NativeAOT runtime can run on the specified target. -->
    <_NativeAotSupportedOS Condition="'$(TargetOS)' == 'windows' or '$(TargetOS)' == 'linux' or '$(TargetOS)' == 'osx' or '$(TargetOS)' == 'maccatalyst' or '$(TargetOS)' == 'iossimulator' or '$(TargetOS)' == 'ios' or '$(TargetOS)' == 'tvossimulator' or '$(TargetOS)' == 'tvos' or '$(TargetOS)' == 'freebsd'">true</_NativeAotSupportedOS>
    <_NativeAotSupportedArch Condition="'$(TargetArchitecture)' == 'x64' or '$(TargetArchitecture)' == 'arm64' or '$(TargetArchitecture)' == 'arm' or '$(TargetArchitecture)' == 'loongarch64' or '$(TargetArchitecture)' == 'riscv64' or ('$(TargetOS)' == 'windows' and '$(TargetArchitecture)' == 'x86')">true</_NativeAotSupportedArch>
    <NativeAotSupported Condition="'$(_NativeAotSupportedOS)' == 'true' and '$(_NativeAotSupportedArch)' == 'true'">true</NativeAotSupported>
  </PropertyGroup>

  <PropertyGroup>
    <DefaultPrimaryRuntimeFlavor>CoreCLR</DefaultPrimaryRuntimeFlavor>
    <DefaultPrimaryRuntimeFlavor Condition="'$(CoreCLRSupported)' != 'true'">Mono</DefaultPrimaryRuntimeFlavor>
    <PrimaryRuntimeFlavor Condition="'$(PrimaryRuntimeFlavor)' == ''">$(DefaultPrimaryRuntimeFlavor)</PrimaryRuntimeFlavor>
  </PropertyGroup>

  <PropertyGroup>
    <DefaultSubsets>clr+mono+libs+tools+host+packs</DefaultSubsets>
    <DefaultSubsets Condition="'$(TargetsMobile)' == 'true'">mono+libs+packs</DefaultSubsets>
    <DefaultSubsets Condition="'$(TargetsAndroid)' == 'true' and '$(CoreCLRSupported)' == 'true'">clr+mono+libs+host+packs</DefaultSubsets>
    <DefaultSubsets Condition="'$(TargetsAppleMobile)' == 'true'">clr.nativeaotruntime+clr.nativeaotlibs+mono+libs+packs</DefaultSubsets>
    <DefaultSubsets Condition="'$(TargetsLinuxBionic)' == 'true' and '$(MonoSupported)' == 'true'">clr.nativeaotruntime+clr.nativeaotlibs+mono+libs+host+packs</DefaultSubsets>
    <DefaultSubsets Condition="'$(TargetsLinuxBionic)' == 'true' and '$(MonoSupported)' != 'true'">clr.nativeaotruntime+clr.nativeaotlibs+libs+packs</DefaultSubsets>
    <!-- In source build, mono is only supported as primary runtime flavor. -->
    <DefaultSubsets Condition="'$(DotNetBuildSourceOnly)' == 'true' and '$(PrimaryRuntimeFlavor)' != 'Mono'">clr+libs+tools+host+packs</DefaultSubsets>
    <DefaultSubsets Condition="'$(DotNetBuildMonoCrossAOT)' == 'true'">mono+packs</DefaultSubsets>

    <!-- In the Win-x86 BuildPass2 job in the VMR, we want to build the cross-OS DACs and pack them. -->
    <DefaultSubsets Condition="'$(DotNetBuildPass)' == '2' and '$(TargetOS)' == 'windows' and '$(TargetArchitecture)' == 'x86'">crossdacpack</DefaultSubsets>
  </PropertyGroup>

  <PropertyGroup>
    <!-- If we're building in the VMR, then we want to build all of the assets even in a PGO-instrumented build as downstream repos will not be able to pull assets from a matching non-PGO-instrumented build. -->
    <BuildOnlyPgoInstrumentedAssets Condition="'$(PgoInstrument)' == 'true' and '$(DotNetBuild)' != 'true'">true</BuildOnlyPgoInstrumentedAssets>
  </PropertyGroup>

  <PropertyGroup Condition="'$(BuildMonoAOTCrossCompilerOnly)' == 'true' or ('$(DotNetBuildAllRuntimePacks)' == 'true' and '$(MonoAOTCrossCompilerSupported)' == 'true')">
    <MonoCrossAOTTargetOS>android+browser+wasi</MonoCrossAOTTargetOS>
    <MonoCrossAOTTargetOS Condition="'$(TargetOS)' == 'osx'">$(MonoCrossAOTTargetOS)+tvos+ios+maccatalyst</MonoCrossAOTTargetOS>
  </PropertyGroup>

  <!-- Init _subset here to allow RuntimeFlavor to be set as early as possible -->
  <PropertyGroup>
    <_subset Condition="'$(Subset)' != ''">+$(Subset.ToLowerInvariant())+</_subset>
    <_subset Condition="'$(Subset)' == ''">+$(DefaultSubsets)+</_subset>
  </PropertyGroup>


  <PropertyGroup Condition="'$(RuntimeFlavor)' == ''">
    <RuntimeFlavor Condition="('$(TargetsMobile)' == 'true' or '$(TargetsLinuxBionic)' == 'true') and ($(_subset.Contains('+clr.nativeaotlibs+')) or $(_subset.Contains('+clr.runtime+')))">CoreCLR</RuntimeFlavor>
    <RuntimeFlavor Condition="'$(TargetsAndroid)' == 'true' and ($(_subset.Contains('+clr+')) or $(_subset.Contains('+clr.')))">CoreCLR</RuntimeFlavor>
    <RuntimeFlavor Condition="'$(RuntimeFlavor)' == '' and '$(TargetsMobile)' == 'true'">Mono</RuntimeFlavor>
    <RuntimeFlavor Condition="'$(RuntimeFlavor)' == '' and ($(_subset.Contains('+mono+')) or $(_subset.Contains('+mono.runtime+'))) and (!$(_subset.Contains('+clr+')) and !$(_subset.Contains('+clr.runtime+')) and !$(_subset.Contains('+clr.corelib+')))">Mono</RuntimeFlavor>
    <RuntimeFlavor Condition="'$(RuntimeFlavor)' == ''">$(PrimaryRuntimeFlavor)</RuntimeFlavor>
  </PropertyGroup>

  <PropertyGroup>
    <DefaultCoreClrSubsets>clr.native+clr.corelib+clr.tools+clr.nativecorelib+clr.packages+clr.nativeaotlibs+clr.crossarchtools+host.native</DefaultCoreClrSubsets>
    <DefaultCoreClrSubsets Condition="'$(PackageRID)' == 'linux-armel'">clr.native+clr.corelib+clr.tools+clr.nativecorelib+clr.packages+clr.nativeaotlibs+clr.crossarchtools</DefaultCoreClrSubsets>
    <DefaultCoreClrSubsets Condition="'$(TargetsAndroid)' == 'true'">clr.native+clr.corelib+clr.tools+clr.nativecorelib+clr.packages+clr.nativeaotlibs+clr.crossarchtools</DefaultCoreClrSubsets>
    <!-- Even on platforms that do not support the CoreCLR runtime, we still want to build ilasm/ildasm. -->
    <DefaultCoreClrSubsets Condition="'$(RuntimeFlavor)' != 'CoreCLR'">clr.iltools+clr.packages</DefaultCoreClrSubsets>

    <DefaultNativeAotSubsets>clr.alljits+clr.tools+clr.nativeaotlibs+clr.nativeaotruntime</DefaultNativeAotSubsets>

    <_MonoAotCrossSubsets Condition="'$(MonoCrossAOTTargetOS)' != ''">mono.aotcross</_MonoAotCrossSubsets>

    <DefaultMonoSubsets Condition="'$(MonoEnableLLVM)' == 'true' and '$(MonoLLVMDir)' == ''">mono.llvm+</DefaultMonoSubsets>
    <DefaultMonoSubsets Condition="'$(MonoAOTEnableLLVM)' == 'true' and '$(MonoLLVMDir)' == ''">mono.llvm+</DefaultMonoSubsets>
    <DefaultMonoSubsets Condition="'$(TargetOS)' == 'browser'">$(DefaultMonoSubsets)mono.wasmruntime+</DefaultMonoSubsets>
    <DefaultMonoSubsets Condition="'$(TargetOS)' == 'wasi'">$(DefaultMonoSubsets)mono.wasiruntime+</DefaultMonoSubsets>
    <DefaultMonoSubsets Condition="'$(_MonoAotCrossSubsets)' != ''">$(DefaultMonoSubsets)$(_MonoAotCrossSubsets)+</DefaultMonoSubsets>
    <DefaultMonoSubsets>$(DefaultMonoSubsets)mono.runtime+mono.corelib+mono.packages+</DefaultMonoSubsets>
    <DefaultMonoSubsets Condition="'$(TargetsMobile)' == 'true' or '$(ForceBuildMobileManifests)' == 'true'">$(DefaultMonoSubsets)mono.manifests+</DefaultMonoSubsets>
    <DefaultMonoSubsets Condition="$(_subset.Contains('+mono.wasmworkload+'))">$(DefaultMonoSubsets)mono.manifests+</DefaultMonoSubsets>
    <DefaultMonoSubsets Condition="'$(PrimaryRuntimeFlavor)' != 'Mono'">$(DefaultMonoSubsets)mono.tools+</DefaultMonoSubsets>
    <DefaultMonoSubsets Condition="'$(TargetsMobile)' != 'true'">$(DefaultMonoSubsets)host.native+</DefaultMonoSubsets>

    <!-- If the Mono runtime isn't supported but the AOT compiler is, just build the AOT cross compiler -->
    <DefaultMonoSubsets Condition="'$(BuildMonoAOTCrossCompilerOnly)' == 'true' or ('$(MonoSupported)' != 'true' and '$(MonoAOTCrossCompilerSupported)' == 'true')">$(_MonoAotCrossSubsets)</DefaultMonoSubsets>

    <DefaultLibrariesSubsets Condition="'$(BuildTargetFramework)' == '$(NetCoreAppCurrent)' or
                                        '$(BuildTargetFramework)' == '' or
                                        '$(BuildAllConfigurations)' == 'true'">libs.native+</DefaultLibrariesSubsets>
    <DefaultLibrariesSubsets>$(DefaultLibrariesSubsets)libs.sfx+libs.oob+libs.pretest</DefaultLibrariesSubsets>
    <!-- Respect the DotNetBuildTests product flag when building the product. -->
    <DefaultLibrariesSubsets Condition="'$(DotNetBuildTests)' == 'true'">$(DefaultLibrariesSubsets)+libs.tests</DefaultLibrariesSubsets>

    <DefaultToolsSubsets>tools.illink+tools.cdacreader</DefaultToolsSubsets>

    <DefaultHostSubsets>host.native+host.tools+host.pkg</DefaultHostSubsets>
    <DefaultHostSubsets Condition="'$(DotNetBuildSourceOnly)' != 'true'">$(DefaultHostSubsets)+host.pretest+host.tests</DefaultHostSubsets>
    <DefaultHostSubsets Condition="'$(RuntimeFlavor)' != '$(PrimaryRuntimeFlavor)' or '$(TargetsMobile)' == 'true'"></DefaultHostSubsets>
    <DefaultHostSubsets Condition="'$(RuntimeFlavor)' != '$(PrimaryRuntimeFlavor)' and '$(TargetsMobile)' != 'true'">host.native</DefaultHostSubsets>
    <!-- When we're building all runtime packs, make sure that we build the correct host components to ship. -->
    <DefaultHostSubsets Condition="'$(DotNetBuildAllRuntimePacks)' == 'true' and '$(TargetsLinuxBionic)' == 'true' and '$(MonoSupported)' == 'true'">host.native+host.pkg</DefaultHostSubsets>

    <DefaultPacksSubsets>packs.product</DefaultPacksSubsets>
    <DefaultPacksSubsets Condition="'$(DotNetBuildSourceOnly)' != 'true'">$(DefaultPacksSubsets)+packs.installers</DefaultPacksSubsets>
    <DefaultPacksSubsets Condition="'$(BuildMonoAOTCrossCompilerOnly)' != 'true' and '$(DotNetBuildSourceOnly)' != 'true'">$(DefaultPacksSubsets)+packs.tests</DefaultPacksSubsets>
    <DefaultPacksSubsets Condition="'$(RuntimeFlavor)' != 'Mono' and '$(ForceBuildMobileManifests)' == 'true'">$(DefaultPacksSubsets)+mono.manifests</DefaultPacksSubsets>
  </PropertyGroup>

  <PropertyGroup>
    <_subset>$(_subset.Replace('+clr.paltests+', '+clr.paltests+clr.paltestlist+'))</_subset>
    <_subset>$(_subset.Replace('+clr+', '+$(DefaultCoreClrSubsets)+'))</_subset>
    <_subset>$(_subset.Replace('+clr.aot+', '+$(DefaultNativeAotSubsets)+'))</_subset>
    <_subset>$(_subset.Replace('+mono+', '+$(DefaultMonoSubsets)+'))</_subset>
    <_subset>$(_subset.Replace('+libs+', '+$(DefaultLibrariesSubsets)+'))</_subset>
    <_subset>$(_subset.Replace('+tools+', '+$(DefaultToolsSubsets)+'))</_subset>
    <_subset>$(_subset.Replace('+host+', '+$(DefaultHostSubsets)+'))</_subset>
    <_subset>$(_subset.Replace('+packs+', '+$(DefaultPacksSubsets)+'))</_subset>

    <!-- Surround _subset in dashes to simplify checks below -->
    <_subset>+$(_subset.Trim('+'))+</_subset>

    <ClrRuntimeBuildSubsets></ClrRuntimeBuildSubsets>
    <ClrDefaultRuntimeBuildSubsets>ClrRuntimeSubset=true;ClrJitSubset=true;ClrILToolsSubset=true</ClrDefaultRuntimeBuildSubsets>
  </PropertyGroup>

  <PropertyGroup>
    <_IsCommunityCrossArchitecture Condition="'$(CrossBuild)' == 'true' and ('$(TargetArchitecture)' == 'loongarch64' or '$(TargetArchitecture)' == 'riscv64')">true</_IsCommunityCrossArchitecture>
    <UseNativeAotForComponents Condition="'$(NativeAotSupported)' == 'true' and '$(TargetOS)' == '$(HostOS)' and '$(TargetsLinuxBionic)' != 'true' and '$(_IsCommunityCrossArchitecture)' != 'true'">true</UseNativeAotForComponents>

    <!-- If we're building clr.nativeaotlibs and not building the CLR runtime, compile libraries against NativeAOT CoreLib -->
    <UseNativeAotCoreLib Condition="'$(TestNativeAot)' == 'true' or ($(_subset.Contains('+clr.nativeaotlibs+')) and !$(_subset.Contains('+clr.native+')) and !$(_subset.Contains('+clr.runtime+')) and !$(_subset.Contains('+clr.corelib+')))">true</UseNativeAotCoreLib>
  </PropertyGroup>

  <!-- Configure build properties for C++ runtime library references. -->
  <PropertyGroup>
    <TargetCxxLibraryProperties Condition="'$(TargetCxxStandardLibrary)' != ''">CxxStandardLibrary=$(TargetCxxStandardLibrary)</TargetCxxLibraryProperties>
    <TargetCxxLibraryProperties Condition="'$(TargetCxxStandardLibraryStatic)' != ''">$(TargetCxxLibraryProperties);CxxStandardLibraryStatic=$(TargetCxxStandardLibraryStatic)</TargetCxxLibraryProperties>
    <TargetCxxLibraryProperties Condition="'$(TargetCxxAbiLibrary)' != ''">$(TargetCxxLibraryProperties);CxxAbiLibrary=$(TargetCxxAbiLibrary)</TargetCxxLibraryProperties>
  </PropertyGroup>

  <ItemGroup>
    <!-- CoreClr -->
    <SubsetName Include="Clr" Description="The full CoreCLR runtime. Equivalent to: $(DefaultCoreClrSubsets)" />
    <SubsetName Include="Clr.NativePrereqs" Description="Managed tools that support building the native components of the runtime (such as DacTableGen)." />
    <SubsetName Include="Clr.ILTools" Description="The CoreCLR IL tools (ilasm/ildasm)." />
    <SubsetName Include="Clr.Runtime" Description="The CoreCLR .NET runtime. Includes clr.jit, clr.iltools, clr.hosts." />
    <SubsetName Include="Clr.Native" Description="All CoreCLR native non-test components, including the runtime, jits, and other native tools. Includes clr.hosts, clr.runtime, clr.jit, clr.alljits, clr.paltests, clr.iltools, clr.nativeaotruntime, clr.spmi." />
    <SubsetName Include="Clr.Aot" Description="Everything needed for Native AOT workloads, including clr.alljits, clr.tools, clr.nativeaotlibs, and clr.nativeaotruntime" />
    <SubsetName Include="Clr.NativeAotLibs" Description="The CoreCLR native AOT CoreLib and other low level class libraries." />
    <SubsetName Include="Clr.NativeAotRuntime" Description="The stripped-down CoreCLR native AOT runtime." />
    <SubsetName Include="Clr.CrossArchTools" Description="The cross-targeted CoreCLR tools." />
    <SubsetName Include="Clr.PalTests" OnDemand="true" Description="The CoreCLR PAL tests." />
    <SubsetName Include="Clr.PalTestList" OnDemand="true" Description="Generate the list of the CoreCLR PAL tests. When using the command line, use Clr.PalTests instead." />
    <SubsetName Include="Clr.Hosts" Description="The CoreCLR corerun test host." />
    <SubsetName Include="Clr.Jit" Description="The JIT for the CoreCLR .NET runtime." />
    <SubsetName Include="Clr.AllJits" Description="All of the cross-targeting JIT compilers for the CoreCLR .NET runtime." />
    <SubsetName Include="Clr.AllJitsCommunity" Description="All of the cross-targeting JIT compilers for the CoreCLR .NET runtime, including community targets." />
    <SubsetName Include="Clr.Spmi" Description="SuperPMI, a tool for CoreCLR JIT testing." />
    <SubsetName Include="Clr.CoreLib" Description="The managed System.Private.CoreLib library for CoreCLR." />
    <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.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" />
    <SubsetName Include="CrossDacPack" OnDemand="true"
            Description="Packaging of cross OS DAC. Requires all assets needed to be present at a folder specified by $(CrossDacArtifactsDir). See 'Microsoft.CrossOsDiag.Private.CoreCLR.proj' for details." />

    <!-- Mono -->
    <SubsetName Include="Mono" Description="The Mono runtime and CoreLib. Equivalent to: $(DefaultMonoSubsets)" />
    <SubsetName Include="Mono.Runtime" Description="The Mono .NET runtime." />
    <SubsetName Include="Mono.EmSDK" Description="The emsdk provisioning." />
    <SubsetName Include="Mono.AotCross" Description="The cross-compiler runtime for Mono AOT." />
    <SubsetName Include="Mono.CoreLib" Description="The managed System.Private.CoreLib library for Mono." />
    <SubsetName Include="Mono.Manifests" Description="The NuGet packages with manifests defining the mobile and Blazor workloads." />
    <SubsetName Include="Mono.Packages" Description="The projects that produce NuGet packages for the Mono runtime." />
    <SubsetName Include="Mono.Tools" Description="Tooling that helps support Mono development and testing." />
    <SubsetName Include="Mono.WasmRuntime" Description="The Emscripten runtime." />
    <SubsetName Include="Mono.WasiRuntime" Description="The WASI runtime." />
    <SubsetName Include="Mono.WasmWorkload" Description="*Helper* subset for building some pre-requisites for wasm workload testing, useful on CI." />
    <SubsetName Include="Mono.MsCorDbi" Description="The implementation of ICorDebug interface." />
    <SubsetName Include="Mono.Workloads" OnDemand="true" Description="Builds the installers and the insertion metadata for Blazor workloads." />

    <!-- Tools -->
    <SubsetName Include="Tools" Description="Additional runtime tools projects. Equivalent to: $(DefaultToolsSubsets)" />
    <SubsetName Include="Tools.ILLink" Description="The projects that produce illink and analyzer tools for trimming." />
    <SubsetName Include="Tools.CdacReader" Description="The cDAC reader." />
    <SubsetName Include="Tools.ILLinkTests" OnDemand="true" Description="Unit tests for the tools.illink subset." />

    <SubsetName Include="Tools.CdacReaderTests" OnDemand="true" Description="Units tests for the cDAC reader." />

    <!-- Host -->
    <SubsetName Include="Host" Description="The .NET hosts, packages, hosting libraries, and tests. Equivalent to: $(DefaultHostSubsets)" />
    <SubsetName Include="Host.Native" Description="The .NET hosts." />
    <SubsetName Include="Host.Pkg" Description="The .NET host packages." />
    <SubsetName Include="Host.Tools" Description="The .NET hosting libraries." />
    <SubsetName Include="Host.PreTest" Description="Test assets which are necessary to run the .NET hosting tests." />
    <SubsetName Include="Host.Tests" Description="The .NET hosting tests." />

    <!-- Libs -->
    <SubsetName Include="Libs" Description="The libraries native part, refs and source assemblies, test infra and packages, but NOT the tests (use Libs.Tests to request those explicitly). Equivalent to: $(DefaultLibrariesSubsets)" />
    <SubsetName Include="Libs.Native" Description="The native libraries used in the shared framework." />
    <SubsetName Include="Libs.Sfx" Description="The managed shared framework libraries." />
    <SubsetName Include="Libs.Oob" Description="The managed out-of-band libraries." />
    <SubsetName Include="Libs.PreTest" Description="Test assets which are necessary to run tests." />
    <SubsetName Include="Libs.Tests" OnDemand="true" Description="The test projects. Note that building this doesn't execute tests: you must also pass the '-test' argument." />

    <!-- Packs -->
    <SubsetName Include="Packs" Description="Builds the shared framework packs, archives, bundles, installers, and the framework pack tests. Equivalent to: $(DefaultPacksSubsets)" />
    <SubsetName Include="Packs.Product" Description="Builds the shared framework packs, archives, bundles, and installers." />
    <SubsetName Include="Packs.Installers" Description="Builds the shared framework bundles and installers." />
    <SubsetName Include="Packs.Tests" Description="The framework pack tests." />

    <!-- Utility -->
    <SubsetName Include="RegenerateDownloadTable" OnDemand="true" Description="Regenerates the nightly build download table" />
    <SubsetName Include="RegenerateThirdPartyNotices" OnDemand="true" Description="Regenerates the THIRD-PARTY-NOTICES.TXT file based on other repos' TPN files." />
    <SubsetName Include="tasks" OnDemand="true" Description="Build the repo local task projects." />

  </ItemGroup>

  <!-- Default targets, parallelization and configurations. -->
  <ItemDefinitionGroup>
    <ProjectToBuild>
      <Test>false</Test>
      <Publish>false</Publish>
      <BuildInParallel>false</BuildInParallel>
    </ProjectToBuild>
  </ItemDefinitionGroup>

  <!-- emscripten provisioning, needs to be placed before runtime projects -->
  <ItemGroup Condition="$(_subset.Contains('+mono.emsdk+'))">
    <ProjectToBuild Include="$(MonoProjectRoot)mono.proj" AdditionalProperties="%(AdditionalProperties);ProvisionEmscriptenOnly=true" Category="mono" />
  </ItemGroup>

  <!-- CoreClr sets -->
  <ItemGroup Condition="$(_subset.Contains('+clr.corelib+'))">
    <ProjectToBuild Include="$(CoreClrProjectRoot)System.Private.CoreLib\System.Private.CoreLib.csproj" Category="clr" />
  </ItemGroup>

  <PropertyGroup Condition="$(_subset.Contains('+clr.hosts+'))">
    <ClrRuntimeBuildSubsets>$(ClrRuntimeBuildSubsets);ClrHostsSubset=true</ClrRuntimeBuildSubsets>
  </PropertyGroup>

  <PropertyGroup Condition="$(_subset.Contains('+clr.runtime+'))">
    <ClrRuntimeBuildSubsets>$(ClrRuntimeBuildSubsets);ClrRuntimeSubset=true</ClrRuntimeBuildSubsets>
  </PropertyGroup>

  <PropertyGroup Condition="$(_subset.Contains('+clr.native+'))">
    <ClrRuntimeBuildSubsets>$(ClrRuntimeBuildSubsets);ClrFullNativeBuild=true</ClrRuntimeBuildSubsets>
  </PropertyGroup>

  <PropertyGroup Condition="$(_subset.Contains('+clr.jit+'))">
    <ClrRuntimeBuildSubsets>$(ClrRuntimeBuildSubsets);ClrJitSubset=true</ClrRuntimeBuildSubsets>
  </PropertyGroup>

  <PropertyGroup Condition="$(_subset.Contains('+clr.paltests+'))">
    <ClrRuntimeBuildSubsets>$(ClrRuntimeBuildSubsets);ClrPalTestsSubset=true</ClrRuntimeBuildSubsets>
  </PropertyGroup>

  <PropertyGroup Condition="$(_subset.Contains('+clr.alljits+'))">
    <ClrRuntimeBuildSubsets>$(ClrRuntimeBuildSubsets);ClrAllJitsSubset=true</ClrRuntimeBuildSubsets>
  </PropertyGroup>

  <PropertyGroup Condition="$(_subset.Contains('+clr.alljitscommunity+'))">
    <ClrRuntimeBuildSubsets>$(ClrRuntimeBuildSubsets);ClrAllJitsCommunitySubset=true</ClrRuntimeBuildSubsets>
  </PropertyGroup>

  <PropertyGroup Condition="$(_subset.Contains('+clr.iltools+'))">
    <ClrRuntimeBuildSubsets>$(ClrRuntimeBuildSubsets);ClrILToolsSubset=true</ClrRuntimeBuildSubsets>
  </PropertyGroup>

  <PropertyGroup Condition="$(_subset.Contains('+clr.nativeaotruntime+')) and '$(NativeAotSupported)' == 'true'">
    <ClrRuntimeBuildSubsets>$(ClrRuntimeBuildSubsets);ClrNativeAotSubset=true</ClrRuntimeBuildSubsets>
  </PropertyGroup>

  <PropertyGroup Condition="$(_subset.Contains('+clr.spmi+'))">
    <ClrRuntimeBuildSubsets>$(ClrRuntimeBuildSubsets);ClrSpmiSubset=true</ClrRuntimeBuildSubsets>
  </PropertyGroup>

  <ItemGroup Condition="'$(ClrRuntimeBuildSubsets)' != '' or $(_subset.Contains('+clr.nativeprereqs+'))">
    <ProjectToBuild Include="$(CoreClrProjectRoot)runtime-prereqs.proj" Category="clr" GlobalPropertiesToRemove="$(NativeBuildPartitionPropertiesToRemove)" />
  </ItemGroup>

  <ItemGroup Condition="'$(ClrRuntimeBuildSubsets)' != ''">
    <ProjectToBuild
      Include="$(CoreClrProjectRoot)runtime.proj"
      AdditionalProperties="%(AdditionalProperties);$(ClrRuntimeBuildSubsets);$(TargetCxxLibraryProperties)"
      Category="clr" />
  </ItemGroup>

  <!--
    Build the CoreCLR cross tools when we're doing a cross build and either we're building any CoreCLR native tools for platforms CoreCLR fully supports or when someone explicitly requests them.
    The cross tools are used as part of the build process with the downloaded build tools, so we need to build them for the host architecture and build them as unsanitized binaries.
    -->
  <PropertyGroup>
    <_BuildAnyCrossArch Condition="('$(CrossBuild)' == 'true' or '$(BuildArchitecture)' != '$(TargetArchitecture)' or '$(HostOS)' != '$(TargetOS)' or '$(EnableNativeSanitizers)' != '') and '$(TargetArchitecture)' != 'wasm'">true</_BuildAnyCrossArch>
    <_BuildCrossComponents Condition="$(_subset.Contains('+clr.crossarchtools+'))">true</_BuildCrossComponents>
    <_BuildCrossComponents Condition="'$(ClrRuntimeBuildSubsets)' != '' and ('$(PrimaryRuntimeFlavor)' == 'CoreCLR' or '$(TargetsMobile)' == 'true')">true</_BuildCrossComponents>
    <_CrossBitwidthBuild Condition="'$(BuildArchitecture)' == 'x64' and ('$(TargetArchitecture)' == 'x86' or '$(TargetArchitecture)' == 'arm')">true</_CrossBitwidthBuild>
    <_BuildCrossDebugComponents Condition="'$(_BuildCrossComponents)' == 'true' and '$(TargetsWindows)' == 'true' and '$(_CrossBitwidthBuild)' != 'true'">true</_BuildCrossDebugComponents>
  </PropertyGroup>

  <ItemGroup>
    <!-- When building cross components, always build the JITs. We will need them for running crossgen2 and ILC in the build. -->
    <_CrossToolSubset Condition="'$(_BuildCrossComponents)' == 'true'" Include="ClrAllJitsSubset=true" />
    <!-- When targeting Windows, we need to build a copy of the diagnostic libraries that can run on the host to enable remote debugging of a local build. -->
    <_CrossToolSubset Condition="'$(_BuildCrossComponents)' == 'true' and '$(TargetsWindows)' == 'true'" Include="ClrDebugSubset=true" />
    <!--
    In a vertical orchestrated build, we need to produce an ilasm and ildasm for use by upstack repositories.
      However, these repositories only build on Windows, so we can limit this to only execute on Windows to avoid additional infrastructure work when not necessary.
    -->
    <_CrossToolSubset Condition="'$(BuildHostILTools)' == 'true'" Include="ClrILToolsSubset=true" />
  </ItemGroup>

  <ItemGroup Condition="'$(_BuildAnyCrossArch)' == 'true' and '@(_CrossToolSubset)' != ''">
    <ProjectToBuild
      Include="$(CoreClrProjectRoot)runtime.proj"
      AdditionalProperties="%(AdditionalProperties);@(_CrossToolSubset);
                            HostArchitecture=$(BuildArchitecture);
                            HostCrossOS=$(HostOS);
                            PgoInstrument=false;
                            NoPgoOptimize=true;
                            CrossBuild=false;
                            BuildSubdirectory=$(BuildArchitecture);
                            CMakeArgs=$(CMakeArgs) -DCLR_CROSS_COMPONENTS_BUILD=1"
      UndefineProperties="EnableNativeSanitizers"
      Category="clr" />
  </ItemGroup>

  <!--
    Build the debugging components of CoreCLR for the same target architecture as an unsanitized build whenever we build a sanitized coreclr build.
    These components are loaded into a debugger process, which generally is not a sanitized executable.
  -->
  <ItemGroup Condition="'$(ClrRuntimeBuildSubsets)' != '' and '$(EnableNativeSanitizers)' != ''">
    <ProjectToBuild
      Include="$(CoreClrProjectRoot)runtime.proj"
      AdditionalProperties="%(AdditionalProperties);
                            ClrDebugSubset=true;
                            PgoInstrument=false;
                            NoPgoOptimize=true;
                            CrossBuild=$(CrossBuild);
                            BuildSubdirectory=unsanitized"
      UndefineProperties="EnableNativeSanitizers"
      Category="clr" />
  </ItemGroup>

  <ItemGroup Condition="$(_subset.Contains('+clr.paltestlist+'))">
    <ProjectToBuild Include="$(CoreClrProjectRoot)pal/tests/palsuite/producepaltestlist.proj" />
  </ItemGroup>

  <PropertyGroup>
    <CrossDacHostArch>x64</CrossDacHostArch>
    <CrossDacHostArch Condition="'$(TargetArchitecture)' == 'arm'">x86</CrossDacHostArch>
  </PropertyGroup>

  <ItemGroup Condition="$(_subset.Contains('+linuxdac+')) and $([MSBuild]::IsOsPlatform(Windows))  and ('$(BuildArchitecture)' == 'x64' or '$(BuildArchitecture)' == 'x86') and '$(TargetArchitecture)' != 'x86'">
    <ProjectToBuild
      Include="$(CoreClrProjectRoot)runtime.proj"
      AdditionalProperties="%(AdditionalProperties);
                            ClrDebugSubset=true;
                            HostArchitecture=$(CrossDacHostArch);
                            PgoInstrument=false;
                            NoPgoOptimize=true;
                            TargetOS=linux;
                            BuildSubdirectory=$(CrossDacHostArch);
                            CMakeArgs=$(CMakeArgs) -DCLR_CROSS_COMPONENTS_BUILD=1" Category="clr" />
  </ItemGroup>

  <ItemGroup Condition="$(_subset.Contains('+alpinedac+')) and $([MSBuild]::IsOsPlatform(Windows)) and ('$(BuildArchitecture)' == 'x64' or '$(BuildArchitecture)' == 'x86') and '$(TargetArchitecture)' != 'x86'">
    <ProjectToBuild
      Include="$(CoreClrProjectRoot)runtime.proj"
      AdditionalProperties="%(AdditionalProperties);
                            ClrDebugSubset=true;
                            HostArchitecture=$(CrossDacHostArch);
                            PgoInstrument=false;
                            NoPgoOptimize=true;
                            TargetOS=alpine;
                            BuildSubdirectory=$(CrossDacHostArch);
                            CMakeArgs=$(CMakeArgs) -DCLR_CROSS_COMPONENTS_BUILD=1" Category="clr" />
  </ItemGroup>

  <ItemGroup Condition="$(_subset.Contains('+crossdacpack+'))">
    <ProjectToBuild Include="$(CoreClrProjectRoot).nuget\Microsoft.CrossOsDiag.Private.CoreCLR\Microsoft.CrossOsDiag.Private.CoreCLR.proj" Category="clr" />
  </ItemGroup>

  <ItemGroup Condition="$(_subset.Contains('+clr.tools+'))">
    <ProjectToBuild Include="$(CoreClrProjectRoot)tools\runincontext\runincontext.csproj;
                             $(CoreClrProjectRoot)tools\tieringtest\tieringtest.csproj;
                             $(CoreClrProjectRoot)tools\r2rdump\R2RDump.csproj;
                             $(CoreClrProjectRoot)tools\dotnet-pgo\dotnet-pgo.csproj;
                             $(CoreClrProjectRoot)tools\aot\ILCompiler\repro\repro.csproj;
                             $(CoreClrProjectRoot)tools\r2rtest\R2RTest.csproj;
                             $(CoreClrProjectRoot)tools\PdbChecker\PdbChecker.csproj;
                             $(CoreClrProjectRoot)tools\AssemblyChecker\AssemblyChecker.csproj;
                             $(ToolsProjectRoot)StressLogAnalyzer\src\StressLogAnalyzer.csproj" Category="clr" Condition="'$(DotNetBuildSourceOnly)' != 'true'"/>
    <!-- skip the architectures that don't have LKG runtime packs -->
    <ProjectToBuild Include="$(CoreClrProjectRoot)tools\aot\crossgen2\crossgen2_publish.csproj" Condition="'$(NativeAotSupported)' == 'true' and '$(StageOneBuild)' != 'true'" Category="clr" />
    <ProjectToBuild Include="$(CoreClrProjectRoot)tools\aot\ILCompiler.Build.Tasks\ILCompiler.Build.Tasks.csproj" Category="clr" Condition="'$(NativeAotSupported)' == 'true'" />
    <ProjectToBuild Include="$(CoreClrProjectRoot)tools\aot\ILCompiler\ILCompiler_publish.csproj" Category="clr" Condition="'$(NativeAotSupported)' == 'true' and '$(StageOneBuild)' != 'true'" />
    <ProjectToBuild Include="$(CoreClrProjectRoot)nativeaot\BuildIntegration\BuildIntegration.proj" Category="clr" Condition="'$(NativeAotSupported)' == 'true'" />

    <ProjectToBuild Include="$(CoreClrProjectRoot)tools\aot\ILCompiler\ILCompiler.csproj" Condition="'$(NativeAotSupported)' == 'true' and '$(StageOneBuild)' != 'true'" Category="clr" />
    <ProjectToBuild Include="$(CoreClrProjectRoot)tools\aot\crossgen2\crossgen2.csproj" Condition="'$(NativeAotSupported)' == 'true' and '$(StageOneBuild)' != 'true'" Category="clr" />

    <!--
      Always build the in-build variants of these tools. They run on the host machine, which we always have LKG packs for.
      For two-stage builds, we omit this step during stage2 since stage1 covers it.
    -->
    <ProjectToBuild Include="$(CoreClrProjectRoot)tools\aot\ILCompiler\ILCompiler_inbuild.csproj" Category="clr" Condition="'$(StageTwoBuild)' != 'true'" />
    <ProjectToBuild Include="$(CoreClrProjectRoot)tools\aot\crossgen2\crossgen2_inbuild.csproj" Category="clr" Condition="'$(StageTwoBuild)' != 'true'" />

    <ProjectToBuild Condition="'$(TargetOS)' == 'windows' or ('$(TargetOS)' == 'linux' and ('$(TargetArchitecture)' == 'x64' or '$(TargetArchitecture)' == 'arm64')) or '$(TargetOS)' == 'osx'" Include="$(CoreClrProjectRoot)tools\SuperFileCheck\SuperFileCheck.csproj" Category="clr" />

    <ProjectToBuild Include="$(CoreClrProjectRoot)tools\cdac-build-tool\cdac-build-tool.csproj" Category="clr" />
  </ItemGroup>

  <ItemGroup Condition="$(_subset.Contains('+clr.toolstests+'))">
    <ProjectToBuild Include="$(CoreClrProjectRoot)tools\aot\ILCompiler.TypeSystem.Tests\ILCompiler.TypeSystem.Tests.csproj"
      Test="true" Category="clr" Condition="'$(DotNetBuildSourceOnly)' != 'true'"/>
    <ProjectToBuild Include="$(CoreClrProjectRoot)tools\aot\ILCompiler.Compiler.Tests\ILCompiler.Compiler.Tests.csproj"
      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'"/>
  </ItemGroup>

  <ItemGroup Condition="$(_subset.Contains('+tools.cdacreader+'))">
    <ProjectToBuild Include="$(SharedNativeRoot)managed\compile-native.proj" Category="tools" />
  </ItemGroup>

  <ItemGroup Condition="$(_subset.Contains('+tools.cdacreadertests+'))">
    <ProjectToBuild Include="$(SharedNativeRoot)managed\cdacreader\tests\Microsoft.Diagnostics.DataContractReader.Tests.csproj" Test="true" Category="tools"/>
  </ItemGroup>

  <ItemGroup Condition="$(_subset.Contains('+tools.illink+'))">
    <ProjectToBuild Include="$(ToolsProjectRoot)illink\src\linker\Mono.Linker.csproj" Category="tools" />
    <ProjectToBuild Include="$(ToolsProjectRoot)illink\src\ILLink.Tasks\ILLink.Tasks.csproj" Category="tools" />
    <ProjectToBuild Include="$(ToolsProjectRoot)illink\src\analyzer\analyzer.csproj" Category="tools" />
    <ProjectToBuild Include="$(ToolsProjectRoot)illink\src\ILLink.RoslynAnalyzer\ILLink.RoslynAnalyzer.csproj" Category="tools" />
    <ProjectToBuild Include="$(ToolsProjectRoot)illink\src\linker\ref\Mono.Linker.csproj" Category="tools" />
    <ProjectToBuild Include="$(ToolsProjectRoot)illink\src\tlens\tlens.csproj" Category="tools" />
    <ProjectToBuild Include="$(ToolsProjectRoot)illink\src\ILLink.CodeFix\ILLink.CodeFixProvider.csproj" Category="tools" />
  </ItemGroup>

  <ItemGroup Condition="$(_subset.Contains('+tools.illinktests+'))">
    <ProjectToBuild Include="$(ToolsProjectRoot)illink\test\Mono.Linker.Tests\Mono.Linker.Tests.csproj"
      Test="true" Category="tools"/>
    <ProjectToBuild Include="$(ToolsProjectRoot)illink\test\Mono.Linker.Tests.Cases\Mono.Linker.Tests.Cases.csproj"
      Test="true" Category="tools"/>
    <ProjectToBuild Include="$(ToolsProjectRoot)illink\test\Mono.Linker.Tests.Cases.Expectations\Mono.Linker.Tests.Cases.Expectations.csproj"
      Test="true" Category="tools"/>
    <ProjectToBuild Include="$(ToolsProjectRoot)illink\test\ILLink.Tasks.Tests\ILLink.Tasks.Tests.csproj"
      Test="true" Category="tools"/>
    <ProjectToBuild Include="$(ToolsProjectRoot)illink\test\ILLink.RoslynAnalyzer.Tests\ILLink.RoslynAnalyzer.Tests.csproj"
      Test="true" Category="tools"/>
    <ProjectToBuild Include="$(ToolsProjectRoot)illink\test\ILLink.RoslynAnalyzer.Tests.Generator\ILLink.RoslynAnalyzer.Tests.Generator.csproj"
      Test="true" Category="tools"/>
  </ItemGroup>

  <ItemGroup Condition="$(_subset.Contains('+clr.nativecorelib+'))">
    <ProjectToBuild Include="$(CoreClrProjectRoot)crossgen-corelib.proj" Category="clr" />
  </ItemGroup>

  <ItemGroup Condition="$(_subset.Contains('+clr.packages+')) and '$(BuildOnlyPgoInstrumentedAssets)' != 'true'">
    <ProjectToBuild Include="$(CoreClrProjectRoot).nuget\coreclr-packages.proj" Category="clr" />
  </ItemGroup>

  <ItemGroup Condition="$(_subset.Contains('+clr.nativeaotlibs+')) and '$(NativeAotSupported)' == 'true'">
    <ProjectToBuild Include="$(CoreClrProjectRoot)nativeaot\**\src\*.csproj" Category="clr" />
  </ItemGroup>

  <!-- Mono sets -->
  <ItemGroup Condition="$(_subset.Contains('+mono.llvm+')) or $(_subset.Contains('+mono.aotcross+')) or '$(TargetOS)' == 'ios' or '$(TargetOS)' == 'iossimulator' or '$(TargetOS)' == 'tvos' or '$(TargetOS)' == 'tvossimulator' or '$(TargetOS)' == 'maccatalyst' or '$(TargetOS)' == 'android' or '$(TargetOS)' == 'browser' or '$(TargetOS)' == 'wasi' or '$(TargetsLinuxBionic)' == 'true'">
    <ProjectToBuild Include="$(MonoProjectRoot)llvm\llvm-init.proj" Category="mono" />
  </ItemGroup>

  <ItemGroup Condition="$(_subset.Contains('+mono.manifests+'))">
    <ProjectToBuild Include="$(MonoProjectRoot)nuget\manifest-packages.proj" Category="mono" />
  </ItemGroup>

  <ItemGroup Condition="$(_subset.Contains('+mono.packages+'))">
    <ProjectToBuild Include="$(MonoProjectRoot)nuget\mono-packages.proj" Category="mono" />
  </ItemGroup>

  <ItemGroup Condition="$(_subset.Contains('+mono.runtime+'))">
    <ProjectToBuild Include="$(MonoProjectRoot)mono.proj" AdditionalProperties="%(AdditionalProperties);MonoMsCorDbi=$(_subset.Contains('+mono.mscordbi+'))" Category="mono" />
  </ItemGroup>

  <ItemGroup Condition="$(_subset.Contains('+mono.aotcross+'))">
    <ProjectToBuild Include="$(MonoProjectRoot)monoaotcross.proj" Category="mono" />
  </ItemGroup>

  <ItemGroup Condition="$(_subset.Contains('+mono.corelib+'))">
    <ProjectToBuild Include="$(MonoProjectRoot)System.Private.CoreLib\System.Private.CoreLib.csproj" Category="mono" />
  </ItemGroup>

  <ItemGroup Condition="$(_subset.Contains('+mono.tools+'))">
    <ProjectToBuild Include="$(CoreClrProjectRoot)tools\dotnet-pgo\dotnet-pgo.csproj;" Category="mono" />
  </ItemGroup>

  <ItemGroup Condition="$(_subset.Contains('+mono.workloads+'))">
    <ProjectToBuild Include="$(WorkloadsProjectRoot)\workloads.csproj" Category="mono" />
  </ItemGroup>

  <ItemGroup Condition="$(_subset.Contains('+mono.wasmworkload+'))">
    <ProjectToBuild Include="$(MonoProjectRoot)\wasm\workloads.proj" Category="mono" />
  </ItemGroup>

  <!-- Host sets -->
  <ItemGroup Condition="$(_subset.Contains('+host.native+'))">
    <CorehostProjectToBuild Include="$(SharedNativeRoot)corehost\corehost.proj" />
    <ProjectToBuild Include="@(CorehostProjectToBuild)" AdditionalProperties="$(TargetCxxLibraryProperties)" Category="host" />
  </ItemGroup>

  <ItemGroup Condition="$(_subset.Contains('+host.tools+'))">
    <ManagedProjectToBuild Include="$(InstallerProjectRoot)managed\**\*.csproj" />
    <ProjectToBuild Include="@(ManagedProjectToBuild)" BuildInParallel="true" Category="host" />
  </ItemGroup>

  <ItemGroup Condition="$(_subset.Contains('+host.pkg+')) and '$(BuildOnlyPgoInstrumentedAssets)' != 'true'">
    <PkgprojProjectToBuild Include="$(InstallerProjectRoot)pkg\projects\host-packages.proj" />
    <ProjectToBuild Include="@(PkgprojProjectToBuild)" Category="host" />
  </ItemGroup>

  <!-- Libraries sets -->
  <ItemGroup Condition="$(_subset.Contains('+libs.native+'))">
    <ProjectToBuild Include="$(SharedNativeRoot)libs\build-native.proj" Category="libs" />
  </ItemGroup>

  <ItemGroup Condition="$(_subset.Contains('+libs.sfx+'))">
    <ProjectToBuild Include="$(LibrariesProjectRoot)sfx.proj"
                    Category="libs"
                    Condition="'$(BuildTargetFramework)' == '$(NetCoreAppCurrent)' or
                               '$(BuildTargetFramework)' == '' or
                               '$(BuildAllConfigurations)' == 'true'" />
  </ItemGroup>

  <ItemGroup Condition="$(_subset.Contains('+libs.oob+'))">
    <ProjectToBuild Include="$(LibrariesProjectRoot)oob.proj" Category="libs" />
  </ItemGroup>

  <ItemGroup Condition="$(_subset.Contains('+mono.wasmruntime+'))">
    <ProjectToBuild Include="$(LibrariesProjectRoot)\System.Runtime.InteropServices.JavaScript\src\System.Runtime.InteropServices.JavaScript.csproj" Category="mono" />
    <ProjectToBuild Include="$(BrowserProjectRoot)browser.proj" Category="mono" />
  </ItemGroup>

  <ItemGroup Condition="$(_subset.Contains('+mono.wasiruntime+'))">
    <ProjectToBuild Include="$(WasiProjectRoot)wasi.proj" Category="mono" />
  </ItemGroup>

  <ItemGroup Condition="$(_subset.Contains('+libs.pretest+'))">
    <ProjectToBuild Include="$(LibrariesProjectRoot)pretest.proj" Category="libs"  />
  </ItemGroup>

  <ItemGroup Condition="$(_subset.Contains('+libs.tests+'))">
    <ProjectToBuild Include="$(LibrariesProjectRoot)tests.proj" Category="libs" Test="true" />
  </ItemGroup>

  <!-- Host.pretest subset (consumes live built libraries assets so needs to come after libraries) -->
  <ItemGroup Condition="$(_subset.Contains('+host.pretest+'))">
    <ProjectToBuild Include="$(InstallerProjectRoot)tests\hostpretest.proj" Category="host" />
  </ItemGroup>

  <!-- Host.tests subset (consumes live built libraries assets so needs to come after libraries) -->
  <ItemGroup Condition="$(_subset.Contains('+host.tests+'))">
    <TestProjectToBuild Include="$(InstallerProjectRoot)tests\AppHost.Bundle.Tests\AppHost.Bundle.Tests.csproj" />
    <TestProjectToBuild Include="$(InstallerProjectRoot)tests\HostActivation.Tests\HostActivation.Tests.csproj" />
    <TestProjectToBuild Include="$(InstallerProjectRoot)tests\Microsoft.NET.HostModel.Tests\Microsoft.NET.HostModel.Tests.csproj" />
    <ProjectToBuild Include="@(TestProjectToBuild)" BuildInParallel="true" Test="true" Category="host" />
  </ItemGroup>

  <!-- Packs sets -->

  <Choose>
    <When Condition="$(_subset.Contains('+packs.product+'))">
      <Choose>
        <When Condition="'$(BuildOnlyPgoInstrumentedAssets)' == 'true'">
          <ItemGroup>
            <ProjectToBuild Include="$(InstallerProjectRoot)pkg\sfx\bundle\Microsoft.NETCore.App.Bundle.bundleproj" Category="packs" />
          </ItemGroup>
        </When>
        <When Condition="'$(BuildMonoAOTCrossCompilerOnly)' == 'true'">
          <ItemGroup Condition="'$(MonoCrossAOTTargetOS)' != ''">
            <ProjectToBuild Include="$(InstallerProjectRoot)pkg\sfx\Microsoft.NETCore.App\monocrossaot.proj" Category="packs" />
          </ItemGroup>
        </When>
        <Otherwise>
          <PropertyGroup>
            <_BuildCoreCLRRuntimePack Condition="'$(RuntimeFlavor)' == 'CoreCLR' and '$(CoreCLRSupported)' == 'true'">true</_BuildCoreCLRRuntimePack>
            <_BuildMonoRuntimePack Condition="'$(RuntimeFlavor)' == 'Mono' and '$(MonoSupported)' == 'true'">true</_BuildMonoRuntimePack>
            <_BuildHostPack Condition="'$(RuntimeFlavor)' == '$(PrimaryRuntimeFlavor)' and '$(TargetsMobile)' != 'true'">true</_BuildHostPack>
            <_BuildBundle Condition="'$(RuntimeFlavor)' == '$(PrimaryRuntimeFlavor)' and '$(TargetsMobile)' != 'true'">true</_BuildBundle>
          </PropertyGroup>

          <PropertyGroup Condition="'$(DotNetBuildAllRuntimePacks)' == 'true' and '$(DotNetBuildSourceOnly)' != 'true'">
            <_BuildCoreCLRRuntimePack Condition="'$(CoreCLRSupported)' == 'true'">true</_BuildCoreCLRRuntimePack>
            <_BuildMonoRuntimePack Condition="'$(MonoSupported)' == 'true'">true</_BuildMonoRuntimePack>
          </PropertyGroup>

          <!-- In source build, mono is only supported as primary runtime flavor, and when Mono is the primary runtime flavor, CoreCLR is not supported. -->
          <PropertyGroup Condition="'$(DotNetBuildAllRuntimePacks)' == 'true' and '$(DotNetBuildSourceOnly)' == 'true'">
            <_BuildCoreCLRRuntimePack Condition="'$(PrimaryRuntimeFlavor)' == 'CoreCLR'">true</_BuildCoreCLRRuntimePack>
            <_BuildMonoRuntimePack Condition="'$(PrimaryRuntimeFlavor)' == 'Mono'">true</_BuildMonoRuntimePack>
          </PropertyGroup>

          <PropertyGroup Condition="'$(DotNetBuildAllRuntimePacks)' == 'true'">
            <_BuildNativeAOTRuntimePack Condition="'$(NativeAOTSupported)' == 'true'">true</_BuildNativeAOTRuntimePack>
            <_BuildHostPack Condition="'$(TargetsMobile)' != 'true' and !('$(TargetsLinuxBionic)' == 'true' and '$(TargetArchitecture)' == 'arm')">true</_BuildHostPack>
            <_BuildBundle Condition="'$(TargetsMobile)' != 'true' and !('$(TargetsLinuxBionic)' == 'true' and '$(TargetArchitecture)' == 'arm')">true</_BuildBundle>
          </PropertyGroup>

          <ItemGroup>
            <SharedFrameworkProjectToBuild Include="$(InstallerProjectRoot)pkg\sfx\Microsoft.NETCore.App\Microsoft.NETCore.App.Ref.sfxproj" />
          </ItemGroup>
          <ItemGroup>
            <SharedFrameworkProjectToBuild Condition="'$(RuntimeFlavor)' != 'Mono' and ('$(TargetsMobile)' != 'true' and '$(TargetsLinuxBionic)' != 'true')" Include="$(InstallerProjectRoot)pkg\sfx\Microsoft.NETCore.App\Microsoft.NETCore.App.Crossgen2.sfxproj" />
            <SharedFrameworkProjectToBuild Condition="'$(RuntimeFlavor)' == '$(PrimaryRuntimeFlavor)' and '$(TargetsMobile)' != 'true'" Include="$(InstallerProjectRoot)pkg\sfx\installers\dotnet-host.proj" />
            <SharedFrameworkProjectToBuild Condition="'$(RuntimeFlavor)' == '$(PrimaryRuntimeFlavor)' and '$(TargetsMobile)' != 'true'" Include="$(InstallerProjectRoot)pkg\sfx\installers\dotnet-hostfxr.proj" />
            <SharedFrameworkProjectToBuild Condition="'$(RuntimeFlavor)' == '$(PrimaryRuntimeFlavor)' and '$(TargetsMobile)' != 'true'" Include="$(InstallerProjectRoot)pkg\sfx\installers\dotnet-runtime-deps\*.proj" />
            <SharedFrameworkProjectToBuild Condition="'$(MonoCrossAOTTargetOS)' != '' and '$(DotNetBuildSourceOnly)' != 'true'" Include="$(InstallerProjectRoot)pkg\sfx\Microsoft.NETCore.App\monocrossaot.proj" />
          </ItemGroup>
          <ItemGroup>
            <ProjectToBuild Condition="'$(NativeAotSupported)' == 'true' and '$(RuntimeFlavor)' != 'Mono' and '$(TargetsMobile)' != 'true' and '$(TargetsLinuxBionic)' != 'true'" Include="$(InstallerProjectRoot)\pkg\projects\nativeaot-packages.proj" Category="packs" />
          </ItemGroup>
          <ItemGroup>
            <!--
              When we're building in the VMR, we need to provide a crossgen2 that runs on the host machine for downstream repos to use to R2R their code.
              In non-VMR builds, downstream repos can use the crossgen2 built for the target host SDK from another build leg, but in the VMR we need to provide one to use.
            -->
            <ProjectToBuild Condition="'$(RuntimeFlavor)' != 'Mono' and '$(TargetsMobile)' != 'true' and '$(TargetsLinuxBionic)' != 'true' and '$(BuildHostTools)' == 'true'" Include="$(InstallerProjectRoot)pkg\sfx\Microsoft.NETCore.App\Microsoft.NETCore.App.Crossgen2.Host.sfxproj" Category="packs" />
          </ItemGroup>
          <ItemGroup>
            <SharedFrameworkProjectToBuild Condition="'$(_BuildHostPack)' == 'true'" Include="$(InstallerProjectRoot)pkg\archives\dotnet-nethost.proj" />
            <SharedFrameworkProjectToBuild Condition="'$(_BuildHostPack)' == 'true'" Include="$(InstallerProjectRoot)pkg\sfx\Microsoft.NETCore.App\Microsoft.NETCore.App.Host.sfxproj" />
            <SharedFrameworkProjectToBuild Condition="'$(_BuildCoreCLRRuntimePack)' == 'true'" Include="$(InstallerProjectRoot)pkg\sfx\Microsoft.NETCore.App\Microsoft.NETCore.App.Runtime.CoreCLR.sfxproj" />
            <SharedFrameworkProjectToBuild Condition="'$(_BuildMonoRuntimePack)' == 'true'" Include="$(InstallerProjectRoot)pkg\sfx\Microsoft.NETCore.App\Microsoft.NETCore.App.Runtime.Mono.sfxproj" />
            <SharedFrameworkProjectToBuild Condition="'$(_BuildNativeAOTRuntimePack)' == 'true'" Include="$(InstallerProjectRoot)pkg\sfx\Microsoft.NETCore.App\Microsoft.NETCore.App.Runtime.NativeAOT.sfxproj" />
          </ItemGroup>
          <ItemGroup>
            <SharedFrameworkProjectToBuild Condition="'$(_BuildBundle)' == 'true'" Include="$(InstallerProjectRoot)pkg\sfx\bundle\Microsoft.NETCore.App.Bundle.bundleproj" />
            <ProjectToBuild Include="@(SharedFrameworkProjectToBuild)" Category="packs" />
          </ItemGroup>
        </Otherwise>
      </Choose>
    </When>
  </Choose>

  <ItemGroup Condition="$(_subset.Contains('+packs.installers+')) AND '$(BuildOnlyPgoInstrumentedAssets)' != 'true'">
    <InstallerProjectToBuild Include="$(InstallerProjectRoot)pkg\sfx\installers.proj" />
    <ProjectToBuild Include="@(InstallerProjectToBuild)" Category="packs" />
  </ItemGroup>

  <ItemGroup Condition="$(_subset.Contains('+packs.tests+')) AND '$(BuildOnlyPgoInstrumentedAssets)' != 'true'">
    <TestProjectToBuild Include="$(InstallerProjectRoot)tests\Microsoft.DotNet.CoreSetup.Packaging.Tests\Microsoft.DotNet.CoreSetup.Packaging.Tests.csproj" />
    <ProjectToBuild Include="@(TestProjectToBuild)" BuildInParallel="true" Test="true" Category="packs" />
  </ItemGroup>

  <!-- Utility -->
  <ItemGroup Condition="$(_subset.Contains('+regeneratedownloadtable+'))">
    <ProjectToBuild Include="$(RepositoryEngineeringDir)regenerate-download-table.proj" />
  </ItemGroup>

  <ItemGroup Condition="$(_subset.Contains('+regeneratethirdpartynotices+'))">
    <ProjectToBuild Include="$(RepositoryEngineeringDir)regenerate-third-party-notices.proj" BuildInParallel="false" />
  </ItemGroup>

  <!-- Tasks-->
  <ItemGroup Condition="$(_subset.Contains('+tasks+'))">
    <ProjectToBuild Include="$(RepoTasksDir)tasks.proj" Category="tasks" />
  </ItemGroup>

  <!-- Set default configurations. -->
  <ItemGroup>
    <ProjectToBuild Update="@(ProjectToBuild)">
      <AdditionalProperties Condition="'%(ProjectToBuild.Category)' == 'clr'">%(AdditionalProperties);Configuration=$(CoreCLRConfiguration)</AdditionalProperties>
      <AdditionalProperties Condition="'%(ProjectToBuild.Category)' == 'mono'">%(AdditionalProperties);Configuration=$(MonoConfiguration)</AdditionalProperties>
      <AdditionalProperties Condition="'%(ProjectToBuild.Category)' == 'libs'">%(AdditionalProperties);Configuration=$(LibrariesConfiguration)</AdditionalProperties>
      <AdditionalProperties Condition="'%(ProjectToBuild.Category)' == 'host'">%(AdditionalProperties);Configuration=$(HostConfiguration)</AdditionalProperties>
      <AdditionalProperties Condition="'%(ProjectToBuild.Category)' == 'tasks'">%(AdditionalProperties);Configuration=$(TasksConfiguration)</AdditionalProperties>
      <AdditionalProperties Condition="'%(ProjectToBuild.Category)' == 'tools'">%(AdditionalProperties);Configuration=$(ToolsConfiguration)</AdditionalProperties>

      <!-- Propagate configurations for cross-subset builds -->
      <AdditionalProperties>%(AdditionalProperties);RuntimeConfiguration=$(RuntimeConfiguration)</AdditionalProperties>
      <AdditionalProperties>%(AdditionalProperties);LibrariesConfiguration=$(LibrariesConfiguration)</AdditionalProperties>
      <AdditionalProperties>%(AdditionalProperties);HostConfiguration=$(HostConfiguration)</AdditionalProperties>
      <AdditionalProperties>%(AdditionalProperties);TasksConfiguration=$(TasksConfiguration)</AdditionalProperties>
      <AdditionalProperties>%(AdditionalProperties);ToolsConfiguration=$(ToolsConfiguration)</AdditionalProperties>
    </ProjectToBuild>
  </ItemGroup>

</Project>