Let's see if this works

Author: grendello

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

@@ -3,6 +3,7 @@
 using System.Collections;
 using System.Collections.Generic;
 using System.Globalization;
+using System.Reflection;
 using System.IO;
 using System.Text;
 
@@ -248,6 +249,12 @@ void WriteGlobalVariables (GeneratorWriteContext context)
 			}
 		}
 
+		void WriteVariableReference (GeneratorWriteContext context, LlvmIrVariableReference variable)
+		{
+			context.Output.Write (variable.Global ? '@' : '%');
+			context.Output.Write (variable.Name);
+		}
+
 		void WriteGlobalVariableStart (GeneratorWriteContext context, LlvmIrGlobalVariable variable)
 		{
 			if (!String.IsNullOrEmpty (variable.Comment)) {
@@ -355,6 +362,10 @@ ulong GetAggregateValueElementCount (GeneratorWriteContext context, Type type, o
 				return (uint)((ICollection)value).Count;
 			}
 
+			if (type.ImplementsInterface (typeof(ICollection<>))) {
+				return (ulong)GetCollectionOfTCount (type, value);
+			}
+
 			throw new InvalidOperationException ($"Internal error: should never get here");
 		}
 
@@ -732,6 +743,11 @@ public void WriteValue (GeneratorWriteContext context, Type type, object? value)
 				throw new NotSupportedException ($"Internal error: array of type {type} is unsupported");
 			}
 
+			if (type == typeof (LlvmIrVariableReference) || type.IsSubclassOf (typeof (LlvmIrVariableReference))) {
+				WriteVariableReference (context, (LlvmIrVariableReference)value);
+				return;
+			}
+
 			throw new NotSupportedException ($"Internal error: value type '{type}' is unsupported");
 		}
 
@@ -940,8 +956,19 @@ void WriteArrayValue (GeneratorWriteContext context, LlvmIrVariable variable)
 					list.Add (kvp.Value);
 				}
 				entries = list;
-			} else {
+			} else if (variable.Type.ImplementsInterface (typeof (ICollection))) {
 				entries = (ICollection)variable.Value;
+			} else if (variable.Type.ImplementsInterface (typeof (ICollection<>))) {
+				// This is slow and messy, but should work for a wide range of types without us having to add
+				// any explicit support
+				Type elementType = variable.Type.GetArrayElementType ();
+				int elementCount = GetCollectionOfTCount (variable.Type, variable.Value);
+				Array array = Array.CreateInstance (elementType, elementCount);
+				MethodInfo copyTo = variable.Type.GetMethod ("CopyTo", new Type[] { array.GetType (), typeof (int) });
+				copyTo.Invoke (variable.Value, new object[] { array, (int)0 });
+				entries = array;
+			} else {
+				throw new NotSupportedException ($"Unsupported array value type '{variable.Type}'");
 			}
 
 			if (entries.Count == 0) {
@@ -1617,5 +1644,21 @@ public static string QuoteString (byte[] bytes, int byteCount, out ulong stringS
 
 			return QuoteStringNoEscape (sb.ToString ());
 		}
+
+		static int GetCollectionOfTCount (Type type, object instance)
+		{
+			if (!type.ImplementsInterface (typeof (ICollection<>))) {
+				throw new ArgumentException ("Must implement the ICollection<T> interface", nameof (type));
+			}
+
+			PropertyInfo countProperty = type.GetProperty ("Count");
+			var ret = (int)countProperty.GetValue (instance);
+
+			if (ret < 0) {
+				throw new InvalidOperationException ($"Collection count is negative: {ret}");
+			}
+
+			return ret;
+		}
 	}
 }

src/Xamarin.Android.Build.Tasks/Utilities/LlvmIrGenerator/TypeUtilities.cs

@@ -178,7 +178,7 @@ public static bool IsArray (this Type t)
 
 			// TODO: cache results here
 			// IDictionary<string, string> is a special case for name:value string arrays which we use for some constructs.
