Compiling C Programs Into X86-64 Assembly Programs

Transcription

1 CSE 2421: Systems I Low-Level Programming and Computer Organization Compiling C Programs Into X86-64 Assembly Programs Part B: If Else, Loops, Recursion & Switch Presentation L Read/Study: Bryant 3.6 Gojko Babić General if- Branching Translation Code with if block if (Test) Statement 1a ; Statement 2a ; Statement na ; Statement 1b ; Statement 2b ; Statement nb ; Statement next ; Goto Version ntest =!Test; if (ntest) goto Else; Statement 1a ; Statement 2a ; Statement na ; goto Done; Else: Statement 1b ; Statement 2b ; Statement nb ; Done: Statement Next ; Presentation L 2 1

2 if- Branching: Example A Code with if block long GenBranch(long x, long y, long z) if (x > y) x = x+y; z = z+y; x = x-y; z = z-y; urn x+z; Goto Version long GenBranch(long x, long y, long z) int ntest = x <= y; if (ntest) goto Else; x = x+y; z = z+y; goto Done; Else: x = x-y; z = z-y; Done: urn x+z; Both C codes compile into identical assembly code. We shall consider goto version, since it is closer to the assembly code. Presentation L 3 if- Branching: Example A (cont.) long GenBranch(long x, long y, long z) int ntest = x <= y; if (ntest) goto Else; x = x+y; z = z+y; goto Done; Else: x = x-y; z = z-y; Done: urn x+z; Compilation command: gcc -O1 -S GenBranch.c GenBranch: cmpq %rsi, %rdi # x:y jle.l2 leaq (%rsi,%rdi), %rdi leaq (%rdx,%rsi), %rsi jmp.l3.l2: subq %rsi, %rdi subq %rsi, %rdx movq %rdx, %rsi leaq (%rsi,%rdi), %rax Register %rdi %rsi %rdx %rax Use(s) Argument x Argument y Argument z Return value 4 2

3 if- Branching: Example B Code with if block long absdiff (long x, long y) long result; if (x > y) result = x-y; result = y-x; urn result; Goto Version long absdiff (long x, long y) long result; int ntest = x <= y; if (ntest) goto Else; result = x-y; urn result; Else: result = y-x; urn result; Assembly code following C code on the right will include branching. Branches are very disruptive to instruction flow through CPU pipelines, and when possible (as it is in this case) a compiler uses conditional move which doesn t require control transfer. g.babic Presentation L 5 if- Branching: Example B1 long absdiff (long x, long y) Compilation command: gcc -O1 -S absdiff.c long result; if (x > y) result = x-y; Register Use(s) %rdi Argument x result = y-x; %rsi Argument y urn result; %rax Return value absdiff: movq %rdi, %rax # x subq %rsi, %rax # result = x-y movq %rsi, %rdx subq %rdi, %rdx # eval = y-x cmpq %rsi, %rdi # x:y cmovle %rdx, %rax # if <=, result = eval 6 3

4 if- Branching: Example B2 long absdiff (long x, long y) long result; int ntest = x <= y; if (ntest) goto Else; result = x-y; urn result; Else: result = y-x; urn result; Register %rdi %rsi %rax Use(s) Argument x Argument y Return value Compilation command: gcc -O1 -S fno-if-conversion absdiff.c generates this x86-64 assembly code: absdiff: cmpq %rsi, %rdi # x:y jle.l2 movq %rdi, %rax subq %rsi, %rax.l2: # x <= y movq %rsi, %rax subq %rdi, %rax Option fno-if-conversion absdiff.c in compilation command generates this old style code. Presentation L 7 General do-while Loop Translation Carnegie Mellon Do While Version do Statement 1 ; Statement 2 ; Statement n ; while (Test); loop: Goto Version Statement 1 ; Statement 2 ; Statement n ; if (Test) goto loop Test urns integer: if = 0 interped as false if 0 interped as true Presentation L 8 4

5 do-while Loop Example Do While Version long pcount_do(unsigned long x) do result += x & 0x1; x >>= 1; while (x); urn result; Goto Version long pcount_do(unsigned long x) loop: result += x & 0x1; x >>= 1; if (x) goto loop; urn result; Both of these functions count the number of 1 s in the argument x and urn that value and both C codes are compiled into identical assembly code. We shall be examining a code goto version, because it is closer to compiled assembly code. Presentation L 9 long pcount_do(unsigned long x) loop: result += x & 0x1; x >>= 1; if (x) goto loop; urn result; Compiling pcount_do.c Compilation command: gcc -O1 -S pcount_do.c generates this x86-64 assembly code (with minor changes in red) Register %rdi %rax Use(s) Argument x result pcount_do:.l2: movq %rdi, %rdx andq $1, %rdx addq %rdx, %rax jne.l2 # if (%rdi) goto loop:, i.e. to.l2: rep # rep = noop; See Brayant page

