// Regression: single-stepping must reproduce running.

//

// The emulator runs through exec6502() and the debugger steps through

// step6502(). They are separate loops over the same tables, and everything a

// debugger tells you rests on them agreeing: if stepping through code produces

// a different machine than letting it run, then every value the debugger shows

// is a value the program would not otherwise have had.

//

// Each scenario runs the same program from the same starting state both ways

// and compares the whole visible machine -- registers, memory and the cycle

// counter. Cycle counts are included deliberately: they are the part most

// likely to drift, and the part a debugger hook can disturb without changing

// anything else.

#include "support/cpu_fixture.h"

#include "support/harness.h"

#include <stdio.h>

#include <string.h>

#define PROG 0x0200

#define SCRATCH 0x0400

// A snapshot of everything a scenario can observe.

typedef struct {

	uint16_t a, x, y, pc, sp, dp;

	uint8_t  status, k, db;

	uint32_t cycles;

	uint8_t  scratch[16];

} machine_t;

static machine_t

snapshot(void)

{

	machine_t m;

	m.a      = cpu_a();

	m.x      = cpu_x();

	m.y      = cpu_y();

	m.pc     = regs.pc;

	m.sp     = regs.sp;

	m.dp     = regs.dp;

	m.status = regs.status;

	m.k      = regs.k;

	m.db     = regs.db;

	m.cycles = clockticks6502;

	for (int i = 0; i < 16; i++) {

		m.scratch[i] = cpu_mem[SCRATCH + i];

	}

	return m;

}

static void

compare(machine_t stepped, machine_t ran, const char *what)

{

	char label[128];

#define FIELD(f, name)                                                        \

	snprintf(label, sizeof label, "%s: %s matches", what, name);              \

	check_eq(ran.f, stepped.f, label)

	FIELD(a, "A");

	FIELD(x, "X");

	FIELD(y, "Y");

	FIELD(pc, "PC");

	FIELD(sp, "SP");

	FIELD(status, "status");

	FIELD(cycles, "cycle count");

#undef FIELD

	bool same_memory = true;

	for (int i = 0; i < 16; i++) {

		if (stepped.scratch[i] != ran.scratch[i]) {

			same_memory = false;

		}

	}

	snprintf(label, sizeof label, "%s: memory matches", what);

	check(same_memory, label);

}

// Run `steps` instructions one at a time, then the same program for the same

// number of cycles in one go, and compare.

static void

both_ways(cpu_mode_t mode, const uint8_t *prog, uint16_t len, int steps,

          const char *what)

{

	cpu_reset_to(mode, PROG);

	cpu_load(PROG, prog, len);

	cpu_steps(steps);

	machine_t stepped = snapshot();

	cpu_reset_to(mode, PROG);

	cpu_load(PROG, prog, len);

	cpu_exec(stepped.cycles);

	machine_t ran = snapshot();

	compare(stepped, ran, what);

}

#define BOTH_WAYS(mode, prog, steps, what) \

	both_ways((mode), (prog), (uint16_t)sizeof(prog), (steps), (what))

// ---- Straight-line arithmetic ----------------------------------------------

static void

test_arithmetic(void)

{

	// CLC ; LDA #$40 ; ADC #$40 ; STA $0400 ; LDX #$05 ; DEX ; STX $0401

	const uint8_t prog[] = {

		0x18, 0xA9, 0x40, 0x69, 0x40, 0x8D, 0x00, 0x04,

		0xA2, 0x05, 0xCA, 0x8E, 0x01, 0x04,

	};

	BOTH_WAYS(CPU_65C02, prog, 7, "arithmetic and stores");

}

// ---- Taken branches, which carry their own cycle penalties -----------------

static void

test_branches(void)

{

	// LDX #$03 ; loop: DEX ; BNE loop ; STX $0400

	const uint8_t prog[] = {

		0xA2, 0x03,

		0xCA,             // loop

		0xD0, 0xFD,       // BNE loop

		0x8E, 0x00, 0x04,

	};

	BOTH_WAYS(CPU_65C02, prog, 8, "a loop with taken branches");

}

// ---- Subroutine call and return --------------------------------------------

static void

test_subroutine(void)

{

	// JSR $0210 ; STA $0400 ; (at $0210) LDA #$7B ; RTS

	uint8_t prog[0x14];

	memset(prog, 0xEA, sizeof prog); // NOP filler

	prog[0x00] = 0x20; prog[0x01] = 0x10; prog[0x02] = 0x02; // JSR $0210

	prog[0x03] = 0x8D; prog[0x04] = 0x00; prog[0x05] = 0x04; // STA $0400

	prog[0x10] = 0xA9; prog[0x11] = 0x7B;                    // LDA #$7B

	prog[0x12] = 0x60;                                       // RTS

	BOTH_WAYS(CPU_65C02, prog, 4, "a subroutine call and return");

}

// ---- Page-crossing indexed reads, which cost an extra cycle ----------------

static void

test_page_cross(void)

{

	// LDX #$01 ; LDA $04FF,X ; STA $0400

	const uint8_t prog[] = {

		0xA2, 0x01, 0xBD, 0xFF, 0x04, 0x8D, 0x00, 0x04,

	};

	BOTH_WAYS(CPU_65C02, prog, 3, "an indexed read across a page");

}

// ---- 65C816 native mode, including a misaligned direct page -----------------

// The direct-page penalty is applied by one loop and not the other, so this is

// where the two paths are most likely to disagree.

static void

test_native_direct_page(void)

{

	// LDA #$01 ; XBA ; LDA #$34 ; TCD  -- direct page to $0134, misaligned

	// LDA $10 ; STA $0400

	const uint8_t prog[] = {

		0xA9, 0x01, 0xEB, 0xA9, 0x34, 0x5B,

		0xA5, 0x10,

		0x8D, 0x00, 0x04,

	};

	BOTH_WAYS(CPU_816_NATIVE_8, prog, 6, "a misaligned direct page in native mode");

}

static void

test_native_aligned_direct_page(void)

{

	// The same shape with an aligned direct page ($0100), which pays no penalty.

	const uint8_t prog[] = {

		0xA9, 0x01, 0xEB, 0xA9, 0x00, 0x5B,

		0xA5, 0x10,

		0x8D, 0x00, 0x04,

	};

	BOTH_WAYS(CPU_816_NATIVE_8, prog, 6, "an aligned direct page in native mode");

}

int

main(void)

{

	test_arithmetic();

	test_branches();

	test_subroutine();

	test_page_cross();

	test_native_aligned_direct_page();

	test_native_direct_page();

	return x16_test_summary("cpu_steprun");

}