gb: memory callbacks no longer fire on writes to the system bus. (they were already not firing for all other memory domain action). add a new memory callback, exec. occurs right before the cpu reads a byte, if that byte will be the first byte of a new opcode. read callback no longer occurs in this situation.

BizHawk.Emulation/Consoles/Nintendo/Gameboy/Gambatte.cs

@@ -488,6 +488,7 @@ namespace BizHawk.Emulation.Cores.Nintendo.Gameboy
 
 		LibGambatte.MemoryCallback readcb;
 		LibGambatte.MemoryCallback writecb;
+		LibGambatte.MemoryCallback execcb;
 
 		void RefreshMemoryCallbacks()
 		{
@@ -503,9 +504,14 @@ namespace BizHawk.Emulation.Cores.Nintendo.Gameboy
 				writecb = delegate(uint addr) { mcs.CallWrite(addr); RefreshMemoryCallbacks(); };
 			else
 				writecb = null;
+			if (mcs.HasExecutes)
+				execcb = delegate(uint addr) { mcs.CallExecute(addr); RefreshMemoryCallbacks(); };
+			else
+				execcb = null;
 
 			LibGambatte.gambatte_setreadcallback(GambatteState, readcb);
 			LibGambatte.gambatte_setwritecallback(GambatteState, writecb);
+			LibGambatte.gambatte_setexeccallback(GambatteState, execcb);
 		}
 
 

BizHawk.Emulation/Consoles/Nintendo/Gameboy/LibGambatte.cs

@@ -146,7 +146,7 @@ namespace BizHawk.Emulation.Cores.Nintendo.Gameboy
 		public delegate void MemoryCallback(uint address);
 
 		/// <summary>
-		/// set a callback to occur immediately BEFORE EVERY cpu read
+		/// set a callback to occur immediately BEFORE EVERY cpu read, except for opcode first byte fetches
 		/// </summary>
 		/// <param name="core">opaque state pointer</param>
 		/// <param name="callback">null to clear</param>
@@ -161,6 +161,14 @@ namespace BizHawk.Emulation.Cores.Nintendo.Gameboy
 		[DllImport("libgambatte.dll", CallingConvention = CallingConvention.Cdecl)]
 		public static extern void gambatte_setwritecallback(IntPtr core, MemoryCallback callback);
 
+		/// <summary>
+		/// set a callback to occur immediately BEFORE EVERY cpu opcode (first byte) fetch
+		/// </summary>
+		/// <param name="core">opaque state pointer</param>
+		/// <param name="callback">null to clear</param>
+		[DllImport("libgambatte.dll", CallingConvention = CallingConvention.Cdecl)]
+		public static extern void gambatte_setexeccallback(IntPtr core, MemoryCallback callback);
+
 		/// <summary>
 		/// type of the cpu trace callback
 		/// </summary>

libgambatte/include/gambatte.h

@@ -88,6 +88,7 @@ public:
 	
 	void setReadCallback(void (*callback)(unsigned));
 	void setWriteCallback(void (*callback)(unsigned));
+	void setExecCallback(void (*callback)(unsigned));
 	void setTraceCallback(void (*callback)(void *));
 	void setScanlineCallback(void (*callback)(), int sl);
 	void setRTCCallback(std::time_t (*callback)());

libgambatte/src/cinterface.cpp

