University of Washington

Section 5: Procedures & Stacks

 Stacks in memory and stack operations
 The stack used to keep track of procedure calls
 Return addresses and return values
 Stack-based languages
 The Linux stack frame
 Passing arguments on the stack
 Allocating local variables on the stack
 Register-saving conventions
 Procedures and stacks on x64 architecture

x64 Procedures and Stacks

 University of Washington

x86-64 Procedure Calling Convention

 Doubling of registers makes us less dependent on stack
 Store argument in registers
 Store temporary variables in registers

 What do we do if we have too many arguments or too many

temporary variables?

x64 Procedures and Stacks

 University of Washington

x86-64 64-bit Registers: Usage Conventions

%rax Return value %r8 Argument #5

%rbx Callee saved %r9 Argument #6

%rcx Argument #4 %r10 Caller saved

%rdx Argument #3 %r11 Caller Saved

%rsi Argument #2 %r12 Callee saved

%rdi Argument #1 %r13 Callee saved

%rsp Stack pointer %r14 Callee saved

%rbp Callee saved %r15 Callee saved

x64 Procedures and Stacks

 University of Washington

Revisiting swap, IA32 vs. x86-64 versions

swap: swap (64-bit long ints):
pushl %ebp movq (%rdi), %rdx
movl %esp,%ebp Set movq (%rsi), %rax
pushl %ebx Up movq %rax, (%rdi)
movq %rdx, (%rsi)
movl 12(%ebp),%ecx ret
movl 8(%ebp),%edx
movl (%ecx),%eax
Body
 Arguments passed in registers
movl (%edx),%ebx  First (xp) in %rdi,
movl %eax,(%edx) second (yp) in %rsi
movl %ebx,(%ecx)
 64-bit pointers
movl -4(%ebp),%ebx  No stack operations
movl %ebp,%esp
popl %ebp
Finish required (except ret)
ret  Avoiding stack
 Can hold all local information
in registers
x64 Procedures and Stacks
 University of Washington

X86-64 procedure call highlights

 Arguments (up to first 6) in registers
 Faster to get these values from registers than from stack in memory
 Local variables also in registers (if there is room)
 callq instruction stores 64-bit return address on stack
 Address pushed onto stack, decrementing %rsp by 8
 No frame pointer
 All references to stack frame made relative to %rsp; eliminates need to
update %ebp/%rbp, which is now available for general-purpose use
 Functions can access memory up to 128 bytes beyond %rsp:
the “red zone”
 Can store some temps on stack without altering %rsp
 Registers still designated “caller-saved” or “callee-saved”

x64 Procedures and Stacks

 University of Washington

x86-64 Stack Frames

 Often (ideally), x86-64 functions need no stack frame at all
 Just a return address is pushed onto the stack when a function call is
made
 A function does need a stack frame when it:
 Has too many local variables to hold in registers
 Has local variables that are arrays or structs
 Uses the address-of operator (&) to compute the address of a local
variable
 Calls another function that takes more than six arguments
 Needs to save the state of callee-save registers before modifying them

x64 Procedures and Stacks

 University of Washington

Example
long int call_proc() call_proc:
{ subq $32,%rsp
long x1 = 1; movq $1,16(%rsp)
int x2 = 2; movl $2,24(%rsp)
short x3 = 3; movw $3,28(%rsp)
char x4 = 4; movb $4,31(%rsp)
proc(x1, &x1, x2, &x2, • • •
x3, &x3, x4, &x4);
return (x1+x2)*(x3-x4);
}

Return address to caller of call_proc %rsp

NB: Details may vary

depending on compiler.
x64 Procedures and Stacks
 University of Washington

Example
long int call_proc() call_proc:
{ subq $32,%rsp
long x1 = 1; movq $1,16(%rsp)
int x2 = 2; movl $2,24(%rsp)
short x3 = 3; movw $3,28(%rsp)
char x4 = 4; movb $4,31(%rsp)
proc(x1, &x1, x2, &x2, • • •
x3, &x3, x4, &x4);
return (x1+x2)*(x3-x4);
}

Return address to caller of call_proc

x4 x3 x2
x1

%rsp

x64 Procedures and Stacks

 University of Washington

Example
long int call_proc() call_proc:
{ • • •
long x1 = 1; movq $1,%rdi
int x2 = 2; leaq 16(%rsp),%rsi
short x3 = 3; movl $2,%edx
char x4 = 4; leaq 24(%rsp),%rcx
proc(x1, &x1, x2, &x2, movl $3,%r8d
x3, &x3, x4, &x4); leaq 28(%rsp),%r9
return (x1+x2)*(x3-x4); movl $4,(%rsp)
} leaq 31(%rsp),%rax
movq %rax,8(%rsp)
Return address to caller of call_proc call proc
x4 x3 x2 • • •
x1 Arguments passed in (in order):
Arg 8 rdi, rsi, rdx, rcx, r8, r9, then stack
Arg 7 %rsp

x64 Procedures and Stacks

 University of Washington

Example
long int call_proc() call_proc:
{ • • •
long x1 = 1; movq $1,%rdi
int x2 = 2; leaq 16(%rsp),%rsi
short x3 = 3; movl $2,%edx
char x4 = 4; leaq 24(%rsp),%rcx
proc(x1, &x1, x2, &x2, movl $3,%r8d
x3, &x3, x4, &x4); leaq 28(%rsp),%r9
return (x1+x2)*(x3-x4); movl $4,(%rsp)
} leaq 31(%rsp),%rax
movq %rax,8(%rsp)
Return address to caller of call_proc call proc
x4 x3 x2 • • •
x1 Arguments passed in (in order):
Arg 8 rdi, rsi, rdx, rcx, r8, r9, then stack
Arg 7
Return address to line after call to proc %rsp
x64 Procedures and Stacks
 University of Washington

Example
long int call_proc() call_proc:
{ • • •
long x1 = 1; movswl 28(%rsp),%eax
int x2 = 2; movsbl 31(%rsp),%edx
short x3 = 3; subl %edx,%eax
char x4 = 4; cltq
proc(x1, &x1, x2, &x2, movslq 24(%rsp),%rdx
x3, &x3, x4, &x4); addq 16(%rsp),%rdx
return (x1+x2)*(x3-x4); imulq %rdx,%rax
} addq $32,%rsp
ret
Return address to caller of call_proc
x4 x3 x2
x1
Arg 8
Arg 7 %rsp

x64 Procedures and Stacks

 University of Washington

Example
long int call_proc() call_proc:
{ • • •
long x1 = 1; movswl 28(%rsp),%eax
int x2 = 2; movsbl 31(%rsp),%edx
short x3 = 3; subl %edx,%eax
char x4 = 4; cltq
proc(x1, &x1, x2, &x2, movslq 24(%rsp),%rdx
x3, &x3, x4, &x4); addq 16(%rsp),%rdx
return (x1+x2)*(x3-x4); imulq %rdx,%rax
} addq $32,%rsp
ret
Return address to caller of call_proc %rsp

x64 Procedures and Stacks

 University of Washington

x86-64 Procedure Summary

 Heavy use of registers (faster than using stack in memory)
 Parameter passing
 More temporaries since more registers

 Minimal use of stack

 Sometimes none
 When needed, allocate/deallocate entire frame at once
 No more frame pointer: address relative to stack pointer

 More room for compiler optimizations

 Prefer to store data in registers rather than memory
 Minimize modifications to stack pointer

x64 Procedures and Stacks