MidtermExamMidterm Exam - AndroBenchcsl.skku.edu/uploads/CSE2003S10/11-procedure.pdf ·...

transcript

Midterm ExamMidterm ExamMidterm ExamMidterm Exam

Midterm Exam Results

Class A (Average 150/230)

Class A (Average = 150/230)Class B (Average = 137/230)

1CSE2003: System Programming | Spring 2010| Jin-Soo Kim (jinsookim@skku.edu)

0‐20 21‐40 41‐60 61‐80 81‐100 101‐120 121‐140 141‐160 161‐180 181‐200 201‐230

NoticeNoticeNoticeNotice Midterm exam results

• Check out your score in GLS• Your exam papers and answer sheets are available in p p

#400629.• If you have any claims, please visit my office during

5/10 ~ 5/14.

First programming assignment results• They will be posted on the course homepage soon.y p p g• Any claims to 김형준 조교 (hjkim@csl.skku.edu,

#400629)

NoticeNoticeNoticeNotice Project assignment #2j g

• Due date is 5/9 11:59PM• Send your code and document to y

cse2003skku@csl.skku.edu and cse2003skku@gmail.com

• Any questions to 김형준 조교 (hjkim@csl.skku.edu)

Guest lecturesGuest lectures• Class on 5/3 by Prof. Hwansoo Han• Class on 5/6 by Prof Joonwon LeeClass on 5/6 by Prof. Joonwon Lee

A bl IIIA bl IIIAssembly III:Procedures

Assembly III:ProceduresProceduresProcedures

Jin-Soo Kim (jinsookim@skku.edu)Jin Soo Kim (jinsookim@skku.edu)Computer Systems Laboratory

Sungkyunkwan Universityhtt // l kk dhttp://csl.skku.edu

IA-32 Stack (1)IA-32 Stack (1)IA 32 Stack (1)IA 32 Stack (1) Characteristics Stack “Bottom”

• Region of memory managed with stack

Stack Bottom

discipline• Grows toward lower

IncreasingAddresses

addresses• Register %esp

i di t l t t kindicates lowest stack address– address of top element

StackPointer

Stack GrowsDown

address of top element Pointer%esp

Stack “Top”

IA-32 Stack (2)IA-32 Stack (2)IA 32 Stack (2)IA 32 Stack (2) Pushing Stack “Bottom”g

• pushl Src• Fetch operand at Src Increasingp• Decrement %esp by 4• Write operand at

IncreasingAddresses

te ope a d ataddress given by %esp

St k GStack GrowsDown

StackPointerPointer%esp -4

Stack “Top”

IA-32 Stack (3)IA-32 Stack (3)IA 32 Stack (3)IA 32 Stack (3) Popping Stack “Bottom”pp g

• popl Dest• Read operand at Increasingp

address given by %esp• Increment %esp by 4

IncreasingAddresses

• Write to Dest

St k GStack GrowsDown

StackPointerPointer%esp +4

Stack “Top”

IA-32 Stack (4)IA-32 Stack (4)IA 32 Stack (4)IA 32 Stack (4) Stack operation examplesp p

pushl %eax popl %edx

0x104 213

1230x108

123 0x108

%edx 555

0x108 0x104

%esp%esp%esp 0x1080x108 0x104 0x1040x108

Procedure Control FlowProcedure Control FlowProcedure Control FlowProcedure Control Flow Use stack to support procedure call and pp p

return Procedure callProcedure call

• call label– Push return address on stack– Jump to label

• Return address value– Address of instruction beyond call

Procedure return• ret

– Pop address from stack

– Jump to address

Procedure Call ExampleProcedure Call ExampleProcedure Call ExampleProcedure Call Example804854e: e8 3d 06 00 00 call 8048b90 <main>

call 8048b90

8048553: 50 pushl %eax

0x1100x110

0x08048553+0x0000063d

1230x108

=0x08048b90

%esp %esp 0x108

0x104 0x8048553

0x108 0x104%esp

%eip 0x804854e

0x804854e

0x8048b90

%eip is program counter

Procedure Return ExampleProcedure Return ExampleProcedure Return ExampleProcedure Return Example8048591: c3 ret

0x110 0x110

0 8048553

123 0x108

0 8048553

%esp 0x1040x104

0x8048553

%eip 0x80485910x8048591 0x8048553

%eip is program counter

Stack-based LanguagesStack-based LanguagesStack based LanguagesStack based Languages Languages that support recursion

• e.g., C, Pascal, Java, etc.• Code must be “Reentrant”

– Multiple simultaneous instantiations of single procedure

• Need some place to store state of each instantiationArguments local variables return pointer– Arguments, local variables, return pointer

Stack discipline• State for given procedure needed for limited time• 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

Stack Frames (1)Stack Frames (1)Stack Frames (1)Stack Frames (1)Call ChainCode Structure

yoo(…){

••who();•

who(…){

• • •

amI();• • •amI();

amI( )

• • •}

amI(…){

••

amIamI();••

• Procedure amIrecursive

}recursive

Stack Frames (2)Stack Frames (2)Stack Frames (2)Stack Frames (2) Contents

• Return information• Arguments• Local variables & temp space

whoLocal variables & temp space

Management• Space allocated when enter

procedure– “set-up” code

• Deallocated when return

FramePointer%ebp

– “finish” code

PointersStack pointe %esp indicates

StackPointer

proc%ebp

• Stack pointer %esp indicates stack top

• Frame pointer %ebp indicates t t f t f

Pointer%esp Stack

“Top”

start of current frame

Stack Frames (3)Stack Frames (3)Stack Frames (3)Stack Frames (3)•Frame••Pointer

%ebpCall Chainyoo(…)

StackPointer%

••h ()

%espwho();••

Stack Frames (4)Stack Frames (4)Stack Frames (4)Stack Frames (4)•••

FrameCall Chain

who(…)yoo

FramePointer%ebp

•amI();

StackPointer%

whowho•amI();•

Stack Frames (5)Stack Frames (5)•

Stack Frames (5)Stack Frames (5)

••

Call ChainamI(…)

whoFrame

••I()

FramePointer%ebp

amI();••

}Stack

Pointer%esp

amIamI}

