[android] Enable android-arm CoreCLR with softfp ABI handling (#127578)

simonrozsival · Copilot · jkotas · web-flow · commit 1753549eda3f · 2026-05-19T23:48:23.000+02:00
> [!NOTE] > This PR description was updated with GitHub Copilot. Fixes #127500. ## Description This re-enables the `android-arm` CoreCLR runtime pack and CI coverage, and fixes the Android ARM softfp ABI handling needed for native code, ReadyToRun/Crossgen2-generated code, and NativeAOT target handling. Android `arm` maps to the `armeabi-v7a` ABI. That ABI can use VFP instructions internally, but floating-point arguments and return values cross function-call boundaries through core registers/stack rather than VFP argument registers. In .NET target terminology, the matching AOT/JIT ABI is `armel`. The original enablement exposed runtime crashes caused by parts of the build and code-generation pipeline disagreeing on that ABI. Native/CoreCLR builds needed `ARM_SOFTFP`, and AOT compiler target handling needed to treat Android ARM as Linux/Bionic with the softfp ABI. ## Changes - Re-enable `android-arm` as a supported CoreCLR runtime pack target. - Re-enable Android ARM CoreCLR legs in the runtime and extra-platform CI pipelines. - Add Android ARM Helix queue selection. - Set `ARM_SOFTFP` for Android ARM native/CoreCLR builds. - Treat Android ARM compile definitions as softfp when setting CoreCLR target definitions. - Keep Android as an accepted AOT command-line target OS without extending the internal `TargetOS` enum. - Centralize Android command-line normalization in both Crossgen2 and NativeAOT ILCompiler: ```text --targetos:android -> TargetOS.Linux --targetos:android --targetarch:arm -> NativeAotArmel / softfp ABI --targetos:android --targetarch:arm64 -> NativeAot ``` - Update Crossgen2 call sites to pass the real Android target identity instead of duplicating Android-to-Linux remaps in MSBuild. - Update NativeAOT build integration to pass `--targetos:android` through to ILCompiler while preserving the existing bionic ARM `armel` target-architecture handling. ## Validation Built Android ARM locally: ```sh ./build.sh clr+libs+host+packs -os android -arch arm -c Release ``` Result: ```text Build succeeded. 0 Warning(s) 0 Error(s) ``` Validated on a physical Android device with `armeabi-v7a` support. The following Android ARM test runs completed with zero failures with both `TestReadyToRun=true` and `TestReadyToRun=false`: - `System.Runtime.Tests` - `System.Runtime.Numerics.Tests` - `System.Numerics.Vectors.Tests` - `System.Numerics.Tensors.Tests` - `Microsoft.Bcl.Numerics.Tests` Additional validation for the centralized AOT target handling: ```sh ./build.sh clr+libs+host /p:RestoreDisableParallel=true ./dotnet.sh build src/coreclr/tools/aot/crossgen2/crossgen2.csproj /p:RestoreDisableParallel=true ./dotnet.sh build src/coreclr/tools/aot/ILCompiler/ILCompiler.csproj /p:RestoreDisableParallel=true ./dotnet.sh build src/tasks/Crossgen2Tasks/Crossgen2Tasks.csproj /p:RestoreDisableParallel=true ./build.sh tasks /p:RestoreDisableParallel=true ./dotnet.sh build src/coreclr/tools/aot/ILCompiler.TypeSystem.Tests/ILCompiler.TypeSystem.Tests.csproj /t:Test --no-restore ./dotnet.sh build src/coreclr/tools/aot/ILCompiler.Compiler.Tests/ILCompiler.Compiler.Tests.csproj /t:Test --no-restore ``` Also smoke-tested that both Crossgen2 and ILCompiler accept Android target arguments, including `--targetos:android --targetarch:arm` and `--targetos:android --targetarch:arm64`, and that the existing `--targetos:linux --targetarch:armel` normalization still works. --------- Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> Co-authored-by: Jan Kotas <jkotas@microsoft.com> Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>
diff --git a/eng/Subsets.props b/eng/Subsets.props
@@ -29,8 +29,7 @@
     <!-- 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>
+    <_CoreCLRSupportedOS Condition="'$(TargetsAndroid)' == 'true' and '$(TargetArchitecture)' != 'x86'">true</_CoreCLRSupportedOS>
     <_CoreCLRSupportedOS Condition="'$(TargetsBrowser)' == 'true'">true</_CoreCLRSupportedOS>
     <_CoreCLRSupportedOS Condition="'$(TargetsAppleMobile)' == 'true'">true</_CoreCLRSupportedOS>
 
diff --git a/eng/native/configureplatform.cmake b/eng/native/configureplatform.cmake
@@ -371,6 +371,10 @@ if(CLR_CMAKE_TARGET_OS STREQUAL android)
     set(CLR_CMAKE_TARGET_UNIX 1)
     set(CLR_CMAKE_TARGET_LINUX 1)
     set(CLR_CMAKE_TARGET_ANDROID 1)
+
+    if(CLR_CMAKE_TARGET_ARCH_ARM)
+        set(ARM_SOFTFP 1)
+    endif(CLR_CMAKE_TARGET_ARCH_ARM)
 endif(CLR_CMAKE_TARGET_OS STREQUAL android)
 
 if(CLR_CMAKE_TARGET_OS STREQUAL darwin)
diff --git a/eng/native/gen-buildsys.sh b/eng/native/gen-buildsys.sh
@@ -81,10 +81,6 @@ if [[ "$CROSSCOMPILE" == "1" ]]; then
     fi
 fi
 
-if [[ "$host_arch" == "armel" ]]; then
-    cmake_extra_defines="$cmake_extra_defines -DARM_SOFTFP=1"
-fi
-
 if ! cmake_command=$(command -v cmake); then
     echo "CMake was not found in PATH."
     exit 1
diff --git a/eng/pipelines/coreclr/templates/helix-queues-setup.yml b/eng/pipelines/coreclr/templates/helix-queues-setup.yml
@@ -46,6 +46,13 @@ jobs:
       - ${{ if eq(variables['System.TeamProject'], 'internal') }}:
         - OSX.15.Amd64
 
+    # Android arm
+    - ${{ if in(parameters.platform, 'android_arm') }}:
+      - ${{ if eq(variables['System.TeamProject'], 'public') }}:
+        - Windows.11.Amd64.Android-armel.Open
+      - ${{ if eq(variables['System.TeamProject'], 'internal') }}:
+        - Ubuntu.2204.Amd64.Android.29
+
     # Android arm64
     - ${{ if in(parameters.platform, 'android_arm64') }}:
       - ${{ if eq(variables['System.TeamProject'], 'public') }}:
diff --git a/eng/pipelines/extra-platforms/runtime-extra-platforms-android.yml b/eng/pipelines/extra-platforms/runtime-extra-platforms-android.yml
@@ -96,6 +96,7 @@ jobs:
     buildConfig: Release
     runtimeFlavor: coreclr
     platforms:
+    - android_arm
     - android_arm64
     variables:
       # map dependencies variables to local variables
diff --git a/eng/pipelines/libraries/helix-queues-setup.yml b/eng/pipelines/libraries/helix-queues-setup.yml
@@ -94,7 +94,9 @@ jobs:
       - Ubuntu.2204.Amd64.Android.29.Open
     - ${{ if and(ne(variables['System.TeamProject'], 'public'), in(parameters.platform, 'android_arm', 'android_arm64', 'linux_bionic_arm', 'linux_bionic_arm64')) }}:
       - Ubuntu.2204.Amd64.Android.29.Open
-    - ${{ if and(eq(variables['System.TeamProject'], 'public'), in(parameters.platform, 'android_arm', 'android_arm64', 'linux_bionic_arm', 'linux_bionic_arm64')) }}:
+    - ${{ if and(eq(variables['System.TeamProject'], 'public'), in(parameters.platform, 'android_arm', 'linux_bionic_arm')) }}:
+      - Windows.11.Amd64.Android-armel.Open
+    - ${{ if and(eq(variables['System.TeamProject'], 'public'), in(parameters.platform, 'android_arm64', 'linux_bionic_arm64')) }}:
       - Windows.11.Amd64.Android.Open
 
     # iOS Simulator/Mac Catalyst arm64
diff --git a/eng/pipelines/runtime.yml b/eng/pipelines/runtime.yml
@@ -1106,7 +1106,7 @@ extends:
                     eq(variables['isRollingBuild'], true))
 
       #
