From 94d073aef3b416a1120a087bc9335de2f1689459 Mon Sep 17 00:00:00 2001
From: Jonathan Peppers <jonathan.peppers@microsoft.com>
Date: Fri, 22 Jan 2021 10:26:52 -0600
Subject: [PATCH 1/2] [One .NET] AOT support
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Fixes: https://github.com/xamarin/xamarin-android/issues/6052

Helpful reading:

* https://github.com/dotnet/runtime/blob/15dec9a2aa5a4236d6ba70de2e9c146867b9d2e0/src/tasks/AotCompilerTask/MonoAOTCompiler.cs
* https://github.com/dotnet/runtime/blob/15dec9a2aa5a4236d6ba70de2e9c146867b9d2e0/src/mono/netcore/nuget/Microsoft.NET.Runtime.MonoAOTCompiler.Task/README.md

To make this work, I moved the existing `<Aot/>` MSBuild task calls to
a new `_AndroidAot` MSBuild target in `Xamarin.Android.Legacy.targets`.

In the .NET 6 targets, there is a *different* `_AndroidAot` MSBuild
target that runs the new `<MonoAOTCompiler/>` MSBuild task. The
`_AndroidAot` target runs per `$(RuntimeIdentifier)` after the linker
completes. Native libraries are added to the
`@(ResolvedFileToPublish)` item group to be included in the final
`.apk`.

To follow convention with Blazor WASM:

https://devblogs.microsoft.com/aspnet/asp-net-core-updates-in-net-6-preview-4/#blazor-webassembly-ahead-of-time-aot-compilation

The `$(RunAOTCompilation)` MSBuild property enables AOT. To help with
backwards compatibility with "legacy" Xamarin.Android, I kept the
`$(AotAssemblies)` MSBuild property intact.

Unfortunately, we have to manually import things to support
`$(AotAssemblies)`:

    <ImportGroup Condition=" '$(MonoAOTCompilerTasksAssemblyPath)' == '' and '$(AotAssemblies)' == 'true' ">
      <Import Project="Sdk.props" Sdk="Microsoft.NET.Runtime.MonoAOTCompiler.Task" />
      <Import Project="Sdk.props" Sdk="Microsoft.NETCore.App.Runtime.AOT.Cross.android-x86" />
      <Import Project="Sdk.props" Sdk="Microsoft.NETCore.App.Runtime.AOT.Cross.android-x64" />
      <Import Project="Sdk.props" Sdk="Microsoft.NETCore.App.Runtime.AOT.Cross.android-arm" />
      <Import Project="Sdk.props" Sdk="Microsoft.NETCore.App.Runtime.AOT.Cross.android-arm64" />
    </ImportGroup>

Since, the default Mono workload does not support `$(AotAssemblies)`:

https://github.com/dotnet/runtime/blob/69711860262e44458bbe276393ea3eb9f7a2192a/src/mono/nuget/Microsoft.NET.Workload.Mono.Toolchain.Manifest/WorkloadManifest.targets.in#L20-L25

I think this is reasonable for now.

~~ Limitations ~~

* Profiled AOT is not implemented yet:

https://github.com/xamarin/xamarin-android/issues/6053

* `$(EnableLLVM)` fails when locating `opt`:

https://github.com/dotnet/runtime/issues/56386

* `AndroidClientHandler` usage causes runtime crash:

https://github.com/dotnet/runtime/issues/56315

* Use of folder names like `Build AndÜmläüts` fails:

https://github.com/dotnet/runtime/issues/56163

~~ Results ~~

All tests were running on a Pixel 5.

Using the HelloAndroid app:

https://github.com/dotnet/maui-samples/tree/main/HelloAndroid

Defaults to two architectures: arm64 and x86

Average of 10 runs with `-c Release` and no AOT:

    Activity: Displayed     00:00:00.308

Apk size: 8367969

Average of 10 runs with `-c Release -p:RunAOTCompilation=true`:

    Activity: Displayed     00:00:00.209

Apk size: 12082123

Using the HelloMaui app:

https://github.com/dotnet/maui-samples/tree/main/HelloMaui

Defaults to two architectures: arm64 and x86

Average of 10 runs with `-c Release` and no AOT:

    Activity: Displayed     00:00:01.117

Apk size: 16272964

Average of 10 runs with `-c Release -p:RunAOTCompilation=true`:

    Activity: Displayed     00:00:00.568

Apk size: 42869016
---
 Documentation/guides/OneDotNet.md             |  12 +
 .../GenerateSupportedPlatforms.cs             |   4 +
 build-tools/automation/azure-pipelines.yaml   |  14 +-
 .../Microsoft.Android.Sdk.After.targets       |   1 +
 .../targets/Microsoft.Android.Sdk.Aot.targets |  87 ++++++
 ...oft.Android.Sdk.AssemblyResolution.targets |   2 +-
 ...soft.Android.Sdk.DefaultProperties.targets |   3 +
 src/Xamarin.Android.Build.Tasks/Tasks/Aot.cs  | 194 +------------
 .../Tasks/BuildApk.cs                         |   6 +-
 .../Tasks/CilStrip.cs                         |   4 +-
 .../Tasks/GetAotArguments.cs                  | 272 ++++++++++++++++++
 .../Xamarin.Android.Build.Tests/AotTests.cs   |  22 +-
 .../IncrementalBuildTest.cs                   |   2 +
 .../Utilities/BaseTest.cs                     |  15 +
 .../Xamarin.Android.Build.Tests/XASdkTests.cs |  28 +-
 .../Xamarin.Android.Common.targets            |  62 ----
 .../Xamarin.Android.Legacy.targets            |  71 +++++
 .../Tests/AotProfileTests.cs                  |   2 +-
 18 files changed, 539 insertions(+), 262 deletions(-)
 create mode 100644 src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.Aot.targets
 create mode 100644 src/Xamarin.Android.Build.Tasks/Tasks/GetAotArguments.cs

diff --git a/Documentation/guides/OneDotNet.md b/Documentation/guides/OneDotNet.md
index c3619205f5b..09b2cf4cbdc 100644
--- a/Documentation/guides/OneDotNet.md
+++ b/Documentation/guides/OneDotNet.md
@@ -164,6 +164,18 @@ It is recommended to migrate to the new linker settings, as
 [linker]: https://docs.microsoft.com/dotnet/core/deploying/trimming-options
 [linker-full]: https://docs.microsoft.com/dotnet/core/deploying/trimming-options#trimmed-assemblies
 
+## AOT
+
+`$(RunAOTCompilation)` will be the new MSBuild property for enabling
+AOT. This is the same property used for [Blazor WASM][blazor].
+`$(AotAssemblies)` will also enable AOT, in order to help with
+migration from "legacy" Xamarin.Android to .NET 6.
+
+It is recommended to migrate to the new `$(RunAOTCompilation)`
+property, as `$(AotAssemblies)` will eventually be deprecated.
+
+[blazor]: https://devblogs.microsoft.com/aspnet/asp-net-core-updates-in-net-6-preview-4/#blazor-webassembly-ahead-of-time-aot-compilation
+
 ## dotnet cli
 
 There are currently a few "verbs" we are aiming to get working in
diff --git a/build-tools/Xamarin.Android.Tools.BootstrapTasks/Xamarin.Android.Tools.BootstrapTasks/GenerateSupportedPlatforms.cs b/build-tools/Xamarin.Android.Tools.BootstrapTasks/Xamarin.Android.Tools.BootstrapTasks/GenerateSupportedPlatforms.cs
index fb491f744dc..57205c01fda 100644
--- a/build-tools/Xamarin.Android.Tools.BootstrapTasks/Xamarin.Android.Tools.BootstrapTasks/GenerateSupportedPlatforms.cs
+++ b/build-tools/Xamarin.Android.Tools.BootstrapTasks/Xamarin.Android.Tools.BootstrapTasks/GenerateSupportedPlatforms.cs
@@ -64,6 +64,10 @@ public override bool Execute ()
 				writer.WriteAttributeString ("Condition", " '$(TargetPlatformVersion)' == '' ");
 				writer.WriteString (versions.MaxStableVersion.ApiLevel.ToString ("0.0", CultureInfo.InvariantCulture));
 				writer.WriteEndElement (); // </TargetPlatformVersion>
+				writer.WriteStartElement ("AndroidMinimumSupportedApiLevel");
+				writer.WriteAttributeString ("Condition", " '$(AndroidMinimumSupportedApiLevel)' == '' ");
+				writer.WriteString (MinimumApiLevel.ToString ());
+				writer.WriteEndElement (); // </AndroidMinimumSupportedApiLevel>
 				writer.WriteEndElement (); // </PropertyGroup>
 
 				writer.WriteStartElement ("ItemGroup");
