cs107, lecture 13
TRANSCRIPT
![Page 1: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/1.jpg)
1This document is copyright (C) Stanford Computer Science, Lisa Yan, and Nick Troccoli, licensed under Creative Commons Attribution 2.5 License. All rights reserved.
Based on slides created by Marty Stepp, Cynthia Lee, Chris Gregg, and others.
CS107, Lecture 13Assembly: Function Calls and the Runtime Stack
Reading: B&O 3.7
![Page 2: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/2.jpg)
2
Learning Assembly
Moving data around
Arithmetic and logical
operationsControl flow Function calls
Lecture 10 Lecture 11 Lecture 12 This Lecture
Reference Sheet: cs107.stanford.edu/resources/x86-64-reference.pdfSee more guides on Resources page of course website!
![Page 3: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/3.jpg)
3
Learning Goals• Learn how assembly calls functions and manages stack frames.• Learn the rules of register use when calling functions.
![Page 4: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/4.jpg)
4
Lecture Plan• Revisiting %rip 5• Calling Functions 19• The Stack 22• Passing Control 36• Passing Data 44• Local Storage 65
• Register Restrictions 69• Pulling it all together: recursion example 78• Optimizations 81• Live session slides 93
cp -r /afs/ir/class/cs107/lecture-code/lect13 .
![Page 5: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/5.jpg)
5
Lecture Plan• Revisiting %rip 5• Calling Functions 19• The Stack 22• Passing Control 36• Passing Data 44• Local Storage 65
• Register Restrictions 69• Pulling it all together: recursion example 78• Optimizations 81• Live session slides 93
cp -r /afs/ir/class/cs107/lecture-code/lect13 .
![Page 6: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/6.jpg)
6
%rip• %rip is a special register that points to the next instruction to execute.• Let’s dive deeper into how %rip works, and how jumps modify it.
![Page 7: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/7.jpg)
7
%ripvoid loop() {
int i = 0;while (i < 100) {
i++;}
}
0x40113f <+0>: b8 00 00 00 00 mov $0x0,%eax0x401144 <+5>: 83 f8 63 cmp $0x63,%eax0x401147 <+8>: 7f 05 jg 40114e <loop2+15>0x401149 <+10>: 83 c0 01 add $0x1,%eax0x40114c <+13>: eb f6 jmp 401144 <loop2+5>0x40114e <+15>: c3 retq
![Page 8: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/8.jpg)
8
%ripvoid loop() {
int i = 0;while (i < 100) {
i++;}
}
0x40113f <+0>: b8 00 00 00 00 mov $0x0,%eax0x401144 <+5>: 83 f8 63 cmp $0x63,%eax0x401147 <+8>: 7f 05 jg 40114e <loop2+15>0x401149 <+10>: 83 c0 01 add $0x1,%eax0x40114c <+13>: eb f6 jmp 401144 <loop2+5>0x40114e <+15>: c3 retq
These are 0-based offsets in bytes for each instruction relative to the start of this function.
![Page 9: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/9.jpg)
9
%ripvoid loop() {
int i = 0;while (i < 100) {
i++;}
}
0x40113f <+0>: b8 00 00 00 00 mov $0x0,%eax0x401144 <+5>: 83 f8 63 cmp $0x63,%eax0x401147 <+8>: 7f 05 jg 40114e <loop2+15>0x401149 <+10>: 83 c0 01 add $0x1,%eax0x40114c <+13>: eb f6 jmp 401144 <loop2+5>0x40114e <+15>: c3 retq
These are bytes for the machine code instructions. Instructions are variable length.
![Page 10: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/10.jpg)
10
0x40113f <+0>: b8 00 00 00 00 mov $0x0,%eax0x401144 <+5>: 83 f8 63 cmp $0x63,%eax0x401147 <+8>: 7f 05 jg 40114e <loop2+15>0x401149 <+10>: 83 c0 01 add $0x1,%eax0x40114c <+13>: eb f6 jmp 401144 <loop2+5>0x40114e <+15>: c3 retq
%ripvoid loop() {
int i = 0;while (i < 100) {
i++;}
}
![Page 11: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/11.jpg)
11
0x40113f <+0>: b8 00 00 00 00 mov $0x0,%eax0x401144 <+5>: 83 f8 63 cmp $0x63,%eax0x401147 <+8>: 7f 05 jg 40114e <loop2+15>0x401149 <+10>: 83 c0 01 add $0x1,%eax0x40114c <+13>: eb f6 jmp 401144 <loop2+5>0x40114e <+15>: c3 retq
%rip
![Page 12: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/12.jpg)
12
0x40113f <+0>: b8 00 00 00 00 mov $0x0,%eax0x401144 <+5>: 83 f8 63 cmp $0x63,%eax0x401147 <+8>: 7f 05 jg 40114e <loop2+15>0x401149 <+10>: 83 c0 01 add $0x1,%eax0x40114c <+13>: eb f6 jmp 401144 <loop2+5>0x40114e <+15>: c3 retq
%rip
0x7f means jg.
![Page 13: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/13.jpg)
13
0x40113f <+0>: b8 00 00 00 00 mov $0x0,%eax0x401144 <+5>: 83 f8 63 cmp $0x63,%eax0x401147 <+8>: 7f 05 jg 40114e <loop2+15>0x401149 <+10>: 83 c0 01 add $0x1,%eax0x40114c <+13>: eb f6 jmp 401144 <loop2+5>0x40114e <+15>: c3 retq
%rip
0x05 is the number of instruction bytes to jump relative to %rip.
With no jump, %rip would advance to the next line. This jg says to then go 5bytes further!
![Page 14: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/14.jpg)
14
0x40113f <+0>: b8 00 00 00 00 mov $0x0,%eax0x401144 <+5>: 83 f8 63 cmp $0x63,%eax0x401147 <+8>: 7f 05 jg 40114e <loop2+15>0x401149 <+10>: 83 c0 01 add $0x1,%eax0x40114c <+13>: eb f6 jmp 401144 <loop2+5>0x40114e <+15>: c3 retq
%rip
0x05 is the number of instruction bytes to jump relative to %rip.
With no jump, %rip would advance to the next line. This jg says to then go 5bytes further!
![Page 15: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/15.jpg)
15
0x40113f <+0>: b8 00 00 00 00 mov $0x0,%eax0x401144 <+5>: 83 f8 63 cmp $0x63,%eax0x401147 <+8>: 7f 05 jg 40114e <loop2+15>0x401149 <+10>: 83 c0 01 add $0x1,%eax0x40114c <+13>: eb f6 jmp 401144 <loop2+5>0x40114e <+15>: c3 retq
%rip
0xeb means jmp.
![Page 16: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/16.jpg)
16
0x40113f <+0>: b8 00 00 00 00 mov $0x0,%eax0x401144 <+5>: 83 f8 63 cmp $0x63,%eax0x401147 <+8>: 7f 05 jg 40114e <loop2+15>0x401149 <+10>: 83 c0 01 add $0x1,%eax0x40114c <+13>: eb f6 jmp 401144 <loop2+5>0x40114e <+15>: c3 retq
%rip
0xf6 is the number of instruction bytes to jump relative to %rip. This is -10 (in two’s complement!).
With no jump, %rip would advance to the next line. This jmp says to then go 10 bytes back!
![Page 17: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/17.jpg)
17
0x40113f <+0>: b8 00 00 00 00 mov $0x0,%eax0x401144 <+5>: 83 f8 63 cmp $0x63,%eax0x401147 <+8>: 7f 05 jg 40114e <loop2+15>0x401149 <+10>: 83 c0 01 add $0x1,%eax0x40114c <+13>: eb f6 jmp 401144 <loop2+5>0x40114e <+15>: c3 retq
%rip
0xf6 is the number of instruction bytes to jump relative to %rip. This is -10 (in two’s complement!).
With no jump, %rip would advance to the next line. This jmp says to then go 10 bytes back!
![Page 18: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/18.jpg)
18
Summary: Instruction Pointer• Machine code instructions live in main memory, just like stack and heap data.• %rip is a register that stores a number (an address) of the next instruction to
execute. It marks our place in the program’s instructions. • To advance to the next instruction, special hardware adds the size of the
current instruction in bytes.• jmp instructions work by adjusting %rip by a specified amount.
![Page 19: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/19.jpg)
19
Lecture Plan• Revisiting %rip 5• Calling Functions 19• The Stack 22• Passing Control 36• Passing Data 44• Local Storage 65
• Register Restrictions 69• Pulling it all together: recursion example 78• Optimizations 81• Live session slides 93
cp -r /afs/ir/class/cs107/lecture-code/lect13 .
![Page 20: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/20.jpg)
20
How do we call functions in assembly?
![Page 21: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/21.jpg)
21
Calling Functions In AssemblyTo call a function in assembly, we must do a few things:• Pass Control – %rip must be adjusted to execute the callee’s instructions, and
then resume the caller’s instructions afterwards.• Pass Data – we must pass any parameters and receive any return value.• Manage Memory – we must handle any space needs of the callee on the
stack.
Terminology: caller function calls the callee function.
How does assembly interact with the stack?
![Page 22: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/22.jpg)
22
Lecture Plan• Revisiting %rip 5• Calling Functions 19• The Stack 22• Passing Control 36• Passing Data 44• Local Storage 65
• Register Restrictions 69• Pulling it all together: recursion example 78• Optimizations 81• Live session slides 93
cp -r /afs/ir/class/cs107/lecture-code/lect13 .
![Page 23: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/23.jpg)
23
%rsp• %rsp is a special register that stores the address of the current “top” of the
stack (the bottom in our diagrams, since the stack grows downwards).
0x0
main()
Heap
myfunction()
Data
Text (code)
%rsp
Main Memory
![Page 24: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/24.jpg)
24
%rsp• %rsp is a special register that stores the address of the current “top” of the
stack (the bottom in our diagrams, since the stack grows downwards).
0x0
main()
Heap
myfunction()
Data
Text (code)
%rsp
Main Memory
foo()
![Page 25: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/25.jpg)
25
%rsp• %rsp is a special register that stores the address of the current “top” of the
stack (the bottom in our diagrams, since the stack grows downwards).
0x0
main()
Heap
myfunction()
Data
Text (code)
%rsp
Main Memory
foo()
foo2()
![Page 26: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/26.jpg)
26
%rsp• %rsp is a special register that stores the address of the current “top” of the
stack (the bottom in our diagrams, since the stack grows downwards).
0x0
main()
Heap
myfunction()
Data
Text (code)
%rsp
Main Memory
foo()
![Page 27: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/27.jpg)
27
%rsp• %rsp is a special register that stores the address of the current “top” of the
stack (the bottom in our diagrams, since the stack grows downwards).
0x0
main()
Heap
myfunction()
Data
Text (code)
%rsp
Main Memory
Key idea: %rsp must point to the same place before a function is called and after that function returns, since stack frames go away when a function finishes.
![Page 28: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/28.jpg)
28
push• The push instruction pushes the data at the specified source onto the top of
the stack, adjusting %rsp accordingly.
Instruction Effectpushq S R[%rsp] ⟵ R[%rsp] – 8;
M[R[%rsp]] ⟵ S
![Page 29: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/29.jpg)
29
push• The push instruction pushes the data at the specified source onto the top of
the stack, adjusting %rsp accordingly.
Instruction Effectpushq S R[%rsp] ⟵ R[%rsp] – 8;
M[R[%rsp]] ⟵ S
![Page 30: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/30.jpg)
30
push• The push instruction pushes the data at the specified source onto the top of
the stack, adjusting %rsp accordingly.
Instruction Effectpushq S R[%rsp] ⟵ R[%rsp] – 8;
M[R[%rsp]] ⟵ S
![Page 31: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/31.jpg)
31
push• The push instruction pushes the data at the specified source onto the top of
the stack, adjusting %rsp accordingly.
• This behavior is equivalent to the following, but pushq is a shorter instruction:subq $8, %rspmovq S, (%rsp)
• Sometimes, you’ll see instructions just explicitly decrement the stack pointer to make room for future data.
Instruction Effectpushq S R[%rsp] ⟵ R[%rsp] – 8;
M[R[%rsp]] ⟵ S
![Page 32: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/32.jpg)
32
pop• The pop instruction pops the topmost data from the stack and stores it in the
specified destination, adjusting %rsp accordingly.
• Note: this does not remove/clear out the data! It just increments %rsp to indicate the next push can overwrite that location.
Instruction Effectpopq D D ⟵ M[R[%rsp]]
R[%rsp] ⟵ R[%rsp] + 8;
![Page 33: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/33.jpg)
33
pop• The pop instruction pops the topmost data from the stack and stores it in the
specified destination, adjusting %rsp accordingly.
• This behavior is equivalent to the following, but popq is a shorter instruction: movq (%rsp), Daddq $8, %rsp
• Sometimes, you’ll see instructions just explicitly increment the stack pointer to pop data.
Instruction Effectpopq D D ⟵ M[R[%rsp]]
R[%rsp] ⟵ R[%rsp] + 8;
![Page 34: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/34.jpg)
34
Stack ExampleInitially
%rax 0x123
%rdx 0
%rsp 0x108
Stack “bottom”
Stack “top”0x108
Increasingaddresses
pushq %rax%rax 0x123
%rdx 0
%rsp 0x100
Stack “bottom”
Stack “top”
Increasingaddresses
popq %rdx%rax 0x123
%rdx 0x123
%rsp 0x108
Stack “bottom”
0x108
Increasingaddresses
0x123
Stack “top”
0x1080x100 0x100
0x123
![Page 35: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/35.jpg)
35
Calling Functions In AssemblyTo call a function in assembly, we must do a few things:• Pass Control – %rip must be adjusted to execute the callee’s instructions, and
then resume the caller’s instructions afterwards.• Pass Data – we must pass any parameters and receive any return value.• Manage Memory – we must handle any space needs of the callee on the
stack.
Terminology: caller function calls the callee function.
![Page 36: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/36.jpg)
36
Lecture Plan• Revisiting %rip 5• Calling Functions 19• The Stack 22• Passing Control 36• Passing Data 44• Local Storage 65
• Register Restrictions 69• Pulling it all together: recursion example 78• Optimizations 81• Live session slides 93
cp -r /afs/ir/class/cs107/lecture-code/lect13 .
![Page 37: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/37.jpg)
37
Remembering Where We Left OffProblem: %rip points to the next instruction to execute. To call a function, we must remember the next caller instruction to resume at after.Solution: push the next value of %rip onto the stack. Then call the function. When it is finished, put this value back into %rip and continue executing.
…
…
Stack
0xff20%rsp
main()
0x3021%rip
E.g. main() calls foo():
![Page 38: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/38.jpg)
38
Remembering Where We Left OffProblem: %rip points to the next instruction to execute. To call a function, we must remember the next caller instruction to resume at after.Solution: push the next value of %rip onto the stack. Then call the function. When it is finished, put this value back into %rip and continue executing.
…
…
0x3026
Stack
main()
0xff18%rsp
0x3021%rip
E.g. main() calls foo():
![Page 39: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/39.jpg)
39
Remembering Where We Left OffProblem: %rip points to the next instruction to execute. To call a function, we must remember the next caller instruction to resume at after.Solution: push the next value of %rip onto the stack. Then call the function. When it is finished, put this value back into %rip and continue executing.
…
…
0x3026
…
Stack
main()
foo()
0xff08%rsp
0x4058%rip
E.g. main() calls foo():
![Page 40: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/40.jpg)
40
Remembering Where We Left OffProblem: %rip points to the next instruction to execute. To call a function, we must remember the next caller instruction to resume at after.Solution: push the next value of %rip onto the stack. Then call the function. When it is finished, put this value back into %rip and continue executing.
…
…
0x3026
Stack
0xff18%rsp
0x4058%rip
main()
E.g. main() calls foo():
![Page 41: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/41.jpg)
41
Remembering Where We Left OffProblem: %rip points to the next instruction to execute. To call a function, we must remember the next caller instruction to resume at after.Solution: push the next value of %rip onto the stack. Then call the function. When it is finished, put this value back into %rip and continue executing.
…
…
Stack
main()
0xff20%rsp
0x3026%rip
E.g. main() calls foo():
![Page 42: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/42.jpg)
42
Call And ReturnThe call instruction pushes the address of the instruction immediately following the call instruction onto the stack and sets %rip to point to the beginning of the specified function’s instructions.
call Labelcall *Operand
The ret instruction pops this instruction address from the stack and stores it in %rip.
retThe stored %rip value for a function is called its return address. It is the address of the instruction at which to resume the function’s execution. (not to be confused with return value, which is the value returned from a function).
![Page 43: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/43.jpg)
43
Calling Functions In AssemblyTo call a function in assembly, we must do a few things:• Pass Control – %rip must be adjusted to execute the function being called and
then resume the caller function afterwards.• Pass Data – we must pass any parameters and receive any return value.• Manage Memory – we must handle any space needs of the callee on the
stack.
Terminology: caller function calls the callee function.
![Page 44: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/44.jpg)
44
Lecture Plan• Revisiting %rip 5• Calling Functions 19• The Stack 22• Passing Control 36• Passing Data 44• Local Storage 65
• Register Restrictions 69• Pulling it all together: recursion example 78• Optimizations 81• Live session slides 93
cp -r /afs/ir/class/cs107/lecture-code/lect13 .
![Page 45: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/45.jpg)
45
Parameters and Return• There are special registers that store parameters and the return value.• To call a function, we must put any parameters we are passing into the correct
registers. (%rdi, %rsi, %rdx, %rcx, %r8, %r9, in that order)• Parameters beyond the first 6 are put on the stack.• If the caller expects a return value, it looks in %rax after the callee completes.
![Page 46: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/46.jpg)
46
Parameters and Return...main()int main(int argc, char *argv[]) {
int i1 = 1;int i2 = 2;int i3 = 3;int i4 = 4;int result = func(&i1, &i2, &i3, &i4,
i1, i2, i3, i4);…
}
int func(int *p1, int *p2, int *p3, int *p4, int v1, int v2, int v3, int v4) {
…}
![Page 47: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/47.jpg)
47
Parameters and Return...main()
0xffea08
0x40054f
%rsp
%rip
int main(int argc, char *argv[]) {int i1 = 1;int i2 = 2;int i3 = 3;int i4 = 4;int result = func(&i1, &i2, &i3, &i4,
i1, i2, i3, i4);…
}
int func(int *p1, int *p2, int *p3, int *p4, int v1, int v2, int v3, int v4) {
…}
0x40054f <+0>: sub $0x18,%rsp0x400553 <+4>: movl $0x1,0xc(%rsp)0x40055b <+12>: movl $0x2,0x8(%rsp)0x400563 <+20>: movl $0x3,0x4(%rsp)0x40056b <+28>: movl $0x4,(%rsp)0x400572 <+35>: pushq $0x4
![Page 48: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/48.jpg)
48
Parameters and Return...
0xffe9f0
main()
0xffe9f0
0x400553
%rsp
%rip
int main(int argc, char *argv[]) {int i1 = 1;int i2 = 2;int i3 = 3;int i4 = 4;int result = func(&i1, &i2, &i3, &i4,
i1, i2, i3, i4);…
}
int func(int *p1, int *p2, int *p3, int *p4, int v1, int v2, int v3, int v4) {
…}
0x40054f <+0>: sub $0x18,%rsp0x400553 <+4>: movl $0x1,0xc(%rsp)0x40055b <+12>: movl $0x2,0x8(%rsp)0x400563 <+20>: movl $0x3,0x4(%rsp)0x40056b <+28>: movl $0x4,(%rsp)0x400572 <+35>: pushq $0x4
![Page 49: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/49.jpg)
49
Parameters and Return...
0xffe9fc 1
0xffe9f0
main()
0xffe9f0
0x40055b
%rsp
%rip
int main(int argc, char *argv[]) {int i1 = 1;int i2 = 2;int i3 = 3;int i4 = 4;int result = func(&i1, &i2, &i3, &i4,
i1, i2, i3, i4);…
}
int func(int *p1, int *p2, int *p3, int *p4, int v1, int v2, int v3, int v4) {
…}
0x40054f <+0>: sub $0x18,%rsp0x400553 <+4>: movl $0x1,0xc(%rsp)0x40055b <+12>: movl $0x2,0x8(%rsp)0x400563 <+20>: movl $0x3,0x4(%rsp)0x40056b <+28>: movl $0x4,(%rsp)0x400572 <+35>: pushq $0x4
![Page 50: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/50.jpg)
50
Parameters and Return...
0xffe9fc 10xffe9f8 2
0xffe9f0
main()
0xffe9f0
0x400563
%rsp
%rip
int main(int argc, char *argv[]) {int i1 = 1;int i2 = 2;int i3 = 3;int i4 = 4;int result = func(&i1, &i2, &i3, &i4,
i1, i2, i3, i4);…
}
int func(int *p1, int *p2, int *p3, int *p4, int v1, int v2, int v3, int v4) {
…}
0x40054f <+0>: sub $0x18,%rsp0x400553 <+4>: movl $0x1,0xc(%rsp)0x40055b <+12>: movl $0x2,0x8(%rsp)0x400563 <+20>: movl $0x3,0x4(%rsp)0x40056b <+28>: movl $0x4,(%rsp)0x400572 <+35>: pushq $0x4
![Page 51: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/51.jpg)
51
Parameters and Return...
0xffe9fc 10xffe9f8 20xffe9f4 30xffe9f0
main()
0xffe9f0
0x40056b
%rsp
%rip
int main(int argc, char *argv[]) {int i1 = 1;int i2 = 2;int i3 = 3;int i4 = 4;int result = func(&i1, &i2, &i3, &i4,
i1, i2, i3, i4);…
}
int func(int *p1, int *p2, int *p3, int *p4, int v1, int v2, int v3, int v4) {
…}
0x400553 <+4>: movl $0x1,0xc(%rsp)0x40055b <+12>: movl $0x2,0x8(%rsp)0x400563 <+20>: movl $0x3,0x4(%rsp)0x40056b <+28>: movl $0x4,(%rsp)0x400572 <+35>: pushq $0x40x400574 <+37>: pushq $0x3
![Page 52: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/52.jpg)
52
Parameters and Return...
0xffe9fc 10xffe9f8 20xffe9f4 30xffe9f0 4
main()
0xffe9f0
0x400572
%rsp
%rip
int main(int argc, char *argv[]) {int i1 = 1;int i2 = 2;int i3 = 3;int i4 = 4;int result = func(&i1, &i2, &i3, &i4,
i1, i2, i3, i4);…
}
int func(int *p1, int *p2, int *p3, int *p4, int v1, int v2, int v3, int v4) {
…}
0x40055b <+12>: movl $0x2,0x8(%rsp)0x400563 <+20>: movl $0x3,0x4(%rsp)0x40056b <+28>: movl $0x4,(%rsp)0x400572 <+35>: pushq $0x40x400574 <+37>: pushq $0x30x400576 <+39>: mov $0x2,%r9d
![Page 53: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/53.jpg)
53
Parameters and Return...
0xffe9fc 10xffe9f8 20xffe9f4 30xffe9f0 4
0xffe9e84
main()
0xffe9e8
0x400574
%rsp
%rip
int main(int argc, char *argv[]) {int i1 = 1;int i2 = 2;int i3 = 3;int i4 = 4;int result = func(&i1, &i2, &i3, &i4,
i1, i2, i3, i4);…
}
int func(int *p1, int *p2, int *p3, int *p4, int v1, int v2, int v3, int v4) {
…}
0x400563 <+20>: movl $0x3,0x4(%rsp)0x40056b <+28>: movl $0x4,(%rsp)0x400572 <+35>: pushq $0x40x400574 <+37>: pushq $0x30x400576 <+39>: mov $0x2,%r9d0x40057c <+45>: mov $0x1,%r8d
![Page 54: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/54.jpg)
54
Parameters and Return...
0xffe9fc 10xffe9f8 20xffe9f4 30xffe9f0 4
0xffe9e84
0xffe9e03
main()
0xffe9e0
0x400576
%rsp
%rip
int main(int argc, char *argv[]) {int i1 = 1;int i2 = 2;int i3 = 3;int i4 = 4;int result = func(&i1, &i2, &i3, &i4,
i1, i2, i3, i4);…
}
int func(int *p1, int *p2, int *p3, int *p4, int v1, int v2, int v3, int v4) {
…}
0x40056b <+28>: movl $0x4,(%rsp)0x400572 <+35>: pushq $0x40x400574 <+37>: pushq $0x30x400576 <+39>: mov $0x2,%r9d0x40057c <+45>: mov $0x1,%r8d0x400582 <+51>: lea 0x10(%rsp),%rcx
![Page 55: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/55.jpg)
55
Parameters and Return...
0xffe9fc 10xffe9f8 20xffe9f4 30xffe9f0 4
0xffe9e84
0xffe9e03
main()
0xffe9e0
0x40057c
%rsp
%rip
int main(int argc, char *argv[]) {int i1 = 1;int i2 = 2;int i3 = 3;int i4 = 4;int result = func(&i1, &i2, &i3, &i4,
i1, i2, i3, i4);…
}
int func(int *p1, int *p2, int *p3, int *p4, int v1, int v2, int v3, int v4) {
…}
0x400572 <+35>: pushq $0x40x400574 <+37>: pushq $0x30x400576 <+39>: mov $0x2,%r9d0x40057c <+45>: mov $0x1,%r8d0x400582 <+51>: lea 0x10(%rsp),%rcx0x400587 <+56>: lea 0x14(%rsp),%rdx
![Page 56: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/56.jpg)
56
Parameters and Return...
0xffe9fc 10xffe9f8 20xffe9f4 30xffe9f0 4
0xffe9e84
0xffe9e03
main()
0xffe9e0
0x40057c
%rsp
%rip
int main(int argc, char *argv[]) {int i1 = 1;int i2 = 2;int i3 = 3;int i4 = 4;int result = func(&i1, &i2, &i3, &i4,
i1, i2, i3, i4);…
}
int func(int *p1, int *p2, int *p3, int *p4, int v1, int v2, int v3, int v4) {
…}
0x400572 <+35>: pushq $0x40x400574 <+37>: pushq $0x30x400576 <+39>: mov $0x2,%r9d0x40057c <+45>: mov $0x1,%r8d0x400582 <+51>: lea 0x10(%rsp),%rcx0x400587 <+56>: lea 0x14(%rsp),%rdx
![Page 57: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/57.jpg)
57
Parameters and Return...
0xffe9fc 10xffe9f8 20xffe9f4 30xffe9f0 4
0xffe9e84
0xffe9e03
main()
0xffe9e0
0x40057c
%rsp
%rip
int main(int argc, char *argv[]) {int i1 = 1;int i2 = 2;int i3 = 3;int i4 = 4;int result = func(&i1, &i2, &i3, &i4,
i1, i2, i3, i4);…
}
int func(int *p1, int *p2, int *p3, int *p4, int v1, int v2, int v3, int v4) {
…}
0x400572 <+35>: pushq $0x40x400574 <+37>: pushq $0x30x400576 <+39>: mov $0x2,%r9d0x40057c <+45>: mov $0x1,%r8d0x400582 <+51>: lea 0x10(%rsp),%rcx0x400587 <+56>: lea 0x14(%rsp),%rdx
2
%r9d
![Page 58: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/58.jpg)
58
Parameters and Return...
0xffe9fc 10xffe9f8 20xffe9f4 30xffe9f0 4
0xffe9e84
0xffe9e03
main()
0xffe9e0
0x400582
%rsp
%rip
int main(int argc, char *argv[]) {int i1 = 1;int i2 = 2;int i3 = 3;int i4 = 4;int result = func(&i1, &i2, &i3, &i4,
i1, i2, i3, i4);…
}
int func(int *p1, int *p2, int *p3, int *p4, int v1, int v2, int v3, int v4) {
…}
0x400574 <+37>: pushq $0x30x400576 <+39>: mov $0x2,%r9d0x40057c <+45>: mov $0x1,%r8d0x400582 <+51>: lea 0x10(%rsp),%rcx0x400587 <+56>: lea 0x14(%rsp),%rdx0x40058c <+61>: lea 0x18(%rsp),%rsi
2
%r9d
1
%r8d
![Page 59: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/59.jpg)
59
Parameters and Return...
0xffe9fc 10xffe9f8 20xffe9f4 30xffe9f0 4
0xffe9e84
0xffe9e03
main()
0xffe9e0
0x400587
%rsp
%rip
int main(int argc, char *argv[]) {int i1 = 1;int i2 = 2;int i3 = 3;int i4 = 4;int result = func(&i1, &i2, &i3, &i4,
i1, i2, i3, i4);…
}
int func(int *p1, int *p2, int *p3, int *p4, int v1, int v2, int v3, int v4) {
…}
0x400576 <+39>: mov $0x2,%r9d0x40057c <+45>: mov $0x1,%r8d0x400582 <+51>: lea 0x10(%rsp),%rcx0x400587 <+56>: lea 0x14(%rsp),%rdx0x40058c <+61>: lea 0x18(%rsp),%rsi0x400591 <+66>: lea 0x1c(%rsp),%rdi
2
%r9d
1
%r8d
0xffe9f0
%rcx
![Page 60: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/60.jpg)
60
Parameters and Return...
0xffe9fc 10xffe9f8 20xffe9f4 30xffe9f0 4
0xffe9e84
0xffe9e03
main()
0xffe9e0
0x40058c
%rsp
%rip
int main(int argc, char *argv[]) {int i1 = 1;int i2 = 2;int i3 = 3;int i4 = 4;int result = func(&i1, &i2, &i3, &i4,
i1, i2, i3, i4);…
}
int func(int *p1, int *p2, int *p3, int *p4, int v1, int v2, int v3, int v4) {
…}
0x40057c <+45>: mov $0x1,%r8d0x400582 <+51>: lea 0x10(%rsp),%rcx0x400587 <+56>: lea 0x14(%rsp),%rdx0x40058c <+61>: lea 0x18(%rsp),%rsi0x400591 <+66>: lea 0x1c(%rsp),%rdi0x400596 <+71>: callq 0x400546 <func>
2
%r9d
1
%r8d
0xffe9f0
%rcx
0xffe9f4
%rdx
![Page 61: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/61.jpg)
61
Parameters and Return...
0xffe9fc 10xffe9f8 20xffe9f4 30xffe9f0 4
0xffe9e84
0xffe9e03
main()
0xffe9e0
0x400591
%rsp
%rip
int main(int argc, char *argv[]) {int i1 = 1;int i2 = 2;int i3 = 3;int i4 = 4;int result = func(&i1, &i2, &i3, &i4,
i1, i2, i3, i4);…
}
int func(int *p1, int *p2, int *p3, int *p4, int v1, int v2, int v3, int v4) {
…}
0x400582 <+51>: lea 0x10(%rsp),%rcx0x400587 <+56>: lea 0x14(%rsp),%rdx0x40058c <+61>: lea 0x18(%rsp),%rsi0x400591 <+66>: lea 0x1c(%rsp),%rdi0x400596 <+71>: callq 0x400546 <func>
2
%r9d
1
%r8d
0xffe9f0
%rcx
0xffe9f4
%rdx
0xffe9f8
%rsi
![Page 62: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/62.jpg)
62
Parameters and Return...
0xffe9fc 10xffe9f8 20xffe9f4 30xffe9f0 4
0xffe9e84
0xffe9e03
main()
0xffe9e0
0x400596
%rsp
%rip
int main(int argc, char *argv[]) {int i1 = 1;int i2 = 2;int i3 = 3;int i4 = 4;int result = func(&i1, &i2, &i3, &i4,
i1, i2, i3, i4);…
}
int func(int *p1, int *p2, int *p3, int *p4, int v1, int v2, int v3, int v4) {
…}
0x400587 <+56>: lea 0x14(%rsp),%rdx0x40058c <+61>: lea 0x18(%rsp),%rsi0x400591 <+66>: lea 0x1c(%rsp),%rdi0x400596 <+71>: callq 0x400546 <func>0x40059b <+76>: add $0x10,%rsp
2
%r9d
1
%r8d
0xffe9f0
%rcx
0xffe9f4
%rdx
0xffe9fc
%rdi0xffe9f8
%rsi
![Page 63: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/63.jpg)
63
Parameters and Return...
0xffe9fc 10xffe9f8 20xffe9f4 30xffe9f0 4
0xffe9e84
0xffe9e03
main()
0xffe9e0
0x400596
%rsp
%rip
int main(int argc, char *argv[]) {int i1 = 1;int i2 = 2;int i3 = 3;int i4 = 4;int result = func(&i1, &i2, &i3, &i4,
i1, i2, i3, i4);…
}
int func(int *p1, int *p2, int *p3, int *p4, int v1, int v2, int v3, int v4) {
…}
0x40058c <+61>: lea 0x18(%rsp),%rsi0x400591 <+66>: lea 0x1c(%rsp),%rdi0x400596 <+71>: callq 0x400546 <func>0x40059b <+76>: add $0x10,%rsp…
2
%r9d
1
%r8d
0xffe9f0
%rcx
0xffe9f4
%rdx
0xffe9fc
%rdi0xffe9f8
%rsi
![Page 64: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/64.jpg)
64
Parameters and Return...
0xffe9fc 10xffe9f8 20xffe9f4 30xffe9f0 4
0xffe9e84
0xffe9e03
0x40059b
main()
0xffe9d8
0x400596
%rsp
%rip
int main(int argc, char *argv[]) {int i1 = 1;int i2 = 2;int i3 = 3;int i4 = 4;int result = func(&i1, &i2, &i3, &i4,
i1, i2, i3, i4);…
}
int func(int *p1, int *p2, int *p3, int *p4, int v1, int v2, int v3, int v4) {
…}
0x40058c <+61>: lea 0x18(%rsp),%rsi0x400591 <+66>: lea 0x1c(%rsp),%rdi0x400596 <+71>: callq 0x400546 <func>0x40059b <+76>: add $0x10,%rsp…
2
%r9d
1
%r8d
0xffe9f0
%rcx
0xffe9f4
%rdx
0xffe9fc
%rdi0xffe9f8
%rsi
![Page 65: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/65.jpg)
65
Lecture Plan• Revisiting %rip 5• Calling Functions 19• The Stack 22• Passing Control 36• Passing Data 44• Local Storage 65
• Register Restrictions 69• Pulling it all together: recursion example 78• Optimizations 81• Live session slides 93
cp -r /afs/ir/class/cs107/lecture-code/lect13 .
![Page 66: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/66.jpg)
66
Calling Functions In AssemblyTo call a function in assembly, we must do a few things:• Pass Control – %rip must be adjusted to execute the function being called and
then resume the caller function afterwards.• Pass Data – we must pass any parameters and receive any return value.• Manage Memory – we must handle any space needs of the callee on the
stack.
Terminology: caller function calls the callee function.
![Page 67: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/67.jpg)
67
Local Storage• So far, we’ve often seen local variables stored directly in registers, rather than
on the stack as we’d expect. This is for optimization reasons.• There are three common reasons that local data must be in memory:• We’ve run out of registers• The ‘&’ operator is used on it, so we must generate an address for it• They are arrays or structs (need to use address arithmetic)
![Page 68: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/68.jpg)
68
Local Storagelong caller() {
long arg1 = 534;long arg2 = 1057;long sum = swap_add(&arg1, &arg2);...
}caller:
sub $0x10, %rsp // 16 bytes for stack framemovq $0x216, 0x8(%rsp) // store 534 in arg1movq $0x421, (%rsp) // store 1057 in arg2mov %rsp, %rsi // compute &arg2 as second arglea 0x8(%rsp), %rdi // compute &arg1 as first argcallq swap_add // call swap_add(&arg1, &arg2)
![Page 69: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/69.jpg)
69
Lecture Plan• Revisiting %rip 5• Calling Functions 19• The Stack 22• Passing Control 36• Passing Data 44• Local Storage 65
• Register Restrictions 69• Pulling it all together: recursion example 78• Optimizations 81
cp -r /afs/ir/class/cs107/lecture-code/lect13 .
![Page 70: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/70.jpg)
70
Register RestrictionsThere is only one copy of registers for all programs and functions.• Problem: what if funcA is building up a value in register %r10, and calls funcB
in the middle, which also has instructions that modify %r10? funcA’s value will be overwritten!
• Solution: make some “rules of the road” that callers and callees must follow when using registers so they do not interfere with one another.
• These rules define two types of registers: caller-owned and callee-owned
![Page 71: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/71.jpg)
71
Caller/Callee
main
function1
function2
Caller/callee is terminology that refers to a pair of functions. A single function may be both a caller and calleesimultaneously (e.g.function1 at right).
calls
calls
main is the caller, and function1 is the callee.
function1 is the caller, and function2 is the callee.
![Page 72: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/72.jpg)
72
Register Restrictions
• Callee must save the existing value and restore it when done.
• Caller can store values and assume they will be preserved across function calls.
• Callee does not need to save the existing value.
• Caller’s values could be overwritten by a callee! The caller may consider saving values elsewhere before calling functions.
Caller-Owned Callee-Owned
![Page 73: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/73.jpg)
73
Caller-Owned Registers
main
function1
calls
main can use caller-owned registers and know that function1 will not permanently modify their values.
If function1 wants to use any caller-owned registers, it must save the existing values and restore them before returning.
![Page 74: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/74.jpg)
74
Caller-Owned Registers
function1:push %rbppush %rbx...pop %rbxpop %rbpretq
main
function1
calls
![Page 75: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/75.jpg)
75
Callee-Owned Registers
main can use callee-owned registers but calling function1may permanently modify their values.
If function1 wants to use any callee-owned registers, it can do so without saving the existing values.
main
function1
calls
![Page 76: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/76.jpg)
76
Callee-Owned Registers
main
function1
calls
main:...push %r10push %r11callq function1pop %r11pop %r10...
![Page 77: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/77.jpg)
77
A Day In the Life of function1
main
function1
function2
calls
calls
Caller-owned registers:• function1 must save/restore existing values
of any it wants to use.• function1 can assume that calling
function2 will not permanently change their values.
Callee-owned registers:• function1 does not need to save/restore
existing values of any it wants to use.• calling function2 may permanently change
their values.
![Page 78: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/78.jpg)
78
Lecture Plan• Revisiting %rip 5• Calling Functions 19• The Stack 22• Passing Control 36• Passing Data 44• Local Storage 65
• Register Restrictions 69• Pulling it all together: recursion example 78• Optimizations 81• Live session slides 93
cp -r /afs/ir/class/cs107/lecture-code/lect13 .
![Page 79: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/79.jpg)
79
Example: Recursion• Let’s look at an example of recursion at the assembly level.• We’ll use everything we’ve learned about registers, the stack, function calls,
parameters, and assembly instructions!• We’ll also see how helpful GDB can be when tracing through assembly.
factorial.c and factorial
![Page 80: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/80.jpg)
80
Our First Assemblyint sum_array(int arr[], int nelems) {
int sum = 0;for (int i = 0; i < nelems; i++) {
sum += arr[i];}return sum;
}
0000000000401136 <sum_array>:401136 <+0>: mov $0x0,%eax40113b <+5>: mov $0x0,%edx401140 <+10>: cmp %esi,%eax401142 <+12>: jge 0x40114f <sum_array+25>401144 <+14>: movslq %eax,%rcx401147 <+17>: add (%rdi,%rcx,4),%edx40114a <+20>: add $0x1,%eax40114d <+23>: jmp 0x401140 <sum_array+10>40114f <+25>: mov %edx,%eax401151 <+27>: retq
We’re done with all our assembly lectures! Now we can fully understand what’s going on in the assembly below, including how someone would call sum_array in assembly and what the ret instruction does.
![Page 81: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/81.jpg)
81
Lecture Plan• Revisiting %rip 5• Calling Functions 19• The Stack 22• Passing Control 36• Passing Data 44• Local Storage 65
• Register Restrictions 69• Pulling it all together: recursion example 78• Optimizations 81• Live session slides 93
cp -r /afs/ir/class/cs107/lecture-code/lect13 .
![Page 82: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/82.jpg)
82
Optimizations you’ll seenop• nop/nopl are “no-op” instructions – they do nothing!• Intent: Make functions align on address boundaries that are nice multiples of 8.• “Sometimes, doing nothing is how to be most productive” – Philosopher Nick
mov %ebx,%ebx• Zeros out the top 32 register bits (because a mov on an e-register zeros out rest
of 64 bits).
xor %ebx,%ebx• Optimizes for performance as well as code size (read more here):
b8 00 00 00 00 mov $0x0,%eax31 c0 xor %eax,%eax
![Page 83: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/83.jpg)
83
GCC For Loop Output
InitializationJump to testBodyUpdateTestJump to body if success
InitializationTestJump past loop if successBodyUpdateJump to test
GCC Common For Loop Output Possible Alternative
![Page 84: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/84.jpg)
84
GCC For Loop Output
InitializationJump to testBodyUpdateTestJump to body if success
InitializationTestJump past loop if successBodyUpdateJump to test
GCC Common For Loop Output Possible Alternative
for (int i = 0; i < n; i++) // n = 100
![Page 85: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/85.jpg)
85
GCC For Loop Output
InitializationJump to testBodyUpdateTestJump to body if success
InitializationTestJump past loop if successBodyUpdateJump to test
GCC Common For Loop Output Possible Alternative
for (int i = 0; i < n; i++) // n = 100
InitializationTestNo jumpBodyUpdateJump to testTestNo jumpBodyUpdateJump to test...
![Page 86: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/86.jpg)
86
GCC For Loop Output
InitializationJump to testBodyUpdateTestJump to body if success
InitializationTestJump past loop if successBodyUpdateJump to test
GCC Common For Loop Output Possible Alternative
for (int i = 0; i < n; i++) // n = 100
InitializationTestNo jumpBodyUpdateJump to testTestNo jumpBodyUpdateJump to test...
![Page 87: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/87.jpg)
87
GCC For Loop Output
InitializationJump to testBodyUpdateTestJump to body if success
InitializationTestJump past loop if passesBodyUpdateJump to test
GCC Common For Loop Output Possible Alternative
for (int i = 0; i < n; i++) // n = 100
InitializationJump to testTestJump to bodyBodyUpdateTestJump to bodyBodyUpdateTestJump to body...
![Page 88: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/88.jpg)
88
GCC For Loop Output
InitializationJump to testBodyUpdateTestJump to body if success
InitializationTestJump past loop if passesBodyUpdateJump to test
GCC Common For Loop Output Possible Alternative
for (int i = 0; i < n; i++) // n = 100
InitializationJump to testTestJump to bodyBodyUpdateTestJump to bodyBodyUpdateTestJump to body...
![Page 89: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/89.jpg)
89
GCC For Loop Output
InitializationJump to testBodyUpdateTestJump to body if success
InitializationTestJump past loop if passesBodyUpdateJump to test
GCC Common For Loop Output Possible Alternative
Which instructions are better when n = 0? n = 1000?
for (int i = 0; i < n; i++)
![Page 90: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/90.jpg)
90
Optimizing Instruction Counts• Both versions have the same static instruction count (# of written instructions).• But they have different dynamic instruction counts (# of executed instructions
when program is run).• If n = 0, left (GCC common output) is best b/c fewer instructions• If n is large, right (alternative) is best b/c fewer instructions
• The compiler may emit a static instruction count that is several times longer than an alternative, but it may be more efficient if loop executes many times.
• Does the compiler know that a loop will execute many times? (in general, no)• So what if our code had loops that always execute a small number of times?
How do we know when gcc makes a bad decision?• (take EE108, EE180, CS316 for more!)
![Page 91: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/91.jpg)
91
Optimizations• Conditional Moves can sometimes eliminate “branches” (jumps), which are
particularly inefficient on modern computer hardware.• Processors try to predict the future execution of instructions for maximum
performance. This is difficult to do with jumps.
![Page 92: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/92.jpg)
92
Recap• Revisiting %rip• Calling Functions• The Stack• Passing Control• Passing Data• Local Storage
• Register Restrictions• Pulling it all together: recursion example• Optimizations
That’s it for assembly! Next time: managing the heap
![Page 93: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/93.jpg)
93
Live Session Slides
![Page 94: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/94.jpg)
94
Plan For Today• 10 minutes: general review• 5 minutes: post questions or comments on Ed for what we should discuss
Lecture 13 takeaway: Function calls rely on the special %rip and %rsp registers to execute another function’s instructions and make stack space. We rely on special registers to pass parameters and the return value between functions. And there are caller and callee owned registers to manage use across functions.
![Page 95: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/95.jpg)
95
Key GDB Tips For Assembly• Examine 4 giant words (8 bytes) on the stack:
(gdb) x/4g $rsp0x7fffffffe870: 0x0000000000000005 0x00000000004005590x7fffffffe880: 0x0000000000000000 0x0000000000400575
• display/undisplay (prints out things every time you step/next)(gdb) display/4w $rsp1: x/4xw $rsp0x7fffffffe8a8: 0xf7a2d830 0x00007fff 0x00000000 0x00000000
![Page 96: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/96.jpg)
96
Key GDB Tips For Assembly• stepi/finish: step into current function call/return to caller:
(gdb) finish
• Set register values during the run(gdb) p $rdi = $rdi + 1
(Might be useful to write down the original value of $rdi somewhere)• Tui things• refresh• focus cmd – use up/down arrows on gdb command line (vs focus asm, focus regs)• layout regs, layout asm
![Page 97: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/97.jpg)
98
Plan For Today• 10 minutes: general review• 5 minutes: post questions or comments on Ed for what we should discuss
Lecture 13 takeaway: Function calls rely on the special %rip and %rsp registers to execute another function’s instructions and make stack space. We rely on special registers to pass parameters and the return value between functions. And there are caller and callee owned registers to manage use across functions.
![Page 98: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/98.jpg)
99
Extra Practice – Escape Room 2
escape_room
https://godbolt.org/z/8e31fG4r5
![Page 99: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/99.jpg)
100
Escape room assembly code000000000000115b <escape_room>:
115b: 48 83 ec 08 sub $0x8,%rsp115f: ba 0a 00 00 00 mov $0xa,%edx1164: be 00 00 00 00 mov $0x0,%esi1169: e8 d2 fe ff ff callq 1040 <strtol@plt>116e: 48 89 c7 mov %rax,%rdi1171: e8 d3 ff ff ff callq 1149 <transform>1176: a8 01 test $0x1,%al1178: 74 0a je 1184 <escape_room+0x29>117a: b8 00 00 00 00 mov $0x0,%eax117f: 48 83 c4 08 add $0x8,%rsp1183: c3 retq1184: b8 01 00 00 00 mov $0x1,%eax1189: eb f4 jmp 117f <escape_room+0x24>
![Page 100: CS107, Lecture 13](https://reader031.vdocument.in/reader031/viewer/2022020620/61e53dd92583e72e951d2209/html5/thumbnails/100.jpg)
101
Escape room assembly code0000000000001149 <transform>:
1149: 8d 04 bd 00 00 00 00 lea 0x0(,%rdi,4),%eax1150: 8d 50 01 lea 0x1(%rax),%edx1153: 83 fa 32 cmp $0x32,%edx1156: 7f 02 jg 115a <transform+0x11>1158: 89 d0 mov %edx,%eax115a: c3 retq