@@ -83,6 +83,12 @@ __declspec(dllexport) void gambatte_setwritecallback(void *core, void (*callback
 	g->setWriteCallback(callback);
 }
 
+__declspec(dllexport) void gambatte_setexeccallback(void *core, void (*callback)(unsigned))
+{
+	GB *g = (GB *) core;
+	g->setExecCallback(callback);
+}
+
 __declspec(dllexport) void gambatte_settracecallback(void *core, void (*callback)(void *))
 {
 	GB *g = (GB *) core;

libgambatte/src/cinterface.h

@@ -24,6 +24,8 @@ extern "C"
 
 	__declspec(dllexport) void gambatte_setwritecallback(void *core, void (*callback)(unsigned));
 
+	__declspec(dllexport) void gambatte_setexeccallback(void *core, void (*callback)(unsigned));
+
 	__declspec(dllexport) void gambatte_settracecallback(void *core, void (*callback)(void *));
 
 	__declspec(dllexport) void gambatte_setscanlinecallback(void *core, void (*callback)(), int sl);

libgambatte/src/cpu.cpp

@@ -131,7 +131,7 @@ void CPU::loadState(const SaveState &state) {
 
 #define READ(dest, addr) do { (dest) = memory.read(addr, cycleCounter); cycleCounter += 4; } while (0)
 // #define PC_READ(dest, addr) do { (dest) = memory.pc_read(addr, cycleCounter); cycleCounter += 4; } while (0)
-#define PC_READ(dest) do { (dest) = memory.read(PC, cycleCounter); PC = (PC + 1) & 0xFFFF; cycleCounter += 4; } while (0)
+#define PC_READ(dest) do { (dest) = memory.read_excb(PC, cycleCounter); PC = (PC + 1) & 0xFFFF; cycleCounter += 4; } while (0)
 #define FF_READ(dest, addr) do { (dest) = memory.ff_read(addr, cycleCounter); cycleCounter += 4; } while (0)
 
 #define WRITE(addr, data) do { memory.write(addr, data, cycleCounter); cycleCounter += 4; } while (0)

libgambatte/src/cpu.h

@@ -75,6 +75,10 @@ public:
 		memory.setWriteCallback(callback);
 	}
 
+	void setExecCallback(void (*callback)(unsigned)) {
+		memory.setExecCallback(callback);
+	}
+
 	void setTraceCallback(void (*callback)(void *)) {
 		tracecallback = callback;
 	}
@@ -124,7 +128,7 @@ public:
 
 	//unsigned char ExternalRead(unsigned short addr) { return memory.read(addr, cycleCounter_); }
 	unsigned char ExternalRead(unsigned short addr) { return memory.peek(addr); }
-	void ExternalWrite(unsigned short addr, unsigned char val) { memory.write(addr, val, cycleCounter_); }
+	void ExternalWrite(unsigned short addr, unsigned char val) { memory.write_nocb(addr, val, cycleCounter_); }
 
 	int LinkStatus(int which) { return memory.LinkStatus(which); }
 

libgambatte/src/gambatte.cpp

@@ -103,6 +103,10 @@ void GB::setWriteCallback(void (*callback)(unsigned)) {
 	p_->cpu.setWriteCallback(callback);
 }
 
+void GB::setExecCallback(void (*callback)(unsigned)) {
+	p_->cpu.setExecCallback(callback);
+}
+
 void GB::setTraceCallback(void (*callback)(void *)) {
 	p_->cpu.setTraceCallback(callback);
 }

libgambatte/src/memory.cpp

@@ -29,6 +29,7 @@ Memory::Memory(const Interrupter &interrupter_in)
 : getInput(0),
   readCallback(0),
   writeCallback(0),
+  execCallback(0),
   divLastUpdate(0),
   lastOamDmaUpdate(DISABLED_TIME),
   display(ioamhram, 0, VideoInterruptRequester(&intreq)),

libgambatte/src/memory.h

@@ -35,6 +35,7 @@ class Memory {
 	
 	void (*readCallback)(unsigned);
 	void (*writeCallback)(unsigned);
+	void (*execCallback)(unsigned);
 
 	InputGetter *getInput;
 	unsigned long divLastUpdate;
@@ -125,10 +126,23 @@ public:
 		return cart.rmem(P >> 12) ? cart.rmem(P >> 12)[P] : nontrivial_read(P, cycleCounter);
 	}
 
+	unsigned read_excb(const unsigned P, const unsigned long cycleCounter) {
+		if (execCallback)
+			execCallback(P);
+		return cart.rmem(P >> 12) ? cart.rmem(P >> 12)[P] : nontrivial_read(P, cycleCounter);
+	}
+
 	unsigned peek(const unsigned P) {
 		return cart.rmem(P >> 12) ? cart.rmem(P >> 12)[P] : nontrivial_peek(P);
 	}
 
+	void write_nocb(const unsigned P, const unsigned data, const unsigned long cycleCounter) {
+		if (cart.wmem(P >> 12)) {
+			cart.wmem(P >> 12)[P] = data;
+		} else
+			nontrivial_write(P, data, cycleCounter);
+	}
+	
 	void write(const unsigned P, const unsigned data, const unsigned long cycleCounter) {
 		if (cart.wmem(P >> 12)) {
 			cart.wmem(P >> 12)[P] = data;
@@ -161,6 +175,9 @@ public:
 	void setWriteCallback(void (*callback)(unsigned)) {
 		this->writeCallback = callback;
 	}
+	void setExecCallback(void (*callback)(unsigned)) {
+		this->execCallback = callback;
+	}
 
 	void setScanlineCallback(void (*callback)(), int sl) {
 		display.setScanlineCallback(callback, sl);