Typemaps use type token ids again

Author: grendello

src/Mono.Android/Android.Runtime/RuntimeNativeMethods.cs

@@ -93,7 +93,7 @@ internal static class RuntimeNativeMethods
 		internal static extern IntPtr clr_typemap_managed_to_java (string fullName, IntPtr mvid);
 
 		[DllImport (RuntimeConstants.InternalDllName, CallingConvention = CallingConvention.Cdecl)]
-		internal static extern IntPtr clr_typemap_java_to_managed (string fullName);
+		internal static extern bool clr_typemap_java_to_managed (string java_type_name, out IntPtr managed_assembly_name, out uint managed_type_token_id);
 
 		[MethodImplAttribute(MethodImplOptions.InternalCall)]
 		internal static extern void monodroid_unhandled_exception (Exception javaException);

src/Mono.Android/Java.Interop/TypeManager.cs

@@ -220,17 +220,24 @@ static Type monovm_typemap_java_to_managed (string java_type_name)
 			return monodroid_typemap_java_to_managed (java_type_name);
 		}
 
-		[UnconditionalSuppressMessage ("Trimming", "IL2057", Justification = "Value of java_type_name isn't statically known.")]
+		[UnconditionalSuppressMessage ("Trimming", "IL2026", Justification = "Value of java_type_name isn't statically known.")]
 		static Type? clr_typemap_java_to_managed (string java_type_name)
 		{
-			IntPtr managedTypeNamePointer = RuntimeNativeMethods.clr_typemap_java_to_managed (java_type_name);
-			if (managedTypeNamePointer == IntPtr.Zero) {
+			bool result = RuntimeNativeMethods.clr_typemap_java_to_managed (java_type_name, out IntPtr managedAssemblyNamePointer, out uint managedTypeTokenId);
+			if (!result || managedAssemblyNamePointer == IntPtr.Zero) {
 				return null;
 			}
 
-			string managedTypeName = Marshal.PtrToStringAnsi (managedTypeNamePointer);
-			Logger.Log (LogLevel.Info, "monodroid", $"clr_typemap_java_to_managed ('{java_type_name}') returned '{managedTypeName}'");
-			Type ret = Type.GetType (managedTypeName);
+			string managedAssemblyName = Marshal.PtrToStringAnsi (managedAssemblyNamePointer);
+			Assembly assembly = Assembly.Load (managedAssemblyName);
+			Type? ret = null;
+			foreach (Module module in assembly.Modules) {
+				ret = module.ResolveType ((int)managedTypeTokenId);
+				if (ret != null) {
+					break;
+				}
+			}
+
 			Logger.Log (LogLevel.Info, "monodroid", $"Loaded type: {ret}");
 			return ret;
 		}

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

@@ -173,6 +173,9 @@ sealed class TypeMapJava
 			[NativeAssembler (UsesDataProvider = true)]
 			public uint managed_type_name_index;
 
+			[NativeAssembler (NumberFormat = LlvmIrVariableNumberFormat.Hexadecimal)]
+			public uint managed_type_token_id;
+
 			[NativeAssembler (UsesDataProvider = true)]
 			public uint java_name_index;
 		}