Call ChainamI(…)

••I()

amIFrame

amI();••

} amIFramePointer%ebp

amI amIStack

Pointer%esp

Call ChainamI(…)

••I()

amI();••

amI amIPointer%ebpamI

Stack Pointer %esp

Call ChainamI(…)

••I()

amI();••

} Frame amIamI}

amI amI

FramePointer%ebp

amIStack

Pointer%esp

Call ChainamI(…)

••I()

Frame who

amI();••

FramePointer%ebp

amIamI}

StackPointer%esp

Call Chainwho(…)

yooFrame

•amI();

yooFramePointer%ebp

whowho

•amI();•

StackPointeramI}

Call ChainamI(…)

••

Frame who

••

FramePointer%ebp

amI amIamI

StackPointer%esp

Call Chainwho(…)

yooFrame

•amI();

yooFramePointer%ebp

whowho

•amI();•

StackPointeramIamI}

Stack Frames (13)Stack Frames (13)Stack Frames (13)Stack Frames (13)•Frame••Pointer

%ebpCall Chainyoo(…)

StackPointer%

••h ()

%espwho

who();••

} amIamI}

IA-32/Linux Stack FrameIA-32/Linux Stack FrameIA 32/Linux Stack FrameIA 32/Linux Stack Frame Current stack frame (“Top”

to Bottom)• Parameters for function about

t llCallerFrameto call

– “Argument build”

• Local variables Frame Pointer Return Addr

ArgumentsFrame

Local variables– If can’t keep in registers

• Saved register context

(%ebp)

Old %ebp

g• Old frame pointer

Caller stack frame

Registers+

• Return address– Pushed by call instruction

f h ll Stack Pointer

Variables

Argument

• Arguments for this call Stack Pointer(%esp)

Revisiting swap (1)Revisiting swap (1)e s t g swap ( )e s t g swap ( )

int zip1 = 15213;Calling swap from call_swap

int zip1 = 15213;int zip2 = 91125;

void call swap()

call_swap:• • •pushl $zip2 # Global Varvoid call_swap()

{swap(&zip1, &zip2);

pushl $zip2 # Global Varpushl $zip1 # Global Varcall swap• • •

void swap(int *xp, int *yp)

} • • •

