CS241 Computer Organization Spring Loops & Arrays

Size: px

Start display at page:

Download "CS241 Computer Organization Spring Loops & Arrays"

Solomon Ross
5 years ago
Views:

1 CS241 Computer Organization Spring 2015 Loops & Arrays

2 Outline! Loops C loops: while, for, do-while Translation to jump to middle! Arrays Read: CS:APP2 Chapter 3, sections IA32 Overview (available in Online References) HW#4 due Tuesday, Mar. 3 (work on in class today) note: add %esi and %edi to the register usage table misprint: line 9 should read move %ebx, %ecx (not %ex) not all variables have memory addresses not all registers are always used Lab#2 Bomblab

3 Conditionals absval: # setup omitted int absval(int x) int result; if (x >=0) result = x; else result = -x; return result;.l2:.l4: then else cmpl $0, 8(%ebp) js.l2 # jump if x < 0 movl 8(%ebp), %eax movl %eax, -4(%ebp) jmp.l4 # uncond jump movl 8(%ebp), %eax negl %eax movl %eax, -4(%ebp) movl -4(%ebp), %eax leave ret

4 Conditional Branch Example int absdiff(int x, int y) int result; if (x > y) result = x-y; else result = y-x; return result; absdiff: pushl %ebp movl %esp, %ebp movl 8(%ebp), %edx movl 12(%ebp), %eax cmpl %eax, %edx jle.l7 subl %eax, %edx movl %edx, %eax.l8: leave ret.l7: subl %edx, %eax jmp.l8 Setup Body1 Finish Body2

5 Conditional Branch Example (Cont.) int goto_ad(int x, int y) int result; if (x <= y) goto Else; result = x-y; Exit: return result; Else: result = y-x; goto Exit; absdiff: pushl %ebp movl %esp, %ebp movl 8(%ebp), %edx movl 12(%ebp), %eax cmpl %eax, %edx jle.l7 subl %eax, %edx movl %edx, %eax.l8: leave ret.l7: subl %edx, %eax jmp.l8

6 Reverse Engineering: if-then int cond(int a, int b) argument a b address (relative to FP) FP + 8 FP + 12 result

7 1 movl 8(%ebp), %eax #. 2 cmpl 12(%ebp), %eax #. 3 jl.l2 #. 4 movl 8(%ebp), %eax #. 5 movl %eax, -4(%ebp) #. 6 jmp.l3 #. 7.L2 8 movl 12(%ebp), %eax #. 9 movl %eax, -4(%ebp) #. 10.L3 %eax = a cmp a : b if a < b goto L2 %eax = a result = a goto L3 %eax = b result = b return result 11 movl -4(%ebp), %eax #. int cond (int a, int b) int result; if (. ) else a >= b result = a result = b return result; ; ;

8 Reverse Engineering int cond(int a, int b) argument a b result address (relative to FP) FP + 8 FP + 12 FP - 4

9 Loops in C! while-do loop while (<boolean expr>) <body>; pre-test, executes <body> zero or more times terminates when boolean expression is false (0)! do-while loop do <body>; while (<boolean expr>); post-test, executes <body> one or more times cf. K&R, Chapter 3 terminates when boolean expression is false (0)! for loop for (<expr1>; <expr2>; <expr3> ) <body>

10 For loop == while for (<expr1>; <expr2>; <expr3> ) <body> is equivalent to: <expr1>; while (<expr2>) <body> <expr3>; example: for (i = 0; i < N; i++) sum = sum + i; is equivalent to: i = 0; while (i < N) sum = sum + i; i++;

11 While loop int summit1(int n) int sum = 0; while (n > 0) sum = sum + n; n = n - 1; return sum; summit1: # setup omitted movl $0, -4(%ebp) jmp.l2.l3: movl 8(%ebp), %eax addl %eax, -4(%ebp) subl $1, 8(%ebp).L2: cmpl $0, 8(%ebp) jg.l3 movl -4(%ebp), %eax leave ret

12 For loop int summit2(int n) int sum = 0; int i; for (i = 1; i <= n; i++) sum = sum + i; return sum; summit2: # setup omitted movl $0, -8(%ebp) movl $1, -4(%ebp) jmp.l2.l3: movl -4(%ebp), %eax addl %eax, -8(%ebp) addl $1, -4(%ebp).L2: movl -4(%ebp), %eax cmpl 8(%ebp), %eax jle.l3 movl -8(%ebp), %eax leave ret

13 Do-While Loop Example C Code int fact_do(int x) int result = 1; do result *= x; x = x-1; while (x > 1); return result; Goto Version int fact_goto(int x) int result = 1; loop: result *= x; x = x-1; if (x > 1) goto loop; return result; Use backward branch to continue looping Only take branch when while condition holds

