[Xamarin.Android.Build.Tasks] implement $(AndroidStripILAfterAOT)

[jonathanpeppers]

Context: dotnet/runtime#86722

This adds an <ILStrip/> step after the <MonoAOTCompiler/> task.

This trims away IL of AOT-compiled methods. This is WIP.

Builds work currently, but the app crashes at runtime with:

07-06 16:57:07.413  8865  8865 E companyname.foo: * Assertion at /__w/1/s/src/mono/mono/mini/mini-trampolines.c:1416, condition `invoke' not met

The above crash has been resolved.

Fixes: dotnet/runtime#88538

[fanyang-mono]

Running _RemoveRegisterAttribute task before MonoAOTCompiler and ILStrip would probably fix this issue. It worked when I tested it with disabling RemoveRegisterAttribute locally.

[fanyang-mono]

I updated this PR with my newest change, which renamed two parameters. I am not sure when exactly it will arrive at Xamarin/Android. The change was in this PR (dotnet/runtime#88926)

[jonathanpeppers]

If others have a better idea on the name, basically you use this in combination with AOT and it will strip most IL that was AOT'd.

For best results, we'd turn off AndroidEnableProfiledAot by default -- so AndroidStripIL will AOT & Strip most of the IL as a good default setting.

@fanyang-mono has some example .apk sizes from a dotnet new android project:

AndroidStripIL	AndroidEnableProfiledAot	App size
false	true	7.7M
true	true	7.7M
false	false	8.4M
true	false	8.1M

[jonathanpeppers]

Ok looks like there is a $(WasmStripILAfterAOT):

https://github.com/dotnet/runtime/blob/2ed506c010b41c41c01997c81df977831f0fa217/src/mono/wasm/build/WasmApp.targets#L88-L89

[SamMonoRT]

$(AndroidStripILAfterAOT) seems logical to align?

[fanyang-mono]

Changed parameter name to AndroidStripILAfterAOT

[fanyang-mono]

Xamarin.Android-PR (MAUI Tests MAUI Integration) failed because it failed to install maui workload. It is a known issue and unrelated to this PR.

[jonpryor]

Possibly silly question, but is there any way to test that $(AndroidStripILAfterAOT)=True actually does something? It could be a no-op and this test would still succeed!

Perhaps we should crack open the linked "app.dll" assembly and verify that e.g. MainActivity.OnCreate() has no body?

[jonathanpeppers]

Yes, we should do something like this test:
https://github.com/xamarin/xamarin-android/blob/5f38d099fc39fd270dca7f0d5ab57ff163945988/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/Tasks/LinkerTests.cs#L293-L304

And then we could assert a method has 0 instructions?

[jonpryor]

or a null method body, yes.

[fanyang-mono]

That would be great, if we could create a test like that.

[jonpryor]

@jonathanpeppers: EnableAndroidStripILAfterAOT() should also test the "profiled AOT/don't AOT everything" case.

[jonpryor]

This <Move/> feels absurd to me: @(_ILStripTrimmedAssemblies) is an output parameter, so I would normally intuit/assume that %(_ILStripTrimmedAssemblies.Identity) is the file that was created. However, this <Move/> implies that %(_ILStripTrimmedAssemblies.Identity) has not in fact been created, and instead what was created is %(_ILStripTrimmedAssemblies.TrimmedAssemblyFileName), which must be moved to %(_ILStripTrimmedAssemblies.Identity).

Does this make sense to anyone? Why was <ILStrip/> defined this way?

[fanyang-mono]

The goal of ILStrip is to trim IL code away from the assemblies which were AOT'ed. However, not all AOT'ed assemblies might be trimmable. That's why we have _ILStripTrimmedAssemblies. ILStrip also doesn't overwrite existing assemblies with the trimmed ones. It is designed this way, in case %(_ILStripTrimmedAssemblies.Identity) are not the ones that you want to replace with the trimmed ones. They could be the ones which live in other directories. And ILStrip could possibly has no knowledge of that.

Here for System.Private.CoreLib.dll,
%(_ILStripTrimmedAssemblies.Identity) is <a_path>/System.Private.CoreLib.dll
%(_ILStripTrimmedAssemblies.TrimmedAssemblyFileName) is <a_path>/System.Private.CoreLib_trimmed.dll

[jonpryor]

@fanyang-mono: how does <ILStrip/> know which method bodies it can remove? I see that the <MonoAOTCompiler/> invocation was updated to add a MonoAOTCompiler.TrimmingEligibleMethodsOutputDirectory property, but how does <ILStrip/> konw about the $(IntermediateOutputPath)tokens directory?

[fanyang-mono]

The output _MonoAOTCompiledAssemblies from MonoAOTCompiler has a metadata MethodTokenFile. It stores the trimmable method token for the corresponding assembly.

[jonathanpeppers]

HasBody was true and Body.Instructions.Count was 0.

[fanyang-mono]

This is probably expected, since I only zero'ed out method body and preserved method method header.

[jonpryor]

[Xamarin.Android.Build.Tasks] add $(AndroidStripILAfterAOT) (#8172)

Context: https://github.com/xamarin/monodroid/commit/388bf4b392c59fc35f51c5eadd0a6218a37a394c
Context: 59ec488b4005a09fc0e5f330f217e78c3fa14724
Context: c929289a7b77ecbc90c3e10aa55f9f3027ed3345
Context: 88215f93fdcf14fa1a2aebbb499c09c6bdb8fa8c
Context: https://github.com/dotnet/runtime/pull/86722

Once Upon A Time™ we had a brilliant thought: if AOT pre-compiles C#
methods, do we need the managed method anymore?  Removing the C#
method body would allow assemblies to be smaller.  ("Even better",
iOS does this too!  Why Can't Android™?!)

While the idea is straightforward, implementation was not: iOS uses 
["Full" AOT][0], which AOT's *all* methods into a form that doesn't
require a runtime JIT.  This allowed iOS to run [`cil-strip`][1],
removing all method bodies from all managed types.

At the time, Xamarin.Android only supported "normal" AOT, and normal
AOT requires a JIT for certain constructs such as generic types and
generic methods.  This meant that attempting to run `cil-strip`
would result in runtime errors if a method body was removed that was
actually required at runtime.  (This was particularly bad because
`cil-strip` could only remove *all* method bodies, not some!)

This limitation was relaxed with the introduction of "Hybrid" AOT,
which is "Full while supporting a JIT".  This meant that *all*
methods could be AOT'd without requiring a JIT, which allowed method
bodies to be removed; see xamarin/monodroid@388bf4b3.

Unfortunately, this wasn't a great long-term solution:

 1. Hybrid AOT was restricted to Visual Studio Enterprise customers.
 2. Enabling Hybrid AOT would slow down Release configuration builds.
 3. Hybrid AOT would result in larger apps.
 4. As a consequence of (1), it didn't get as much testing
 5. `cil-strip` usage was dropped as part of the .NET 5+ migration
    (c929289a)

Re-intoduce IL stripping for .NET 8.

Add a new `$(AndroidStripILAfterAOT)` MSBuild property.  When true,
the `<MonoAOTCompiler/>` task will track which method bodies
were actually AOT'd, storing this information into
`%(_MonoAOTCompiledAssemblies.MethodTokenFile)`, and the new
`<ILStrip/>` task will update the input assemblies, removing all
method bodies that can be removed.

By default setting `$(AndroidStripILAfterAOT)`=true will *override*
the default `$(AndroidEnableProfiledAot)` setting, allowing all
trimmable AOT'd methods to be removed.  Profiled AOT and IL stripping
can be used together by explicitly setting both within the `.csproj`:

	<PropertyGroup>
	  <AndroidStripILAfterAOT>true</AndroidStripILAfterAOT>
	  <AndroidEnableProfiledAot>true</AndroidEnableProfiledAot>
	</PropertyGroup>

`.apk` size results for a `dotnet new android` app:

| `$(AndroidStripILAfterAOT)` | `$(AndroidEnableProfiledAot)` | `.apk` size   |
| --------------------------- | ----------------------------- | ------------- |
| true                        | true                          | 7.7MB         |
| true                        | false                         | 8.1MB         |
| false                       | true                          | 7.7MB         |
| false                       | false                         | 8.4MB         |

Note that `$(AndroidStripILAfterAOT)`=false and
`$(AndroidEnableProfiledAot)`=true is the *default* Release
configuration environment, for 7.7MB.

A project that *only* sets `$(AndroidStripILAfterAOT)`=true implicitly
sets `$(AndroidEnableProfiledAot)`=false, resulting in an 8.1MB app.

[0]: https://www.mono-project.com/docs/advanced/aot/#full-aot
[1]: https://github.com/mono/mono/tree/2020-02/mcs/tools/cil-strip