run time

Run-Time EnvironmentsRun Time Environments

TCS-502Compiler Design

P K Singh M M M E C GKP RTSM-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 beThe 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 of 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.p f p


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.

Lif ti f ti ti f d i th f th t b t th• 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• If a procedure is recursive, a new activation can begin before an earlier activation of the same procedure has ended.


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.

h d i f h d b iff h l fl f– The node a is a parent of the node b iff the control flows from a to b.

– The node a is left to to the node b iff the lifetime of a occursThe node a is left to to the node b iff the lifetime of a occurs before the lifetime of b.


Activation Tree (cont.)

program main; enter mainprocedure s; enter pp pbegin ... end; enter q

procedure p; exit qdprocedure q; enter s

begin ... end; exit sbegin q; s; end; exit pbegin q; s; end; exit p

begin p; s; end; enter sexit sexit main

A Nested Structure


A Nested Structure

Activation Tree (cont.)

mainmain

p sp s

q sq


Procedure Activationsprogram sort(input, output)

var a : array [0..10] of integer;procedure readarray;

var i : integer;b i

Activations:begin sortbegin

for i := 1 to 9 do read(a[i])end;

function partition(y, z : integer) : integervar i, j, x, v : integer;

begin sortenter readarrayleave readarrayenter quicksort(1,9)enter partition(1,9)

begin …end

procedure quicksort(m, n : integer);var i : integer;begin

e te pa t t o ( ,9)leave partition(1,9)enter quicksort(1,3)…leave quicksort(1,3)begin

if (n > m) then begini := partition(m, n);quicksort(m, i - 1);quicksort(i + 1, n)

q ( , )enter quicksort(5,9)…leave quicksort(5,9)leave quicksort(1,9)

endend;

begina[0] := -9999; a[10] := 9999;readarray;

q ( , )end sort.


readarray;quicksort(1, 9)

end.

Activation TreesActivation Trees

ss

q(1,9)r

q(1,3)

p(1,3) q(1,0) q(2,3)

p(1,9) q(5,9)

p(5,9) q(5,5) q(7,9)

q(2,1)p(2,3) q(3,3) q(7,7)p(7,9) q(9,9)


Control Stack• The flow of the control in a program corresponds to a depth‐• 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 an 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– 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


contains the nodes along the path from n to the root.

Control Stack

Activations:ControlActivation tree:s

(1 9)r

Activations:begin sortenter readarrayleave readarray

Controlstack:

Activation tree:

sq(1,9)

q(1,3)p(1,9)

r enter quicksort(1,9)enter partition(1,9)leave partition(1,9)enter quicksort(1,3)

q(1,9)

q(1,3)

q(2,3)

p(1,3) q(1,0) q(2,3)enter partition(1,3)leave partition(1,3)enter quicksort(1,0)leave quicksort(1,0)

(2 3)enter quicksort(2,3)…


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• 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;procedure p;

var a: integer; a is localbegin a := 1; b := 2; end; b is non-local

begin end;


begin ... end;

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.

StackData objects allocated at run‐time.(Activation Records)(Activation Records)

Other dynamically allocated data

Heap

Other dynamically allocated dataobjects at run‐time. (For example,malloc area in C).


Activation Records• Information needed by a single execution of a procedure is managed using a contiguous block of storage called

i i dactivation 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 timeSize 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.


p

Activation Records (cont.)

return valueThe returned value of the called procedure is returned in this field to the calling procedure. In practice, we mayuse a machine register for the return value.

actual parameters

optional control link

g

The field for actual parameters is used by the calling procedure to supply parameters to the called procedure.

Th i l l li k i h i i doptional control link

optional access link

The optional control link points to the activation record of the caller.

The optional access link is used to refer to nonlocal datah ld i h i i d

saved machine status

local data

held in other activation records.

The field for saved machine status holds information about the state of the machine before the procedure is called.

temporariesThe field of local data holds data that local to an executionof a procedure..

Temporay variables is stored in the field of temporaries.


Temporay variables is stored in the field of temporaries.

Activation Records (Ex1)

program main;procedure p;

mainstack

procedure p;var a:real;procedure q;var b:integer;

pbegin ... end;begin q; end;

procedure s;var c:integer;

p

a:var c:integer;begin ... end;

begin p; s; end; qmain

pb:

p

q

s


q

Activation Records for Recursive Proceduresprogram main;procedure p;function q(a:integer):integer;

mainfunction q(a:integer):integer;beginif (a=1) then q:=1;else q:=a+q(a-1);

p

end;begin q(3); end;

begin p; end;q(3)

a: 3

q(2)a:2

q(1)a:1


Creation of An Activation Record

• Who allocates an activation record of a procedure?

– Some part of the activation record of a procedure is created bySome 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?• Who deallocates?

– Callee de‐allocates the part allocated by Callee.

– Caller de‐allocates the part allocated by Caller.Caller de allocates the part allocated by Caller.