diff --git a/build-tools/automation/azure-pipelines.yaml b/build-tools/automation/azure-pipelines.yaml
index aa8585666cb..3df4deb4a93 100644
--- a/build-tools/automation/azure-pipelines.yaml
+++ b/build-tools/automation/azure-pipelines.yaml
@@ -49,7 +49,7 @@ variables:
   # - This is a non-fork branch with name containing "mono-" (for Mono bumps)
   IsMonoBranch: $[and(ne(variables['System.PullRequest.IsFork'], 'True'), or(contains(variables['Build.SourceBranchName'], 'mono-'), contains(variables['System.PullRequest.SourceBranch'], 'mono-')))]
   RunAllTests: $[or(eq(variables['XA.RunAllTests'], true), eq(variables['IsMonoBranch'], true))]
-  DotNetNUnitCategories: '& TestCategory != DotNetIgnore & TestCategory != AOT & TestCategory != MkBundle & TestCategory != MonoSymbolicate & TestCategory != PackagesConfig & TestCategory != StaticProject & TestCategory != Debugger & TestCategory != SystemApplication'
+  DotNetNUnitCategories: '& TestCategory != DotNetIgnore & TestCategory != HybridAOT & TestCategory != ProfiledAOT & TestCategory != LLVM & TestCategory != MkBundle & TestCategory != MonoSymbolicate & TestCategory != PackagesConfig & TestCategory != StaticProject & TestCategory != Debugger & TestCategory != SystemApplication'
   NUnit.NumberOfTestWorkers: 4
   GitHub.Token: $(github--pat--vs-mobiletools-engineering-service2)
   CONVERT_JAVADOC_TO_XMLDOC: $[ne(variables['Build.DefinitionName'], 'Xamarin.Android-PR')]
@@ -798,6 +798,18 @@ stages:
         artifactFolder: net6-Interpreter
         useDotNet: true
 
+    - template: yaml-templates/apk-instrumentation.yaml
+      parameters:
+        configuration: $(XA.Build.Configuration)
+        testName: Mono.Android.NET_Tests-Aot
+        project: tests/Mono.Android-Tests/Runtime-Microsoft.Android.Sdk/Mono.Android.NET-Tests.csproj
+        testResultsFiles: TestResult-Mono.Android.NET_Tests-$(XA.Build.Configuration)-Aot.xml
+        # InetAccess excluded due to: https://github.com/dotnet/runtime/issues/56315
+        extraBuildArgs: /p:RunAOTCompilation=true /p:ExcludeCategories=InetAccess
+        artifactSource: bin/Test$(XA.Build.Configuration)/net6.0-android/Mono.Android.NET_Tests-Signed.apk
+        artifactFolder: net6-aot
+        useDotNet: true
+
     - task: MSBuild@1
       displayName: shut down emulator
       inputs:
diff --git a/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.After.targets b/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.After.targets
index 1e2b90a1f16..15f83d483ef 100644
--- a/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.After.targets
+++ b/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.After.targets
@@ -18,6 +18,7 @@ This file is imported *after* the Microsoft.NET.Sdk/Sdk.targets.
   <Import Project="..\tools\Xamarin.Android.Bindings.Core.targets" />
   <Import Project="..\tools\Xamarin.Android.Bindings.ClassParse.targets" />
   <Import Project="Microsoft.Android.Sdk.AndroidLibraries.targets" />
+  <Import Project="Microsoft.Android.Sdk.Aot.targets"         Condition=" '$(AndroidApplication)' == 'true' " />
   <Import Project="Microsoft.Android.Sdk.Application.targets" Condition=" '$(AndroidApplication)' == 'true' " />
   <Import Project="Microsoft.Android.Sdk.AssemblyResolution.targets" />
   <Import Project="Microsoft.Android.Sdk.ILLink.targets" />
diff --git a/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.Aot.targets b/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.Aot.targets
new file mode 100644
index 00000000000..705affcc8b0
--- /dev/null
+++ b/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.Aot.targets
@@ -0,0 +1,87 @@
+<!--
+***********************************************************************************************
+Microsoft.Android.Sdk.Aot.targets
+
+.NET 6 AOT support. You can find "legacy" Xamarin.Android AOT support
+in Xamarin.Android.Legacy.targets.
+
+For <MonoAOTCompiler/> usage, see:
+* https://github.com/dotnet/runtime/blob/15dec9a2aa5a4236d6ba70de2e9c146867b9d2e0/src/tasks/AotCompilerTask/MonoAOTCompiler.cs
+* https://github.com/dotnet/runtime/blob/15dec9a2aa5a4236d6ba70de2e9c146867b9d2e0/src/mono/netcore/nuget/Microsoft.NET.Runtime.MonoAOTCompiler.Task/README.md
+
+These targets are running within the _ComputeFilesToPublishForRuntimeIdentifiers target.
+They run in a context of an inner build with a single $(RuntimeIdentifier).
+
+***********************************************************************************************
+-->
+<Project>
+
+  <!--
+    NOTE: currently, the only way to allow $(AotAssemblies) in
+    .csproj files is to import these in the Android workload
+    when $(MonoAOTCompilerTasksAssemblyPath) is blank:
+    https://github.com/dotnet/runtime/blob/69711860262e44458bbe276393ea3eb9f7a2192a/src/mono/nuget/Microsoft.NET.Workload.Mono.Toolchain.Manifest/WorkloadManifest.targets.in#L20-L25
+  -->
+  <ImportGroup Condition=" '$(MonoAOTCompilerTasksAssemblyPath)' == '' and '$(AotAssemblies)' == 'true' ">
+    <Import Project="Sdk.props" Sdk="Microsoft.NET.Runtime.MonoAOTCompiler.Task" />
+    <Import Project="Sdk.props" Sdk="Microsoft.NETCore.App.Runtime.AOT.Cross.android-x86" />
+    <Import Project="Sdk.props" Sdk="Microsoft.NETCore.App.Runtime.AOT.Cross.android-x64" />
+    <Import Project="Sdk.props" Sdk="Microsoft.NETCore.App.Runtime.AOT.Cross.android-arm" />
+    <Import Project="Sdk.props" Sdk="Microsoft.NETCore.App.Runtime.AOT.Cross.android-arm64" />
+  </ImportGroup>
+
+  <UsingTask TaskName="Xamarin.Android.Tasks.GetAotArguments" AssemblyFile="$(_XamarinAndroidBuildTasksAssembly)" />
+
+  <Target Name="_AndroidAotInputs">
+    <ItemGroup>
+      <_AndroidAotInputs Include="@(ResolvedFileToPublish)" Condition=" '%(Extension)' == '.dll' " />
+    </ItemGroup>
+  </Target>
+
+  <Target Name="_AndroidAot"
+      Condition=" '$(AotAssemblies)' == 'true' and '$(RuntimeIdentifier)' != '' "
+      DependsOnTargets="_AndroidAotInputs"
+      Inputs="@(_AndroidAotInputs)"
+      Outputs="$(_AndroidStampDirectory)_AndroidAot.stamp">
+    <GetAotArguments
+        AndroidAotMode="$(AndroidAotMode)"
+        AndroidNdkDirectory="$(_AndroidNdkDirectory)"
+        AndroidBinUtilsDirectory="$(AndroidBinUtilsDirectory)"
+        AndroidApiLevel="$(_AndroidApiLevel)"
+        MinimumSupportedApiLevel="$(AndroidMinimumSupportedApiLevel)"
+        AndroidSequencePointsMode="$(_SequencePointsMode)"
+        AotAdditionalArguments="$(AndroidAotAdditionalArguments)"
+        AotOutputDirectory="$(_AndroidAotBinDirectory)"
+        RuntimeIdentifier="$(RuntimeIdentifier)"
+        EnableLLVM="$(EnableLLVM)"
+        Profiles="@(_AotProfiles)">
+      <Output PropertyName="_AotArguments" TaskParameter="Arguments" />
+      <Output PropertyName="_LLVMPath" TaskParameter="LLVMPath" />
+    </GetAotArguments>
+    <ItemGroup>
+      <_MonoAOTAssemblies Include="@(_AndroidAotInputs->'%(FullPath)')" AotArguments="$(_AotArguments)" />
+    </ItemGroup>
+    <MakeDir Directories="$(IntermediateOutputPath)aot\" />
+    <MonoAOTCompiler
+        Assemblies="@(_MonoAOTAssemblies)"
+        CompilerBinaryPath="@(MonoAotCrossCompiler->WithMetadataValue('RuntimeIdentifier', '$(RuntimeIdentifier)'))"
+        DisableParallelAot="$(_DisableParallelAot)"
+        LibraryFormat="So"
+        Mode="$(AndroidAotMode)"
+        OutputDir="$(IntermediateOutputPath)aot\"
+        OutputType="Library"
+        UseAotDataFile="false"
+        UseLLVM="$(EnableLLVM)"
+        LLVMPath="$(_LLVMPath)">
+      <Output TaskParameter="CompiledAssemblies" ItemName="_AotCompiledAssemblies" />
+      <Output TaskParameter="FileWrites"         ItemName="FileWrites" />
+    </MonoAOTCompiler>
+    <Touch Files="$(_AndroidStampDirectory)_AndroidAot.stamp" AlwaysCreate="true" />
+    <ItemGroup>
+      <ResolvedFileToPublish
+          Include="@(_AotCompiledAssemblies->'%(LibraryFile)')"
+          ArchiveFileName="libaot-$([System.IO.Path]::GetFileNameWithoutExtension('%(_AotCompiledAssemblies.LibraryFile)')).so"
+      />
+    </ItemGroup>
+  </Target>
+</Project>
diff --git a/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.AssemblyResolution.targets b/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.AssemblyResolution.targets
index ad39e5f3823..de356268f77 100644
--- a/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.AssemblyResolution.targets
+++ b/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.AssemblyResolution.targets
@@ -31,7 +31,7 @@ _ResolveAssemblies MSBuild target.
   </PropertyGroup>
 
   <Target Name="_ComputeFilesToPublishForRuntimeIdentifiers"
