From 837e8ce6501c25a6fa4596daa3c4395845a27730 Mon Sep 17 00:00:00 2001
From: Simon Rozsival <simon@rozsival.com>
Date: Thu, 14 May 2026 13:54:02 +0200
Subject: [PATCH 1/6] Compare trimmable typemap APK contents

Add a Release CoreCLR HelloWorld comparison test that builds llvm-ir and trimmable typemap APKs, prints managed and dex diagnostics, and asserts the trimmable typemap does not retain extra typemap-eligible managed or Java entries.

Pass all generated typemap assemblies to ILLink as typemap entry assemblies and mark them trimmable so conditional typemap entries are honored.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 ...roid.Sdk.TypeMap.Trimmable.CoreCLR.targets |   9 +-
 .../TrimmableTypeMapBuildTests.cs             | 727 ++++++++++++++++++
 2 files changed, 735 insertions(+), 1 deletion(-)

diff --git a/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.CoreCLR.targets b/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.CoreCLR.targets
index d0ca9742e30..c27922166c1 100644
--- a/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.CoreCLR.targets
+++ b/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.CoreCLR.targets
@@ -12,6 +12,7 @@
     <ItemGroup>
       <ManagedAssemblyToLink Include="$(_TypeMapOutputDirectory)*.dll">
         <DestinationSubPath>%(Filename)%(Extension)</DestinationSubPath>
+        <IsTrimmable>true</IsTrimmable>
       </ManagedAssemblyToLink>
     </ItemGroup>
   </Target>
@@ -20,9 +21,15 @@
   <Target Name="_ConfigureTrimmableTypeMapForLinker"
       BeforeTargets="PrepareForILLink;_RunILLink"
       DependsOnTargets="_GenerateTrimmableTypeMap">
+    <ItemGroup>
+      <_TrimmableTypeMapEntryAssemblies Include="$(_TypeMapOutputDirectory)*.dll" />
+    </ItemGroup>
     <PropertyGroup>
-      <_ExtraTrimmerArgs>--typemap-entry-assembly $(_TypeMapAssemblyName) $(_ExtraTrimmerArgs)</_ExtraTrimmerArgs>
+      <_ExtraTrimmerArgs>@(_TrimmableTypeMapEntryAssemblies->'--typemap-entry-assembly %(Filename)', ' ') $(_ExtraTrimmerArgs)</_ExtraTrimmerArgs>
     </PropertyGroup>
+    <ItemGroup>
+      <_TrimmableTypeMapEntryAssemblies Remove="@(_TrimmableTypeMapEntryAssemblies)" />
+    </ItemGroup>
   </Target>
 
   <!-- Add TypeMap DLLs to assembly store with per-ABI metadata.
diff --git a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/TrimmableTypeMapBuildTests.cs b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/TrimmableTypeMapBuildTests.cs
index 795f135d1a1..068cea291f5 100644
--- a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/TrimmableTypeMapBuildTests.cs
+++ b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/TrimmableTypeMapBuildTests.cs
@@ -1,14 +1,24 @@
+using System;
+using System.Collections.Generic;
 using System.IO;
+using System.IO.Compression;
+using System.Globalization;
 using System.Linq;
+using System.Text;
 using System.Text.RegularExpressions;
+using K4os.Compression.LZ4;
+using Mono.Cecil;
 using NUnit.Framework;
+using Xamarin.Android.AssemblyStore;
 using Xamarin.Android.Tasks;
+using Xamarin.Android.Tools;
 using Xamarin.ProjectTools;
 
 namespace Xamarin.Android.Build.Tests {
 	[TestFixture]
 	[Category ("Node-2")]
 	public class TrimmableTypeMapBuildTests : BaseTest {
+		const uint CompressedAssemblyMagic = 0x5A4C4158; // 'XALZ', little-endian
 
 		[Test]
 		public void Build_WithTrimmableTypeMap_Succeeds ([Values] bool isRelease, [Values (AndroidRuntime.CoreCLR, AndroidRuntime.NativeAOT)] AndroidRuntime runtime)
@@ -117,6 +127,26 @@ public void Build_WithTrimmableTypeMap_AssemblyStoreMappingsStayInRange ()
 			}
 		}
 
+		[Test]
+		public void ReleaseCoreClrTrimmableTypeMap_DoesNotKeepMoreTypemapPeersThanLlvmIr ()
+		{
+			if (IgnoreUnsupportedConfiguration (AndroidRuntime.CoreCLR, release: true)) {
+				return;
+			}
+
+			var llvmIr = BuildTypemapComparisonApk ("llvm-ir");
+			var trimmable = BuildTypemapComparisonApk ("trimmable");
+
+			WriteComparisonDiagnostics (llvmIr, trimmable);
+
+			Assert.IsEmpty (
+				trimmable.ManagedTypemapEntries.Except (llvmIr.ManagedTypemapEntries, StringComparer.Ordinal).OrderBy (x => x, StringComparer.Ordinal).ToArray (),
+				"Trimmable typemap should not keep additional managed typemap-eligible types or methods compared to llvm-ir.");
+			Assert.IsEmpty (
+				trimmable.JavaTypemapEntries.Except (llvmIr.JavaTypemapEntries, StringComparer.Ordinal).OrderBy (x => x, StringComparer.Ordinal).ToArray (),
+				"Trimmable typemap should not keep additional Java typemap-eligible classes or methods compared to llvm-ir.");
+		}
+
 		[Test]
 		public void TrimmableTypeMap_PreserveLists_ArePackagedInSdk ()
 		{
@@ -150,5 +180,702 @@ public void TrimmableTypeMap_RuntimeArtifacts_ArePackagedInSdk ()
 			}
 
 		}
