Machine-Level Representation of Programs III

1. Machine-Level Representation of Programs III

2. Outline • Jump instructions • Translate Control constructs in C to assembly • goto • branch • loop • Suggested reading • Chap 3.6

3. Control • Two of the most important parts of program execution • Data flow (Accessing and operating data) • Control flow (control the sequence of operations)

4. Control • Sequential execution is default • the instructions are executed in the order they appear in the program • Chang the control flow • Jump instructions

5. Jump Instructions 1 xorl %eax, %eax Set %eax to 0 2 jmp .L1 Goto .L1 3 movl (%eax), %edx Null pointer dereference 4 .L1: 5 popl %edx

6. Unconditional jump • Jumps unconditionally • Direct jump: jmp label • jmp .L • Indirect jump: jmp *Operand • jmp *%eax • jmp *(%eax)

7. Conditional jump • Either jump or continue executing at the next instruction in the code sequence • Depending on some combination of the condition codes • All direct jump

8. Jump Instructions • jle .L2 • .L5: • movl %edx, %eax • sarl $1, %eax • subl %eax, %edx • Leal (%edx, %edx, 2), %edx • testl %edx, %edx • jg .L5 9 .L2: 10 movl %edx, %eax

9. Example for Jump • 8: 7e 0d jle 17<silly+0x17> • a: 89 d0 mov %edx, %eax dest1: 3 c: c1 f8 sar %eax • e: 29 c2 sub %eax, %edx • 10: 8d 14 52 lea (%edx, %edx, 2), %edx 6 13: 85 d2 test %edx, %edx • 15: 7f f3 jg a<silly+0x10> • 17: 89 d0 movl %edx, %eax dest2: d+a = 17 17+f3(-d) =a

10. Example for Jump • 804839: 7e 0d jle 17<silly+0x17> • 804839e: 89 d0 mov %edx, %eax dest1: 3 80483a0: c1 f8 sar %eax • 80483a2: 29 c2 sub %eax, %edx • 80483a4: 8d 14 52 lea (%edx, %edx, 2), %edx 6 80483a7: 85 d2 test %edx, %edx • 80483a9: 7f f3 jg a<silly+0x10> • 80483ab: 89 d0 movl %edx, %eax dest2: d+804849e = 80483ab 80483ab+f3(-d) = 804839e

11. Jump Instructions • PC-relative • Jump target is an offset relative to the address of the instruction just followed jump (pointed by PC) • Absolute address • Jump target is an absolute address

12. Control Constructs in C • Gotos • goto L • break • continue • Branch • if () { } else { } • switch () { }

13. Control Constructs in C • Loop • while () { } • do { } while () • for (init; test; incr) { }

14. Translating Conditional Branches t = test-expr ; if ( t ) goto true ; else-statement goto done true: then-statement done: if ( test-expr ) then-statement else else-statement

15. int absdiff(int x, int y) • { • if (x < y) • return y – x; • else • return x – y; • } • int absdiff(int x, int y) • { • int rval ; • if (x < y) • goto less • rval = x – y ; • goto done; • less: • rval = y – x; • done: • return rval; • } Translating Conditional Branches

16. Jump Instructions • movl 8(%ebp), %edx get x • movl 12(%ebp), %eax get y • cmpl %eax, %edx cal x - y • jl .L3 if x < y goto less • subl %eax, %edx compute x - y • movl %edx, %eax set return val • jmp .L5 goto done • .L3: less: • subl %edx, %eax compute y – x • .L5: done: Begin Completion code

17. Do-while Translation do body-statement while (test-expr) loop: body-statement t = test-expr; if ( t ) goto loop ;

18. Do-while Translation .L6: lea (%ebx, %edx), %eax movl %edx, %ebx movl %eax, %edx incl %ecx cmpl %esi, %ecx jl .L6 movl %ebx, %eax int fib_dw(int n) { int i = 0; int val = 0 ; int nval = 1 ; do { int t = val + nval ; val = nval ; nval = t ; i++; } while ( i<n) ; return val ; }

19. While Loop Translation while (test-expr) body-statement loop: if ( !test-expr) t = test-expr goto done; if ( !t ) do goto done; body-statement body-statement while(test-expr) goto loop; done: done:

20. While Loop Translation int fib_w_goto(int n) { int val=1; int nval=1; int nmi, t ; if ( val >= n ) goto done ; nmi = n-1; loop: t=val+nval ; val = nval ; nval = t ; nmi--; if ( nmi ) goto loop done: return val } int fib_w(int n) { int i=1; int val=1; int nval=1; while ( i<n ) { int t=val+nval ; val = nval ; nval = t ; i++; } return val ; }

21. Register usage Register Variable Initially %edx nmi n-1 %ebx val 1 %ecx nval 1 While Loop Translation • movl 8(%ebp), %eax • movl $1, %ebx • movl $1, %ecx • cmpl %eax, ebx • jge .L9 • lea –1(%eax), %edx • .L10: • lea (%ecx, %ebx), %eax • movl %ecx, %ebx • movl %eax, %ecx • decl %edx • jnz .L10 • .L9:

22. While Loop Translation /* strcpy: copy t to s; pointer version 2 */ void strcpy(char *s, char *t){ while ((*s = *t) != '\0') { s++ ; t++ ; } }

