Part 5: What is a stack and how does it work?

What this lecture covers

The previous video's "Hello world" program worked but was long and repetitive. This lecture first cleans it up by moving the repeated LCD-instruction and print-character code into subroutines called with JSR and exited with RTS, dramatically shrinking the assembled machine code. It's a practical lesson in how assembly code size directly maps to the compiled program.

After reprogramming the EEPROM, the refactored program fails to print anything. The bulk of the lecture is a single-step debugging session with the Arduino bus monitor that traces exactly what JSR and RTS do internally, leading to the discovery that the 6502's call stack lives at a fixed memory range the breadboard computer doesn't actually have any RAM for yet.

Key ideas

• Subroutines (JSR/RTS): JSR jumps to a subroutine and saves a return address; RTS returns to the instruction after the original call, letting repeated code be written once and reused.
• The 6502 stack: a fixed 256-byte region from $0100 to $01FF used to store return addresses (and optionally other temporary data) via push and pull operations.
• Stack pointer: an 8-bit CPU register that always points somewhere within page $01xx; it decrements when data is pushed and increments when data is pulled.
• Stack pointer initialization: the stack pointer starts at an arbitrary value on power-up, so programs should explicitly set it (commonly to $FF) using LDX #$FF followed by TXS, since there is no direct "load stack pointer" instruction.
• Push/pull for register preservation: values can be temporarily saved on the stack (for example the accumulator) with a push, then restored with a pull, as long as pushes and pulls are correctly paired.
• Stack overflow: pushing more data than the 256-byte stack can hold causes the stack pointer to wrap around and overwrite earlier data, corrupting saved return addresses.
• Missing RAM as root cause: the program fails because nothing in the circuit responds to addresses in the $0100-$01FF range, so writes there go nowhere and later reads return meaningless data.

Walkthrough

Factoring repeated code into subroutines (0:00)

The lecture moves the block of code that sends an instruction to the LCD into a subroutine labeled lcd_instruction, replacing each repeated copy in the main program with a single JSR lcd_instruction line ending in RTS. The same refactor is applied to the code that prints a character, replacing dozens of duplicated lines with JSR print_character calls.

Comparing assembled code size (3:01)

Reassembling the refactored program produces a much smaller binary than the original "Hello world" version, illustrating that assembly source maps directly to machine code size, at the minor cost of extra clock cycles spent jumping to and returning from subroutines.

The program stops working after reprogramming (4:02)

After writing the smaller program to the EEPROM and resetting the computer, the display fails to print anything, prompting the lecture to reconnect the Arduino bus monitor from earlier videos to trace address, data, read/write, and clock signals cycle by cycle.

Tracing a JSR call and its hidden writes (7:05)

Single-stepping through a JSR to the LCD-instruction subroutine reveals two unexpected write cycles to addresses $0124 and $0123 before the jump completes. These turn out to be the processor saving the return address ($800E) so it can find its way back after the subroutine finishes.

Discovering the broken RTS (9:07)

When the subroutine reaches RTS, the processor tries to read back the saved return address from $0123/$0124 but gets the wrong bytes, then jumps to a nonsensical address instead of returning correctly. The lecture identifies that nothing in the circuit is actually connected to those addresses, so both the earlier write and this read are effectively going nowhere.

Explaining the 6502's fixed stack region (15:16)

Referencing the datasheet, the lecture explains that addresses $0100 through $01FF are reserved as the stack, tracked by an 8-bit stack pointer that decrements on each push. It walks through how nested subroutine calls use the stack, how pushing and pulling the accumulator can preserve its value across a call, and why unbalanced pushes and pulls, or too many nested calls, can cause a stack overflow that corrupts saved return addresses.

Initializing the stack pointer (21:19)

Because the stack pointer starts at an arbitrary value on power-up, the lecture shows the standard fix: load the X register with $FF and transfer it to the stack pointer with TXS, ensuring the stack starts at the top of its 256-byte range.

Identifying the real fix needed (23:21)

The lecture concludes that subroutine calls cannot work correctly until the computer has actual RAM covering the $0100-$01FF stack region, and previews adding a RAM chip in the next video.

Before you watch

• Watch parts 1 through 4 first; this lecture assumes the VIA wiring, LCD instruction set, and Arduino bus-monitoring setup from those videos.
• Comfort reading hexadecimal addresses and following single-stepped bus traces is important for the debugging section.

Check your understanding

1. What does JSR do internally on the 6502, and why does it need somewhere to store a return address?
2. Why did the refactored program stop working even though the subroutine logic itself was correct?
3. What is a stack overflow on the 6502, and how could unbalanced pushes and pulls cause one?
4. Why does the lecture initialize the stack pointer to $FF using LDX/TXS instead of a direct load instruction?
5. What hardware change does the lecture say is needed before subroutine calls can work reliably?