University of Washington

Transcription

1 Roadmap C: car *c = malloc(sizeof(car)); c->miles = 100; c->gals = 17; float mpg = get_mpg(c); free(c); Assembly language: Machine code: Computer system: get_mpg: pushq %rbp movq %rsp, %rbp... popq %rbp Java: Car c = new Car(); c.setmiles(100); c.setgals(17); float mpg = c.getmpg(); OS: Memory & data Integers & floats Machine code & C x86 assembly Procedures & stacks Arrays & structs Memory & caches Processes Virtual memory Memory allocation Java vs. C Section 5: Procedures & s s in memory and stack operations The stack used to keep track of procedure calls Return addresses and urn values -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 Procedures and s Memory Layout Memory Layout 2 N -1 local variables; procedure context writable; not executable Managed automatically (by compiler) Dynamic Data (Heap) variables allocated with new or malloc writable; not executable Dynamic Data (Heap) Managed by programmer Static Data static variables (including global variables (C)) writable; not executable Static Data Initialized when process starts Literals literals (e.g., example ) Read-only; not executable Literals Initialized when process starts 0 Instructions Read-only; executable Instructions Initialized when process starts Procedures and s Procedures and s

2 IA32 Call IA32 Call : Push Region of memory managed with a stack discipline Grows toward lower addresses Customarily shown upside-down Bottom Increasing Addresses pushl Src Bottom Increasing Addresses Register contains lowest stack address = address of top element Pointer: Grows Down Pointer: Grows Down Top Top Procedures and s Procedures and s IA32 Call : Push IA32 Call : Pop pushl Src Fetch value from Src Decrement by 4 (why 4?) Store value at address given by Bottom Increasing Addresses popl Dest Bottom Increasing Addresses Pointer: -4 Grows Down Pointer: Grows Down Top Top Procedures and s Procedures and s

3 IA32 Call : Pop popl Dest Load value from address Write value to Dest Increment by 4 Item still remains, we are just not referencing it any more Not really moving out of memory Pointer: Bottom +4 Increasing Addresses Grows Down Section 5: Procedures & s s in memory and stack operations The stack used to keep track of procedure calls Return addresses and urn values -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 Top Procedures and s Procedure Call Overview Caller <set up args> call <clean up args> <find urn val> Calleemust know where to find args Callee <create local vars> <set up urn val> <destroy local vars> urn Callee must know where to find urn address Caller must know where to find urn val Caller and Calleerun on same CPU use the same registers Caller might need to save registers that Callee might use Callee might need to save registers that Caller has used Procedure Call Overview Caller <save regs> <set up args> call <clean up args> <restore regs> <find urn val> Callee <save regs> <create local vars> <set up urn val> <destroy local vars> <restore regs> urn The conventionof where to leave/find things is called the procedure call linkage Details vary between systems We will see the convention for IA32/Linux in detail What could happen if our program didn t follow these conventions?

4 Procedure Control Flow Use stack to support procedure call and urn Procedure call: call label Push urn address on stack Jump to label Procedure Control Flow Use stack to support procedure call and urn Procedure call: call label Push urn address on stack Jump to label Return address: Address of instruction after call from disassembly: e: e8 3d call 8048b90 <main> : 50 pushl %eax Return address = Procedure urn: Pop urn address from stack Jump to address Procedure Call e: e8 3d call 8048b90 <main> : 50 pushl %eax call 8048b90 Procedure Call e: e8 3d call 8048b90 <main> : 50 pushl %eax call 8048b90 %eip 0x804854e %eip 0x804854e %eip 0x804854e %eip: program counter %eip: program counter

5 Procedure Call e: e8 3d call 8048b90 <main> : 50 pushl %eax call 8048b90 Procedure Call e: e8 3d call 8048b90 <main> : 50 pushl %eax call 8048b90 %eip 0x804854e %eip 0x804854e %eip 0x804854e %eip 0x804854e %eip: program counter %eip: program counter Procedure Call e: e8 3d call 8048b90 <main> : 50 pushl %eax Procedure Return : c3 call 8048b90 %eip 0x804854e %eip + 0x000063d %eip 0x %eip: program counter 0x8048b90 %eip: program counter

