Presentation is loading. Please wait.

Presentation is loading. Please wait.

Stack Activation Records Topics IA32 stack discipline Register saving conventions Creating pointers to local variables February 6, 2003 CSCE 212H Computer.

Published by Modified over 9 years ago

Similar presentations

Presentation on theme: "Stack Activation Records Topics IA32 stack discipline Register saving conventions Creating pointers to local variables February 6, 2003 CSCE 212H Computer."— Presentation transcript:

1 Stack Activation Records Topics IA32 stack discipline Register saving conventions Creating pointers to local variables February 6, 2003 CSCE 212H Computer Architecture

2 – 2 – CSCE 212H Sp 03 IA32 Stack Region of memory managed with stack discipline Grows toward lower addresses Register %esp indicates lowest stack address address of top element Stack Pointer %esp Stack Grows Down Increasing Addresses Stack “Top” Stack “Bottom”

3 – 3 – CSCE 212H Sp 03 IA32 Stack Pushing Pushing pushl Src Fetch operand at Src Decrement %esp by 4 Write operand at address given by %esp Stack Grows Down Increasing Addresses Stack “Top” Stack “Bottom” Stack Pointer %esp -4

4 – 4 – CSCE 212H Sp 03 IA32 Stack Popping Popping popl Dest Read operand at address given by %esp Increment %esp by 4 Write to Dest Stack Pointer %esp Stack Grows Down Increasing Addresses Stack “Top” Stack “Bottom” +4

5 – 5 – CSCE 212H Sp 03 %esp %eax %edx %esp %eax %edx %esp %eax %edx 0x104 555 0x108 0x10c 0x110 0x104 555 213 123 Stack Operation Examples 0x108 0x10c 0x110 555 213 123 0x1080x104 pushl %eax 0x108 0x10c 0x110 213 123 0x104 213 popl %edx 0x108 213

6 – 6 – CSCE 212H Sp 03 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 value Address of instruction beyond call Example from disassembly 804854e:e8 3d 06 00 00 call 8048b90 8048553:50 pushl %eax Return address = 0x8048553 Procedure return: ret Pop address from stack; Jump to address

7 – 7 – CSCE 212H Sp 03 %esp %eip %esp %eip 0x804854e 0x108 0x10c 0x110 0x104 0x804854e 0x8048553 123 Procedure Call Example 0x108 0x10c 0x110 123 0x108 call 8048b90 804854e:e8 3d 06 00 00 call 8048b90 8048553:50 pushl %eax 0x8048b90 0x104 %eip is program counter

8 – 8 – CSCE 212H Sp 03 %esp %eip 0x104 %esp %eip 0x8048591 0x104 0x108 0x10c 0x110 0x8048553 123 Procedure Return Example 0x108 0x10c 0x110 123 ret 8048591:c3 ret 0x108 %eip is program counter 0x8048553

9 – 9 – CSCE 212H Sp 03 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

10 – 10 – CSCE 212H Sp 03 Call Chain Example Code Structure yoo(…) { who(); } who(…) { amI(); amI(); } amI(…) { amI(); } yoo who amI Call Chain Procedure amI recursive amI

11 – 11 – CSCE 212H Sp 03 Stack Pointer %esp yoo who proc Frame Pointer %ebp Stack “Top” Stack Frames Contents Local variables Return information Temporary spaceManagement Space allocated when enter procedure “Set-up” code Deallocated when return “Finish” codePointers Stack pointer %esp indicates stack top Frame pointer %ebp indicates start of current frame amI

12 – 12 – CSCE 212H Sp 03 Stack Pointer %esp yoo Frame Pointer %ebp Stack Operation yoo Call Chain yoo(…) { who(); }

13 – 13 – CSCE 212H Sp 03 Stack Pointer %esp yoo who Frame Pointer %ebp Stack Operation yoo who Call Chain who(…) { amI(); amI(); }

14 – 14 – CSCE 212H Sp 03 Stack Pointer %esp yoo who amI Frame Pointer %ebp Stack Operation yoo who amI Call Chain amI(…) { amI(); }

15 – 15 – CSCE 212H Sp 03 Stack Pointer %esp yoo who amI Frame Pointer %ebp Stack Operation yoo who amI Call Chain amI(…) { amI(); } amI

16 – 16 – CSCE 212H Sp 03 Stack Pointer %esp yoo who amI Frame Pointer %ebp Stack Operation yoo who amI Call Chain amI(…) { amI(); } amI

