Conventions
October Procedure-Calling 30
CSC201 Section 002 Fall, 2000
Saving registers
Registers are inevitably used by subroutines; changes their value! Registers have global scope; calling procedures also use their contents
Conclusion: somebody needs to save registers before the subroutine executes, and restore values afterwards
CSC201 Section
Copyright 2000, Douglas Reeves
2
Approaches
"Caller saves" model
caller saves/restores just the registers that it knows have important values
"Callee saves" model
callee saves just the registers that it knows it will modify
"Hybrid" model
callee saves / restores the registers it modifies that are "important" to the caller
Our convention: "callee saves" model
CSC201 Section
Copyright 2000, Douglas Reeves
3
Example of Callee Saves
main: . call upcase nextinstruction: upcase proc push EAX ; save EAX value get_ch add AL, 23 put_ch pop EAX ; restore EAX value ret upcase endp
CSC201 Section
Copyright 2000, Douglas Reeves
4
Just after the push EAX and before the get_ch
popping
ESP
Saved Value of EAX Address of nextinstr uction The stack pushing
5
CSC201 Section
Copyright 2000, Douglas Reeves
Passing Input Parameters and Return Values
Registers are global variables; not a great idea to use for this purpose
Better choice: the stack
Before calling the procedure
allocate room on the stack for the return value Push a copy of the input parameter values on the stack
Some parameters are modified by the procedure as part of its output
In this case, push the parameter *address* instead of its value Procedure can modify the parameter using indirect addressing
CSC201 Section
Copyright 2000, Douglas Reeves
6
Parameter Passing (cont.)
Callee reads parameter values on stack, using based-displacement addressing
EBP = based register
Before using EBP, must save its value and restore it on exit!
CSC201 Section
Copyright 2000, Douglas Reeves
7
"Cleaning Up" the Stack
After calling a procedure and returning, the stack should look just like it did before the call The callee must
1. Deallocate memory it allocated 2. Pop saved register values from the stack 3. Pop the return address
What about input parameters and the return value?
"callee" can deallocate input parameters with "ret x" statement
"x" = # of bytes to deallocate (i.e., value to add to ESP)
CSC201 Section
only "caller" can deallocate the return value, after copying
Copyright 2000, Douglas Reeves
8
Example
Specification for a procedure: Write a procedure to read up to n characters from the standard input. Each alphabetic character is mapped to upper case and ouput. Stop when anything other than a lower-case alphabetic character is read, and return to the caller the number of lower case characters read and mapped to upper case.
CSC201 Section
Copyright 2000, Douglas Reeves
9
Activation record for procedure upcase EBP Saved old EBP value Return address Storage for local variables of upcase would go here EBP-8 Saved old ECX value Saved old EAX value
EBP+4
EBP+8
Input paramet er Space for return value
EBP-4
EBP+12
CSC201 Section
Copyright 2000, Douglas Reeves
The stack
10
main: ESP, 4 ; allocate 4 bytes ; for the return value mov maxch, 12 push maxch ; maximum number ; of characters to map call upcase nextinstruction: pop nummap ; get return value + de; allocate return val. space . sub
CSC201 Section
Copyright 2000, Douglas Reeves
11
Just after call to upcase
ESP
Address of nextinstr uction
12
Space for return value
CSC201 Section
Copyright 2000, Douglas Reeves
The stack
12
upcase proc push mov push push mov loop1: cmp je get_ch cmp jl cmp jg add put_ch inc jmp endup: mov pop pop pop ret
CSC201 Section
EBP EBP, ESP EAX ; save EAX value ECX ECX, 0 ECX, [EBP+8] endup AL, a endup AL, z endup AL, 23 ECX loop1 [EBP+12], ECX ECX EAX ; restore EAX value ; EBP restore EBP value 4 ; deallocate input ; parameter space
Copyright 2000, Douglas Reeves
upcase endp
13
Just before loop1 EBP Saved old EBP value Address of nextinstr uction 12 EBP+12 Space for return value
CSC201 Section
Copyright 2000, Douglas Reeves
EBP+4
ESP
EBP+8 EBP-4
Saved old ECX value Saved old EAX value
The stack
14
Just before ret 4 (assuming 6 characters mapped to upper case)
ESP
Address of nextinstr uction 12
6 The stack
CSC201 Section
Copyright 2000, Douglas Reeves
15
Just after ret 4
ESP 6 The stack
CSC201 Section
Copyright 2000, Douglas Reeves
16
Procedure Checklist
1. Caller allocates space for return value 2. Caller copies input parameters to stack using push 3. "call" statement 4. Callee pushes EBP 5. Caller copies ESP to EBP 6. Caller saves registers it will modify 7. Caller allocates space for local variables 8. --Body of procedure executes-CSC201 Section
Copyright 2000, Douglas Reeves
17
Programming Checklist (cont.)
9. Callee copies result into return variable space 10. Callee deallocates space for local variables 11. Callee restores registers, pops off stack 12. Callee restores EBP, pops off stack 13. Callee returns, deallocates input parameters from stack 14. Caller copies return value 15. Caller deallocates space for return value
CSC201 Section
Copyright 2000, Douglas Reeves
18
Using Registers, Instead
How would the above example change if
the procedure didnt call any other procedure (no nesting)? + we used registers to hold input parameters? + we used a register to hold the return value? + the procedure used registers for all local variables?
A lot simpler! If only we had enough registers...
CSC201 Section
Copyright 2000, Douglas Reeves
19
Example, Using Registers
main: EDX, 12 upcase nummap, ECX ; value of ECX was ; changed by procedure nextinstruction: . mov call mov
CSC201 Section
Copyright 2000, Douglas Reeves
20
upcase proc push mov loop1: cmp je get_ch cmp jl cmp jg add put_ch inc jmp endup: pop ret upcase endp
EAX ; save EAX value ECX, 0 ECX, EDX endup AL, a endup AL, z endup AL, 23 ECX loop1 EAX ; restore EAX value
CSC201 Section
Copyright 2000, Douglas Reeves
21
Recursion
Procedure calling itself! Traversing a tree, divide and conquer algorithms, etc. Example in C:
Int f, a; a = 10; f = factorial(a); factorial(int a) int b; if (a == 1) return(1); e...