Memory, the Stack & Calling Convention

Registers are fast but few — only 32. Real programs need to store far more, and to call functions that call other functions. For that we need memory, the stack, and a shared rulebook called the calling convention. This is the last ISA concept before Day 6's assembly, and it's the one that makes "functions" actually work.

1. Memory is just a giant numbered shelf

Forget anything complicated. Memory is one enormous array of bytes, and every byte has a number — its address. In RV32, addresses are 32 bits, so there are up to 4 GB of byte-slots (2³² of them). To use memory you give an address and either read or write — exactly the load/store instructions from Day 4.

Two details that bite beginners

• Little-endian — a 32-bit word is stored with its least-significant byte at the lowest address. It's a convention; just know RISC-V uses it.
• Alignment — a 32-bit word normally sits at an address that's a multiple of 4 (a half-word at a multiple of 2). Aligned accesses are simplest for the hardware.

2. The memory map

Memory isn't a free-for-all; a program divides its address space into regions. Roughly, from low addresses up:

• Text — your program's instructions.
• Data — global variables.
• Heap — dynamically allocated memory (grows up).
• Stack — function scratch space (grows down).

3. The stack — a pile you push and pop

The stack is a special memory region used like a stack of plates: last in, first out. The register sp (x2) always points to the top of the stack. Two surprises for beginners:

• The stack grows downward — pushing makes sp smaller.
• There's no "push" instruction. You push by hand: subtract from sp, then store; pop by loading, then adding back.

# Push two registers, then pop them back (stack grows DOWN)
        addi sp, sp, -8     # make room for 2 words (push)
        sw   ra, 4(sp)      # save ra  on the stack
        sw   s0, 0(sp)      # save s0  on the stack
        # ... do work that may clobber ra and s0 ...
        lw   s0, 0(sp)      # restore s0  (pop)
        lw   ra, 4(sp)      # restore ra
        addi sp, sp, 8      # free the space

4. Why the stack exists: nested function calls

Here's the problem it solves. From Day 4, jal calls a function and saves the return address in ra. But if that function calls another function, the second jal overwrites ra — and now the first function has forgotten where to return! The fix: each function saves ra on the stack before making nested calls, then restores it. The stack lets calls nest arbitrarily deep, each remembering its own return address.

5. The calling convention (the shared rulebook)

For functions written by different people (or compilers) to work together, everyone must agree on how arguments are passed, where results go, and which registers must be preserved. That agreement is the calling convention (RISC-V's is similar to ARM's AAPCS). Using the ABI names from Day 2:

• Caller-saved (t, a, ra) — a called function may freely overwrite these. If the caller needs them afterward, the caller saves them first.
• Callee-saved (s0–s11, sp) — the called function must leave them exactly as it found them, so it pushes any it uses and pops them before returning.

6. A real function: prologue & epilogue

Putting it together: a function that calls another function follows a standard pattern — a prologue (save ra and any s-registers), the body, and an epilogue (restore, return):

# int outer(int n) { return inner(n) + 1; }
outer:
        addi sp, sp, -16    # PROLOGUE: make a stack frame
        sw   ra, 12(sp)     #   save return address (we'll call -> ra clobbered)
        sw   s0, 8(sp)      #   save a callee-saved reg we want to use
        mv   s0, a0         #   keep n in s0 across the call

        # a0 already holds n -> call inner(n)
        jal  ra, inner      #   inner's result comes back in a0

        addi a0, a0, 1      #   return value = inner(n) + 1

        lw   s0, 8(sp)      # EPILOGUE: restore
        lw   ra, 12(sp)     #   restore return address
        addi sp, sp, 16     #   pop the frame
        ret                 #   jalr x0, 0(ra)  -> return to caller

The frame on the stack (16 bytes here) is this function's private scratch space. Skip saving ra and a non-leaf function returns to the wrong place — the single most common beginner bug. (A leaf function that calls nothing can skip the frame and just ret.)

Quick check

1. Which direction does the stack grow, and what does sp point to?
2. How do you "push" a register if there's no push instruction?
3. Why must a function that calls another function save ra?
4. Which registers carry arguments and the return value?

FAQ

← Back to the full roadmap  ·  Open the Verilog simulator →