1 / 50

Understanding IA-32 Assembly Procedures and Stack Management in Computer Systems

This course covers the essential concepts of IA-32 assembly language programming, focusing on procedures, stack management, and control flow. Students will learn about conditional jumps, stack discipline, and how to manage stack frames for recursive calls. We will explore various control statements, the significance of calling conventions, and how the stack grows in memory. Practical examples will be discussed to illustrate procedure calls in IA-32 assembly, emphasizing the stack's role in procedure state management.

pancho
Télécharger la présentation

Understanding IA-32 Assembly Procedures and Stack Management in Computer Systems

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Machine-Level Programming IV:IA32 ProceduresComp 21000: Introduction to Computer Systems & Assembly LangSpring 2013 • * Modified slides from the book “Computer Systems: a Programmer’s Perspective”, Randy Bryant & David O’Hallaron, 2011

  2. Summarizing • C Control • if-then-else • do-while • while, for • switch • Assembler Control • Conditional jump • Conditional move • Indirect jump • Compiler generates code sequence to implement more complex control • Standard Techniques • Loops converted to do-while form • Large switch statements use jump tables • Sparse switch statements may use decision trees

  3. Today • Switch statements • IA 32 Procedures • Stack Structure • Calling Conventions • Illustrations of Recursion & Pointers

  4. Stack “Bottom” Increasing Addresses Stack Grows Down Stack Pointer: %esp Stack “Top” IA32 Stack • Region of memory managed with stack discipline • Grows toward lower addresses • Register %esp contains lowest stack address • address of “top” element

  5. Stack Pointer: %esp -4 Stack “Top” IA32 Stack: Push Stack “Bottom” • pushlSrc • Fetch operand at Src • Decrement %esp by 4 • Write operand at address given by %esp Increasing Addresses %esp points at the top of the stack, i.e., at the last entry in the stack. Stack Grows Down

  6. +4 IA32 Stack: Pop Stack “Bottom” • poplDest • Read operand at address given by %esp • Increment %esp by 4 • Write to Dest Increasing Addresses Stack Grows Down Stack Pointer: %esp Stack “Top”

  7. Stack Operation Examples pushl %eax popl %edx 0x110 0x110 0x110 0x10c 0x10c 0x10c top 0x108 123 0x108 123 0x108 123 top 0x104 213 0x104 213 top %eax 213 %eax 213 %eax 213 %edx 555 %edx 555 %edx 555 213 %esp 0x108 %esp 0x108 0x104 %esp 0x108 0x104

  8. Procedure Control Flow • Use stack to support procedure call and return • Procedure call:calllabel • Push return address on stack • Jump to label • Return address: • Address of the next instruction right after call • Example from disassembly 804854e:e8 3d 06 00 00 call 8048b90 <main> 8048553:50 pushl %eax • Return address = 0x8048553 • Procedure return:ret • Pop address from stack • Jump to address

  9. Procedure Call Example 804854e: e8 3d 06 00 00 call 8048b90 <main> 8048553: 50 pushl %eax call 8048b90 0x110 0x110 0x10c 0x10c 0x108 123 0x108 123 0x104 0x8048553 %esp 0x108 %esp 0x104 %eip 0x804854e %eip 0x8048b90 %eip: program counter

  10. Procedure Return Example 8048591: c3 ret ret 0x110 0x110 0x10c 0x10c 0x108 123 0x108 123 0x104 0x8048553 0x8048553 %esp 0x104 %esp 0x108 %eip 0x8048591 %eip 0x8048553 %eip: program counter

  11. 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

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

  13. Stack Frames • Contents • Local variables • Return information • Temporary space • Management • Space allocated when enter procedure • “Set-up” code • Deallocated when return • “Finish” code Frame Pointer: %ebp Stack Pointer: %esp Stack “Top” • Stack pointer %esp indicates stack top • Frame pointer %ebp indicates start of current frame

  14. %ebp %esp Example Stack yoo yoo(…) { • • who(); • • } yoo who amI amI amI amI

  15. %ebp %esp Example Stack yoo yoo(…) { • • who(); • • } yoo who(…) { • • • amI(); • • • amI(); • • • } who amI amI amI amI

  16. %ebp %esp Example Stack yoo yoo(…) { • • who(); • • } yoo who(…) { • • • amI(); • • • amI(); • • • } amI(…) { • • amI(); • • } who amI amI amI amI

  17. %ebp %esp Example Stack yoo yoo(…) { • • who(); • • } yoo who(…) { • • • amI(); • • • amI(); • • • } amI(…) { • • amI(); • • } who amI(…) { • • amI(); • • } amI amI amI amI

  18. %ebp %esp Example Stack yoo yoo(…) { • • who(); • • } yoo who(…) { • • • amI(); • • • amI(); • • • } amI(…) { • • amI(); • • } who amI(…) { • • amI(); • • } amI amI amI(…) { • • amI(); • • } amI amI

  19. %ebp %esp Example Stack yoo yoo(…) { • • who(); • • } yoo who(…) { • • • amI(); • • • amI(); • • • } amI(…) { • • amI(); • • } who amI(…) { • • amI(); • • } amI amI amI amI

  20. %ebp %esp Example Stack yoo yoo(…) { • • who(); • • } yoo who(…) { • • • amI(); • • • amI(); • • • } amI(…) { • • amI(); • • } who amI amI amI amI

  21. %ebp %esp Example Stack yoo yoo(…) { • • who(); • • } yoo who(…) { • • • amI(); • • • amI(); • • • } who amI amI amI amI

  22. %ebp %esp Example Stack yoo yoo(…) { • • who(); • • } yoo who(…) { • • • amI(); • • • amI(); • • • } amI(…) { • • amI(); • • } who amI amI amI amI

  23. %ebp %esp Example Stack yoo yoo(…) { • • who(); • • } yoo who(…) { • • • amI(); • • • amI(); • • • } who amI amI amI amI

  24. %ebp %esp Example Stack yoo yoo yoo(…) { • • who(); • • } who amI amI amI amI

  25. IA32/Linux Stack Frame • Current Stack Frame (“Top” to Bottom) • “Argument build:”Parameters for function about to call • Local variablesIf can’t keep in registers • Saved register context • Old frame pointer • Caller Stack Frame • Return address • Pushed by call instruction • Arguments for this call Caller Frame Arguments Frame pointer%ebp Return Addr Old %ebp Saved Registers + Local Variables Argument Build Stack pointer %esp

  26. Revisiting swap Calling swap from call_swap int course1 = 15213; int course2 = 18243; void call_swap() { swap(&course1, &course2); } call_swap: • • • subl $8, %esp movl $course2, 4(%esp) movl $course1, (%esp) call swap • • • • • • Resulting Stack void swap(int *xp, int *yp) { int t0 = *xp; int t1 = *yp; *xp = t1; *yp = t0; } %esp &course2 subl &course1 %esp call Rtn adr %esp

  27. Revisiting swap swap: pushl %ebp movl %esp, %ebp pushl %ebx movl 8(%ebp), %edx movl 12(%ebp), %ecx movl (%edx), %ebx movl (%ecx), %eax movl %eax, (%edx) movl %ebx, (%ecx) popl %ebx popl %ebp ret Set Up void swap(int *xp, int *yp) { int t0 = *xp; int t1 = *yp; *xp = t1; *yp = t0; } Body Finish

  28. swap Setup #1 Entering Stack Resulting Stack %ebp %ebp • • • • • • &course2 yp &course1 xp %esp Rtn adr Rtn adr Old %ebp %esp swap: pushl %ebp movl %esp,%ebp pushl %ebx

  29. swap Setup #2 Entering Stack Resulting Stack %ebp • • • • • • &course2 yp &course1 xp %esp Rtn adr Rtn adr %ebp Old %ebp %esp swap: pushl %ebp movl %esp,%ebp pushl %ebx

  30. swap Setup #3 Entering Stack Resulting Stack %ebp • • • • • • &course2 yp &course1 xp %esp Rtn adr Rtn adr Old %ebp %ebp Old %ebx %esp swap: pushl %ebp movl %esp,%ebp pushl %ebx

  31. swap Body Entering Stack Resulting Stack %ebp • • • • • • Offset relative to %ebp &course2 yp 12 &course1 8 xp %esp Rtn adr 4 Rtn adr Old %ebp %ebp Old %ebx %esp movl 8(%ebp),%edx # get xp movl12(%ebp),%ecx # get yp . . .

  32. • • • yp xp Rtn adr Old %ebp %ebp Old %ebx %esp swapFinish Stack Before Finish Resulting Stack %ebp • • • popl %ebx popl %ebp yp xp Rtn adr %esp • Observation • Saved and restored register %ebx • Not so for %eax, %ecx, %edx

  33. Disassembled swap 08048384 <swap>: 8048384: 55 push %ebp 8048385: 89 e5 mov %esp,%ebp 8048387: 53 push %ebx 8048388: 8b 55 08 mov 0x8(%ebp),%edx 804838b: 8b 4d 0c mov 0xc(%ebp),%ecx 804838e: 8b 1a mov (%edx),%ebx 8048390: 8b 01 mov (%ecx),%eax 8048392: 89 02 mov %eax,(%edx) 8048394: 89 19 mov %ebx,(%ecx) 8048396: 5b pop %ebx 8048397: 5d pop %ebp 8048398: c3 ret Calling Code 80483b4: movl $0x8049658,0x4(%esp) # Copy &course2 80483bc: movl $0x8049654,(%esp) # Copy &course1 80483c3: call 8048384 <swap> # Call swap 80483c8: leave # Prepare to return 80483c9: ret # Return

  34. Switch statements IA 32 Procedures Stack Structure Calling Conventions Illustrations of Recursion & Pointers Today

  35. 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 %edx overwritten by who • This could be trouble ➙ something should be done! • Need some coordination yoo: • • • movl$15213, %edx call who addl%edx, %eax • • • ret who: • • • movl8(%ebp), %edx addl $18243, %edx • • • ret

  36. 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 Save” • Caller saves temporary values in its frame before the call • “Callee Save” • Callee saves temporary values in its frame before using

  37. IA32/Linux+WindowsRegister Usage • %eax, %edx, %ecx • Caller saves prior to call if values are used later • %eax • also used to return integer value • %ebx, %esi, %edi • Callee saves if wants to use them • %esp, %ebp • special form of callee save • Restored to original values upon exit from procedure %eax Caller-Save Temporaries %edx %ecx %ebx Callee-Save Temporaries %esi %edi %esp Special %ebp

  38. Today • Switch statements • IA 32 Procedures • Stack Structure • Calling Conventions • Illustrations of Recursion & Pointers

  39. Recursive Function pcount_r: pushl %ebp movl %esp, %ebp pushl %ebx subl $4, %esp movl 8(%ebp), %ebx movl $0, %eax testl %ebx, %ebx je .L3 movl %ebx, %eax shrl %eax movl %eax, (%esp) call pcount_r movl %ebx, %edx andl $1, %edx leal (%edx,%eax), %eax .L3: addl $4, %esp popl %ebx popl %ebp ret /* Recursive popcount */ intpcount_r(unsigned x) { if (x == 0) return 0; else return (x & 1) + pcount_r(x >> 1); } • Registers • %eax, %edxused without first saving • %ebx used, but saved at beginning & restored at end

  40. Recursive Call #1 pcount_r: pushl %ebp movl %esp, %ebp pushl %ebx subl $4, %esp movl 8(%ebp), %ebx • • • /* Recursive popcount */ intpcount_r(unsigned x) { if (x == 0) return 0; else return (x & 1) + pcount_r(x >> 1); } • Actions • Save old value of %ebx on stack • Allocate space for argument to recursive call • Store x in %ebx • • • x Rtn adr Old %ebp %ebp Old %ebx %ebx x %esp

  41. Recursive Call #2 • • • movl $0, %eax testl%ebx, %ebx je .L3 • • • .L3: • • • ret /* Recursive popcount */ intpcount_r(unsigned x) { if (x == 0) return 0; else return (x & 1) + pcount_r(x >> 1); } • Actions • If x == 0, return • with %eax set to 0 %ebx x

  42. Recursive Call #3 • • • movl %ebx, %eax shrl %eax movl %eax, (%esp) call pcount_r • • • /* Recursive popcount */ intpcount_r(unsigned x) { if (x == 0) return 0; else return (x & 1) + pcount_r(x >> 1); } • Actions • Store x >> 1 on stack • Make recursive call • Effect • %eax set to function result • %ebx still has value of x • • • Rtn adr Old %ebp %ebp Old %ebx x >> 1 %esp %ebx x

  43. Recursive Call #4 /* Recursive popcount */ intpcount_r(unsigned x) { if (x == 0) return 0; else return (x & 1) + pcount_r(x >> 1); } • • • movl %ebx, %edx andl $1, %edx leal (%edx,%eax), %eax • • • • Assume • %eaxholds value from recursive call • %ebxholds x • Actions • Compute (x & 1) + computed value • Effect • %eax set to function result %ebx x

  44. Recursive Call #5 • • • L3: addl $4, %esp popl %ebx popl %ebp ret /* Recursive popcount */ intpcount_r(unsigned x) { if (x == 0) return 0; else return (x & 1) + pcount_r(x >> 1); } • Actions • Restore values of %ebx and %ebp • Restore %esp • • • %ebp • • • %esp Rtn adr Old %ebp %ebp %ebx Old %ebx Old %ebx %esp

  45. 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 • 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

  46. Pointer Code • add3 creates pointer and passes it to incrk Generating Pointer /* Compute x + 3 */ int add3(int x) { intlocalx = x; incrk(&localx, 3); return localx; } Referencing Pointer /* Increment value by k */ void incrk(int *ip, int k) { *ip += k; }

  47. Creating and Initializing Local Variable • Variable localxmust be stored on stack • Because: Need to create pointer to it • Compute pointer as -4(%ebp) int add3(int x) { intlocalx = x; incrk(&localx, 3); return localx; } 8 x 4 Rtn adr 0 Old %ebp %ebp First part of add3 -4 localx= x add3: pushl %ebp movl %esp, %ebp subl $24, %esp # Alloc. 24 bytes movl 8(%ebp), %eax movl %eax, -4(%ebp) # Set localx to x -8 Unused -12 -16 -20 %esp -24

  48. Creating Pointer as Argument • Use leal instruction to compute address of localx int add3(int x) { intlocalx = x; incrk(&localx, 3); return localx; } 8 x 4 Rtn adr 0 Old %ebp %ebp Middle part of add3 -4 localx movl $3, 4(%esp) # 2ndarg = 3 leal -4(%ebp), %eax # &localx movl %eax, (%esp) # 1starg = &localx call incrk -8 Unused -12 -16 3 %esp+4 -20 %esp -24

  49. Retrieving local variable • Retrieve localx from stack as return value int add3(int x) { intlocalx = x; incrk(&localx, 3); return localx; } 8 x 4 Rtn adr 0 Old %ebp %ebp Final part of add3 -4 localx movl -4(%ebp), %eax # Return val= localx leave ret -8 Unused -12 -16 -20 %esp -24

  50. IA 32 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 %eax • Pointers are addresses of values • On stack or global Caller Frame Arguments Return Addr %ebp Old %ebp Saved Registers + Local Variables Argument Build %esp

More Related