17 – 17 – CSCE 212H Sp 03 Stack Pointer %esp yoo who amI Frame Pointer %ebp Stack Operation yoo who amI Call Chain amI(…) { amI(); } amI

18 – 18 – CSCE 212H Sp 03 Stack Pointer %esp yoo who amI Frame Pointer %ebp Stack Operation yoo who amI Call Chain amI(…) { amI(); } amI

19 – 19 – CSCE 212H Sp 03 Stack Pointer %esp yoo who Frame Pointer %ebp Stack Operation yoo who Call Chain who(…) { amI(); amI(); } amI

20 – 20 – CSCE 212H Sp 03 Stack Pointer %esp yoo who amI Frame Pointer %ebp Stack Operation yoo who Call Chain amI(…) { } amI

21 – 21 – CSCE 212H Sp 03 Stack Pointer %esp yoo who Frame Pointer %ebp Stack Operation yoo who Call Chain who(…) { amI(); amI(); } amI

22 – 22 – CSCE 212H Sp 03 yoo(…) { who(); } Stack Pointer %esp yoo Frame Pointer %ebp Stack Operation yoo who Call Chain amI

23 – 23 – CSCE 212H Sp 03 IA32/Linux Stack Frame Current Stack Frame (“Top” to Bottom) Parameters for function about to call “Argument build” Local variables If can’t keep in registers Saved register context Old frame pointer Caller Stack Frame Return address Pushed by call instruction Arguments for this call Stack Pointer ( %esp ) Frame Pointer ( %ebp ) Return Addr Saved Registers + Local Variables Argument Build Old %ebp Arguments Caller Frame

24 – 24 – CSCE 212H Sp 03 Revisiting swap void swap(int *xp, int *yp) { int t0 = *xp; int t1 = *yp; *xp = t1; *yp = t0; } int zip1 = 15213; int zip2 = 91125; void call_swap() { swap(&zip1, &zip2); } call_swap: pushl $zip2# Global Var pushl $zip1# Global Var call swap &zip2 &zip1 Rtn adr %esp Resulting Stack Calling swap from call_swap

25 – 25 – CSCE 212H Sp 03 Revisiting swap void swap(int *xp, int *yp) { int t0 = *xp; int t1 = *yp; *xp = t1; *yp = t0; } 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 Body Set Up Finish

26 – 26 – CSCE 212H Sp 03 swap Setup #1 swap: pushl %ebp movl %esp,%ebp pushl %ebx Resulting Stack &zip2 &zip1 Rtn adr %esp Entering Stack %ebp yp xp Rtn adr Old %ebp %ebp %esp

27 – 27 – CSCE 212H Sp 03 swap Setup #2 swap: pushl %ebp movl %esp,%ebp pushl %ebx yp xp Rtn adr Old %ebp %ebp Resulting Stack &zip2 &zip1 Rtn adr %esp Entering Stack %ebp %esp

28 – 28 – CSCE 212H Sp 03 swap Setup #3 swap: pushl %ebp movl %esp,%ebp pushl %ebx yp xp Rtn adr Old %ebp %ebp Resulting Stack &zip2 &zip1 Rtn adr %esp Entering Stack %ebp Old %ebx %esp

29 – 29 – CSCE 212H Sp 03 Effect of swap Setup yp xp Rtn adr Old %ebp %ebp 0 4 8 12 Offset (relative to %ebp ) Resulting Stack &zip2 &zip1 Rtn adr %esp Entering Stack %ebp Old %ebx %esp movl 12(%ebp),%ecx # get yp movl 8(%ebp),%edx # get xp... Body

30 – 30 – CSCE 212H Sp 03 swap Finish #1 movl -4(%ebp),%ebx movl %ebp,%esp popl %ebp ret yp xp Rtn adr Old %ebp %ebp 0 4 8 12 Offset swap ’s Stack Old %ebx %esp-4 Observation Saved & restored register %ebx yp xp Rtn adr Old %ebp %ebp 0 4 8 12 Offset Old %ebx %esp-4

31 – 31 – CSCE 212H Sp 03 swap Finish #2 movl -4(%ebp),%ebx movl %ebp,%esp popl %ebp ret yp xp Rtn adr Old %ebp %ebp 0 4 8 12 Offset swap ’s Stack Old %ebx %esp-4 yp xp Rtn adr Old %ebp %ebp 0 4 8 12 Offset swap ’s Stack %esp

