[CoreCLR] java to managed typemap (#10075)

Finish implementing java-to-managed typemap lookup for Debug builds (started in #10065). Maps translate Java type name to a pair consisting of the managed type's assembly name and its token ID within that assembly. This is then used by the managed land to find and load the indicated type.

Optimize, by using hashes, the managed-to-java typemap lookup for Debug builds, with a fallback to string-based lookups if hash clashes are detected. Since it is hard to produce a test for such clashes, instead add a way to force usage of string-based lookups by checking whether the `CI_TYPEMAP_DEBUG_USE_STRINGS` environment variable is present and not empty in the environment. This is used in one of the tests.

Additionally, optimize usage of certain sets of strings in native code, namely type and assembly names. Instead of storing them as "standard" string pointers, they are now contained in "blobs" - arrays of character data, separated with `NUL` characters. This approach gets rid of a potentially large number of native code relocations (each string is a pointer), replacing X pointers with a single pointer + offset when accessing a string. It also has a side effect of (slightly) reducing generated code size.

Author: grendello

src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/Utilities/DeviceTest.cs

@@ -1,6 +1,7 @@
 using NUnit.Framework;
 using NUnit.Framework.Interfaces;
 using System;
+using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
 using System.Diagnostics;
@@ -207,10 +208,10 @@ protected static string AdbStartActivity (string activity)
 			return RunAdbCommand ($"shell am start -S -n \"{activity}\"");
 		}
 
-		protected static void RunProjectAndAssert (XamarinAndroidApplicationProject proj, ProjectBuilder builder, string logName = "run.log", bool doNotCleanupOnUpdate = false, string [] parameters = null)
+		protected static void RunProjectAndAssert (XamarinAndroidApplicationProject proj, ProjectBuilder builder, string logName = "run.log", Dictionary<string, string> environmentVariables = null, bool doNotCleanupOnUpdate = false, string [] parameters = null)
 		{
 			builder.BuildLogFile = logName;
-			Assert.True (builder.RunTarget (proj, "Run", doNotCleanupOnUpdate: doNotCleanupOnUpdate, parameters: parameters), "Project should have run.");
+			Assert.True (builder.RunTarget (proj, "Run", doNotCleanupOnUpdate: doNotCleanupOnUpdate, parameters: parameters, environmentVariables: environmentVariables), "Project should have run.");
 		}
 
 		protected static void StartActivityAndAssert (XamarinAndroidApplicationProject proj)

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

@@ -374,6 +374,10 @@ bool IsValueAssignableFrom (Type valueType, LlvmIrVariable variable)
 
 		ulong GetAggregateValueElementCount (GeneratorWriteContext context, Type type, object? value, LlvmIrGlobalVariable? globalVariable = null)
 		{
+			if (type == typeof(LlvmIrStringBlob)) {
+				return 1; // String blobs are a collection of bytes
+			}
+
 			if (!type.IsArray ()) {
 				throw new InvalidOperationException ($"Internal error: unknown type {type} when trying to determine aggregate type element count");
 			}
@@ -479,6 +483,11 @@ void WriteType (GeneratorWriteContext context, Type type, object? value, out Llv
 				return;
 			}
 
+			if (type == typeof(LlvmIrStringBlob)) {
+				WriteStringBlobType (context, (LlvmIrStringBlob?)value, out typeInfo);
+				return;
+			}
+
 			irType = GetIRType (context, type, out size, out isPointer);
 			typeInfo = new LlvmTypeInfo (
 				isPointer: isPointer,
@@ -490,6 +499,21 @@ void WriteType (GeneratorWriteContext context, Type type, object? value, out Llv
 			context.Output.Write (irType);
 		}
 
+		void WriteStringBlobType (GeneratorWriteContext context, LlvmIrStringBlob? blob, out LlvmTypeInfo typeInfo)
+		{
+			long size = blob?.Size ?? 0;
+			// Blobs are always arrays of bytes
+			context.Output.Write ($"[{size} x i8]");
+
+			typeInfo = new LlvmTypeInfo (
+				isPointer: false,
+				isAggregate: true,
+				isStructure: false,
+				size: (ulong)size,
+				maxFieldAlignment: 1
+			);
+		}
+
 		void WriteArrayType (GeneratorWriteContext context, Type elementType, ulong elementCount, out LlvmTypeInfo typeInfo)
 		{
 			WriteArrayType (context, elementType, elementCount, variable: null, out typeInfo);
@@ -769,6 +793,11 @@ public void WriteValue (GeneratorWriteContext context, Type type, object? value,
 				return;
 			}
 
+			if (type == typeof(LlvmIrStringBlob)) {
+				WriteStringBlobArray (context, (LlvmIrStringBlob)value);
+				return;
+			}
+
 			if (type.IsArray) {
 				if (type == typeof(byte[])) {
 					WriteInlineArray (context, (byte[])value, encodeAsASCII: true);
@@ -786,6 +815,69 @@ public void WriteValue (GeneratorWriteContext context, Type type, object? value,
 			throw new NotSupportedException ($"Internal error: value type '{type}' is unsupported");
 		}
 
+		void WriteStringBlobArray (GeneratorWriteContext context, LlvmIrStringBlob blob)
+		{
+			const uint stride = 16;
+			Type elementType = typeof(byte);
+
+			LlvmIrVariableNumberFormat oldNumberFormat = context.NumberFormat;
+			context.NumberFormat = LlvmIrVariableNumberFormat.Hexadecimal;
+			WriteArrayValueStart (context);
+			foreach (LlvmIrStringBlob.StringInfo si in blob.GetSegments ()) {
+				if (si.Offset > 0) {
+					context.Output.Write (',');
+					context.Output.WriteLine ();
+					context.Output.WriteLine ();
+				}
+
+				context.Output.Write (context.CurrentIndent);
+				WriteCommentLine (context, $" '{si.Value}' @ {si.Offset}");
+				WriteBytes (si.Bytes);
+			}
+			context.Output.WriteLine ();
+			WriteArrayValueEnd (context);
+			context.NumberFormat = oldNumberFormat;
+
+			void WriteBytes (byte[] bytes)
+			{
+				ulong counter = 0;
+				bool first = true;
+				foreach (byte b in bytes) {
+					if (!first) {
+						WriteCommaWithStride (counter);
+					} else {
+						context.Output.Write (context.CurrentIndent);
+						first = false;
+					}
+
+					counter++;
+					WriteByteTypeAndValue (b);
+				}
+
+				WriteCommaWithStride (counter);
+				WriteByteTypeAndValue (0); // Terminating NUL is counted for each string, but not included in its bytes
+			}
+
+			void WriteCommaWithStride (ulong counter)
+			{
+				context.Output.Write (',');
+				if (stride == 1 || counter % stride == 0) {
+					context.Output.WriteLine ();
+					context.Output.Write (context.CurrentIndent);
+				} else {
+					context.Output.Write (' ');
+				}
+			}
+
+			void WriteByteTypeAndValue (byte v)
+			{
+				WriteType (context, elementType, v, out _);
+
+				context.Output.Write (' ');
+				WriteValue (context, elementType, v);
+			}
+		}
+
 		void WriteStructureValue (GeneratorWriteContext context, StructureInstance? instance)
 		{
 			if (instance == null || instance.IsZeroInitialized) {

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

@@ -0,0 +1,76 @@
+using System;
+using System.Collections.Generic;
+
+namespace Xamarin.Android.Tasks.LLVMIR;
+
+/// <summary><para>
+/// This class is an optimization which allows us to store strings
+/// as a single "blob" of data where each string follows another, all
+/// of them separated with a NUL character. This allows us to use a single
+/// pointer at run time instead of several (one per string). The result is
+/// less relocations in the final .so, which is good for performance
+/// </para><para>
+/// Each string is converted to UTF8 before storing as a byte array. To optimize
+/// for size, duplicate strings are not stored, instead the earlier offset+length
+/// are returned when calling the <see cref="Add(string)" /> method.
+/// </para>
+/// </summary>
+class LlvmIrStringBlob
+{
+	// Length is one more than byte size, to account for the terminating nul
+	public record struct StringInfo (int Offset, int Length, byte[] Bytes, string Value);
+
+	Dictionary<string, StringInfo> cache = new (StringComparer.Ordinal);
+	List<StringInfo> segments = new ();
+	long size = 0;
+
+	public long Size => size;
+
+	public (int offset, int length) Add (string s)
+	{
+		if (cache.TryGetValue (s, out StringInfo info)) {
+			return (info.Offset, info.Length);
+		}
+
+		byte[] bytes = MonoAndroidHelper.Utf8StringToBytes (s);
+		int offset;
+		if (segments.Count > 0) {
+			StringInfo lastSegment = segments[segments.Count - 1];
+			offset = lastSegment.Offset + lastSegment.Length + 1; // Include trailing NUL here
+		} else {
+			offset = 0;
+		}
+
+		info = new StringInfo (
+			Offset: offset,
+			Length: bytes.Length,
+			Bytes: bytes,
+			Value: s
+		);
+		segments.Add (info);
+		cache.Add (s, info);
+		size += info.Length + 1; // Account for the trailing NUL
+
+		return (info.Offset, info.Length);
+	}
+
+	public int GetIndexOf (string s)
+	{
+		if (String.IsNullOrEmpty (s)) {
+			return -1;
+		}
+
+		if (!cache.TryGetValue (s, out StringInfo info)) {
+			return -1;
+		}
+
+		return info.Offset;
+	}
+
+	public IEnumerable<StringInfo> GetSegments ()
+	{
+		foreach (StringInfo si in segments) {
+			yield return si;
+		}
+	}
+}

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

@@ -145,8 +145,10 @@ static TypeMapDebugEntry GetDebugEntry (TypeDefinition td, TypeDefinitionCache c
 		return new TypeMapDebugEntry {
 			JavaName = Java.Interop.Tools.TypeNameMappings.JavaNativeTypeManager.ToJniName (td, cache),
 			ManagedName = GetManagedTypeName (td),
+			ManagedTypeTokenId = td.MetadataToken.ToUInt32 (),
 			TypeDefinition = td,
 			SkipInJavaToManaged = ShouldSkipInJavaToManaged (td),
+			AssemblyName = td.Module.Assembly.Name.Name,
 		};
 	}
 

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

@@ -62,8 +62,10 @@ internal sealed class TypeMapDebugEntry
 		{
 			public string JavaName;
 			public string ManagedName;
+			public uint ManagedTypeTokenId;
 			public bool SkipInJavaToManaged;
 			public TypeMapDebugEntry DuplicateForJavaToManaged;
+			public string AssemblyName;
 
 			// This field is only used by the Cecil adapter for temp storage while reading.
 			// It is not used to create the typemap.

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

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.IO;
 using System.Linq;
 using System.Xml;
@@ -101,6 +102,7 @@ void WriteTypeMapDebugEntry (XmlWriter xml, TypeMapDebugEntry entry)
 		xml.WriteAttributeStringIfNotDefault ("managed-name", entry.ManagedName);
 		xml.WriteAttributeStringIfNotDefault ("skip-in-java-to-managed", entry.SkipInJavaToManaged);
 		xml.WriteAttributeStringIfNotDefault ("is-invoker", entry.IsInvoker);
+		xml.WriteAttributeString ("managed-type-token-id", entry.ManagedTypeTokenId.ToString (CultureInfo.InvariantCulture));
 		xml.WriteEndElement ();
 	}
 
@@ -198,19 +200,20 @@ public static TypeMapObjectsXmlFile Import (string filename)
 
 	static void ImportDebugData (XElement root, TypeMapObjectsXmlFile file)
 	{
-		var isMonoAndroid = root.GetAttributeOrDefault ("assembly-name", string.Empty) == "Mono.Android";
+		var assemblyName = root.GetAttributeOrDefault ("assembly-name", string.Empty);
+		var isMonoAndroid = assemblyName == "Mono.Android";
 		var javaToManaged = root.Element ("java-to-managed");
 
 		if (javaToManaged is not null) {
 			foreach (var entry in javaToManaged.Elements ("entry"))
-				file.JavaToManagedDebugEntries.Add (FromDebugEntryXml (entry, isMonoAndroid));
+				file.JavaToManagedDebugEntries.Add (FromDebugEntryXml (entry, assemblyName, isMonoAndroid));
 		}
 
 		var managedToJava = root.Element ("managed-to-java");
 
 		if (managedToJava is not null) {
 			foreach (var entry in managedToJava.Elements ("entry"))
-				file.ManagedToJavaDebugEntries.Add (FromDebugEntryXml (entry, isMonoAndroid));
+				file.ManagedToJavaDebugEntries.Add (FromDebugEntryXml (entry, assemblyName, isMonoAndroid));
 		}
 	}
 
@@ -251,19 +254,22 @@ public static void WriteEmptyFile (string destination, TaskLoggingHelper log)
 		File.Create (destination).Dispose ();
 	}
 
-	static TypeMapDebugEntry FromDebugEntryXml (XElement entry, bool isMonoAndroid)
+	static TypeMapDebugEntry FromDebugEntryXml (XElement entry, string assemblyName, bool isMonoAndroid)
 	{
 		var javaName = entry.GetAttributeOrDefault ("java-name", string.Empty);
 		var managedName = entry.GetAttributeOrDefault ("managed-name", string.Empty);
 		var skipInJavaToManaged = entry.GetAttributeOrDefault ("skip-in-java-to-managed", false);
 		var isInvoker = entry.GetAttributeOrDefault ("is-invoker", false);
+		var managedTokenId = entry.GetAttributeOrDefault ("managed-type-token-id", (uint)0);
 
 		return new TypeMapDebugEntry {
 			JavaName = javaName,
 			ManagedName = managedName,
+			ManagedTypeTokenId = managedTokenId,
 			SkipInJavaToManaged = skipInJavaToManaged,
 			IsInvoker = isInvoker,
 			IsMonoAndroid = isMonoAndroid,
+			AssemblyName = assemblyName,
 		};
 	}
 

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

@@ -66,11 +66,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;