[CoreCLR] Compressed assemblies code producess less relocs

Instead of separate per-assembly buffers, there's now a single buffer
and assembly descriptors use offsets into this buffer to store data.
This removes N + 1 relocs where N is the number of assemblies in the app.
The extra removed relocation is for the pointer which used to point to
the descriptors array, which is now made public.

MonoVM runtime not yet updated.

Author: grendello

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

@@ -13,24 +13,16 @@ namespace Xamarin.Android.Tasks
 	partial class CompressedAssembliesNativeAssemblyGenerator : LlvmIrComposer
 	{
 		const string DescriptorsArraySymbolName = "compressed_assembly_descriptors";
-		const string CompressedAssembliesSymbolName = "compressed_assemblies";
-
-		sealed class CompressedAssemblyDescriptorContextDataProvider : NativeAssemblerStructContextDataProvider
-		{
-			public override string? GetPointedToSymbolName (object data, string fieldName)
-			{
-				if (String.Compare ("data", fieldName, StringComparison.Ordinal) != 0) {
-					return null;
-				}
-
-				var descriptor = EnsureType<CompressedAssemblyDescriptor> (data);
-				return descriptor.BufferSymbolName;
-			}
-		}
-
-		// Order of fields and their type must correspond *exactly* to that in
-		// src/monodroid/jni/xamarin-app.hh CompressedAssemblyDescriptor structure
-		[NativeAssemblerStructContextDataProvider (typeof (CompressedAssemblyDescriptorContextDataProvider))]
+		const string CompressedAssemblyCountSymbolName = "compressed_assembly_count";
+		const string UncompressedAssembliesBufferSymbolName = "uncompressed_assemblies_data_buffer";
+		const string UncompressedAssembliesBufferSizeSymbolName = "uncompressed_assemblies_data_size";
+
+		// Order of fields and their type must correspond *exactly* to that in:
+		//
+		// src/native/mono/xamarin-app-stub/xamarin-app.hh CompressedAssemblyDescriptor structure
+		// src/native/clr/include/xamarin-app.hh CompressedAssemblyDescriptor structure
+		//
+		//[NativeAssemblerStructContextDataProvider (typeof (CompressedAssemblyDescriptorContextDataProvider))]
 		sealed class CompressedAssemblyDescriptor
 		{
 			[NativeAssembler (Ignore = true)]
@@ -44,38 +36,11 @@ sealed class CompressedAssemblyDescriptor
 
 			public uint   uncompressed_file_size;
 			public bool   loaded;
-
-			[NativeAssembler (UsesDataProvider = true), NativePointer (PointsToSymbol = "")]
-			public byte data;
-		};
-
-		sealed class CompressedAssembliesContextDataProvider : NativeAssemblerStructContextDataProvider
-		{
-			public override ulong GetBufferSize (object data, string fieldName)
-			{
-				if (String.Compare ("descriptors", fieldName, StringComparison.Ordinal) != 0) {
-					return 0;
-				}
-
-				var cas = EnsureType<CompressedAssemblies> (data);
-				return cas.count;
-			}
-		}
-
-		// Order of fields and their type must correspond *exactly* to that in
-		// src/monodroid/jni/xamarin-app.hh CompressedAssemblies structure
-		[NativeAssemblerStructContextDataProvider (typeof (CompressedAssembliesContextDataProvider))]
-		sealed class CompressedAssemblies
-		{
-			public uint count;
-
-			[NativeAssembler (UsesDataProvider = true), NativePointer (PointsToSymbol = DescriptorsArraySymbolName)]
-			public CompressedAssemblyDescriptor descriptors;
+			public uint   buffer_offset;
 		};
 
 		IDictionary<AndroidTargetArch, Dictionary<string, CompressedAssemblyInfo>>? archAssemblies;
 		StructureInfo compressedAssemblyDescriptorStructureInfo;
-		StructureInfo compressedAssembliesStructureInfo;
 		Dictionary<AndroidTargetArch, List<StructureInstance<CompressedAssemblyDescriptor>>> archData = new Dictionary<AndroidTargetArch, List<StructureInstance<CompressedAssemblyDescriptor>>> ();
 
 		public CompressedAssembliesNativeAssemblyGenerator (TaskLoggingHelper log, IDictionary<AndroidTargetArch, Dictionary<string, CompressedAssemblyInfo>>? archAssemblies)
@@ -95,8 +60,10 @@ void InitCompressedAssemblies (out List<LlvmIrGlobalVariable>? compressedAssembl
 				return;
 			}
 
-			buffers = new List<LlvmIrGlobalVariable> ();
+			buffers = new ();
 			foreach (var kvpArch in archAssemblies) {
+				uint bufferSize = 0;
+
 				foreach (var kvp in kvpArch.Value) {
 					CompressedAssemblyInfo info = kvp.Value;
 
@@ -105,25 +72,30 @@ void InitCompressedAssemblies (out List<LlvmIrGlobalVariable>? compressedAssembl
 						archData.Add (info.TargetArch, descriptors);
 					}
 
-					string bufferName = $"__compressedAssemblyData_{info.DescriptorIndex}";
 					var descriptor = new CompressedAssemblyDescriptor {
 						Index = info.DescriptorIndex,
-						BufferSymbolName = bufferName,
 						AssemblyName = info.AssemblyName,
 						uncompressed_file_size = info.FileSize,
 						loaded = false,
-						data = 0
+						buffer_offset = bufferSize,
 					};
-
+					bufferSize += info.FileSize;
 					descriptors.Add (new StructureInstance<CompressedAssemblyDescriptor> (compressedAssemblyDescriptorStructureInfo, descriptor));
-
-					var buffer = new LlvmIrGlobalVariable (typeof(List<byte>), descriptor.BufferSymbolName, LlvmIrVariableOptions.LocalWritable) {
-						ArrayItemCount = descriptor.uncompressed_file_size,
-						TargetArch = info.TargetArch,
-						ZeroInitializeArray = true,
-					};
-					buffers.Add (buffer);
 				}
+
+				var variable = new LlvmIrGlobalVariable (typeof(uint), UncompressedAssembliesBufferSizeSymbolName) {
+					Options = LlvmIrVariableOptions.GlobalConstant,
+					TargetArch = kvpArch.Key,
+					Value = bufferSize,
+				};
+				buffers.Add (variable);
+
+				variable = new LlvmIrGlobalVariable (typeof(List<byte>), UncompressedAssembliesBufferSymbolName, LlvmIrVariableOptions.GlobalWritable) {
+					ArrayItemCount = bufferSize,
+					TargetArch = kvpArch.Key,
+					ZeroInitializeArray = true,
+				};
+				buffers.Add (variable);
 			}
 
 			compressedAssemblies = new List<LlvmIrGlobalVariable> ();
@@ -132,16 +104,16 @@ void InitCompressedAssemblies (out List<LlvmIrGlobalVariable>? compressedAssembl
 				List<StructureInstance<CompressedAssemblyDescriptor>> descriptors = kvp.Value;
 				descriptors.Sort ((StructureInstance<CompressedAssemblyDescriptor> a, StructureInstance<CompressedAssemblyDescriptor> b) => a.Instance.Index.CompareTo (b.Instance.Index));
 
-				var variable = new LlvmIrGlobalVariable (typeof(StructureInstance<CompressedAssemblies>), CompressedAssembliesSymbolName) {
-					Options = LlvmIrVariableOptions.GlobalWritable,
+				var variable = new LlvmIrGlobalVariable (typeof(uint), CompressedAssemblyCountSymbolName) {
+					Options = LlvmIrVariableOptions.GlobalConstant,
 					TargetArch = kvp.Key,
-					Value = new StructureInstance<CompressedAssemblies> (compressedAssembliesStructureInfo, new CompressedAssemblies { count = (uint)descriptors.Count, }),
+					Value = (uint)descriptors.Count,
 				};
 				compressedAssemblies.Add (variable);
 
 				variable = new LlvmIrGlobalVariable (typeof(List<StructureInstance<CompressedAssemblyDescriptor>>), DescriptorsArraySymbolName) {
 					GetArrayItemCommentCallback = GetCompressedAssemblyDescriptorsItemComment,
-					Options = LlvmIrVariableOptions.LocalWritable,
+					Options = LlvmIrVariableOptions.GlobalWritable,
 					TargetArch = kvp.Key,
 					Value = descriptors,
 				};
@@ -162,21 +134,17 @@ out List<LlvmIrGlobalVariable>? buffers
 			);
 
 			if (archData.Count == 0) {
-				module.AddGlobalVariable (
-					typeof(StructureInstance<CompressedAssemblies>),
-					CompressedAssembliesSymbolName,
-					new StructureInstance<CompressedAssemblies> (compressedAssembliesStructureInfo, new CompressedAssemblies ()) { IsZeroInitialized = true },
-					LlvmIrVariableOptions.GlobalWritable
-				);
+				var emptyBufferVar = new LlvmIrGlobalVariable (typeof(List<byte>), UncompressedAssembliesBufferSymbolName, LlvmIrVariableOptions.GlobalWritable) {
+					ArrayItemCount = 0,
+					ZeroInitializeArray = true,
+				};
+				module.Add (emptyBufferVar);
 				return;
 			}
 
 			module.Add (compressedAssemblies);
 			module.Add (compressedAssemblyDescriptors);
-
-			module.Add (new LlvmIrGroupDelimiterVariable ());
 			module.Add (buffers);
-			module.Add (new LlvmIrGroupDelimiterVariable ());
 		}
 
 		string? GetCompressedAssemblyDescriptorsItemComment (LlvmIrVariable v, LlvmIrModuleTarget target, ulong index, object? value, object? callerState)
@@ -202,7 +170,6 @@ List<StructureInstance<CompressedAssemblyDescriptor>> GetArchDescriptors (LlvmIr
 		void MapStructures (LlvmIrModule module)
 		{
 			compressedAssemblyDescriptorStructureInfo = module.MapStructure<CompressedAssemblyDescriptor> ();
-			compressedAssembliesStructureInfo = module.MapStructure<CompressedAssemblies> ();
 		}
 	}
 }

