// Checks for interrupt context tracking (src/cpu/irq_ctx.c).

//

// The CPU core reports an entry from interrupt6502() and a leave from rti(),

// and the two are paired by the stack pointer. That pairing is the whole

// design, and it has to survive things a real program does: nested handlers, a

// handler that returns further than its own frame, an RTI with no matching

// entry, and a reset in the middle of one. Getting it wrong leaves the debugger

// permanently convinced the machine is inside an interrupt, or never in one.

//

// The 6502 stack grows DOWN, so a deeper frame has a LOWER stack pointer, and

// an interrupt entry records the pointer BEFORE anything is pushed -- which is

// exactly what its matching RTI restores.

#include "cpu/irq_ctx.h"

#include <stdbool.h>

#include <stdint.h>

#include <stdio.h>

static int failures = 0;

static void

check(bool cond, const char *what)

{

	if (!cond) {

		failures++;

		printf("FAIL: %s\n", what);

	} else {

		printf("ok  : %s\n", what);

	}

}

// The vector values the CPU core passes through; their exact numbering does not

// matter here, only that it is reported back unchanged.

#define VEC_IRQ 0

#define VEC_NMI 1

#define VEC_BRK 2

// CPU_IRQ_CTX_MAX comes from the header rather than being restated here: a

// private copy that drifted from the real limit would leave the boundary checks

// below passing while no longer testing the boundary.

int

main(void)