-      DependsOnTargets="_FixupIntermediateAssembly;ResolveReferences;ComputeFilesToPublish"
+      DependsOnTargets="_FixupIntermediateAssembly;ResolveReferences;ComputeFilesToPublish;_AndroidAot"
       Returns="@(ResolvedFileToPublish)">
       <ItemGroup>
         <ResolvedFileToPublish
diff --git a/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.DefaultProperties.targets b/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.DefaultProperties.targets
index b8412b4b9bb..73154e0f4b2 100644
--- a/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.DefaultProperties.targets
+++ b/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.DefaultProperties.targets
@@ -68,6 +68,9 @@
     <AndroidManifest Condition=" '$(AndroidManifest)' == '' and Exists ('Properties\AndroidManifest.xml') and !Exists ('AndroidManifest.xml') ">Properties\AndroidManifest.xml</AndroidManifest>
     <AndroidManifest Condition=" '$(AndroidManifest)' == '' ">AndroidManifest.xml</AndroidManifest>
     <GenerateApplicationManifest Condition=" '$(GenerateApplicationManifest)' == '' ">true</GenerateApplicationManifest>
+    <RunAOTCompilation Condition=" '$(RunAOTCompilation)' == '' and '$(AotAssemblies)' == 'true' ">true</RunAOTCompilation>
+    <RunAOTCompilation Condition=" '$(RunAOTCompilation)' == '' ">false</RunAOTCompilation>
+    <AotAssemblies>$(RunAOTCompilation)</AotAssemblies>
 
     <!--
       Runtime libraries feature switches defaults
diff --git a/src/Xamarin.Android.Build.Tasks/Tasks/Aot.cs b/src/Xamarin.Android.Build.Tasks/Tasks/Aot.cs
index 246fc8bd50a..34c14cd8cef 100644
--- a/src/Xamarin.Android.Build.Tasks/Tasks/Aot.cs
+++ b/src/Xamarin.Android.Build.Tasks/Tasks/Aot.cs
@@ -1,10 +1,8 @@
 using System;
 using System.Collections.Generic;
-using System.Collections.Specialized;
 using System.Diagnostics;
 using System.IO;
 using System.Linq;
-using System.Reflection;
 using System.Text;
 using System.Threading;
 using Microsoft.Build.Framework;
@@ -33,21 +31,10 @@ public enum SequencePointsMode {
 	}
 
 	// can't be a single ToolTask, because it has to run mkbundle many times for each arch.
