Runtime Structure of Stack-based Languages (C3)

C3

New Features

Direct Recursion - call themselves recursively
Indirect Recursion - call one another recursively
Ability to return values ( act like functions)

C3 Example - Factorial

Mutual Recursion

Requires program to be patterned after
- A's declaration (i.e. A's header)
- B's definition (i.e. B's header and body)
- A's definition

Effect of Introducing Recursion

Do not know at translation time how many instances of each routine will be needed during execution
- Different activations of a given routine will use the same code segment
- Different activations of a given routine will use different activation records
The compiler can bind each variable to an offset within a routine's activation record at translation time
but further binding to an absolute address in D must be done at execution time.
The effect of this:
- Use cell at address 0 in D to store Base Address of currently executing unit
- D[0] is referred to as CURRENT
When the current instance of a unit terminates
- Activation record is no longer needed
- No other units can access its local environment
- Semantic rules require a fresh activation record be allocated for a future invocation
- We can free the D space used by a terminated unit and make it available for future activation records.
The effect of this:
- We can allocate storage for activation records using a last-in/first-out (LIFO)
- D is organized like a stack (ABC example)
To make return from a unit activation possible
- Return Pointer is needed
- Base address of caller's activation record is needed
The effect of this:
- The cell at offset 0 of an activation record contains the return pointer
- The cell at offset 1 of an activation record contains a pointer to the base address of caller's activation record
  - Referred to as Dynamic Link
  - Chain of dynamic links originating in currently activated unit is called Dynamic Chain
To manage SIMPLESEM's D storage as a stack:
- Need to know at runtime the address of first free memory cell on the stack
- Memory cell at address 1 in D holds this value called FREE
To allow a routine to return a value we need memory space for that value
- The returned value must be saved in the caller's activation record
- When a function routine is called, the caller's activation record is extended to hold the return value

Semantics of a Routine call specified by SIMPLESEM

Routine call	This code is in the caller
set 1, D[1] +1	allocate space on the stack for the return value (assume one cell needed) this step adds one to the value of FREE
set D[1], ip + 4	set the value of the return pointer in the callee's activation record. The 4 is added to ip because 4 more instructions are needed to complete the call. this step stores the return pointer in the cell at offset 0 of the callee's activation record, though technically it has not been allocated yet. We store it at the cell pointed to by FREE.
set D[1]+1, D[0]	set the dynamic link of the callee's activation record to point to the caller's activation record this step stores the value, CURRENT, in the cell at offset 1 of the callee's activation record, technically not allocated yet
set 0, D[1]	Set CURRENT to reflect the address of the currently executing activation record. this step stores the value FREE in address 0 of D
set 1, D[1] + AR	Allocates space for the currently executing activation record by setting the value of FREE. AR is the size of the callee's activation record.
jump start_addr	start_addr is an address in C storage where the first instruction of the callee's code is stored

Return from Routine	This code is in the callee
set 1, D[0]	set FREE ( deallocates current activation record by setting value of FREE to CURRENT
set 0, D[D0]+1]	set CURRENT ( D[0]+1 represents cell where dynamic link to caller's base address is stored)
jump D[D[1]]	jump to stored_return_pointer (D[1] represents the address of the memory cell at offset 0 of the callee's activation record; which contains the return_pointer)

Example - Code for C3 Program in Figure 2.17

D-Store Snapshots

assume main reads an input value of 3
immediately after the first call to fact()
at the return point from the third activation of fact()

Assumptions

ip is set to 0 prior to SIMPLESEM start
FREE is initialized based on memory needed for any global variables and main's local variables, if any.