Pause emulation on breakpoints and be able to advance step by step (cpu).

Author: pherrymason

README.md

@@ -3,7 +3,8 @@
 # Usage
 ## Arguments
 - `-rom` Path to rom to load.
-
+- `-scale` Output screen resolution, relative to native NES. > 1
+- `-breakpoint` setup a single breakpoint
 
 ## Shortcuts
 - `p` Displays PPU Register debug panel.

src/debugger/breakpoints.go

@@ -5,15 +5,20 @@ import (
 	"github.com/lachee/raylib-goplus/raylib"
 	"github.com/raulferras/nes-golang/src/nes"
 	"github.com/raulferras/nes-golang/src/nes/types"
+	"log"
 )
 
 type breakpointDebugger struct {
 	emulator           *nes.Nes
 	panel              *draggablePanel
 	breakpointAddPanel *breakpointAdd
-	breakpoints        [4]uint16
-	breakpointsCount   uint8
-	breakpointEnabled  bool
+
+	dasmScroll int
+	dasmActive int
+
+	breakpoints       [4]uint16
+	breakpointsCount  uint8
+	breakpointEnabled bool
 }
 
 const breakpointDebuggerWidth = 500
@@ -43,23 +48,42 @@ func (dbg *breakpointDebugger) Draw() {
 	padding := float32(5)
 	anchor := raylib.Vector2{dbg.panel.position.X + padding, dbg.panel.position.Y + 30}
 
+	dbg.drawDisassembler(anchor)
+	dbg.breakPointControls(anchor)
+}
+
+func (dbg *breakpointDebugger) drawDisassembler(anchor raylib.Vector2) {
 	raylib.GuiLabel(
 		raylib.Rectangle{anchor.X, anchor.Y, 200, 20},
 		"Disassembler",
 	)
-	raylib.GuiListViewEx(
+
+	disassembled := dbg.emulator.Debugger().SortedDisassembled()
+	pc := dbg.emulator.Debugger().ProgramCounter()
+
+	// todo optimization: extract only the asm lines required, based on current dbg.dasmScroll
+	var disasm []string
+	disasm = make([]string, 0, len(disassembled))
+	line := 0
+	active := 0
+	for _, asm := range disassembled {
+		if asm.Address == pc {
+			active = line
+			//log.Printf("Current pc found: %x (idx %d)", pc, line)
+		}
+		disasm = append(disasm, asm.Asm)
+		line++
+	}
+
+	_, _, scroll := raylib.GuiListViewEx(
 		raylib.Rectangle{anchor.X, anchor.Y + 20, 200, 300},
-		[]string{
-			"hola",
-			"dos",
-		},
-		2,
+		disasm,
+		len(disasm),
 		0,
-		0,
-		-1,
+		active,
+		active,
 	)
-
-	dbg.breakPointControls(anchor)
+	dbg.dasmScroll = scroll
 }
 
 func (dbg *breakpointDebugger) breakPointControls(windowAnchor raylib.Vector2) {
@@ -104,12 +128,17 @@ func (dbg *breakpointDebugger) breakPointControls(windowAnchor raylib.Vector2) {
 	)
 	y = dbg.panel.registerStackedControl(20, padding)
 
-	raylib.GuiButton(
+	stepClicked := raylib.GuiButton(
 		raylib.Rectangle{anchor.X, y, 100, 20},
 		//raylib.GuiIconText(raylib.)
 		"Step",
 	)
 
+	if stepClicked {
+		log.Println("click on step")
+		dbg.emulator.Debugger().RunOneCPUOperationAndPause()
+	}
+
 	if dbg.breakpointsCount < 4 {
 		if addBreakPointClicked {
 			dbg.showBreakpointAdd()

src/main.go

@@ -3,6 +3,7 @@ package main
 import (
 	"flag"
 	"fmt"
+	"github.com/FMNSSun/hexit"
 	r "github.com/lachee/raylib-goplus/raylib"
 	"github.com/pkg/profile"
 	"github.com/raulferras/nes-golang/src/debugger"
@@ -20,16 +21,8 @@ import (
 var cpuAdvance bool
 
 func main() {
-	scale, cpuprofile, romPath, debugPPU, maxCPUCycle := cmdLineArguments()
+	scale, cpuprofile, romPath, debugPPU, breakpoint := cmdLineArguments()
 	if cpuprofile != "" {
-		/*f, err := os.Create(cpuprofile)
-		if err != nil {
-			log.Fatal(err)
-		}
-		pprof.StartCPUProfile(f)
-		pprof.
-		defer pprof.StopCPUProfile()
-		*/
 		defer profile.Start(profile.CPUProfile, profile.ProfilePath(".")).Stop()
 	}
 
@@ -57,14 +50,17 @@ func main() {
 
 	debugger.PrintRomInfo(&cartridge)
 
+	nesDebugger := nes.CreateNesDebugger(
+		"./var",
+		true,
+		debugPPU,
+	)
+	if len(breakpoint) > 0 {
+		nesDebugger.AddBreakPoint(types.Address(hexit.UnhexUint16Str(breakpoint)))
+	}
 	console := nes.CreateNes(
 		&cartridge,
-		nes.CreateNesDebugger(
-			"./var",
-			true,
-			debugPPU,
-			maxCPUCycle,
-		),
+		nesDebugger,
 	)
 
 	loop(console, scale)
@@ -78,7 +74,7 @@ func loop(console *nes.Nes, scale int) {
 	debuggerGUI := debugger.NewDebugger(console)
 
 	for !r.WindowShouldClose() {
-		if console.Stopped() {
+		if console.Finished() {
 			break
 		}
 
@@ -90,8 +86,10 @@ func loop(console *nes.Nes, scale int) {
 		}
 
 		// Update emulator
-		if cpuAdvance {
+		if !console.Paused() {
 			console.TickForTime(dt)
+		} else {
+			console.PausedTick()
 		}
 
 		// Draw --------------------
@@ -126,13 +124,13 @@ func drawEmulation(frame *image.RGBA) {
 	}
 }
 
-func cmdLineArguments() (int, string, string, bool, int64) {
+func cmdLineArguments() (int, string, string, bool, string) {
 	var cpuprofile = flag.String("cpuprofile", "", "write cpu profile to file")
 	var romPath = flag.String("rom", "", "path to rom")
 	var debugPPU = flag.Bool("debugPPU", false, "Displays PPU debug information")
-	var stopAtCpuCycle = flag.Int64("maxCpuCycle", -1, "stops emulation at given cpu cycle")
 	var scale = flag.Int("scale", 1, "scale resolution")
+	var breakpoint = flag.String("breakpoint", "", "defines a breakpoint on start")
 	flag.Parse()
 
-	return *scale, *cpuprofile, *romPath, *debugPPU, *stopAtCpuCycle
+	return *scale, *cpuprofile, *romPath, *debugPPU, *breakpoint
 }

src/nes/Debugger.go

@@ -3,39 +3,48 @@ package nes
 import (
 	"github.com/raulferras/nes-golang/src/nes/ppu"
 	"github.com/raulferras/nes-golang/src/nes/types"
+	"github.com/raulferras/nes-golang/src/utils"
 	"image"
 	"image/color"
+	"log"
 )
 
 // Debugger offers an api to interact externally with
 // NES components
 type Debugger struct {
-	cpu          *Cpu6502
-	ppu          *ppu.Ppu2c02
-	logPath      string
-	maxCPUCycle  int64
-	disassembled map[types.Address]string
-	DebugPPU     bool
-	debugCPU     bool
+	cpu                *Cpu6502
+	ppu                *ppu.Ppu2c02
+	logPath            string
+	disassembled       map[types.Address]string
+	sortedDisassembled []utils.ASM
+
+	pauseEmulation func()
+
+	DebugPPU bool
+	debugCPU bool
 	// debugging related
-	cpuBreakPoints    map[types.Address]bool
-	cpuStepByStepMode bool
+	cpuBreakPoints                  map[types.Address]bool
+	cpuBreakPointTriggeredAt        types.Address // flag breakpoint as used
+	cpuStepByStepMode               bool
+	waitingNextCPUOperationFinishes bool
 }
 
-func CreateNesDebugger(logPath string, debugCPU bool, debugPPU bool, maxCPUCycle int64) *Debugger {
+func CreateNesDebugger(logPath string, debugCPU bool, debugPPU bool) *Debugger {
 	return &Debugger{
 		cpu:          nil,
 		ppu:          nil,
 		logPath:      logPath,
-		maxCPUCycle:  maxCPUCycle,
 		disassembled: nil,
 		debugCPU:     debugCPU,
 		DebugPPU:     debugPPU,
 
+		pauseEmulation: nil,
 		cpuBreakPoints: make(map[types.Address]bool),
 	}
 }
 
+// Control flow related ---------------------------
+
 func (debugger *Debugger) AddBreakPoint(address types.Address) {
 	debugger.cpuBreakPoints[address] = true
 }
@@ -44,21 +53,72 @@ func (debugger *Debugger) RemoveBreakPoint(address types.Address) {
 	debugger.cpuBreakPoints[address] = false
 }
 
-func (debugger *Debugger) shouldPauseBecauseBreakpoint() bool {
+func (debugger *Debugger) shouldPauseEmulation() bool {
+	if debugger.waitingNextCPUOperationFinishes {
+		log.Printf("Allow one Cpu instruction")
+		return false
+	}
+
+	if debugger.isBreakpointTriggered() {
+		debugger.pauseEmulation()
+		return true
+	}
+
+	if debugger.isManualStepMode() {
+		return true
+	} else {
+	}
+
+	return false
+}
+
+func (debugger *Debugger) isBreakpointTriggered() bool {
 	pc := debugger.cpu.ProgramCounter()
+	if pc == debugger.cpuBreakPointTriggeredAt {
+		return false
+	}
+
 	enabled, exist := debugger.cpuBreakPoints[pc]
 	if enabled && exist {
+		log.Printf("Breakpoint reached")
 		debugger.cpuStepByStepMode = true
+		debugger.cpuBreakPointTriggeredAt = pc
 		return true
 	}
 
 	return false
 }
 
+func (debugger *Debugger) isManualStepMode() bool {
+	return debugger.cpuStepByStepMode
+}
+
+func (debugger *Debugger) resumeFromBreakpoint() {
+	debugger.cpuStepByStepMode = false
+}
+
+// RunOneCPUOperationAndPause executed when user wants to just run one single cycle after having
+// emulation paused.
+func (debugger *Debugger) RunOneCPUOperationAndPause() {
+	debugger.waitingNextCPUOperationFinishes = true
+}
+
+// oneCpuOperationRan This method is expected to be called after the CPU runs a cycle.
+// This is intended to reenable the emulation pause automatically after next cpu instruction has been called.
+func (debugger *Debugger) oneCpuOperationRan() {
+	debugger.waitingNextCPUOperationFinishes = false
+}
+
+// debugging control flow related ^---------------------------
+
 func (debugger *Debugger) Disassembled() map[types.Address]string {
 	return debugger.disassembled
 }
 
+func (debugger *Debugger) SortedDisassembled() []utils.ASM {
+	return debugger.sortedDisassembled
+}
+
 func (debugger *Debugger) ProgramCounter() types.Address {
 	return debugger.cpu.ProgramCounter()
 }