Resulting•{int t0 = *xp;int t1 = *yp;

gStack•

*xp = t1;*yp = t0;

Rtn adr %esp

Revisiting swap (2)Revisiting swap (2)e s t g swap ( )e s t g swap ( )

void swap(int *xp int *yp)void swap(int *xp, int *yp) {int t0 = *xp;int t1 = *yp;

swap:pushl %ebpmovl %esp,%ebppushl %ebx

Setupint t1 = *yp;*xp = t1;*yp = t0;

pushl %ebx

movl 12(%ebp),%ecxmovl 8(%ebp) %edx} movl 8(%ebp),%edxmovl (%ecx),%eaxmovl (%edx),%ebxmovl %eax,(%edx)

Bodymovl %eax,(%edx)movl %ebx,(%ecx)

movl -4(%ebp),%ebx( p),movl %ebp,%esppopl %ebpret

Finish

Swap Setup (1)Swap Setup (1)Swap Setup ( )Swap Setup ( )ResultingSt k

EnteringSt k StackStack

%ebp %ebp•••

•••

Rtn adr %esp

Rtn adrOld %ebp %esp

swap:pushl %ebpmovl %esp,%ebp

pushl %ebx

Swap Setup (2)Swap Setup (2)Swap Setup ( )Swap Setup ( )ResultingSt k

%ebp•••

•••

Rtn adr %esp

Rtn adrOld %ebp %esp

pushl %ebx

Swap Setup (3)Swap Setup (3)Swap Setup (3)Swap Setup (3)ResultingSt k

%ebp•••

•••

Rtn adr %esp

Rtn adrOld %ebp %ebp

%espOld %ebx

pushl %ebx

Effect of swap SetupEffect of swap Setupect o swap Setupect o swap SetupResultingSt k

%ebp•••

•••

Rtn adr %esp

Rtn adrOld %ebp %ebp0

movl 12(%ebp),%ecx # get ypmovl 8(%ebp),%edx # get xp

%espOld %ebx

swap Finish (1)swap Finish (1)swap s ( )swap s ( )swap’s Stack

••

Offset

Rtn adr4

Old %ebp %ebp

%espOld %ebx0

Old %ebp %ebp

%espOld %ebx0

movl –4(%ebp),%ebxmovl %ebp,%esppopl %ebp

Observation• Saved & restored register %ebx

p p pret

Saved & restored register %ebx

••

Offset

Rtn adr4

Old %ebp %ebp

%espOld %ebx0

Old %ebp %ebp

%espOld %ebx0

p p pret

swap Finish (3)swap Finish (3)swap s (3)swap s (3)swap’s Stack

••

Offset

Rtn adr

Rtn adr4

Old %ebp%espOld %ebx

Old %ebp %ebp

%espOld %ebx0

p p pret

%ebp% bExiting Stack

••

Offset

Rtn adr

xp %esp

Rtn adrOld %ebp

Old %ebx0

Old %ebp%espOld %ebx

Observation• Saved & restored register %ebx

p p pret• Didn’t do so for %eax, %ecx, or %edx

Register Saving Conventions (1)Register Saving Conventions (1)g g ( )g g ( )

When procedure yoo() calls who():p y () ()• yoo is the caller, who is the callee

Can register be used for temporary storage?Can register be used for temporary storage?

yoo:• • •

who:• • •• • •

movl $15213, %edxcall whoaddl %edx, %eax

• • •movl 8(%ebp), %edxaddl $91125, %edx• • •addl %edx, %eax

• • •ret

• Contents of register %edx overwritten by who

Register Saving Conventions (2)Register Saving Conventions (2)g g ( )g g ( )

Conventions• “Caller save”

– Caller saves temporary in its frame before calling

• “Callee save”– Callee saves temporary in its frame before using

IA-32/Linux Register UsageIA-32/Linux Register UsageIA 32/Linux Register UsageIA 32/Linux Register Usage Integer registersg g

• Two have special uses:– %ebp, %esp

%edxCaller‐Save

• Three managed as callee-save:– %ebx, %esi, %edi

Temporaries

– Old values saved on stack prior to using

• Three managed as caller save:

%esiCallee‐SaveTemporaries

• Three managed as caller-save:– %eax, %edx, %ecx– Do what you please, but expect

%espSpecialy p , p

any callee to do so, as well

• Register %eax also stores d l

%ebpSpecial

returned value

Recursive Factorial: rfactRecursive Factorial: rfactecu s e acto a : actecu s e acto a : act Registers rfact:

pushl %ebpg

• %eax used without first saving

pushl %ebpmovl %esp,%ebppushl %ebxmovl 8(%ebp),%ebx

• %ebx used, but save at beginning & d

cmpl $1,%ebxjle .L78leal -1(%ebx),%eaxpushl %eax& restore at end

int rfact(int x)

pushl %eaxcall rfactimull %ebx,%eaxjmp .L79

{int rval;if (x <= 1)

.align 4.L78:

movl $1,%eaxL79:return 1;

rval = rfact(x-1);return rval * x;

.L79:movl -4(%ebp),%ebxmovl %ebp,%esppopl %ebp

rfact Stack Setuprfact Stack Setupact Stac Setupact Stac Setup

Entering Stack%ebppre %ebp pre %ebp

xCaller

%ebppre %ebppre %ebx

Callerpre %ebppre %ebx

Rtn adr %esp Rtn adr4

%ebp0 Callee

Old %ebp%espOld %ebx-4

Callee

rfact:pushl %ebppushl %ebpmovl %esp,%ebppushl %ebx

rfact Bodyrfact Bodyact odyact ody Registers int rfact(int x)

• %ebx: stored value of x• %eax

{int rval;if (x <= 1)

return 1;– Temporary value of x-1– Returned value from rfact(x-1)

R t d l f thi ll

return 1;rval = rfact(x-1);return rval * x;

}– Returned value from this call

movl 8(%ebp),%ebx # ebx = xcmpl $1,%ebx # Compare x : 1

8 #jle .L78 # If <= goto Termleal -1(%ebx),%eax # eax = x-1pushl %eax # Push x-1call rfact # rfact(x-1)Recursion call rfact # rfact(x 1)imull %ebx,%eax # rval * xjmp .L79 # Goto done

.L78: # Term:l $1 % # l 1

movl $1,%eax # return val = 1.L79: # Done:

rfact Recursionrfact Recursionact ecu s oact ecu s oleal -1(%ebx),%eax

pushl %eaxx

Rtn adr call rfact

Old %ebp %ebp

Old %ebx %espx

Rtn adrOld %ebx

%espx-1

Old %ebx

x-1%eax

x-1x-1

%espRtn adrx 1%eax

x%ebx x-1%eax

rfact Resultrfact Resultact esu tact esu t

imull %ebx,%eaxReturn from Call

Rtn adr

imull %ebx,%eax

Rtn adr

Return from Call

Old %ebx

%espx-1%espx-1

(x-1)!x!%eax

(x-1)!%eax

(x-1)!

x%ebxx%ebx

Assume that rfact(x-1)returns (x-1)! in register

( ) g%eax

rfact Completionrfact Completionact Co p et oact Co p et o

pre %ebpmovl –4(%ebp),%ebx

l % b %

pre %ebppre %ebx

movl %ebp,%esppopl %ebpret

pre %ebppre %ebx %ebppre %ebp

Old %ebx%esp

Rt d %

pre %ebx

x!%eax

Old %ebp %ebp0 %esp

Old %ebx

Rtn adr %esp

x%ebxx!%eax

Old %ebx%ebx

Old %ebx

x!%eax

Old %ebx%ebx

SummarySummarySummarySummary The stack makes recursion work

• Private storage for each instance of procedure call– Instantiations don’t clobber each other

Add i f l l t b l ti t t k– Addressing of locals + arguments can be relative to stack positions

• Can be managed by stack disciplineg y p– Procedures return in inverse order of calls

Procedures = Instructions + Conventions• Call / Ret instructions• Register usage conventions

ll ll– Caller / Callee save– %ebp and %esp

• Stack frame organization conventions

MidtermExamMidterm Exam - AndroBenchcsl.skku.edu/uploads/CSE2003S10/11-procedure.pdf ·...

Documents