14 Do-While Loop Compilation Goto Version int fact_goto(int x) int result = 1; Assembly Registers: %edx %eax fact_goto: pushl %ebp # Setup movl %esp,%ebp # Setup movl $1,%eax # eax = 1 movl 8(%ebp),%edx # edx = x x result loop: result *= x; x = x-1; if (x > 1) goto loop;.l11: imull %edx,%eax # result *= x decl %edx # x-- Annotate cmpl $1,%edx # Compare x : 1 jg.l11 # if > goto loop return result; movl %ebp,%esp popl %ebp ret # Finish # Finish # Finish

15 Do-While Loop Compilation Goto Version int fact_goto(int x) int result = 1; Assembly Registers: %edx %eax fact_goto: pushl %ebp # Setup movl %esp,%ebp # Setup movl $1,%eax # eax = 1 movl 8(%ebp),%edx # edx = x x result loop: result *= x; x = x-1; if (x > 1) goto loop;.l11: imull %edx,%eax # result *= x decl %edx # x-- cmpl $1,%edx # Compare x : 1 jg.l11 # if > goto loop return result; movl %ebp,%esp popl %ebp ret # Finish # Finish # Finish

16 General Do-While Translation C Code do Body while (Test); Goto Version loop: Body if (Test) goto loop Body: Statement 1 ; Statement 2 ; Statement n ; Test returns integer = 0 interpreted as false 0 interpreted as true

17 While Loop Example C Code int fact_while(int x) int result = 1; while (x > 1) result *= x; x = x-1; ; return result; Goto Version #1 int fact_while_goto(int x) int result = 1; loop: if (!(x > 1)) goto done; result *= x; x = x-1; goto loop; done: return result; Is this code equivalent to the do-while version? Must jump out of loop if test fails

18 Alternative While Loop Translation C Code int fact_while(int x) int result = 1; while (x > 1) result *= x; x = x-1; ; return result; Historically used by GCC Uses same inner loop as dowhile version Guards loop entry with extra test Goto Version #2 int fact_while_goto2(int x) int result = 1; if (!(x > 1)) goto done; loop: result *= x; x = x-1; if (x > 1) goto loop; done: return result;

19 General While Translation While version while (Test) Body Do-While Version if (!Test) goto done; do Body while(test); done: Goto Version if (!Test) goto done; loop: Body if (Test) goto loop; done:

20 New Style While Loop Translation C Code int fact_while(int x) int result = 1; while (x > 1) result *= x; x = x-1; ; return result; Recent technique for GCC Both IA32 & x86-64 First iteration jumps over body computation within loop Goto Version int fact_while_goto3(int x) int result = 1; goto middle; loop: result *= x; x = x-1; middle: if (x > 1) goto loop; return result;

21 Jump-to-Middle While Translation C Code while (Test) Body Goto Version goto middle; loop: Body middle: if (Test) goto loop; Avoids duplicating test code Unconditional goto incurs no performance penalty for loops compiled in similar fashion Goto (Previous) Version if (!Test) goto done; loop: Body if (Test) goto loop; done:

22 Jump-to-Middle Example int fact_while(int x) int result = 1; while (x > 1) result *= x; x--; ; return result; # x in %edx, result in %eax jmp.l34 # goto Middle.L35: # Loop: imull %edx, %eax # result *= x decl %edx # x--.l34: # Middle: cmpl $1, %edx # x:1 jg.l35 # if >, goto Loop

23 Implementing Loops IA32 All loops translated into form based on do-while x86-64 Also make use of jump to middle Why the difference IA32 compiler developed for machine where all operations costly x86-64 compiler developed for machine where unconditional branches incur (almost) no overhead

24 Summary! Do-While loop C Code do Body while (Test); Goto Version loop: Body if (Test) goto loop! While-Do loop While version while (Test) Body Do-While Version if (!Test) goto done; do Body while(test); done: Goto Version if (!Test) goto done; loop: Body if (Test) goto loop; done: or goto middle; loop: Body middle: if (Test) goto loop;

25 For-Loop: Compilation #2 For Version for (Init; Test; Update ) Body for (result = 1; p!= 0; p = p>>1) if (p & 0x1) result *= x; x = x*x; Goto Version Init; goto middle; loop: Body Update ; middle: if (Test) goto loop; done: result = 1; goto middle; loop: if (p & 0x1) result *= x; x = x*x; p = p >> 1; middle: if (p!= 0) goto loop; done:

Arrays Arrays (one dimensional) int val[5]; 1 5 2 1 3 x x + 4 x + 8 x + 12 x

26 Arrays Arrays (one dimensional) int val[5]; x x + 4 x + 8 x + 12 x + 16 x + 20 Nested (multi-dimensional) int pgh[4][5]; Multi-level int *univ[3]

27 Basic Data Types Integral Stored & operated on in general (integer) registers Signed vs. unsigned depends on instructions used Intel GAS Bytes C byte b 1 [unsigned] char word w 2 [unsigned] short double word l 4 [unsigned] int quad word q 8 [unsigned] long int (x86-64) Floating Point Stored & operated on in floating point registers Intel GAS Bytes C Single s 4 float Double l 8 double Extended t 10/12/16 long double

