More assembly store code

grendello · grendello · commit 35ff9773c3b0 · 2025-08-05T11:04:36.000+02:00
diff --git a/tools/apput/src/AssemblyStore/AssemblyStore.cs b/tools/apput/src/AssemblyStore/AssemblyStore.cs
@@ -67,12 +67,11 @@ static IAspectState DoProbeAspect (Stream storeStream, string? description)
 		}
 
 		uint version = reader.ReadUInt32 ();
-
-		// We currently support version 3. Main store version is kept in the lower 16 bits of the version word
-		uint mainVersion = version & 0xFFFF;
+		var storeVersion = new AssemblyStoreVersion (version);
 		FormatBase? validator = null;
+		Log.Debug ($"AssemblyStore: store format version {storeVersion.MainVersion}");
 
-		switch (mainVersion) {
+		switch (storeVersion.MainVersion) {
 			case 2:
 				validator = new Format_V2 (storeStream, description);
 				break;
@@ -82,7 +81,7 @@ static IAspectState DoProbeAspect (Stream storeStream, string? description)
 				break;
 
 			default:
-				Log.Debug ($"AssemblyStore: unsupported store version: {mainVersion}");
+				Log.Debug ($"AssemblyStore: unsupported store version: {storeVersion.MainVersion}");
 				return new BasicAspectState (false);
 		}
 
diff --git a/tools/apput/src/AssemblyStore/AssemblyStoreAbi.cs b/tools/apput/src/AssemblyStore/AssemblyStoreAbi.cs
@@ -1,10 +1,12 @@
 namespace ApplicationUtility;
 
 // Values correspond to those in `xamarin-app.hh`
-enum AssemblyStoreABI
+enum AssemblyStoreABI : uint
 {
-	Arm64 = 0x00010000,
-	Arm   = 0x00020000,
-	X86   = 0x00030000,
-	X64   = 0x00040000,
+	Unknown = 0x00000000,
+
+	Arm64   = 0x00010000,
+	Arm     = 0x00020000,
+	X86     = 0x00030000,
+	X64     = 0x00040000,
 }
diff --git a/tools/apput/src/AssemblyStore/AssemblyStoreAspectState.cs b/tools/apput/src/AssemblyStore/AssemblyStoreAspectState.cs
@@ -5,7 +5,7 @@ namespace ApplicationUtility;
 class AssemblyStoreAspectState : BasicAspectState
 {
 	public AssemblyStoreHeader Header { get; }
-	public AssemblyStoreIndex Index { get; }
+	public FormatBase Format { get; }
 
 	public AssemblyStoreAspectState (bool success)
 		: base (success)
diff --git a/tools/apput/src/AssemblyStore/AssemblyStoreAssemblyDescriptor.cs b/tools/apput/src/AssemblyStore/AssemblyStoreAssemblyDescriptor.cs
@@ -0,0 +1,4 @@
+namespace ApplicationUtility;
+
+abstract class AssemblyStoreAssemblyDescriptor
+{}
diff --git a/tools/apput/src/AssemblyStore/AssemblyStoreAssemblyDescriptorV2.cs b/tools/apput/src/AssemblyStore/AssemblyStoreAssemblyDescriptorV2.cs
@@ -0,0 +1,12 @@
+namespace ApplicationUtility;
+
+class AssemblyStoreAssemblyDescriptorV2 : AssemblyStoreAssemblyDescriptor
+{
+	public uint MappingIndex     { get; internal set; }
+	public uint DataOffset       { get; internal set; }
+	public uint DataSize         { get; internal set; }
+	public uint DebugDataOffset  { get; internal set; }
+	public uint DebugDataSize    { get; internal set; }
+	public uint ConfigDataOffset { get; internal set; }
+	public uint ConfigDataSize   { get; internal set; }
+}
diff --git a/tools/apput/src/AssemblyStore/AssemblyStoreAssemblyDescriptorV3.cs b/tools/apput/src/AssemblyStore/AssemblyStoreAssemblyDescriptorV3.cs
@@ -0,0 +1,5 @@
+namespace ApplicationUtility;
+
+// Format is identical to V2, class exists merely for versioning consistency
+class AssemblyStoreAssemblyDescriptorV3 : AssemblyStoreAssemblyDescriptorV2
+{}
diff --git a/tools/apput/src/AssemblyStore/AssemblyStoreHeader.cs b/tools/apput/src/AssemblyStore/AssemblyStoreHeader.cs
@@ -13,8 +13,13 @@ namespace ApplicationUtility;
 /// </summary>
 class AssemblyStoreHeader
 {
-	public AssemblyStoreVersion Version { get; protected set; }
-	public uint? EntryCount { get; protected set; }
-	public uint? IndexEntryCount { get; protected set; }
-	public uint? IndexSize { get; protected set; }
+	public AssemblyStoreVersion Version { get; }
+	public uint? EntryCount { get; internal set; }
+	public uint? IndexEntryCount { get; internal set; }
+	public uint? IndexSize { get; internal set; }
+
+	public AssemblyStoreHeader (AssemblyStoreVersion version)
+	{
+		Version = version;
+	}
 }
diff --git a/tools/apput/src/AssemblyStore/AssemblyStoreIndex.cs b/tools/apput/src/AssemblyStore/AssemblyStoreIndex.cs
diff --git a/tools/apput/src/AssemblyStore/AssemblyStoreIndexEntryV3.cs b/tools/apput/src/AssemblyStore/AssemblyStoreIndexEntryV3.cs
@@ -0,0 +1,6 @@
+namespace ApplicationUtility;
+
+class AssemblyStoreIndexEntryV3
+{
+
+}
diff --git a/tools/apput/src/AssemblyStore/AssemblyStoreVersion.cs b/tools/apput/src/AssemblyStore/AssemblyStoreVersion.cs
@@ -1,15 +1,36 @@
+using System;
+
 namespace ApplicationUtility;
 
 class AssemblyStoreVersion
 {
+	public uint RawVersion      { get; }
 	public uint MainVersion     { get; }
 	public AssemblyStoreABI ABI { get; }
 	public bool Is64Bit         { get; }
 
-	internal AssemblyStoreVersion (uint mainVersion, AssemblyStoreABI abi, bool is64Bit)
+	internal AssemblyStoreVersion (uint rawVersion)
 	{
-		MainVersion = mainVersion;
-		ABI = abi;
-		Is64Bit = is64Bit;
+		RawVersion = rawVersion;
+		Log.Debug ($"AssemblyStoreVersion: raw version is 0x{rawVersion:x}");
+
+		// Main store version is kept in the lower 16 bits of the version word
+		MainVersion = rawVersion & 0xFFFF;
+		Log.Debug ($"AssemblyStoreVersion: main version is {MainVersion}");
+
+		// ABI is kept in the higher 15 bits of the version word
+		uint abi = rawVersion & 0x7FFF0000;
+		Log.Debug ($"AssemblyStoreVersion: raw ABI value is 0x{abi:x}");
+
+		if (Enum.IsDefined (typeof(AssemblyStoreABI), abi)) {
+			ABI = (AssemblyStoreABI)abi;
+		} else {
+			ABI = AssemblyStoreABI.Unknown;
+		}
+		Log.Debug ($"AssemblyStoreVersion: ABI is {ABI}");
+
+		// 64-bit flag is the leftmost bit in the word
+		Is64Bit = (rawVersion & 0x80000000) == 0x80000000;
+		Log.Debug ($"AssemblyStoreVersion: is store 64-bit? {Is64Bit}");
 	}
 }
diff --git a/tools/apput/src/AssemblyStore/FormatBase.cs b/tools/apput/src/AssemblyStore/FormatBase.cs
@@ -1,17 +1,170 @@
+using System;
+using System.Collections.Generic;
 using System.IO;
+using System.Text;
 
 namespace ApplicationUtility;
 
+/// <summary>
+/// `FormatBase` class is the base class for all format-specific validators/readers. It will
+/// always implement reading the current (i.e. the `main` branch) assembly store format, with
+/// subclasses required to handle differences. Subclasses are expected to override the virtual
+/// `Read*` methods and completely handle reading of the respective structure, without calling
+/// up to the base class.
+/// </summary>
 abstract class FormatBase
 {
 	protected Stream StoreStream { get; }
 	protected string? Description { get; }
 
+	public AssemblyStoreHeader? Header { get; protected set; }
+	public List<AssemblyStoreAssemblyDescriptor>? Descriptors { get; protected set; }
+
 	protected FormatBase (Stream storeStream, string? description)
 	{
 		this.StoreStream = storeStream;
 		this.Description = description;
 	}
 
-	public abstract IAspectState Validate ();
+	public void Read ()
+	{
+		using var reader = new BinaryReader (StoreStream, Encoding.UTF8, leaveOpen: true);
+
+		// They can be `null` if `Validate` wasn't called for some reason.
+		if (Header == null && ReadHeader (reader, out AssemblyStoreHeader? header)) {
+			Header = header;
+		}
+
+		if (Descriptors == null && ReadAssemblyDescriptors (reader, out List<AssemblyStoreAssemblyDescriptor>? descriptors)) {
+			Descriptors = descriptors;
+		}
+	}
+
+	public IAspectState Validate ()
+	{
+		using var reader = new BinaryReader (StoreStream, Encoding.UTF8, leaveOpen: true);
+
+		if (ReadHeader (reader, out AssemblyStoreHeader? header)) {
+			Header = header;
+		}
+
+		if (ReadAssemblyDescriptors (reader, out List<AssemblyStoreAssemblyDescriptor>? descriptors)) {
+			Descriptors = descriptors;
+		}
+
+		return ValidateInner ();
+	}
+
+	protected abstract IAspectState ValidateInner ();
+
+	protected virtual bool ReadHeader (BinaryReader reader, out AssemblyStoreHeader? header)
+	{
+		header = null;
+		try {
+			header = DoReadHeader (reader);
+			Log.Debug ("AssemblyStore/FormatBase: read store header.");
+			Log.Debug ($"  Raw version: 0x{header.Version.RawVersion:x}");
+			Log.Debug ($"  Main version: {header.Version.MainVersion}");
+			Log.Debug ($"  ABI: {header.Version.ABI}");
+			Log.Debug ($"  64-bit: {header.Version.Is64Bit}");
+			Log.Debug ($"  Entry count: {header.EntryCount}");
+			Log.Debug ($"  Index entry count: {header.IndexEntryCount}");
+			Log.Debug ($"  Index size (bytes): {header.IndexSize}");
+		} catch (Exception ex) {
+			Log.Debug ($"AssemblyStore/FormatBase: Failed to read assembly store header. Exception thrown:", ex);
+			return false;
+		}
+
+		return header != null;
+	}
+
+	AssemblyStoreHeader? DoReadHeader (BinaryReader reader)
+	{
+		StoreStream.Seek (0, SeekOrigin.Begin);
+
+		// From src/native/clr/include/xamarin-app.hh
+		//
+		// HEADER (fixed size)
+		//  [MAGIC]              uint; value: 0x41424158
+		//  [FORMAT_VERSION]     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
+		//
+
+		// By the time we are called, the magic number has been verified. We simply ignore it.
+		uint uintValue = reader.ReadUInt32 (); // magic
+		uintValue = reader.ReadUInt32 (); // format version
+		var storeVersion = new AssemblyStoreVersion (uintValue);
+
+		uint entryCount = reader.ReadUInt32 ();
+		uint indexEntryCount  = reader.ReadUInt32 ();
+		uint indexSize = reader.ReadUInt32 ();
+
+		return new AssemblyStoreHeader (storeVersion) {
+			EntryCount = entryCount,
+			IndexEntryCount = indexEntryCount,
+			IndexSize = indexSize,
+		};
+	}
+
+	protected virtual bool ReadAssemblyDescriptors (BinaryReader reader, out List<AssemblyStoreAssemblyDescriptor>? descriptors)
+	{
+		descriptors = null;
+		try {
+			descriptors = DoReadAssemblyDescriptors (reader);
+		} catch (Exception ex) {
+			Log.Debug ($"AssemblyStore/FormatBase: failed to read assembly descriptors. Exception thrown:", ex);
+			return false;
+		}
+
+		return descriptors != null && descriptors.Count > 0;
+	}
+
+	List<AssemblyStoreAssemblyDescriptor>? DoReadAssemblyDescriptors (BinaryReader reader)
+	{
+		if (Header == null) {
+			Log.Debug ($"AssemblyStore/FormatBase: unable to read descriptors, header hasn't been read.");
+			return null;
+		}
+
+		if (Header.EntryCount == null) {
+			Log.Debug ($"AssemblyStore/FormatBase: unable to read descriptors, header entry count hasn't been read.");
+			return null;
+		}
+
+		ulong indexEntrySize = Header.Version.Is64Bit ? Format_V3.IndexEntrySize64 : Format_V3.IndexEntrySize32;
+		ulong descriptorsOffset = (ulong)(Format_V3.HeaderSize + ((Header.EntryCount * 2) * indexEntrySize));
+
+		if (descriptorsOffset > Int64.MaxValue) {
+			Log.Debug ($"AssemblyStore/FormatBase: descriptors offset exceeds the maximum value handled by System.IO.Stream");
+			return null;
+		}
+
+		reader.BaseStream.Seek ((long)descriptorsOffset, SeekOrigin.Begin);
+		var descriptors = new List<AssemblyStoreAssemblyDescriptor> ();
+
+		for (uint i = 0; i < Header.EntryCount; i++) {
+			uint mappingIndex = reader.ReadUInt32 ();
+			uint dataOffset = reader.ReadUInt32 ();
+			uint dataSize = reader.ReadUInt32 ();
+			uint debugDataOffset = reader.ReadUInt32 ();
+			uint debugDataSize = reader.ReadUInt32 ();
+			uint configDataOffset = reader.ReadUInt32 ();
+			uint configDataSize = reader.ReadUInt32 ();
+
+			var desc = new AssemblyStoreAssemblyDescriptorV3 {
+				MappingIndex = mappingIndex,
+				DataOffset = dataOffset,
+				DataSize = dataSize,
+				DebugDataOffset = debugDataOffset,
+				DebugDataSize = debugDataSize,
+				ConfigDataOffset = configDataOffset,
+				ConfigDataSize = configDataSize,
+			};
+			descriptors.Add (desc);
+		}
+
+		return descriptors;
+	}
 }
diff --git a/tools/apput/src/AssemblyStore/Format_V2.cs b/tools/apput/src/AssemblyStore/Format_V2.cs
@@ -9,7 +9,7 @@ public Format_V2 (Stream storeStream, string? description)
 		: base (storeStream, description)
 	{}
 
-	public override IAspectState Validate ()
+	protected override IAspectState ValidateInner ()
 	{
 		throw new NotImplementedException ();
 	}
diff --git a/tools/apput/src/AssemblyStore/Format_V3.cs b/tools/apput/src/AssemblyStore/Format_V3.cs
@@ -4,14 +4,34 @@ namespace ApplicationUtility;
 
 class Format_V3 : FormatBase
 {
+	public const uint HeaderSize = 5 * sizeof(uint);
+	public const uint IndexEntrySize32 = sizeof(uint) + sizeof(uint) + sizeof(byte);
+	public const uint IndexEntrySize64 = sizeof(ulong) + sizeof(uint) + sizeof(byte);
+	public const uint AssemblyDescriptorSize = 7 * sizeof(uint);
+
 	public Format_V3 (Stream storeStream, string? description)
 		: base (storeStream, description)
 	{}
 
-	public override IAspectState Validate ()
+	protected override IAspectState ValidateInner ()
 	{
-		// TODO: validate that the store has correct format and populate the state below accordingly
-		//       to save time later.
+		Log.Debug ("AssemblyStore/Format_V3: validating store format.");
+		if (Header == null || Header.EntryCount == null || Header.IndexEntryCount == null || Header.IndexSize == null) {
+			return ValidationFailed ($"AssemblyStore/Format_V3: invalid header data.");
+		}
+
+		if (Descriptors == null || Descriptors.Count == 0) {
+			return ValidationFailed ($"AssemblyStore/Format_V3: no descriptors read.");
+		}
+
+		// TODO: validate stream size
+		// TODO: populate
 		return new AssemblyStoreAspectState (true);
+
+		BasicAspectState ValidationFailed (string message)
+		{
+			Log.Debug (message);
+			return new BasicAspectState (false);
+		}
 	}
 }
diff --git a/tools/apput/src/Package/ApplicationPackage.cs b/tools/apput/src/Package/ApplicationPackage.cs
@@ -181,7 +181,7 @@ void TryLoadAssemblyStores ()
 
 			return (AssemblyStore)AssemblyStore.LoadAspect (storeStream, state, fullStorePath);
 		} catch (Exception ex) {
-			Log.Debug ($"Failed to load assembly store '{storePath}'", ex);
+			Log.Debug ($"Failed to load assembly store '{storePath}'. Exception thrown:", ex);
 			return null;
 		}
 	}

Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@ namespace ApplicationUtility;`
`5`	`5`	`class AssemblyStoreAspectState : BasicAspectState`
`6`	`6`	`{`
`7`	`7`	`public AssemblyStoreHeader Header { get; }`
`8`		`- public AssemblyStoreIndex Index { get; }`
	`8`	`+ public FormatBase Format { get; }`
`9`	`9`
`10`	`10`	`public AssemblyStoreAspectState (bool success)`
`11`	`11`	`: base (success)`
-Original file line number
+Diff line change
@@ @@ -0,0 +1,4 @@ @@
 +namespace ApplicationUtility;
++
 +abstract class AssemblyStoreAssemblyDescriptor
 +{}