Mono.Android-Tests might work now

Author: grendello

src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.NativeRuntime.targets

@@ -32,6 +32,7 @@ Contains code to build and link the native runtime at application build time.
       <Output TaskParameter="RequiredLibraries" ItemName="_RequiredLinkLibraries" />
       <Output TaskParameter="LinkStartFiles" ItemName="_NativeLinkStartFiles" />
       <Output TaskParameter="LinkEndFiles" ItemName="_NativeLinkEndFiles" />
+      <Output TaskParameter="NativeSymbolsToExport" ItemName="_NativeSymbolsToExport" />
     </GetNativeRuntimeComponents>
   </Target>
 
@@ -48,6 +49,7 @@ Contains code to build and link the native runtime at application build time.
         NativeObjectFiles="@(_NativeAssemblyTarget)"
         NativeLinkStartFiles="@(_NativeLinkStartFiles)"
         NativeLinkEndFiles="@(_NativeLinkEndFiles)"
+        NativeSymbolsToExport="@(_NativeSymbolsToExport)"
         LinkLibraries="@(_RequiredLinkLibraries)"
         OutputRuntimes="@(_UnifiedNativeRuntime)"
         SupportedAbis="@(_BuildTargetAbis)"

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

@@ -32,19 +32,33 @@ public class GetNativeRuntimeComponents : AndroidTask
 	[Output]
 	public ITaskItem[] LinkEndFiles { get; set; }
 
+	// TODO: more research, for now it seems `--export-dynamic-symbol=name` options generated from
+	//       this array don't work as expected.
+	[Output]
+	public ITaskItem[] NativeSymbolsToExport { get; set; }
+
 	public override bool RunTask ()
 	{
 		var components = new NativeRuntimeComponents (MonoComponents);
 		var uniqueAbis = new HashSet<string> (StringComparer.OrdinalIgnoreCase);
 		var archives = new List<ITaskItem> ();
+		var symbolsToExport = new List<ITaskItem> ();
 
 		foreach (NativeRuntimeComponents.Archive archiveItem in components.KnownArchives) {
 			if (!archiveItem.Include) {
 				continue;
 			}
 			MakeArchiveItem (archiveItem, archives, uniqueAbis);
+			if (archiveItem.SymbolsToPreserve == null || archiveItem.SymbolsToPreserve.Count == 0) {
+				continue;
+			}
+
+			foreach (string symbolName in archiveItem.SymbolsToPreserve) {
+				MakeLibItem (symbolName, symbolsToExport, uniqueAbis);
+			}
 		}
 		NativeArchives = archives.ToArray ();
+		NativeSymbolsToExport = symbolsToExport.ToArray ();
 
 		var items = new List<ITaskItem> ();
 		foreach (string lib in components.NativeLibraries) {

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

@@ -36,6 +36,9 @@ public class LinkNativeRuntime : AsyncTask
 	[Required]
 	public ITaskItem[] NativeLinkEndFiles { get; set; }
 
+	[Required]
+	public ITaskItem[] NativeSymbolsToExport { get; set; }
+
 	[Required]
 	public ITaskItem[] OutputRuntimes { get; set; }
 
@@ -68,7 +71,8 @@ void LinkRuntime (ITaskItem abiItem)
 			GetAbiItems (NativeArchives, "_SelectedNativeArchive", abi),
 			GetAbiItems (LinkLibraries, "_RequiredLinkLibraries", abi),
 			GetAbiItems (NativeLinkStartFiles, "_NativeLinkStartFiles", abi),
-			GetAbiItems (NativeLinkEndFiles, "_NativeLinkEndFiles", abi)
+			GetAbiItems (NativeLinkEndFiles, "_NativeLinkEndFiles", abi),
+			GetAbiItems (NativeSymbolsToExport, "_NativeSymbolsToExport", abi)
 		);
 	}
 

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

