Subroutines & the Stack

assembly1-6 ended with a forward pointer: longer jumps rely on JMP, "the same mechanism assembly1-7 uses to implement RET." This chapter makes good on that. You'll see how LC-3 calls and returns from reusable blocks of code, why a single register isn't enough once calls start nesting, and how to build a stack entirely out of ordinary instructions — because unlike some real chips this course will eventually meet, LC-3 doesn't give you one for free.

JSR / JSRR — Calling a Subroutine

JSR ("Jump to Subroutine") does two things in one instruction: it saves the address of the instruction right after itself into R7 — the return address — and then jumps to the subroutine, using the same PC-relative idea as BR, just with a wider offset:

Notice the offset here is 11 bits, not the 9 bits BR and LD use — LC-3 gives subroutine calls roughly four times the reach of a regular branch, since a subroutine is often placed much farther away in a program than a nearby loop target.

JSRR does the identical "save R7, then jump" job, but computes its target from a base register instead of a PC-relative offset — useful when the subroutine's address isn't known until runtime:

JSR  MYSUB     ; R7 <- return address; PC <- PC-relative target
JSRR R3        ; R7 <- return address; PC <- value in R3

RET — Returning from a Subroutine

RET is, at the bit level, nothing more than JMP R7 — LC-3's specification doesn't even give it a separate opcode. JMP jumps unconditionally to whatever address sits in a chosen base register:

Set BaseR to 111 (R7) and you get exactly RET — jump to whatever address JSR/JSRR most recently saved there. The two instructions are a matched pair by convention, not by any special hardware connection between them: JSR happens to write R7, and RET happens to be the specific case of JMP that reads it back.

Why Nested Calls Need a Stack

R7 holds exactly one return address at a time. That's fine for a single, non-nested call — but consider subroutine A calling subroutine B, where B itself calls a third subroutine:

A:  ...
    JSR B        ; R7 <- "return to A", PC <- B
    ...

B:  ...
    JSR C        ; R7 <- "return to B" — OVERWRITES A's return address!
    ...
    RET           ; jumps using R7 — but R7 no longer points back to A

The instant B's own JSR C runs, it overwrites R7 with B's return address, permanently destroying the return address A was counting on. By the time B's RET eventually runs, R7 correctly returns to A's caller-side location — but only because C's own return already restored it along the way, which only works by luck of ordering, not by design. A single shared register simply cannot hold more than one pending return address, and nested calls need more than one.

LC-3 Has No Dedicated Stack Pointer — You Build the Stack Yourself

This is exactly the kind of problem a hardware stack — a last-in-first-out storage structure with a dedicated stack-pointer register the CPU manages automatically — is built to solve. LC-3 deliberately doesn't provide one. There's no register reserved by the hardware for this purpose, and no dedicated PUSH/POP instructions. By convention, LC-3 programs simply dedicate one general-purpose register — commonly R6 — to act as a software-maintained stack pointer, and build push/pop behavior out of instructions you already know:

; PUSH R0 onto the stack (stack conventionally grows downward)
ADD R6, R6, #-1   ; move the stack pointer down one slot
STR R0, R6, #0    ; store R0 at the new top-of-stack address

; POP into R0
LDR R0, R6, #0    ; read the value currently at top-of-stack
ADD R6, R6, #1    ; move the stack pointer back up

Both sequences lean directly on assembly1-3's base+offset addressing mode (STR/LDR with R6 as the base) and assembly1-4's load/store discipline — there's nothing new here mechanically, just a convention for how to use what you already have.

A Full Calling Convention — Saving R7 Around a Nested Call

With a working stack, A can safely call B, and B can safely call C, by pushing R7 before making its own nested call and popping it back right after:

A:      ...
        JSR B
        ...

B:      ; save R7 before B makes its own nested call
        ADD R6, R6, #-1
        STR R7, R6, #0

        JSR C          ; safe now — B's own return address is preserved on the stack

        ; restore R7 before returning to A
        LDR R7, R6, #0
        ADD R6, R6, #1
        RET              ; now correctly returns to A

This push-before-call, pop-before-return pattern is the actual calling convention that makes nesting safe to any depth — every subroutine that itself calls another subroutine follows the same rule.

Hands-On Exercises