Code changes for melonDS sized access.

Author: SuuperW

src/BizHawk.Emulation.Cores/Waterbox/LibWaterboxCore.cs

@@ -92,6 +92,10 @@ public enum MemoryDomainFlags : long
 			/// If true, Data is a function to call and not a pointer
 			/// </summary>
 			FunctionHook = 1024,
+			/// <summary>
+			/// If true, Data is a list of functions; function(s) may be null
+			/// </summary>
+			SizedFunctionHooks = 2048,
 		}
 
 		[StructLayout(LayoutKind.Sequential)]

src/BizHawk.Emulation.Cores/Waterbox/WaterboxMemoryDomain.cs

@@ -18,9 +18,12 @@ public abstract class WaterboxMemoryDomain : MemoryDomain
 
 		public static WaterboxMemoryDomain Create(MemoryArea m, WaterboxHost monitor)
 		{
-			return m.Flags.HasFlag(MemoryDomainFlags.FunctionHook)
-				? new WaterboxMemoryDomainFunc(m, monitor)
-				: new WaterboxMemoryDomainPointer(m, monitor);
+			if (m.Flags.HasFlag(MemoryDomainFlags.FunctionHook))
+				return new WaterboxMemoryDomainFunc(m, monitor);
+			else if (m.Flags.HasFlag(MemoryDomainFlags.SizedFunctionHooks))
+				return new WaterboxMemoryDomainSizedFuncs(m, monitor);
+			else
+				return new WaterboxMemoryDomainPointer(m, monitor);
 		}
 
 		protected WaterboxMemoryDomain(MemoryArea m, IMonitor monitor)
@@ -149,6 +152,33 @@ public static MemoryDomainAccessStub Create(IntPtr p, WaterboxHost host)
 				new StubResolver(p), host, CallingConventionAdapters.MakeWaterboxDepartureOnly(host));
 		}
 	}
+	public abstract class MemoryDomainSizedAccessStub
+	{
+		[BizImport(CallingConvention.Cdecl)]
+		public abstract void Access(IntPtr buffer, long address, long count);
+
+		private class StubResolver : IImportResolver
+		{
+			private readonly IntPtr _p;
+
+			public StubResolver(IntPtr p)
+			{
+				_p = p;
+			}
+
+			public IntPtr GetProcAddrOrThrow(string entryPoint) => _p;
+			public IntPtr GetProcAddrOrZero(string entryPoint) => _p;
+		}
+
+		public static MemoryDomainSizedAccessStub Create(IntPtr p, WaterboxHost host)
+		{
+			return BizInvoker.GetInvoker<MemoryDomainSizedAccessStub>(
+				new StubResolver(p),
+				host,
+				CallingConventionAdapters.MakeWaterboxDepartureOnly(host));
+		}
+	}
+
 
 	public unsafe class WaterboxMemoryDomainFunc : WaterboxMemoryDomain
 	{
@@ -202,7 +232,7 @@ public override void BulkPeekByte(Range<long> addresses, byte[] values)
 
 			if (start < (ulong)Size && (start + count) <= (ulong)Size)
 			{
-				fixed(byte* p = values)
+				fixed (byte* p = values)
 					_access.Access((IntPtr)p, (long)start, (long)count, false);
 			}
 			else
@@ -211,4 +241,145 @@ public override void BulkPeekByte(Range<long> addresses, byte[] values)
 			}
 		}
 	}