+
+		ApkComparisonProfile BuildTypemapComparisonApk (string typemapImplementation)
+		{
+			var proj = new XamarinAndroidApplicationProject {
+				IsRelease = true,
+				PackageName = "com.xamarin.typemapcomparison",
+				ProjectName = "TypemapComparison",
+			};
+			proj.SetRuntime (AndroidRuntime.CoreCLR);
+			proj.SetProperty ("AndroidSupportedAbis", "arm64-v8a");
+			proj.SetProperty ("AndroidPackageFormat", "apk");
+			proj.SetProperty ("TrimMode", "full");
+			proj.SetProperty ("_AndroidTypeMapImplementation", typemapImplementation);
+
+			using var builder = CreateApkBuilder (Path.Combine ("temp", $"TypemapComparison_{typemapImplementation}_{Guid.NewGuid ():N}"));
+			Assert.IsTrue (builder.Build (proj), $"{typemapImplementation} build should have succeeded.");
+
+			if (typemapImplementation != "trimmable") {
+				FileAssert.Exists (builder.Output.GetIntermediaryPath (Path.Combine ("android", "typemaps.arm64-v8a.ll")), "llvm-ir build should generate the native typemap.");
+				FileAssert.Exists (builder.Output.GetIntermediaryPath (Path.Combine ("android", "typemaps.arm64-v8a.o")), "llvm-ir build should compile the native typemap.");
+			}
+
+			var apkDirectory = Path.Combine (Root, builder.ProjectDirectory, proj.OutputPath);
+			var apkPath = Directory.GetFiles (apkDirectory, "*-Signed.apk", SearchOption.AllDirectories).Single ();
+			var acwMapPath = builder.Output.GetIntermediaryPath ("acw-map.txt");
+			var javaSourceDirectory = builder.Output.GetIntermediaryPath (Path.Combine ("android", "src"));
+
+			var profile = ReadApkProfile (typemapImplementation, apkPath, acwMapPath, javaSourceDirectory);
+			if (typemapImplementation == "trimmable") {
+				Assert.IsTrue (profile.ManagedAssemblyNames.Contains ("_Microsoft.Android.TypeMaps.dll"), "trimmable build should package the root managed typemap assembly.");
+			} else {
+				Assert.IsFalse (profile.ManagedAssemblyNames.Contains ("_Microsoft.Android.TypeMaps.dll"), "llvm-ir build should not package the trimmable root managed typemap assembly.");
+			}
+			return profile;
+		}
+
+		ApkComparisonProfile ReadApkProfile (string name, string apkPath, string acwMapPath, string javaSourceDirectory)
+		{
+			var profile = new ApkComparisonProfile {
+				Name = name,
+				ApkPath = apkPath,
+				ApkSize = new FileInfo (apkPath).Length,
+			};
+
+			LoadAcwMap (acwMapPath, profile);
+			ReadGeneratedJavaProfile (javaSourceDirectory, profile);
+			ReadAssemblyStoreProfile (profile);
+			ReadDexProfile (profile);
+
+			return profile;
+		}
+
+		void ReadGeneratedJavaProfile (string javaSourceDirectory, ApkComparisonProfile profile)
+		{
+			if (!Directory.Exists (javaSourceDirectory)) {
+				return;
+			}
+
+			foreach (var file in Directory.EnumerateFiles (javaSourceDirectory, "*.java", SearchOption.AllDirectories)) {
+				profile.GeneratedJavaSourceCount++;
+				var text = File.ReadAllText (file);
+				if (text.IndexOf ("__md_methods", StringComparison.Ordinal) >= 0) {
+					profile.GeneratedJavaWithMdMethodsCount++;
+				}
+				if (text.IndexOf ("Runtime.register (", StringComparison.Ordinal) >= 0) {
+					profile.GeneratedJavaWithRuntimeRegisterCount++;
+				}
+				if (text.IndexOf ("Runtime.registerNatives", StringComparison.Ordinal) >= 0) {
+					profile.GeneratedJavaWithRegisterNativesCount++;
+				}
+			}
+		}
+
+		void LoadAcwMap (string acwMapPath, ApkComparisonProfile profile)
+		{
+			FileAssert.Exists (acwMapPath, $"{profile.Name} build should produce acw-map.txt.");
+
+			foreach (var line in File.ReadLines (acwMapPath)) {
+				if (line.Length == 0 || line [0] == '#') {
+					continue;
+				}
+
+				var fields = line.Split (new [] { ';' }, 2);
+				if (fields.Length != 2) {
+					continue;
+				}
+
+				var javaName = fields [1].Trim ();
+				if (!IsTypemapHelperJavaType (javaName)) {
+					profile.CandidateJavaNames.Add (javaName);
+				}
+
+				var managedType = GetManagedTypeFromAcwMapKey (fields [0]);
+				if (managedType != null && !IsTypemapHelperManagedType (managedType)) {
+					profile.CandidateManagedTypes.Add (managedType);
+				}
+			}
+		}
+
+		string GetManagedTypeFromAcwMapKey (string key)
+		{
+			var comma = key.IndexOf (',');
+			if (comma < 0) {
+				return null;
+			}
+
+			var typeName = key.Substring (0, comma).Trim ();
+			if (typeName.Length == 0 || typeName.IndexOf ('/') >= 0) {
+				return null;
+			}
+
+			return typeName.Replace ('+', '/');
+		}
+
+		void ReadAssemblyStoreProfile (ApkComparisonProfile profile)
+		{
+			(var explorers, var errorMessage) = AssemblyStoreExplorer.Open (profile.ApkPath);
+			Assert.IsNull (errorMessage, $"{profile.ApkPath} should contain readable assembly stores.");
+			Assert.IsNotNull (explorers, $"{profile.ApkPath} should contain assembly stores.");
+
+			var explorer = explorers.FirstOrDefault (e => e.TargetArch == AndroidTargetArch.Arm64);
+			Assert.IsNotNull (explorer, $"{profile.ApkPath} should contain an arm64-v8a assembly store.");
+
+			profile.AssemblyStoreCount = explorers.Count;
+			foreach (var store in explorers) {
+				var storeSize = store.Assemblies?.Where (a => !a.Ignore).Sum (a => (long)a.DataSize) ?? 0;
+				profile.AssemblyStores.Add ($"{store.TargetArch}: assemblies={store.AssemblyCount}, indexed={store.IndexEntryCount}, size={storeSize}");
+				profile.AssemblyStoreSize += storeSize;
+			}
+
+			foreach (var item in explorer.Assemblies.Where (a => !a.Ignore && a.Name.EndsWith (".dll", StringComparison.OrdinalIgnoreCase) && !a.Name.EndsWith (".ni.dll", StringComparison.OrdinalIgnoreCase))) {
+				profile.ManagedAssemblyNames.Add (item.Name);
+				using var stream = explorer.ReadImageData (item);
+				if (stream == null) {
+					continue;
+				}
+
+				using var assemblyStream = GetManagedAssemblyStream (stream, item.Name);
+				AssemblyDefinition assembly;
+				try {
+					assembly = AssemblyDefinition.ReadAssembly (assemblyStream);
+				} catch (BadImageFormatException ex) {
+					Assert.Fail ($"Assembly store entry '{item.Name}' should contain a readable managed assembly: {ex.Message}. First bytes: {ReadFirstBytes (assemblyStream)}");
+					throw;
+				}
+				using (assembly) {
+					profile.ManagedAssemblyCount++;
+					foreach (var type in assembly.Modules.SelectMany (m => m.Types).SelectMany (FlattenType)) {
+						if (IsTypemapHelperManagedType (type.FullName)) {
+							continue;
+						}
+
+						profile.RawManagedTypeCount++;
+						profile.RawManagedMethodCount += type.Methods.Count;
+
+						if (!IsManagedTypemapEligible (type, profile)) {
+							continue;
+						}
+
+						profile.FilteredManagedTypeCount++;
+						profile.FilteredManagedMethodCount += type.Methods.Count;
+						profile.ManagedTypemapEntries.Add ($"type {type.FullName}");
+						foreach (var method in type.Methods) {
+							profile.ManagedTypemapEntries.Add ($"method {type.FullName}::{GetManagedMethodSignature (method)}");
+						}
+					}
+				}
+			}
+		}
+
+		bool IsManagedTypemapEligible (TypeDefinition type, ApkComparisonProfile profile)
+		{
+			if (profile.CandidateManagedTypes.Contains (type.FullName)) {
+				return true;
+			}
+
+			var isTypemapEligible = false;
+			foreach (var attribute in type.CustomAttributes) {
+				var attributeName = attribute.AttributeType.FullName;
+				if (attributeName != "Android.Runtime.RegisterAttribute" && attributeName != "Java.Interop.JniTypeSignatureAttribute") {
+					continue;
+				}
+
+				isTypemapEligible = true;
+				if (attribute.ConstructorArguments.Count > 0 && attribute.ConstructorArguments [0].Value is string jniName) {
+					jniName = NormalizeJniName (jniName);
+					if (!IsTypemapHelperJavaType (jniName)) {
+						profile.CandidateJavaNames.Add (jniName);
+					}
+				}
+			}
+
+			return isTypemapEligible;
+		}
+
+		string GetManagedMethodSignature (MethodDefinition method)
+		{
+			var parameters = String.Join (",", method.Parameters.Select (p => p.ParameterType.FullName));
+			return $"{method.Name}({parameters}):{method.ReturnType.FullName}";
+		}
+
+		string NormalizeJniName (string jniName)
+		{
+			if (jniName.Length >= 2 && jniName [0] == 'L' && jniName [jniName.Length - 1] == ';') {
+				return jniName.Substring (1, jniName.Length - 2);
+			}
+
+			return jniName;
+		}
+
+		string ReadFirstBytes (Stream stream)
+		{
+			var position = stream.Position;
+			stream.Seek (0, SeekOrigin.Begin);
+			var bytes = new byte [Math.Min (16, stream.Length)];
+			stream.ReadExactly (bytes, 0, bytes.Length);
+			stream.Seek (position, SeekOrigin.Begin);
+			return BitConverter.ToString (bytes);
+		}
+
+		Stream GetManagedAssemblyStream (Stream stream, string name)
+		{
+			(ulong elfPayloadOffset, ulong elfPayloadSize, var error) = Xamarin.Android.AssemblyStore.Utils.FindELFPayloadSectionOffsetAndSize (stream);
+			Assert.IsTrue (
+				error == ELFPayloadError.None || error == ELFPayloadError.NotELF,
+				$"{name} should be a managed assembly or an ELF image containing one. ELF payload error: {error}");
+
+			if (elfPayloadOffset == 0) {
+				stream.Seek (0, SeekOrigin.Begin);
+				var copy = new MemoryStream ();
+				stream.CopyTo (copy);
+				copy.Seek (0, SeekOrigin.Begin);
+				return DecompressAssemblyIfNeeded (copy);
+			}
+
+			var payload = new MemoryStream ();
+			var buffer = new byte [16 * 1024];
+			var remaining = elfPayloadSize;
+			stream.Seek ((long)elfPayloadOffset, SeekOrigin.Begin);
+			while (remaining > 0) {
+				var read = stream.Read (buffer, 0, (int)Math.Min ((ulong)buffer.Length, remaining));
+				if (read == 0) {
+					break;
+				}
+				payload.Write (buffer, 0, read);
+				remaining -= (ulong)read;
+			}
+			payload.Seek (0, SeekOrigin.Begin);
+			return DecompressAssemblyIfNeeded (payload);
+		}
+
+		Stream DecompressAssemblyIfNeeded (Stream stream)
+		{
+			using var reader = new BinaryReader (stream, Encoding.UTF8, leaveOpen: true);
+			var magic = reader.ReadUInt32 ();
+			if (magic != CompressedAssemblyMagic) {
+				stream.Seek (0, SeekOrigin.Begin);
+				return stream;
+			}
+
+			reader.ReadUInt32 ();
+			var decompressedLength = reader.ReadUInt32 ();
+			var compressedLength = (int)(stream.Length - stream.Position);
+			var compressed = new byte [compressedLength];
+			stream.ReadExactly (compressed, 0, compressed.Length);
+
+			var decompressed = new byte [decompressedLength];
+			var decoded = LZ4Codec.Decode (compressed, 0, compressed.Length, decompressed, 0, decompressed.Length);
+			Assert.AreEqual ((int)decompressedLength, decoded, "Compressed assembly should decompress to the expected size.");
+			stream.Dispose ();
+			return new MemoryStream (decompressed, 0, decoded, writable: false);
+		}
+
+		IEnumerable<TypeDefinition> FlattenType (TypeDefinition type)
+		{
+			yield return type;
+			foreach (var nested in type.NestedTypes) {
+				foreach (var nestedType in FlattenType (nested)) {
+					yield return nestedType;
+				}
+			}
+		}
+
+		void ReadDexProfile (ApkComparisonProfile profile)
+		{
+			using var zip = ZipFile.OpenRead (profile.ApkPath);
+			foreach (var entry in zip.Entries.Where (e => Regex.IsMatch (e.FullName, @"^classes(\d*)\.dex$", RegexOptions.CultureInvariant))) {
+				using var stream = entry.Open ();
+				using var memory = new MemoryStream ();
+				stream.CopyTo (memory);
+				var bytes = memory.ToArray ();
+
+				profile.DexSize += bytes.Length;
+
+				var dex = DexProfileReader.Read (bytes);
+				profile.DexFiles.Add ($"{entry.FullName}: size={bytes.Length}, classes={dex.Classes.Count}");
+				profile.DexStringIdCount += dex.StringIdCount;
+				profile.DexTypeIdCount += dex.TypeIdCount;
+				profile.DexProtoIdCount += dex.ProtoIdCount;
+				profile.DexFieldIdCount += dex.FieldIdCount;
+				profile.DexMethodIdCount += dex.MethodIdCount;
+				profile.DexDataSize += dex.DataSize;
+				profile.RawJavaClassCount += dex.Classes.Count;
+				profile.RawJavaMethodCount += dex.Classes.Sum (c => c.Methods.Count);
+
+				foreach (var javaClass in dex.Classes) {
+					profile.JavaClassNames.Add (javaClass.Name);
+					if (IsTypemapHelperJavaType (javaClass.Name) || !profile.CandidateJavaNames.Contains (javaClass.Name)) {
+						continue;
+					}
+
+					profile.FilteredJavaClassCount++;
+					profile.FilteredJavaMethodCount += javaClass.Methods.Count;
+					profile.JavaTypemapEntries.Add ($"class {javaClass.Name}");
+					foreach (var method in javaClass.Methods) {
+						profile.JavaTypemapEntries.Add ($"method {javaClass.Name}->{method}");
+					}
+				}
+			}
+		}
+
+		bool IsTypemapHelperManagedType (string typeName)
+		{
+			return typeName.StartsWith ("_TypeMap.", StringComparison.Ordinal) ||
+				typeName.StartsWith ("_Microsoft.Android.TypeMaps", StringComparison.Ordinal) ||
+				typeName.EndsWith ("/__TypeMapAnchor", StringComparison.Ordinal) ||
+				typeName == "Android.Runtime.JavaProxyThrowable" ||
+				typeName.IndexOf ("JavaPeerProxy", StringComparison.Ordinal) >= 0 ||
+				typeName.IndexOf ("TypeMapProvider", StringComparison.Ordinal) >= 0 ||
+				typeName.IndexOf ("TypeMapping", StringComparison.Ordinal) >= 0;
+		}
+
+		bool IsTypemapHelperJavaType (string jniName)
+		{
+			return jniName.StartsWith ("net/dot/android/", StringComparison.Ordinal) ||
+				jniName.StartsWith ("mono/android/", StringComparison.Ordinal) ||
+				jniName.IndexOf ("JavaPeerProxy", StringComparison.Ordinal) >= 0 ||
+				jniName.IndexOf ("TypeMap", StringComparison.Ordinal) >= 0;
+		}
+
+		void WriteComparisonDiagnostics (ApkComparisonProfile llvmIr, ApkComparisonProfile trimmable)
+		{
+			var managedDiff = GetEntryDiff (llvmIr.ManagedTypemapEntries, trimmable.ManagedTypemapEntries);
+			var javaDiff = GetEntryDiff (llvmIr.JavaTypemapEntries, trimmable.JavaTypemapEntries);
+			var javaClassDiff = GetEntryDiff (llvmIr.JavaClassNames, trimmable.JavaClassNames);
+
+			TestContext.Out.WriteLine ("APK contents comparison: llvm-ir vs trimmable typemap");
+			WriteComparisonTable (llvmIr, trimmable, managedDiff, javaDiff);
+			WriteSize ("APK", llvmIr.ApkSize, trimmable.ApkSize);
+			WriteSize ("assembly stores", llvmIr.AssemblyStoreSize, trimmable.AssemblyStoreSize);
+			WriteSize ("classes*.dex", llvmIr.DexSize, trimmable.DexSize);
+			WriteProfile (llvmIr);
+			WriteProfile (trimmable);
+			WriteEntryDiff ("managed typemap entries", managedDiff);
+			WriteEntryDiff ("Java typemap entries", javaDiff);
+			WriteEntryDiff ("Java classes", javaClassDiff);
+		}
+
+		void WriteComparisonTable (ApkComparisonProfile llvmIr, ApkComparisonProfile trimmable, EntryDiff managedDiff, EntryDiff javaDiff)
+		{
+			TestContext.Out.WriteLine ("| Metric | llvm-ir | trimmable |");
+			TestContext.Out.WriteLine ("|---|---:|---:|");
+			TestContext.Out.WriteLine ($"| APK size | {FormatNumber (llvmIr.ApkSize)} | {FormatNumber (trimmable.ApkSize)} |");
+			TestContext.Out.WriteLine ($"| Assembly-store payload | {FormatNumber (llvmIr.AssemblyStoreSize)} | {FormatNumber (trimmable.AssemblyStoreSize)} |");
+			TestContext.Out.WriteLine ($"| classes*.dex | {FormatNumber (llvmIr.DexSize)} | {FormatNumber (trimmable.DexSize)} |");
+			TestContext.Out.WriteLine ($"| Filtered managed types / methods | {FormatNumber (llvmIr.FilteredManagedTypeCount)} / {FormatNumber (llvmIr.FilteredManagedMethodCount)} | {FormatNumber (trimmable.FilteredManagedTypeCount)} / {FormatNumber (trimmable.FilteredManagedMethodCount)} |");
+			TestContext.Out.WriteLine ($"| Managed diff | {FormatNumber (managedDiff.LlvmIrOnly.Length)} llvm-ir-only | {FormatNumber (managedDiff.TrimmableOnly.Length)} trimmable-only |");
+			TestContext.Out.WriteLine ($"| Java diff | {FormatNumber (javaDiff.LlvmIrOnly.Length)} llvm-ir-only | {FormatNumber (javaDiff.TrimmableOnly.Length)} trimmable-only |");
+		}
+
+		string FormatNumber (long value) => value.ToString ("N0", CultureInfo.InvariantCulture);
+
+		void WriteProfile (ApkComparisonProfile profile)
+		{
+			TestContext.Out.WriteLine ($"{profile.Name}: apk={profile.ApkSize} bytes, stores={profile.AssemblyStoreCount}, store-bytes={profile.AssemblyStoreSize}, dex-bytes={profile.DexSize}");
+			TestContext.Out.WriteLine ($"{profile.Name}: managed assemblies={profile.ManagedAssemblyCount}, raw types={profile.RawManagedTypeCount}, raw methods={profile.RawManagedMethodCount}, filtered types={profile.FilteredManagedTypeCount}, filtered methods={profile.FilteredManagedMethodCount}");
+			TestContext.Out.WriteLine ($"{profile.Name}: raw Java classes={profile.RawJavaClassCount}, raw Java methods={profile.RawJavaMethodCount}, filtered classes={profile.FilteredJavaClassCount}, filtered methods={profile.FilteredJavaMethodCount}");
+			TestContext.Out.WriteLine ($"{profile.Name}: dex ids: strings={profile.DexStringIdCount}, types={profile.DexTypeIdCount}, protos={profile.DexProtoIdCount}, fields={profile.DexFieldIdCount}, methods={profile.DexMethodIdCount}, data-size={profile.DexDataSize}");
+			TestContext.Out.WriteLine ($"{profile.Name}: generated Java sources={profile.GeneratedJavaSourceCount}, __md_methods files={profile.GeneratedJavaWithMdMethodsCount}, Runtime.register files={profile.GeneratedJavaWithRuntimeRegisterCount}, Runtime.registerNatives files={profile.GeneratedJavaWithRegisterNativesCount}");
+			TestContext.Out.WriteLine ($"{profile.Name}: assembly stores: {String.Join ("; ", profile.AssemblyStores)}");
+			TestContext.Out.WriteLine ($"{profile.Name}: dex files: {String.Join ("; ", profile.DexFiles)}");
+		}
+
+		void WriteSize (string label, long llvmIr, long trimmable)
+		{
+			var ratio = llvmIr == 0 ? 0 : (double)trimmable / llvmIr;
+			TestContext.Out.WriteLine ($"{label}: llvm-ir={llvmIr}, trimmable={trimmable}, delta={trimmable - llvmIr}, ratio={ratio:0.000}");
+		}
+
+		EntryDiff GetEntryDiff (ISet<string> llvmIr, ISet<string> trimmable)
+		{
+			var llvmOnly = llvmIr.Except (trimmable, StringComparer.Ordinal).OrderBy (x => x, StringComparer.Ordinal).ToArray ();
+			var trimmableOnly = trimmable.Except (llvmIr, StringComparer.Ordinal).OrderBy (x => x, StringComparer.Ordinal).ToArray ();
+			var common = llvmIr.Intersect (trimmable, StringComparer.Ordinal).Count ();
+
+			return new EntryDiff (llvmOnly, trimmableOnly, common);
+		}
+
+		void WriteEntryDiff (string label, EntryDiff diff)
+		{
+			TestContext.Out.WriteLine ($"{label}: llvm-ir only={diff.LlvmIrOnly.Length}, trimmable only={diff.TrimmableOnly.Length}, common={diff.Common}");
+			WriteSample ($"{label} llvm-ir only", diff.LlvmIrOnly);
+			WriteSample ($"{label} trimmable only", diff.TrimmableOnly);
+		}
+
+		void WriteSample (string label, string [] entries)
+		{
+			if (entries.Length == 0) {
+				return;
+			}
+
+			TestContext.Out.WriteLine ($"{label}:");
+			foreach (var entry in entries.Take (50)) {
+				TestContext.Out.WriteLine ($"  {entry}");
+			}
+			if (entries.Length > 50) {
+				TestContext.Out.WriteLine ($"  ... {entries.Length - 50} more");
+			}
+		}
+
+		class ApkComparisonProfile
+		{
+			public string Name;
+			public string ApkPath;
+			public long ApkSize;
+			public int AssemblyStoreCount;
+			public long AssemblyStoreSize;
+			public long DexSize;
+			public int ManagedAssemblyCount;
+			public int RawManagedTypeCount;
+			public int RawManagedMethodCount;
+			public int FilteredManagedTypeCount;
+			public int FilteredManagedMethodCount;
+			public int RawJavaClassCount;
+			public int RawJavaMethodCount;
+			public int FilteredJavaClassCount;
+			public int FilteredJavaMethodCount;
+			public int DexStringIdCount;
+			public int DexTypeIdCount;
+			public int DexProtoIdCount;
+			public int DexFieldIdCount;
+			public int DexMethodIdCount;
+			public int DexDataSize;
+			public int GeneratedJavaSourceCount;
+			public int GeneratedJavaWithMdMethodsCount;
+			public int GeneratedJavaWithRuntimeRegisterCount;
+			public int GeneratedJavaWithRegisterNativesCount;
+			public readonly List<string> AssemblyStores = new List<string> ();
+			public readonly List<string> DexFiles = new List<string> ();
+			public readonly HashSet<string> ManagedAssemblyNames = new HashSet<string> (StringComparer.Ordinal);
+			public readonly HashSet<string> CandidateManagedTypes = new HashSet<string> (StringComparer.Ordinal);
+			public readonly HashSet<string> CandidateJavaNames = new HashSet<string> (StringComparer.Ordinal);
+			public readonly HashSet<string> ManagedTypemapEntries = new HashSet<string> (StringComparer.Ordinal);
+			public readonly HashSet<string> JavaTypemapEntries = new HashSet<string> (StringComparer.Ordinal);
+			public readonly HashSet<string> JavaClassNames = new HashSet<string> (StringComparer.Ordinal);
+		}
+
+		class EntryDiff
+		{
+			public EntryDiff (string [] llvmIrOnly, string [] trimmableOnly, int common)
+			{
+				LlvmIrOnly = llvmIrOnly;
+				TrimmableOnly = trimmableOnly;
+				Common = common;
+			}
+
+			public string [] LlvmIrOnly { get; }
+			public string [] TrimmableOnly { get; }
+			public int Common { get; }
+		}
+
+		class DexClass
+		{
+			public string Name;
+			public readonly List<string> Methods = new List<string> ();
+		}
+
+		class DexProfile
+		{
+			public readonly List<DexClass> Classes = new List<DexClass> ();
+			public int StringIdCount { get; set; }
+			public int TypeIdCount { get; set; }
+			public int ProtoIdCount { get; set; }
+			public int FieldIdCount { get; set; }
+			public int MethodIdCount { get; set; }
+			public int DataSize { get; set; }
+		}
+
+		class DexProfileReader
+		{
+			readonly byte [] data;
+
+			DexProfileReader (byte [] data)
+			{
+				this.data = data;
+			}
+
+			public static DexProfile Read (byte [] data) => new DexProfileReader (data).ReadProfile ();
+
+			DexProfile ReadProfile ()
+			{
+				Assert.AreEqual ((byte)'d', data [0], "classes.dex magic should start with dex.");
+				Assert.AreEqual ((byte)'e', data [1], "classes.dex magic should start with dex.");
+				Assert.AreEqual ((byte)'x', data [2], "classes.dex magic should start with dex.");
+
+				var strings = ReadStrings ();
+				var typeIds = ReadTypeIds (strings);
+				var protoIds = ReadProtoIds (typeIds);
+				var methodIds = ReadMethodIds (strings, protoIds);
+				var profile = new DexProfile {
+					StringIdCount = strings.Length,
+					TypeIdCount = typeIds.Length,
+					ProtoIdCount = protoIds.Length,
+					FieldIdCount = ReadInt32 (80),
+					MethodIdCount = methodIds.Length,
+					DataSize = ReadInt32 (104),
+				};
+
+				var classDefsSize = ReadInt32 (96);
+				var classDefsOffset = ReadInt32 (100);
+				for (int i = 0; i < classDefsSize; i++) {
+					var classDefOffset = classDefsOffset + i * 32;
+					var classIdx = ReadInt32 (classDefOffset);
+					var classDataOffset = ReadInt32 (classDefOffset + 24);
+					var dexClass = new DexClass {
+						Name = DescriptorToJniName (GetItem (typeIds, classIdx, "class type")),
+					};
+
+					if (classDataOffset != 0) {
+						ReadClassData (classDataOffset, methodIds, dexClass);
+					}
+
+					profile.Classes.Add (dexClass);
+				}
+
+				return profile;
+			}
+
+			string [] ReadStrings ()
+			{
+				var stringsSize = ReadInt32 (56);
+				var stringsOffset = ReadInt32 (60);
+				var strings = new string [stringsSize];
+				for (int i = 0; i < stringsSize; i++) {
+					var offset = ReadInt32 (stringsOffset + i * 4);
+					ReadUleb128 (ref offset);
+					var start = offset;
+					while (true) {
+						EnsureAvailable (offset, 1, "string data");
+						if (data [offset] == 0) {
+							break;
+						}
+						offset++;
+					}
+					strings [i] = Encoding.UTF8.GetString (data, start, offset - start);
+				}
+
+				return strings;
+			}
+
+			string [] ReadTypeIds (string [] strings)
+			{
+				var typeIdsSize = ReadInt32 (64);
+				var typeIdsOffset = ReadInt32 (68);
+				var typeIds = new string [typeIdsSize];
+				for (int i = 0; i < typeIdsSize; i++) {
+					typeIds [i] = GetItem (strings, ReadInt32 (typeIdsOffset + i * 4), "type descriptor string");
+				}
+
+				return typeIds;
+			}
+
+			string [] ReadProtoIds (string [] typeIds)
+			{
+				var protoIdsSize = ReadInt32 (72);
+				var protoIdsOffset = ReadInt32 (76);
+				var protoIds = new string [protoIdsSize];
+				for (int i = 0; i < protoIdsSize; i++) {
+					var returnType = GetItem (typeIds, ReadInt32 (protoIdsOffset + i * 12 + 4), "proto return type");
+					var parametersOffset = ReadInt32 (protoIdsOffset + i * 12 + 8);
+					protoIds [i] = $"({ReadTypeList (parametersOffset, typeIds)}){returnType}";
+				}
+
+				return protoIds;
+			}
+
+			string ReadTypeList (int offset, string [] typeIds)
+			{
+				if (offset == 0) {
+					return "";
+				}
+
+				var count = ReadInt32 (offset);
+				var builder = new StringBuilder ();
+				offset += 4;
+				for (int i = 0; i < count; i++) {
+					builder.Append (GetItem (typeIds, ReadUInt16 (offset + i * 2), "proto parameter type"));
+				}
+				return builder.ToString ();
+			}
+
+			string [] ReadMethodIds (string [] strings, string [] protoIds)
+			{
+				var methodIdsSize = ReadInt32 (88);
+				var methodIdsOffset = ReadInt32 (92);
+				var methodIds = new string [methodIdsSize];
+				for (int i = 0; i < methodIdsSize; i++) {
+					var protoIdx = ReadUInt16 (methodIdsOffset + i * 8 + 2);
+					methodIds [i] = GetItem (strings, ReadInt32 (methodIdsOffset + i * 8 + 4), "method name string") + GetItem (protoIds, protoIdx, "method prototype");
+				}
+
+				return methodIds;
+			}
+
+			void ReadClassData (int offset, string [] methodIds, DexClass dexClass)
+			{
+				var staticFieldsSize = ReadUleb128 (ref offset);
+				var instanceFieldsSize = ReadUleb128 (ref offset);
+				var directMethodsSize = ReadUleb128 (ref offset);
+				var virtualMethodsSize = ReadUleb128 (ref offset);
+
+				SkipEncodedFields (staticFieldsSize, ref offset);
+				SkipEncodedFields (instanceFieldsSize, ref offset);
+				ReadEncodedMethods (directMethodsSize, methodIds, dexClass, ref offset);
+				ReadEncodedMethods (virtualMethodsSize, methodIds, dexClass, ref offset);
+			}
+
+			void SkipEncodedFields (int count, ref int offset)
+			{
+				for (int i = 0; i < count; i++) {
+					ReadUleb128 (ref offset);
+					ReadUleb128 (ref offset);
+				}
+			}
+
+			void ReadEncodedMethods (int count, string [] methodIds, DexClass dexClass, ref int offset)
+			{
+				var methodIndex = 0;
+				for (int i = 0; i < count; i++) {
+					methodIndex += ReadUleb128 (ref offset);
+					ReadUleb128 (ref offset);
+					ReadUleb128 (ref offset);
+					dexClass.Methods.Add (GetItem (methodIds, methodIndex, "encoded method"));
+				}
+			}
+
+			int ReadInt32 (int offset)
+			{
+				EnsureAvailable (offset, 4, "uint");
+				return data [offset] |
+					(data [offset + 1] << 8) |
+					(data [offset + 2] << 16) |
+					(data [offset + 3] << 24);
+			}
+
+			int ReadUInt16 (int offset)
+			{
+				EnsureAvailable (offset, 2, "ushort");
+				return data [offset] |
+					(data [offset + 1] << 8);
+			}
+
+			int ReadUleb128 (ref int offset)
+			{
+				var result = 0;
+				var shift = 0;
+				int value;
+				do {
+					EnsureAvailable (offset, 1, "ULEB128");
+					value = data [offset++];
+					result |= (value & 0x7f) << shift;
+					shift += 7;
+				} while ((value & 0x80) != 0);
+
+				return result;
+			}
+
+			T GetItem<T> (T [] items, int index, string description)
+			{
+				Assert.IsTrue (index >= 0 && index < items.Length, $"Invalid {description} index {index}; table has {items.Length} entries.");
+				return items [index];
+			}
+
+			void EnsureAvailable (int offset, int count, string description)
+			{
+				Assert.IsTrue (offset >= 0 && count >= 0 && offset <= data.Length - count, $"DEX {description} read at offset {offset} with size {count} exceeds file size {data.Length}.");
+			}
+
+			string DescriptorToJniName (string descriptor)
+			{
+				if (descriptor.Length >= 2 && descriptor [0] == 'L' && descriptor [descriptor.Length - 1] == ';') {
+					return descriptor.Substring (1, descriptor.Length - 2);
+				}
+
+				return descriptor;
+			}
+		}
 	}
 }