-      # Android arm64 devices and x64 emulators
+      # Android arm/arm64 devices and x64 emulators
       # Build the whole product using CoreCLR and run functional tests
       #
       - template: /eng/pipelines/common/platform-matrix.yml
@@ -1116,6 +1116,7 @@ extends:
           buildConfig: Release
           runtimeFlavor: coreclr
           platforms:
+          - android_arm
           - android_x64
           - android_arm64
           variables:
diff --git a/eng/testing/tests.readytorun.targets b/eng/testing/tests.readytorun.targets
@@ -3,14 +3,12 @@
   <Target Name="ResolveReadyToRunCompilers">
     <PropertyGroup>
       <Crossgen2Path>$([MSBuild]::NormalizePath('$(Crossgen2InBuildDir)', 'crossgen2$(ExeSuffix)'))</Crossgen2Path>
-      <_CrossGenTargetOS Condition="'$(TargetsAndroid)' != 'true'">$(TargetOS)</_CrossGenTargetOS>
-      <_CrossGenTargetOS Condition="'$(TargetsAndroid)' == 'true'">linux</_CrossGenTargetOS>
     </PropertyGroup>
 
     <ItemGroup>
       <Crossgen2Tool Include="$(Crossgen2Path)"
                      TargetArch="$(TargetArchitecture)"