-	public class Aot : AndroidAsyncTask
+	public class Aot : GetAotArguments
 	{
 		public override string TaskPrefix => "AOT";
 
-		[Required]
-		public string AndroidAotMode { get; set; }
-
-		public string AndroidNdkDirectory { get; set; }
-
-		[Required]
-		public string AndroidApiLevel { get; set; }
-
-		[Required]
-		public ITaskItem ManifestFile { get; set; }
-
 		[Required]
 		public ITaskItem[] ResolvedAssemblies { get; set; }
 
@@ -55,80 +42,18 @@ public class Aot : AndroidAsyncTask
 		[Required]
 		public string [] SupportedAbis { get; set; }
 
-		[Required]
-		public string AotOutputDirectory { get; set; }
-
 		[Required]
 		public string IntermediateAssemblyDir { get; set; }
 
 		public string LinkMode { get; set; }
 
-		public bool EnableLLVM { get; set; }
-
-		public string AndroidSequencePointsMode { get; set; }
-
-		public string AotAdditionalArguments { get; set; }
-
 		public ITaskItem[] AdditionalNativeLibraryReferences { get; set; }
 
 		public string ExtraAotOptions { get; set; }
 
-		public ITaskItem [] Profiles { get; set; }
-
-		[Required]
-		public string AndroidBinUtilsDirectory { get; set; }
-
 		[Output]
 		public string[] NativeLibrariesReferences { get; set; }
 
-		AotMode AotMode;
-		SequencePointsMode sequencePointsMode;
-
-		public static bool GetAndroidAotMode(string androidAotMode, out AotMode aotMode)
-		{
-			aotMode = AotMode.Normal;
-
-			switch ((androidAotMode ?? string.Empty).ToLowerInvariant().Trim())
-			{
-			case "":
-			case "none":
-				aotMode = AotMode.None;
-				return true;
-			case "normal":
-				aotMode = AotMode.Normal;
-				return true;
-			case "hybrid":
-				aotMode = AotMode.Hybrid;
-				return true;
-			case "full":
-				aotMode = AotMode.Full;
-				return true;
-			case "interpreter":
-				aotMode = AotMode.Interp;
-				return true; // We don't do anything here for this mode, this is just to set the flag for the XA
-							  // runtime to initialize Mono in the inrepreter "AOT" mode.
-			}
-
-			return false;
-		}
-
-		public static bool TryGetSequencePointsMode (string value, out SequencePointsMode mode)
-		{
-			mode = SequencePointsMode.None;
-			switch ((value ?? string.Empty).ToLowerInvariant().Trim ()) {
-			case "none":
-				mode = SequencePointsMode.None;
-				return true;
-			case "normal":
-				mode = SequencePointsMode.Normal;
-				return true;
-			case "offline":
-				mode = SequencePointsMode.Offline;
-				return true;
-			}
-			return false;
-		}
-
 		static string GetNdkToolchainLibraryDir (NdkTools ndk, string binDir, string archDir = null)
 		{
 			var baseDir = Path.GetFullPath(Path.Combine(binDir, ".."));
@@ -174,51 +99,6 @@ static string QuoteFileName(string fileName)
 			return builder.ToString();
 		}
 
-		int GetNdkApiLevel (NdkTools ndk, string androidApiLevel, AndroidTargetArch arch)
-		{
-			var manifest    = AndroidAppManifest.Load (ManifestFile.ItemSpec, MonoAndroidHelper.SupportedVersions);
-
-			int level;
-			if (manifest.MinSdkVersion.HasValue) {
-				level       = manifest.MinSdkVersion.Value;
-			}
-			else if (int.TryParse (androidApiLevel, out level)) {
-				// level already set
-			}
-			else {
-				// Probably not ideal!
-				level       = MonoAndroidHelper.SupportedVersions.MaxStableVersion.ApiLevel;
-			}
-
-			// Some Android API levels do not exist on the NDK level. Workaround this my mapping them to the
-			// most appropriate API level that does exist.
-			if (level == 6 || level == 7) level = 5;
-			else if (level == 10) level = 9;
-			else if (level == 11) level = 12;
-			else if (level == 20) level = 19;
-			else if (level == 22) level = 21;
-			else if (level == 23) level = 21;
-
-			// API levels below level 21 do not provide support for 64-bit architectures.
-			if (ndk.IsNdk64BitArch (arch) && level < 21) {
-				level = 21;
-			}
-
-			// We perform a downwards API level lookup search since we might not have hardcoded the correct API
-			// mapping above and we do not want to crash needlessly.
-			for (; level >= 5; level--) {
-				try {
-					ndk.GetDirectoryPath (NdkToolchainDir.PlatformLib, arch, level);
-					break;
-				} catch (InvalidOperationException ex) {
-					// Path not found, continue searching...
-					continue;
-				}
-			}
-
-			return level;
-		}
-
 		public async override System.Threading.Tasks.Task RunTaskAsync ()
 		{
 			NdkTools? ndk = NdkTools.Create (AndroidNdkDirectory, Log);
@@ -237,7 +117,7 @@ public async override System.Threading.Tasks.Task RunTaskAsync ()
 				return;
 			}
 
-			TryGetSequencePointsMode (AndroidSequencePointsMode, out sequencePointsMode);
+			TryGetSequencePointsMode (AndroidSequencePointsMode, out SequencePointsMode);
 
 			var nativeLibs = new List<string> ();
 
@@ -272,48 +152,9 @@ IEnumerable<Config> GetAotConfigs (NdkTools ndk)
 			if (!Directory.Exists (AotOutputDirectory))
 				Directory.CreateDirectory (AotOutputDirectory);
 
-			var sdkBinDirectory = MonoAndroidHelper.GetOSBinPath ();
+			SdkBinDirectory = MonoAndroidHelper.GetOSBinPath ();
 			foreach (var abi in SupportedAbis) {
-				string aotCompiler = "";
-				string outdir = "";
-				string mtriple = "";
-				AndroidTargetArch arch;
-
-				switch (abi) {
-				case "armeabi-v7a":
-					aotCompiler = Path.Combine (sdkBinDirectory, "cross-arm");
-					outdir = Path.Combine (AotOutputDirectory, "armeabi-v7a");
-					mtriple = "armv7-linux-gnueabi";
-					arch = AndroidTargetArch.Arm;
-					break;
-
-				case "arm64":
-				case "arm64-v8a":
-				case "aarch64":
-					aotCompiler = Path.Combine (sdkBinDirectory, "cross-arm64");
-					outdir = Path.Combine (AotOutputDirectory, "arm64-v8a");
-					mtriple = "aarch64-linux-android";
-					arch = AndroidTargetArch.Arm64;
-					break;
-
-				case "x86":
-					aotCompiler = Path.Combine (sdkBinDirectory, "cross-x86");
-					outdir = Path.Combine (AotOutputDirectory, "x86");
-					mtriple = "i686-linux-android";
-					arch = AndroidTargetArch.X86;
-					break;
-
-				case "x86_64":
-					aotCompiler = Path.Combine (sdkBinDirectory, "cross-x86_64");
-					outdir = Path.Combine (AotOutputDirectory, "x86_64");
-					mtriple = "x86_64-linux-android";
-					arch = AndroidTargetArch.X86_64;
-					break;
-
-				// case "mips":
-				default:
-					throw new Exception ("Unsupported Android target architecture ABI: " + abi);
-				}
+				(string aotCompiler, string outdir, string mtriple, AndroidTargetArch arch) = GetAbiSettings (abi);
 
 				if (EnableLLVM && !ndk.ValidateNdkPlatform (LogMessage, LogCodedError, arch, enableLLVM:EnableLLVM)) {
 					yield return Config.Invalid;
@@ -329,10 +170,7 @@ IEnumerable<Config> GetAotConfigs (NdkTools ndk)
 					outdir = outdir.Replace (WorkingDirectory + Path.DirectorySeparatorChar, string.Empty);
 				}
 
-				int level = 0;
-				string toolPrefix = EnableLLVM
-					? ndk.GetNdkToolPrefixForAOT (arch, level = GetNdkApiLevel (ndk, AndroidApiLevel, arch))
-					: Path.Combine (AndroidBinUtilsDirectory, $"{ndk.GetArchDirName (arch)}-");
+				string toolPrefix = GetToolPrefix (ndk, arch, out int level);
 				var toolchainPath = toolPrefix.Substring(0, toolPrefix.LastIndexOf(Path.DirectorySeparatorChar));
 				var ldFlags = string.Empty;
 				if (EnableLLVM) {
@@ -397,27 +235,9 @@ IEnumerable<Config> GetAotConfigs (NdkTools ndk)
 					if (!Directory.Exists (tempDir))
 						Directory.CreateDirectory (tempDir);
 
-					List<string> aotOptions = new List<string> ();
-
-					if (Profiles != null && Profiles.Length > 0) {
-						aotOptions.Add ("profile-only");
-						foreach (var p in Profiles) {
-							var fp = Path.GetFullPath (p.ItemSpec);
-							aotOptions.Add ($"profile={fp}");
-						}
-					}
-					if (!string.IsNullOrEmpty (AotAdditionalArguments))
-						aotOptions.Add (AotAdditionalArguments);
-					if (sequencePointsMode == SequencePointsMode.Offline)
-						aotOptions.Add ($"msym-dir={outdir}");
-					if (AotMode != AotMode.Normal)
-						aotOptions.Add (AotMode.ToString ().ToLowerInvariant ());
-
+					var aotOptions = GetAotOptions (outdir, mtriple, toolPrefix);
 					aotOptions.Add ($"outfile={outputFile}");
-					aotOptions.Add ("asmwriter");
-					aotOptions.Add ($"mtriple={mtriple}");
-					aotOptions.Add ($"tool-prefix={toolPrefix}");
-					aotOptions.Add ($"llvm-path={sdkBinDirectory}");
+					aotOptions.Add ($"llvm-path={SdkBinDirectory}");
 					aotOptions.Add ($"temp-path={tempDir}");
 
 					if (!String.IsNullOrEmpty (ldName)) {
diff --git a/src/Xamarin.Android.Build.Tasks/Tasks/BuildApk.cs b/src/Xamarin.Android.Build.Tasks/Tasks/BuildApk.cs
index 36763a00717..be43b151a0e 100644
--- a/src/Xamarin.Android.Build.Tasks/Tasks/BuildApk.cs
+++ b/src/Xamarin.Android.Build.Tasks/Tasks/BuildApk.cs
@@ -696,7 +696,11 @@ private void AddAdditionalNativeLibraries (ArchiveFileList files, string [] supp
 				return;
 
 			var libs = AdditionalNativeLibraryReferences
-				.Select (l => new LibInfo { Path = l.ItemSpec, Abi = AndroidRidAbiHelper.GetNativeLibraryAbi (l) });
+				.Select (l => new LibInfo {
+					Path = l.ItemSpec,
+					Abi = AndroidRidAbiHelper.GetNativeLibraryAbi (l),
+					ArchiveFileName = l.GetMetadata ("ArchiveFileName"),
+				});
 
 			AddNativeLibraries (files, supportedAbis, libs);
 		}
diff --git a/src/Xamarin.Android.Build.Tasks/Tasks/CilStrip.cs b/src/Xamarin.Android.Build.Tasks/Tasks/CilStrip.cs
index f6c4bd4a772..225fb02c9bf 100644
--- a/src/Xamarin.Android.Build.Tasks/Tasks/CilStrip.cs
+++ b/src/Xamarin.Android.Build.Tasks/Tasks/CilStrip.cs
@@ -24,7 +24,7 @@ public class CilStrip : AndroidTask
 		public ITaskItem[] ResolvedAssemblies { get; set; }
 
 		[Required]
-		public ITaskItem ApkOutputPath { get; set; }
+		public string StampFile { get; set; }
 
 		public CilStrip ()
 		{
@@ -52,7 +52,7 @@ bool DoExecute () {
 			if (!Directory.Exists (nonstripDir))
 				Directory.CreateDirectory (nonstripDir);
 
-			var timestampFileDate = File.GetLastWriteTimeUtc (ApkOutputPath.ItemSpec);
+			var timestampFileDate = File.GetLastWriteTimeUtc (StampFile);
 
 			foreach (var assembly in ResolvedAssemblies) {
 				string assemblyPath = Path.GetFullPath (assembly.ItemSpec);
diff --git a/src/Xamarin.Android.Build.Tasks/Tasks/GetAotArguments.cs b/src/Xamarin.Android.Build.Tasks/Tasks/GetAotArguments.cs
new file mode 100644
index 00000000000..7fcbc5299be
--- /dev/null
+++ b/src/Xamarin.Android.Build.Tasks/Tasks/GetAotArguments.cs
@@ -0,0 +1,272 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using Microsoft.Android.Build.Tasks;
+using Microsoft.Build.Framework;
+using Xamarin.Android.Tools;
+
+namespace Xamarin.Android.Tasks
+{
+	/// <summary>
+	/// The <Aot/> task subclasses this in "legacy" Xamarin.Android.
+	/// Called directly in .NET 5 to populate %(AotArguments) metadata.
+	/// </summary>
+	public class GetAotArguments : AndroidAsyncTask
+	{
+		public override string TaskPrefix => "GAOT";
+
+		[Required]
+		public string AndroidApiLevel { get; set; }
+
+		[Required]
+		public string AndroidAotMode { get; set; }
+
+		[Required]
+		public string AotOutputDirectory { get; set; }
+
+		[Required]
+		public string AndroidBinUtilsDirectory { get; set; }
+
+		/// <summary>
+		/// Will be blank in .NET 6+
+		/// </summary>
+		public string ManifestFile { get; set; }
+
+		/// <summary>
+		/// $(AndroidMinimumSupportedApiLevel) in .NET 6+
+		/// </summary>
+		public string MinimumSupportedApiLevel { get; set; }
+
+		public string RuntimeIdentifier { get; set; }
+
+		public string AndroidNdkDirectory { get; set; }
+
+		public bool EnableLLVM { get; set; }
+
+		public string AndroidSequencePointsMode { get; set; }
+
+		public ITaskItem [] Profiles { get; set; }
+
+		public string AotAdditionalArguments { get; set; }
+
+		[Output]
+		public string Arguments { get; set; }
+
+		[Output]
+		public string LLVMPath { get; set; }
+
+		protected AotMode AotMode;
+		protected SequencePointsMode SequencePointsMode;
+		protected string SdkBinDirectory;
+
+		public static bool GetAndroidAotMode(string androidAotMode, out AotMode aotMode)
+		{
+			aotMode = AotMode.Normal;
+
+			switch ((androidAotMode ?? string.Empty).ToLowerInvariant().Trim())
+			{
+			case "":
+			case "none":
+				aotMode = AotMode.None;
+				return true;
+			case "normal":
+				aotMode = AotMode.Normal;
+				return true;
+			case "hybrid":
+				aotMode = AotMode.Hybrid;
+				return true;
+			case "full":
+				aotMode = AotMode.Full;
+				return true;
+			case "interpreter":
+				// We don't do anything here for this mode, this is just to set the flag for the XA
+				// runtime to initialize Mono in the interpreter "AOT" mode.
+				aotMode = AotMode.Interp;
+				return true;
+			}
+
+			return false;
+		}
+
+		public static bool TryGetSequencePointsMode (string value, out SequencePointsMode mode)
+		{
+			mode = SequencePointsMode.None;
+			switch ((value ?? string.Empty).ToLowerInvariant ().Trim ()) {
+			case "none":
+				mode = SequencePointsMode.None;
+				return true;
+			case "normal":
+				mode = SequencePointsMode.Normal;
+				return true;
+			case "offline":
+				mode = SequencePointsMode.Offline;
+				return true;
+			}
+			return false;
+		}
+
+		public override Task RunTaskAsync ()
+		{
+			NdkTools? ndk = NdkTools.Create (AndroidNdkDirectory, Log);
+			if (ndk == null) {
+				return Task.CompletedTask; // NdkTools.Create will log appropriate error
+			}
+
+			bool hasValidAotMode = GetAndroidAotMode (AndroidAotMode, out AotMode);
+			if (!hasValidAotMode) {
+				LogCodedError ("XA3002", Properties.Resources.XA3002, AndroidAotMode);
+				return Task.CompletedTask;
+			}
+
+			if (AotMode == AotMode.Interp) {
+				LogDebugMessage ("Interpreter AOT mode enabled");
+				return Task.CompletedTask;
+			}
+
+			TryGetSequencePointsMode (AndroidSequencePointsMode, out SequencePointsMode);
+
+			SdkBinDirectory = MonoAndroidHelper.GetOSBinPath ();
+
+			var abi = AndroidRidAbiHelper.RuntimeIdentifierToAbi (RuntimeIdentifier);
+			if (string.IsNullOrEmpty (abi)) {
+				Log.LogCodedError ("XA0035", Properties.Resources.XA0035, RuntimeIdentifier);
+				return Task.CompletedTask;
+			}
+
+			(_, string outdir, string mtriple, AndroidTargetArch arch) = GetAbiSettings (abi);
+			string toolPrefix = GetToolPrefix (ndk, arch, out _);
+
+			Arguments = string.Join (",", GetAotOptions (outdir, mtriple, toolPrefix));
+			if (EnableLLVM)
+				LLVMPath = Path.GetDirectoryName (toolPrefix);
+			return Task.CompletedTask;
+		}
+
+		protected string GetToolPrefix (NdkTools ndk, AndroidTargetArch arch, out int level)
+		{
+			level = 0;
+			return EnableLLVM
+				? ndk.GetNdkToolPrefixForAOT (arch, level = GetNdkApiLevel (ndk, arch))
+				: Path.Combine (AndroidBinUtilsDirectory, $"{ndk.GetArchDirName (arch)}-");
+		}
+
+		int GetNdkApiLevel (NdkTools ndk, AndroidTargetArch arch)
+		{
+			AndroidAppManifest manifest = null;
+			if (!string.IsNullOrEmpty (ManifestFile)) {
+				manifest = AndroidAppManifest.Load (ManifestFile, MonoAndroidHelper.SupportedVersions);
+			}
+
+			int level;
+			if (manifest?.MinSdkVersion != null) {
+				level       = manifest.MinSdkVersion.Value;
+			} else if (int.TryParse (MinimumSupportedApiLevel, out level)) {
+				// level already set
+			} else if (int.TryParse (AndroidApiLevel, out level)) {
+				// level already set
+			} else {
+				// Probably not ideal!
+				level       = MonoAndroidHelper.SupportedVersions.MaxStableVersion.ApiLevel;
+			}
+
+			// Some Android API levels do not exist on the NDK level. Workaround this my mapping them to the
+			// most appropriate API level that does exist.
+			if (level == 6 || level == 7) level = 5;
+			else if (level == 10) level = 9;
+			else if (level == 11) level = 12;
+			else if (level == 20) level = 19;
+			else if (level == 22) level = 21;
+			else if (level == 23) level = 21;
+
+			// API levels below level 21 do not provide support for 64-bit architectures.
+			if (ndk.IsNdk64BitArch (arch) && level < 21) {
+				level = 21;
+			}
+
+			// We perform a downwards API level lookup search since we might not have hardcoded the correct API
+			// mapping above and we do not want to crash needlessly.
+			for (; level >= 5; level--) {
+				try {
+					ndk.GetDirectoryPath (NdkToolchainDir.PlatformLib, arch, level);
+					break;
+				} catch (InvalidOperationException ex) {
+					// Path not found, continue searching...
+					continue;
+				}
+			}
+
+			return level;
+		}
+
+		protected (string aotCompiler, string outdir, string mtriple, AndroidTargetArch arch) GetAbiSettings (string abi)
+		{
+			switch (abi) {
+				case "armeabi-v7a":
+					return (
+						Path.Combine (SdkBinDirectory, "cross-arm"),
+						Path.Combine (AotOutputDirectory, "armeabi-v7a"),
+						"armv7-linux-gnueabi",
+						AndroidTargetArch.Arm
+					);
+
+				case "arm64":
+				case "arm64-v8a":
+				case "aarch64":
+					return (
+						Path.Combine (SdkBinDirectory, "cross-arm64"),
+						Path.Combine (AotOutputDirectory, "arm64-v8a"),
+						"aarch64-linux-android",
+						AndroidTargetArch.Arm64
+					);
+
+				case "x86":
+					return (
+						Path.Combine (SdkBinDirectory, "cross-x86"),
+						Path.Combine (AotOutputDirectory, "x86"),
+						"i686-linux-android",
+						AndroidTargetArch.X86
+					);
+
+				case "x86_64":
+					return (
+						Path.Combine (SdkBinDirectory, "cross-x86_64"),
+						Path.Combine (AotOutputDirectory, "x86_64"),
+						"x86_64-linux-android",
+						AndroidTargetArch.X86_64
+					);
+
+				// case "mips":
+				default:
+					throw new Exception ("Unsupported Android target architecture ABI: " + abi);
+			}
+		}
+
+		/// <summary>
+		/// Returns a list of parameters to pass to the --aot switch
+		/// </summary>
+		protected List<string> GetAotOptions (string outdir, string mtriple, string toolPrefix)
+		{
+			List<string> aotOptions = new List<string> ();
+
+			if (Profiles != null && Profiles.Length > 0) {
+				aotOptions.Add ("profile-only");
+				foreach (var p in Profiles) {
+					var fp = Path.GetFullPath (p.ItemSpec);
+					aotOptions.Add ($"profile={fp}");
+				}
+			}
+			if (!string.IsNullOrEmpty (AotAdditionalArguments))
+				aotOptions.Add (AotAdditionalArguments);
+			if (SequencePointsMode == SequencePointsMode.Offline)
+				aotOptions.Add ($"msym-dir={outdir}");
+			if (AotMode != AotMode.Normal)
+				aotOptions.Add (AotMode.ToString ().ToLowerInvariant ());
+
+			aotOptions.Add ("asmwriter");
+			aotOptions.Add ($"mtriple={mtriple}");
+			aotOptions.Add ($"tool-prefix={toolPrefix}");
+			return aotOptions;
+		}
+	}
+}
diff --git a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/AotTests.cs b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/AotTests.cs
index ffb7b48000e..b0ea6906eb6 100644
--- a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/AotTests.cs
+++ b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/AotTests.cs
@@ -50,7 +50,7 @@ public void TearDown ()
 			Directory.Delete (SdkWithSpacesPath, recursive: true);
 		}
 
-		[Test, Category ("SmokeTests")]
+		[Test, Category ("SmokeTests"), Category ("ProfiledAOT")]
 		public void BuildBasicApplicationReleaseProfiledAot ()
 		{
 			var proj = new XamarinAndroidApplicationProject () {
@@ -65,7 +65,7 @@ public void BuildBasicApplicationReleaseProfiledAot ()
 			}
 		}
 
-		[Test, Category ("SmokeTests")]
+		[Test, Category ("SmokeTests"), Category ("ProfiledAOT")]
 		public void BuildBasicApplicationReleaseWithCustomAotProfile ()
 		{
 			var proj = new XamarinAndroidApplicationProject () {
@@ -88,7 +88,7 @@ public void BuildBasicApplicationReleaseWithCustomAotProfile ()
 			}
 		}
 
-		[Test]
+		[Test, Category ("ProfiledAOT")]
 		public void BuildBasicApplicationReleaseProfiledAotWithoutDefaultProfile ()
 		{
 			var proj = new XamarinAndroidApplicationProject () {
@@ -147,8 +147,11 @@ public void BuildBasicApplicationReleaseProfiledAotWithoutDefaultProfile ()
 
 		[Test]
 		[TestCaseSource (nameof (AotChecks))]
+		[Category ("DotNetIgnore")] // Not currently working, see: https://github.com/dotnet/runtime/issues/56163
 		public void BuildAotApplicationAndÜmläüts (string supportedAbis, bool enableLLVM, bool expectedResult)
 		{
+			AssertLLVMSupported (enableLLVM);
+
 			var path = Path.Combine ("temp", string.Format ("BuildAotApplication AndÜmläüts_{0}_{1}_{2}", supportedAbis, enableLLVM, expectedResult));
 			var proj = new XamarinAndroidApplicationProject () {
 				IsRelease = true,
@@ -224,8 +227,11 @@ public void BuildAotApplicationAndÜmläüts (string supportedAbis, bool enableL
 		[Test]
 		[TestCaseSource (nameof (AotChecks))]
 		[Category ("Minor"), Category ("MkBundle")]
+		[Category ("DotNetIgnore")] // Not currently working, see: https://github.com/dotnet/runtime/issues/56163
 		public void BuildAotApplicationAndBundleAndÜmläüts (string supportedAbis, bool enableLLVM, bool expectedResult)
 		{
+			AssertLLVMSupported (enableLLVM);
+
 			var path = Path.Combine ("temp", string.Format ("BuildAotApplicationAndBundle AndÜmläüts_{0}_{1}_{2}", supportedAbis, enableLLVM, expectedResult));
 			var proj = new XamarinAndroidApplicationProject () {
 				IsRelease = true,
@@ -368,6 +374,7 @@ public static void Foo () {
 		}
 
 		[Test]
+		[Category ("HybridAOT")]
 		public void HybridAOT ([Values ("armeabi-v7a;arm64-v8a", "armeabi-v7a", "arm64-v8a")] string abis)
 		{
 			var proj = new XamarinAndroidApplicationProject () {
@@ -418,8 +425,11 @@ public static void Foo () {
 		}
 
 		[Test]
-		public void NoSymbolsArgShouldReduceAppSize ([Values (true, false)] bool enableHybridAot)
+		[Category ("LLVM")]
+		public void NoSymbolsArgShouldReduceAppSize ([Values ("", "Hybrid")] string androidAotMode)
 		{
+			AssertAotModeSupported (androidAotMode);
+
 			var proj = new XamarinAndroidApplicationProject () {
 				IsRelease = true,
 				AotAssemblies = true,
@@ -427,8 +437,8 @@ public void NoSymbolsArgShouldReduceAppSize ([Values (true, false)] bool enableH
 			var supportedAbi = "arm64-v8a";
 			proj.SetAndroidSupportedAbis (supportedAbi);
 			proj.SetProperty ("EnableLLVM", true.ToString ());
-			if (enableHybridAot)
-				proj.SetProperty ("AndroidAotMode", "Hybrid");
+			if (!string.IsNullOrEmpty (androidAotMode))
+				proj.SetProperty ("AndroidAotMode", androidAotMode);
 
 			var xaAssemblySize = 0;
 			var xaAssemblySizeNoSymbol = 0;
diff --git a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/IncrementalBuildTest.cs b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/IncrementalBuildTest.cs
index f3da4c0a711..465f674ac8e 100644
--- a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/IncrementalBuildTest.cs
+++ b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/IncrementalBuildTest.cs
@@ -1053,6 +1053,8 @@ void AssertAssemblyFilesInFileWrites (XamarinAndroidApplicationProject proj, Pro
 		[TestCaseSource (nameof (AotChecks))]
 		public void BuildIncrementalAot (string supportedAbis, string androidAotMode, bool aotAssemblies, bool expectedResult)
 		{
+			AssertAotModeSupported (androidAotMode);
+
 			var targets = new string [] {
 				"_RemoveRegisterAttribute",
 				"_BuildApkEmbed",
diff --git a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/Utilities/BaseTest.cs b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/Utilities/BaseTest.cs
index 2634ae85282..1c3fb61229d 100644
--- a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/Utilities/BaseTest.cs
+++ b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/Utilities/BaseTest.cs
@@ -197,6 +197,21 @@ protected static void AssertAaptSupported (bool useAapt2)
 			}
 		}
 
+		protected static void AssertAotModeSupported (string aotMode)
+		{
+			if (Builder.UseDotNet && !string.IsNullOrEmpty (aotMode) &&
+					!string.Equals (aotMode, "Normal", StringComparison.OrdinalIgnoreCase)) {
+				Assert.Ignore ($"AotMode={aotMode} is not yet supported in .NET 6+");
+			}
+		}
+
+		protected static void AssertLLVMSupported (bool llvm)
+		{
+			if (Builder.UseDotNet && llvm) {
+				Assert.Ignore ($"EnableLLVM={llvm} is not yet supported in .NET 6+");
+			}
+		}
+
 		protected static void WaitFor(int milliseconds)
 		{
 			var pause = new ManualResetEvent(false);
diff --git a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/XASdkTests.cs b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/XASdkTests.cs
index 3212f882e2a..b4a4befa793 100644
--- a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/XASdkTests.cs
+++ b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/XASdkTests.cs
@@ -325,41 +325,64 @@ public void DotNetBuildBinding ()
 			new object [] {
 				/* runtimeIdentifiers */ "android-arm",
 				/* isRelease */          false,
+				/* aot */                false,
 			},
 			new object [] {
 				/* runtimeIdentifiers */ "android-arm64",
 				/* isRelease */          false,
+				/* aot */                false,
 			},
 			new object [] {
 				/* runtimeIdentifiers */ "android-x86",
 				/* isRelease */          false,
+				/* aot */                false,
 			},
 			new object [] {
 				/* runtimeIdentifiers */ "android-x64",
 				/* isRelease */          false,
+				/* aot */                false,
 			},
 			new object [] {
 				/* runtimeIdentifiers */ "android-arm",
 				/* isRelease */          true,
+				/* aot */                false,
+			},
+			new object [] {
+				/* runtimeIdentifiers */ "android-arm",
+				/* isRelease */          true,
+				/* aot */                true,
+			},
+			new object [] {
+				/* runtimeIdentifiers */ "android-arm64",
+				/* isRelease */          true,
+				/* aot */                false,
 			},
 			new object [] {
 				/* runtimeIdentifiers */ "android-arm;android-arm64;android-x86;android-x64",
 				/* isRelease */          false,
+				/* aot */                false,
 			},
 			new object [] {
 				/* runtimeIdentifiers */ "android-arm;android-arm64;android-x86",
 				/* isRelease */          true,
+				/* aot */                false,
+			},
+			new object [] {
+				/* runtimeIdentifiers */ "android-arm;android-arm64;android-x86;android-x64",
+				/* isRelease */          true,
+				/* aot */                false,
 			},
 			new object [] {
 				/* runtimeIdentifiers */ "android-arm;android-arm64;android-x86;android-x64",
 				/* isRelease */          true,
+				/* aot */                true,
 			},
 		};
 
 		[Test]
 		[Category ("SmokeTests")]
 		[TestCaseSource (nameof (DotNetBuildSource))]
-		public void DotNetBuild (string runtimeIdentifiers, bool isRelease)
+		public void DotNetBuild (string runtimeIdentifiers, bool isRelease, bool aot)
 		{
 			var proj = new XASdkProject {
 				IsRelease = isRelease,
@@ -392,6 +415,9 @@ public void DotNetBuild (string runtimeIdentifiers, bool isRelease)
 				}
 			};
 			proj.MainActivity = proj.DefaultMainActivity.Replace (": Activity", ": AndroidX.AppCompat.App.AppCompatActivity");
+			if (aot) {
+				proj.SetProperty ("RunAOTCompilation", "true");
+			}
 			proj.OtherBuildItems.Add (new AndroidItem.InputJar ("javaclasses.jar") {
 				BinaryContent = () => ResourceData.JavaSourceJarTestJar,
 			});
diff --git a/src/Xamarin.Android.Build.Tasks/Xamarin.Android.Common.targets b/src/Xamarin.Android.Build.Tasks/Xamarin.Android.Common.targets
index 5752f8eef53..4b66f936974 100644
--- a/src/Xamarin.Android.Build.Tasks/Xamarin.Android.Common.targets
+++ b/src/Xamarin.Android.Build.Tasks/Xamarin.Android.Common.targets
@@ -1972,68 +1972,6 @@ because xbuild doesn't support framework reference assemblies.
   Inputs="$(_BuildApkEmbedInputs)"
   Outputs="$(_BuildApkEmbedOutputs)"
   Condition="'$(EmbedAssembliesIntoApk)' == 'True'">
-
-  <PropertyGroup>
-    <_StartupAotProfile Condition="'%(ResolvedAssemblies.Filename)' == 'Xamarin.Forms.Platform.Android'">startup-xf.aotprofile</_StartupAotProfile>
-    <_StartupAotProfile Condition="'$(_StartupAotProfile)' == ''">startup.aotprofile</_StartupAotProfile>
-  </PropertyGroup>
-  <ItemGroup Condition="'$(AndroidUseDefaultAotProfile)' != 'False'">
-    <AndroidAotProfile Include="$(MSBuildThisFileDirectory)$(_StartupAotProfile)" />
-  </ItemGroup>
-  <SplitProperty Value="$(AndroidAotProfiles)" Condition="'$(AndroidAotProfiles)' != ''">
-    <Output TaskParameter="Output" ItemName="_AotProfiles" />
-  </SplitProperty>
-  <ItemGroup Condition="'$(AndroidEnableProfiledAot)' == 'True'">
-    <_AotProfiles Include="@(AndroidAotProfile)" />
-  </ItemGroup>
-  <Aot
-	Condition="'$(AotAssemblies)' == 'True'"
-	AndroidAotMode="$(AndroidAotMode)"
-	AndroidNdkDirectory="$(_AndroidNdkDirectory)"
-	AndroidBinUtilsDirectory="$(AndroidBinUtilsDirectory)"
-	AndroidApiLevel="$(_AndroidApiLevel)"
-	ManifestFile="$(IntermediateOutputPath)android\AndroidManifest.xml"
-	SupportedAbis="@(_BuildTargetAbis)"
-	AndroidSequencePointsMode="$(_SequencePointsMode)"
-	AotAdditionalArguments="$(AndroidAotAdditionalArguments)"
-	ExtraAotOptions="$(AndroidExtraAotOptions)"
-	ResolvedAssemblies="@(_ShrunkAssemblies)"
-	AotOutputDirectory="$(_AndroidAotBinDirectory)"
-	IntermediateAssemblyDir="$(MonoAndroidIntermediateAssemblyDir)"
-	LinkMode="$(AndroidLinkMode)"
-	AdditionalNativeLibraryReferences="@(_AdditionalNativeLibraryReferences)"
-	YieldDuringToolExecution="$(YieldDuringToolExecution)"
-	EnableLLVM="$(EnableLLVM)"
-	Profiles="@(_AotProfiles)">
-	   <Output TaskParameter="NativeLibrariesReferences" ItemName="_AdditionalNativeLibraryReferences" />
-  </Aot>
-
-  <ItemGroup Condition=" '$(AndroidAotMode)' == 'Hybrid' And '$(AotAssemblies)' == 'True' ">
-    <_CilStripAssemblies Include="@(_ShrunkAssemblies)" Condition=" '%(FileName)' != 'Mono.Android' " />
-  </ItemGroup>
-
-  <!-- Strip the IL code of the resolved managed assemblies -->
-   <CilStrip
-	Condition=" '$(AndroidAotMode)' == 'Hybrid' And '$(AotAssemblies)' == 'True' "
-	AndroidAotMode="$(AndroidAotMode)"
-	ToolPath="$(_MonoAndroidToolsDirectory)"
-	ApkOutputPath="$(_BuildApkEmbedOutputs)"
-	ResolvedAssemblies="@(_CilStripAssemblies)">
-  </CilStrip>
-
-  <!-- Bundle the assemblies into native libraries in the apk -->
-  <MakeBundleNativeCodeExternal
-		Condition="'$(BundleAssemblies)' == 'True'"
-		KeepTemp="$(AndroidMakeBundleKeepTemporaryFiles)"
-		AndroidNdkDirectory="$(_AndroidNdkDirectory)"
-		Assemblies="@(_ShrunkAssemblies);@(_AndroidResolvedSatellitePaths)"
-		IncludePath="$(MonoAndroidIncludeDirectory)"
-		SupportedAbis="@(_BuildTargetAbis)"
-		TempOutputPath="$(IntermediateOutputPath)"
-		ToolPath="$(_MonoAndroidToolsDirectory)"
-		BundleApiPath="$(MSBuildThisFileDirectory)\mkbundle-api.h">
- 	<Output TaskParameter="OutputNativeLibraries" PropertyName="_BundleResultNativeLibraries" />
-  </MakeBundleNativeCodeExternal>
   <!-- Put the assemblies and native libraries in the apk -->
   <BuildApk
     Condition=" '$(AndroidPackageFormat)' != 'aab' "
diff --git a/src/Xamarin.Android.Build.Tasks/Xamarin.Android.Legacy.targets b/src/Xamarin.Android.Build.Tasks/Xamarin.Android.Legacy.targets
index d2f1e8dedac..62055f22f8d 100644
--- a/src/Xamarin.Android.Build.Tasks/Xamarin.Android.Legacy.targets
+++ b/src/Xamarin.Android.Build.Tasks/Xamarin.Android.Legacy.targets
@@ -149,6 +149,7 @@ projects. .NET 5 projects will not import this file.
       _LintChecks;
       _IncludeNativeSystemLibraries;
       _CheckGoogleSdkRequirements;
+      _AndroidAot;
     </_PrepareBuildApkDependsOnTargets>
     <_UpdateAndroidResourcesDependsOn>
       $(CoreResolveReferencesDependsOn);
@@ -658,4 +659,74 @@ projects. .NET 5 projects will not import this file.
     </ItemGroup>
   </Target>
 
+  <!-- Legacy AOT support that runs before _BuildApkEmbed -->
+  <Target Name="_AndroidAot"
+      Condition=" '$(AotAssemblies)' == 'true' or '$(BundleAssemblies)' == 'true' "
+      Inputs="$(_BuildApkEmbedInputs)"
+      Outputs="$(_AndroidStampDirectory)_AndroidAot.stamp">
+    <PropertyGroup>
+      <_StartupAotProfile Condition="'%(ResolvedAssemblies.Filename)' == 'Xamarin.Forms.Platform.Android'">startup-xf.aotprofile</_StartupAotProfile>
+      <_StartupAotProfile Condition="'$(_StartupAotProfile)' == ''">startup.aotprofile</_StartupAotProfile>
+    </PropertyGroup>
+    <ItemGroup Condition="'$(AndroidUseDefaultAotProfile)' != 'False'">
+      <AndroidAotProfile Include="$(MSBuildThisFileDirectory)$(_StartupAotProfile)" />
+    </ItemGroup>
+    <SplitProperty Value="$(AndroidAotProfiles)" Condition="'$(AndroidAotProfiles)' != ''">
+      <Output TaskParameter="Output" ItemName="_AotProfiles" />
+    </SplitProperty>
+    <ItemGroup Condition="'$(AndroidEnableProfiledAot)' == 'True'">
+      <_AotProfiles Include="@(AndroidAotProfile)" />
+    </ItemGroup>
+    <Aot
+        Condition="'$(AotAssemblies)' == 'True'"
+        AndroidAotMode="$(AndroidAotMode)"
+        AndroidNdkDirectory="$(_AndroidNdkDirectory)"
+        AndroidBinUtilsDirectory="$(AndroidBinUtilsDirectory)"
+        AndroidApiLevel="$(_AndroidApiLevel)"
+        ManifestFile="$(IntermediateOutputPath)android\AndroidManifest.xml"
+        SupportedAbis="@(_BuildTargetAbis)"
+        AndroidSequencePointsMode="$(_SequencePointsMode)"
+        AotAdditionalArguments="$(AndroidAotAdditionalArguments)"
+        ExtraAotOptions="$(AndroidExtraAotOptions)"
+        ResolvedAssemblies="@(_ShrunkAssemblies)"
+        AotOutputDirectory="$(_AndroidAotBinDirectory)"
+        IntermediateAssemblyDir="$(MonoAndroidIntermediateAssemblyDir)"
+        LinkMode="$(AndroidLinkMode)"
+        AdditionalNativeLibraryReferences="@(_AdditionalNativeLibraryReferences)"
+        YieldDuringToolExecution="$(YieldDuringToolExecution)"
+        EnableLLVM="$(EnableLLVM)"
+        Profiles="@(_AotProfiles)">
+      <Output TaskParameter="NativeLibrariesReferences" ItemName="_AdditionalNativeLibraryReferences" />
+    </Aot>
+
+    <ItemGroup Condition=" '$(AndroidAotMode)' == 'Hybrid' And '$(AotAssemblies)' == 'True' ">
+      <_CilStripAssemblies Include="@(_ShrunkAssemblies)" Condition=" '%(FileName)' != 'Mono.Android' " />
+    </ItemGroup>
+
+    <!-- Strip the IL code of the resolved managed assemblies -->
+    <CilStrip
+        Condition=" '$(AndroidAotMode)' == 'Hybrid' And '$(AotAssemblies)' == 'True' "
+        AndroidAotMode="$(AndroidAotMode)"
+        ToolPath="$(_MonoAndroidToolsDirectory)"
+        StampFile="$(_AndroidStampDirectory)_AndroidAot.stamp"
+        ResolvedAssemblies="@(_CilStripAssemblies)"
+    />
+
+    <!-- Bundle the assemblies into native libraries in the apk -->
+    <MakeBundleNativeCodeExternal
+        Condition="'$(BundleAssemblies)' == 'True'"
+        KeepTemp="$(AndroidMakeBundleKeepTemporaryFiles)"
+        AndroidNdkDirectory="$(_AndroidNdkDirectory)"
+        Assemblies="@(_ShrunkAssemblies);@(_AndroidResolvedSatellitePaths)"
+        IncludePath="$(MonoAndroidIncludeDirectory)"
+        SupportedAbis="@(_BuildTargetAbis)"
+        TempOutputPath="$(IntermediateOutputPath)"
+        ToolPath="$(_MonoAndroidToolsDirectory)"
+        BundleApiPath="$(MSBuildThisFileDirectory)\mkbundle-api.h">
+      <Output TaskParameter="OutputNativeLibraries" PropertyName="_BundleResultNativeLibraries" />
+    </MakeBundleNativeCodeExternal>
+
+    <Touch Files="$(_AndroidStampDirectory)_AndroidAot.stamp" AlwaysCreate="true" />
+  </Target>
+
 </Project>
diff --git a/tests/MSBuildDeviceIntegration/Tests/AotProfileTests.cs b/tests/MSBuildDeviceIntegration/Tests/AotProfileTests.cs
index 93dcd07bba5..8885879417c 100644
--- a/tests/MSBuildDeviceIntegration/Tests/AotProfileTests.cs
+++ b/tests/MSBuildDeviceIntegration/Tests/AotProfileTests.cs
@@ -5,7 +5,7 @@
 
 namespace Xamarin.Android.Build.Tests
 {
-	[Category ("UsesDevice"), Category ("AOT")]
+	[Category ("UsesDevice"), Category ("AOT"), Category ("ProfiledAOT")]
 	public class AotProfileTests : DeviceTest
 	{
 

From 04bacb87cf917cd236e329f698f2012919849687 Mon Sep 17 00:00:00 2001
From: Jonathan Peppers <jonathan.peppers@microsoft.com>
Date: Tue, 27 Jul 2021 16:47:06 -0500
Subject: [PATCH 2/2] Fix AOT tests in Mono.Android.NET-Tests.csproj

* had the wrong file path for `TestResults-*.xml`
* `$(ExcludeCategories)` should include `DotNetIgnore` and `InetAccess`
---
 build-tools/automation/azure-pipelines.yaml                 | 5 ++---
 .../Mono.Android.NET-Tests.csproj                           | 6 +++++-
 2 files changed, 7 insertions(+), 4 deletions(-)

diff --git a/build-tools/automation/azure-pipelines.yaml b/build-tools/automation/azure-pipelines.yaml
index 3df4deb4a93..bdafebf3e70 100644
--- a/build-tools/automation/azure-pipelines.yaml
+++ b/build-tools/automation/azure-pipelines.yaml
@@ -803,9 +803,8 @@ stages:
         configuration: $(XA.Build.Configuration)
         testName: Mono.Android.NET_Tests-Aot
         project: tests/Mono.Android-Tests/Runtime-Microsoft.Android.Sdk/Mono.Android.NET-Tests.csproj
-        testResultsFiles: TestResult-Mono.Android.NET_Tests-$(XA.Build.Configuration)-Aot.xml
-        # InetAccess excluded due to: https://github.com/dotnet/runtime/issues/56315
-        extraBuildArgs: /p:RunAOTCompilation=true /p:ExcludeCategories=InetAccess
+        testResultsFiles: TestResult-Mono.Android.NET_Tests-$(XA.Build.Configuration)Aot.xml
+        extraBuildArgs: /p:TestsFlavor=Aot /p:RunAOTCompilation=true
         artifactSource: bin/Test$(XA.Build.Configuration)/net6.0-android/Mono.Android.NET_Tests-Signed.apk
         artifactFolder: net6-aot
         useDotNet: true
diff --git a/tests/Mono.Android-Tests/Runtime-Microsoft.Android.Sdk/Mono.Android.NET-Tests.csproj b/tests/Mono.Android-Tests/Runtime-Microsoft.Android.Sdk/Mono.Android.NET-Tests.csproj
index 296d426a057..9cb12a9b4ca 100644
--- a/tests/Mono.Android-Tests/Runtime-Microsoft.Android.Sdk/Mono.Android.NET-Tests.csproj
+++ b/tests/Mono.Android-Tests/Runtime-Microsoft.Android.Sdk/Mono.Android.NET-Tests.csproj
@@ -19,8 +19,12 @@
     <EnableDefaultAndroidAssetItems>false</EnableDefaultAndroidAssetItems>
     <_MonoAndroidTestPackage>Mono.Android.NET_Tests</_MonoAndroidTestPackage>
     <PlotDataLabelSuffix>-$(TestsFlavor)NET6</PlotDataLabelSuffix>
-    <!-- TODO: Fix excluded tests -->
+    <!--
+      TODO: Fix excluded tests
+      For AOT, InetAccess excluded due to: https://github.com/dotnet/runtime/issues/56315
+    -->
     <ExcludeCategories>DotNetIgnore</ExcludeCategories>
+    <ExcludeCategories Condition=" '$(RunAOTCompilation)' == 'true' ">$(ExcludeCategories):InetAccess</ExcludeCategories>
   </PropertyGroup>
 
   <PropertyGroup Condition=" '$(Configuration)' == 'Release' ">