From 0b7703a80144a52dc41b0ed34eed8d468671be6d Mon Sep 17 00:00:00 2001
From: Simon Rozsival <simon@rozsival.com>
Date: Thu, 14 May 2026 13:58:22 +0200
Subject: [PATCH 2/6] Enable R8 shrinking for trimmable typemap comparison

Generate proguard keep rules for the CoreCLR trimmable typemap path from the linked assemblies, matching the llvm-ir path, and make the APK comparison test use R8 so dex contents are actually shrunk.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 ...roid.Sdk.TypeMap.Trimmable.CoreCLR.targets | 22 +++++++++++++++++++
 ...soft.Android.Sdk.TypeMap.Trimmable.targets |  1 +
 .../TrimmableTypeMapBuildTests.cs             |  1 +
 3 files changed, 24 insertions(+)

diff --git a/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.CoreCLR.targets b/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.CoreCLR.targets
index c27922166c1..43406ea56be 100644
--- a/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.CoreCLR.targets
+++ b/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.CoreCLR.targets
@@ -5,6 +5,10 @@
     <_TrimmableRuntimeProviderJavaName Condition=" '$(_TrimmableRuntimeProviderJavaName)' == '' ">mono.MonoRuntimeProvider</_TrimmableRuntimeProviderJavaName>
   </PropertyGroup>
 