-			return (t.ImplementsInterface (typeof(ICollection<>)) && t.ImplementsInterface (typeof(ICollection))) ||
+			return (t.ImplementsInterface (typeof(ICollection<>)) || t.ImplementsInterface (typeof(ICollection))) ||
 				t.ImplementsInterface (typeof(IDictionary<string, string>));
 		}
 	}

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

@@ -10,17 +10,19 @@ class NativeRuntimeComponents
 	internal class Archive
 	{
 		public readonly string Name;
+		public readonly string JniOnLoadName;
 		public bool Include => shouldInclude (this);
 		public readonly bool WholeArchive;
 		public bool DontExportSymbols { get; set; }
 
 		Func<Archive, bool> shouldInclude;
 
-		public Archive (string name, Func<Archive, bool>? include = null, bool wholeArchive = false)
+		public Archive (string name, Func<Archive, bool>? include = null, bool wholeArchive = false, string? jniOnLoadName = null)
 		{
 			Name = name;
 			shouldInclude = include == null ? ((Archive arch) => true) : include;
 			WholeArchive = wholeArchive;
+			JniOnLoadName = jniOnLoadName;
 		}
 	}
 
@@ -52,8 +54,8 @@ public AndroidArchive (string name)
 
 	sealed class BclArchive : Archive
 	{
-		public BclArchive (string name, bool wholeArchive = false)
-			: base (name, wholeArchive: wholeArchive)
+		public BclArchive (string name, bool wholeArchive = false, string? jniOnLoadName = null)
+			: base (name, wholeArchive: wholeArchive, jniOnLoadName: jniOnLoadName)
 		{
 			DontExportSymbols = true;
 		}
@@ -87,7 +89,7 @@ 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"),
+			new BclArchive ("libSystem.Security.Cryptography.Native.Android.a", jniOnLoadName: "AndroidCryptoNative_InitLibraryOnLoad"),
 
 			// .NET for Android
 			new AndroidArchive ("libpinvoke-override-dynamic-release.a"),

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

@@ -100,7 +100,8 @@ protected override void Construct (LlvmIrModule module)
 		}
 
 		Log.LogDebugMessage ("  Looking for enabled native components");