6 Procedure Return : c3 Procedure Return : c3 %eip 0x %eip 0x %eip 0x %eip 0x %eip: program counter %eip: program counter Procedure Return : c3 %eip 0x %eip 0x Return Values By convention, values urned by procedures are placed in the %eax register Choice of %eax is arbitrary, could have easily been a different register Caller must make sure to save that register before calling a callee that urns a value Part of register-saving convention we ll see later Calleeplaced urn value (any te that can fit in 4 bytes integer, float, pointer, etc.) into the %eax register For urn values greater than 4 bytes, best to urn a pointer to them Upon urn, caller finds the urn value in the %eaxregister %eip: program counter

7 Section 5: Procedures & s s in memory and stack operations The stack used to keep track of procedure calls Return addresses and urn values -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 Languages that support recursion e.g., C, Pascal, Java Code must bere-entrant Multiple simultaneous instantiations of single procedure Need some place to store state of each instantiation Arguments Local variables Return pointer discipline State for a given procedure needed for a limited time Starting from when it is called to when it urns Callee always urns before caller does allocated inframes State for a single procedure instantiation Call Chain ( ) (); ( ) (); (); ( ) (); Procedure is recursive (calls itself) Call Chain Frames Contents Local variables Function arguments Return information Temporary space Frame Pointer: Pointer: Management Space allocated when procedure is entered Set-up code Space deallocated upon urn Finish code Previous Frame Frame for current proc Top

8 ( ) (); ( ) (); (); ( ) (); ( ) ();

9 ( ) (); ( ) (); ( ) (); ( ) (); ();

10 ( ) ( ) (); (); Section 5: Procedures & s ( ) (); s in memory and stack operations The stack used to keep track of procedure calls Return addresses and urn values -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

11 IA32/ Revisiting swap Current Frame ( Top to Bottom) Argument build area (parameters for function about to be called) Local variables (if can t be kept in registers) Saved register context (when reusing registers) Old frame pointer (for caller) Caller s Frame Return address Pushed by call instruction Arguments for this call Frame pointer pointer Caller Frame Arguments Return Addr Old Saved Registers + Local Variables Argument Build int zip1 = 15213; int zip2 = 98195; void call_swap() swap(&zip1, &zip2); void swap(int *, int *) int t0 = *; int t1 = *; * = t1; * = t0; Revisiting swap int zip1 = 15213; int zip2 = 98195; void call_swap() swap(&zip1, &zip2); Calling swap from call_swap call_swap: pushl $zip2 pushl $zip1 call swap # Global Var # Global Var Revisiting swap int zip1 = 15213; int zip2 = 98195; void call_swap() swap(&zip1, &zip2); Calling swap from call_swap call_swap: pushl $zip2 pushl $zip1 call swap # Global Var # Global Var void swap(int *, int *) int t0 = *; int t1 = *; * = t1; * = t0; void swap(int *, int *) int t0 = *; int t1 = *; * = t1; * = t0; &zip2 &zip1 Resulting

12 Revisiting swap swap Setup #1 void swap(int *, int *) int t0 = *; int t1 = *; * = t1; * = t0; swap: pushl movl, pushl %ebx movl 12(),%ecx movl 8(),%edx movl (%ecx),%eax movl (%edx),%ebx movl %eax,(%edx) movl %ebx,(%ecx) Set Up Body Entering &zip2 &zip1 Resulting? movl -4(),%ebx movl, popl Finish swap: pushl movl, pushl %ebx swap Setup #1 swap Setup #2 Entering Resulting Entering Resulting &zip2 &zip1 Old &zip2 &zip1 Old swap: pushl movl, pushl %ebx swap: pushl movl, pushl %ebx

13 swap Setup #3 swap Body Entering Resulting Entering Resulting &zip2 &zip1 swap: pushl movl, pushl %ebx Old Old %ebx &zip2 &zip1 movl 12(),%ecx # get movl 8(),%edx # get... Offset relative to new Old Old %ebx swap Finish #1 swap Finish #1 swap s Resulting? swap s Resulting Old Old %ebx Old Old %ebx Old Old %ebx movl -4(),%ebx movl, popl movl -4(),%ebx movl, popl Observation: Saved and restored register %ebx

