First steps towards p/invoke usage scanner

Author: grendello

src/Xamarin.Android.Build.Tasks/Tasks/GenerateJavaStubs.cs

@@ -91,6 +91,8 @@ public class GenerateJavaStubs : AndroidTask
 
 		public ITaskItem[] Environments { get; set; }
 
+		public bool EnableNativeRuntimeLinking { get; set; }
+
 		[Output]
 		public ITaskItem[] GeneratedBinaryTypeMaps { get; set; }
 
@@ -187,6 +189,7 @@ void Run (bool useMarshalMethods)
 			// Now that "never" never happened, we can proceed knowing that at least the assembly sets are the same for each architecture
 			var nativeCodeGenStates = new ConcurrentDictionary<AndroidTargetArch, NativeCodeGenState> ();
 			NativeCodeGenState? templateCodeGenState = null;
+			var scanner = new PinvokeScanner (Log);
 
 			var firstArch = allAssembliesPerArch.First ().Key;
 			var generateSucceeded = true;
@@ -206,6 +209,11 @@ void Run (bool useMarshalMethods)
 					generateSucceeded = false;
 				}
 
+				(success, List<PinvokeScanner.PinvokeEntryInfo> pinfos) = ScanForUsedPinvokes (scanner, arch, state.Resolver);
+				if (!success) {
+					return;
+				}
+
 				// If this is the first architecture, we need to store the state for later use
 				if (generateJavaCode) {
 					templateCodeGenState = state;
@@ -363,6 +371,31 @@ IList<string> MergeManifest (NativeCodeGenState codeGenState, Dictionary<string,
 			return additionalProviders;
 		}
 
+		(bool success, List<PinvokeScanner.PinvokeEntryInfo> pinfos) ScanForUsedPinvokes (PinvokeScanner scanner, AndroidTargetArch arch, XAAssemblyResolver resolver)
+		{
+			if (!EnableNativeRuntimeLinking) {
+				return;
+			}
+
+			var frameworkAssemblies = new List<ITaskItem> ();
+
+			foreach (ITaskItem asm in ResolvedAssemblies) {
+				string? metadata = asm.GetMetadata ("FrameworkAssembly");
+				if (String.IsNullOrEmpty (metadata)) {
+					continue;
+				}
+
+				if (!Boolean.TryParse (metadata, out bool isFrameworkAssembly) || !isFrameworkAssembly) {
+					continue;
+				}
+
+				frameworkAssemblies.Add (asm);
+			}
+
+			var pinfos = scanner.Scan (arch, resolver, frameworkAssemblies);
+			return (true, pinfos);
+		}
+
 		(bool success, NativeCodeGenState? stubsState) GenerateJavaSourcesAndMaybeClassifyMarshalMethods (AndroidTargetArch arch, Dictionary<string, ITaskItem> assemblies, Dictionary<string, ITaskItem> userAssemblies, bool useMarshalMethods, bool generateJavaCode)
 		{
 			XAAssemblyResolver resolver = MakeResolver (useMarshalMethods, arch, assemblies);

src/Xamarin.Android.Build.Tasks/Tasks/GeneratePackageManagerJava.cs

@@ -79,6 +79,7 @@ public class GeneratePackageManagerJava : AndroidTask
 		public string AndroidSequencePointsMode { get; set; }
 		public bool EnableSGenConcurrent { get; set; }
 		public string? CustomBundleConfigFile { get; set; }
+		public bool EnableNativeRuntimeLinking { get; set; }
 
 		bool _Debug {
 			get {
@@ -387,6 +388,13 @@ void AddEnvironment ()
 					);
 				}
 
+				if (EnableNativeRuntimeLinking) {
+					// var pinfoGen = new PreservePinvokesNativeAssemblyGenerator (
+					// 	Log,
+					// 	targetArch,
+
+				}
+
 				LLVMIR.LlvmIrModule marshalMethodsModule = marshalMethodsAsmGen.Construct ();
 				using var marshalMethodsWriter = MemoryStreamPool.Shared.CreateStreamWriter ();
 				try {

src/Xamarin.Android.Build.Tasks/Utilities/PinvokeScanner.cs

@@ -0,0 +1,91 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+
+using Microsoft.Build.Framework;
+using Microsoft.Build.Utilities;
+using Microsoft.Android.Build.Tasks;
+
+using Mono.Cecil;
+
+using Xamarin.Android.Tools;
+
+namespace Xamarin.Android.Tasks;
+
+class PinvokeScanner
+{
+	public sealed class PinvokeEntryInfo
+	{
+		public readonly string LibraryName;
+		public readonly string EntryName;
+
+		public PinvokeEntryInfo (MethodDefinition method)
+		{
+			LibraryName = method.PInvokeInfo.Module.Name;
+			EntryName = method.PInvokeInfo.EntryPoint;
+		}
+	}
+
+	readonly TaskLoggingHelper log;
+
+	public PinvokeScanner (TaskLoggingHelper log)
+	{
+		this.log = log;
+	}
+
+	public List<PinvokeEntryInfo> Scan (AndroidTargetArch targetArch, XAAssemblyResolver resolver, ICollection<ITaskItem> frameworkAssemblies)
+	{
+		var pinvokes = new List<PinvokeEntryInfo> ();
+		var pinvokeCache = new HashSet<string> (StringComparer.Ordinal);
+
+		foreach (ITaskItem fasm in frameworkAssemblies) {
+			string asmName = Path.GetFileNameWithoutExtension (fasm.ItemSpec);
+			AssemblyDefinition? asmdef = resolver.Resolve (asmName);
+			if (asmdef == null) {
+				log.LogWarning ($"Failed to resolve assembly '{fasm.ItemSpec}' for target architecture {targetArch}");
+				continue;
+			}
+			Scan (asmdef, pinvokeCache, pinvokes);
+		}
+
+		return pinvokes;
+	}
+
+	void Scan (AssemblyDefinition assembly, HashSet<string> pinvokeCache, List<PinvokeEntryInfo> pinvokes)
+	{
+		log.LogDebugMessage ($"Scanning assembly {assembly}");
+		foreach (ModuleDefinition module in assembly.Modules) {
+			if (!module.HasTypes) {
+				continue;
+			}
+
+			foreach (TypeDefinition type in module.Types) {
+				Scan (type, pinvokeCache, pinvokes);
+			}
+		}
+	}
+
+	void Scan (TypeDefinition type, HashSet<string> pinvokeCache, List<PinvokeEntryInfo> pinvokes)
+	{
+		if (!type.HasMethods) {
+			return;
+		}
+
+		log.LogDebugMessage ($"Scanning type '{type}'");
+		foreach (MethodDefinition method in type.Methods) {
+			if (!method.HasPInvokeInfo) {
+				continue;
+			}
+
+			var pinfo = new PinvokeEntryInfo (method);
+			string key = $"{pinfo.LibraryName}/{pinfo.EntryName}";
+			if (pinvokeCache.Contains (key)) {
+				continue;
+			}
+
+			log.LogDebugMessage ($"  p/invoke method: {pinfo.LibraryName}/{pinfo.EntryName}");
+			pinvokeCache.Add (key);
+			pinvokes.Add (pinfo);
+		}
+	}
+}

src/Xamarin.Android.Build.Tasks/Utilities/PreservePinvokesNativeAssemblyGenerator.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+
+using Microsoft.Android.Build.Tasks;
+using Microsoft.Build.Utilities;
+
+using Xamarin.Android.Tasks.LLVMIR;
+using Xamarin.Android.Tools;
+
+using CecilMethodDefinition = global::Mono.Cecil.MethodDefinition;
+using CecilParameterDefinition = global::Mono.Cecil.ParameterDefinition;
+
+namespace Xamarin.Android.Tasks;
+
+class PreservePinvokesNativeAssemblyGenerator : LlvmIrComposer
+{
+	readonly TaskLoggingHelper log;
+	readonly AndroidTargetArch targetArch;
+	readonly ICollection<PinvokeScanner.PinvokeEntryInfo> pinfos;
+
+	public PreservePinvokesNativeAssemblyGenerator (TaskLoggingHelper log, AndroidTargetArch targetArch, ICollection<PinvokeScanner.PinvokeEntryInfo> pinfos)
+		: base (log)
+	{
+		this.log = log;
+		this.targetArch = targetArch;
+		this.pinfos = pinfos;
+	}
+
+	protected override void Construct (LlvmIrModule module)
+	{
+	}
+}

src/Xamarin.Android.Build.Tasks/Xamarin.Android.Common.targets

@@ -1502,7 +1502,8 @@ because xbuild doesn't support framework reference assemblies.
       LinkingEnabled="$(_LinkingEnabled)"
       HaveMultipleRIDs="$(_HaveMultipleRIDs)"
       IntermediateOutputDirectory="$(IntermediateOutputPath)"
-      Environments="@(AndroidEnvironment);@(LibraryEnvironments)">
+      Environments="@(AndroidEnvironment);@(LibraryEnvironments)"
+      EnableNativeRuntimeLinking="$(_AndroidEnableNativeRuntimeLinking)">
     <Output TaskParameter="GeneratedBinaryTypeMaps" ItemName="_AndroidTypeMapping" Condition=" '$(_InstantRunEnabled)' == 'True' " />
   </GenerateJavaStubs>
 
@@ -1732,6 +1733,7 @@ because xbuild doesn't support framework reference assemblies.
     UseAssemblyStore="$(AndroidUseAssemblyStore)"
     EnableMarshalMethods="$(_AndroidUseMarshalMethods)"
     CustomBundleConfigFile="$(AndroidBundleConfigurationFile)"
+    EnableNativeRuntimeLinking="$(_AndroidEnableNativeRuntimeLinking)"
   >
   </GeneratePackageManagerJava>
   <Touch Files="$(_AndroidStampDirectory)_GeneratePackageManagerJava.stamp" AlwaysCreate="True" />