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 movq... popq %rbp %rsp, %rbp %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*allocaJon* Java*vs.*C* Procedures*and*Call*Stacks* How*do*I*pass*arguments*to*a*procedure?* How*do*I*get*a*urn*value*from*a*procedure?* Where*do*I*put*local*variables?* When*a*funcJon*urns,*how*does*it*know*where*to*urn?* To*answer*these*quesJons,*we*need*a*call$stack* * 1* 2* Memory*Layout* Memory*Layout* segmentajon*faults?* 2 N -1 Stack local variables; procedure context writable; not executable Stack 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 3* 4*

2 IA32*Call* Region*of*memory*managed** with*a*stack* discipline * Grows*toward*lower*addresses* Customarily*shown* upside[down * Bo^om * Increasing& Addresses& IA32*Call*Stack:*Push* pushl Src* Bo^om * Increasing& Addresses& Register**contains** lowest*stack*address* =*address*of* top *element* Pointer:* Stack&Grows& Down& Pointer:* Stack&Grows& Down& Top * Top * 5* 6* IA32*Call*Stack:*Push* IA32*Call*Stack:*Pop* Bo^om * Bo^om * pushl Src* Fetch&value&from&Src& Decrement&*by&4&&(why(4?)( Store&value&at&address&& given&by& Increasing& Addresses& popl Dest* Increasing& Addresses& Pointer:* [4* Stack&Grows& Down& Pointer:* Stack&Grows& Down& Top * Top * 7* 8*

3 IA32*Call*Stack:*Pop* IA32*Call*Stack:*Pop* Bo^om * Bo^om * popl Dest* Load&value&from&address&* Write&value&to&Dest( Increment&*by&4& Increasing& Addresses& popl Dest* Load&value&from&address&* Write&value&to&Dest( Increment&*by&4& Increasing& Addresses& Pointer:* +4* Stack&Grows& Down& Pointer:* +4* Stack&Grows& Down& Top * Top * Those*bits*are*sJll*there;* we re*just*not*using*them.* 9* 10* Procedure*Call*Overview* Procedure*Call*Overview* Caller* procedures* Caller* **** * <set*up*args>* call* <clean*up*args>* <find*urn*val>* **** * Callee*must*know*where*to*find*args* Callee* <create*local*vars>* *** * <set*up*urn*val>* <destroy*local*vars>* urn* **** * <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* Callee*must*know*where*to*find* urn*address * Caller*must*know*where*to*find*urn*val* Caller*and*Callee*run*on*same*CPU* *use*the*same*registers* So&how&do&we&deal&with&register&reuse?& The*convenJon*of*where*to*leave/find*things*is*called*the* calling*convenjon*(or*procedure*call*linkage).* Details&vary&between&systems& We&will&see&the&convenAon&for&IA32/Linux&in&detail& What&could&happen&if&our&program&didn t&follow&these&convenaons?* 11* 12*

4 Procedure*Control*Flow* Use*stack*to*support*procedure*call*and*urn* Procedure*call:*call label Push&urn&address&on&stack&(why?,(and(which(exact(address?)( 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&instrucAon&aLer&call* Example&from&disassembly:& e: e8 3d call 8048b90 <main> : 50 pushl %eax Return&address&=&* Procedure*urn:* Pop&urn&address&from&stack& Jump&to&address next*instrucjon* just*happens*to*be*a*push* could*be*anything* 13* 14* Procedure*Call* e: e8 3d call 8048b90 <main> : 50 pushl %eax Procedure*Call* e: e8 3d call 8048b90 <main> : 50 pushl %eax call 8048b90 call 8048b90 %eip 0x804854e %eip 0x804854e %eip 0x804854e %eip: program$counter 15* %eip: program$counter 16*

5 Procedure*Call* e: e8 3d call 8048b90 <main> : 50 pushl %eax Procedure*Return* : c3 call 8048b90 %eip 0x804854e %eip: program$counter %eip + 0x000063d 0x8048b90 relajve*address* just*like*jumps * (chosen&by&compiler;&& there s&also&an&absolute&call)& 17* %eip: program$counter %eip 0x * Procedure*Return* : c3 Procedure*Return* : c3 %eip 0x %eip 0x %eip 0x %eip 0x %eip: program$counter 19* %eip: program$counter 20*

6 Procedure*Return* : c3 %eip 0x %eip 0x Stack[Based*Languages* Languages*that*support*recursion* e.g.,&c,&java,&most&modern&languages& Code&must&be&re6entrant& MulAple&simultaneous&instanAaAons&of&single&procedure& Need&some&place&to&store&state&of&each&instanAaAon& Arguments& Local&variables& Return&pointer& discipline* State&for&a&given&procedure&needed&for&a&limited&Ame& StarAng&from&when&it&is&called&to&when&it&urns& Callee&always&urns&before&caller&does& allocated*in*frames$ State&for&a&single&procedure&instanAaAon& %eip: program$counter 21* 22* Call*Chain* ( ) (); ( ) (); (); ( ) (); Procedure****is*recursive* (calls*itself)* Call*Chain* Frames* Contents* Local&variables& FuncAon&arguments& Return&informaAon& Temporary&space& Frame*Pointer:** Pointer:** Management* Space&allocated&when&procedure&is&entered& SetYup &code& Space&deallocated&upon&urn& Finish &code& Previous* Frame* Frame* for* current* proc Top * 23* 24*

7 ( ) (); * * 25* ( ) (); (); * * 26* ( ) (); * * 27* ( ) (); * * 28*

8 ( ) (); * * 29* ( ) (); * * 30* ( ) (); * * 31* ( ) (); (); * * 32*

9 ( ) * * ( ) (); (); * * 33* 34* IA32/Linux*Frame* ( ) (); * * How*did*we*remember*where*to*point**when*urning?* 35* Current*Frame*( Top *to*bo^om)* Argument&build &area& (parameters&for&funcaon&& 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&instrucAon& Arguments&for&this&call& Frame*pointer* * pointer* * Caller* Frame* Arguments* Return*Addr* Old** Saved* Registers* +* Local* Variables* Argument* Build* 36*

10 RevisiJng*swap* int zip1 = 15213; int zip2 = 98195; void call_swap() swap(&zip1, &zip2); void swap(int *, int *) int t0 = *; int t1 = *; * = t1; * = t0; RevisiJng*swap* int zip1 = 15213; int zip2 = 98195; void call_swap() swap(&zip1, &zip2); void swap(int *, int *) int t0 = *; int t1 = *; * = t1; * = t0; Calling*swap*from*call_swap call_swap: pushl $zip2 # Global Var pushl $zip1 # Global Var call swap we*know*the*address* not*global*war!* 37* 38* RevisiJng*swap* RevisiJng*swap* int zip1 = 15213; int zip2 = 98195; void call_swap() swap(&zip1, &zip2); void swap(int *, int *) int t0 = *; int t1 = *; * = t1; * = t0; Calling*swap*from*call_swap call_swap: pushl $zip2 # Global Var pushl $zip1 # Global Var call swap * * &zip2 &zip1 ResulJng* 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) movl -4(),%ebx movl, popl Set* Up* Body* Finish* 39* 40*

11 swap*setup*#1* swap*setup*#1* Entering* ResulJng*Stack?* Entering* ResulJng* * * * * * * &zip2 &zip2 &zip1 &zip1 Old** swap: pushl movl, pushl %ebx Set* Up* swap: pushl movl, pushl %ebx Set* Up* 41* 42* swap*setup*#2* swap*setup*#3* Entering* ResulJng* Entering* ResulJng* * * * * * * * * &zip2 &zip2 &zip1 &zip1 swap: pushl movl, pushl %ebx Set* Up* Old** swap: pushl movl, pushl %ebx Set* Up* Old** Old*%ebx* 43* 44*

12 swap*body* swap*finish*#1* Entering* ResulJng* Finishing* ResulJng*Stack?* * * &zip2 &zip1 Offset$rela8ve$$ to$new$ 12* 8* 4* * * Old** Old*%ebx* * * Old** Old*%ebx* movl 12(),%ecx # get movl 8(),%edx # get... Body* 45* movl -4(),%ebx movl, popl Finish* 46* swap*finish*#1* swap*finish*#2* Finishing* ResulJng* Finishing* ResulJng* * * * * * * * * Old** Old*%ebx* Old** Old*%ebx* Old** Old*%ebx* Old** movl -4(),%ebx movl, popl Finish* ObservaJon:*Saved*and*restored** register*%ebx 47* movl -4(),%ebx movl, popl Finish* 48*

13 swap*finish*#3* swap*finish*#4* Finishing* ResulJng* Finishing* ResulJng* * * * * * * * * Old** Old*%ebx* Old** Old*%ebx* movl -4(),%ebx movl, popl Finish* 49* movl -4(),%ebx movl, popl Finish* 50* Disassembled*swap* swap*finish*#4* 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 Calling*Code* : e8 96 ff ff ff call 80483a4 <swap> e: 8b 45 f8 mov 0xfffffff8(),%eax relajve*address*(li^le*endian)*, 51* Finishing* * * Old** Old*%ebx* movl -4(),%ebx movl, popl Finish* ResulJng* * * ObservaJon* Saved&&&restored&register&%ebx* but&not&%eax,*%ecx,&or&%edx* 52*

14 Register*Saving*ConvenJons* When*procedure**calls*:* &is&the&caller* &is&the&callee$ Register*Saving*ConvenJons* 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?* ConvenJons* 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&%edx*overwri]en&by&* 53* 54* 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 Example:*Pointers*to*Local*Variables* Top[Level*Call* int sfact(int x) int val = 1; s_helper(x, &val); urn val; sfact(3) * ** 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);, special&form&of&callee&save& &restored&to&original&values&upon&exit&from& procedure& Pass*pointer*to*update*locaJon* 55* 56*

15 Example:*Pointers*to*Local*Variables* Top[Level*Call* int sfact(int x) int val = 1; s_helper(x, &val); urn val; sfact(3) * *val*=*1* s_helper(3,*&val) ** 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*locaJon* Example:*Pointers*to*Local*Variables* Top[Level*Call* int sfact(int x) int val = 1; s_helper(x, &val); urn val; sfact(3) * *val*=*1* s_helper(3,*&val) *val*=*3* s_helper(2,*&val) ** 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*locaJon* 57* 58* Example:*Pointers*to*Local*Variables* Top[Level*Call* int sfact(int x) int val = 1; s_helper(x, &val); urn val; sfact(3) * *val*=*1* s_helper(3,*&val) *val*=*3* s_helper(2,*&val) *val*=*6* s_helper(1,*&val) *.* 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*locaJon* CreaJng*&*IniJalizing*Pointer* int sfact(int x) int val = 1; s_helper(x, &val); urn val; IniJal*part*of*sfact* _sfact: pushl # Save movl, # Set subl $16, # Add 16 bytes movl 8(),%edx # edx = x movl $1,-4() # val = 1 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 0 Old** -4 val = Temp.* Unused* Space* 59* 60*

16 Passing*Pointer* int sfact(int x) int val = 1; s_helper(x, &val); urn val; Calling*s_helper*from*sfact* at*jme*of*call:* leal -4(),%eax # Compute &val pushl %eax # Push on stack pushl %edx # Push x call s_helper # call movl -4(),%eax # Return val # Finish Variable*val*must*be*stored*on*stack* Because:&Need&to&create&pointer&to&it& Compute*pointer*as*-4()* Push*on*stack*as*second*argument* x Old** -4 val=x! = Unused* &val x IA*32*Procedure*Summary* Important*points:* IA32&procedures&are&a&combinaAon&of&instruc8ons& and&conven8ons( Caller* ConvenAons&prevent&funcAons&from& Frame* disrupang&each&other& Stack&is&the&right&data&structure&for&procedure& call&/&urn& * If&P&calls&Q,&then&Q&urns&before&P& Recursion*handled*by*normal*calling* convenjons* Can&safely&store&values&in&local&stack&frame&and&in& calleeysaved&registers& Put&funcAon&arguments&at&top&of&stack& Result&urned&in&%eax * Arguments* Return*Addr* Old** Saved* Registers* +* Local* Variables* Argument* Build* 61* 62* x86[64*procedure*calling*convenjon* x86[64*64[bit*registers:*usage*convenjons* 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* 63* 64*

17 RevisiJng*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* 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 64Ybit&pointers& No*stack*operaJons** required*(except*)* Avoiding*stack* Can&hold&all&local&informaAon&& in&registers& 65* 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)* Registers*sJll*designated* caller[saved *or* callee[saved * callq*instrucjon*stores*64[bit*urn*address*on*stack** Address&pushed&onto&stack,&decremenAng&%rsp&by&8& No*frame*pointer* All&references&to&stack&frame&made&relaAve&to&%rsp;&eliminates&need&to& update&/%rbp,&which&is&now&available&for&generalypurpose&use& FuncJons*can*access*memory*up*to*128*bytes*beyond*%rsp:* the* red*zone * Can&store&some&temps&on&stack&without&altering&%rsp& 66* x86[64*memory*layout* 2 N -1 Stack Dynamic Data (Heap) Static Data Literals %rsp* 128[byte*red*zone* space(lower(than(the( stack(pointer(that( procedures(can(use(for( data(not(needed(across( procedure(calls( op8miza8on(to(avoid( extra(%rsp(updates( x86[64*frames* Owen*(ideally),*x86[64*funcJons*need*no*stack*frame*at*all* Just&a&urn&address&is&pushed&onto&the&stack&when&a&funcAon&call&is& made& A*funcJon*does*need*a*stack*frame*when*it:* Has&too&many&local&variables&to&hold&in&registers& Has&local&variables&that&are&arrays&or&structs& Uses&the&addressYof&operator&(&)&to&compute&the&address&of&a&local& variable& Calls&another&funcAon&that&takes&more&than&six&arguments& Needs&to&save&the&state&of&callerYsave&registers&before&calling&a&procedure& Needs&to&save&the&state&of&calleeYsave&registers&before&modifying&them& 0 Instructions 67* 68*

18 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); call_proc: subq $32,%rsp movq $1,16(%rsp) movl $2,24(%rsp) movw $3,28(%rsp) movb $4,31(%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); call_proc: subq $32,%rsp movq $1,16(%rsp) movl $2,24(%rsp) movw $3,28(%rsp) movb $4,31(%rsp) Return*address*to*caller*of*call_proc* %rsp Return*address*to*caller*of*call_proc* x4* x3* x2* x1* NB:*Details*may*vary* depending*on*compiler.* %rsp 69* 70* 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* x4* x3* x2* call_proc: leaq 24(%rsp),%rcx leaq 16(%rsp),%rsi leaq 31(%rsp),%rax movq %rax,8(%rsp) movl $4,(%rsp) leaq 28(%rsp),%r9 movl $3,%r8d movl $2,%edx movq $1,%rdi call proc 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* x4* x3* x2* call_proc: leaq 24(%rsp),%rcx leaq 16(%rsp),%rsi leaq 31(%rsp),%rax movq %rax,8(%rsp) movl $4,(%rsp) leaq 28(%rsp),%r9 movl $3,%r8d movl $2,%edx movq $1,%rdi call proc note* sizes* x1* Arg*8* Arg*7* %rsp Arguments*passed*in*(in* order):*rdi,*rsi,*rdx,*rcx,*r8,*r9* x1* Arg*8* Arg*7* %rsp Arguments*passed*in*(in* order):*rdi,*rsi,*rdx,*rcx,*r8,*r9* 71* 72*

19 sign*extension!* 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* x4* x3* x2* call_proc: leaq 24(%rsp),%rcx leaq 16(%rsp),%rsi leaq 31(%rsp),%rax movq %rax,8(%rsp) movl $4,(%rsp) leaq 28(%rsp),%r9 movl $3,%r8d movl $2,%edx movq $1,%rdi call proc 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* x4* x3* 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 x1* x1* Arg*8* Arg*7* Arg*8* Arg*7* %rsp Return*address*to*line*awer*call*to*proc* %rsp 73* 74* 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* SomeAmes&none& When&needed,&allocate/deallocate&enAre&frame&at&once& No&more&frame&pointer:&address&relaAve&to&stack&pointer& More*room*for*compiler*opJmizaJons* Prefer&to&store&data&in&registers&rather&than&memory& Minimize&modificaAons&to&stack&pointer& 75* 76*