Optimize debug maps a bit

grendello · grendello · commit 03a87c4e679b · 2025-04-25T18:42:53.000+02:00
diff --git a/src/Xamarin.Android.Build.Tasks/Utilities/TypeMappingDebugNativeAssemblyGeneratorCLR.cs b/src/Xamarin.Android.Build.Tasks/Utilities/TypeMappingDebugNativeAssemblyGeneratorCLR.cs
@@ -16,6 +16,8 @@ class TypeMappingDebugNativeAssemblyGeneratorCLR : LlvmIrComposer
 	const string TypeMapSymbol = "type_map";
 	const string UniqueAssembliesSymbol = "type_map_unique_assemblies";
 	const string AssemblyNamesBlobSymbol = "type_map_assembly_names";
+	const string ManagedTypeNamesBlobSymbol = "type_map_managed_type_names";
+	const string JavaTypeNamesBlobSymbol = "type_map_java_type_names";
 
 	sealed class TypeMapContextDataProvider : NativeAssemblerStructContextDataProvider
 	{
@@ -53,11 +55,11 @@ public override string GetComment (object data, string fieldName)
 			var entry = EnsureType<TypeMapEntry> (data);
 
 			if (String.Compare ("from", fieldName, StringComparison.Ordinal) == 0) {
-				return $"from: {entry.from}";
+				return $"from: {entry.From}";
 			}
 
 			if (String.Compare ("to", fieldName, StringComparison.Ordinal) == 0) {
-				return $"to: {entry.to}";
+				return $"to: {entry.To}";
 			}
 
 			return String.Empty;
@@ -87,11 +89,23 @@ public override string GetComment (object data, string fieldName)
 	[NativeAssemblerStructContextDataProvider (typeof (TypeMapEntryContextDataProvider))]
 	sealed class TypeMapEntry
 	{
+		[NativeAssembler (Ignore = true)]
+		public string From;
+
+		[NativeAssembler (Ignore = true)]
+		public string To;
+
 		[NativeAssembler (UsesDataProvider = true)]
-		public string from;
+		public uint from;
+
+		[NativeAssembler (NumberFormat = LlvmIrVariableNumberFormat.Hexadecimal)]
+		public ulong from_hash;
 
 		[NativeAssembler (UsesDataProvider = true)]
-		public string to;
+		public uint to;
+
+		[NativeAssembler (NumberFormat = LlvmIrVariableNumberFormat.Hexadecimal)]
+		public ulong to_hash;
 	};
 
 	// Order of fields and their type must correspond *exactly* to that in
@@ -164,30 +178,45 @@ protected override void Construct (LlvmIrModule module)
 
 		MapStructures (module);
 
-		if (data.ManagedToJavaMap != null && data.ManagedToJavaMap.Count > 0) {
-			foreach (TypeMapGenerator.TypeMapDebugEntry entry in data.ManagedToJavaMap) {
-				var m2j = new TypeMapEntry {
-					from = entry.ManagedName,
-					to = entry.JavaName,
-				};
-				managedToJavaMap.Add (new StructureInstance<TypeMapEntry> (typeMapEntryStructureInfo, m2j));
-			}
+		var managedTypeNames = new LlvmIrStringBlob ();
+		var javaTypeNames = new LlvmIrStringBlob ();
+
+		// CoreCLR supports only 64-bit targets, so we can make things simpler by hashing all the things here instead of
+		// in a callback during code generation
+		foreach (TypeMapGenerator.TypeMapDebugEntry entry in data.ManagedToJavaMap) {
+			(int managedTypeNameOffset, int _) = managedTypeNames.Add (entry.ManagedName);
+			(int javaTypeNameOffset, int _) = javaTypeNames.Add (entry.JavaName);
+			var m2j = new TypeMapEntry {
+				From = entry.ManagedName,
+				To = entry.JavaName,
+
+				from = (uint)managedTypeNameOffset,
+				from_hash = MonoAndroidHelper.GetXxHash (entry.ManagedName, is64Bit: true),
+				to = (uint)javaTypeNameOffset,
+				to_hash = MonoAndroidHelper.GetXxHash (entry.JavaName, is64Bit: true),
+			};
+			managedToJavaMap.Add (new StructureInstance<TypeMapEntry> (typeMapEntryStructureInfo, m2j));
 		}
+		managedToJavaMap.Sort ((StructureInstance<TypeMapEntry> a, StructureInstance<TypeMapEntry> b) => a.Instance.from_hash.CompareTo (b.Instance.from_hash));
 
-		if (data.JavaToManagedMap != null && data.JavaToManagedMap.Count > 0) {
-			foreach (TypeMapGenerator.TypeMapDebugEntry entry in data.JavaToManagedMap) {
-				TypeMapGenerator.TypeMapDebugEntry managedEntry = entry.DuplicateForJavaToManaged != null ? entry.DuplicateForJavaToManaged : entry;
+		foreach (TypeMapGenerator.TypeMapDebugEntry entry in data.JavaToManagedMap) {
+			TypeMapGenerator.TypeMapDebugEntry managedEntry = entry.DuplicateForJavaToManaged != null ? entry.DuplicateForJavaToManaged : entry;
+			(int managedTypeNameOffset, int _) = managedTypeNames.Add (entry.ManagedName);
+			(int javaTypeNameOffset, int _) = javaTypeNames.Add (entry.JavaName);
 
-				var j2m = new TypeMapEntry {
-					from = entry.JavaName,
-					to = managedEntry.SkipInJavaToManaged ? null : managedEntry.ManagedName,
-				};
-				javaToManagedMap.Add (new StructureInstance<TypeMapEntry> (typeMapEntryStructureInfo, j2m));
-			}
+			var j2m = new TypeMapEntry {
+				From = entry.JavaName,
+				To = managedEntry.SkipInJavaToManaged ? String.Empty : entry.ManagedName,
+
+				from = (uint)javaTypeNameOffset,
+				from_hash = MonoAndroidHelper.GetXxHash (entry.JavaName, is64Bit: true),
+				to = managedEntry.SkipInJavaToManaged ? uint.MaxValue : (uint)managedTypeNameOffset,
+				to_hash = managedEntry.SkipInJavaToManaged ? 0 : MonoAndroidHelper.GetXxHash (entry.ManagedName, is64Bit: true),
+			};
+			javaToManagedMap.Add (new StructureInstance<TypeMapEntry> (typeMapEntryStructureInfo, j2m));
 		}
+		javaToManagedMap.Sort ((StructureInstance<TypeMapEntry> a, StructureInstance<TypeMapEntry> b) => a.Instance.from_hash.CompareTo (b.Instance.from_hash));
 
-		// CoreCLR supports only 64-bit targets, so we can make things simpler by hashing the MVIDs here instead of
-		// in a callback during code generation
 		var assemblyNamesBlob = new LlvmIrStringBlob ();
 		foreach (TypeMapGenerator.TypeMapDebugAssembly asm in data.UniqueAssemblies) {
 			(int assemblyNameOffset, int assemblyNameLength) = assemblyNamesBlob.Add (asm.Name);
@@ -224,6 +253,8 @@ protected override void Construct (LlvmIrModule module)
 
 		module.AddGlobalVariable (UniqueAssembliesSymbol, uniqueAssemblies, LlvmIrVariableOptions.GlobalConstant);
 		module.AddGlobalVariable (AssemblyNamesBlobSymbol, assemblyNamesBlob, LlvmIrVariableOptions.GlobalConstant);
+		module.AddGlobalVariable (ManagedTypeNamesBlobSymbol, managedTypeNames, LlvmIrVariableOptions.GlobalConstant);
+		module.AddGlobalVariable (JavaTypeNamesBlobSymbol, javaTypeNames, LlvmIrVariableOptions.GlobalConstant);
 	}
 
 	void MapStructures (LlvmIrModule module)
diff --git a/src/native/clr/host/typemap.cc b/src/native/clr/host/typemap.cc
@@ -65,36 +65,40 @@ namespace {
 
 #if defined(DEBUG)
 [[gnu::always_inline]]
-auto TypeMapper::typemap_type_to_type_debug (const char *typeName, const TypeMapEntry *map, std::string_view const& from_name, std::string_view const& to_name) noexcept -> const char*
+auto TypeMapper::typemap_type_to_type_debug (const char *typeName, const TypeMapEntry *map, const char (&name_map)[], std::string_view const& from_name, std::string_view const& to_name) noexcept -> const char*
 {
 	log_debug (LOG_ASSEMBLY, "Looking up {} type '{}'", from_name, optional_string (typeName));
-	auto equal = [](TypeMapEntry const& entry, const char *key) -> bool {
-		if (entry.from == nullptr) {
+	auto equal = [](TypeMapEntry const& entry, hash_t key) -> bool {
+		if (entry.from == std::numeric_limits<uint32_t>::max ()) {
 			return 1;
 		}
 
-		return strcmp (entry.from, key) == 0;
+		return entry.from_hash == key;
 	};
 
-	auto less_than = [](TypeMapEntry const& entry, const char *key) -> bool {
-		if (entry.from == nullptr) {
+	auto less_than = [](TypeMapEntry const& entry, hash_t key) -> bool {
+		if (entry.from == std::numeric_limits<uint32_t>::max ()) {
 			return 1;
 		}
 
-		return strcmp (entry.from, key) < 0;
+		return entry.from_hash < key;
 	};
 
-	ssize_t idx = Search::binary_search<TypeMapEntry, const char*, equal, less_than> (typeName, map, type_map.entry_count);
+	hash_t type_name_hash = xxhash::hash (typeName, strlen (typeName));
+	ssize_t idx = Search::binary_search<TypeMapEntry, hash_t, equal, less_than> (type_name_hash, map, type_map.entry_count);
 	if (idx >= 0) [[likely]] {
+		TypeMapEntry const& entry = map[idx];
+		const char *mapped_name = &name_map[entry.to];
+
 		log_debug (
 			LOG_ASSEMBLY,
 			"{} type '{}' maps to {} type '{}'",
 			from_name,
 			optional_string (typeName),
 			to_name,
-			optional_string (type_map.managed_to_java[idx].to)
+			optional_string (mapped_name)
 		);
-		return type_map.managed_to_java[idx].to;
+		return mapped_name;
 	}
 
 	return nullptr;
@@ -126,7 +130,7 @@ auto TypeMapper::typemap_managed_to_java_debug (const char *typeName, const uint
 		log_warn (LOG_ASSEMBLY, "Unable to look up assembly name for type '{}', trying without it.", typeName);
 	}
 
-	return typemap_type_to_type_debug (full_type_name.get (), type_map.managed_to_java, MANAGED, JAVA);
+	return typemap_type_to_type_debug (full_type_name.get (), type_map.managed_to_java, type_map_java_type_names, MANAGED, JAVA);
 }
 #endif // def DEBUG
 
@@ -300,7 +304,7 @@ auto TypeMapper::typemap_java_to_managed_debug (const char *java_type_name, char
 	// FIXME: this is currently VERY broken
 	*assembly_name = nullptr;
 	*managed_type_token_id = 0;
-	return typemap_type_to_type_debug (java_type_name, type_map.java_to_managed, JAVA, MANAGED);
+	return typemap_type_to_type_debug (java_type_name, type_map.java_to_managed, type_map_managed_type_names, JAVA, MANAGED);
 }
 #else // def DEBUG
 
diff --git a/src/native/clr/include/host/typemap.hh b/src/native/clr/include/host/typemap.hh
@@ -27,7 +27,7 @@ namespace xamarin::android {
 
 		static auto find_java_to_managed_entry (hash_t name_hash) noexcept -> const TypeMapJava*;
 #else
-		static auto typemap_type_to_type_debug (const char *typeName, const TypeMapEntry *map, std::string_view const& from_name, std::string_view const& to_name) noexcept -> const char*;
+		static auto typemap_type_to_type_debug (const char *typeName, const TypeMapEntry *map, const char (&name_map)[], std::string_view const& from_name, std::string_view const& to_name) noexcept -> const char*;
 		static auto typemap_managed_to_java_debug (const char *typeName, const uint8_t *mvid) noexcept -> const char*;
 		static auto typemap_java_to_managed_debug (const char *java_type_name, char const** assembly_name, uint32_t *managed_type_token_id) noexcept -> bool;
 #endif
diff --git a/src/native/clr/include/xamarin-app.hh b/src/native/clr/include/xamarin-app.hh
@@ -56,10 +56,15 @@ struct TypeMapIndexHeader
 	uint32_t module_file_name_width;
 };
 
+// If any of the members is set to maximum uint32_t value it means the entry is ignored (treated
+// as equivalent to `nullptr` if the member was a pointer). The reasoning is that no string could
+// begin at this offset (well, an empty string could, but we don't have those here)
 struct TypeMapEntry
 {
-	const char *from;
-	const char *to;
+	const uint32_t from;
+	const xamarin::android::hash_t from_hash;
+	const uint32_t to;
+	const xamarin::android::hash_t to_hash;
 };
 
 // MUST match src/Xamarin.Android.Build.Tasks/Utilities/TypeMappingDebugNativeAssemblyGeneratorCLR.cs
@@ -325,6 +330,8 @@ extern "C" {
 	[[gnu::visibility("default")]] extern const TypeMap type_map; // MUST match src/Xamarin.Android.Build.Tasks/Utilities/TypeMappingDebugNativeAssemblyGeneratorCLR.cs
 	[[gnu::visibility("default")]] extern const TypeMapAssembly type_map_unique_assemblies[];
 	[[gnu::visibility("default")]] extern const char type_map_assembly_names[];
+	[[gnu::visibility("default")]] extern const char type_map_managed_type_names[];
+	[[gnu::visibility("default")]] extern const char type_map_java_type_names[];
 #else
 	[[gnu::visibility("default")]] extern const uint32_t managed_to_java_map_module_count;
 	[[gnu::visibility("default")]] extern const uint32_t java_type_count;
diff --git a/src/native/clr/xamarin-app-stub/application_dso_stub.cc b/src/native/clr/xamarin-app-stub/application_dso_stub.cc
@@ -10,7 +10,6 @@ const uint64_t format_tag = FORMAT_TAG;
 
 #if defined (DEBUG)
 static TypeMapEntry java_to_managed[] = {};
-
 static TypeMapEntry managed_to_java[] = {};
 
 // MUST match src/Xamarin.Android.Build.Tasks/Utilities/TypeMappingDebugNativeAssemblyGenerator.cs
@@ -24,6 +23,8 @@ const TypeMap type_map = {
 
 const TypeMapAssembly type_map_unique_assemblies[] = {};
 const char type_map_assembly_names[] = {};
+const char type_map_managed_type_names[] = {};
+const char type_map_java_type_names[] = {};
 #else
 const uint32_t managed_to_java_map_module_count = 0;
 const uint32_t java_type_count = 0;