@@ -100,7 +100,7 @@ public NativeLinker (TaskLoggingHelper log, string abi, string soname, string bi
 	}
 
 	public bool Link (ITaskItem outputLibraryPath, List<ITaskItem> objectFiles, List<ITaskItem> archives, List<ITaskItem> libraries,
-	                  List<ITaskItem> linkStartFiles, List<ITaskItem> linkEndFiles)
+	                  List<ITaskItem> linkStartFiles, List<ITaskItem> linkEndFiles, ICollection<ITaskItem>? exportDynamicSymbols = null)
 	{
 		log.LogDebugMessage ($"Linking: {outputLibraryPath}");
 		EnsureCorrectAbi (outputLibraryPath);
@@ -132,6 +132,12 @@ public bool Link (ITaskItem outputLibraryPath, List<ITaskItem> objectFiles, List
 		WriteFilesToResponseFile (sw, objectFiles);
 		WriteFilesToResponseFile (sw, archives);
 
+		if (exportDynamicSymbols != null && exportDynamicSymbols.Count > 0) {
+			foreach (ITaskItem symbolItem in exportDynamicSymbols) {
+				sw.WriteLine ($"--export-dynamic-symbol={symbolItem.ItemSpec}");
+			}
+		}
+
 		if (excludeExportsLibs.Count > 0) {
 			string libs = String.Join (",", excludeExportsLibs);
 			sw.WriteLine ($"--exclude-libs={libs}");

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

@@ -14,6 +14,7 @@ internal class Archive
 		public bool Include => shouldInclude (this);
 		public readonly bool WholeArchive;
 		public bool DontExportSymbols { get; set; }
+		public HashSet<string>? SymbolsToPreserve { get; set; }
 
 		Func<Archive, bool> shouldInclude;
 
@@ -89,7 +90,23 @@ public NativeRuntimeComponents (ITaskItem[] monoComponents)
 			new BclArchive ("libSystem.Globalization.Native.a"),
 			new BclArchive ("libSystem.IO.Compression.Native.a"),
 			new BclArchive ("libSystem.Native.a"),
-			new BclArchive ("libSystem.Security.Cryptography.Native.Android.a", jniOnLoadName: "AndroidCryptoNative_InitLibraryOnLoad"),
+			new BclArchive ("libSystem.Security.Cryptography.Native.Android.a", jniOnLoadName: "AndroidCryptoNative_InitLibraryOnLoad") {
+				SymbolsToPreserve = new (StringComparer.Ordinal) {
+					// This isn't referenced directly by any code in libSystem.Security.Cryptography.Native.Android.  It is instead
+					// referenced by the Java code shipped with the component (`DotnetProxyTrustManager`), as a native Java method:
+					//
+					//   static native boolean verifyRemoteCertificate(long sslStreamProxyHandle);
+					//
+					// Therefore we must reference it explicitly
+					"Java_net_dot_android_crypto_DotnetProxyTrustManager_verifyRemoteCertificate"
+				},
+
+				// For now, we have to export all the symbols from this archive because we need the above `Java_net*` symbol to be
+				// externally visible, and the linker's `--exclude-libs` flag works on the archive (.a) level.
+				//
+				// TODO: use `llvm-ar` to extract the relevant object file and link it separately?
+				DontExportSymbols = false,
+			},
 
 			// .NET for Android
 			new AndroidArchive ("libpinvoke-override-dynamic-release.a"),

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

@@ -102,6 +102,7 @@ protected override void Construct (LlvmIrModule module)
 		Log.LogDebugMessage ("  Looking for enabled native components");
 		var componentNames = new HashSet<string> (StringComparer.Ordinal);
 		var jniOnLoadNames = new HashSet<string> (StringComparer.Ordinal);
+		var symbolsToExplicitlyPreserve = new HashSet<LlvmIrGlobalVariableReference> ();
 		var nativeComponents = new NativeRuntimeComponents (monoComponents);
 		foreach (NativeRuntimeComponents.Archive archiveItem in nativeComponents.KnownArchives) {
 			if (!archiveItem.Include) {
@@ -113,6 +114,15 @@ protected override void Construct (LlvmIrModule module)
 			if (!String.IsNullOrEmpty (archiveItem.JniOnLoadName)) {
 				jniOnLoadNames.Add (archiveItem.JniOnLoadName);
 			}
+
+			if (archiveItem.SymbolsToPreserve == null || archiveItem.SymbolsToPreserve.Count == 0) {
+				continue;
+			}
+
+			foreach (string symbolName in archiveItem.SymbolsToPreserve) {
+				symbolsToExplicitlyPreserve.Add (new LlvmIrGlobalVariableReference (symbolName));
+				DeclareDummyFunction (module, symbolName);
+			}
 		}
 
 		if (componentNames.Count == 0) {
@@ -124,13 +134,11 @@ protected override void Construct (LlvmIrModule module)
 		var jniOnLoadPointers = new List<LlvmIrVariableReference> ();
 		foreach (string name in jniOnLoadNames) {
 			jniOnLoadPointers.Add (new LlvmIrGlobalVariableReference (name));
-
-			// Just a dummy declaration, we don't care about the arguments
-			var funcSig = new LlvmIrFunctionSignature (name, returnType: typeof(void));
-			var _ = module.DeclareExternalFunction (funcSig);
+			DeclareDummyFunction (module, name);
 		}
 		module.AddGlobalVariable ("__jni_on_load_handlers", jniOnLoadPointers, LlvmIrVariableOptions.GlobalConstant);
 		module.AddGlobalVariable ("__jni_on_load_handler_names", jniOnLoadNames, LlvmIrVariableOptions.GlobalConstant);
+		module.AddGlobalVariable ("__explicitly_preserved_symbols", symbolsToExplicitlyPreserve, LlvmIrVariableOptions.GlobalConstant);
 
 		bool is64Bit = state.TargetArch switch {
 			AndroidTargetArch.Arm64  => true,
@@ -360,4 +368,11 @@ bool Matches (string libraryName, string componentName)
 			return String.Compare (libraryName, componentName, StringComparison.Ordinal) == 0;
 		}
 	}
+
+	static void DeclareDummyFunction (LlvmIrModule module, string name)
+	{
+		// Just a dummy declaration, we don't care about the arguments
+		var funcSig = new LlvmIrFunctionSignature (name, returnType: typeof(void));
+		var _ = module.DeclareExternalFunction (funcSig);
+	}
 }

src/native/pinvoke-override/dynamic.cc

@@ -18,6 +18,7 @@ extern "C" {
 	extern const uint32_t __jni_on_load_handler_count;
 	extern const JniOnLoadHandler __jni_on_load_handlers[];
 	extern const char* __jni_on_load_handler_names[];
+	extern const void* __explicitly_preserved_symbols[];
 }
 
 [[gnu::flatten]]
@@ -72,4 +73,13 @@ void PinvokeOverride::handle_jni_on_load (JavaVM *vm, void *reserved) noexcept
 	for (uint32_t i = 0; i < __jni_on_load_handler_count; i++) {
 		__jni_on_load_handlers[i] (vm, reserved);
 	}
+
+	// This is just to reference the generated array, all we need from it is to be there
+	// TODO: see if there's an attribute we can use to make the linker keep the symbol instead.
+	// void *first_ptr = __explicitly_preserved_symbols;
+	// if (first_ptr == nullptr) {
+	// 	// This will never actually be logged, since by the time this function is called we haven't initialized
+	// 	// logging categories yet.  It's here just to have some code in the if statement body.
+	// 	log_debug (LOG_ASSEMBLY, "No explicitly preserved symbols");
+	// }
 }