32 – 32 – CSCE 212H Sp 03 swap Finish #3 movl -4(%ebp),%ebx movl %ebp,%esp popl %ebp ret yp xp Rtn adr %ebp 4 8 12 Offset swap ’s Stack yp xp Rtn adr Old %ebp %ebp 0 4 8 12 Offset swap ’s Stack %esp

33 – 33 – CSCE 212H Sp 03 swap Finish #4 movl -4(%ebp),%ebx movl %ebp,%esp popl %ebp ret &zip2 &zip1 %esp Exiting Stack %ebp Observation Saved & restored register %ebx Didn’t do so for %eax, %ecx, or %edx yp xp Rtn adr %ebp 4 8 12 Offset swap ’s Stack %esp

34 – 34 – CSCE 212H Sp 03 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 yoo: movl $15213, %edx call who addl %edx, %eax ret who: movl 8(%ebp), %edx addl $91125, %edx ret

35 – 35 – CSCE 212H Sp 03 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 in its frame before calling “Callee Save” Callee saves temporary in its frame before using

36 – 36 – CSCE 212H Sp 03 IA32/Linux Register Usage Integer Registers Two have special uses %ebp, %esp Three managed as callee-save %ebx, %esi, %edi Old values saved on stack prior to using Three managed as caller-save %eax, %edx, %ecx Do what you please, but expect any callee to do so, as well Register %eax also stores returned value %eax %edx %ecx %ebx %esi %edi %esp %ebp Caller-Save Temporaries Callee-Save Temporaries Special

37 – 37 – CSCE 212H Sp 03 int rfact(int x) { int rval; if (x <= 1) return 1; rval = rfact(x-1); return rval * x; }.globl rfact.type rfact,@function rfact: pushl %ebp movl %esp,%ebp pushl %ebx movl 8(%ebp),%ebx cmpl $1,%ebx jle.L78 leal -1(%ebx),%eax pushl %eax call rfact imull %ebx,%eax jmp.L79.align 4.L78: movl $1,%eax.L79: movl -4(%ebp),%ebx movl %ebp,%esp popl %ebp ret Recursive Factorial Registers %eax used without first saving %ebx used, but save at beginning & restore at end

38 – 38 – CSCE 212H Sp 03 rfact: pushl %ebp movl %esp,%ebp pushl %ebx rfact: pushl %ebp movl %esp,%ebp pushl %ebx Rfact Stack Setup Entering Stack x Rtn adr 4 8 Caller %ebp 0 %esp Old %ebx -4 Callee x Rtn adr Caller %esp %ebp pre %ebp pre %ebx pre %ebp pre %ebx Old %ebp rfact: pushl %ebp movl %esp,%ebp pushl %ebx

39 – 39 – CSCE 212H Sp 03 Rfact Body Registers %ebx Stored value of x %eax Temporary value of x-1 Returned value from rfact(x-1) Returned value from this call movl 8(%ebp),%ebx# ebx = x cmpl $1,%ebx# Compare x : 1 jle.L78# If <= goto Term leal -1(%ebx),%eax# eax = x-1 pushl %eax# Push x-1 call rfact# rfact(x-1) imull %ebx,%eax# rval * x jmp.L79# Goto done.L78:# Term: movl $1,%eax# return val = 1.L79:# Done: int rfact(int x) { int rval; if (x <= 1) return 1; rval = rfact(x-1) ; return rval * x; } Recursion

40 – 40 – CSCE 212H Sp 03 Rfact Recursion x Rtn adr Old %ebp %ebp Old %ebx pushl %eax %esp x-1 %eax x %ebx x Rtn adr Old %ebp %ebp Old %ebx %esp %eax x %ebx x-1 leal -1(%ebx),%eax x Rtn adr Old %ebp %ebp Old %ebx x-1 %eax x %ebx %esp Rtn adr call rfact

41 – 41 – CSCE 212H Sp 03 (x-1)! Rfact Result x Rtn adr Old %ebp %ebp Old %ebx %esp x-1 imull %ebx,%eax x! %eax x %ebx x Rtn adr Old %ebp %ebp Old %ebx %esp x-1 (x-1)! %eax x %ebx Return from Call (x-1)! Assume that rfact(x-1) returns (x-1)! in register %eax