-		var componentNames = new List<string> ();
+		var componentNames = new HashSet<string> (StringComparer.Ordinal);
+		var jniOnLoadNames = new HashSet<string> (StringComparer.Ordinal);
 		var nativeComponents = new NativeRuntimeComponents (monoComponents);
 		foreach (NativeRuntimeComponents.Archive archiveItem in nativeComponents.KnownArchives) {
 			if (!archiveItem.Include) {
@@ -109,13 +110,28 @@ protected override void Construct (LlvmIrModule module)
 
 			Log.LogDebugMessage ($"    {archiveItem.Name}");
 			componentNames.Add (archiveItem.Name);
+			if (!String.IsNullOrEmpty (archiveItem.JniOnLoadName)) {
+				jniOnLoadNames.Add (archiveItem.JniOnLoadName);
+			}
 		}
 
 		if (componentNames.Count == 0) {
 			Log.LogDebugMessage ("No native framework components are included in the build, not scanning for p/invoke usage");
 			return;
 		}
 
+		module.AddGlobalVariable ("__jni_on_load_handler_count", (uint)jniOnLoadNames.Count, LlvmIrVariableOptions.GlobalConstant);
+		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);
+		}
+		module.AddGlobalVariable ("__jni_on_load_handlers", jniOnLoadPointers, LlvmIrVariableOptions.GlobalConstant);
+		module.AddGlobalVariable ("__jni_on_load_handler_names", jniOnLoadNames, LlvmIrVariableOptions.GlobalConstant);
+
 		bool is64Bit = state.TargetArch switch {
 			AndroidTargetArch.Arm64  => true,
 			AndroidTargetArch.X86_64 => true,
@@ -304,7 +320,7 @@ LlvmIrFunctionAttributeSet MakeFindPinvokeAttributeSet (LlvmIrModule module)
 	// Returns `true` for all p/invokes that we know are part of our set of components, otherwise returns `false`.
 	// Returning `false` merely means that the p/invoke isn't in any of BCL or our code and therefore we shouldn't
 	// care.  It doesn't mean the p/invoke will be removed in any way.
-	bool MustPreserve (PinvokeScanner.PinvokeEntryInfo pinfo, List<string> components)
+	bool MustPreserve (PinvokeScanner.PinvokeEntryInfo pinfo, ICollection<string> components)
 	{
 		if (String.Compare ("xa-internal-api", pinfo.LibraryName, StringComparison.Ordinal) == 0) {
 			return true;

src/native/monodroid/CMakeLists.txt

@@ -149,6 +149,11 @@ if(BUILD_STATIC_LIBRARY)
     ${XAMARIN_MONODROID_SOURCES}
   )
   set_static_library_suffix(${XAMARIN_MONO_ANDROID_STATIC_LIB})
+  target_compile_definitions(
+    ${XAMARIN_MONO_ANDROID_STATIC_LIB}
+    PRIVATE
+    DYNAMIC_RUNTIME_LINKING
+  )
 endif()
 
 macro(lib_target_options TARGET_NAME)

src/native/monodroid/monodroid-glue.cc

@@ -351,6 +351,9 @@ MonodroidRuntime::Java_JNI_OnLoad (JavaVM *vm, [[maybe_unused]] void *reserved)
 	vm->GetEnv ((void**)&env, JNI_VERSION_1_6);
 	osBridge.initialize_on_onload (vm, env);
 
+#if defined(DYNAMIC_RUNTIME_LINKING)
+	PinvokeOverride::handle_jni_on_load (vm, reserved);
+#endif
 	return JNI_VERSION_1_6;
 }
 

src/native/pinvoke-override/dynamic.cc

@@ -1,4 +1,5 @@
 #include <dlfcn.h>
+#include <jni.h>
 
 #define PINVOKE_OVERRIDE_INLINE [[gnu::noinline]]
 #include "pinvoke-override-api-impl.hh"
@@ -9,17 +10,26 @@ using namespace xamarin::android::internal;
 //
 // This is generated during application build (see obj/${CONFIGURATION}/${RID}/android/pinvoke_preserve.*.ll)
 //
-extern "C" void* find_pinvoke (hash_t library_name_hash, hash_t entrypoint_hash, bool &known_library);
+using JniOnLoadHandler = jint (*) (JavaVM *vm, void *reserved);
+
+extern "C" {
+	void* find_pinvoke (hash_t library_name_hash, hash_t entrypoint_hash, bool &known_library);
+
+	extern const uint32_t __jni_on_load_handler_count;
+	extern const JniOnLoadHandler __jni_on_load_handlers[];
+	extern const char* __jni_on_load_handler_names[];
+}
 
 [[gnu::flatten]]
 void*
-PinvokeOverride::monodroid_pinvoke_override (const char *library_name, const char *entrypoint_name)
+PinvokeOverride::monodroid_pinvoke_override (const char *library_name, const char *entrypoint_name) noexcept
 {
 	log_debug (LOG_ASSEMBLY, __PRETTY_FUNCTION__);
 	log_debug (LOG_ASSEMBLY, "library_name == '%s'; entrypoint_name == '%s'", library_name, entrypoint_name);
 
-	if (library_name == nullptr || entrypoint_name == nullptr) {
-        return nullptr;
+	if (library_name == nullptr || entrypoint_name == nullptr) [[unlikely]] {
+		log_fatal (LOG_ASSEMBLY, "Both library name ('%s') and entry point name ('%s') must be specified", library_name, entrypoint_name);
+		Helpers::abort_application ();
     }
 
 	hash_t library_name_hash = xxhash::hash (library_name, strlen (library_name));
@@ -28,7 +38,8 @@ PinvokeOverride::monodroid_pinvoke_override (const char *library_name, const cha
 
 	bool known_library = true;
 	void *pinvoke_ptr = find_pinvoke (library_name_hash, entrypoint_hash, known_library);
-	if (pinvoke_ptr != nullptr) {
+	if (pinvoke_ptr != nullptr) [[likely]] {
+		log_debug (LOG_ASSEMBLY, "pinvoke_ptr == %p", pinvoke_ptr);
 		return pinvoke_ptr;
 	}
 
@@ -39,12 +50,26 @@ PinvokeOverride::monodroid_pinvoke_override (const char *library_name, const cha
 		// the find* functions didn't know its hash), but we cannot be sure of that so we'll try to load it.
 		pinvoke_ptr = dlsym (RTLD_DEFAULT, entrypoint_name);
 		if (pinvoke_ptr == nullptr) {
-			log_warn (LOG_ASSEMBLY, "Unable to load p/invoke entry '%s/%s' from the unified runtime DSO", library_name, entrypoint_name);
+			log_fatal (LOG_ASSEMBLY, "Unable to load p/invoke entry '%s/%s' from the unified runtime DSO", library_name, entrypoint_name);
+			Helpers::abort_application ();
 		}
 
 		return pinvoke_ptr;
 	}
 
 	log_debug (LOG_ASSEMBLY, "p/invoke not from a known library, slow path taken.");
-	return handle_other_pinvoke_request (library_name, library_name_hash, entrypoint_name, entrypoint_hash);;
+	pinvoke_ptr = handle_other_pinvoke_request (library_name, library_name_hash, entrypoint_name, entrypoint_hash);;
+	log_debug (LOG_ASSEMBLY, "foreign library pinvoke_ptr == %p", pinvoke_ptr);
+	return pinvoke_ptr;
+}
+
+void PinvokeOverride::handle_jni_on_load (JavaVM *vm, void *reserved) noexcept
+{
+	if (__jni_on_load_handler_count == 0) {
+		return;
+	}
+
+	for (uint32_t i = 0; i < __jni_on_load_handler_count; i++) {
+		__jni_on_load_handlers[i] (vm, reserved);
+	}
 }

src/native/pinvoke-override/pinvoke-override-api.hh

@@ -2,6 +2,8 @@
 
 #include <string>
 
+#include <jni.h>
+
 #include "cppcompat.hh"
 #include "xxhash.hh"
 
@@ -75,7 +77,8 @@ namespace xamarin::android {
 		static void* fetch_or_create_pinvoke_map_entry (std::string const& library_name, std::string const& entrypoint_name, hash_t entrypoint_name_hash, pinvoke_api_map_ptr api_map, bool need_lock) noexcept;
 		static PinvokeEntry* find_pinvoke_address (hash_t hash, const PinvokeEntry *entries, size_t entry_count) noexcept;
 		static void* handle_other_pinvoke_request (const char *library_name, hash_t library_name_hash, const char *entrypoint_name, hash_t entrypoint_name_hash) noexcept;
-		static void* monodroid_pinvoke_override (const char *library_name, const char *entrypoint_name);
+		static void* monodroid_pinvoke_override (const char *library_name, const char *entrypoint_name) noexcept;
+		static void handle_jni_on_load (JavaVM *vm, void *reserved) noexcept;
 
 	private:
 		static xamarin::android::mutex  pinvoke_map_write_lock;

src/native/pinvoke-override/precompiled.cc

@@ -9,7 +9,7 @@ using namespace xamarin::android;
 
 [[gnu::flatten]]
 void*
-PinvokeOverride::monodroid_pinvoke_override (const char *library_name, const char *entrypoint_name)
+PinvokeOverride::monodroid_pinvoke_override (const char *library_name, const char *entrypoint_name) noexcept
 {
 	if (library_name == nullptr || entrypoint_name == nullptr) {
 		return nullptr;