@@ -398,15 +401,15 @@ void InitJavaMap (ConstructionState cs)
 			TypeMapJava map_entry;
 			foreach (TypeMapGenerator.TypeMapReleaseEntry entry in mappingData.JavaTypes) {
 				string assemblyName = mappingData.Modules[entry.ModuleIndex].AssemblyName;
-				string fullManagedTypeName = $"{entry.ManagedTypeName}, {assemblyName}";
-				uint managedTypeNameIndex = GetEntryIndex (fullManagedTypeName, seenManagedTypeNames, cs.ManagedTypeNames);
+				uint managedTypeNameIndex = GetEntryIndex (entry.ManagedTypeName, seenManagedTypeNames, cs.ManagedTypeNames);
 				cs.JavaNames.Add (entry.JavaName);
 
 				map_entry = new TypeMapJava {
 					ManagedTypeName = cs.ManagedTypeNames[(int)managedTypeNameIndex],
 
 					module_index = (uint)entry.ModuleIndex, // UInt32.MaxValue,
 					managed_type_name_index = managedTypeNameIndex,
+					managed_type_token_id = entry.Token,
 					java_name_index = (uint)(cs.JavaNames.Count - 1),
 					JavaName = entry.JavaName,
 				};

src/native/clr/host/internal-pinvokes.cc

@@ -28,9 +28,9 @@ const char* clr_typemap_managed_to_java (const char *typeName, const uint8_t *mv
 	return TypeMapper::typemap_managed_to_java (typeName, mvid);
 }
 
-const char* clr_typemap_java_to_managed (const char *typeName) noexcept
+bool clr_typemap_java_to_managed (const char *java_type_name, char const** assembly_name, uint32_t *managed_type_token_id) noexcept
 {
-	return TypeMapper::typemap_java_to_managed (typeName);
+	return TypeMapper::typemap_java_to_managed (java_type_name, assembly_name, managed_type_token_id);
 }
 
 void monodroid_log (LogLevel level, LogCategories category, const char *message) noexcept

src/native/clr/host/typemap.cc

@@ -3,6 +3,7 @@
 #include <host/typemap.hh>
 #include <runtime-base/timing-internal.hh>
 #include <runtime-base/search.hh>
+#include <runtime-base/util.hh>
 #include <shared/xxhash.hh>
 #include <xamarin-app.hh>
 
@@ -14,10 +15,6 @@ namespace {
 		static inline constexpr size_t MVID_SIZE = 16;
 		static inline constexpr size_t NUM_HYPHENS = 4;
 		static inline constexpr size_t BUF_SIZE = (MVID_SIZE * 2) + NUM_HYPHENS + 1;
-		static inline std::array<char, 16> hex_map {
-			'0', '1', '2', '3', '4', '5', '6', '7',
-			'8', '9', 'a', 'b', 'c', 'd', 'e', 'f',
-		};
 
 	public:
 		explicit MonoGuidString (const uint8_t *mvid) noexcept
@@ -29,8 +26,8 @@ namespace {
 
 			// In the caller we trust, we have no way to validate the size here
 			auto to_hex = [this, &mvid] (size_t &dest_idx, size_t src_idx) {
-				_ascii_form[dest_idx++] = hex_map[(mvid[src_idx] & 0xf0) >> 4];
-				_ascii_form[dest_idx++] = hex_map[mvid[src_idx] & 0x0f];
+				Util::to_hex (mvid[src_idx], _ascii_form[dest_idx], _ascii_form[dest_idx + 1]);
+				dest_idx += 2;
 			};
 
 			auto hyphen = [this] (size_t &dest_idx) {
@@ -240,7 +237,7 @@ auto TypeMapper::typemap_managed_to_java (const char *typeName, const uint8_t *m
 
 #if defined(DEBUG)
 [[gnu::flatten]]
-auto TypeMapper::typemap_java_to_managed (const char *typeName) noexcept -> const char*
+auto TypeMapper::typemap_java_to_managed (const char *java_type_name, char const** assembly_name, uint32_t *managed_type_token_id) noexcept -> bool
 {
 	Helpers::abort_application ("typemap_java_to_managed not implemented for debug builds yet");
 }
@@ -258,32 +255,65 @@ auto TypeMapper::find_java_to_managed_entry (hash_t name_hash) noexcept -> const
 }
 
 [[gnu::flatten]]
-auto TypeMapper::typemap_java_to_managed (const char *typeName) noexcept -> const char*
+auto TypeMapper::typemap_java_to_managed (const char *java_type_name, char const** assembly_name, uint32_t *managed_type_token_id) noexcept -> bool
 {
-	if (typeName == nullptr) [[unlikely]] {
-		return nullptr;
+	if (java_type_name == nullptr || assembly_name == nullptr || managed_type_token_id == nullptr) [[unlikely]] {
+		if (java_type_name == nullptr) {
+			log_warn (
+				LOG_ASSEMBLY,
+				"typemap: required parameter `{}` not passed to {}",
+				"java_type_name"sv,
+				__PRETTY_FUNCTION__
+			);
+		}
+
+		if (assembly_name == nullptr) {
+			log_warn (
+				LOG_ASSEMBLY,
+				"typemap: required parameter `{}` not passed to {}",
+				"assembly_name"sv,
+				__PRETTY_FUNCTION__
+			);
+		}
+
+		if (managed_type_token_id == nullptr) {
+			log_warn (
+				LOG_ASSEMBLY,
+				"typemap: required parameter `{}` not passed to {}",
+				"managed_type_token_id"sv,
+				__PRETTY_FUNCTION__
+			);
+		}
+
+		return false;
 	}
 
-	hash_t name_hash = xxhash::hash (typeName, strlen (typeName));
+	hash_t name_hash = xxhash::hash (java_type_name, strlen (java_type_name));
 	TypeMapJava const* java_entry = find_java_to_managed_entry (name_hash);
 	if (java_entry == nullptr) {
 		log_info (
 			LOG_ASSEMBLY,
 			"typemap: unable to find mapping to a managed type from Java type '{}' (hash {:x})",
-			optional_string (typeName),
+			optional_string (java_type_name),
 			name_hash
 		);
 
-		return nullptr;
+		return false;
 	}
 
+	TypeMapModule const &module = managed_to_java_map[java_entry->module_index];
+	*assembly_name = managed_assembly_names[module.assembly_name_index];
+	*managed_type_token_id = java_entry->managed_type_token_id;
+
 	log_debug (
 		LOG_ASSEMBLY,
-		"Java type '{}' corresponds to managed type '{}' ({:p}",
-		optional_string (typeName),
+		"Java type '{}' corresponds to managed type '{}' (token 0x{:x} in assembly '{}')",
+		optional_string (java_type_name),
 		optional_string (managed_type_names[java_entry->managed_type_name_index]),
-		reinterpret_cast<const void*>(managed_type_names[java_entry->managed_type_name_index])
+		*managed_type_token_id,
+		optional_string (*assembly_name)
 	);
-	return managed_type_names[java_entry->managed_type_name_index];
+
+	return true;
 }
 #endif // ndef DEBUG

src/native/clr/include/host/typemap.hh

@@ -11,7 +11,7 @@ namespace xamarin::android {
 	{
 	public:
 		static auto typemap_managed_to_java (const char *typeName, const uint8_t *mvid) noexcept -> const char*;
-		static auto typemap_java_to_managed (const char *typeName) noexcept -> const char*;
+		static auto typemap_java_to_managed (const char *java_type_name, char const** assembly_name, uint32_t *managed_type_doken_id) noexcept -> bool;
 
 	private:
 #if defined(RELEASE)

src/native/clr/include/runtime-base/internal-pinvokes.hh

@@ -9,7 +9,7 @@ void _monodroid_gref_log (const char *message) noexcept;
 int _monodroid_gref_log_new (jobject curHandle, char curType, jobject newHandle, char newType, const char *threadName, int threadId, const char *from, int from_writable) noexcept;
 void _monodroid_gref_log_delete (jobject handle, char type, const char *threadName, int threadId, const char *from, int from_writable) noexcept;
 const char* clr_typemap_managed_to_java (const char *typeName, const uint8_t *mvid) noexcept;
-const char* clr_typemap_java_to_managed (const char *typeName) noexcept;
+bool clr_typemap_java_to_managed (const char *java_type_name, char const** assembly_name, uint32_t *managed_type_token_id) noexcept;
 void monodroid_log (xamarin::android::LogLevel level, LogCategories category, const char *message) noexcept;
 char* monodroid_TypeManager_get_java_class_name (jclass klass) noexcept;
 void monodroid_free (void *ptr) noexcept;

src/native/clr/include/runtime-base/util.hh

@@ -41,12 +41,25 @@ namespace xamarin::android {
 
 	class Util
 	{
+		static constexpr inline std::array<char, 16> hex_map {
+			'0', '1', '2', '3', '4', '5', '6', '7',
+			'8', '9', 'a', 'b', 'c', 'd', 'e', 'f',
+		};
+
 	public:
 		static int create_directory (const char *pathname, mode_t mode);
 		static void create_public_directory (std::string_view const& dir);
 		static auto monodroid_fopen (std::string_view const& filename, std::string_view const& mode) noexcept -> FILE*;
 		static void set_world_accessable (std::string_view const& path);
 
+		// Puts higher half of the `value` byte as a hexadecimal character in `high_half` and
+		// the lower half in `low_half`
+		static void to_hex (uint8_t value, char &high_half, char &low_half) noexcept
+		{
+			high_half = hex_map[(value & 0xf0) >> 4];
+			low_half = hex_map[value & 0x0f];
+		}
+
 		static auto should_log (LogCategories category) noexcept -> bool
 		{
 			return (log_categories & category) != 0;

src/native/clr/include/xamarin-app.hh

@@ -93,6 +93,7 @@ struct TypeMapJava
 {
 	uint32_t  module_index;
 	uint32_t  managed_type_name_index;
+	uint32_t  managed_type_token_id;
 	uint32_t  java_name_index;
 };
 #endif