+  <PropertyGroup>
+    <_GenerateProguardAfterTargets Condition=" '$(_GenerateProguardAfterTargets)' == '' ">ILLink</_GenerateProguardAfterTargets>
+  </PropertyGroup>
+
   <!-- Add TypeMap DLLs to ILLink input. ILLink natively understands TypeMapAttribute<T>. -->
   <Target Name="_AddTrimmableTypeMapToLinker"
       BeforeTargets="PrepareForILLink;_RunILLink"
@@ -32,6 +36,24 @@
     </ItemGroup>
   </Target>
 
+  <Target Name="_PrepareLinkedAssembliesForProguard"
+      AfterTargets="$(_GenerateProguardAfterTargets)"
+      Condition=" '$(PublishTrimmed)' == 'true' and '$(_ProguardProjectConfiguration)' != '' ">
+    <ItemGroup>
+      <_LinkedAssemblyForProguard Include="@(ResolvedFileToPublish)" Condition=" '%(Extension)' == '.dll' " />
+    </ItemGroup>
+  </Target>
+
+  <Target Name="_GenerateProguardConfiguration"
+      AfterTargets="_PrepareLinkedAssembliesForProguard"
+      Condition=" '$(PublishTrimmed)' == 'true' and '$(_ProguardProjectConfiguration)' != '' "
+      Inputs="@(_LinkedAssemblyForProguard)"
+      Outputs="$(_ProguardProjectConfiguration)">
+    <GenerateProguardConfiguration
+        LinkedAssemblies="@(_LinkedAssemblyForProguard)"
+        OutputFile="$(_ProguardProjectConfiguration)" />
+  </Target>
+
   <!-- Add TypeMap DLLs to assembly store with per-ABI metadata.
        TypeMap DLLs are ABI-agnostic (pure IL), so the same DLLs are added for every ABI.
        This target batches over @(_BuildTargetAbis) to add items per-ABI. -->
diff --git a/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.targets b/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.targets
index 88e4683d37d..7d03164da34 100644
--- a/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.targets
+++ b/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.targets
@@ -4,6 +4,7 @@
   <UsingTask TaskName="Xamarin.Android.Tasks.GenerateTrimmableTypeMap" AssemblyFile="$(_XamarinAndroidBuildTasksAssembly)" />
   <UsingTask TaskName="Xamarin.Android.Tasks.GenerateEmptyTypemapStub" AssemblyFile="$(_XamarinAndroidBuildTasksAssembly)" />
   <UsingTask TaskName="Xamarin.Android.Tasks.GenerateNativeAotBootstrapSources" AssemblyFile="$(_XamarinAndroidBuildTasksAssembly)" />
+  <UsingTask TaskName="Xamarin.Android.Tasks.GenerateProguardConfiguration" AssemblyFile="$(_XamarinAndroidBuildTasksAssembly)" />
 
   <Import Project="$(MSBuildThisFileDirectory)Microsoft.Android.Sdk.TypeMap.Trimmable.CoreCLR.targets"
       Condition=" '$(_AndroidRuntime)' == 'CoreCLR' " />
diff --git a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/TrimmableTypeMapBuildTests.cs b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/TrimmableTypeMapBuildTests.cs
index 068cea291f5..65a39960a18 100644
--- a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/TrimmableTypeMapBuildTests.cs
+++ b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/TrimmableTypeMapBuildTests.cs
@@ -191,6 +191,7 @@ ApkComparisonProfile BuildTypemapComparisonApk (string typemapImplementation)
 			proj.SetRuntime (AndroidRuntime.CoreCLR);
 			proj.SetProperty ("AndroidSupportedAbis", "arm64-v8a");
 			proj.SetProperty ("AndroidPackageFormat", "apk");
+			proj.SetProperty (KnownProperties.AndroidLinkTool, "r8");
 			proj.SetProperty ("TrimMode", "full");
 			proj.SetProperty ("_AndroidTypeMapImplementation", typemapImplementation);
 