src/native/clr/host/assembly-store.cc

@@ -35,10 +35,10 @@ auto AssemblyStore::get_assembly_data (AssemblyStoreSingleAssemblyRuntimeData co
 			internal_timing.start_event (TimingEventKind::AssemblyDecompression);
 		}
 
-		if (compressed_assemblies.descriptors == nullptr) [[unlikely]] {
+		if (compressed_assembly_count == 0) [[unlikely]] {
 			Helpers::abort_application (LOG_ASSEMBLY, "Compressed assembly found but no descriptor defined"sv);
 		}
-		if (header->descriptor_index >= compressed_assemblies.count) [[unlikely]] {
+		if (header->descriptor_index >= compressed_assembly_count) [[unlikely]] {
 			Helpers::abort_application (
 				LOG_ASSEMBLY,
 				std::format (
@@ -48,13 +48,42 @@ auto AssemblyStore::get_assembly_data (AssemblyStoreSingleAssemblyRuntimeData co
 			);
 		}
 
-		CompressedAssemblyDescriptor &cad = compressed_assemblies.descriptors[header->descriptor_index];
+		CompressedAssemblyDescriptor &cad = compressed_assembly_descriptors[header->descriptor_index];
 		assembly_data_size = e.descriptor->data_size - sizeof(CompressedAssemblyHeader);
+
+		if (cad.buffer_offset >= uncompressed_assemblies_data_size) [[unlikely]] {
+			Helpers::abort_application (
+				LOG_ASSEMBLY,
+				std::format (
+					"Invalid compressed assembly buffer offset {}. Must be smaller than {}",
+					cad.buffer_offset,
+					uncompressed_assemblies_data_size
+				)
+			);
+		}
+
+		// This is not a perfect check, since we might be still within the buffer size and yet
+		// have the tail end of this assembly's data overwritten by the next assembly's data, but
+		// that will cause the app to crash when one or the the other assembly is loaded, so it's
+		// OK to accept that risk. The whole situation is very, very unlikely.
+		if (cad.uncompressed_file_size > uncompressed_assemblies_data_size - cad.buffer_offset) [[unlikely]] {
+			Helpers::abort_application (
+				LOG_ASSEMBLY,
+				std::format (
+					"Invalid compressed assembly buffer size {} at offset {}. Must not exceed {}",
+					cad.uncompressed_file_size,
+					cad.buffer_offset,
+					uncompressed_assemblies_data_size - cad.buffer_offset
+				)
+			);
+		}
+
+		uint8_t *data_buffer = uncompressed_assemblies_data_buffer + cad.buffer_offset;
 		if (!cad.loaded) {
 			StartupAwareLock decompress_lock (assembly_decompress_mutex);
 
 			if (cad.loaded) {
-				set_assembly_data_and_size (reinterpret_cast<uint8_t*>(cad.data), cad.uncompressed_file_size, assembly_data, assembly_data_size);
+				set_assembly_data_and_size (data_buffer, cad.uncompressed_file_size, assembly_data, assembly_data_size);
 
 				if (FastTiming::enabled ()) [[unlikely]] {
 					internal_timing.end_event (true /* uses_more_info */);
@@ -67,16 +96,6 @@ auto AssemblyStore::get_assembly_data (AssemblyStoreSingleAssemblyRuntimeData co
 				return {assembly_data, assembly_data_size};
 			}
 
-			if (cad.data == nullptr) [[unlikely]] {
-				Helpers::abort_application (
-					LOG_ASSEMBLY,
-					std::format (
-						"Invalid compressed assembly descriptor at {}: no data"sv,
-						header->descriptor_index
-					)
-				);
-			}
-
 			if (header->uncompressed_length != cad.uncompressed_file_size) {
 				if (header->uncompressed_length > cad.uncompressed_file_size) {
 					Helpers::abort_application (
@@ -95,7 +114,7 @@ auto AssemblyStore::get_assembly_data (AssemblyStoreSingleAssemblyRuntimeData co
 			}
 
 			const char *data_start = pointer_add<const char*>(e.image_data, sizeof(CompressedAssemblyHeader));
-			int ret = LZ4_decompress_safe (data_start, reinterpret_cast<char*>(cad.data), static_cast<int>(assembly_data_size), static_cast<int>(cad.uncompressed_file_size));
+			int ret = LZ4_decompress_safe (data_start, reinterpret_cast<char*>(data_buffer), static_cast<int>(assembly_data_size), static_cast<int>(cad.uncompressed_file_size));
 
 			if (ret < 0) {
 				Helpers::abort_application (
@@ -126,7 +145,7 @@ auto AssemblyStore::get_assembly_data (AssemblyStoreSingleAssemblyRuntimeData co
 			}
 		}
 
-		set_assembly_data_and_size (reinterpret_cast<uint8_t*>(cad.data), cad.uncompressed_file_size, assembly_data, assembly_data_size);
+		set_assembly_data_and_size (reinterpret_cast<uint8_t*>(data_buffer), cad.uncompressed_file_size, assembly_data, assembly_data_size);
 	} else
 #endif // def HAVE_LZ4 && def RELEASE
 	{

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

@@ -131,13 +131,7 @@ struct CompressedAssemblyDescriptor
 {
 	uint32_t   uncompressed_file_size;
 	bool       loaded;
-	uint8_t   *data;
-};
-
-struct CompressedAssemblies
-{
-	uint32_t                      count;
-	CompressedAssemblyDescriptor *descriptors;
+	uint32_t   buffer_offset;
 };
 
 struct XamarinAndroidBundledAssembly
@@ -354,7 +348,10 @@ extern "C" {
 	[[gnu::visibility("default")]] extern const xamarin::android::hash_t java_to_managed_hashes[];
 #endif
 
-	[[gnu::visibility("default")]] extern CompressedAssemblies compressed_assemblies;
+	[[gnu::visibility("default")]] extern uint32_t compressed_assembly_count;
+	[[gnu::visibility("default")]] extern CompressedAssemblyDescriptor compressed_assembly_descriptors[];
+	[[gnu::visibility("default")]] extern uint32_t uncompressed_assemblies_data_size;
+	[[gnu::visibility("default")]] extern uint8_t uncompressed_assemblies_data_buffer[];
 	[[gnu::visibility("default")]] extern const ApplicationConfig application_config;
 	[[gnu::visibility("default")]] extern const char* const app_environment_variables[];
 	[[gnu::visibility("default")]] extern const char* const app_system_properties[];

src/native/clr/xamarin-app-stub/application_dso_stub.cc

@@ -38,10 +38,10 @@ const TypeMapJava java_to_managed_map[] = {};
 const xamarin::android::hash_t java_to_managed_hashes[] = {};
 #endif
 
-CompressedAssemblies compressed_assemblies = {
-	.count = 0,
-	.descriptors = nullptr,
-};
+uint32_t compressed_assembly_count = 0;
+CompressedAssemblyDescriptor compressed_assembly_descriptors[] = {};
+uint32_t uncompressed_assemblies_data_size = 0;
+uint8_t uncompressed_assemblies_data_buffer[] = {};
 
 //
 // Config settings below **must** be valid for Desktop builds as the default `libxamarin-app.{dll,dylib,so}` is used by

src/native/mono/xamarin-app-stub/xamarin-app.hh

@@ -113,6 +113,7 @@ struct CompressedAssemblyDescriptor
 {
 	uint32_t   uncompressed_file_size;
 	bool       loaded;
+	uint32_t   buffer_offset;
 	uint8_t   *data;
 };