23. While Loop Translation L2: movl12(%ebp), %eax movzbl(%eax), %edx movl8(%ebp), %eax movb%dl, (%eax) movl8(%ebp), %eax movzbl(%eax), %eax testb%al, %al jneL3 popl%ebp ret _strcpy: pushl%ebp movl%esp, %ebp jmpL2 L3: addl$1, 8(%ebp) addl$1, 12(%ebp)

24. For Loop Translation for ( init-expr; test-expr; update-expr) body-statement init-expr while ( test-expr) { body-statement update-expr }

25. For Loop Translation /* strcmp: return <0 if s<t, 0 if s==t, >0 if s>t */ int strcmp(char *s, char *t) { for (; *s == *t ; s++, t++) if (*s == '\0') return 0; return *s - *t; }

26. For Loop Translation _strcmp: pushl%ebp movl%esp, %ebp subl$4, %esp jmpL2 L5: movl8(%ebp), %eax movzbl(%eax), %eax testb%al, %al jneL3 movl$0, -4(%ebp) jmpL4 L3: addl$1, 8(%ebp) addl$1, 12(%ebp) L2: movl8(%ebp), %eax movzbl(%eax), %edx movl12(%ebp), %eax movzbl(%eax), %eax cmpb%al, %dl jeL5

27. For Loop Translation movl8(%ebp), %eax movzbl(%eax), %eax movsbl%al,%edx movl12(%ebp), %eax movzbl(%eax), %eax movsbl%al,%eax movl%edx, %ecx subl%eax, %ecx movl%ecx, -4(%ebp) L4: movl-4(%ebp), %eax leave ret

28. Switch Statements int switch_eg(int x, int n) { int result = x ; switch ( n ) { case 100: result *= 13 ; break ; case 102: result += 10 ; /* fall through */ case 103 result += 11; break ; case 104: case 106: result *= result ; break ; default: result = 0 ; } return result ; }

29. Switch Construct • Properties of Switch Construct • Integer testing • Multiple outcomes (may be a large number) • Improve the readability of the source code

30. Switch Statements int switch_eg(int x, int n) { int result = x ; switch ( n ) { case 100: result *= 13 ; break ; case 102: result += 10 ; /* fall through */ case 103 result += 11; break ; case 104: case 106: result *= result ; break ; default: result = 0 ; } return result ; } Multiple cases Integer testing

31. Switch Form switch(op) { case val_0: Block 0 case val_1: Block 1 • • • case val_n-1: Block n–1 }

32. Jump Table • Efficient implementation • Avoid long sequence of if-else statement • Criteria • the number of cases and the sparcity of the case value

33. Targ0: Code Block 0 jtab: Targ0 Targ1 Targ2 Targ1: Code Block 1 • • • Targn-1 Targ2: Code Block 2 • • • Targn-1: Code Block n–1 Jump Table Implementation Jump Table Jump Targets Approx. Translation target = JTab[op]; goto *target;

34. Switch Statements int switch_eg(int x, int n) { int result = x ; switch ( n ) { case 100: result *= 13 ; break ; case 102: result += 10 ; /* fall through */ case 103 result += 11; break ; case 104: case 106: result *= result ; break ; default: result = 0 ; } return result ; }

35. Jump Table Implementation code jt[7] = {loc_a, loc_def, loc_b, loc_c, loc_d, loc_def, loc_d}; int switch_eg_goto ( int x, int n) { unsigned ni = n-100; int result = x ; if ( ni >6 ) goto loc_def ; //default goto jt[xi]; loc_a: //100 result *= 13 ; goto done ; loc_b: //102 result += 10 ; /* fall through*/ loc_c: //103 result +=11; goto done ; loc_d: //104, 106 result *= result ; goto done ; loc_def: //default result = 0 ; done: return result ; }

36. Jump Table • .section .rodata • .align 4 • .L7: • .long .L3 case 100: loc_a • .long .L2 case 101: loc_def • .long .L4 case 102: loc_b • .long .L5 case 103: loc_c • .long .L6 case 104: loc_d • .long .L2 case 105: loc_def • .long .L6 case 106: loc_d

37. Jump Table Implementation • movl 8(%ebp), %edx get x • movl 12(%ebp), %eax get n • subl $100, %eax compute index = n – 100 • cmpl $6, %eax compare index:6 • ja .L2 If > , goto default • jmp *.L7(, %eax, 4) • .L2: default: • mov $0, %eax result = 0 • jmp .L8 goto done

38. Jump Table Implementation • .L5: loc_c: // 103 • movl %edx, %eax result = x • jmp .L9 goto rest • .L3: loc_a: // 100 • leal (%edx, %edx, 2), %eax result = x * 3 • leal (%edx, %eax, 4), %eax result = x + 4 * result • jmp .L8 goto done • .L4: loc_b: // 102 • leal 10(%edx), %eax result = x + 10

39. Jump Table Implementation • .L9: rest: // fall through • addl $11, %eax result += 11 • jmp .L8 goto done • .L6: loc_d: // 104, 106 • movl %edx, %eax result = x • imull %edx, %eax result *= x • .L8: done: