1 / 39

Machine-Level Representation of Programs III

Machine-Level Representation of Programs III. Outline. Jump instructions Translate Control constructs in C to assembly goto branch loop Suggested reading Chap 3.6. Control. Two of the most important parts of program execution Data flow (Accessing and operating data)

reyna
Download Presentation

Machine-Level Representation of Programs III

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  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:

More Related