Release+assembly stores works fine now

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

@@ -28,7 +28,7 @@ public override string GetComment (object data, string fieldName)
 			{
 				var dso_entry = EnsureType<DSOCacheEntry> (data);
 				if (String.Compare ("hash", fieldName, StringComparison.Ordinal) == 0) {
-					return $" hash 0x{dso_entry.hash:x}, from name: {dso_entry.HashedName}";
+					return $" from name: {dso_entry.HashedName}";
 				}
 
 				if (String.Compare ("name", fieldName, StringComparison.Ordinal) == 0) {
@@ -48,7 +48,7 @@ sealed class DSOCacheEntry
 			[NativeAssembler (Ignore = true)]
 			public string HashedName;
 
-			[NativeAssembler (UsesDataProvider = true)]
+			[NativeAssembler (UsesDataProvider = true, NumberFormat = LlvmIrVariableNumberFormat.Hexadecimal)]
 			public ulong hash;
 			public bool ignore;
 
@@ -92,9 +92,10 @@ sealed class AssemblyStoreSingleAssemblyRuntimeData
 		// src/monodroid/jni/xamarin-app.hh AssemblyStoreRuntimeData structure
 		sealed class AssemblyStoreRuntimeData
 		{
-			[NativePointer]
+			[NativePointer (IsNull = true)]
 			public byte data_start;
 			public uint assembly_count;
+			public uint index_entry_count;
 
 			[NativePointer (IsNull = true)]
 			public AssemblyStoreAssemblyDescriptor assemblies;
@@ -354,7 +355,14 @@ void AddNameMutations (string name)
 			{
 				nameMutations.Add (name);
 				if (name.EndsWith (".dll.so", StringComparison.OrdinalIgnoreCase)) {
-					nameMutations.Add (Path.GetFileNameWithoutExtension (Path.GetFileNameWithoutExtension (name))!);
+					string nameNoExt = Path.GetFileNameWithoutExtension (Path.GetFileNameWithoutExtension (name))!;
+					nameMutations.Add (nameNoExt);
+
+					// This helps us at runtime, because sometimes MonoVM will ask for "AssemblyName" and sometimes for "AssemblyName.dll".
+					// In the former case, the runtime would ask for the "libaot-AssemblyName.so" image, which doesn't exist - we have
+					// "libaot-AssemblyName.dll.so" instead and, thus, we are forced to check for and append the missing ".dll" extension when
+					// loading the assembly, unnecessarily wasting time.
+					nameMutations.Add ($"{nameNoExt}.so");
 				} else {
 					nameMutations.Add (Path.GetFileNameWithoutExtension (name)!);
 				}

src/Xamarin.Android.Build.Tasks/Utilities/AssemblyStoreGenerator.Classes.cs

@@ -4,16 +4,22 @@ partial class AssemblyStoreGenerator
 {
 	sealed class AssemblyStoreHeader
 	{
-		public const uint NativeSize = 3 * sizeof (uint);
+		public const uint NativeSize = 5 * sizeof (uint);
 
 		public readonly uint magic = ASSEMBLY_STORE_MAGIC;
 		public readonly uint version;
-		public readonly uint entry_count = 0;
+		public readonly uint entry_count;
+		public readonly uint index_entry_count;
 
-		public AssemblyStoreHeader (uint version, uint entry_count)
+		// Index size in bytes
+		public readonly uint index_size;
+
+		public AssemblyStoreHeader (uint version, uint entry_count, uint index_entry_count, uint index_size)
 		{
 			this.version = version;
 			this.entry_count = entry_count;
+			this.index_entry_count = index_entry_count;
+			this.index_size = index_size;
 		}
 	}
 

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

@@ -24,6 +24,8 @@ namespace Xamarin.Android.Tasks;
 //  [MAGIC]       uint; value: 0x41424158
 //  [FORMAT]      uint; store format version number
 //  [ENTRY_COUNT] uint; number of entries in the store
+//  [INDEX_ENTRY_COUNT] uint; number of entries in the index
+//  [INDEX_SIZE] uint; index size in bytes
 //
 // INDEX (variable size, HEADER.ENTRY_COUNT*2 entries, for assembly names with and without the extension)
 //  [NAME_HASH]        uint on 32-bit platforms, ulong on 64-bit platforms; xxhash of the assembly name
@@ -126,11 +128,13 @@ string Generate (string baseOutputDirectory, AndroidTargetArch arch, List<Assemb
 		fs.Seek (0, SeekOrigin.Begin);
 
 		uint storeVersion = is64Bit ? ASSEMBLY_STORE_FORMAT_VERSION_64BIT : ASSEMBLY_STORE_FORMAT_VERSION_32BIT;
-		var header = new AssemblyStoreHeader (storeVersion, infoCount);
+		var header = new AssemblyStoreHeader (storeVersion, infoCount, (uint)index.Count, (uint)(index.Count * IndexEntrySize ()));
 		using var writer = new BinaryWriter (fs);
 		writer.Write (header.magic);
 		writer.Write (header.version);
 		writer.Write (header.entry_count);
+		writer.Write (header.index_entry_count);
+		writer.Write (header.index_size);
 
 		index.Sort ((AssemblyStoreIndexEntry a, AssemblyStoreIndexEntry b) => a.name_hash.CompareTo (b.name_hash));
 

src/monodroid/jni/embedded-assemblies-zip.cc

@@ -67,8 +67,7 @@ EmbeddedAssemblies::zip_load_entry_common (size_t entry_index, std::vector<uint8
 
 #if defined (NET)
 	if (application_config.have_runtime_config_blob && !runtime_config_blob_found) {
-		if (utils.ends_with (entry_name, SharedConstants::RUNTIME_CONFIG_BLOB_NAME)) { // TODO: fix this for rc.bin.so
-																					   // being in `lib/ARCH/` now
+		if (utils.ends_with (entry_name, SharedConstants::RUNTIME_CONFIG_BLOB_NAME)) {
 			runtime_config_blob_found = true;
 			runtime_config_blob_mmap = md_mmap_apk_file (state.apk_fd, state.data_offset, state.file_size, entry_name.get ());
 			return false;
@@ -192,13 +191,11 @@ EmbeddedAssemblies::map_assembly_store (dynamic_local_string<SENSIBLE_PATH_MAX>
 	}
 
 	constexpr size_t header_size = sizeof(AssemblyStoreHeader);
-	constexpr size_t index_assembly_info_size = sizeof(AssemblyStoreIndexEntry) * 2; // We have two records for each assembly
-	const size_t index_size = (index_assembly_info_size * header->entry_count);
 
-	log_debug (LOG_ASSEMBLY, "Assembly store: index size == %zu; header size == %zu; entry size == %zu", index_size, header_size, index_assembly_info_size / 2);
 	assembly_store.data_start = static_cast<uint8_t*>(assembly_store_map.area);
 	assembly_store.assembly_count = header->entry_count;
-	assembly_store.assemblies = reinterpret_cast<AssemblyStoreEntryDescriptor*>(assembly_store.data_start + header_size + index_size);
+	assembly_store.index_entry_count = header->index_entry_count;
+	assembly_store.assemblies = reinterpret_cast<AssemblyStoreEntryDescriptor*>(assembly_store.data_start + header_size + header->index_size);
 	assembly_store_hashes = reinterpret_cast<AssemblyStoreIndexEntry*>(assembly_store.data_start + header_size);
 
 	number_of_found_assemblies += assembly_store.assembly_count;
@@ -223,16 +220,14 @@ EmbeddedAssemblies::zip_load_assembly_store_entries (std::vector<uint8_t> const&
 			break;
 		}
 
-		//		log_debug (LOG_ASSEMBLY, "ZIP entry: %s", entry_name.get ());
 		bool interesting_entry = zip_load_entry_common (i, buf, entry_name, state);
 		if (!interesting_entry) {
 			continue;
 		}
 
-		//		log_debug (LOG_ASSEMBLY, "Interesting entry: %s", entry_name.get ());
+		log_debug (LOG_ASSEMBLY, "Interesting entry: %s", entry_name.get ());
 		if (!assembly_store_found && utils.ends_with (entry_name, assembly_store_file_name)) {
 			assembly_store_found = true;
-			//			log_debug (LOG_ASSEMBLY, "Loading assembly store");
 			map_assembly_store (entry_name, state);
 		}
 	}

src/monodroid/jni/embedded-assemblies.cc

@@ -320,25 +320,14 @@ EmbeddedAssemblies::individual_assemblies_open_from_bundles (dynamic_local_strin
 }
 
 force_inline const AssemblyStoreIndexEntry*
-EmbeddedAssemblies::find_assembly_store_entry ([[maybe_unused]] hash_t hash, [[maybe_unused]] const AssemblyStoreIndexEntry *entries, [[maybe_unused]] size_t entry_count) noexcept
+EmbeddedAssemblies::find_assembly_store_entry (hash_t hash, const AssemblyStoreIndexEntry *entries, size_t entry_count) noexcept
 {
-#if !defined (__MINGW32__) || (defined (__MINGW32__) && __GNUC__ >= 10)
-	const AssemblyStoreIndexEntry *ret = nullptr;
-
-	while (entry_count > 0) {
-		ret = entries + (entry_count / 2);
-		auto result = hash <=> ret->name_hash;
-
-		if (result < 0) {
-			entry_count /= 2;
-		} else if (result > 0) {
-			entries = ret + 1;
-			entry_count -= entry_count / 2 + 1;
-		} else {
-			return ret;
-		}
+	auto equal = [](AssemblyStoreIndexEntry const& entry, hash_t key) -> bool { return entry.name_hash == key; };
+	auto less_than = [](AssemblyStoreIndexEntry const& entry, hash_t key) -> bool { return entry.name_hash < key; };
+	ssize_t idx = Search::binary_search<AssemblyStoreIndexEntry, equal, less_than> (hash, entries, entry_count);
+	if (idx >= 0) {
+		return &entries[idx];
 	}
-#endif // ndef __MINGW32__ || (def __MINGW32__ && __GNUC__ >= 10)
 
 	return nullptr;
 }
@@ -347,44 +336,30 @@ template<LoaderData TLoaderData>
 force_inline MonoAssembly*
 EmbeddedAssemblies::assembly_store_open_from_bundles (dynamic_local_string<SENSIBLE_PATH_MAX>& name, TLoaderData loader_data, bool ref_only) noexcept
 {
-	size_t len = name.length ();
-	bool have_dll_ext = utils.ends_with (name, SharedConstants::DLL_EXTENSION);
-
-	if (have_dll_ext) {
-		len -= sizeof(SharedConstants::DLL_EXTENSION) - 1;
-	}
-
-	hash_t name_hash = xxhash::hash (name.get (), len);
+	hash_t name_hash = xxhash::hash (name.get (), name.length ());
 	log_debug (LOG_ASSEMBLY, "assembly_store_open_from_bundles: looking for bundled name: '%s' (hash 0x%zx)", name.get (), name_hash);
 
-	const AssemblyStoreIndexEntry *hash_entry = find_assembly_store_entry (name_hash, assembly_store_hashes, application_config.number_of_assemblies_in_apk);
-	log_debug (LOG_ASSEMBLY, "assembly_store_open_from_bundles: #0");
+	const AssemblyStoreIndexEntry *hash_entry = find_assembly_store_entry (name_hash, assembly_store_hashes, assembly_store.index_entry_count);
 	if (hash_entry == nullptr) {
 		log_warn (LOG_ASSEMBLY, "Assembly '%s' (hash 0x%zx) not found", name.get (), name_hash);
 		return nullptr;
 	}
-	log_debug (LOG_ASSEMBLY, "assembly_store_open_from_bundles: #1");
+
 	if (hash_entry->descriptor_index >= assembly_store.assembly_count) {
-		log_fatal (LOG_ASSEMBLY, "Invalid assembly index %u, exceeds the maximum index of %u", hash_entry->descriptor_index, assembly_store.assembly_count - 1);
+		log_fatal (LOG_ASSEMBLY, "Invalid assembly descriptor index %u, exceeds the maximum value of %u", hash_entry->descriptor_index, assembly_store.assembly_count - 1);
 		Helpers::abort_application ();
 	}
-	log_debug (LOG_ASSEMBLY, "assembly_store_open_from_bundles: #2 (descriptor_index: %u)", hash_entry->descriptor_index);
-	AssemblyStoreEntryDescriptor *store_entry = &assembly_store.assemblies[hash_entry->descriptor_index];
-	log_debug (LOG_ASSEMBLY, "assembly_store_open_from_bundles: #3 (mapping_index: %u)", store_entry->mapping_index);
-	AssemblyStoreSingleAssemblyRuntimeData &assembly_runtime_info = assembly_store_bundled_assemblies[store_entry->mapping_index];
-	log_debug (LOG_ASSEMBLY, "assembly_store_open_from_bundles: #4");
+
+	AssemblyStoreEntryDescriptor &store_entry = assembly_store.assemblies[hash_entry->descriptor_index];
+	AssemblyStoreSingleAssemblyRuntimeData &assembly_runtime_info = assembly_store_bundled_assemblies[store_entry.mapping_index];
+
 	if (assembly_runtime_info.image_data == nullptr) {
-		log_debug (LOG_ASSEMBLY, "assembly_store_open_from_bundles: #5");
 		// The assignments here don't need to be atomic, the value will always be the same, so even if two threads
 		// arrive here at the same time, nothing bad will happen.
-		assembly_runtime_info.image_data = assembly_store.data_start + store_entry->data_offset;
-		log_debug (LOG_ASSEMBLY, "assembly_store_open_from_bundles: #6");
-		assembly_runtime_info.descriptor = store_entry;
-		log_debug (LOG_ASSEMBLY, "assembly_store_open_from_bundles: #7");
-		if (store_entry->debug_data_offset != 0) {
-			log_debug (LOG_ASSEMBLY, "assembly_store_open_from_bundles: #8");
-			assembly_runtime_info.debug_info_data = assembly_store.data_start + store_entry->debug_data_offset;
-			log_debug (LOG_ASSEMBLY, "assembly_store_open_from_bundles: #9");
+		assembly_runtime_info.image_data = assembly_store.data_start + store_entry.data_offset;
+		assembly_runtime_info.descriptor = &store_entry;
+		if (store_entry.debug_data_offset != 0) {
+			assembly_runtime_info.debug_info_data = assembly_store.data_start + store_entry.debug_data_offset;
 		}
 #if !defined (NET)
 		if (bba->config_data_size != 0) {
@@ -397,7 +372,6 @@ EmbeddedAssemblies::assembly_store_open_from_bundles (dynamic_local_string<SENSI
 			);
 		}
 #endif // NET
-		log_debug (LOG_ASSEMBLY, "assembly_store_open_from_bundles: #10");
 		log_debug (
 			LOG_ASSEMBLY,
 			"Mapped: image_data == %p; debug_info_data == %p; config_data == %p; descriptor == %p; data size == %u; debug data size == %u; config data size == %u; name == '%s'",
@@ -410,20 +384,11 @@ EmbeddedAssemblies::assembly_store_open_from_bundles (dynamic_local_string<SENSI
 			assembly_runtime_info.descriptor->config_data_size,
 			name.get ()
 		);
-		log_debug (LOG_ASSEMBLY, "assembly_store_open_from_bundles: #11");
 	}
-	log_debug (LOG_ASSEMBLY, "assembly_store_open_from_bundles: #12");
 
 	uint8_t *assembly_data;
 	uint32_t assembly_data_size;
 
-	if (!have_dll_ext) {
-		// AOT needs this since Mono will form the DSO name by appending the .so suffix to the assembly name passed to
-		// functions below and `monodroid_dlopen` uses the `.dll.so` extension to check whether we're being asked to load
-		// the AOTd code for an assembly.
-		name.append (SharedConstants::DLL_EXTENSION);
-	}
-
 	get_assembly_data (assembly_runtime_info, assembly_data, assembly_data_size);
 	MonoImage *image = MonoImageLoader::load (name, loader_data, name_hash, assembly_data, assembly_data_size);
 	if (image == nullptr) {

src/monodroid/jni/embedded-assemblies.hh

@@ -97,6 +97,8 @@ namespace xamarin::android::internal {
 		static constexpr char  assemblies_prefix[] = "assemblies/";
 		static constexpr char  zip_path_separator[] = "/";
 
+		// We have two records for each assembly, for names with and without the extension
+		static constexpr uint32_t assembly_store_index_entries_per_assembly = 2;
 		static constexpr uint32_t number_of_assembly_store_files = 1;
 		static constexpr char assembly_store_prefix[] = "lib/";
 		static constexpr auto assembly_store_file_name = concat_const (assembly_store_prefix, SharedConstants::android_lib_abi, "/assemblies.", SharedConstants::android_lib_abi, ".blob.so");
@@ -347,7 +349,7 @@ namespace xamarin::android::internal {
 		uint32_t               number_of_mapped_assembly_stores = 0;
 		bool                   need_to_scan_more_apks = true;
 
-		AssemblyStoreIndexEntry             *assembly_store_hashes;
+		AssemblyStoreIndexEntry *assembly_store_hashes;
 		std::mutex             assembly_decompress_mutex;
 	};
 }

src/monodroid/jni/mono-image-loader.hh

@@ -134,7 +134,7 @@ namespace xamarin::android::internal {
 		}
 
 #if defined (USE_CACHE)
-		static inline size_t number_of_cache_index_entries = application_config.number_of_assemblies_in_apk * number_of_assembly_name_forms_in_image_cache;;
+		static inline size_t number_of_cache_index_entries = application_config.number_of_assemblies_in_apk * number_of_assembly_name_forms_in_image_cache;
 #endif // def USE_CACHE
 	};
 }

src/monodroid/jni/monodroid-glue.cc

@@ -367,6 +367,7 @@ MonodroidRuntime::gather_bundled_assemblies (jstring_array_wrapper &runtimeApks,
 	int64_t apk_count = static_cast<int64_t>(runtimeApks.get_length ());
 	size_t prev_num_assemblies = 0;
 	bool got_split_config_abi_apk = false;
+	bool got_base_apk = false;
 
 	for (int64_t i = 0; i < apk_count; i++) {
 		jstring_wrapper &apk_file = runtimeApks [static_cast<size_t>(i)];
@@ -378,6 +379,8 @@ MonodroidRuntime::gather_bundled_assemblies (jstring_array_wrapper &runtimeApks,
 			// configuration blob are in `lib/{ARCH}`, which in turn lives in the split config APK
 			if (!got_split_config_abi_apk && utils.ends_with (apk_file.get_cstr (), SharedConstants::split_config_abi_apk_name)) {
 				got_split_config_abi_apk = scan_apk = true;
+			} else if (!application_config.have_assembly_store && !got_base_apk && utils.ends_with (apk_file.get_cstr (), base_apk_name)) {
+				got_base_apk = scan_apk = true;
 			}
 
 			if (!scan_apk) {
@@ -1262,29 +1265,15 @@ MonodroidRuntime::init_internal_api_dso (void *handle)
 #endif // ndef NET
 
 force_inline DSOCacheEntry*
-MonodroidRuntime::find_dso_cache_entry ([[maybe_unused]] hash_t hash) noexcept
+MonodroidRuntime::find_dso_cache_entry (hash_t hash) noexcept
 {
-#if !defined (__MINGW32__) || (defined (__MINGW32__) && __GNUC__ >= 10)
-	hash_t entry_hash;
-	DSOCacheEntry *ret = nullptr;
-	size_t entry_count = application_config.number_of_dso_cache_entries;
-	DSOCacheEntry *entries = dso_cache;
-
-	while (entry_count > 0) {
-		ret = entries + (entry_count / 2);
-		entry_hash = static_cast<hash_t> (ret->hash);
-		auto result = hash <=> entry_hash;
-
-		if (result < 0) {
-			entry_count /= 2;
-		} else if (result > 0) {
-			entries = ret + 1;
-			entry_count -= entry_count / 2 + 1;
-		} else {
-			return ret;
-		}
+	auto equal = [](DSOCacheEntry const& entry, hash_t key) -> bool { return entry.hash == key; };
+	auto less_than = [](DSOCacheEntry const& entry, hash_t key) -> bool { return entry.hash < key; };
+	ssize_t idx = Search::binary_search<DSOCacheEntry, equal, less_than> (hash, dso_cache, application_config.number_of_dso_cache_entries);
+	if (idx >= 0) {
+		return &dso_cache[idx];
 	}
-#endif // ndef MINGW32 || def MINGW32 && GNUC >= 10
+
 	return nullptr;
 }
 

src/monodroid/jni/search.hh

@@ -6,26 +6,40 @@
 
 #include "platform-compat.hh"
 #include "xxhash.hh"
+#include "logger.hh"
 
 namespace xamarin::android::internal {
 	class Search final
 	{
 	public:
-		force_inline static ssize_t binary_search (hash_t key, const hash_t *arr, size_t n) noexcept
+		template<class T, bool (*equal) (T const&, hash_t), bool (*less_than) (T const&, hash_t)>
+		force_inline static ssize_t binary_search (hash_t key, const T *arr, size_t n) noexcept
 		{
+			static_assert (equal != nullptr, "equal is a required template parameter");
+			static_assert (less_than != nullptr, "less_than is a required template parameter");
+
 			ssize_t left = -1;
 			ssize_t right = static_cast<ssize_t>(n);
 
 			while (right - left > 1) {
 				ssize_t middle = (left + right) >> 1;
-				if (arr[middle] < key) {
+				if (less_than (arr[middle], key)) {
 					left = middle;
 				} else {
 					right = middle;
 				}
 			}
 
-			return arr[right] == key ? right : -1;
+			return equal (arr[right], key) ? right : -1;
+		}
+
+		force_inline static ssize_t binary_search (hash_t key, const hash_t *arr, size_t n) noexcept
+		{
+			log_debug (LOG_ASSEMBLY, "binary search over %zu entries for hash 0x%zx", n, key);
+			auto equal = [](hash_t const& entry, hash_t key) -> bool { return entry == key; };
+			auto less_than = [](hash_t const& entry, hash_t key) -> bool { return entry < key; };
+
+			return binary_search<hash_t, equal, less_than> (key, arr, n);
 		}
 
 		force_inline static ptrdiff_t binary_search_branchless (hash_t x, const hash_t *arr, uint32_t len) noexcept

src/monodroid/jni/xamarin-app.hh

@@ -150,6 +150,8 @@ struct [[gnu::packed]] AssemblyStoreHeader final
 	uint32_t magic;
 	uint32_t version;
 	uint32_t entry_count;
+	uint32_t index_entry_count;
+	uint32_t index_size; // index size in bytes
 };
 
 struct [[gnu::packed]] AssemblyStoreIndexEntry final
@@ -176,6 +178,7 @@ struct AssemblyStoreRuntimeData final
 {
 	uint8_t             *data_start;
 	uint32_t             assembly_count;
+	uint32_t             index_entry_count;
 	AssemblyStoreEntryDescriptor *assemblies;
 };