From 77ee9e0cb3a2b298839c0daf745b2b56cab7df2e Mon Sep 17 00:00:00 2001
From: Simon Rozsival <simon@rozsival.com>
Date: Thu, 14 May 2026 14:08:13 +0200
Subject: [PATCH 3/6] Pass per-assembly typemap entries to ILLink

Limit --typemap-entry-assembly arguments to generated per-assembly *.TypeMap.dll assemblies that contain TypeMapAttribute entries, instead of treating the root typemap loader assembly as an entry assembly.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 .../Microsoft.Android.Sdk.TypeMap.Trimmable.CoreCLR.targets     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.CoreCLR.targets b/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.CoreCLR.targets
index 43406ea56be..4d3b1470ee2 100644
--- a/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.CoreCLR.targets
+++ b/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.CoreCLR.targets
@@ -26,7 +26,7 @@
       BeforeTargets="PrepareForILLink;_RunILLink"
       DependsOnTargets="_GenerateTrimmableTypeMap">
     <ItemGroup>
-      <_TrimmableTypeMapEntryAssemblies Include="$(_TypeMapOutputDirectory)*.dll" />
+      <_TrimmableTypeMapEntryAssemblies Include="$(_TypeMapOutputDirectory)*.TypeMap.dll" />
     </ItemGroup>
     <PropertyGroup>
       <_ExtraTrimmerArgs>@(_TrimmableTypeMapEntryAssemblies->'--typemap-entry-assembly %(Filename)', ' ') $(_ExtraTrimmerArgs)</_ExtraTrimmerArgs>

From 7a654675370199f9a1445ac8bea9663fb9106e67 Mon Sep 17 00:00:00 2001
From: Simon Rozsival <simon@rozsival.com>
Date: Thu, 14 May 2026 16:23:53 +0200
Subject: [PATCH 4/6] Refine trimmable typemap framework roots

Keep SDK framework ACWs conditional unless they are explicitly rooted, and pass framework assembly names through trimmable typemap generation. This allows Mono.Android implementor entries to be trimmed while preserving app ACWs and scanner-rooted components.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 .../Generator/ModelBuilder.cs                 |   2 +-
 .../Scanner/JavaPeerInfo.cs                   |   7 +
 .../TrimmableTypeMapGenerator.cs              |  10 ++
 ...soft.Android.Sdk.TypeMap.Trimmable.targets |   1 +
 .../Tasks/GenerateTrimmableTypeMap.cs         |  22 +++-
 .../TrimmableTypeMapBuildTests.cs             | 122 +++++++++++++++++-
 .../Generator/TypeMapModelBuilderTests.cs     |  26 ++++
 7 files changed, 183 insertions(+), 7 deletions(-)

diff --git a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/ModelBuilder.cs b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/ModelBuilder.cs
index 25e9db22008..a1805b8253b 100644
--- a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/ModelBuilder.cs
+++ b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/ModelBuilder.cs
@@ -226,7 +226,7 @@ static bool IsUnconditionalEntry (JavaPeerInfo peer)
 
 		// User-defined ACW types (not MCW bindings, not interfaces) are unconditional
 		// because Android can instantiate them from Java at any time.
