Activation Records (Introduction) Mooly Sagiv html://msagiv/courses/wcc03.html Chapter 6.3.
1 Chapter 6 Runtime storage and Activation Records.
-
Upload
ronald-cole -
Category
Documents
-
view
216 -
download
0
Transcript of 1 Chapter 6 Runtime storage and Activation Records.
![Page 1: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/1.jpg)
1
Chapter 6
Runtime storage andActivation Records
![Page 2: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/2.jpg)
2
Outline Basic computer execution model run-time program layout activation record procedure linkage Frame in MiniJava
![Page 3: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/3.jpg)
3
Basic Execution Model MIPS as an example
» Intro to mips assembly» Programmed Intro To mips assembly.
CPU» ALU Unit» Registers» Control Unit
Memory» program» data
Memory
Registers
Control
ALU
![Page 4: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/4.jpg)
4
Arithmetic and Logic Unit Performs most of the data operations Has the form:
OP Rdest, Rsrc1, Rsrc2
Operations are:» Arithmetic operations (add, sub,
mulo [mult with overflow])» Logical operations (and, sll, srl)» Comparison operations (seq, sge,
slt [set to 1 if less than])
Memory
Registers
Control
ALU
![Page 5: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/5.jpg)
5
Arithmetic and Logic Unit Many arithmetic operations can cause
an exception» overflow and underflow
Can operate on different data types» 8, 16, 32 bits» signed and unsigned arithmetic» Floating-point operations
(separate ALU)» Instructions to convert between
formats (cvt.s.d)
Memory
Registers
Control
ALU
![Page 6: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/6.jpg)
6
Control Handles the instruction sequencing Executing instructions
» All instructions are in memory» Fetch the instruction pointed by the
PC and execute it» For general instructions, increment
the PC to point to the next location in memory
Memory
Registers ALU
Control
![Page 7: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/7.jpg)
7
Control Unconditional Branches
» Fetch the next instruction from a different location
» Unconditional jump to a given addressj label
» Unconditional jump to an address in a register jr rsrc
» To handle procedure calls, do an unconditional jump, but save the next address in the current stream in a register jal label [jump and link] jalr rsrc
Memory
Registers ALU
Control
![Page 8: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/8.jpg)
8
Control Conditional Branches
» Perform a test, if successful fetch instructions from a new address, otherwise fetch the next instruction
» Instructions are of the form: brelop Rsrc1, Rsrc2, label
» ‘relop’ is of the form: ‘’, ‘eq’, ‘ne’, ‘gt’, ‘ge’, ‘lt’, ‘le’
Memory
Registers ALU
Control
![Page 9: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/9.jpg)
9
Control Control transfer in special (rare)
cases» traps and exceptions» Mechanism
– Save the next(or current) instruction location
– find the address to jump to (from an exception vector)
– jump to that location
Memory
Registers ALU
Control
![Page 10: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/10.jpg)
10
Memory Flat Address Space
» composed of words» byte addressable
Need to store» Program» Local variables» Global variables and data» Stack» Heap
Memory
Registers ALU
Control
![Page 11: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/11.jpg)
11
Memory
Memory
Registers ALU
Control
Stack
Generated Code
HeapObjects
Arrays
locals(parameters)
![Page 12: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/12.jpg)
12
Registers Load/store architecture
» All operations are on register values» Need to bring data in-to/out-of registers
» la Rdest, address [load address]
» lw Rdest, address [load word]
» li, Rdest, imm [load imm]
» sw Rsrc, address [store word ]
» mv Rdest, Rsrc [ move ]
» address has the from value(R) Important for performance
» limited in number
ALU
Control
Memory
Registers
![Page 13: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/13.jpg)
13
Other interactions Other operations
» Input/Output» Privilege / secure operations» Handling special hardware
– TLBs, Caches etc.
Mostly via system calls » hand-coded in assembly» compiler can treat them as a normal
function call
ALU
Control
Memory
Registers
![Page 14: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/14.jpg)
14
Registers (of MIPS processors)
0 zero hard-wired to zero
1 at Reserved for asm
2 - 3 v0 - v1 expr. eval and return of results
4 - 7 a0 - a3 arguments 1 to 4
8-15 t0 - t7 caller saved temporary(save before call)
16 - 23 s0 - s724, 25 t8, t9 caller saved temporary
28 gp pointer to global area
29 sp stack pointer
30 fp frame pointer
31 ra return address
![Page 15: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/15.jpg)
15
Typical program layout Start of the stack Heap management
» free lists starting location in
the text segment
Stack
Text segment
HeapObjectsArrays
locals(parameters)
0x7fffffff
0x400000
Reserved
static Data segment
![Page 16: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/16.jpg)
16
Procedure call and Stack Frame
![Page 17: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/17.jpg)
17
Activations An invocation of procedure P is an activation of P
The lifetime of an activation of P is» All the steps to execute P» Including all the steps in procedures that P
calls
![Page 18: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/18.jpg)
18
Lifetimes of Variables The lifetime of a variable x is the portion of
execution in which x is defined
Note that» Lifetime is a dynamic (run-time) concept» Scope is a static concept
![Page 19: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/19.jpg)
19
Activation Trees When P calls Q, then Q returns before P does
» LIFO Stack
Lifetimes of procedure activations are properly nested
Activation lifetimes can be depicted as a tree
![Page 20: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/20.jpg)
20
ExampleClass Main {
void g() { return ; }
void f() { g() ; }
void m() { g(); f(); };
} m
fg
g
m enter
g enter
g return
f enter
g enter
g return
f return
m return
activation tree for m() Lifetime of invocations
![Page 21: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/21.jpg)
21
Example 2
Class Main {
int g() { return 1; };
int f(int x){
if( x == 0) return g(); else return f(x - 1); }
int m(){ return f(3) }
}
What is the activation tree for this example?
![Page 22: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/22.jpg)
22
Example 2m() enter
f(3) enter f(2) enter f(1) enter f(0) enter g()
enter g()
return f(0) return f(1) return f(2) returnf(3) return
m() return
m()
f(3)
f(2)
f(1)
g()
![Page 23: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/23.jpg)
23
Notes The activation tree depends on run-time behavior
The activation tree may be different for every program input
Since activations are properly nested, a stack can track currently active procedures
![Page 24: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/24.jpg)
24
ExampleClass Main {
g() { return; };
f() { g() };
m() { g(); f(); };
}m Stack
m
![Page 25: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/25.jpg)
25
ExampleClass Main {
g() { return; }
f(): Int { g() }
m() { g(); f(); }
} m
g
Stack
m
g
![Page 26: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/26.jpg)
26
ExampleClass Main {
g() { return }
f() { g() }
m() { g(); f(); }
}m
g f
Stack
m
f
![Page 27: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/27.jpg)
27
ExampleClass Main {
g() { return; }
f() { g(); }
m(){ g(); f(); }
} m
fg
g
Stack
m
f
g
![Page 28: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/28.jpg)
28
Revised Memory Layout
Low Address
High Address
Memory
Code
Stack
![Page 29: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/29.jpg)
29
Activation Records On many machine the stack starts at high-
addresses and grows towards lower addresses
The information needed to manage one procedure activation is called an activation record (AR) or (stack) frame
If procedure F calls G, then G’s activation record contains a mix of info about F and G.
![Page 30: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/30.jpg)
30
What is in G’s AR when F calls G?
F is “suspended” until G completes, at which point F resumes. G’s AR contains information needed to resume execution of F.
G’s AR may also contain:» Actual parameters to G (supplied by F)» G’s return value (needed by F)» Space for G’s local variables
![Page 31: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/31.jpg)
31
The Contents of a Typical AR for G
Space for G’s return value Actual parameters Pointer to the previous activation record
» The control link; points to AR of caller of G Machine status prior to calling G
» Contents of registers & program counter» Local variables
Other temporary values
![Page 32: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/32.jpg)
32
Example 2, Revisited
Class Main {
int g() { return 1; };
int f(int x) {if (x==0) return g();
else return f(x - 1); (**) };
void main() { f(3); (*)}
AR for f:result
argument
control link
return address
![Page 33: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/33.jpg)
33
Stack After Two Calls to f
main result
3
(*)
f(3)
result
2
(**)
f(2)
Stack
fp for f(1)
fp for f(2)
![Page 34: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/34.jpg)
34
Notes main has no argument or local variables and its
result is never used; its AR is uninteresting (*) and (**) are return addresses of the
invocations of f» The return address is where execution
resumes after a procedure call finishes
This is only one of many possible AR designs» Would also work for C, Pascal, FORTRAN, etc.
![Page 35: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/35.jpg)
35
The Main Point
The compiler must determine, at compile-time, the layout of activation records and generate code
that correctly accesses locations in the activation record
Thus, the AR layout and the code generator must be designed together!
![Page 36: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/36.jpg)
36
Heap Storage A value that outlives the procedure that creates it
cannot be kept in the AR
void foo(Foo f) { f.bar = new Bar(); }
The Bar object must survive deallocation of foo’s AR
Languages with dynamically allocated data use a heap to store dynamic data
![Page 37: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/37.jpg)
37
Notes The code area contains object code
» For most languages, fixed size and read only The static area contains data (not code) with
fixed addresses (e.g., global data)» Fixed size, may be readable or writable
The stack contains an AR for each currently active procedure.» Each AR usually fixed size, contains locals
Heap contains all other data» In C, heap is managed by malloc and free
![Page 38: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/38.jpg)
38
Stack Frames
incomingargs
locallocalvariablesvariables
return addressreturn address
tempstemps
saved saved registersregisters
arg narg n....
arg 1arg 1Static linkStatic link
arg narg n....
arg 1arg 1static linkstatic link
outgoingargs
currentframe
prevframe
nextframe
stackpointer
framepointer
low
er m
em
ory
ad
dre
sses
h
igh
er a
dd
ress
es
• Push/pop frames• Access variables in deeper
frames -> nonlocal variables• Stack frame
– Local variables– Parameters– Return address– Temporaries– Register save area
• Usually has “standard” frame layout for several languages
• Depends on architecture
![Page 39: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/39.jpg)
39
arg narg n....
arg 1arg 1stackpointer
framepointer
arg narg n....
arg 1arg 1
stackpointer
framepointer
: frame sizeeither fixed or varies => Can be determined very late
Frame PointerFrame Pointer
g(…) calls f(a1, a2, ………, an)
![Page 40: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/40.jpg)
40
Registers
register : local vars, temporary results…» Can save load/store instructions
general purpose vs. special purpose registers caller save vs. callee save register
» Ex: MIPS r16 - r23 are preserved across procedure calls (callee-save) r0 - r15 not preserved (caller-save)
If we do interprocedure analysis, we can do fine register save scheduling» If x is not needed after the call caller-save but not save» If x is need before and after the call callee-save» In general, register allocator (chapter 11)
![Page 41: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/41.jpg)
41
Parameter Passing passing with stack (for machines designed in 1970s) passing some (k) in registers and others in stack
» k=6 or 4(mips: $a0~$a3)» Need to save register when call another function
To reduce memory traffic, need not save “argument registers” [into memory stack], when» Leaf procedure
– – procedure does not call other procedures
» Interprocedural register allocation – – analyze all functions
» Arguments become dead variables at the point where another function is called
» Register windows – - each function call allocates a fresh set of registers
![Page 42: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/42.jpg)
42
Parameter Passing (cont’d)
argument passing in reg + stack
Sometimes formal parameters are at consecutive addresses: register save area by callee
call-by-reference» Code for dereferencing
formal parameter access» no dangling reference
int *f(int x) {return &x;}
void f(int &y);
arg karg k....
arg 1arg 1
arg narg n....
arg k+arg k+11
registersavearea
framepointer
![Page 43: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/43.jpg)
43
Return Address g calls f : f returns
» Need g’s address (resume point) -> return address» Call instruction at address a
-> return to a+1 (the next instruction) Can be saved
» On stack» In special register» In special memory location
Hardware “call” instruction dependent» Usually in designated registers» Need to save (non-leaf proc)» No need to save (leaf proc)
![Page 44: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/44.jpg)
44
Frame-resident Variables
Variables are written to memory only when necessary» Variable will be passed by reference or & (address
of) operator is applied» Variable is accessed by a procedure nested inside
the current one» Value is too big to fit into a single register» Variable is an array» Register holding variable is needed for special
purpose (parameter passing)» Too many local variables (“spilled” into frame)
![Page 45: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/45.jpg)
45
Escaped Variable A variable “escape”s if
» it is passed by reference, » its address is taken, » or it is accessed from a nested function.
Variables are bound to register or memory in later phase in compiling.» declarations vs. uses
![Page 46: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/46.jpg)
46
Static Linksprettyprint output
write --output
show
n
ident
i,s
--output
--n
-- i,s
Inner functions may use variables declared in outer functions
Variable References• Static Links• Lambda lifting (passing all nonlocals as arguments)• Display
Procedure Calls
prettyprint show ident
show,,
![Page 47: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/47.jpg)
47
Static Link activation record contains a static
link (pointer) that points to outer scope
int a(int i) {
int c() {return i+7;}
int b(int i) {return i+c();}
return b(2)- 3;
}
static link
dynamic link
return address
parameter i
a
static link
dynamic link
return address
parameter i
b
parameter i
cstatic link
dynamic link
return address
![Page 48: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/48.jpg)
48
Example Given the GNU C routine:
void A(int a) {
void B(int b) {
void C(void) {
printf(“C called, a = %d\n”, a);
}
if (b == 0) C() else B(b-1);
}
B(a);
}
a) draw the stack that results from the call A(2)b) how does C access the parameter (a) from A?
![Page 49: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/49.jpg)
49
Answersdynamic
linksstatic
links
A 2
B 2
B 1
B 0
CFP->static_link->static_link->param[#i]
![Page 50: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/50.jpg)
50
Lambda lifting outer-scope variables
» referencing: pass additional pointers
int f() {
int k = 5;
int g(int t) {
return k + t
}
return g(2);
}
nested
int g(int k, int t) { return k + t }
int f() {
int k = 5;
return g(k, 2);
}
lifted
![Page 51: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/51.jpg)
51
Lambda lifting out-of-scope variables
» referencing: pass additional pointers» creating: heap (dynamic) allocation
typedef int (*fptr)();
fptr mies(int i) {
int aap() {return i+7;}
return aap;
}
nested
int aap(int *i) {return *i+7;}
fptr mies(int i) {
int *_i = malloc(sizeof(i));
*_i = i;
return closure(aap,_i);
}
lifted
![Page 52: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/52.jpg)
52
Procedure linkages The linkage convention is the interface used for
performing procedure calls» on entry, establish p's environment» at a call, preserve p's environment» after a call, restore p’s environment» on exit, tear down p's environment» in between, handle addressability and lifetimes
Ensures each procedure inherits from caller a valid run-time environment and also restores one for its caller
![Page 53: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/53.jpg)
53
Procedure LinkagesStandard procedure linkage
procedure p
prolog
epilog
pre-call
post-return
procedure q
prolog
epilog
Procedure has
• standard prolog
• standard epilog
Each call involves a
• pre-call sequence
• post-return sequence
![Page 54: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/54.jpg)
54
Stack
return addressold frame pointer
Local variables
Calliee savedregisters
Stack temporaries
... argument 5argument 4
Dynamic area
Caller saved registers arguments
fp
sp
When calling a new procedure, caller:» push any t0-t9 that has a
live value on the stack» put arguments 1-4 on a0-
a3» push rest of the
arguments on the stack » do a jal or jalr
Pre-Call
![Page 55: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/55.jpg)
55
return addressold frame pointer
return addressold frame pointer
Stack
Local variables
Callee savedregisters
Stack temporaries
... argument 5argument 4
Dynamic area
Local variables
Callee savedregisters
Caller saved registers arguments
Dynamic area
fp
sp
In a procedure call, the callee at the beginning:» push $fp on the stack» copy $sp+4 to $fp» push $ra on the stack» if any s0-s7 is used in the
procedure save it on the stack
» create space for local variables on the stack
» execute the callee...
Prolog
stack frame
![Page 56: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/56.jpg)
56
return addressold frame pointer
Stack
Local variables
Callee savedregisters
Stack temporaries
... argument 5argument 4
Dynamic area
Caller saved registers arguments
In a procedure call, the callee at the end:
» put return values on v0,v1
» update $sp using $fp ($fp-8) - ...
» Pop the callee saved registers from stack
» restore $ra from stack
» restore $fp from stack
» execute jr ra and return to caller
fp
sp
Epilog
![Page 57: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/57.jpg)
57
Stack On return from a procedure
call, the caller:» Update $sp to ignore
arguments» pop the caller saved
registers» Continue...
return addressold frame pointer
Local variables
Calliee savedregisters
Stack temporaries
... argument 5argument 4
Dynamic area
fp
sp
Post-call
![Page 58: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/58.jpg)
58
Argument 5: bx (0)
Example Programclass auxmath {
int sum3d(int ax, int ay, int az, int bx, int by, int bz)
{int dx, dy, dz;if(ax > ay)
dx = ax - bx;else
dx = bx - ax; …
retrun dx + dy + dz;}
}
…int px, py, pz;px = 10; py = 20; pz = 30;auxmath am;am.sum3d(px, py, pz, 0, 1, -1);
return addressold frame pointer
Dynamic area
Caller saved registers
Argument 7: bz (-1)
fp
sp
Argument 6: by (1)
Local variable dx (??) Local variable dy (??) Local variable dz (??)
v0 ??v1 ??a0 thisa1 ax (10)a2 ay (20)a3 az (30)v0 ??v1 ??t0 ??t1 ??
![Page 59: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/59.jpg)
59
Frames in MiniJava Package Frame
» Frame.java Access.java AccessList.java Package Temp
» Temp.java, TempList.java, Label.java, LabelList.java» Temp is used for temporary register» Label is used for storage location
Package Util» BoolList.java
Package T(Mips, Sparcs)» T(Mips/Sparcs) Frame.java
– Inframe(), InReg(), newFrame(), allocLocal()
![Page 60: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/60.jpg)
60
Package Frame Abstraction of Actual Frames
package Frame;import Temp.Temp import Temp.Label;
Public abstract class Access{ … }public class AccessList { public Access head; public AccessList tail; public AccessList(Access h, AccessList t) { head=h; tail=t;}}
![Page 61: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/61.jpg)
61
Frame.java
public abstract class Frame { public abstract Frame newFrame(Temp.Label name,
Util.BoolList formals); public Temp.Label name; //Function name public AccessList formals; //Parameters public abstract Access allocLocal(boolean escape);
public abstract Temp.Temp FP(); //Frame Pointer public abstract Temp.Temp RV(); //Return Value /* ..other stuff, eventually … */
// public abstract int wordSize(); //Size of Word// public abstract Tree.Exp externalCall(String func,
Tree.ExpList args);// public abstarct tree.Stm procEntryExit1(tree.Stm body );}
Hold information for parameters & local variables allocated in this frame
![Page 62: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/62.jpg)
62
TFrame : specific to Target Machine
For T machine… package T; class Frame extends Frame.Frame { /* real definitions of Frame */ …. }
In machine independent part of compiler // in class Main.Main: Frame.Frame frame = new T.Frame(…);
» To hide the identity of the target machine
![Page 63: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/63.jpg)
63
Making new Frames» Frame for function f with k formals
newFrame(f, l) where f : Label l: BoolList
Ex: a three-argument function named g with 1st argument escaped, i.e., needs to stay in memory
frame.newFrame(g,
new BoolList(true,
new BoolList(false,
new BoolList(false,null))))
(No parameters will be escapes in MiniJava.)
![Page 64: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/64.jpg)
64
Class Access
Access formal & local variables in the frame or in registers
Abstract data type whose implementation is visible only inside the Frame module:
package T class InFrame extends Frame.Access { int offset; InFrame (int o) {offset = o; } } class InReg extends Frame.Access { Temp.Temp temp; InReg(Temp.Temp t) {temp = t; }
![Page 65: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/65.jpg)
65
Access and Allocate the Variables InFrame(X) : a memory location at offset X from the
FP(frame pointer) InReg(t84) : in register t84
formals in Frame.java» A list of k “accesses” denoting locations where the
formal parameters will be kept at runtime , as seen from inside the callee
» May be seen differently by the caller and callee : “shift of view”
» View shift must be handled by “newFrame()”
![Page 66: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/66.jpg)
66
Representation of Frame Descriptions
Implementation of frame is an object holding:» the location of all the formals» instructions required to implement the “view
shift”» the number of locals allocated so far» the “label” at which the function’s machine
code is to begin» See Table 6.4 on page 129
![Page 67: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/67.jpg)
67
Local Variables
To allocate a new local variable in a frame f
» f.allocLocal(true) // allocate in memory (stack)
» will return InFrame() access with an offset from FPex) two local variables in Sparcs => InFrame(-4), InFrame(-8)
» f.allocLocal(false) // allocate in register» will return InReg()
ex) on register-allocated vars => InReg(t481)
allocLocal(bool) » Called when frame is create » Called when nested block is entered
![Page 68: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/68.jpg)
68
Allocating Local Storage in frame
with the Same Name v
function f() {
var v1 := 6
print(v1);
{
var v2 := 7
print(v2);
}
print(v1);
{ var v3 := 8
print(v3);
} }
allocLocal()
allocLocal()
allocLocal()
v1
v2
v3
v3 mightuse the same space of v1 or v2
framepointer
stackpointer
![Page 69: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/69.jpg)
69
Escape Variables No variables escape in MiniJava, because
» there is no nesting of classes and methods» it is not possible to take the address of a variable» integers and booleans are passed by value» object, including integer arrays, can be represented as
pointers that are passed by value
![Page 70: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/70.jpg)
70
Temporaries and Labels
Temps are virtual registers» May not be enough registers available to store all
temporaries in a program» Delay decision until later
Labels are like labels in assembler, a location of a machine language instruction» processing the declaration m(…) new Temp.Label(“C”+”$”+”m”)
Classes Temp and Label in package Temp Packages Frame and Temp provide machine
independent views of variables
![Page 71: 1 Chapter 6 Runtime storage and Activation Records.](https://reader036.fdocuments.in/reader036/viewer/2022062806/5697c02d1a28abf838cd96d3/html5/thumbnails/71.jpg)
71
Managing Static Links Static Link management is somewhat tedious? MiniJava does not have nested function declarations:
» thus Frame should not know anything about static links.
It will be handled in the Translation phase. Static links may be passed to the callee by the 1st formal
parameter.