42 – 42 – CSCE 212H Sp 03 Rfact Completion movl -4(%ebp),%ebx movl %ebp,%esp popl %ebp ret x Rtn adr Old %ebp %ebp 0 4 8 Old %ebx %esp -4 x! %eax x %ebx x-1 -8 pre %ebp pre %ebx movl -4(%ebp),%ebx movl %ebp,%esp popl %ebp ret x Rtn adr Old %ebp %ebp 0 4 8 %esp x! %eax Old %ebx %ebx pre %ebp pre %ebx Old %ebx movl -4(%ebp),%ebx movl %ebp,%esp popl %ebp ret x Rtn adr %ebp %esp x! %eax Old %ebx %ebx pre %ebp pre %ebx

43 – 43 – CSCE 212H Sp 03 Pointer Code void s_helper (int x, int *accum) { if (x <= 1) return; else { int z = *accum * x; *accum = z; s_helper (x-1,accum); } int sfact(int x) { int val = 1; s_helper(x, &val); return val; } Top-Level Call Recursive Procedure Pass pointer to update location

44 – 44 – CSCE 212H Sp 03 Temp. Space %esp Creating & Initializing Pointer int sfact(int x) { int val = 1; s_helper(x, &val); return val; } _sfact: pushl %ebp# Save %ebp movl %esp,%ebp# Set %ebp subl $16,%esp# Add 16 bytes movl 8(%ebp),%edx# edx = x movl $1,-4(%ebp)# val = 1 Using Stack for Local Variable Variable val must be stored on stack Need to create pointer to it Compute pointer as -4(%ebp) Push on stack as second argument Initial part of sfact x Rtn adr Old %ebp %ebp 0 4 8 -4 val = 1 Unused -12 -8 -16 _sfact: pushl %ebp# Save %ebp movl %esp,%ebp# Set %ebp subl $16,%esp# Add 16 bytes movl 8(%ebp),%edx# edx = x movl $1,-4(%ebp)# val = 1 _sfact: pushl %ebp# Save %ebp movl %esp,%ebp# Set %ebp subl $16,%esp# Add 16 bytes movl 8(%ebp),%edx# edx = x movl $1,-4(%ebp)# val = 1 _sfact: pushl %ebp# Save %ebp movl %esp,%ebp# Set %ebp subl $16,%esp# Add 16 bytes movl 8(%ebp),%edx# edx = x movl $1,-4(%ebp)# val = 1

45 – 45 – CSCE 212H Sp 03 Passing Pointer int sfact(int x) { int val = 1; s_helper(x, &val); return val; } leal -4(%ebp),%eax# Compute &val pushl %eax# Push on stack pushl %edx# Push x call s_helper# call movl -4(%ebp),%eax# Return val # Finish Calling s_helper from sfact x Rtn adr Old %ebp %ebp 0 4 8 val = 1 -4 Unused -12 -8 -16 %esp x &val Stack at time of call leal -4(%ebp),%eax# Compute &val pushl %eax# Push on stack pushl %edx# Push x call s_helper# call movl -4(%ebp),%eax# Return val # Finish leal -4(%ebp),%eax# Compute &val pushl %eax# Push on stack pushl %edx# Push x call s_helper# call movl -4(%ebp),%eax# Return val # Finish val =x!

46 – 46 – CSCE 212H Sp 03 Using Pointer movl %ecx,%eax# z = x imull (%edx),%eax# z *= *accum movl %eax,(%edx)# *accum = z void s_helper (int x, int *accum) { int z = *accum * x; *accum = z; } Register %ecx holds x Register %edx holds pointer to accum Use access (%edx) to reference memory %edx accum x x %eax %ecx accum*x

47 – 47 – CSCE 212H Sp 03 Summary The Stack Makes Recursion Work Private storage for each instance of procedure call Instantiations don’t clobber each other Addressing of locals + arguments can be relative to stack positions Can be managed by stack discipline Procedures return in inverse order of calls IA32 Procedures Combination of Instructions + Conventions Call / Ret instructions Register usage conventions Caller / Callee save %ebp and %esp Stack frame organization conventions

Download ppt "Stack Activation Records Topics IA32 stack discipline Register saving conventions Creating pointers to local variables February 6, 2003 CSCE 212H Computer."

Similar presentations

Machine-Level Programming III: Procedures Feb. 8, 2000 Topics IA32 stack Stack-based languages Stack frames Register saving conventions Creating pointers.

Machine-Level Programming III: Procedures Feb. 8, 2000 Topics IA32 stack Stack-based languages Stack frames Register saving conventions Creating pointers.
University of Washington Procedures and Stacks II The Hardware/Software Interface CSE351 Winter 2013.

University of Washington Procedures and Stacks II The Hardware/Software Interface CSE351 Winter 2013.
Machine Programming – Procedures and IA32 Stack CENG334: Introduction to Operating Systems Instructor: Erol Sahin Acknowledgement: Most of the slides are.

Machine Programming – Procedures and IA32 Stack CENG334: Introduction to Operating Systems Instructor: Erol Sahin Acknowledgement: Most of the slides are.
X86 Programming CS 740 Sept. 12, 2007 Topics Basics Accessing and Moving Data Arithmetic operations Control Flow Procedures Data Structures.

X86 Programming CS 740 Sept. 12, 2007 Topics Basics Accessing and Moving Data Arithmetic operations Control Flow Procedures Data Structures.
Carnegie Mellon Instructors: Randy Bryant and Dave O’Hallaron Machine-Level Programming III: Switch Statements and IA32 Procedures 15-213: Introduction.

Carnegie Mellon Instructors: Randy Bryant and Dave O’Hallaron Machine-Level Programming III: Switch Statements and IA32 Procedures : Introduction.
University of Washington Last Time For loops  for loop → while loop → do-while loop → goto version  for loop → while loop → goto “jump to middle” version.

University of Washington Last Time For loops  for loop → while loop → do-while loop → goto version  for loop → while loop → goto “jump to middle” version.
Machine-Level Programming III: Procedures Apr. 17, 2006 Topics IA32 stack discipline Register saving conventions Creating pointers to local variables CS213.

Machine-Level Programming III: Procedures Apr. 17, 2006 Topics IA32 stack discipline Register saving conventions Creating pointers to local variables CS213.
1 Function Calls Professor Jennifer Rexford COS 217 Reading: Chapter 4 of “Programming From the Ground Up” (available online from the course Web site)

1 Function Calls Professor Jennifer Rexford COS 217 Reading: Chapter 4 of “Programming From the Ground Up” (available online from the course Web site)
Machine-Level Programming III: Procedures Sept. 17, 2007 IA32 stack discipline Register saving conventions Creating pointers to local variablesx86-64 Argument.

Machine-Level Programming III: Procedures Sept. 17, 2007 IA32 stack discipline Register saving conventions Creating pointers to local variablesx86-64 Argument.
– 1 – 15-213, F’02 ICS05 Instructor: Peter A. Dinda TA: Bin Lin Recitation 4.

– 1 – , F’02 ICS05 Instructor: Peter A. Dinda TA: Bin Lin Recitation 4.
IA32 Stack Discipline From Last Time

IA32 Stack Discipline From Last Time
Machine-Level Programming III: Procedures Jan 30, 2003

Machine-Level Programming III: Procedures Jan 30, 2003
Assembly תרגול 8 פונקציות והתקפת buffer.. Procedures (Functions) A procedure call involves passing both data and control from one part of the code to.

Assembly תרגול 8 פונקציות והתקפת buffer.. Procedures (Functions) A procedure call involves passing both data and control from one part of the code to.
Machine-Level Programming III: Procedures Sept. 15, 2006 IA32 stack discipline Register saving conventions Creating pointers to local variablesx86-64 Argument.

Machine-Level Programming III: Procedures Sept. 15, 2006 IA32 stack discipline Register saving conventions Creating pointers to local variablesx86-64 Argument.
September 22, 2014 Pengju (Jimmy) Jin Section E

September 22, 2014 Pengju (Jimmy) Jin Section E
Introduction to x86 Assembly or “How does someone hack my laptop?”

Introduction to x86 Assembly or “How does someone hack my laptop?”
Y86 Processor State Program Registers

Y86 Processor State Program Registers
Carnegie Mellon Introduction to Computer Systems 15-213/18-243, spring 2009 Recitation, Jan. 14 th.

Carnegie Mellon Introduction to Computer Systems /18-243, spring 2009 Recitation, Jan. 14 th.
1 Carnegie Mellon Stacks 15-213: Introduction to Computer Systems Recitation 5: September 24, 2012 Joon-Sup Han Section F.

1 Carnegie Mellon Stacks : Introduction to Computer Systems Recitation 5: September 24, 2012 Joon-Sup Han Section F.
Lee CSCE 312 TAMU 1 Based on slides provided by Randy Bryant and Dave O’Hallaron Machine-Level Programming III: Switch Statements and IA32 Procedures Instructor:

Lee CSCE 312 TAMU 1 Based on slides provided by Randy Bryant and Dave O’Hallaron Machine-Level Programming III: Switch Statements and IA32 Procedures Instructor:

Similar presentations

Ads by Google