14 swap Finish #2 swap Finish #3 swap s Resulting swap s Resulting Old Old %ebx Old Old Old %ebx movl -4(),%ebx movl, popl movl -4(),%ebx movl, popl swap Finish #4 Disassembled swap swap s Old Old %ebx Resulting a4 <swap>: 80483a4: 55 push 80483a5: 89 e5 mov, 80483a7: 53 push %ebx 80483a8: 8b mov 0x8(),%edx 80483ab: 8b 4d 0c mov 0xc(),%ecx 80483ae: 8b 1a mov (%edx),%ebx 80483b0: 8b 01 mov (%ecx),%eax 80483b2: mov %eax,(%edx) 80483b4: mov %ebx,(%ecx) 80483b6: 5b pop %ebx mov, 80483b7: c9 leave pop 80483b8: c3 movl -4(),%ebx movl, popl Calling Code : e8 96 ff ff ff call 80483a4 <swap> e: 8b 45 f8 mov 0xfffffff8(),%eax

15 swap Finish #4 swap s Old Old %ebx movl -4(),%ebx movl, popl Resulting Observation Saved & restored register %ebx Didn t do so for %eax, %ecx, or %edx Section 5: Procedures & s s in memory and stack operations The stack used to keep track of procedure calls Return addresses and urn values -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 Register Saving and Local Variables Register Saving Conventions When procedure calls : is the caller is the callee Register Saving Conventions When procedure calls : is the caller is the callee Can a register be used for temporary storage? : movl $45, %edx call addl %edx, %eax : movl 8(), %edx addl $98195, %edx Can a register be used for temporary storage? Conventions Caller Save Caller saves temporary values in its frame before calling Callee Save Callee saves temporary values in its frame before using Contents of register %edxoverwritten by Register Saving and Local Variables Register Saving and Local Variables

16 IA32/Linux Register Usage %eax, %edx, %ecx Caller saves prior to call if values are used later %eax also used to urn integer value %ebx, %esi, %edi Callee saves if wants to use them Caller-Save Temporaries Callee-Save Temporaries Special %eax %edx %ecx %ebx %esi %edi, special form of callee save restored to original values upon exit from procedure : Pointers to Local Variables Recursive Procedure void s_helper (int x, int *accum) if (x <= 1) urn; else int z = *accum * x; *accum = z; s_helper (x-1,accum); Pass pointer to update location Top-Level Call intsfact(int x) intval = 1; s_helper(x, &val); urn val; Register Saving and Local Variables Register Saving and Local Variables Creating & Initializing Pointer int sfact(int x) int val = 1; s_helper(x, &val); urn val; Initial part of sfact _sfact: pushl # Save movl movl, # Set subl subl $16, # Add 16 bytes movl movl 8(),%edx # edx = x movl movl $1,-4() # val = 1 Temp. Unused Space Variable val must be stored on stack Because: Need to create pointer to it Compute pointer as -4() Push on stack as second argument 8 4 x Rtnadr 0 Old -4 val = Passing Pointer int sfact(int x) int val = 1; s_helper(x, &val); urn val; Calling s_helper from sfact at time of call: leal -4(),%eax # Compute &val pushl %eax # Push on stack pushl %edx # Push x call call s_helper # call movl -4(),%eax # Return val # Finish x Rtnadr Old val=x! = 1 Unused &val x Variable val must be stored on stack Because: Need to create pointer to it Compute pointer as -4() Push on stack as second argument Register Saving and Local Variables Register Saving and Local Variables

17 IA 32 Procedure Summary Important points: IA32 procedures are a combination of instructions and conventions Conventions prevent functions from disrupting each other is the right data structure for procedure call / urn If P calls Q, then Q urns before P 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 urned in %eax Register Saving and Local Variables Caller Frame Arguments Return Addr Old Saved Registers + Local Variables Argument Build Section 5: Procedures & s s in memory and stack operations The stack used to keep track of procedure calls Return addresses and urn values -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 s x86-64 Procedure Calling Convention x bit Registers: Usage Conventions Doubling of registers makes us less dependent on stack Store argument in registers Store temporary variables in registers %rax %rbx Return value Callee saved %r8 %r9 Argument #5 Argument #6 What do we do if we have too many arguments or too many temporary variables? %rcx %rdx Argument #4 Argument #3 %r10 %r11 Caller saved Caller Saved %rsi Argument #2 %r12 Callee saved %rdi Argument #1 %r13 Callee saved %rsp pointer %r14 Callee saved %rbp Callee saved %r15 Callee saved x64 Procedures and s x64 Procedures and s