-		if (!peer.DoNotGenerateAcw && !peer.IsInterface) {
+		if (!peer.IsFrameworkAssembly && !peer.DoNotGenerateAcw && !peer.IsInterface) {
 			return true;
 		}
 
diff --git a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/JavaPeerInfo.cs b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/JavaPeerInfo.cs
index 97606a4b5af..6b30ec1d3ef 100644
--- a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/JavaPeerInfo.cs
+++ b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/JavaPeerInfo.cs
@@ -43,6 +43,13 @@ public sealed record JavaPeerInfo
 	/// </summary>
 	public required string AssemblyName { get; init; }
 
+	/// <summary>
+	/// True when the type belongs to a framework assembly supplied by the Android SDK.
+	/// Framework ACWs are generated by the SDK and can be trimmed like bindings unless
+	/// another rule explicitly roots them.
+	/// </summary>
+	public bool IsFrameworkAssembly { get; set; }
+
 	/// <summary>
 	/// JNI name of the base Java type, e.g., "android/app/Activity" for a type
 	/// that extends Activity. Null for java/lang/Object or types without a Java base.
diff --git a/src/Microsoft.Android.Sdk.TrimmableTypeMap/TrimmableTypeMapGenerator.cs b/src/Microsoft.Android.Sdk.TrimmableTypeMap/TrimmableTypeMapGenerator.cs
index 4851fde0857..35c55c6834f 100644
--- a/src/Microsoft.Android.Sdk.TrimmableTypeMap/TrimmableTypeMapGenerator.cs
+++ b/src/Microsoft.Android.Sdk.TrimmableTypeMap/TrimmableTypeMapGenerator.cs
@@ -48,6 +48,7 @@ public TrimmableTypeMapResult Execute (
 			logger.LogNoJavaPeerTypesFound ();
 			return new TrimmableTypeMapResult ([], [], allPeers);
 		}
+		MarkFrameworkAssemblyPeers (allPeers, frameworkAssemblyNames);
 
 		RootManifestReferencedTypes (allPeers, PrepareManifestForRooting (manifestTemplate, manifestConfig));
 		PropagateDeferredRegistrationToBaseClasses (allPeers);
@@ -188,6 +189,15 @@ List<GeneratedAssembly> GenerateTypeMapAssemblies (List<JavaPeerInfo> allPeers,
 		return generatedAssemblies;
 	}
 
+	static void MarkFrameworkAssemblyPeers (List<JavaPeerInfo> allPeers, HashSet<string> frameworkAssemblyNames)
+	{
+		foreach (var peer in allPeers) {
+			if (frameworkAssemblyNames.Contains (peer.AssemblyName)) {
+				peer.IsFrameworkAssembly = true;
+			}
+		}
+	}
+
 	/// <summary>
 	/// Groups peers by assembly, merging cross-assembly aliases into a single group.
 	/// When the same JNI name appears in multiple assemblies (e.g. <c>Java.Lang.Object</c>
diff --git a/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.targets b/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.targets
index 7d03164da34..b95d4212a65 100644
--- a/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.targets
+++ b/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.targets
@@ -79,6 +79,7 @@
 
     <GenerateTrimmableTypeMap
         ResolvedAssemblies="@(_TypeMapInputAssemblies)"
+        FrameworkAssemblyNames="@(ResolvedFrameworkAssemblies->'%(Filename)')"
         OutputDirectory="$(_TypeMapOutputDirectory)"
         JavaSourceOutputDirectory="$(_TypeMapJavaOutputDirectory)"
         TargetFrameworkVersion="$(TargetFrameworkVersion)"
diff --git a/src/Xamarin.Android.Build.Tasks/Tasks/GenerateTrimmableTypeMap.cs b/src/Xamarin.Android.Build.Tasks/Tasks/GenerateTrimmableTypeMap.cs
index c58b43fa1d2..8b60304d453 100644
--- a/src/Xamarin.Android.Build.Tasks/Tasks/GenerateTrimmableTypeMap.cs
+++ b/src/Xamarin.Android.Build.Tasks/Tasks/GenerateTrimmableTypeMap.cs
@@ -15,6 +15,12 @@ namespace Xamarin.Android.Tasks;
 
 public class GenerateTrimmableTypeMap : AndroidTask
 {
+	static readonly string [] DefaultFrameworkAssemblyNames = [
+		"Java.Interop",
+		"Mono.Android",
+		"Mono.Android.Runtime",
+	];
+
 	sealed class MSBuildTrimmableTypeMapLogger (TaskLoggingHelper log) : ITrimmableTypeMapLogger
 	{
 		public void LogNoJavaPeerTypesFound () =>
@@ -43,6 +49,7 @@ public void LogManifestReferencedTypeNotFoundWarning (string javaTypeName) =>
 
 	[Required]
 	public ITaskItem [] ResolvedAssemblies { get; set; } = [];
+	public string [] FrameworkAssemblyNames { get; set; } = [];
 	[Required]
 	public string OutputDirectory { get; set; } = "";
 	[Required]
@@ -91,8 +98,13 @@ public override bool RunTask ()
 	{
 		var systemRuntimeVersion = ParseTargetFrameworkVersion (TargetFrameworkVersion);
 		var assemblyPaths = ResolvedAssemblies.Select (i => i.ItemSpec).Distinct ().ToList ();
-		// TODO(#10792): populate with framework assembly names to skip JCW generation for pre-compiled framework types
-		var frameworkAssemblyNames = new HashSet<string> (StringComparer.OrdinalIgnoreCase);
+		var frameworkAssemblyPaths = new HashSet<string> (ResolvedAssemblies
+			.Where (i => string.Equals (i.GetMetadata ("FrameworkAssembly"), "true", StringComparison.OrdinalIgnoreCase))
+			.Select (i => i.ItemSpec), StringComparer.OrdinalIgnoreCase);
+		var frameworkAssemblyNames = new HashSet<string> (DefaultFrameworkAssemblyNames, StringComparer.OrdinalIgnoreCase);
+		foreach (var assemblyName in FrameworkAssemblyNames) {
+			frameworkAssemblyNames.Add (assemblyName);
+		}
 
 		Directory.CreateDirectory (OutputDirectory);
 		Directory.CreateDirectory (JavaSourceOutputDirectory);
@@ -105,7 +117,11 @@ public override bool RunTask ()
 				var peReader = new PEReader (File.OpenRead (path));
 				peReaders.Add (peReader);
 				var mdReader = peReader.GetMetadataReader ();
-				assemblies.Add ((mdReader.GetString (mdReader.GetAssemblyDefinition ().Name), peReader));
+				var assemblyName = mdReader.GetString (mdReader.GetAssemblyDefinition ().Name);
+				assemblies.Add ((assemblyName, peReader));
+				if (frameworkAssemblyPaths.Contains (path)) {
+					frameworkAssemblyNames.Add (assemblyName);
+				}
 			}
 
 			ManifestConfig? manifestConfig = null;
diff --git a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/TrimmableTypeMapBuildTests.cs b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/TrimmableTypeMapBuildTests.cs
index 65a39960a18..98a7f66c6b0 100644
--- a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/TrimmableTypeMapBuildTests.cs
+++ b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/TrimmableTypeMapBuildTests.cs
@@ -207,8 +207,10 @@ ApkComparisonProfile BuildTypemapComparisonApk (string typemapImplementation)
 			var apkPath = Directory.GetFiles (apkDirectory, "*-Signed.apk", SearchOption.AllDirectories).Single ();
 			var acwMapPath = builder.Output.GetIntermediaryPath ("acw-map.txt");
 			var javaSourceDirectory = builder.Output.GetIntermediaryPath (Path.Combine ("android", "src"));
+			var typeMapDirectory = builder.Output.GetIntermediaryPath ("typemap");
+			var linkedAssemblyDirectory = builder.Output.GetIntermediaryPath (Path.Combine ("android-arm64", "linked"));
 
-			var profile = ReadApkProfile (typemapImplementation, apkPath, acwMapPath, javaSourceDirectory);
+			var profile = ReadApkProfile (typemapImplementation, apkPath, acwMapPath, javaSourceDirectory, typeMapDirectory, linkedAssemblyDirectory);
 			if (typemapImplementation == "trimmable") {
 				Assert.IsTrue (profile.ManagedAssemblyNames.Contains ("_Microsoft.Android.TypeMaps.dll"), "trimmable build should package the root managed typemap assembly.");
 			} else {
@@ -217,7 +219,7 @@ ApkComparisonProfile BuildTypemapComparisonApk (string typemapImplementation)
 			return profile;
 		}
 
-		ApkComparisonProfile ReadApkProfile (string name, string apkPath, string acwMapPath, string javaSourceDirectory)
+		ApkComparisonProfile ReadApkProfile (string name, string apkPath, string acwMapPath, string javaSourceDirectory, string typeMapDirectory, string linkedAssemblyDirectory)
 		{
 			var profile = new ApkComparisonProfile {
 				Name = name,
@@ -227,6 +229,8 @@ ApkComparisonProfile ReadApkProfile (string name, string apkPath, string acwMapP
 
 			LoadAcwMap (acwMapPath, profile);
 			ReadGeneratedJavaProfile (javaSourceDirectory, profile);
+			ReadTypeMapAssemblyProfile (profile, "generated", typeMapDirectory);
+			ReadTypeMapAssemblyProfile (profile, "linked", linkedAssemblyDirectory);
 			ReadAssemblyStoreProfile (profile);
 			ReadDexProfile (profile);
 
@@ -328,6 +332,9 @@ void ReadAssemblyStoreProfile (ApkComparisonProfile profile)
 				}
 				using (assembly) {
 					profile.ManagedAssemblyCount++;
+					if (item.Name.EndsWith (".TypeMap.dll", StringComparison.Ordinal) || item.Name == "_Microsoft.Android.TypeMaps.dll") {
+						ReadTypeMapAssemblyProfile (profile, "packaged", assembly, item.Name);
+					}
 					foreach (var type in assembly.Modules.SelectMany (m => m.Types).SelectMany (FlattenType)) {
 						if (IsTypemapHelperManagedType (type.FullName)) {
 							continue;
@@ -351,6 +358,66 @@ void ReadAssemblyStoreProfile (ApkComparisonProfile profile)
 			}
 		}
 
+		void ReadTypeMapAssemblyProfile (ApkComparisonProfile profile, string stage, string directory)
+		{
+			if (!Directory.Exists (directory)) {
+				return;
+			}
+
+			foreach (var file in Directory.EnumerateFiles (directory, "*.dll", SearchOption.TopDirectoryOnly).Where (IsTypeMapAssemblyPath)) {
+				using var assembly = AssemblyDefinition.ReadAssembly (file);
+				ReadTypeMapAssemblyProfile (profile, stage, assembly, Path.GetFileName (file));
+			}
+		}
+
+		bool IsTypeMapAssemblyPath (string file)
+		{
+			var name = Path.GetFileName (file);
+			return name.EndsWith (".TypeMap.dll", StringComparison.Ordinal) || name == "_Microsoft.Android.TypeMaps.dll";
+		}
+
+		void ReadTypeMapAssemblyProfile (ApkComparisonProfile profile, string stage, AssemblyDefinition assembly, string assemblyName)
+		{
+			var metrics = new TypeMapAssemblyMetrics {
+				Stage = stage,
+				AssemblyName = assemblyName,
+			};
+
+			foreach (var attribute in assembly.CustomAttributes) {
+				var attributeName = attribute.AttributeType.FullName;
+				if (attributeName.StartsWith ("System.Runtime.InteropServices.TypeMapAttribute`1", StringComparison.Ordinal)) {
+					ReadTypeMapAttribute (attribute, metrics);
+				} else if (attributeName.StartsWith ("System.Runtime.InteropServices.TypeMapAssociationAttribute", StringComparison.Ordinal)) {
+					metrics.AssociationAttributeCount++;
+				} else if (attributeName.StartsWith ("System.Runtime.InteropServices.TypeMapAssemblyTargetAttribute`1", StringComparison.Ordinal)) {
+					metrics.AssemblyTargetAttributeCount++;
+				}
+			}
+
+			if (metrics.TypeMapAttributeCount != 0 || metrics.AssociationAttributeCount != 0 || metrics.AssemblyTargetAttributeCount != 0) {
+				profile.TypeMapAssemblies.Add (metrics);
+			}
+		}
+
+		void ReadTypeMapAttribute (CustomAttribute attribute, TypeMapAssemblyMetrics metrics)
+		{
+			metrics.TypeMapAttributeCount++;
+			if (attribute.ConstructorArguments.Count == 2) {
+				metrics.UnconditionalTypeMapAttributeCount++;
+			} else if (attribute.ConstructorArguments.Count == 3) {
+				metrics.ConditionalTypeMapAttributeCount++;
+			}
+
+			var jniName = attribute.ConstructorArguments.Count > 0 ? attribute.ConstructorArguments [0].Value as string : null;
+			var proxyType = attribute.ConstructorArguments.Count > 1 ? attribute.ConstructorArguments [1].Value as string : null;
+			var targetType = attribute.ConstructorArguments.Count > 2 ? attribute.ConstructorArguments [2].Value as string : null;
+			var key = $"{jniName}\t{proxyType}\t{targetType}";
+			metrics.TypeMapAttributeKeys.Add (key);
+			if (jniName != null) {
+				metrics.IncrementPrefixBucket (jniName);
+			}
+		}
+
 		bool IsManagedTypemapEligible (TypeDefinition type, ApkComparisonProfile profile)
 		{
 			if (profile.CandidateManagedTypes.Contains (type.FullName)) {
@@ -546,7 +613,7 @@ void WriteComparisonTable (ApkComparisonProfile llvmIr, ApkComparisonProfile tri
 			TestContext.Out.WriteLine ($"| APK size | {FormatNumber (llvmIr.ApkSize)} | {FormatNumber (trimmable.ApkSize)} |");
 			TestContext.Out.WriteLine ($"| Assembly-store payload | {FormatNumber (llvmIr.AssemblyStoreSize)} | {FormatNumber (trimmable.AssemblyStoreSize)} |");
 			TestContext.Out.WriteLine ($"| classes*.dex | {FormatNumber (llvmIr.DexSize)} | {FormatNumber (trimmable.DexSize)} |");
-			TestContext.Out.WriteLine ($"| Filtered managed types / methods | {FormatNumber (llvmIr.FilteredManagedTypeCount)} / {FormatNumber (llvmIr.FilteredManagedMethodCount)} | {FormatNumber (trimmable.FilteredManagedTypeCount)} / {FormatNumber (trimmable.FilteredManagedMethodCount)} |");
+			TestContext.Out.WriteLine ($"| Registered managed types / methods | {FormatNumber (llvmIr.FilteredManagedTypeCount)} / {FormatNumber (llvmIr.FilteredManagedMethodCount)} | {FormatNumber (trimmable.FilteredManagedTypeCount)} / {FormatNumber (trimmable.FilteredManagedMethodCount)} |");
 			TestContext.Out.WriteLine ($"| Managed diff | {FormatNumber (managedDiff.LlvmIrOnly.Length)} llvm-ir-only | {FormatNumber (managedDiff.TrimmableOnly.Length)} trimmable-only |");
 			TestContext.Out.WriteLine ($"| Java diff | {FormatNumber (javaDiff.LlvmIrOnly.Length)} llvm-ir-only | {FormatNumber (javaDiff.TrimmableOnly.Length)} trimmable-only |");
 		}
@@ -562,6 +629,9 @@ void WriteProfile (ApkComparisonProfile profile)
 			TestContext.Out.WriteLine ($"{profile.Name}: generated Java sources={profile.GeneratedJavaSourceCount}, __md_methods files={profile.GeneratedJavaWithMdMethodsCount}, Runtime.register files={profile.GeneratedJavaWithRuntimeRegisterCount}, Runtime.registerNatives files={profile.GeneratedJavaWithRegisterNativesCount}");
 			TestContext.Out.WriteLine ($"{profile.Name}: assembly stores: {String.Join ("; ", profile.AssemblyStores)}");
 			TestContext.Out.WriteLine ($"{profile.Name}: dex files: {String.Join ("; ", profile.DexFiles)}");
+			foreach (var metrics in profile.TypeMapAssemblies) {
+				TestContext.Out.WriteLine ($"{profile.Name}: typemap {metrics.Stage}/{metrics.AssemblyName}: typemap={metrics.TypeMapAttributeCount}, unique={metrics.UniqueTypeMapAttributeCount}, duplicates={metrics.DuplicateTypeMapAttributeCount}, unconditional={metrics.UnconditionalTypeMapAttributeCount}, conditional={metrics.ConditionalTypeMapAttributeCount}, associations={metrics.AssociationAttributeCount}, assembly-targets={metrics.AssemblyTargetAttributeCount}, prefixes={metrics.FormatPrefixBuckets ()}");
+			}
 		}
 
 		void WriteSize (string label, long llvmIr, long trimmable)
@@ -636,6 +706,52 @@ class ApkComparisonProfile
 			public readonly HashSet<string> ManagedTypemapEntries = new HashSet<string> (StringComparer.Ordinal);
 			public readonly HashSet<string> JavaTypemapEntries = new HashSet<string> (StringComparer.Ordinal);
 			public readonly HashSet<string> JavaClassNames = new HashSet<string> (StringComparer.Ordinal);
+			public readonly List<TypeMapAssemblyMetrics> TypeMapAssemblies = new List<TypeMapAssemblyMetrics> ();
+		}
+
+		class TypeMapAssemblyMetrics
+		{
+			public string Stage;
+			public string AssemblyName;
+			public int TypeMapAttributeCount;
+			public int UnconditionalTypeMapAttributeCount;
+			public int ConditionalTypeMapAttributeCount;
+			public int AssociationAttributeCount;
+			public int AssemblyTargetAttributeCount;
+			public readonly List<string> TypeMapAttributeKeys = new List<string> ();
+			readonly SortedDictionary<string, int> prefixBuckets = new SortedDictionary<string, int> (StringComparer.Ordinal);
+
+			public int UniqueTypeMapAttributeCount => TypeMapAttributeKeys.Distinct (StringComparer.Ordinal).Count ();
+			public int DuplicateTypeMapAttributeCount => TypeMapAttributeCount - UniqueTypeMapAttributeCount;
+
+			public void IncrementPrefixBucket (string jniName)
+			{
+				var bucket = GetPrefixBucket (jniName);
+				prefixBuckets.TryGetValue (bucket, out int count);
+				prefixBuckets [bucket] = count + 1;
+			}
+
+			public string FormatPrefixBuckets ()
+			{
+				return String.Join (", ", prefixBuckets.Select (p => $"{p.Key}={p.Value}"));
+			}
+
+			static string GetPrefixBucket (string jniName)
+			{
+				if (jniName.StartsWith ("mono/android/", StringComparison.Ordinal)) {
+					return "mono/android";
+				}
+				if (jniName.StartsWith ("android/", StringComparison.Ordinal)) {
+					return "android";
+				}
+				if (jniName.StartsWith ("java/", StringComparison.Ordinal)) {
+					return "java";
+				}
+				if (jniName.StartsWith ("com/xamarin/", StringComparison.Ordinal)) {
+					return "app";
+				}
+				return "other";
+			}
 		}
 
 		class EntryDiff
diff --git a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/TypeMapModelBuilderTests.cs b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/TypeMapModelBuilderTests.cs
index 7a34fc345fe..9fcf59fe774 100644
--- a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/TypeMapModelBuilderTests.cs
+++ b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/TypeMapModelBuilderTests.cs
@@ -168,6 +168,32 @@ public void Build_UserAcwType_IsUnconditional ()
 			Assert.Null (mainEntry.TargetTypeReference);
 		}
 
+		[Fact]
+		public void Build_FrameworkAcwType_IsTrimmable ()
+		{
+			var peer = MakeAcwPeer ("mono/android/view/View_OnClickListenerImplementor", "Android.Views.View+IOnClickListenerImplementor", "Mono.Android") with {
+				IsFrameworkAssembly = true,
+			};
+			var model = BuildModel (new [] { peer });
+
+			var entry = model.Entries.First (e => e.JniName == "mono/android/view/View_OnClickListenerImplementor");
+			Assert.False (entry.IsUnconditional);
+			Assert.Equal ("Android.Views.View+IOnClickListenerImplementor, Mono.Android", entry.TargetTypeReference);
+		}
+
+		[Fact]
+		public void Build_FrameworkAcwType_MarkedUnconditional_IsUnconditional ()
+		{
+			var peer = MakeAcwPeer ("mono/android/app/ApplicationRegistration", "Android.App.ApplicationRegistration", "Mono.Android") with {
+				IsFrameworkAssembly = true,
+				IsUnconditional = true,
+			};
+			var model = BuildModel (new [] { peer });
+
+			Assert.True (model.Entries [0].IsUnconditional);
+			Assert.Null (model.Entries [0].TargetTypeReference);
+		}
+
 		[Fact]
 		public void Build_McwBinding_IsTrimmable ()
 		{

From 44d8c10d429dfc2e691f06bd12f74d4675d9aea5 Mon Sep 17 00:00:00 2001
From: Simon Rozsival <simon@rozsival.com>
Date: Thu, 14 May 2026 20:45:59 +0200
Subject: [PATCH 5/6] Reduce trimmable typemap R8 keep rules

Generate R8 keep rules for trimmable typemap builds from linked assemblies instead of the pre-link acw-map, and use a minimal Xamarin runtime keep list for this path.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 ...roid.Sdk.TypeMap.Trimmable.CoreCLR.targets | 20 +++++------
 src/Xamarin.Android.Build.Tasks/Tasks/R8.cs   | 34 +++++++++++++++++--
 .../Xamarin.Android.D8.targets                |  4 +++
 3 files changed, 46 insertions(+), 12 deletions(-)

diff --git a/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.CoreCLR.targets b/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.CoreCLR.targets
index 4d3b1470ee2..714ff9ae8aa 100644
--- a/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.CoreCLR.targets
+++ b/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.CoreCLR.targets
@@ -7,6 +7,8 @@
 
   <PropertyGroup>
     <_GenerateProguardAfterTargets Condition=" '$(_GenerateProguardAfterTargets)' == '' ">ILLink</_GenerateProguardAfterTargets>
+    <_R8GenerateApplicationProguardConfigurationFromAcwMap>false</_R8GenerateApplicationProguardConfigurationFromAcwMap>
+    <_R8UseMinimalXamarinProguardConfiguration>true</_R8UseMinimalXamarinProguardConfiguration>
   </PropertyGroup>
 
   <!-- Add TypeMap DLLs to ILLink input. ILLink natively understands TypeMapAttribute<T>. -->
@@ -36,22 +38,20 @@
     </ItemGroup>
   </Target>
 
-  <Target Name="_PrepareLinkedAssembliesForProguard"
-      AfterTargets="$(_GenerateProguardAfterTargets)"
-      Condition=" '$(PublishTrimmed)' == 'true' and '$(_ProguardProjectConfiguration)' != '' ">
-    <ItemGroup>
-      <_LinkedAssemblyForProguard Include="@(ResolvedFileToPublish)" Condition=" '%(Extension)' == '.dll' " />
-    </ItemGroup>
-  </Target>
-
   <Target Name="_GenerateProguardConfiguration"
-      AfterTargets="_PrepareLinkedAssembliesForProguard"
+      BeforeTargets="_CompileToDalvik"
       Condition=" '$(PublishTrimmed)' == 'true' and '$(_ProguardProjectConfiguration)' != '' "
-      Inputs="@(_LinkedAssemblyForProguard)"
+      Inputs="$(IntermediateOutputPath)*/linked/*.dll"
       Outputs="$(_ProguardProjectConfiguration)">
+    <ItemGroup>
+      <_LinkedAssemblyForProguard Include="$(IntermediateOutputPath)*/linked/*.dll" />
+    </ItemGroup>
     <GenerateProguardConfiguration
         LinkedAssemblies="@(_LinkedAssemblyForProguard)"
         OutputFile="$(_ProguardProjectConfiguration)" />
+    <ItemGroup>
+      <_LinkedAssemblyForProguard Remove="@(_LinkedAssemblyForProguard)" />
+    </ItemGroup>
   </Target>
 
   <!-- Add TypeMap DLLs to assembly store with per-ABI metadata.
diff --git a/src/Xamarin.Android.Build.Tasks/Tasks/R8.cs b/src/Xamarin.Android.Build.Tasks/Tasks/R8.cs
index fbf66e7bf48..59c4cd4ba0c 100644
--- a/src/Xamarin.Android.Build.Tasks/Tasks/R8.cs
+++ b/src/Xamarin.Android.Build.Tasks/Tasks/R8.cs
@@ -33,6 +33,8 @@ public class R8 : D8
 		public string? ProguardGeneratedReferenceConfiguration { get; set; }
 		public string? ProguardGeneratedApplicationConfiguration { get; set; }
 		public string? ProguardCommonXamarinConfiguration { get; set; }
+		public bool GenerateApplicationProguardConfigurationFromAcwMap { get; set; } = true;
+		public bool UseMinimalXamarinProguardConfiguration { get; set; }
 		public string? ProguardMappingFileOutput { get; set; }
 		public string []? ProguardConfigurationFiles { get; set; }
 
@@ -95,7 +97,7 @@ protected override string CreateResponseFile ()
 			}
 
 			if (EnableShrinking) {
-				if (!AcwMapFile.IsNullOrEmpty ()) {
+				if (GenerateApplicationProguardConfigurationFromAcwMap && !AcwMapFile.IsNullOrEmpty ()) {
 					var acwMap      = MonoAndroidHelper.LoadMapFile (BuildEngine4, Path.GetFullPath (AcwMapFile), StringComparer.OrdinalIgnoreCase);
 					var javaTypes   = new List<string> (acwMap.Values.Count);
 					foreach (var v in acwMap.Values) {
@@ -107,10 +109,16 @@ protected override string CreateResponseFile ()
 							appcfg.WriteLine ($"-keep class {java} {{ *; }}");
 						}
 					}
+				} else if (!ProguardGeneratedApplicationConfiguration.IsNullOrEmpty ()) {
+					File.WriteAllText (ProguardGeneratedApplicationConfiguration, "");
 				}
 				if (!ProguardCommonXamarinConfiguration.IsNullOrWhiteSpace ()) {
 					using (var xamcfg = File.CreateText (ProguardCommonXamarinConfiguration)) {
-						GetType ().Assembly.GetManifestResourceStream ("proguard_xamarin.cfg").CopyTo (xamcfg.BaseStream);
+						if (UseMinimalXamarinProguardConfiguration) {
+							WriteMinimalXamarinProguardConfiguration (xamcfg);
+						} else {
+							GetType ().Assembly.GetManifestResourceStream ("proguard_xamarin.cfg").CopyTo (xamcfg.BaseStream);
+						}
 						if (IgnoreWarnings) {
 							xamcfg.WriteLine ("-ignorewarnings");
 						}
@@ -159,6 +167,28 @@ protected override string CreateResponseFile ()
 			return responseFile;
 		}
 
+		static void WriteMinimalXamarinProguardConfiguration (TextWriter writer)
+		{
+			writer.WriteLine ("# Minimal Xamarin configuration for trimmable typemap builds.");
+			writer.WriteLine ("-dontobfuscate");
+			writer.WriteLine ();
+			writer.WriteLine ("-keep class android.support.multidex.MultiDexApplication { <init>(); }");
+			writer.WriteLine ("-keep class mono.MonoRuntimeProvider* { *; <init>(...); }");
+			writer.WriteLine ("-keep class mono.MonoPackageManager { *; <init>(...); }");
+			writer.WriteLine ("-keep class mono.MonoPackageManager_Resources { *; <init>(...); }");
+			writer.WriteLine ("-keep class net.dot.jni.** { *; <init>(); }");
+			writer.WriteLine ("-keep class net.dot.android.crypto.** { *; <init>(...); }");
+			writer.WriteLine ();
+			writer.WriteLine ("-keepclassmembers class * extends android.view.View {");
+			writer.WriteLine ("   *** set*(...);");
+			writer.WriteLine ("}");
+			writer.WriteLine ();
+			writer.WriteLine ("-keepclassmembers class * extends android.view.View {");
+			writer.WriteLine ("   <init>(android.content.Context,android.util.AttributeSet);");
+			writer.WriteLine ("   <init>(android.content.Context,android.util.AttributeSet,int);");
+			writer.WriteLine ("}");
+		}
+
 		// Note: We do not want to call the base.LogEventsFromTextOutput as it will incorrectly identify
 		// Warnings and Info messages as errors.
 		protected override void LogEventsFromTextOutput (string singleLine, MessageImportance messageImportance)
diff --git a/src/Xamarin.Android.Build.Tasks/Xamarin.Android.D8.targets b/src/Xamarin.Android.Build.Tasks/Xamarin.Android.D8.targets
index 0796e933155..a196142b01a 100644
--- a/src/Xamarin.Android.Build.Tasks/Xamarin.Android.D8.targets
+++ b/src/Xamarin.Android.Build.Tasks/Xamarin.Android.D8.targets
@@ -30,6 +30,8 @@ Copyright (C) 2018 Xamarin. All rights reserved.
       <!--Flag indicating if r8 should have EnableShrinking-->
       <_R8EnableShrinking Condition=" '$(AndroidLinkTool)' == 'r8' ">True</_R8EnableShrinking>
       <_R8EnableShrinking Condition=" '$(_R8EnableShrinking)' == '' ">False</_R8EnableShrinking>
+      <_R8GenerateApplicationProguardConfigurationFromAcwMap Condition=" '$(_R8GenerateApplicationProguardConfigurationFromAcwMap)' == '' ">True</_R8GenerateApplicationProguardConfigurationFromAcwMap>
+      <_R8UseMinimalXamarinProguardConfiguration Condition=" '$(_R8UseMinimalXamarinProguardConfiguration)' == '' ">False</_R8UseMinimalXamarinProguardConfiguration>
     </PropertyGroup>
 
     <Error
@@ -72,6 +74,8 @@ Copyright (C) 2018 Xamarin. All rights reserved.
         ProguardCommonXamarinConfiguration="$(IntermediateOutputPath)proguard\proguard_xamarin.cfg"
         ProguardGeneratedReferenceConfiguration="$(_ProguardProjectConfiguration)"
         ProguardGeneratedApplicationConfiguration="$(IntermediateOutputPath)proguard\proguard_project_primary.cfg"
+        GenerateApplicationProguardConfigurationFromAcwMap="$(_R8GenerateApplicationProguardConfigurationFromAcwMap)"
+        UseMinimalXamarinProguardConfiguration="$(_R8UseMinimalXamarinProguardConfiguration)"
         ProguardMappingFileOutput="$(AndroidProguardMappingFile)"
         ProguardConfigurationFiles="@(_ProguardConfiguration)"
         EnableShrinking="$(_R8EnableShrinking)"

From adc8960d60ff363eeae9c8e90cec4a25b301ae44 Mon Sep 17 00:00:00 2001
From: Simon Rozsival <simon@rozsival.com>
Date: Thu, 14 May 2026 21:24:34 +0200
Subject: [PATCH 6/6] Revert "Reduce trimmable typemap R8 keep rules"

This reverts commit 44d8c10d429dfc2e691f06bd12f74d4675d9aea5.
---
 ...roid.Sdk.TypeMap.Trimmable.CoreCLR.targets | 20 +++++------
 src/Xamarin.Android.Build.Tasks/Tasks/R8.cs   | 34 ++-----------------
 .../Xamarin.Android.D8.targets                |  4 ---
 3 files changed, 12 insertions(+), 46 deletions(-)

diff --git a/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.CoreCLR.targets b/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.CoreCLR.targets
index 714ff9ae8aa..4d3b1470ee2 100644
--- a/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.CoreCLR.targets
+++ b/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.CoreCLR.targets
@@ -7,8 +7,6 @@
 
   <PropertyGroup>
     <_GenerateProguardAfterTargets Condition=" '$(_GenerateProguardAfterTargets)' == '' ">ILLink</_GenerateProguardAfterTargets>
-    <_R8GenerateApplicationProguardConfigurationFromAcwMap>false</_R8GenerateApplicationProguardConfigurationFromAcwMap>
-    <_R8UseMinimalXamarinProguardConfiguration>true</_R8UseMinimalXamarinProguardConfiguration>
   </PropertyGroup>
 
   <!-- Add TypeMap DLLs to ILLink input. ILLink natively understands TypeMapAttribute<T>. -->
@@ -38,20 +36,22 @@
     </ItemGroup>
   </Target>
 
+  <Target Name="_PrepareLinkedAssembliesForProguard"
+      AfterTargets="$(_GenerateProguardAfterTargets)"
+      Condition=" '$(PublishTrimmed)' == 'true' and '$(_ProguardProjectConfiguration)' != '' ">
+    <ItemGroup>
+      <_LinkedAssemblyForProguard Include="@(ResolvedFileToPublish)" Condition=" '%(Extension)' == '.dll' " />
+    </ItemGroup>
+  </Target>
+
   <Target Name="_GenerateProguardConfiguration"
-      BeforeTargets="_CompileToDalvik"
+      AfterTargets="_PrepareLinkedAssembliesForProguard"
       Condition=" '$(PublishTrimmed)' == 'true' and '$(_ProguardProjectConfiguration)' != '' "
-      Inputs="$(IntermediateOutputPath)*/linked/*.dll"
+      Inputs="@(_LinkedAssemblyForProguard)"
       Outputs="$(_ProguardProjectConfiguration)">
-    <ItemGroup>
-      <_LinkedAssemblyForProguard Include="$(IntermediateOutputPath)*/linked/*.dll" />
-    </ItemGroup>
     <GenerateProguardConfiguration
         LinkedAssemblies="@(_LinkedAssemblyForProguard)"
         OutputFile="$(_ProguardProjectConfiguration)" />
-    <ItemGroup>
-      <_LinkedAssemblyForProguard Remove="@(_LinkedAssemblyForProguard)" />
-    </ItemGroup>
   </Target>
 
   <!-- Add TypeMap DLLs to assembly store with per-ABI metadata.
diff --git a/src/Xamarin.Android.Build.Tasks/Tasks/R8.cs b/src/Xamarin.Android.Build.Tasks/Tasks/R8.cs
index 59c4cd4ba0c..fbf66e7bf48 100644
--- a/src/Xamarin.Android.Build.Tasks/Tasks/R8.cs
+++ b/src/Xamarin.Android.Build.Tasks/Tasks/R8.cs
@@ -33,8 +33,6 @@ public class R8 : D8
 		public string? ProguardGeneratedReferenceConfiguration { get; set; }
 		public string? ProguardGeneratedApplicationConfiguration { get; set; }
 		public string? ProguardCommonXamarinConfiguration { get; set; }
-		public bool GenerateApplicationProguardConfigurationFromAcwMap { get; set; } = true;
-		public bool UseMinimalXamarinProguardConfiguration { get; set; }
 		public string? ProguardMappingFileOutput { get; set; }
 		public string []? ProguardConfigurationFiles { get; set; }
 
@@ -97,7 +95,7 @@ protected override string CreateResponseFile ()
 			}
 
 			if (EnableShrinking) {
-				if (GenerateApplicationProguardConfigurationFromAcwMap && !AcwMapFile.IsNullOrEmpty ()) {
+				if (!AcwMapFile.IsNullOrEmpty ()) {
 					var acwMap      = MonoAndroidHelper.LoadMapFile (BuildEngine4, Path.GetFullPath (AcwMapFile), StringComparer.OrdinalIgnoreCase);
 					var javaTypes   = new List<string> (acwMap.Values.Count);
 					foreach (var v in acwMap.Values) {
@@ -109,16 +107,10 @@ protected override string CreateResponseFile ()
 							appcfg.WriteLine ($"-keep class {java} {{ *; }}");
 						}
 					}
-				} else if (!ProguardGeneratedApplicationConfiguration.IsNullOrEmpty ()) {
-					File.WriteAllText (ProguardGeneratedApplicationConfiguration, "");
 				}
 				if (!ProguardCommonXamarinConfiguration.IsNullOrWhiteSpace ()) {
 					using (var xamcfg = File.CreateText (ProguardCommonXamarinConfiguration)) {
-						if (UseMinimalXamarinProguardConfiguration) {
-							WriteMinimalXamarinProguardConfiguration (xamcfg);
-						} else {
-							GetType ().Assembly.GetManifestResourceStream ("proguard_xamarin.cfg").CopyTo (xamcfg.BaseStream);
-						}
+						GetType ().Assembly.GetManifestResourceStream ("proguard_xamarin.cfg").CopyTo (xamcfg.BaseStream);
 						if (IgnoreWarnings) {
 							xamcfg.WriteLine ("-ignorewarnings");
 						}
@@ -167,28 +159,6 @@ protected override string CreateResponseFile ()
 			return responseFile;
 		}
 
-		static void WriteMinimalXamarinProguardConfiguration (TextWriter writer)
-		{
-			writer.WriteLine ("# Minimal Xamarin configuration for trimmable typemap builds.");
-			writer.WriteLine ("-dontobfuscate");
-			writer.WriteLine ();
-			writer.WriteLine ("-keep class android.support.multidex.MultiDexApplication { <init>(); }");
-			writer.WriteLine ("-keep class mono.MonoRuntimeProvider* { *; <init>(...); }");
-			writer.WriteLine ("-keep class mono.MonoPackageManager { *; <init>(...); }");
-			writer.WriteLine ("-keep class mono.MonoPackageManager_Resources { *; <init>(...); }");
-			writer.WriteLine ("-keep class net.dot.jni.** { *; <init>(); }");
-			writer.WriteLine ("-keep class net.dot.android.crypto.** { *; <init>(...); }");
-			writer.WriteLine ();
-			writer.WriteLine ("-keepclassmembers class * extends android.view.View {");
-			writer.WriteLine ("   *** set*(...);");
-			writer.WriteLine ("}");
-			writer.WriteLine ();
-			writer.WriteLine ("-keepclassmembers class * extends android.view.View {");
-			writer.WriteLine ("   <init>(android.content.Context,android.util.AttributeSet);");
-			writer.WriteLine ("   <init>(android.content.Context,android.util.AttributeSet,int);");
-			writer.WriteLine ("}");
-		}
-
 		// Note: We do not want to call the base.LogEventsFromTextOutput as it will incorrectly identify
 		// Warnings and Info messages as errors.
 		protected override void LogEventsFromTextOutput (string singleLine, MessageImportance messageImportance)
diff --git a/src/Xamarin.Android.Build.Tasks/Xamarin.Android.D8.targets b/src/Xamarin.Android.Build.Tasks/Xamarin.Android.D8.targets
index a196142b01a..0796e933155 100644
--- a/src/Xamarin.Android.Build.Tasks/Xamarin.Android.D8.targets
+++ b/src/Xamarin.Android.Build.Tasks/Xamarin.Android.D8.targets
@@ -30,8 +30,6 @@ Copyright (C) 2018 Xamarin. All rights reserved.
       <!--Flag indicating if r8 should have EnableShrinking-->
       <_R8EnableShrinking Condition=" '$(AndroidLinkTool)' == 'r8' ">True</_R8EnableShrinking>
       <_R8EnableShrinking Condition=" '$(_R8EnableShrinking)' == '' ">False</_R8EnableShrinking>
-      <_R8GenerateApplicationProguardConfigurationFromAcwMap Condition=" '$(_R8GenerateApplicationProguardConfigurationFromAcwMap)' == '' ">True</_R8GenerateApplicationProguardConfigurationFromAcwMap>
-      <_R8UseMinimalXamarinProguardConfiguration Condition=" '$(_R8UseMinimalXamarinProguardConfiguration)' == '' ">False</_R8UseMinimalXamarinProguardConfiguration>
     </PropertyGroup>
 
     <Error
@@ -74,8 +72,6 @@ Copyright (C) 2018 Xamarin. All rights reserved.
         ProguardCommonXamarinConfiguration="$(IntermediateOutputPath)proguard\proguard_xamarin.cfg"
         ProguardGeneratedReferenceConfiguration="$(_ProguardProjectConfiguration)"
         ProguardGeneratedApplicationConfiguration="$(IntermediateOutputPath)proguard\proguard_project_primary.cfg"
-        GenerateApplicationProguardConfigurationFromAcwMap="$(_R8GenerateApplicationProguardConfigurationFromAcwMap)"
-        UseMinimalXamarinProguardConfiguration="$(_R8UseMinimalXamarinProguardConfiguration)"
         ProguardMappingFileOutput="$(AndroidProguardMappingFile)"
         ProguardConfigurationFiles="@(_ProguardConfiguration)"
         EnableShrinking="$(_R8EnableShrinking)"