CSCE 212 Computer Architecture Lecture 9 Procedures Topics Procedures Lab 02 comments Vim, gedit February 14, 2017

Overview Last Time New Lec 08 – control Lab 02 – Lab 02 – Divide and Conquer then combine Lec 09 Procedures

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]; }

Today Procedures Passing control Passing data Managing local data Carnegie Mellon Today Procedures Stack Structure Calling Conventions Passing control Passing data Managing local data Illustration of Recursion

x86-64 Stack Stack “Bottom” Carnegie Mellon 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

x86-64 Stack: Push Stack “Bottom” pushq Src Stack Pointer: %rsp Carnegie Mellon 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

x86-64 Stack: Pop Stack “Bottom” popq Dest Stack Pointer: %rsp Carnegie Mellon 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”

Today Procedures Passing control Passing data Managing local data Carnegie Mellon Today Procedures Stack Structure Calling Conventions Passing control Passing data Managing local data Illustration of Recursion

Code Examples void multstore (long x, long y, long *dest) { long t = mult2(x, y); *dest = t; } 0000000000400540 <multstore>: 400540: push %rbx # Save %rbx 400541: mov %rdx,%rbx # Save dest 400544: callq 400550 <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; } 0000000000400550 <mult2>: 400550: mov %rdi,%rax # a 400553: imul %rsi,%rax # a * b 400557: retq # Return

Procedure Control Flow Carnegie Mellon 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 Procedure return: ret Pop address from stack Jump to address

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

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

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

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

Today Procedures Passing control Passing data Managing local data Carnegie Mellon Today Procedures Stack Structure Calling Conventions Passing control Passing data Managing local data Illustrations of Recursion & Pointers

Procedure Data Flow Registers Stack First 6 arguments Return value Carnegie Mellon Procedure Data Flow Registers Stack First 6 arguments Return value Arg 7 • • • Arg 8 Arg n %rdi %rsi %rdx %rcx %r8 %r9 %rax Only allocate stack space when needed

Data Flow Examples void multstore (long x, long y, long *dest) { long t = mult2(x, y); *dest = t; } Data Flow Examples 0000000000400540 <multstore>: # x in %rdi, y in %rsi, dest in %rdx • • • 400541: mov %rdx,%rbx # Save dest 400544: callq 400550 <mult2> # mult2(x,y) # t in %rax 400549: mov %rax,(%rbx) # Save at dest long mult2 (long a, long b) { long s = a * b; return s; } 0000000000400550 <mult2>: # a in %rdi, b in %rsi 400550: mov %rdi,%rax # a 400553: imul %rsi,%rax # a * b # s in %rax 400557: retq # Return

Today Procedures Passing control Passing data Managing local data Carnegie Mellon Today Procedures Stack Structure Calling Conventions Passing control Passing data Managing local data Illustration of Recursion

Stack-Based Languages Carnegie Mellon Stack-Based Languages Languages that support recursion e.g., C, Pascal, Java Code must be “Reentrant” Multiple simultaneous instantiations of single procedure Need some place to store state of each instantiation Arguments Local variables Return pointer Stack discipline State for given procedure needed for limited time From when called to when return Callee returns before caller does Stack allocated in Frames state for single procedure instantiation

