1. Ithaca College
Machine-Level Programming VII: Procedures Comp 21000: Introduction to Computer Systems & Assembly Lang Spring 2017

2. Mechanisms in Procedures•
y = Q(x);
print(y) }
Passing control
To beginning of procedure code
Back to return point
Passing data
Procedure arguments
Return value
Memory management
Allocate during procedure execution
Deallocate upon return
Mechanisms all implemented with machine instructions
x86-64 implementation of a procedure uses only those mechanisms required
int Q(int i) {
int t = 3*i;
int v[10]; •
return v[t]; }

3. Today Procedures Stack Structure Calling Conventions Passing control
Ithaca College
Today
Procedures
Stack Structure
Calling Conventions
Passing control
Passing data
Managing local data
Illustration of Recursion

4. x86-64 Stack Stack “Bottom”
Ithaca College
x86-64 Stack
Stack Pointer: %rsp
Stack Grows
Down
Increasing
Addresses
Stack “Top”
Stack “Bottom”
Region of memory managed with stack discipline
Grows toward lower addresses
Register %rsp contains lowest stack address
address of “top” element

5. x86-64 Stack: Push Stack “Bottom” pushq Src Stack Pointer: %rsp
Ithaca College
x86-64 Stack: Push
Stack “Bottom”
pushq Src
Fetch operand at Src
Decrement %rsp by 8
Write operand at address given by %rsp
Increasing
Addresses
Stack Grows
Down
Stack Pointer: %rsp
Stack “Top” -8

6. x86-64 Stack: Pop Stack “Bottom” popq Dest Stack Pointer: %rsp
Ithaca College
x86-64 Stack: Pop
Stack “Bottom”
popq Dest
Read value at address given by %rsp
Increment %rsp by 8
Store value at Dest (must be register)
Increasing
Addresses
Stack Grows
Down +8
Stack Pointer: %rsp
Stack “Top”

7. pushl and popl instructions
Effect
Description
pushq S
R[%rsp] R[%rsp]–8;
M[R[%rsp]]S
Push on runtime stack
popq D
DM[R[%rsp]];
R[%rsp]R[%rsp]+8
Pop from runtime stack
Notes: 1. both instructions take a single operand
2. Stack is a place in memory allocated to a process
3. Stack grows from smaller addresses to larger addresses
4. %rsp holds the address of the current top of stack
5. When pushq a value, first increment %rsp by 8, then write the value at the new top of stack address.
Effect of a pushq %rbp instruction:
subq $8, %rsp
movq %rbp, (%rsp)
Effect of a popq %rax instruction:
movq (%rsp), %rax
addq $8, %rsp

8. Initially
pushq %rax
popq %rdx
0x123
0x108
%rax
%rdx
%rsp
0x123
0x100
%rax
%rdx
%rsp
0x123
0x108
%rax
%rdx
%rsp •
Stack “top”
Stack “bottom”
Stack “bottom”
Stack “bottom” • •
Increasing
address
Stack Grows
Down
0x108
0x108
0x108
0x123
0x123
0x100
Stack “top”
Stack “top”
1. By convention we draw the stack with the top towards the bottom
2. stack grows toward lower addresses

9. Today Procedures Stack Structure Calling Conventions Passing control
Ithaca College
Today
Procedures
Stack Structure
Calling Conventions
Passing control
Passing data
Managing local data
Illustration of Recursion

10. Code Examples void multstore (long x, long y, long *dest) {
long t = mult2(x, y);
*dest = t; }
<multstore>:
400540: push %rbx # Save %rbx
400541: mov %rdx,%rbx # Save dest
400544: callq <mult2> # mult2(x,y)
400549: mov %rax,(%rbx) # Save at dest
40054c: pop %rbx # Restore %rbx
40054d: retq # Return
long mult2
(long a, long b) {
long s = a * b;
return s; }
<mult2>:
400550: mov %rdi,%rax # a
400553: imul %rsi,%rax # a * b
400557: retq # Return

11. Procedure Control Flow
Ithaca College
Procedure Control Flow
Use stack to support procedure call and return
Procedure call: call label
Push return address on stack
Jump to label
Return address:
Address of the next instruction right after call
Example from disassembly
804854e: e8 3d call b90 <main>
: pushl %eax
Return address = 0x
Procedure return: ret
Pop address from stack
Jump to address

12. Control Flow Example #1 • 0x130 0000000000400540 <multstore>: •
400544: callq <mult2>
400549: mov %rax,(%rbx)
0x128
0x120
%rsp
0x120
%rip
0x400544
<mult2>:
400550: mov %rdi,%rax •
400557: retq

13. Control Flow Example #2 • %rsp 0x120 0x128 0x130 0x118 %rip
<multstore>: •
400544: callq <mult2>
400549: mov %rax,(%rbx)
0x400549
0x118
0x400550
<mult2>:
400550: mov %rdi,%rax •
400557: retq

14. Control Flow Example #3 • %rsp 0x120 0x128 0x130 0x118 %rip
<multstore>: •
400544: callq <mult2>
400549: mov %rax,(%rbx)
0x400549
0x118
0x400557
<mult2>:
400550: mov %rdi,%rax •
400557: retq

15. Control Flow Example #4 • 0x130 0000000000400540 <multstore>: •
400544: callq <mult2>
400549: mov %rax,(%rbx)
0x128
0x120
%rsp
0x120
%rip
0x400549
<mult2>:
400550: mov %rdi,%rax •
400557: retq