28 Array Allocation Basic Principle T A[L]; Array of data type T and length L Contiguously allocated region of L * sizeof(t) bytes char string[12]; int val[5]; double a[3]; char *p[3]; x x + 12 x x + 4 x + 8 x + 12 x + 16 x + 20 x x + 8 x + 16 IA32 x x + 4 x + 8 x + 12 x + 24 x86-64 x x + 8 x + 16 x + 24

29 Array Access Basic Principle T A[L]; Array of data type T and length L Identifier A can be used as a pointer to array element 0: Type T* int val[5]; Value val[4] int 3 Reference Type val int * x val+1 int * x + 4 &val[2] int * x + 8 val[5] int?? *(val+1) int 5 x x + 4 x + 8 x + 12 x + 16 x + 20 val + i int * x + 4 i

30 Array Example typedef int zip_dig[5]; zip_dig cmu = 1, 5, 2, 1, 3 ; zip_dig mit = 0, 2, 1, 3, 9 ; zip_dig cu = 1, 3, 6, 9, 9 ; zip_dig cmu; zip_dig mit; zip_dig cu; Declaration zip_dig cmu equivalent to int cmu[5] Example arrays were allocated in successive 20 byte blocks Not guaranteed to happen in general

31 Array Accessing Example zip_dig cmu; int get_digit (zip_dig z, int dig) return z[dig]; IA32 # %edx = z # %eax = dig movl (%edx,%eax,4),%eax # z[dig] Register %edx contains starting address of array Register %eax contains array index Desired digit at 4*%eax + %edx Use memory reference (%edx,%eax,4)

32 Referencing Examples zip_dig cmu; zip_dig mit; zip_dig cu; Reference Address Value Guaranteed? mit[3] * 3 = 48 3 mit[5] * 5 = 56 9 mit[-1] *-1 Blackboard = 32 3 cmu[15] *15 = 76??

Referencing Examples zip_dig cmu; 1 5 2 1 3 16 20 24 28 32 36 zip_dig mit; 0 2 1 3 9 36 40 44 48 52 56 zip_dig cu; 1 3 6 9 9 56 60 64 68 72 76 Reference Address Value Guaranteed?

33 Referencing Examples zip_dig cmu; zip_dig mit; zip_dig cu; Reference Address Value Guaranteed? mit[3] * 3 = 48 3 mit[5] * 5 = 56 1 mit[-1] *-1 = 32 3 cmu[15] *15 = 76?? Yes No No No No bound checking Out of range behavior implementation-dependent No guaranteed relative allocation of different arrays

34 Array Loop Example Original Transformed As generated by GCC Eliminate loop variable i Convert array code to pointer code Express in do-while form (no test at entrance) int zd2int(zip_dig z) int i; int zi = 0; for (i = 0; i < 5; i++) zi = 10 * zi + z[i]; return zi; int zd2int(zip_dig z) int zi = 0; int *zend = z + 4; do zi = 10 * zi + *z; z++; while (z <= zend); return zi;

35 Array Loop Implementation (IA32) int zd2int(zip_dig z) int zi = 0; int *zend = z + 4; do zi = 10 * zi + *z; z++; while(z <= zend); return zi; # %ecx = z xorl %eax,%eax # zi = 0 leal 16(%ecx),%ebx # zend = z+4.l59: leal (%eax,%eax,4),%edx # 5*zi movl (%ecx),%eax # *z Whiteboard addl $4,%ecx # z++ leal (%eax,%edx,2),%eax # zi = *z + 2*(5*zi) cmpl %ebx,%ecx # z : zend jle.l59 # if <= goto loop

36 Array Loop Implementation (IA32) Registers %ecx %eax %ebx z zi zend Computations 10*zi + *z implemented as *z + 2*(zi+4*zi) z++ increments by 4 int zd2int(zip_dig z) int zi = 0; int *zend = z + 4; do zi = 10 * zi + *z; z++; while(z <= zend); return zi; # %ecx = z xorl %eax,%eax # zi = 0 leal 16(%ecx),%ebx # zend = z+4.l59: leal (%eax,%eax,4),%edx # 5*zi movl (%ecx),%eax # *z addl $4,%ecx # z++ leal (%eax,%edx,2),%eax # zi = *z + 2*(5*zi) cmpl %ebx,%ecx # z : zend jle.l59 # if <= goto loop

Homework 0: Given: k-bit exponent, n-bit fraction Find: Exponent E, Significand M, Fraction f, Value V, Bit representation

$Homework 0: Given: k-bit exponent, n-bit fraction Find: Exponent E, Significand M, Fraction f, Value V, Bit representation$ Homework 0: 2.84 Given: k-bit exponent, n-bit fraction Find: Exponent E, Significand M, Fraction f, Value V, Bit representation Homework 0: 2.84 Given: k-bit exponent, n-bit fraction 7.0: 0111 = 1.11 2