+
+	/// <summary>
+	/// A memory domain for things like a system bus, where the size of the read/write may affect the result.
+	/// Endianness is ignored; we are writing numbers not multi-byte representations of numbers.
+	/// </summary>
+	public unsafe class WaterboxMemoryDomainSizedFuncs : WaterboxMemoryDomain
+	{
+		private readonly MemoryDomainSizedAccessStub _read8 = null;
+		private readonly MemoryDomainSizedAccessStub _write8 = null;
+		private readonly MemoryDomainSizedAccessStub _read16 = null;
+		private readonly MemoryDomainSizedAccessStub _write16 = null;
+		private readonly MemoryDomainSizedAccessStub _read32 = null;
+		private readonly MemoryDomainSizedAccessStub _write32 = null;
+
+		private string AddressRangeError => string.Format("Address must be in the range [0, 0x{0:x}]", Size - 1);
+
+		internal WaterboxMemoryDomainSizedFuncs(MemoryArea m, WaterboxHost monitor)
+			: base(m, monitor)
+		{
+			if (!m.Flags.HasFlag(MemoryDomainFlags.SizedFunctionHooks))
+				throw new InvalidOperationException();
+
+			using (monitor.EnterExit())
+			{
+				IntPtr* functionPointers = (IntPtr*)m.Data;
+				for (int i = 0; i < 6; i++)
+				{
+					if (functionPointers[i] == IntPtr.Zero) throw new Exception("All access functions must have implementations.");
+				}
+				_read8 = MemoryDomainSizedAccessStub.Create(functionPointers[0], monitor);
+				_write8 = MemoryDomainSizedAccessStub.Create(functionPointers[1], monitor);
+
+				_read16 = MemoryDomainSizedAccessStub.Create(functionPointers[2], monitor);
+				_write16 = MemoryDomainSizedAccessStub.Create(functionPointers[3], monitor);
+
+				_read32 = MemoryDomainSizedAccessStub.Create(functionPointers[4], monitor);
+				_write32 = MemoryDomainSizedAccessStub.Create(functionPointers[5], monitor);
+			}
+		}
+
+		public override byte PeekByte(long addr)
+		{
+			if ((ulong)addr >= (ulong)Size || addr < 0) throw new ArgumentOutOfRangeException(nameof(addr), message: AddressRangeError);
+
+			byte ret = 0;
+			_read8.Access((IntPtr)(&ret), addr, 1);
+			return ret;
+		}
+
+		public override void PokeByte(long addr, byte val)
+		{
+			if ((ulong)addr >= (ulong)Size || addr < 0) throw new ArgumentOutOfRangeException(nameof(addr), message: AddressRangeError);
+
+			_write8.Access((IntPtr)(&val), addr, 1);
+		}
+
+		public override ushort PeekUshort(long addr, bool bigEndian)
+		{
+			if ((ulong)addr + 1 >= (ulong)Size || addr < 0) throw new ArgumentOutOfRangeException(nameof(addr), message: AddressRangeError);
+
+			ushort ret = 0;
+			_read16.Access((IntPtr)(&ret), addr, 1);
+			return ret;
+		}
+
+		public override void PokeUshort(long addr, ushort val, bool bigEndian)
+		{
+			if ((ulong)addr + 1 >= (ulong)Size || addr < 0) throw new ArgumentOutOfRangeException(nameof(addr), message: AddressRangeError);
+
+			_write16.Access((IntPtr)(&val), addr, 1);
+		}
+
+		public override uint PeekUint(long addr, bool bigEndian)
+		{
+			if ((ulong)addr + 3 >= (ulong)Size || addr < 0) throw new ArgumentOutOfRangeException(nameof(addr), message: AddressRangeError);
+
+			uint ret = 0;
+			_read32.Access((IntPtr)(&ret), addr, 1);
+			return ret;
+		}
+
+		public override void PokeUint(long addr, uint val, bool bigEndian)
+		{
+			if ((ulong)addr + 3 >= (ulong)Size || addr < 0) throw new ArgumentOutOfRangeException(nameof(addr), message: AddressRangeError);
+
+			_write32.Access((IntPtr)(&val), addr, 1);
+		}
+
+		public override void BulkPeekByte(Range<long> addresses, byte[] values)
+		{
+			if ((ulong)addresses.Start + addresses.Count() > (ulong)Size || addresses.Start < 0) throw new ArgumentOutOfRangeException(nameof(addresses), message: AddressRangeError);
+			if (addresses.Count() > (uint)values.Length) throw new ArgumentException(message: $"Length of {nameof(values)} must be at least {nameof(addresses)} count.", nameof(values));
+
+			fixed (byte* p = values)
+				_read8.Access((IntPtr)p, addresses.Start, (long)addresses.Count());
+		}
+
+		public void BulkPokeByte(long addr, Span<byte> values)
+		{
+			if ((ulong)addr + (ulong)values.Length > (ulong)Size || addr < 0) throw new ArgumentOutOfRangeException(nameof(addr), message: AddressRangeError);
+
+			fixed (byte* p = values)
+				_write8.Access((IntPtr)p, addr, values.Length);
+		}
+
+		public override void BulkPeekUshort(Range<long> addresses, bool bigEndian, ushort[] values)
+		{
+			if ((ulong)addresses.Start + addresses.Count() > (ulong)Size || addresses.Start < 0) throw new ArgumentOutOfRangeException(nameof(addresses), message: AddressRangeError);
+			if (addresses.Count() > (uint)values.Length * sizeof(ushort)) throw new ArgumentException(message: $"Length of {nameof(values)} must be at least {nameof(addresses)} count.", nameof(values));
+			if ((addresses.Count() & 1) != 0) throw new ArgumentOutOfRangeException(nameof(addresses), "Requested byte count must be divisible by 2."); // TODO: The caller should be specifying the count of ushorts, not the count of bytes!
+
+			fixed (ushort* p = values)
+				_read16.Access((IntPtr)p, addresses.Start, (long)addresses.Count() / sizeof(ushort));
+		}
+
+		public void BulkPokeUshort(long addr, Span<ushort> values)
+		{
+			if ((ulong)addr + (ulong)values.Length * sizeof(ushort) > (ulong)Size || addr < 0) throw new ArgumentOutOfRangeException(nameof(addr), message: AddressRangeError);
+
+			fixed (ushort* p = values)
+				_write16.Access((IntPtr)p, addr, values.Length);
+		}
+
+		public override void BulkPeekUint(Range<long> addresses, bool bigEndian, uint[] values)
+		{
+			if ((ulong)addresses.Start + addresses.Count() > (ulong)Size || addresses.Start < 0) throw new ArgumentOutOfRangeException(nameof(addresses), message: AddressRangeError);
+			if (addresses.Count() > (uint)values.Length * sizeof(uint)) throw new ArgumentException(message: $"Length of {nameof(values)} must be at least {nameof(addresses)} count.", nameof(values));
+			if ((addresses.Count() & 3) != 0) throw new ArgumentOutOfRangeException(nameof(addresses), "Requested byte count must be divisible by 4."); // TODO: The caller should be specifying the count of uints, not the count of bytes!
+
+			fixed (uint* p = values)
+				_read32.Access((IntPtr)p, addresses.Start, (long)addresses.Count() / sizeof(uint));
+		}
+
+		public void BulkPokeUint(long addr, Span<uint> values)
+		{
+			if ((ulong)addr + (ulong)values.Length * sizeof(uint) > (ulong)Size || addr < 0) throw new ArgumentOutOfRangeException(nameof(addr), message: AddressRangeError);
+
+			fixed (uint* p = values)
+				_write32.Access((IntPtr)p, addr, values.Length);
+		}
+	}
 }

waterbox/emulibc/waterboxcore.h

@@ -38,6 +38,7 @@ typedef void (*MemoryFunctionHook)(uint8_t* buffer, int64_t address, int64_t cou
 #define MEMORYAREA_FLAGS_WORDSIZE8 256
 #define MEMORYAREA_FLAGS_SWAPPED 512
 #define MEMORYAREA_FLAGS_FUNCTIONHOOK 1024
+#define MEMORYAREA_FLAGS_SIZEDFUNCTIONHOOKS 2048
 
 #ifdef __cplusplus
 }