Creation of An Activation Record (cont.)return value

actual parametersti l t l li k

Caller’s Activation Record

optional control linkoptional access link

saved machine statuslocal data

temporaries

return value

Caller’s Responsibility

C ll ’ A i i R dreturn valueactual parameters

optional control link

Callee’s Activation Record

optional access link

saved machine statuslocal data

Callee’s Responsibility


temporaries

Variable Length Datareturn value

actual parametersti l t l li k

Variable length data is allocated afteroptional control linkoptional access link

saved machine status

temporaries, and there is a link to fromlocal data to that array.

local datapointer apointer b

temporaries

array a

array b


Dangling Reference

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

main () {i *int *p;p = dangle();

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

}


Access to Nonlocal Names

• Scope rules of a language determine the treatment of references to nonlocal names.

• Scope Rules:

– Lexical Scope (Static Scope)

• Determines the declaration that applies to a name by examining the program text alone at compile‐time.

• Most closely nested rule is used• Most‐closely nested rule is used.

• Pascal, C, ..

– Dynamic ScopeDynamic Scope

• Determines the declaration that applies to a name at run‐time.

• Lisp, APL, ...


Lexical Scope

• The scope of a declaration in a block‐structured language is given by the mostly closed rule.y y

• Each procedure (block) will have its own activation record.– procedure

begin end blocks– begin‐end blocks • (treated same as procedure without creating most part of its activation record)

• A procedure may access to a nonlocal name using:

– access links in activation records, or

– displays (an efficient way to access to nonlocal names)


Access Linksprogram main;var a:int;procedure p;

mainaccess linkp p;

var d:int;begin a:=1; end;

procedure q(i:int);

a:q(1)

access linkvar b:int;procedure s;

var c:int;

i,b:q(0)

access link

AccessLinks

begin p; end;begin

if (i<>0) then q(i-1)else s;

i,b:s

access linkelse s;end;

begin q(1); end;

c:p

access link


access linkd:

Access Links

s s s s

a x

q(1,9)

a x

q(1,9)

a x

q(1,9)

a x

q(1,9)q(1,9)accessk v

q(1,9)accessk v

q(1 3)

q(1,9)accessk v

q(1 3)

q(1,9)accessk v

q(1 3)q(1,3)accessk v

q(1,3)accessk v

p(1 3)

q(1,3)accessk v

p(1 3)p(1,3)accessi j

p(1,3)accessi j

e(1 3)

24

e(1,3)access

Procedure Parameters

program main;procedure p(procedure a);

mainaccess link

procedure p(procedure a);begin a; end;

procedure q;procedure s;

qaccess linkprocedure s;

begin ... end;begin p(s) end;

begin q; end;

access link

pli k

g qaccess link

sAccess links must be passed with access link

pprocedure parameters.


Displays

• An array of pointers to activation records can be used to accessactivation recordsactivation records.

• This array is called as displays.• For each level, there will be an array entry.

1:

2

Current activation record at level 1

C t ti ti d t l l 22:

3:

Current activation record at level 2Current activation record at level 3


Accessing Nonlocal Variables

program main;var a:int;

mainaccess link

addrC := offsetC(currAR)t := *currARvar a:int;

procedure p;var b:int;begin q; end;

a:

p

addrB := offsetB(t)t := *taddrA := offsetA(t)begin q; end;

procedure q();var c:int;begin

paccess linkb:

ADD addrA,addrB,addrC

gc:=a+b;

end;begin p; end;

qaccess linkc:


Accessing Nonlocal Variables using Display

program main;var a:int;

mainaccess link

addrC := offsetC(D[3])addrB := offsetB(D[2])

D[1]var a:int;procedure p;

var b:int;begin q; end;

a:

p

addrB : offsetB(D[2])addrA := offsetA(D[1])ADD addrA,addrB,addrC

begin q; end;procedure q();

var c:int;begin

paccess linkb:

D[2]

gc:=a+b;

end;begin p; end;

qaccess link

D[3]

c:


Parameter Passing Methods

• Call-by-value• Call-by-referenceCall by reference• Call-by-name (used by Algol)


Parameter Passing Methods

• Call-by-value: evaluate actual parameters and enter r-values in activation record

• Call-by-reference: enter pointer to the storage of the actual parameter

• Copy-restore (value-result): evaluate actual parameters and enter r-values, after the call copy r-values of formal parameters into actualsparameters into actuals

• Call-by-name: use a form of in-line code expansion (thunk) to evaluate parameterseva uate pa a ete s

30

SOME OTHER ISSUES

• Symbol Tables hold scope information.

• Dynamic Scope:– uses control link (similar to access links)

• Dynamic Storage Allocation (Heap Management)different allocation techniques– different allocation techniques


run time

Education

p f p p

p s end

end end

e c gkp rtsm

root p

end exit s

mainmain p sp s q sq

leave quicksort1