1 / 62

Machine Programming – Procedures and IA32 Stack CENG334: Introduction to Operating Systems

Machine Programming – Procedures and IA32 Stack CENG334: Introduction to Operating Systems. Instructor: Erol Sahin. Acknowledgement: Most of the slides are adapted from the ones prepared by R.E. Bryant, D.R. O’Hallaron of Carnegie-Mellon Univ. % eax. % ecx. % edx. %ebx. %esi. %edi.

jubal
Download Presentation

Machine Programming – Procedures and IA32 Stack CENG334: Introduction to Operating 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 Programming – Procedures and IA32 StackCENG334: Introduction to Operating Systems Instructor: ErolSahin • Acknowledgement: Most of the slides are adapted from the ones prepared • by R.E. Bryant, D.R. O’Hallaron of Carnegie-Mellon Univ.

  2. %eax %ecx %edx %ebx %esi %edi %esp %ebp Integer Registers (IA32) Origin (mostly obsolete) %ax %ah %al accumulate %cx %ch %cl counter %dx %dh %dl data general purpose %bx %bh %bl base source index %si destination index %di stack pointer %sp base pointer %bp 16-bit virtual registers (backwards compatibility)

  3. %eax %ecx %edx %ebx %esi %edi %esp %ebp Moving Data: IA32 • Moving Data • movxSource, Dest • x in {b, w, l} • movlSource, Dest: Move 4-byte “long word” • movwSource, Dest: Move 2-byte “word” • movbSource, Dest: Move 1-byte “byte” • Lots of these in typical code

  4. %eax %ecx %edx %ebx %esi %edi %esp %ebp Moving Data: IA32 • Moving Data movlSource, Dest: • Operand Types • Immediate: Constant integer data • Example: $0x400, $-533 • Like C constant, but prefixed with ‘$’ • Encoded with 1, 2, or 4 bytes • Register: One of 8 integer registers • Example: %eax, %edx • But %espand %ebpreserved for special use • Others have special uses for particular instructions • Memory: 4 consecutive bytes of memory at address given by register • Simplest example: (%eax) • Various other “address modes”

  5. movl Operand Combinations Cannot do memory-memory transfer with a single instruction Source Dest Src,Dest C Analog Reg movl $0x4,%eax temp = 0x4; Imm Mem movl $-147,(%eax) *p = -147; Reg movl %eax,%edx temp2 = temp1; movl Reg Mem movl %eax,(%edx) *p = temp; Mem Reg movl (%eax),%edx temp = *p;

  6. Simple Memory Addressing Modes • Normal (R) Mem[Reg[R]] • Register R specifies memory addressmovl (%ecx),%eax • Displacement D(R) Mem[Reg[R]+D] • Register R specifies start of memory region • Constant displacement D specifies offsetmovl 8(%ebp),%edx

  7. Using Simple Addressing Modes swap: pushl %ebp movl %esp,%ebp pushl %ebx movl 12(%ebp),%ecx movl 8(%ebp),%edx movl (%ecx),%eax movl (%edx),%ebx movl %eax,(%edx) movl %ebx,(%ecx) movl -4(%ebp),%ebx movl %ebp,%esp popl %ebp ret Set Up void swap(int *xp, int *yp) { int t0 = *xp; int t1 = *yp; *xp = t1; *yp = t0; } Body Finish

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

  9. • • • Offset 12 yp 8 xp 4 Rtnadr 0 Old %ebp %ebp -4 Old %ebx Understanding Swap void swap(int *xp, int *yp) { int t0 = *xp; int t1 = *yp; *xp = t1; *yp = t0; } Stack (in memory) Register Value %ecxyp %edxxp %eax t1 %ebx t0 movl 12(%ebp),%ecx # ecx = yp movl 8(%ebp),%edx # edx = xp movl (%ecx),%eax # eax = *yp (t1) movl (%edx),%ebx # ebx = *xp (t0) movl %eax,(%edx) # *xp = eax movl %ebx,(%ecx) # *yp = ebx

  10. %eax %edx %ecx %ebx %esi %edi %esp %ebp 0x104 Address Understanding Swap 123 0x124 456 0x120 0x11c 0x118 Offset 0x114 yp 12 0x120 0x110 xp 8 0x124 0x10c 4 Rtnadr 0x108 0 %ebp 0x104 -4 0x100 movl 12(%ebp),%ecx # ecx = yp movl 8(%ebp),%edx # edx = xp movl (%ecx),%eax # eax = *yp (t1) movl (%edx),%ebx # ebx = *xp (t0) movl %eax,(%edx) # *xp = eax movl %ebx,(%ecx) # *yp = ebx

  11. %eax %edx %ecx %ebx %esi %edi %esp %ebp 0x104 Address Understanding Swap 123 0x124 456 0x120 0x11c 0x118 Offset 0x114 yp 12 0x120 0x120 0x110 0x120 xp 8 0x124 0x10c 4 Rtnadr 0x108 0 %ebp 0x104 -4 0x100 movl 12(%ebp),%ecx # ecx = yp movl 8(%ebp),%edx # edx = xp movl (%ecx),%eax # eax = *yp (t1) movl (%edx),%ebx # ebx = *xp (t0) movl %eax,(%edx) # *xp = eax movl %ebx,(%ecx) # *yp = ebx

  12. %eax %edx %ecx %ebx %esi %edi %esp %ebp Address Understanding Swap 123 0x124 456 0x120 0x11c 0x118 Offset 0x124 0x114 yp 12 0x120 0x110 0x120 xp 8 0x124 0x124 0x10c 4 Rtnadr 0x108 0 %ebp 0x104 -4 0x100 movl 12(%ebp),%ecx # ecx = yp movl 8(%ebp),%edx # edx = xp movl (%ecx),%eax # eax = *yp (t1) movl (%edx),%ebx # ebx = *xp (t0) movl %eax,(%edx) # *xp = eax movl %ebx,(%ecx) # *yp = ebx 0x104

  13. %eax %edx %ecx %ebx %esi %edi %esp %ebp Address Understanding Swap 123 0x124 456 456 0x120 0x11c 456 0x118 Offset 0x124 0x114 yp 12 0x120 0x110 0x120 xp 8 0x124 0x10c 4 Rtnadr 0x108 0 %ebp 0x104 -4 0x100 movl 12(%ebp),%ecx # ecx = yp movl 8(%ebp),%edx # edx = xp movl (%ecx),%eax # eax = *yp (t1) movl (%edx),%ebx # ebx = *xp (t0) movl %eax,(%edx) # *xp = eax movl %ebx,(%ecx) # *yp = ebx 0x104

  14. %eax %edx %ecx %ebx %esi %edi %esp %ebp Address Understanding Swap 123 123 0x124 456 0x120 0x11c 456 0x118 Offset 0x124 0x114 yp 12 0x120 0x110 0x120 xp 8 0x124 0x10c 123 4 Rtnadr 0x108 0 %ebp 0x104 -4 0x100 movl 12(%ebp),%ecx # ecx = yp movl 8(%ebp),%edx # edx = xp movl (%ecx),%eax # eax = *yp (t1) movl (%edx),%ebx # ebx = *xp (t0) movl %eax,(%edx) # *xp = eax movl %ebx,(%ecx) # *yp = ebx 0x104

  15. %eax %edx %ecx %ebx %esi %edi %esp %ebp Address Understanding Swap 456 0x124 456 0x120 0x11c 456 456 0x118 Offset 0x124 0x114 yp 12 0x120 0x110 0x120 xp 8 0x124 0x10c 123 123 4 Rtnadr 0x108 0 %ebp 0x104 -4 0x100 movl 12(%ebp),%ecx # ecx = yp movl 8(%ebp),%edx # edx = xp movl (%ecx),%eax # eax = *yp (t1) movl (%edx),%ebx # ebx = *xp (t0) movl %eax,(%edx) # *xp = eax movl %ebx,(%ecx) # *yp = ebx 0x104

  16. %eax %edx %ecx %ebx %esi %edi %esp %ebp Address Understanding Swap 456 0x124 0x120 123 0x11c 456 0x118 Offset 0x124 0x114 yp 12 0x120 0x110 0x120 xp 8 0x124 0x10c 123 123 4 Rtnadr 0x108 0 %ebp 0x104 -4 0x100 movl 12(%ebp),%ecx # ecx = yp movl 8(%ebp),%edx # edx = xp movl (%ecx),%eax # eax = *yp (t1) movl (%edx),%ebx # ebx = *xp (t0) movl %eax,(%edx) # *xp = eax movl %ebx,(%ecx) # *yp = ebx 0x104

  17. Complete Memory Addressing Modes • Most General Form D(Rb,Ri,S) Mem[Reg[Rb]+S*Reg[Ri]+ D] • D: Constant “displacement” 1, 2, or 4 bytes • Rb: Base register: Any of 8 integer registers • Ri: Index register: Any, except for %esp • Unlikely you’d use %ebp, either • S: Scale: 1, 2, 4, or 8 (why these numbers?) • Special Cases (Rb,Ri) Mem[Reg[Rb]+Reg[Ri]] D(Rb,Ri) Mem[Reg[Rb]+Reg[Ri]+D] (Rb,Ri,S) Mem[Reg[Rb]+S*Reg[Ri]]

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

  19. IA32 Stack: Push Stack “Bottom” • pushlSrc • Fetch operand at Src • Decrement %espby 4 • Write operand at address given by %esp Increasing Addresses Stack Grows Down -4 Stack Pointer: %esp Stack “Top”

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

  21. 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 instruction beyond 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

  22. 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 0x108 0x104 %eip 0x804854e %eip 0x804854e 0x8048b90 %eip: program counter

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

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

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

  26. Stack Frames Previous Frame • Contents • Local variables • Return information • Temporary space • Management • Space allocated when enter procedure • “Set-up” code • Deallocated when return • “Finish” code Frame Pointer: %ebp Frame for proc Stack Pointer: %esp Stack “Top”

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

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

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

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

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

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

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

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

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

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

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

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

  39. Revisiting swap Calling swap from call_swap int zip1 = 15213; int zip2 = 91125; void call_swap() { swap(&zip1, &zip2); } call_swap: • • • pushl $zip2 # Global Var pushl $zip1 # Global Var call swap • • • • • • Resulting Stack void swap(int *xp, int *yp) { int t0 = *xp; int t1 = *yp; *xp = t1; *yp = t0; } &zip2 &zip1 Rtnadr %esp

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

  41. swap Setup #1 Entering Stack Resulting Stack %ebp %ebp • • • • • • &zip2 yp &zip1 xp Rtnadr %esp Rtnadr Old %ebp %esp swap: pushl %ebp movl %esp,%ebp pushl %ebx

  42. swap Setup #1 Entering Stack %ebp %ebp • • • • • • &zip2 yp &zip1 xp Rtnadr %esp Rtnadr Old %ebp %esp swap: pushl %ebp movl %esp,%ebp pushl %ebx

  43. swap Setup #1 Entering Stack Resulting Stack %ebp • • • • • • &zip2 yp &zip1 xp Rtnadr %esp Rtnadr Old %ebp %ebp %esp swap: pushl %ebp movl %esp,%ebp pushl %ebx

  44. swap Setup #1 Entering Stack %ebp • • • • • • &zip2 yp &zip1 xp Rtnadr %esp Rtnadr Old %ebp %ebp %esp swap: pushl %ebp movl %esp,%ebp pushl %ebx

  45. swap Setup #1 Entering Stack Resulting Stack %ebp • • • • • • Offset relative to %ebp &zip2 12 yp &zip1 8 xp Rtnadr 4 %esp Rtnadr Old %ebp %ebp Old %ebx %esp movl 12(%ebp),%ecx # get yp movl 8(%ebp),%edx # get xp . . .

  46. swapFinish #1 swap’s Stack Resulting Stack • • • • • • yp yp xp xp Rtnadr Rtnadr Old %ebp Old %ebp %ebp %ebp Old %ebx Old %ebx %esp %esp movl -4(%ebp),%ebx movl %ebp,%esp popl %ebp ret Observation: Saved and restored register %ebx

  47. swapFinish #2 swap’s Stack • • • • • • yp yp xp xp Rtnadr Rtnadr Old %ebp Old %ebp %ebp %ebp Old %ebx Old %ebx %esp %esp movl -4(%ebp),%ebx movl %ebp,%esp popl %ebp ret

  48. swapFinish #2 swap’s Stack Resulting Stack • • • • • • yp yp xp xp Rtnadr Rtnadr Old %ebp Old %ebp %ebp %ebp %esp Old %ebx %esp movl -4(%ebp),%ebx movl %ebp,%esp popl %ebp ret

  49. swapFinish #2 swap’s Stack • • • • • • yp yp xp xp Rtnadr Rtnadr Old %ebp Old %ebp %ebp %ebp %esp Old %ebx %esp movl -4(%ebp),%ebx movl %ebp,%esp popl %ebp ret

  50. swapFinish #3 swap’s Stack Resulting Stack %ebp • • • • • • yp yp xp xp Rtnadr Rtnadr %esp Old %ebp %ebp Old %ebx %esp movl -4(%ebp),%ebx movl %ebp,%esp popl %ebp ret

More Related