Run-Time Environments

CS308 Compiler Theory 1

 Run-Time Environments
• How do we allocate the space for the generated target code and the data
object of our source programs?
• The places of the data objects that can be determined at compile time
will be allocated statically.
• But the places for the some of data objects will be allocated at run-time.
• The allocation and de-allocation of the data objects is managed by the
run-time support package.
– run-time support package is loaded together with the generate target code.
– the structure of the run-time support package depends on the semantics of the programming
language (especially the semantics of procedures in that language).
• Each execution of a procedure is called as activation of that procedure.

CS308 Compiler Theory 2

 Static vs. Dynamic Allocation
• Static: Compile time, Dynamic: Runtime allocation
• Many compilers use some combination of following
– Stack storage: for local variables, parameters and so on
– Heap storage: Data that may outlive the call to the procedure that created it
• Stack allocation is a valid allocation for procedures since procedure
calls are nested
 Procedure Activations
• An execution of a procedure starts at the beginning of the procedure
body;
• When the procedure is completed, it returns the control to the point
immediately after the place where that procedure is called.
• Each execution of a procedure is called as its activation.
• Lifetime of an activation of a procedure is the sequence of the steps
between the first and the last steps in the execution of that procedure
(including the other procedures called by that procedure).
• If a and b are procedure activations, then their lifetimes are either non-
overlapping or are nested.
• If a procedure is recursive, a new activation can begin before an earlier
activation of the same procedure has ended.

CS308 Compiler Theory 4

 Activation Tree
• We can use a tree (called activation tree) to show the way control
enters and leaves activations.

• In an activation tree:
– Each node represents an activation of a procedure.
– The root represents the activation of the main program.
– The node a is a parent of the node b iff the control flows from a to b.
– The node a is left to the node b iff the lifetime of a occurs before the
lifetime of b.

CS308 Compiler Theory 5

 Activation Tree (cont.)
program main; enter main
procedure s; enter p
begin ... end; enter q
procedure p; exit q
procedure q; enter s
begin ... end; exit s
begin q; s; end; exit p
begin p; s; end; enter s
exit s
exit main

A Nested Structure

CS308 Compiler Theory 6

 Activation Tree (cont.)

main

p s

q s

CS308 Compiler Theory 7

 Control Stack
• The flow of the control in a program corresponds to a depth-first
traversal of the activation tree that:
– starts at the root,
– visits a node before its children, and
– recursively visits children at each node in a left-to-right order.
• A stack (called control stack) can be used to keep track of live
procedure activations.
– An activation record is pushed onto the control stack as the
activation starts.
– That activation record is popped when that activation ends.
• When node n is at the top of the control stack, the stack contains the
nodes along the path from n to the root.
CS308 Compiler Theory 8
 Variable Scopes
• The same variable name can be used in the different parts of the
program.
• The scope rules of the language determine which declaration of a name
applies when the name appears in the program.
• An occurrence of a variable (a name) is:
– local: If that occurrence is in the same procedure in which that name is declared.
– non-local: Otherwise (ie. it is declared outside of that procedure)

procedure p;
var b:real;
procedure p;
var a: integer; a is local
begin a := 1; b := 2; end; b is non-local
begin ... end;

CS308 Compiler Theory 9

 Run-Time Storage Organization
Code
Memory locations for code are
determined at compile time.

Static Data Locations of static data can also be

determined at compile time.
Stack
Data objects allocated at run-time.
(Activation Records)

Other dynamically allocated data

Heap
objects at run-time. (For example,
malloc area in C).

CS308 Compiler Theory 10

 Activation Records
• Information needed by a single execution of a procedure is managed
using a contiguous block of storage called activation record.
• An activation record is allocated when a procedure is entered, and it is
de-allocated when that procedure exited.
• Size of each field can be determined at compile time (Although actual
location of the activation record is determined at run-time).
– Except that if the procedure has a local variable and its size depends
on a parameter, its size is determined at the run time.

CS308 Compiler Theory 11

 Activation Records (cont.)
The returned value of the called procedure is returned
return value in this field to the calling procedure. In practice, we may
use a machine register for the return value.
actual parameters The field for actual parameters is used by the calling
procedure to supply parameters to the called procedure.
optional control link The optional control link points to the activation record
of the caller.
optional access link
The optional access link is used to refer to nonlocal data
held in other activation records.
saved machine status
The field for saved machine status holds information about
the state of the machine before the procedure is called.
local data
The field of local data holds data that local to an execution
temporaries of a procedure..
Temporay variables is stored in the field of temporaries.

CS308 Compiler Theory 12

 Activation records
• Procedure calls and returns are usaully managed by a run-time stack
called the control stack.
• Each live activation has an activation record (sometimes called a frame)
• The root of activation tree is at the bottom of the stack
• The current execution path specifies the content of the stack with the
last activation has record in the top of the stack.
 Activation Records (Ex1)
stack
main
program main;
procedure p;
var a:real;
procedure q;
var b:integer;
begin ... end; p
begin q; end;
procedure s; a:
var c:integer;
begin ... end; main
begin p; s; end; q

p s b:

CS308 Compiler Theory 14

 Activation Records for Recursive Procedures
program main;
main
procedure p;
function q(a:integer):integer;
begin
if (a=1) then q:=1; p
else q:=a+q(a-1);
end;
begin q(3); end; q(3)
begin p; end; a: 3

q(2)
a:2

q(1)
a:1

CS308 Compiler Theory 15

 Creation of An Activation Record
• Who allocates an activation record of a procedure?
– Some part of the activation record of a procedure is created by that
procedure immediately after that procedure is entered.
– Some part is created by the caller of that procedure before that
procedure is entered.

• Who deallocates?
– Callee de-allocates the part allocated by Callee.
– Caller de-allocates the part allocated by Caller.

CS308 Compiler Theory 16

 Creation of An Activation Record (cont.)
return value Caller’s Activation Record
actual parameters
optional control link
optional access link
saved machine status
local data
Caller’s Responsibility
temporaries
return value Callee’s Activation Record
actual parameters
optional control link
optional access link
saved machine status
local data
Callee’s Responsibility
temporaries
CS308 Compiler Theory 17
 Variable Length Data
actual parameters
return value
Variable length data is allocated after
optional control link
temporaries, and there is a link from
optional access link
local data to that array.
saved machine status
local data
pointer a
pointer b

temporaries

array a

array b

CS308 Compiler Theory 18

 Dangling Reference
• Whenever a storage is de-allocated, the problem of dangling references
may accur.

main () {
int *p;
p = dangle();
}
int *dangle*() {
int i=2;
return &i;
}

CS308 Compiler Theory 19

 Designing Calling Sequences
• Values communicated between caller and callee are generally placed at
the beginning of callee’s activation record
• Fixed-length items: are generally placed at the middle
• Items whose size may not be known early enough: are placed at the end
of activation record
• We must locate the top-of-stack pointer judiciously: a common
approach is to have it point to the end of fixed length fields.
Division of tasks between caller and callee
 calling sequence
• The caller evaluates the actual parameters
• The caller stores a return address and the old value of top-sp into the
callee's activation record.
• The callee saves the register values and other status information.
• The callee initializes its local data and begins execution.
 corresponding return sequence
• The callee places the return value next to the parameters
• Using information in the machine-status field, the callee restores top-sp
and other registers, and then branches to the return address that the
caller placed in the status field.
• Although top-sp has been decremented, the caller knows where the
return value is, relative to the current value of top-sp; the caller
therefore may use that value.
Access to dynamically allocated arrays