Call Chain Example Example Call Chain yoo(…) { • who(); } yoo who(…) { Carnegie Mellon Call Chain Example Example Call Chain yoo(…) { • who(); } yoo who(…) { • • • amI(); } who amI(…) { • amI(); } amI amI amI amI Procedure amI() is recursive

Stack Frames Contents Management “Set-up” code Carnegie Mellon Stack Frames Previous Frame Frame for proc Contents Return information Local storage (if needed) Temporary space (if needed) Management Space allocated when enter procedure “Set-up” code Includes push by call instruction Deallocated when return “Finish” code Includes pop by ret instruction Frame Pointer: %rbp (Optional) x Stack Pointer: %rsp Stack “Top”

Example Stack yoo yoo yoo(…) %rbp { • yoo who(); who %rsp } amI amI Carnegie Mellon Example Stack yoo yoo yoo(…) { • who(); } %rbp %rsp yoo who amI amI amI amI

Example Stack yoo who yoo(…) { • who(); } yoo who(…) { • • • amI(); } Carnegie Mellon Example Stack yoo who yoo(…) { • who(); } yoo who(…) { • • • amI(); } yoo who %rbp %rsp amI amI amI amI

Example Stack yoo who amI yoo(…) { • who(); } yoo who(…) { • • • Carnegie Mellon Example Stack yoo who amI yoo(…) { • who(); } yoo who(…) { • • • amI(); } yoo amI(…) { • amI(); } who amI amI %rbp %rsp amI amI

Example Stack yoo who amI yoo(…) { • who(); } yoo who(…) { • • • Carnegie Mellon Example Stack yoo who amI yoo(…) { • who(); } yoo who(…) { • • • amI(); } yoo amI(…) { • amI(); } who amI(…) { • amI(); } amI amI amI %rbp %rsp amI

Example Stack yoo who amI yoo(…) { • who(); } yoo who(…) { • • • Carnegie Mellon Example Stack yoo who amI yoo(…) { • who(); } yoo who(…) { • • • amI(); } yoo amI(…) { • amI(); } who amI(…) { • amI(); } amI amI amI(…) { • amI(); } amI amI %rbp %rsp

Example Stack yoo who amI yoo(…) { • who(); } yoo who(…) { • • • Carnegie Mellon Example Stack yoo who amI yoo(…) { • who(); } yoo who(…) { • • • amI(); } yoo amI(…) { • amI(); } who amI(…) { • amI(); } amI amI amI %rbp %rsp amI

Example Stack yoo who amI yoo(…) { • who(); } yoo who(…) { • • • Carnegie Mellon Example Stack yoo who amI yoo(…) { • who(); } yoo who(…) { • • • amI(); } yoo amI(…) { • amI(); } who amI amI %rbp %rsp amI amI

Example Stack yoo who yoo(…) { • who(); } yoo who(…) { • • • amI(); } Carnegie Mellon Example Stack yoo who yoo(…) { • who(); } yoo who(…) { • • • amI(); } yoo who %rbp %rsp amI amI amI amI

Example Stack yoo who amI yoo(…) { • who(); } yoo who(…) { • • • Carnegie Mellon Example Stack yoo who amI yoo(…) { • who(); } yoo who(…) { • • • amI(); } yoo amI(…) { • amI(); } who amI amI %rbp %rsp amI amI

Example Stack yoo who yoo(…) { • who(); } yoo who(…) { • • • amI(); } Carnegie Mellon Example Stack yoo who yoo(…) { • who(); } yoo who(…) { • • • amI(); } yoo who %rbp %rsp amI amI amI amI

Example Stack yoo yoo %rbp yoo(…) yoo { • who who(); %rsp } amI amI Carnegie Mellon Example Stack yoo yoo %rbp %rsp yoo(…) { • who(); } yoo who amI amI amI amI

x86-64/Linux Stack Frame Current Stack Frame (“Top” to Bottom) Carnegie Mellon x86-64/Linux Stack Frame Current Stack Frame (“Top” to Bottom) “Argument build:” Parameters for function about to call Local variables If can’t keep in registers Saved register context Old frame pointer (optional) Caller Stack Frame Return address Pushed by call instruction Arguments for this call Caller Frame Arguments 7+ Frame pointer %rbp Return Addr Old %rbp (Optional) Saved Registers + Local Variables Argument Build (Optional) Stack pointer %rsp

Example: incr long incr(long *p, long val) { long x = *p; Carnegie Mellon Example: incr long incr(long *p, long val) { long x = *p; long y = x + val; *p = y; return x; } incr: movq (%rdi), %rax addq %rax, %rsi movq %rsi, (%rdi) ret Register Use(s) %rdi Argument p %rsi Argument val, y %rax x, Return value

Example: Calling incr #1 Carnegie Mellon Example: Calling incr #1 Initial Stack Structure long call_incr() { long v1 = 15213; long v2 = incr(&v1, 3000); return v1+v2; } . . . Rtn address %rsp call_incr: subq $16, %rsp movq $15213, 8(%rsp) movl $3000, %esi leaq 8(%rsp), %rdi call incr addq 8(%rsp), %rax addq $16, %rsp ret Resulting Stack Structure . . . Rtn address 15213 %rsp+8 Unused %rsp

Example: Calling incr #2 Carnegie Mellon Example: Calling incr #2 Stack Structure long call_incr() { long v1 = 15213; long v2 = incr(&v1, 3000); return v1+v2; } . . . Rtn address 15213 %rsp+8 Unused %rsp call_incr: subq $16, %rsp movq $15213, 8(%rsp) movl $3000, %esi leaq 8(%rsp), %rdi call incr addq 8(%rsp), %rax addq $16, %rsp ret Register Use(s) %rdi &v1 %rsi 3000

Example: Calling incr #3 Carnegie Mellon Example: Calling incr #3 Stack Structure long call_incr() { long v1 = 15213; long v2 = incr(&v1, 3000); return v1+v2; } . . . Rtn address 18213 %rsp+8 Unused %rsp call_incr: subq $16, %rsp movq $15213, 8(%rsp) movl $3000, %esi leaq 8(%rsp), %rdi call incr addq 8(%rsp), %rax addq $16, %rsp ret Register Use(s) %rdi &v1 %rsi 3000

Example: Calling incr #4 Carnegie Mellon Example: Calling incr #4 Stack Structure . . . long call_incr() { long v1 = 15213; long v2 = incr(&v1, 3000); return v1+v2; } Rtn address 18213 %rsp+8 Unused %rsp call_incr: subq $16, %rsp movq $15213, 8(%rsp) movl $3000, %esi leaq 8(%rsp), %rdi call incr addq 8(%rsp), %rax addq $16, %rsp ret Register Use(s) %rax Return value Updated Stack Structure . . . Rtn address %rsp

Example: Calling incr #5 Carnegie Mellon Example: Calling incr #5 Updated Stack Structure long call_incr() { long v1 = 15213; long v2 = incr(&v1, 3000); return v1+v2; } . . . Rtn address %rsp call_incr: subq $16, %rsp movq $15213, 8(%rsp) movl $3000, %esi leaq 8(%rsp), %rdi call incr addq 8(%rsp), %rax addq $16, %rsp ret Register Use(s) %rax Return value Final Stack Structure . . . %rsp

Register Saving Conventions Carnegie Mellon Register Saving Conventions When procedure yoo calls who: yoo is the caller who is the callee Can register be used for temporary storage? Contents of register %rdx overwritten by who This could be trouble ➙ something should be done! Need some coordination yoo: • • • movq $15213, %rdx call who addq %rdx, %rax ret who: • • • subq $18213, %rdx ret

Register Saving Conventions Carnegie Mellon Register Saving Conventions When procedure yoo calls who: yoo is the caller who is the callee Can register be used for temporary storage? Conventions “Caller Saved” Caller saves temporary values in its frame before the call “Callee Saved” Callee saves temporary values in its frame before using Callee restores them before returning to caller

x86-64 Linux Register Usage #1 Carnegie Mellon x86-64 Linux Register Usage #1 %rax Return value Also caller-saved Can be modified by procedure %rdi, ..., %r9 Arguments %r10, %r11 Caller-saved Return value %rax %rdi %rsi %rdx Arguments %rcx %r8 %r9 %r10 Caller-saved temporaries %r11

x86-64 Linux Register Usage #2 Carnegie Mellon x86-64 Linux Register Usage #2 %rbx, %r12, %r13, %r14 Callee-saved Callee must save & restore %rbp May be used as frame pointer Can mix & match %rsp Special form of callee save Restored to original value upon exit from procedure %rbx %r12 Callee-saved Temporaries %r13 %r14 %rbp Special %rsp

Callee-Saved Example #1 Carnegie Mellon Callee-Saved Example #1 Initial Stack Structure long call_incr2(long x) { long v1 = 15213; long v2 = incr(&v1, 3000); return x+v2; } . . . Rtn address %rsp call_incr2: pushq %rbx subq $16, %rsp movq %rdi, %rbx movq $15213, 8(%rsp) movl $3000, %esi leaq 8(%rsp), %rdi call incr addq %rbx, %rax addq $16, %rsp popq %rbx ret Resulting Stack Structure . . . Rtn address Saved %rbx 15213 %rsp+8 Unused %rsp

Callee-Saved Example #2 Carnegie Mellon Callee-Saved Example #2 Resulting Stack Structure long call_incr2(long x) { long v1 = 15213; long v2 = incr(&v1, 3000); return x+v2; } . . . Rtn address Saved %rbx 15213 %rsp+8 call_incr2: pushq %rbx subq $16, %rsp movq %rdi, %rbx movq $15213, 8(%rsp) movl $3000, %esi leaq 8(%rsp), %rdi call incr addq %rbx, %rax addq $16, %rsp popq %rbx ret Unused %rsp Pre-return Stack Structure . . . Rtn address %rsp

Today Procedures Passing control Passing data Managing local data Carnegie Mellon Today Procedures Stack Structure Calling Conventions Passing control Passing data Managing local data Illustration of Recursion

Recursive Function pcount_r: movl $0, %eax testq %rdi, %rdi je .L6 Carnegie Mellon Recursive Function pcount_r: movl $0, %eax testq %rdi, %rdi je .L6 pushq %rbx movq %rdi, %rbx andl $1, %ebx shrq %rdi call pcount_r addq %rbx, %rax popq %rbx .L6: rep; ret /* Recursive popcount */ long pcount_r(unsigned long x) { if (x == 0) return 0; else return (x & 1) + pcount_r(x >> 1); }

Recursive Function Terminal Case Carnegie Mellon Recursive Function Terminal Case /* Recursive popcount */ long pcount_r(unsigned long x) { if (x == 0) return 0; else return (x & 1) + pcount_r(x >> 1); } pcount_r: movl $0, %eax testq %rdi, %rdi je .L6 pushq %rbx movq %rdi, %rbx andl $1, %ebx shrq %rdi call pcount_r addq %rbx, %rax popq %rbx .L6: rep; ret Register Use(s) Type %rdi x Argument %rax Return value

Recursive Function Register Save Carnegie Mellon Recursive Function Register Save pcount_r: movl $0, %eax testq %rdi, %rdi je .L6 pushq %rbx movq %rdi, %rbx andl $1, %ebx shrq %rdi call pcount_r addq %rbx, %rax popq %rbx .L6: rep; ret /* Recursive popcount */ long pcount_r(unsigned long x) { if (x == 0) return 0; else return (x & 1) + pcount_r(x >> 1); } Register Use(s) Type %rdi x Argument . . . Rtn address Saved %rbx %rsp

Recursive Function Call Setup Carnegie Mellon Recursive Function Call Setup /* Recursive popcount */ long pcount_r(unsigned long x) { if (x == 0) return 0; else return (x & 1) + pcount_r(x >> 1); } pcount_r: movl $0, %eax testq %rdi, %rdi je .L6 pushq %rbx movq %rdi, %rbx andl $1, %ebx shrq %rdi call pcount_r addq %rbx, %rax popq %rbx .L6: rep; ret Register Use(s) Type %rdi x >> 1 Rec. argument %rbx x & 1 Callee-saved

Recursive Function Call Carnegie Mellon Recursive Function Call /* Recursive popcount */ long pcount_r(unsigned long x) { if (x == 0) return 0; else return (x & 1) + pcount_r(x >> 1); } pcount_r: movl $0, %eax testq %rdi, %rdi je .L6 pushq %rbx movq %rdi, %rbx andl $1, %ebx shrq %rdi call pcount_r addq %rbx, %rax popq %rbx .L6: rep; ret Register Use(s) Type %rbx x & 1 Callee-saved %rax Recursive call return value

Recursive Function Result Carnegie Mellon Recursive Function Result /* Recursive popcount */ long pcount_r(unsigned long x) { if (x == 0) return 0; else return (x & 1) + pcount_r(x >> 1); } pcount_r: movl $0, %eax testq %rdi, %rdi je .L6 pushq %rbx movq %rdi, %rbx andl $1, %ebx shrq %rdi call pcount_r addq %rbx, %rax popq %rbx .L6: rep; ret Register Use(s) Type %rbx x & 1 Callee-saved %rax Return value

Recursive Function Completion Carnegie Mellon Recursive Function Completion pcount_r: movl $0, %eax testq %rdi, %rdi je .L6 pushq %rbx movq %rdi, %rbx andl $1, %ebx shrq %rdi call pcount_r addq %rbx, %rax popq %rbx .L6: rep; ret /* Recursive popcount */ long pcount_r(unsigned long x) { if (x == 0) return 0; else return (x & 1) + pcount_r(x >> 1); } Register Use(s) Type %rax Return value . . . %rsp

Observations About Recursion Carnegie Mellon Observations About Recursion Handled Without Special Consideration Stack frames mean that each function call has private storage Saved registers & local variables Saved return pointer Register saving conventions prevent one function call from corrupting another’s data Unless the C code explicitly does so (e.g., buffer overflow in Lecture 9) Stack discipline follows call / return pattern If P calls Q, then Q returns before P Last-In, First-Out Also works for mutual recursion P calls Q; Q calls P

x86-64 Procedure Summary Important Points Carnegie Mellon x86-64 Procedure Summary Important Points Stack is the right data structure for procedure call / return If P calls Q, then Q returns before P Recursion (& mutual recursion) handled by normal calling conventions Can safely store values in local stack frame and in callee-saved registers Put function arguments at top of stack Result return in %rax Pointers are addresses of values On stack or global Caller Frame Arguments 7+ Return Addr %rbp (Optional) Old %rbp Saved Registers + Local Variables Argument Build %rsp