// Commander X16 Emulator — interrupt context tracking. See irq_ctx.h.

#include "irq_ctx.h"

#include <string.h>

// Past CPU_IRQ_CTX_MAX (see irq_ctx.h) the depth still counts, but there is no

// room to record which stack pointer each of those entries had. A return can

// therefore only take them off one at a time, since it has nothing to match

// against; an entry can still clear them wholesale, by judging them against the

// deepest frame that does have a recorded pointer.

// Nesting beyond this is a runaway loop, and the exact number stops meaning

// anything. This is reachable, not merely defensive. Once the depth passes the

// array, frames[] stops being written, so the pointer everything above is

// judged against -- frames[CPU_IRQ_CTX_MAX - 1] -- is frozen. Interrupts taken

// strictly below it therefore add a level every time with nothing able to

// retire any of them, and they need not even keep descending. A handler that

// BRKs on entry would climb until a signed counter overflowed, which is

// undefined behaviour rather than merely a wrong answer.

#define CPU_IRQ_DEPTH_MAX 0x10000

struct irq_frame {

	uint8_t  vector;

	uint32_t from_pc;  // 24-bit: the program bank matters on the 65816

	uint16_t sp;       // stack pointer before the interrupt pushed anything

};

static struct irq_frame frames[CPU_IRQ_CTX_MAX];

static int              depth;

static uint32_t         taken;

static uint8_t          last_vector;

static bool             just_entered;

void

cpu_irq_ctx_enter(int vector, uint32_t from_pc, uint16_t sp)

{

	taken++;

	last_vector  = (uint8_t)vector;

	just_entered = true;

	// Retire frames the stack has already passed. Nesting drives the pointer

	// DOWN, so open frames must be strictly decreasing in sp; one recorded at or

	// below where this interrupt is being taken cannot still be live, because

	// the stack has risen back above it.

	//

	// This is what clears a handler that left without an RTI -- a BRK reaching a

	// warm start, which resets the stack instead of returning. Nothing on the

	// return path can do it: the abandoned frame has no matching return, so it

	// would sit there for the rest of the session, and every further BRK would

	// add another.

	//

	// Judged here rather than on return because entry is the moment the stack

	// level is known to be real. A return only tells us where the stack ended

	// up, which a handler is free to fake.

	//

	// Levels above the array have no recorded pointer of their own, so they are

	// judged by the deepest one that has: an interrupt taken at or above

	// frames[CPU_IRQ_CTX_MAX - 1] proves everything from there up is gone,

	// unrecorded levels included. Skipping them instead would strand every frame

	// underneath as soon as the depth passed the array, which is the same

	// permanent staleness this rule exists to prevent.

	while (depth > 0) {

		const int top = (depth < CPU_IRQ_CTX_MAX ? depth : CPU_IRQ_CTX_MAX) - 1;

		if (frames[top].sp > sp)

			break;

		depth = top;

	}

	if (depth >= 0 && depth < CPU_IRQ_CTX_MAX) {

		frames[depth].vector  = (uint8_t)vector;

		frames[depth].from_pc = from_pc;

		frames[depth].sp      = sp;

	}

	if (depth < CPU_IRQ_DEPTH_MAX)

		depth++;

}

void

cpu_irq_ctx_leave(uint16_t sp)

{

	// An RTI outside anything we saw entered is not an error -- an interrupt

	// could already have been in flight when the emulator started, or a handler

	// could have been entered before a reset. There is simply nothing to pop.

	if (depth <= 0) {

		depth = 0;

		return;

	}

	// Nothing was recorded for entries above the array, so they come off singly.

	if (depth > CPU_IRQ_CTX_MAX) {

		depth--;

		return;

	}

	// A balanced RTI restores the stack pointer to exactly what it was when the

	// interrupt was taken, so the frame being returned from is the one whose

	// recorded pointer equals this one. Matching exactly, rather than measuring

	// how far the stack has moved, is what keeps this honest: a distance test

	// cannot tell a genuine unwind from a stack that wrapped, and guessing

	// wrong collapses the depth to zero while a handler is still running.

	//

	// Retirement on entry keeps the recorded pointers strictly decreasing, so

	// at most one frame can match and the search direction does not matter.

	// Searching outwards also handles a handler that returns past its own

	// frame, unwinding several at once.

	for (int i = depth - 1; i >= 0; i--) {

		if (frames[i].sp == sp) {

			depth = i;

			return;

		}

	}

	// No frame matches: a handler that rewrote the stack, or an RTI for an

	// interrupt taken before this was watching. Leave the depth alone rather

	// than popping a frame that may still be live -- a handler can fabricate a

	// frame and RTI to itself with three pushes, which lands on no recorded

	// pointer at all while the real interrupt is still running.

	//

	// So this errs high, and stays there until a return matches an outer frame.

	// Too high corrects itself at the next matching return; too low would claim

	// no interrupt is running while one is, and a debugger confidently

	// reporting that is worse than one reporting a stale depth.

}

void

cpu_irq_ctx_reset(void)

{

	depth        = 0;

	taken        = 0;

	last_vector  = 0;

	just_entered = false;

	memset(frames, 0, sizeof(frames));

}

bool

cpu_in_interrupt(void)

{

	return depth > 0;

}

int

cpu_irq_depth(void)

{

	return depth;

}

uint32_t

cpu_irq_count(void)

{

	return taken;

}

int

cpu_irq_last_vector(void)

{

	return last_vector;

}

uint32_t

cpu_irq_return_pc(void)

{

	if (depth <= 0)

		return 0;

	const int top = depth - 1;

	return top < CPU_IRQ_CTX_MAX ? frames[top].from_pc : 0;

}

bool

cpu_irq_take_entered_flag(void)

{

	const bool v = just_entered;

	just_entered = false;

	return v;

}