Assembly Language: Function Calls
description
Transcript of Assembly Language: Function Calls
![Page 1: Assembly Language: Function Calls](https://reader035.fdocuments.us/reader035/viewer/2022062309/56813b0c550346895da3b4b0/html5/thumbnails/1.jpg)
1
Assembly Language: Function Calls
Professor Jennifer Rexford
http://www.cs.princeton.edu/~jrex
![Page 2: Assembly Language: Function Calls](https://reader035.fdocuments.us/reader035/viewer/2022062309/56813b0c550346895da3b4b0/html5/thumbnails/2.jpg)
2
Goals of Today’s Lecture
• Challenges of supporting functions Providing information for the called function
– Function arguments and local variables Allowing the calling function to continue where it left off
– Return address and contents of registers
• Stack: last-in-first-out data structure Stack frame: args, local vars, return address, registers Stack pointer: pointing to the current top of the stack
• Calling functions Call and ret instructions, to call and return from functions Pushing and popping the stack frame Using the base pointer EBP as a reference point
![Page 3: Assembly Language: Function Calls](https://reader035.fdocuments.us/reader035/viewer/2022062309/56813b0c550346895da3b4b0/html5/thumbnails/3.jpg)
3
Challenges of Supporting Functions
• Code with a well-defined entry and exit points Call: How does the CPU go to that entry point? Return: How does the CPU go back to the right place,
when “right place” depends on who called the function?
• With arguments and local variables How are the arguments passed from the caller? Where should the local variables be stored?
• Providing a return value How is the return value returned to the calling function?
• Without changing variables in other functions How are the values stored in registers protected?
![Page 4: Assembly Language: Function Calls](https://reader035.fdocuments.us/reader035/viewer/2022062309/56813b0c550346895da3b4b0/html5/thumbnails/4.jpg)
4
Call and Return Abstractions
• Call a function Jump to the beginning of an arbitrary procedure I.e., jump to the address of the function’s first instruction
• Return from a function Jump to the instruction immediately following the “most-
recently-executed” Call instruction But, the same function may be called from many places!
P: # Function P
…
jmp R # Call R
Rtn_point1:
…
R: # Function R
…
jmp Rtn_point1 # Return
![Page 5: Assembly Language: Function Calls](https://reader035.fdocuments.us/reader035/viewer/2022062309/56813b0c550346895da3b4b0/html5/thumbnails/5.jpg)
5
Challenge: Where to Return?
P: # Function P
…
jmp R # Call R
Rtn_point1:
…
Q: # Function Q
…
jmp R # Call R
Rtn_point2:
…
R: # Function R
…
jmp ??? # Return
What should the return instruction in R jump to???
![Page 6: Assembly Language: Function Calls](https://reader035.fdocuments.us/reader035/viewer/2022062309/56813b0c550346895da3b4b0/html5/thumbnails/6.jpg)
6
Store Return Address in Register?
P: # Proc P
movl $Rtn_point1, %eax
jmp R # Call R
Rtn_point1:
…
Q: # Proc Q
movl $Rtn_point2, %eax
jmp R # Call R
Rtn_point2:
…
R: # Proc R
…
jmp %eax # Return
Convention: At Call time, store return address in EAX
![Page 7: Assembly Language: Function Calls](https://reader035.fdocuments.us/reader035/viewer/2022062309/56813b0c550346895da3b4b0/html5/thumbnails/7.jpg)
7
Problem: Nested Function Calls
P: # Function P
movl $Rtn_point1, %eax
jmp Q # Call Q
Rtn_point1:
…
Q: # Function Q
movl $Rtn_point2, %eax
jmp R # Call R
Rtn_point2:
…
jmp %eax # Return
R: # Function R
…
jmp %eax # Return
• Problem if P calls Q, and Q calls R
• Return address for P to Q call is lost
![Page 8: Assembly Language: Function Calls](https://reader035.fdocuments.us/reader035/viewer/2022062309/56813b0c550346895da3b4b0/html5/thumbnails/8.jpg)
8
Solution: Put Return Address on a Stack
• May need to store many return addresses The number of nested functions is not known in advance A return address must be saved for as long as the
function invocation continues
• Addresses used in reverse order E.g., function P calls Q, which then calls R Then R returns to Q which then returns to P
• Last-in-first-out data structure (stack) Calling function pushes return address on the stack … and called function pops return address off the stack
EIP for P
EIP for Q
![Page 9: Assembly Language: Function Calls](https://reader035.fdocuments.us/reader035/viewer/2022062309/56813b0c550346895da3b4b0/html5/thumbnails/9.jpg)
9
Arguments to the Function
• Calling function needs to pass arguments Cannot simply put arguments
in a specific register Because function calls may
be nested
• So, put the arguments on the stack, too! Calling function pushes
arguments on the stack Called function loads/stores-
them on the stack
int add3(int a, int b, int c){ int d;
d = a + b + c;
return d;}
int foo(void){ return add3(3, 4, 5);}
![Page 10: Assembly Language: Function Calls](https://reader035.fdocuments.us/reader035/viewer/2022062309/56813b0c550346895da3b4b0/html5/thumbnails/10.jpg)
10
Local Variables
• Local variables: called function has local variables Short-lived, so don’t need a
permanent location in memory Size known in advance, so don’t
need to allocate on the heap
• So, the function just uses the top of the stack Store local variables on the top
of the stack The local variables disappear
after the function returns
int add3(int a, int b, int c){ int d;
d = a + b + c;
return d;}
int foo(void){ return add3(3, 4, 5);}
![Page 11: Assembly Language: Function Calls](https://reader035.fdocuments.us/reader035/viewer/2022062309/56813b0c550346895da3b4b0/html5/thumbnails/11.jpg)
11
Registers
• Registers Small, fast memory (e.g., directly on the CPU chip) Used as temporary storage for computations
• Cannot have separate registers per function Could have arbitrary number of nested functions Want to allow each function to use all the registers
• Could write all registers out to memory E.g., save values corresponding to program variables
– Possible, but a bit of a pain… E.g., find someplace to stash intermediate results
– Where would we put them?
• Instead, save the registers on the stack, too
![Page 12: Assembly Language: Function Calls](https://reader035.fdocuments.us/reader035/viewer/2022062309/56813b0c550346895da3b4b0/html5/thumbnails/12.jpg)
12
Stack Frames
• Use stack for all temporary data related to each active function invocation
Return address Input parameters Local variables of function Saving registers across invocations
• Stack has one Stack Frame per active function invocation
Stack Frame
![Page 13: Assembly Language: Function Calls](https://reader035.fdocuments.us/reader035/viewer/2022062309/56813b0c550346895da3b4b0/html5/thumbnails/13.jpg)
13
High-Level Picture
main begins executing
main’s
Stack Frame
0
Bottom
%ESP
![Page 14: Assembly Language: Function Calls](https://reader035.fdocuments.us/reader035/viewer/2022062309/56813b0c550346895da3b4b0/html5/thumbnails/14.jpg)
14
High-Level Picture
main begins executing
main calls P
main’s
Stack Frame
P’s
Stack Frame
0
Bottom
%ESP
![Page 15: Assembly Language: Function Calls](https://reader035.fdocuments.us/reader035/viewer/2022062309/56813b0c550346895da3b4b0/html5/thumbnails/15.jpg)
15
High-Level Picture
main begins executing
main calls P
P calls Q
main’s
Stack Frame
P’s
Stack Frame
Q’s
Stack Frame
0
Bottom
%ESP
![Page 16: Assembly Language: Function Calls](https://reader035.fdocuments.us/reader035/viewer/2022062309/56813b0c550346895da3b4b0/html5/thumbnails/16.jpg)
16
High-Level Picture
main begins executing
main calls P
P calls Q
Q calls P
main’s
Stack Frame
P’s
Stack Frame
P’s
Stack Frame
Q’s
Stack Frame
0
Bottom
%ESP
![Page 17: Assembly Language: Function Calls](https://reader035.fdocuments.us/reader035/viewer/2022062309/56813b0c550346895da3b4b0/html5/thumbnails/17.jpg)
17
High-Level Picture
main begins executing
main calls P
P calls Q
Q calls P
P returns
main’s
Stack Frame
P’s
Stack Frame
Q’s
Stack Frame
0
Bottom
%ESP
![Page 18: Assembly Language: Function Calls](https://reader035.fdocuments.us/reader035/viewer/2022062309/56813b0c550346895da3b4b0/html5/thumbnails/18.jpg)
18
High-Level Picture
main begins executing
main calls P
P calls Q
Q calls P
P returns
Q calls R
main’s
Stack Frame
P’s
Stack Frame
R’s
Stack Frame
Q’s
Stack Frame
0
Bottom
%ESP
![Page 19: Assembly Language: Function Calls](https://reader035.fdocuments.us/reader035/viewer/2022062309/56813b0c550346895da3b4b0/html5/thumbnails/19.jpg)
19
High-Level Picture
main begins executing
main calls P
P calls Q
Q calls P
P returns
Q calls R
R returns
main’s
Stack Frame
P’s
Stack Frame
Q’s
Stack Frame
0
Bottom
%ESP
![Page 20: Assembly Language: Function Calls](https://reader035.fdocuments.us/reader035/viewer/2022062309/56813b0c550346895da3b4b0/html5/thumbnails/20.jpg)
20
High-Level Picture
main begins executing
main calls P
P calls Q
Q calls P
P returns
Q calls R
R returns
Q returns
main’s
Stack Frame
P’s
Stack Frame
0
Bottom
%ESP
![Page 21: Assembly Language: Function Calls](https://reader035.fdocuments.us/reader035/viewer/2022062309/56813b0c550346895da3b4b0/html5/thumbnails/21.jpg)
21
High-Level Picture
main begins executing
main calls P
P calls Q
Q calls P
P returns
Q calls R
R returns
Q returns
P returns
main’s
Stack Frame
0
Bottom
%ESP
![Page 22: Assembly Language: Function Calls](https://reader035.fdocuments.us/reader035/viewer/2022062309/56813b0c550346895da3b4b0/html5/thumbnails/22.jpg)
22
High-Level Picture
main begins executing
main calls P
P calls Q
Q calls P
P returns
Q calls R
R returns
Q returns
P returns
main returns
0
Bottom
![Page 23: Assembly Language: Function Calls](https://reader035.fdocuments.us/reader035/viewer/2022062309/56813b0c550346895da3b4b0/html5/thumbnails/23.jpg)
23
Function Call Details
• Call and Return instructions Call: push EIP on the stack, and jump to function Return: pop the stack into the EIP to go back
• Argument passing between procedures Calling function pushes arguments on to the stack Called function reads/writes on the stack
• Local variables Called function creates and manipulates on the stack
• Register saving conventions Either calling or called function saves all of the registers
before use
![Page 24: Assembly Language: Function Calls](https://reader035.fdocuments.us/reader035/viewer/2022062309/56813b0c550346895da3b4b0/html5/thumbnails/24.jpg)
24
Call and Return Instructions
Instruction Effective Operations
pushl src subl $4, %esp
movl src, (%esp)
popl dest movl (%esp), dest
addl $4, %esp
call addr pushl %eipjmp addr
ret pop %eip %ESP before Call
0
Note: can’t really access EIP directly, but this is implicitly what call and ret are doing.
![Page 25: Assembly Language: Function Calls](https://reader035.fdocuments.us/reader035/viewer/2022062309/56813b0c550346895da3b4b0/html5/thumbnails/25.jpg)
25
Call and Return Instructions
Instruction Operation
pushl src subl $4, %esp
movl src, (%esp)
popl dest movl (%esp), dest
addl $4, %esp
call addr pushl %eipjmp addr
ret pop %eip
%ESP after Call Old EIP
0
![Page 26: Assembly Language: Function Calls](https://reader035.fdocuments.us/reader035/viewer/2022062309/56813b0c550346895da3b4b0/html5/thumbnails/26.jpg)
26
Call and Return Instructions
Instruction Operation
pushl src subl $4, %esp
movl src, (%esp)
popl dest movl (%esp), dest
addl $4, %esp
call addr pushl %eipjmp addr
ret pop %eip
%ESP before Return
Old EIP
0
Return instruction assumes that the return address is at the top of the stack
![Page 27: Assembly Language: Function Calls](https://reader035.fdocuments.us/reader035/viewer/2022062309/56813b0c550346895da3b4b0/html5/thumbnails/27.jpg)
27
Call and Return Instructions
Instruction Operation
pushl src subl $4, %esp
movl src, (%esp)
popl dest movl (%esp), dest
addl $4, %esp
call addr pushl %eipjmp addr
ret pop %eip %ESP after
Return
0
Return instruction assumes that the return address is at the top of the stack
![Page 28: Assembly Language: Function Calls](https://reader035.fdocuments.us/reader035/viewer/2022062309/56813b0c550346895da3b4b0/html5/thumbnails/28.jpg)
28
Input Parameters
%ESP before
pushing argument
s
0• Caller pushes input parameters before executing the Call instruction
• Parameters are pushed in the reverse order Push Nth argument first Push 1st argument last So that first argument is at the top of
the stack at the time of the Call
![Page 29: Assembly Language: Function Calls](https://reader035.fdocuments.us/reader035/viewer/2022062309/56813b0c550346895da3b4b0/html5/thumbnails/29.jpg)
29
Input Parameters
%ESP before
Call
0• Caller pushes input parameters before executing the Call instruction
• Parameters are pushed in the reverse order Push Nth argument first Push 1st argument last So that first argument is at top of
the stack at the time of the Call
Arg N
Arg 1
Arg …
![Page 30: Assembly Language: Function Calls](https://reader035.fdocuments.us/reader035/viewer/2022062309/56813b0c550346895da3b4b0/html5/thumbnails/30.jpg)
30
Input Parameters
%ESP after Call
0• Caller pushes input parameters before executing the Call instruction
• Parameters are pushed in the reverse order Push Nth argument first Push 1st argument last So that first argument is at top of
the stack at the time of the Call
Arg N
Arg 1
Arg …
Old EIP
Called function can address arguments relative to ESP: Arg 1 as 4(%esp)
Why is the EIP put on after the arguments?
![Page 31: Assembly Language: Function Calls](https://reader035.fdocuments.us/reader035/viewer/2022062309/56813b0c550346895da3b4b0/html5/thumbnails/31.jpg)
31
Input Parameters
%ESP before Return
0• Caller pushes input parameters before executing the Call instruction
• Parameters are pushed in the reverse order Push Nth argument first Push 1st argument last So that first argument is at top of
the stack at the time of the Call
Arg N
Arg 1
Arg …
Old EIP
![Page 32: Assembly Language: Function Calls](https://reader035.fdocuments.us/reader035/viewer/2022062309/56813b0c550346895da3b4b0/html5/thumbnails/32.jpg)
32
Input Parameters
%ESP after
Return
0• Caller pushes input parameters before executing the Call instruction
• Parameters are pushed in the reverse order Push Nth argument first Push 1st argument last So that first argument is at top of
the stack at the time of the Call
Arg N
Arg 1
Arg …
After the function call is finished, the caller pops the pushed arguments from the stack
![Page 33: Assembly Language: Function Calls](https://reader035.fdocuments.us/reader035/viewer/2022062309/56813b0c550346895da3b4b0/html5/thumbnails/33.jpg)
33
Input Parameters
%ESP after
popping argument
s
0• Caller pushes input parameters before executing the Call instruction
• Parameters are pushed in the reverse order Push Nth argument first Push 1st argument last So that first argument is at top of
the stack at the time of the Call
After the function call is finished, the caller pops the pushed arguments from the stack
![Page 34: Assembly Language: Function Calls](https://reader035.fdocuments.us/reader035/viewer/2022062309/56813b0c550346895da3b4b0/html5/thumbnails/34.jpg)
34
Base Pointer: EBP
%ESP after Call
0• As Callee executes, ESP may change
E.g., preparing to call another function
• Use EBP as fixed reference point E.g., to access arguments and
other local variables
• Need to save old value of EBP Before overwriting EBP register
• Callee begins by executing “prolog”
pushl %ebp
movl %esp, %ebp
Arg N
Arg 1
Arg …
Old EIP
%EBP
![Page 35: Assembly Language: Function Calls](https://reader035.fdocuments.us/reader035/viewer/2022062309/56813b0c550346895da3b4b0/html5/thumbnails/35.jpg)
35
Base Pointer: EBP
%ESP, %EBP
0
Arg N
Arg 1
Arg …
Old EIP
Old EBP
• As Callee executes, ESP may change E.g., preparing to call another function
• Use EBP as fixed reference point E.g., to access arguments and
other local variables
• Need to save old value of EBP Before overwriting EBP register
• Callee begins by executing “epilog”
pushl %ebp
movl %esp, %ebp
• Regardless of ESP, Callee can address Arg 1 as 8(%ebp)
![Page 36: Assembly Language: Function Calls](https://reader035.fdocuments.us/reader035/viewer/2022062309/56813b0c550346895da3b4b0/html5/thumbnails/36.jpg)
36
Base Pointer: EBP
%EBP
0
Arg N
Arg 1
Arg …
Old EIP
Old EBP
• Before returning, Callee must restore EBP to its old value
• Executes
movl %ebp, %esp
popl %ebp
ret
%ESP
![Page 37: Assembly Language: Function Calls](https://reader035.fdocuments.us/reader035/viewer/2022062309/56813b0c550346895da3b4b0/html5/thumbnails/37.jpg)
37
Base Pointer: EBP
%ESP, %EBP
0
Arg N
Arg 1
Arg …
Old EIP
Old EBP
• Before returning, Callee must restore EBP to its old value
• Executes
movl %ebp, %esp
popl %ebp
ret
![Page 38: Assembly Language: Function Calls](https://reader035.fdocuments.us/reader035/viewer/2022062309/56813b0c550346895da3b4b0/html5/thumbnails/38.jpg)
38
Base Pointer: EBP
%ESP
0
Arg N
Arg 1
Arg …
Old EIP
• Before returning, Callee must restore EBP to its old value
• Executes
movl %ebp, %esp
popl %ebp
ret
%EBP
![Page 39: Assembly Language: Function Calls](https://reader035.fdocuments.us/reader035/viewer/2022062309/56813b0c550346895da3b4b0/html5/thumbnails/39.jpg)
39
Base Pointer: EBP
%ESP
0
Arg N
Arg 1
Arg …
• Before returning, Callee must restore EBP to its old value
• Executes
movl %ebp, %esp
popl %ebp
ret
%EBP
![Page 40: Assembly Language: Function Calls](https://reader035.fdocuments.us/reader035/viewer/2022062309/56813b0c550346895da3b4b0/html5/thumbnails/40.jpg)
40
Allocation for Local Variables
%EBP
0
Arg N
Arg 1
Arg …
Old EIP
Old EBP
• Local variables of the Callee are also allocated on the stack
• Allocation done by moving the stack pointer
• Example: allocate two integers subl $4, %esp subl $4, %esp (or equivalently, subl $8, %esp)
• Reference local variables using the base pointer -4(%ebp) -8(%ebp)
%ESP
Var 1
Var 2
![Page 41: Assembly Language: Function Calls](https://reader035.fdocuments.us/reader035/viewer/2022062309/56813b0c550346895da3b4b0/html5/thumbnails/41.jpg)
41
Use of Registers
• Problem: Called function may use a register that the calling function is also using When called function returns control to calling function,
old register contents may be lost Calling function cannot continue where it left off
• Solution: save the registers on the stack Someone must save old register contents Someone must later restore the register contents
• Need a convention for who saves and restores which registers
![Page 42: Assembly Language: Function Calls](https://reader035.fdocuments.us/reader035/viewer/2022062309/56813b0c550346895da3b4b0/html5/thumbnails/42.jpg)
42
GCC/Linux Convention
%EBP
0
Arg N
Arg 1
Arg …
Old EIP
Old EBP
• Caller-save registers %eax, %edx, %ecx Save on stack (if necessary)
prior to calling
• Callee-save registers %ebx, %esi, %edi Old values saved on stack prior
to using, and restored later
• %esp, %ebp handled as described earlier
• Return value is passed from Callee to Caller in %eax
%ESP
Var 1
Var 2
Saved
Registers
Saved
Registers
![Page 43: Assembly Language: Function Calls](https://reader035.fdocuments.us/reader035/viewer/2022062309/56813b0c550346895da3b4b0/html5/thumbnails/43.jpg)
43
A Simple Example
int add3(int a, int b, int c){ int d;
d = a + b + c;
return d;}
int foo(void){ return add3( 3, 4, 5 );}
![Page 44: Assembly Language: Function Calls](https://reader035.fdocuments.us/reader035/viewer/2022062309/56813b0c550346895da3b4b0/html5/thumbnails/44.jpg)
44
A Simple Example
int add3(int a, int b, int c){ int d; d = a + b + c; return d;}
# In general, one may need to push # callee-save registers onto the stack
# Add the three arguments movl 8(%ebp), %eax addl 12(%ebp), %eax addl 16(%ebp), %eax
# Put the sum into d movl %eax, -4(%ebp)
# Return value is already in eax
# In general, one may need to pop # callee-save registers
# Restore old ebp, discard stack frame movl %ebp, %esp popl %ebp
# Return ret
add3: # Save old ebp and set up new ebp pushl %ebp movl %esp, %ebp
# Allocate space for d subl $4, $esp
%EBP
Arg c
Arg a
Arg b
old EIP
old EBP
%ESPVar d
![Page 45: Assembly Language: Function Calls](https://reader035.fdocuments.us/reader035/viewer/2022062309/56813b0c550346895da3b4b0/html5/thumbnails/45.jpg)
45
A Simple Example
# No need to save caller- # save registers either
# Push arguments in reverse order pushl $5 pushl $4 pushl $3
call add3
# Pop arguments from the stack addl $12, %esp
# Return value is already in eax
# Restore old ebp and # discard stack frame movl %ebp, %esp popl %ebp
# Return ret
foo: # Save old ebp, and set-up # new ebp pushl %ebp movl %esp, %ebp
# No local variables
# No need to save callee-save # registers as we # don’t use any registers
int foo(void) { return add3( 3, 4, 5 );}
%EBP
Arg c
Arg aArg b
old EIP
%ESP
![Page 46: Assembly Language: Function Calls](https://reader035.fdocuments.us/reader035/viewer/2022062309/56813b0c550346895da3b4b0/html5/thumbnails/46.jpg)
46
Conclusion
• Invoking a function Call: call the function Ret: return from the instruction
• Stack Frame for a function invocation includes Return address, Procedure arguments, Local variables, and Saved registers
• Base pointer EBP Fixed reference point in the Stack Frame Useful for referencing arguments and local variables