18 Revisiting swap, IA32 vs. x86-64 versions X86-64 procedure call highlights swap: pushl movl, pushl %ebx movl 12(),%ecx movl 8(),%edx movl (%ecx),%eax movl (%edx),%ebx movl %eax,(%edx) movl %ebx,(%ecx) movl -4(),%ebx movl, popl Set Up Body Finish x64 Procedures and s swap (64-bit long ints): movq (%rdi), %rdx movq (%rsi), %rax movq %rax, (%rdi) movq %rdx, (%rsi) Arguments passed in registers First () in %rdi, second () in %rsi 64-bit pointers No stack operations required (except ) Avoiding stack Can hold all local information in registers 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) callqinstruction stores 64-bit urn 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 /%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 s x86-64 Frames Often (ideally), x86-64 functions need no stack frame at all Just a urn address is pushed onto the stack when a function call is made A function doesneed 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 long int call_proc() long x1 = 1; int x2 = 2; short x3 = 3; char x4 = 4; proc(x1, &x1, x2, &x2, x3, &x3, x4, &x4); urn (x1+x2)*(x3-x4); Return address to caller of call_proc call_proc: subq $32,%rsp movq $1,16(%rsp) movl $2,24(%rsp) movw $3,28(%rsp) movb $4,31(%rsp) %rsp NB: Details may vary depending on compiler. x64 Procedures and s x64 Procedures and s

19 long int call_proc() long x1 = 1; int x2 = 2; short x3 = 3; char x4 = 4; proc(x1, &x1, x2, &x2, x3, &x3, x4, &x4); urn (x1+x2)*(x3-x4); x4 Return address to caller of call_proc x3 x1 x2 call_proc: subq $32,%rsp movq $1,16(%rsp) movl $2,24(%rsp) movw $3,28(%rsp) movb $4,31(%rsp) %rsp long int call_proc() long x1 = 1; int x2 = 2; short x3 = 3; char x4 = 4; proc(x1, &x1, x2, &x2, x3, &x3, x4, &x4); urn (x1+x2)*(x3-x4); x4 Return address to caller of call_proc x3 x1 Arg8 Arg 7 x2 call_proc: movq $1,%rdi leaq 16(%rsp),%rsi movl $2,%edx leaq 24(%rsp),%rcx movl $3,%r8d leaq 28(%rsp),%r9 movl $4,(%rsp) leaq 31(%rsp),%rax movq %rax,8(%rsp) call proc %rsp Arguments passed in (in order): rdi, rsi, rdx, rcx, r8, r9, then stack x64 Procedures and s x64 Procedures and s long int call_proc() long x1 = 1; int x2 = 2; short x3 = 3; char x4 = 4; proc(x1, &x1, x2, &x2, x3, &x3, x4, &x4); urn (x1+x2)*(x3-x4); x4 Return address to caller of call_proc x3 x1 Arg8 Arg7 x2 Return address to line after call to proc call_proc: movq $1,%rdi leaq 16(%rsp),%rsi movl $2,%edx leaq 24(%rsp),%rcx movl $3,%r8d leaq 28(%rsp),%r9 movl $4,(%rsp) leaq 31(%rsp),%rax movq %rax,8(%rsp) call proc %rsp Arguments passed in (in order): rdi, rsi, rdx, rcx, r8, r9, then stack long int call_proc() long x1 = 1; int x2 = 2; short x3 = 3; char x4 = 4; proc(x1, &x1, x2, &x2, x3, &x3, x4, &x4); urn (x1+x2)*(x3-x4); x4 Return address to caller of call_proc x3 x1 Arg8 Arg7 x2 call_proc: movswl 28(%rsp),%eax movsbl 31(%rsp),%edx subl %edx,%eax cltq movslq 24(%rsp),%rdx addq 16(%rsp),%rdx imulq %rdx,%rax addq $32,%rsp %rsp x64 Procedures and s x64 Procedures and s

20 long int call_proc() long x1 = 1; int x2 = 2; short x3 = 3; char x4 = 4; proc(x1, &x1, x2, &x2, x3, &x3, x4, &x4); urn (x1+x2)*(x3-x4); Return address to caller of call_proc call_proc: movswl 28(%rsp),%eax movsbl 31(%rsp),%edx subl %edx,%eax cltq movslq 24(%rsp),%rdx addq 16(%rsp),%rdx imulq %rdx,%rax addq $32,%rsp %rsp 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 s x64 Procedures and s