-                     TargetOS="$(_CrossGenTargetOS)"
+                     TargetOS="$(TargetOS)"
                      PerfmapFormatVersion="$(PublishReadyToRunPerfmapFormatVersion)"/>
     </ItemGroup>
   </Target>
diff --git a/src/coreclr/clrdefinitions.cmake b/src/coreclr/clrdefinitions.cmake
@@ -292,8 +292,4 @@ function(set_target_definitions_to_custom_os_and_arch)
     target_compile_definitions(${TARGETDETAILS_TARGET} PRIVATE TARGET_WASM)
     target_compile_definitions(${TARGETDETAILS_TARGET} PRIVATE TARGET_WASM32)
   endif()
-
-  if (TARGETDETAILS_ARCH STREQUAL "armel")
-    target_compile_definitions(${TARGETDETAILS_TARGET} PRIVATE ARM_SOFTFP)
-  endif()
 endfunction()
diff --git a/src/coreclr/crossgen-corelib.proj b/src/coreclr/crossgen-corelib.proj
@@ -159,9 +159,7 @@
       <CrossGenDllCmd Condition="'$(PublishReadyToRunContainerFormat)' != ''">$(CrossGenDllCmd) --obj-format:$(PublishReadyToRunContainerFormat)</CrossGenDllCmd>
       <CrossGenDllCmd Condition="'$(PublishReadyToRunContainerFormat)' == 'wasm'">$(CrossGenDllCmd) --codegenopt:JitWasmNyiToR2RUnsupported=1</CrossGenDllCmd>
       <CrossGenDllCmd Condition="'$(UseComposite)' == 'true'">$(CrossGenDllCmd) --composite</CrossGenDllCmd>
-      <CrossGenDllCmd Condition="'$(TargetsAndroid)' != 'true'">$(CrossGenDllCmd) --targetos:$(TargetOS)</CrossGenDllCmd>
-      <!-- Unless and until Android requires R2R specific customizations, we're just dealing with another linux -->
-      <CrossGenDllCmd Condition="'$(TargetsAndroid)' == 'true'">$(CrossGenDllCmd) --targetos:linux</CrossGenDllCmd>
+      <CrossGenDllCmd>$(CrossGenDllCmd) --targetos:$(TargetOS)</CrossGenDllCmd>
       <CrossGenDllCmd Condition="'$(UsingToolIbcOptimization)' != 'true' and '$(EnableNgenOptimization)' == 'true'">$(CrossGenDllCmd) -m:$(MergedMibcPath) --embed-pgo-data</CrossGenDllCmd>
       <CrossGenDllCmd>$(CrossGenDllCmd) -O</CrossGenDllCmd>
       <!-- Enable type and field layout verification to make it easier to catch when the crossgen2 type layout engine and the runtime disagree on layout conventions -->
diff --git a/src/coreclr/jit/CMakeLists.txt b/src/coreclr/jit/CMakeLists.txt
@@ -731,7 +731,7 @@ if (CLR_CMAKE_TARGET_ARCH_RISCV64)
   create_standalone_jit(TARGET clrjit_unix_riscv64_${ARCH_HOST_NAME} OS unix ARCH riscv64)
 else()
   create_standalone_jit(TARGET clrjit_universal_arm_${ARCH_HOST_NAME} OS universal ARCH arm)