6 General while Loop Translation Carnegie Mellon While Version while (Test) Statement 1 ; Statement 2 ; Statement n ; Do While Version if (!Test) goto done; do Statement 1 ; Statement 2 ; Statement n ; while (Test); done: Goto Version if (!Test) goto done; loop: Statement 1 ; Statement 2 ; Statement n ; if(test) goto loop done: Presentation L 11 While version long pcount_while(unsigned long x) while (x) result += x & 0x1; x >>= 1; urn result; Goto Version long pcount_while(unsigned long x) if (!x) goto done; loop: result += x & 0x1; x >>= 1; if (x) goto loop; done: urn result; This code must jump to skip the loop if the initial test fails Both C codes above compile into identical assembly codes and we shall be examining a code goto version, because it is closer to compiled assembly code. while Loop Example Presentation L 12 6

7 Compiling pcount_while.c long pcount_while(unsigned long x) if (!x) goto done; loop: result += x & 0x1; x >>= 1; if (x) goto loop; done: urn result; Compilation command: gcc -O1 -S pcount_while.c generates this x86-64 assembly code (with minor changes in red): pcount_while: testq %rdi, %rdi.l6: movq %rdi, %rdx andq $1, %rdx addq %rdx, %rax jne.l6 rep Register %rdi %rax Use(s) Argument x result Presentation L 13 for Loop Version for (Init; Test; Update) Body Init; while (Test) Body Update; for Loop Version Goto Version while Loop Version do-while Loop Version if (!Test) goto done; Init; do Body Update while(test); done: Goto Version if (!Test) goto done; Init; loop: Body Update if (Test) goto loop; done: 14 7

8 For Loop Example long pcount_for(unsigned long x) long i; for (i = 0; i < 64; i++) result += (x & 0x1); x >>=1; urn result; Init i = 0 Test i < 64 Update i++ Body result += (x & 0x1); x >>=1; Presentation L 15 long pcount_for(unsigned long x) long i; for (i = 0; i < 64; i++) result += (x & 0x1); x >>=1; urn result; Compilation command: gcc -O1 S pcount_for.c generated this x86-64 assembly Compiling pcount_for.c code (with minor changes in red) Presentation L pcount_for: movq $0, %rdx.l2: movq %rdi, %rcx andq $1, %rcx addq %rcx, %rax addq $1, %rdx cmpq $64, %rdx jne.l2 rep Note: Code above doesn t have test at the beginning, because the compiler figures out it is not necessary. 16 8

9 Compiling pcount_forn33.c int pcount_forn33(unsigned long x) long i,n; N=33; for (i = N; i < 32; i++) result += (x & 0x1); x >>=1; urn result; pcount_forn33: Assembly code is simple since the compiler figures out that urn value is always 0. Compilation command: gcc -O1 S pcount_forn33.c Presentation L 17 Recursive Function /* Recursive popcount */ long pcount_r(unsigned long x) if (x == 0) urn 0; urn (x & 1) + pcount_r(x >> 1); Compilation command: gcc -O1 S pcount_r.c generates this x86-64 assembly code (with minor changes in red) In the following slides, slightly changed code is analyzed; only 3 blue instructions will be moved to make the code more understandable. pcount_r: pushq %rbx movq %rdi, %rbx testq %rdi, %rdi #shift 1 call pcount_r andq $1, %rbx addq %rbx, %rax popq %rbx Presentation L 18 9

10 Recursive Function Terminal Case /* Recursive popcount */ long pcount_r(unsigned long x) if (x == 0) urn 0; urn (x & 1) + pcount_r(x >> 1); Register Use(s) Type %rdi x Argument %rax Return value Return value pcount_r: testq %rdi, %rdi pushq %rbx movq %rdi, %rbx andq $1, %rbx call pcount_r addq %rbx, %rax popq %rbx Presentation L 19 Recursive Function Register Save /* Recursive popcount */ long pcount_r(unsigned long x) if (x == 0) urn 0; urn (x & 1) + pcount_r(x >> 1); Register Use(s) Type %rdi x Argument... Rtn address Saved %rbx %rsp pcount_r: testq %rdi, %rdi pushq %rbx movq %rdi, %rbx andq $1, %rbx call pcount_r addq %rbx, %rax popq %rbx Note that register %rbx has to be urned from called function unchanged. Presentation L 20 10

11 Recursive Function Call Setup /* Recursive popcount */ long pcount_r(unsigned long x) if (x == 0) urn 0; urn (x & 1) + pcount_r(x >> 1); Register Use(s) Type %rdi x >> 1 Rec. argument %rbx x & 1 Callee-saved pcount_r: testq %rdi, %rdi pushq %rbx movq %rdi, %rbx andq $1, %rbx call pcount_r addq %rbx, %rax popq %rbx Presentation L 21 Recursive Function Call /* Recursive popcount */ long pcount_r(unsigned long x) if (x == 0) urn 0; urn (x & 1) + pcount_r(x >> 1); Register Use(s) Type %rbx x & 1 Callee-saved %rax Recursive call urn value pcount_r: testq %rdi, %rdi pushq %rbx movq %rdi, %rbx andq $1, %rbx call pcount_r addq %rbx, %rax popq %rbx Presentation L 22 11