{

	// ── Nothing has happened yet ────────────────────────────────────────────

	{

		cpu_irq_ctx_reset();

		check(!cpu_in_interrupt(), "starts outside any interrupt");

		check(cpu_irq_depth() == 0, "at depth zero");

		check(cpu_irq_count() == 0, "with nothing counted");

		check(cpu_irq_return_pc() == 0, "and no return address to report");

		check(!cpu_irq_take_entered_flag(), "and nothing just entered");

	}

	// ── One interrupt, taken and returned from ──────────────────────────────

	{

		cpu_irq_ctx_reset();

		cpu_irq_ctx_enter(VEC_IRQ, 0x1234, 0x01FD);

		check(cpu_in_interrupt(), "reports being inside a handler");

		check(cpu_irq_depth() == 1, "at depth one");

		check(cpu_irq_count() == 1, "counts the interrupt");

		check(cpu_irq_last_vector() == VEC_IRQ, "remembers which vector");

		check(cpu_irq_return_pc() == 0x1234, "reports where it will return to");

		// A balanced RTI restores the stack pointer to the entry value.

		cpu_irq_ctx_leave(0x01FD);

		check(!cpu_in_interrupt(), "reports leaving the handler");

		check(cpu_irq_depth() == 0, "back to depth zero");

		check(cpu_irq_count() == 1, "the count survives the return");

		check(cpu_irq_return_pc() == 0, "and there is no return address again");

	}

	// ── The just-entered flag is a one-shot ─────────────────────────────────

	// A debugger uses this to notice "an interrupt was just taken" while

	// stepping. It has to be true exactly once, or every poll would look like a

	// fresh interrupt.

	{

		cpu_irq_ctx_reset();

		check(!cpu_irq_take_entered_flag(), "no entry reported before one happens");

		cpu_irq_ctx_enter(VEC_IRQ, 0x1000, 0x01FD);

		check(cpu_irq_take_entered_flag(), "reports the entry once");

		check(!cpu_irq_take_entered_flag(), "and only once");

		// A second interrupt sets it again.

		cpu_irq_ctx_enter(VEC_NMI, 0x2000, 0x01FA);

		check(cpu_irq_take_entered_flag(), "a second entry is reported too");

	}

	// ── Nesting ─────────────────────────────────────────────────────────────

	// An NMI can interrupt an IRQ handler, and a handler that re-enables

	// interrupts can be interrupted again. Each RTI must unwind exactly one.

	{

		cpu_irq_ctx_reset();

		cpu_irq_ctx_enter(VEC_IRQ, 0x1000, 0x01FD);   // outer

		cpu_irq_ctx_enter(VEC_NMI, 0x2000, 0x01FA);   // inner, deeper stack

		check(cpu_irq_depth() == 2, "counts nested handlers");

		check(cpu_irq_count() == 2, "counts both interrupts");

		check(cpu_irq_last_vector() == VEC_NMI, "reports the innermost vector");

		check(cpu_irq_return_pc() == 0x2000, "reports the innermost return address");

		cpu_irq_ctx_leave(0x01FA);                    // inner RTI

		check(cpu_irq_depth() == 1, "unwinds one level per return");

		check(cpu_in_interrupt(), "still inside the outer handler");

		check(cpu_irq_return_pc() == 0x1000, "and reports its return address again");

		cpu_irq_ctx_leave(0x01FD);                    // outer RTI

		check(cpu_irq_depth() == 0, "unwinds the outer handler too");

		check(!cpu_in_interrupt(), "and is outside any interrupt");

	}

	// ── Returning past more than one frame ──────────────────────────────────

	// A handler that unwinds several frames at once, or discards them, must not

	// leave the depth stuck high for the rest of the session.

	{

		cpu_irq_ctx_reset();

		cpu_irq_ctx_enter(VEC_IRQ, 0x1000, 0x01FD);

		cpu_irq_ctx_enter(VEC_IRQ, 0x2000, 0x01FA);

		cpu_irq_ctx_enter(VEC_IRQ, 0x3000, 0x01F7);

		check(cpu_irq_depth() == 3, "three handlers open");

		// One RTI that restores the stack all the way back to the outermost

		// entry: every frame it returned past is finished.

		cpu_irq_ctx_leave(0x01FD);

		check(cpu_irq_depth() == 0, "a return past every frame unwinds them all");

		check(!cpu_in_interrupt(), "and leaves the machine outside any interrupt");

	}

	// ── An RTI with nothing to match ────────────────────────────────────────

	// A program can RTI without us having seen the entry -- an interrupt

	// already in flight at startup, or a hand-rolled stack frame. That is not

	// an error, and must not drive the depth negative.

	{

		cpu_irq_ctx_reset();

		cpu_irq_ctx_leave(0x01FD);

		check(cpu_irq_depth() == 0, "an unmatched return leaves depth at zero");

		check(!cpu_in_interrupt(), "and does not report being in a handler");

		cpu_irq_ctx_leave(0x01FD);

		cpu_irq_ctx_leave(0x01FD);

		check(cpu_irq_depth() == 0, "repeated unmatched returns stay at zero");

		// And the tracker still works afterwards.

		cpu_irq_ctx_enter(VEC_IRQ, 0x4000, 0x01FD);

		check(cpu_irq_depth() == 1 && cpu_irq_return_pc() == 0x4000,

		      "tracking still works after an unmatched return");

	}

	// ── Reset abandons anything in flight ───────────────────────────────────

	{

		cpu_irq_ctx_reset();

		cpu_irq_ctx_enter(VEC_IRQ, 0x1000, 0x01FD);

		cpu_irq_ctx_enter(VEC_NMI, 0x2000, 0x01FA);

		cpu_irq_ctx_reset();

		check(cpu_irq_depth() == 0, "reset abandons open handlers");

		check(!cpu_in_interrupt(), "and reports being outside one");

		check(cpu_irq_count() == 0, "and clears the count");

		check(cpu_irq_return_pc() == 0, "and the return address");

		check(!cpu_irq_take_entered_flag(), "and the just-entered flag");

	}

	// ── Deeper nesting than the tracker records detail for ──────────────────

	// Past its limit the depth still has to count correctly and come back down

	// to zero; only the per-frame detail is allowed to go missing.

	{

		cpu_irq_ctx_reset();

		uint16_t sp = 0x01FD;

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

			cpu_irq_ctx_enter(VEC_IRQ, (uint16_t)(0x1000 + i), sp);

			sp = (uint16_t)(sp - 3);

		}

		check(cpu_irq_depth() == 40, "counts deeper nesting than it records");

		check(cpu_irq_count() == 40, "and counts every interrupt");

		// Unwind them one balanced return at a time.

		for (int i = 39; i >= 0; i--) {

			sp = (uint16_t)(sp + 3);

			cpu_irq_ctx_leave(sp);

		}

		check(cpu_irq_depth() == 0, "and unwinds all the way back out");

		check(!cpu_in_interrupt(), "ending outside any interrupt");

		// Just past the recorded frames, an unbalanced return must still pop

		// exactly one level rather than cascading on detail it never kept.

		cpu_irq_ctx_reset();

		sp = 0x01FD;

		for (int i = 0; i < CPU_IRQ_CTX_MAX + 1; i++) {

			cpu_irq_ctx_enter(VEC_IRQ, (uint16_t)(0x1000 + i), sp);

			sp = (uint16_t)(sp - 3);

		}

		check(cpu_irq_depth() == CPU_IRQ_CTX_MAX + 1, "opens one more than it records");

		// An sp far above every recorded frame: were the unrecorded level to

		// consult the frames it does not have, this would cascade.

		cpu_irq_ctx_leave(0x01FD);

		check(cpu_irq_depth() == CPU_IRQ_CTX_MAX,

		      "an unrecorded level pops exactly one, without cascading");

	}

	// ── A stack that wraps is out of contract ───────────────────────────────

	// Both rules here read the stack pointer: frames must decrease as nesting

	// deepens, and a balanced RTI lands exactly on the pointer its entry

	// recorded. A guest that pushes past the bottom of page 1 breaks the first

	// one -- an outer frame near the bottom ends up numerically ABOVE the frame

	// nested inside it, and is indistinguishable from a frame the stack has

	// legitimately risen back past.

	//

	// Nothing based on the stack pointer alone can tell those apart, so this

	// picks the case that actually happens: overflowing a 256-byte stack has

	// already destroyed the guest's own return addresses, while a BRK reaching a

	// warm start happens in every debugging session. The exact behaviour is

	// pinned rather than bounded, so changing that trade has to come here and

	// edit it deliberately.

	{

		cpu_irq_ctx_reset();

		cpu_irq_ctx_enter(VEC_IRQ, 0x1000, 0x0101);   // outer, near the bottom

		cpu_irq_ctx_enter(VEC_NMI, 0x2000, 0x01FE);   // pushes wrapped it round

		// The wrapped outer frame is retired, because it cannot be told from one

		// the stack has passed. This is the accepted false-low.

		check(cpu_irq_depth() == 1, "a wrapped outer frame is retired, not kept");

		cpu_irq_ctx_leave(0x01FE);

		check(cpu_irq_depth() == 0, "and the inner return closes what is left");

		// What makes this survivable, and better than the alternative: the very

		// next clean pair reads correctly, so the damage is bounded by the

		// wrapped handler's own lifetime rather than lasting until reset.

		cpu_irq_ctx_enter(VEC_IRQ, 0x3000, 0x01FD);

		check(cpu_irq_depth() == 1, "the next clean interrupt is tracked normally");

		check(cpu_irq_return_pc() == 0x3000, "with its own return address");

		cpu_irq_ctx_leave(0x01FD);

		check(cpu_irq_depth() == 0, "and closes cleanly");

	}

	// ── Retirement still works above the recorded frames ────────────────────

	// Only CPU_IRQ_CTX_MAX levels keep a pointer of their own. Judging the ones

	// above by the deepest that does is what stops the depth passing the array

	// and then never coming back down: an interrupt taken at or above the last

	// recorded frame proves everything from there up is gone.

	{

		cpu_irq_ctx_reset();

		// Nest past the array, each level below the last.

		uint16_t sp = 0x01FD;

		for (int i = 0; i < CPU_IRQ_CTX_MAX + 6; i++)

			cpu_irq_ctx_enter(VEC_IRQ, 0x1000, sp--);

		check(cpu_irq_depth() == CPU_IRQ_CTX_MAX + 6, "nesting can pass the array");

		// An interrupt arrives partway down, at the level frames[8] recorded.

		// Everything from there up is gone -- the six unrecorded levels and the

		// seven recorded ones above frames[8] -- while frames[0..7] are still

		// live and must survive. Landing between two recorded frames is what

		// makes this test the difference between collapsing to the deepest

		// surviving frame and simply wiping the depth.

		cpu_irq_ctx_enter(VEC_IRQ, 0x2000, 0x01F5);   // == frames[8].sp

		check(cpu_irq_depth() == 9,

		      "levels above the array collapse onto the deepest surviving frame");

		check(cpu_irq_return_pc() == 0x2000, "and the new frame is the innermost");

		// The frames below it really are still there.

		cpu_irq_ctx_leave(0x01F5);

		check(cpu_irq_depth() == 8, "leaving it uncovers the frame beneath");

		// And an interrupt above everything clears the lot.

		cpu_irq_ctx_enter(VEC_IRQ, 0x3000, 0x01FD);

		check(cpu_irq_depth() == 1, "an interrupt above them all retires the rest");

		cpu_irq_ctx_leave(0x01FD);

		check(cpu_irq_depth() == 0, "so the depth comes back to zero");

	}

	// ── Nesting that does not wrap is exact ─────────────────────────────────

	// The ordinary case, which is what the rules are for: each nested frame

	// sits below the one outside it, and a balanced return unwinds exactly one.

	{

		cpu_irq_ctx_reset();

		cpu_irq_ctx_enter(VEC_IRQ, 0x1000, 0x01FD);

		cpu_irq_ctx_enter(VEC_NMI, 0x2000, 0x01F9);

		check(cpu_irq_depth() == 2, "nested handlers count two");

		cpu_irq_ctx_leave(0x01F9);

		check(cpu_irq_depth() == 1, "a balanced inner return unwinds only its own");

		check(cpu_irq_return_pc() == 0x1000, "and the outer frame is reported again");

		cpu_irq_ctx_leave(0x01FD);

		check(cpu_irq_depth() == 0, "and the outer return closes it");

	}

	// ── A return past several frames unwinds them all ───────────────────────

	{

		cpu_irq_ctx_reset();

		cpu_irq_ctx_enter(VEC_IRQ, 0x1000, 0x01FD);

		cpu_irq_ctx_enter(VEC_NMI, 0x2000, 0x01F9);

		cpu_irq_ctx_enter(VEC_BRK, 0x3000, 0x01F5);

		cpu_irq_ctx_leave(0x01FD);                    // straight back to the outermost

		check(cpu_irq_depth() == 0,

		      "a return to an outer frame's own entry unwinds everything inside it");

	}

	// ── The count is cumulative ─────────────────────────────────────────────

	{

		cpu_irq_ctx_reset();

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

			cpu_irq_ctx_enter(VEC_IRQ, 0x1000, 0x01FD);

			cpu_irq_ctx_leave(0x01FD);

		}

		check(cpu_irq_count() == 100, "counts every interrupt taken, not just open ones");

		check(cpu_irq_depth() == 0, "while ending balanced");

	}

	// ── Each vector is reported back unchanged ──────────────────────────────

	{

		cpu_irq_ctx_reset();

		const int vectors[] = { VEC_IRQ, VEC_NMI, VEC_BRK };

		bool ok = true;

		for (unsigned i = 0; i < sizeof(vectors) / sizeof(vectors[0]); i++) {

			cpu_irq_ctx_enter(vectors[i], 0x1000, 0x01FD);

			if (cpu_irq_last_vector() != vectors[i])

				ok = false;

			cpu_irq_ctx_leave(0x01FD);

		}

		check(ok, "reports back whichever vector was taken");

	}

	// ── A frame abandoned without an RTI ────────────────────────────────────

	// A BRK reaching a warm start resets the stack instead of returning, so its

	// entry never gets a matching RTI. Later interrupts must still be tracked

	// correctly rather than being swallowed by the stale frame, and the depth

	// must read HIGH rather than low: too high corrects itself at the next

	// matching return, too low claims nothing is running when something is.

	{

		cpu_irq_ctx_reset();

		cpu_irq_ctx_enter(VEC_BRK, 0x4000, 0x01F0);   // BRK, never returns

		// Warm start resets the stack to the top; an ordinary IRQ then arrives.

		cpu_irq_ctx_enter(VEC_IRQ, 0x5000, 0x01FD);

		// Taking that IRQ is what retires the abandoned BRK frame: the stack

		// had risen back above it, which proves it was gone.

		check(cpu_irq_depth() == 1, "an abandoned frame is retired, not stacked");

		cpu_irq_ctx_leave(0x01FD);                    // balanced IRQ return

		check(cpu_irq_depth() == 0,

		      "so the depth comes back to zero once the IRQ returns");

		// And it does not accumulate: a second BRK that never returns must not

		// leave the machine permanently looking like it is inside an interrupt.

		cpu_irq_ctx_enter(VEC_BRK, 0x4100, 0x01F0);

		cpu_irq_ctx_enter(VEC_IRQ, 0x5100, 0x01FD);

		cpu_irq_ctx_leave(0x01FD);

		check(cpu_irq_depth() == 0, "however many times it happens");

	}

	// ── The program bank is part of the return address ──────────────────────

	// Native-mode interrupts push the program bank, and the CPU zeroes it on

	// entry, so a handler cannot recover it. Recording only the low 16 bits

	// would send a step-over to the right offset in the wrong bank.

	{

		cpu_irq_ctx_reset();

		cpu_irq_ctx_enter(VEC_IRQ, 0x123456, 0x01FD);

		check(cpu_irq_return_pc() == 0x123456,

		      "the return address keeps its program bank");

		cpu_irq_ctx_enter(VEC_NMI, 0x008000, 0x01F9);

		check(cpu_irq_return_pc() == 0x008000,

		      "and a bank-zero address is unchanged");

		cpu_irq_ctx_leave(0x01F9);

		check(cpu_irq_return_pc() == 0x123456,

		      "and the outer one is restored when the inner returns");

	}

	// ── Runaway nesting stays safe ──────────────────────────────────────────

	// A BRK handler that BRKs never returns. Once the depth passes the array

	// the pointer that retirement judges against is frozen, so interrupts taken

	// below it pile up with nothing able to retire them. The saturation in the

	// code is what stops a signed counter overflowing, which would be undefined

	// behaviour rather than a wrong number.

	{

		cpu_irq_ctx_reset();

		// Walk the pointer all the way down, one byte per entry.

		for (int sp = 0xFFFF; sp >= 0; sp--)

			cpu_irq_ctx_enter(VEC_BRK, 0x6000, (uint16_t)sp);

		const int deep = cpu_irq_depth();

		check(deep > CPU_IRQ_CTX_MAX,

		      "nesting can exceed the frames it records detail for");

		check(deep == 0x10000, "up to the cap");

		// Entering again while already at the cap must not move it. Without the

		// clamp this simply keeps counting, and a long enough runaway would

		// overflow the counter rather than merely report a silly number.

		cpu_irq_ctx_enter(VEC_BRK, 0x6000, 0x0000);

		check(cpu_irq_depth() == 0x10000, "and stays there when it is passed");

		check(cpu_in_interrupt(), "and still reports an interrupt");

		// No detail is kept past the array, so those come off one at a time;

		// the recorded ones then close together when the outermost returns.

		for (int i = 0; i < deep - CPU_IRQ_CTX_MAX; i++)

			cpu_irq_ctx_leave(0x0000);

		check(cpu_irq_depth() == CPU_IRQ_CTX_MAX,

		      "undetailed levels come off one at a time");

		cpu_irq_ctx_leave(0xFFFF);   // back to the outermost frame's own entry

		check(cpu_irq_depth() == 0, "and the outermost return closes the rest");

	}

	// ── A frame abandoned at the same stack level ───────────────────────────

	// Two interrupts taken at the identical pointer cannot both be live: the

	// stack being back at that level means the first one's frame is gone. This

	// is the boundary of the retirement rule, and it has to be inclusive.

	{

		cpu_irq_ctx_reset();

		cpu_irq_ctx_enter(VEC_BRK, 0x7000, 0x01FD);   // abandoned

		cpu_irq_ctx_enter(VEC_IRQ, 0x7100, 0x01FD);   // same level again

		check(cpu_irq_depth() == 1,

		      "an interrupt at the same level retires the one before it");

		cpu_irq_ctx_leave(0x01FD);

		check(cpu_irq_depth() == 0, "and returns cleanly to zero");

	}

	// ── A return that matches nothing changes nothing ───────────────────────

	// A handler can push a fabricated frame and RTI to itself, landing on a

	// pointer no entry recorded, while the interrupt it is running inside is

	// still live. Popping on that would report no interrupt during one -- the

	// one answer a debugger must never give. Frames only close when something

	// proves they have: a return that lands exactly on them, or a later

	// interrupt taken at or above them.

	{

		cpu_irq_ctx_reset();

		cpu_irq_ctx_enter(VEC_IRQ, 0x8000, 0x01FD);

		cpu_irq_ctx_leave(0x01FA);                    // matches no recorded frame

		check(cpu_irq_depth() == 1,

		      "a return matching no frame leaves the depth alone");

		check(cpu_in_interrupt(),

		      "so a live handler is never reported as finished");

		cpu_irq_ctx_leave(0x01FD);                    // the real balanced return

		check(cpu_irq_depth() == 0, "and the real return still closes it");

	}

	if (failures) {

		printf("\nFAILED (%d failures)\n", failures);

		return 1;

	}

	printf("\nPASSED (0 failures)\n");

	return 0;

}