-  target_compile_definitions(clrjit_universal_arm_${ARCH_HOST_NAME} PRIVATE ARM_SOFTFP CONFIGURABLE_ARM_ABI)
+  target_compile_definitions(clrjit_universal_arm_${ARCH_HOST_NAME} PRIVATE CONFIGURABLE_ARM_ABI)
   create_standalone_jit(TARGET clrjit_win_x86_${ARCH_HOST_NAME} OS win ARCH x86)
 endif (CLR_CMAKE_TARGET_ARCH_RISCV64)
 
diff --git a/src/coreclr/nativeaot/BuildIntegration/Microsoft.NETCore.Native.targets b/src/coreclr/nativeaot/BuildIntegration/Microsoft.NETCore.Native.targets
@@ -215,9 +215,7 @@ The .NET Foundation licenses this file to you under the MIT license.
       <IlcArg Include="@(IlcSatelliteAssembly->'--satellite:%(Identity)')" />
       <IlcArg Include="@(MibcFile->'--mibc:%(Identity)')" />
       <IlcArg Condition="$(IlcGenerateMetadataLog) == 'true'" Include="--metadatalog:$(NativeIntermediateOutputPath)%(ManagedBinary.Filename).metadata.csv" />
-      <!-- To the NativeAOT compiler, Android is just another linux -->
-      <IlcArg Condition="'$(_targetOS)' == 'android'" Include="--targetos:linux" />
-      <IlcArg Condition="'$(_targetOS)' != '' and '$(_targetOS)' != 'android'" Include="--targetos:$(_targetOS)" />
+      <IlcArg Condition="'$(_targetOS)' != ''" Include="--targetos:$(_targetOS)" />
       <IlcArg Condition="$(_targetArchitectureWithAbi) != ''" Include="--targetarch:$(_targetArchitectureWithAbi)" />
       <IlcArg Condition="$(IlcMultiModule) == 'true'" Include="--multifile" />
       <IlcArg Condition="$(IlcMultiModule) != 'true' and '$(IlcDehydrate)' != 'false' and ($(_targetOS) != 'win' or '$(OptimizationPreference)' == 'Size' or '$(IlcDehydrate)' == 'true')" Include="--dehydrate" />