12 Recursive Function Result /* Recursive popcount */ long pcount_r(unsigned long x) if (x == 0) urn 0; urn (x & 1) + pcount_r(x >> 1); Register Use(s) Type %rbx x & 1 Callee-saved %rax Return value pcount_r: testq %rdi, %rdi pushq %rbx movq %rdi, %rbx andq $1, %rbx call pcount_r addq %rbx, %rax popq %rbx Presentation L 23 Recursive Function Completion /* Recursive popcount */ long pcount_r(unsigned long x) if (x == 0) urn 0; urn (x & 1) + pcount_r(x >> 1); Register Use(s) Type %rax Return value Return value pcount_r: testq %rdi, %rdi pushq %rbx movq %rdi, %rbx andq $1, %rbx call pcount_r addq %rbx, %rax popq %rbx... %rsp Presentation L 24 12

13 Switch Statement switch(x) case val_0: Block 0 case val_1: Block 1 case val_n-1: Block n 1 default: Block n Jump Table JTab: Targ Targ Targ Targ Switch statements will be decomposed into blocks and jump table; Blocks 0, 1,, n will be accessed through Jump Presentation L table Targ 0 : Targ 1 : Targ 2 : Targ n-1 : Targ n : Jump Targets Code Block 0 Code Block 1 Code Block 2 Code Block n 1 Code Block n 25 Switch Statement Example long switch_eg (long x, long y, long z) long w = 1; switch(x) case 1: w = y*z; break; case 2: w = y/z; case 3: w += z; break; case 5: case 6: w -= z; break; default: w = 2; urn w; In this example, we have all possible cases with case labels: multiple case labels: 5 &6 fall through case: 2 missing case: 4 default Compilation command: gcc -O1 -S switch_eg.c generated x86-64 assembly code on the following slide: Presentation L 26 13

14 Compiling switch_eg.c.text switch_eg: movq %rdx, %rcx cmpq $6, %rdi ja.l2 jmp *.L7(,%rdi,8).section.rodata.align 8.L7:.quad.L2.quad.L3.quad.L4.quad.L5.quad.L2.quad.L6.quad.L6.text: code section.rodata = read only data.text.l2: movq $2, %rax.l5: movq $1, %rax jmp.l9 movq %rdx, %rax imulq %rsi, %rax.l4: movq %rsi, %rdx movq %rsi, %rax sarq $63, %rdx idivq %rcx.l9: addq %rcx, %rax.l6: movq $1, %rax subq %rdx, %rax 27 Switch Statement Setup long switch_eg (long x, long y, long z) long w = 1; switch(x)... default: w = 2; urn w; switch_eg: movq cmpq %rdx, %rcx $6, %rdi ja.l2 #if >6, default jmp *.L7(,%rdi,8) Indirect jump: jmp *.L7(,%rdi,8) fetch jump target from effective address.l7 + %rdi*8 Register Use(s) %rdi Argument x %rsi Argument y %rdx Argument z %rax Return value Jump Table.section.rodata.align 8.L7:.quad.L2 #x = 0.quad.L3 #x = 1.quad.L4 #x = 2.quad.L5 #x = 3.quad.L2 #x = 4.quad.L6 #x = 5.quad.L6 #x =

15 Example Jump Table Jump table.section.rodata.align 8.L7:.quad.L2 #x = 0.quad.L3 #x = 1.quad.L4 #x = 2.quad.L5 #x = 3.quad.L2 #x = 4.quad.L6 #x = 5.quad.L6 #x = 6.text.L2: movq $2, %rax.l5: movq $1, %rax jmp.l9 movq %rdx, %rax imulq %rsi, %rax.l4: movq %rsi, %rdx movq %rsi, %rax sarq $63, %rdx idivq %rcx.l9: addq %rcx, %rax.l6: movq $1, %rax subq %rdx, %rax 29 Sparse Switch Statement Example long switch_sp (long x, long y, long z) int w = 1; switch(x) case 100: w = y*z; break; case 200: w = y/z; case 300: w += z; break; case 400: case 500: w -= z; break; default: w = 2; urn w; Presentation L The example is almost identical to the previous switch example. Except in this example, we have case labels far apart from each other, and jump table would be very large. Compilation command: gcc -O1 -S switch_sp.c generated IA-32 assembly code on the following slide: 30 15

16 Compiling switch_sp.c switch_sp: movq %rdx, %rcx cmpq $300, %rdi je.l5 cmpq $300, %rdi jg.l7 cmpq $100, %rdi cmpq $200, %rdi jne.l2 jmp.l11.l7: cmpq $400, %rdi je.l6 cmpq $500, %rdi je.l6.l2: movq $2, %rax.l5: movq $1, %rax jmp.l9 movq %rdx, %rax imulq %rsi, %rax.l11: movq %rsi, %rdx movq %rsi, %rax sarq $63, %rdx idivq %rcx.l9: addq %rcx, %rax.l6: movq $1, %rax subq %rcx, %rax 31 16