diff --git a/src/coreclr/tools/Common/CommandLineHelpers.cs b/src/coreclr/tools/Common/CommandLineHelpers.cs
@@ -25,6 +25,9 @@ internal static partial class Helpers
     {
         public const string DefaultSystemModule = "System.Private.CoreLib";
 
+        public static string[] ValidOS { get; } = ["windows", "linux", "freebsd", "osx", "maccatalyst", "ios", "iossimulator", "tvos", "tvossimulator", "android", "browser", "wasi"];
+        public static string[] ValidArchitectures { get; } = ["arm", "armel", "arm64", "x86", "x64", "riscv64", "loongarch64", "wasm"];
+
         public static Dictionary<string, string> BuildPathDictionary(IReadOnlyList<Token> tokens, bool strict)
         {
             Dictionary<string, string> dictionary = new(StringComparer.OrdinalIgnoreCase);
@@ -73,7 +76,7 @@ public static TargetOS GetTargetOS(string token)
 
             return token.ToLowerInvariant() switch
             {
-                "linux" => TargetOS.Linux,
+                "linux" or "android" => TargetOS.Linux,
                 "win" or "windows" => TargetOS.Windows,
                 "osx" => TargetOS.OSX,
                 "freebsd" => TargetOS.FreeBSD,
@@ -120,6 +123,23 @@ public static TargetArchitecture GetTargetArchitecture(string token)
             }
         }
 
+        public static (TargetArchitecture, TargetOS, TargetAbi) GetTargetSpec(string targetArchitectureToken, string targetOSToken)
+        {
+            targetArchitectureToken = targetArchitectureToken?.ToLowerInvariant();
+            targetOSToken = targetOSToken?.ToLowerInvariant();
+
+            TargetArchitecture targetArchitecture = GetTargetArchitecture(targetArchitectureToken);
+            TargetOS targetOS = GetTargetOS(targetOSToken);
+            TargetAbi targetAbi = (targetOSToken, targetArchitectureToken) switch
+            {
+                (_, "armel") => TargetAbi.NativeAotArmel,
+                ("android", "arm") => TargetAbi.NativeAotArmel,
+                _ => TargetAbi.NativeAot,
+            };
+
+            return (targetArchitecture, targetOS, targetAbi);
+        }
+
         public static RootCommand UseVersion(this RootCommand command)
         {
             for (int i = 0; i < command.Options.Count; i++)
diff --git a/src/coreclr/tools/aot/ILCompiler/ILCompilerRootCommand.cs b/src/coreclr/tools/aot/ILCompiler/ILCompilerRootCommand.cs
@@ -160,10 +160,10 @@ internal sealed class ILCompilerRootCommand : RootCommand
             new("--trim") { DefaultValueFactory = _ => Array.Empty<string>(), Description = "Trim the specified assembly" };
         public Option<bool> RootDefaultAssemblies { get; } =
             new("--defaultrooting") { Description = "Root assemblies that are not marked [IsTrimmable]" };
-        public Option<TargetArchitecture> TargetArchitecture { get; } =
-            new("--targetarch") { CustomParser = MakeTargetArchitecture, DefaultValueFactory = MakeTargetArchitecture, Description = "Target architecture for cross compilation", HelpName = "arg" };
-        public Option<TargetOS> TargetOS { get; } =
-            new("--targetos") { CustomParser = result => Helpers.GetTargetOS(result.Tokens.Count > 0 ? result.Tokens[0].Value : null), DefaultValueFactory = result => Helpers.GetTargetOS(result.Tokens.Count > 0 ? result.Tokens[0].Value : null), Description = "Target OS for cross compilation", HelpName = "arg" };
+        public Option<string> TargetArchitecture { get; } =
+            new("--targetarch") { Description = "Target architecture for cross compilation" };
+        public Option<string> TargetOS { get; } =
+            new("--targetos") { Description = "Target OS for cross compilation" };
         public Option<string> JitPath { get; } =
             new("--jitpath") { Description = "Path to JIT compiler library" };
         public Option<string> SingleMethodTypeName { get; } =
@@ -187,8 +187,6 @@ internal sealed class ILCompilerRootCommand : RootCommand
 
         public OptimizationMode OptimizationMode { get; private set; }
         public ParseResult Result;
-        public static bool IsArmel { get; private set; }
-
         public ILCompilerRootCommand(string[] args) : base(".NET Native IL Compiler")
         {
             Arguments.Add(InputFilePaths);
@@ -349,20 +347,17 @@ public static void PrintExtendedHelp(ParseResult _)
             Console.WriteLine("Use the '--' option to disambiguate between input files that have begin with -- and options. After a '--' option, all arguments are " +
                 "considered to be input files. If no input files begin with '--' then this option is not necessary.\n");
 
-            string[] ValidArchitectures = new string[] { "arm", "arm64", "x86", "x64", "riscv64", "loongarch64" };
-            string[] ValidOS = new string[] { "windows", "linux", "freebsd", "osx", "maccatalyst", "ios", "iossimulator", "tvos", "tvossimulator" };
-
-            Console.WriteLine("Valid switches for {0} are: '{1}'. The default value is '{2}'\n", "--targetos", string.Join("', '", ValidOS), Helpers.GetTargetOS(null).ToString().ToLowerInvariant());
+            Console.WriteLine("Valid switches for {0} are: '{1}'. The default value is '{2}'\n", "--targetos", string.Join("', '", Helpers.ValidOS), Helpers.GetTargetOS(null).ToString().ToLowerInvariant());
 
-            Console.WriteLine(string.Format("Valid switches for {0} are: '{1}'. The default value is '{2}'\n", "--targetarch", string.Join("', '", ValidArchitectures), Helpers.GetTargetArchitecture(null).ToString().ToLowerInvariant()));
+            Console.WriteLine(string.Format("Valid switches for {0} are: '{1}'. The default value is '{2}'\n", "--targetarch", string.Join("', '", Helpers.ValidArchitectures), Helpers.GetTargetArchitecture(null).ToString().ToLowerInvariant()));
 
             Console.WriteLine("The allowable values for the --instruction-set option are described in the table below. Each architecture has a different set of valid " +
                 "instruction sets, and multiple instruction sets may be specified by separating the instructions sets by a ','. By default other instruction sets not " +
                 "specified may light-up optimistically via dynamic checks. Individual instruction sets can be disallowed from such light-up by prefixing them with '-'. " +
                 "All such light-up can be disallowed by specifying '-optimistic'. The instruction sets supported by the machine invoking the tool can be targeted by " +
                 "specifying 'native'. For example 'native', 'avx,aes', 'avx,aes,-avx2', or 'avx,aes,-optimistic'");
 
-            foreach (string arch in ValidArchitectures)
+            foreach (string arch in Helpers.ValidArchitectures)
             {
                 TargetArchitecture targetArch = Helpers.GetTargetArchitecture(arch);
                 bool first = true;
@@ -395,18 +390,6 @@ public static void PrintExtendedHelp(ParseResult _)
             Console.WriteLine(string.Join(", ", Internal.JitInterface.InstructionSetFlags.AllCpuNames));
         }
 
-        private static TargetArchitecture MakeTargetArchitecture(ArgumentResult result)
-        {
-            string firstToken = result.Tokens.Count > 0 ? result.Tokens[0].Value : null;
-            if (firstToken != null && firstToken.Equals("armel", StringComparison.OrdinalIgnoreCase))
-            {
-                IsArmel = true;
-                return Internal.TypeSystem.TargetArchitecture.ARM;
-            }
-
-            return Helpers.GetTargetArchitecture(firstToken);
-        }
-
         private static int MakeParallelism(ArgumentResult result)
         {
             if (result.Tokens.Count > 0)
diff --git a/src/coreclr/tools/aot/ILCompiler/Program.cs b/src/coreclr/tools/aot/ILCompiler/Program.cs
@@ -104,8 +104,8 @@ public int Run()
             // directly encoded as part of the required ISAs.
             bool isVectorTOptimistic = false;
 
-            TargetArchitecture targetArchitecture = Get(_command.TargetArchitecture);
-            TargetOS targetOS = Get(_command.TargetOS);
+            (TargetArchitecture targetArchitecture, TargetOS targetOS, TargetAbi targetAbi) =
+                Helpers.GetTargetSpec(Get(_command.TargetArchitecture), Get(_command.TargetOS));
             InstructionSetSupport instructionSetSupport = Helpers.ConfigureInstructionSetSupport(Get(_command.InstructionSet), Get(_command.MaxVectorTBitWidth), isVectorTOptimistic, targetArchitecture, targetOS,
                 "Unrecognized instruction set {0}", "Unsupported combination of instruction sets: {0}/{1}", logger,
                 allowOptimistic: _command.OptimizationMode != OptimizationMode.PreferSize,
@@ -122,7 +122,6 @@ public int Run()
             SharedGenericsMode genericsMode = SharedGenericsMode.CanonicalReferenceTypes;
 
             var simdVectorLength = instructionSetSupport.GetVectorTSimdVector();
-            var targetAbi = ILCompilerRootCommand.IsArmel ? TargetAbi.NativeAotArmel : TargetAbi.NativeAot;
             var targetDetails = new TargetDetails(targetArchitecture, targetOS, targetAbi, simdVectorLength);
             CompilerTypeSystemContext typeSystemContext =
                 new CompilerTypeSystemContext(targetDetails, genericsMode, supportsReflection ? DelegateFeature.All : 0,
diff --git a/src/coreclr/tools/aot/crossgen2/Crossgen2RootCommand.cs b/src/coreclr/tools/aot/crossgen2/Crossgen2RootCommand.cs
diff --git a/src/coreclr/tools/aot/crossgen2/Program.cs b/src/coreclr/tools/aot/crossgen2/Program.cs
diff --git a/src/installer/pkg/sfx/Microsoft.NETCore.App/Microsoft.NETCore.App.Runtime.CoreCLR.sfxproj b/src/installer/pkg/sfx/Microsoft.NETCore.App/Microsoft.NETCore.App.Runtime.CoreCLR.sfxproj
diff --git a/src/mono/msbuild/android/build/AndroidBuild.InTree.targets b/src/mono/msbuild/android/build/AndroidBuild.InTree.targets
diff --git a/src/tasks/Crossgen2Tasks/ResolveReadyToRunCompilers.cs b/src/tasks/Crossgen2Tasks/ResolveReadyToRunCompilers.cs
