mith College Computer Science CSC231 Assembly Week #12 Thanksgiving 2017 Dominique Thiébaut

Transcription

1 mith College Computer Science CSC231 Assembly Week #12 Thanksgiving 2017 Dominique Thiébaut

2 ;;; FUNCTION SIDE function: ebp ;save old ebp ebp, esp ;make ebp point ;to stack frame Summary dword[ebp+8] ;access paramn dword[ebp+12];access paramn-1 ;restore ebp N ;return and pop ;4N bytes from stack ;;; CALLER SIDE param1 param2 paramn function

3 Summary ;;; FUNCTION SIDE function: ebp ;save old ebp ebp, esp ;make ebp point ;to stack frame -registers-you-will-use (clean function) dword[ebp+8] ;access param1 dword[ebp+12];access param2 ;;; CALLER SIDE pop-register-you-used ;restore ebp N ;return and pop ;4N bytes from stack param1 param2 paramn function

4 Useful Instructions for Functions ad popad ; EAX, ECX, EDX, ;EBX, original ESP, ; EBP, ESI, and EDI. ;pop them back in ;reverse order

5 ;;; ; ;;; ; _printstring: prints a string whose address is in ;;; ; ecx, and whose total number of chars ;;; ; is in edx. ;;; ; Examples: ;;; ; Assume a string labeled msg, containing "Hello World!", ;;; ; and a constant MSGLEN equal to 12. To print this string: ;;; ; ;;; ; ecx, msg ;;; ; edx, MSGLEN ;;; ; _printstring ;;; ; ;;; ; REGISTERS MODIFIED: NONE ;;; ; ;;; ;save and ebx so that they are not modified by the function Example 1 _printstring: int pop pop ret ebx,sys_write ebx,stdout 0x80 ebx

6 ;;; ; ;;; ; ;;; ; getinput: gets a numerical input from the keyboard. ;;; ; returns the resulting number in (32 bits). ;;; ; recognizes - as the first character of ;;; ; negative numbers. Does not skip whitespace ;;; ; at the beginning. Stops on first not decimal ;;; ; character encountered. ;;; ; ;;; ; NO REGISTERS MODIFIED, except ;;; ; ;;; ; Example of : ;;; ; ;;; ; getinput ;;; ; dword[x], ; put integer in x ;;; ; ;;; ; ;;; ; _getinput: section.bss buffer resb 120 intg resd 1 isneg resb 1 Example 2 ad ; save all registers.loop1: esi, buffer ; eci --> buffer edi, 0 ; edi = counter of chars, 03 ; input ebx, 0 ; stdin ecx, esi ; where to put the next char ; cut for the sake of simplicity. Look in 231Lib.asm for more info!

7 Dot-Labels ;;; ; ;;; ; printline: esi, buffer ; esi --> buffer edi, 0 ; edi = counter of chars.loop1:, 03 ; input ebx, 0 ; stdin ecx, esi ; where to put the next char loop.loop1.for1:.for2:... ret ;;; ; ;;; ; printreg: esi, buffer edi, 0.for1:.for2: ret

8 Dot-Labels ;;; ; ;;; ; printline: esi, buffer ; esi --> buffer edi, 0 ; edi = counter of chars.loop1:, 03 ; input ebx, 0 ; stdin ecx, esi ; where to put the next char loop.loop1.for1:.for2:... ret ;;; ; ;;; ; printreg: esi, buffer edi, 0.for1: printline.for2:.for2: ret printreg.for2:

9 Exercise Write a function that copies an array of N bytes into another array of N bytes. The function receives three parameters: the address of the first array, the address of the second array, and the number of bytes. void copyarrays( table1, table2, N );

10 Passing through registers Passing through the stack Passing by Value Passing by Reference

11 Rule for Writing Functions: Pushing and popping operations into/from the stack must always cancel each other out! ( a + 3 ( b^2 + ( c+1) ^(d-1) ) ) Same as with parentheses

12 # example.py from future import print_function def ( array ): for i in range( len( array ) ): array[ i ] += 1 Table = [1, 2, 3, 4] print( str( Table ) ) ( Table ) print( str( Table ) ) An Example : ebp ebp, esp ebx ecx ecx, 4 ebx, dword[ebp+8], Table

13 # example.py from future import print_function def ( array ): for i in range( len( array ) ): array[ i ] += 1 Table = [1, 2, 3, 4] print( str( Table ) ) ( Table ) print( str( Table ) ) An Example : ebp ebp, esp ebx ecx ecx, 4 ebx, dword[ebp+8], Table

14 # example.py from future import print_function def ( array ): for i in range( len( array ) ): array[ i ] += 1 Table = [1, 2, 3, 4] print( str( Table ) ) ( Table ) print( str( Table ) ) An Example : ebp ebp, esp ebx ecx ecx, 4 ebx, dword[ebp+8], Table

15 # example.py from future import print_function def ( array ): for i in range( len( array ) ): array[ i ] += 1 Table = [1, 2, 3, 4] print( str( Table ) ) ( Table ) print( str( Table ) ) An Example : ebp ebp, esp ebx ecx ecx, 4 ebx, dword[ebp+8], Table

16 Single-Step Execution

17 Passing Parameters by Reference: an Example

18 ?? ebx?? ecx?? : ebp ebp, esp ebx ecx ecx, 4 ebx, dword[ebp+8] esp > Memory?? 4, Table < eip 3 2 1

19 ebx?? ecx?? : ebp ebp, esp ebx ecx ecx, 4 ebx, dword[ebp+8] esp > Memory?? 4, Table < eip 3 2 1

20 ebx?? ecx?? : ebp ebp, esp ebx ecx ecx, 4 ebx, dword[ebp+8] esp > Memory?? 4, Table < eip 3 2 1

21 ebx?? ecx?? : ebp ebp, esp ebx ecx ecx, 4 ebx, dword[ebp+8] < eip esp > Memory?? ret addr 4, Table 3 2 1

22 ebx?? ecx?? : ebp ebp, esp ebx ecx ecx, 4 ebx, dword[ebp+8] < eip esp > Memory?? ret addr old epb 4, Table 3 2 1

23 ebx?? ecx?? : ebp ebp, esp ebx ecx ecx, 4 ebx, dword[ebp+8] < eip esp ebp > Memory?? ret addr old epb 4, Table 3 2 1

24 ebx?? ecx?? : ebp ebp, esp ebx ecx ecx, 4 ebx, dword[ebp+8] < eip ebp > esp > Memory?? ret addr old epb old ebx 4, Table 3 2 1

25 ebx?? ecx?? : ebp ebp, esp ebx ecx ecx, 4 ebx, dword[ebp+8] < eip ebp > esp > Memory?? ret addr old epb old ebx old ecx 4, Table 3 2 1

26 ebx?? ecx 4 : ebp ebp, esp ebx ecx ecx, 4 ebx, dword[ebp+8] < eip ebp > esp > Memory?? ret addr old epb old ebx old ecx 4, Table 3 2 1

27 ebx ecx 4 : ebp ebp, esp ebx ecx ecx, 4 ebx, dword[ebp+8] < eip ebp > esp > Memory?? ret addr old epb old ebx old ecx 4, Table 3 2 1

28 ebx ecx 4 : ebp ebp, esp ebx ecx ecx, 4 ebx, dword[ebp+8] < eip ebp > esp > Memory?? ret addr old epb old ebx old ecx 4, Table

29 ebx 89A4 ecx 4 : ebp ebp, esp ebx ecx ecx, 4 ebx, dword[ebp+8] < eip ebp > esp > Memory?? ret addr old epb old ebx old ecx 4, Table

30 ebx 89A4 ecx 4 3 : ebp ebp, esp ebx ecx ecx, 4 ebx, dword[ebp+8] < eip ebp > esp > Memory?? ret addr old epb old ebx old ecx 4, Table

31 ebx 89A4 ecx 4 3 : ebp ebp, esp ebx ecx ecx, 4 ebx, dword[ebp+8] < eip ebp > esp > Memory?? ret addr old epb old ebx old ecx 4, Table

32 ebx 89A8 ecx 4 3 : ebp ebp, esp ebx ecx ecx, 4 ebx, dword[ebp+8] < eip ebp > esp > Memory?? ret addr old epb old ebx old ecx 4, Table

33 ebx 89B2 ecx : ebp ebp, esp ebx ecx ecx, 4 ebx, dword[ebp+8] < eip ebp > esp > Memory?? ret addr old epb old ebx old ecx 4 5, Table

34 ebx 89B2 ecx?? : ebp ebp, esp ebx ecx ecx, 4 ebx, dword[ebp+8] < eip ebp > esp > Memory?? ret addr old epb old ebx old ecx 4 5, Table

35 ebx?? ecx?? : ebp ebp, esp ebx ecx ecx, 4 ebx, dword[ebp+8] < eip esp ebp > Memory?? ret addr old epb old ebx old ecx 4 5, Table

36 ebx?? ecx?? : ebp ebp, esp ebx ecx ecx, 4 ebx, dword[ebp+8] < eip esp > Memory?? ret addr old epb old ebx old ecx 4 5, Table

37 ebx?? ecx?? : ebp ebp, esp ebx ecx ecx, 4 ebx, dword[ebp+8] esp > Memory?? ret addr old epb old ebx old ecx 4 5, Table < eip

38 Passing through registers Passing through the stack Passing by Value Passing by Reference

39 esp > Memory?? ret addr old epb old ebx old ecx Question 1: What happens to the data "below" esp? Can it be used?

40 Memory?? ret addr old epb Question 2: What about local variables? old ebx esp > old ecx

41 RECURSION

42 Python 3.5.0b1 (v3.5.0b1:071fefbb5e3d, May , 18:22:54) [GCC (Apple Inc. build 5666) (dot 3)] on darwin Type "copyright", "credits" or "license()" for more information. >>> def fact( n ): if n <= 1: return 1 return n * fact( n - 1 ) >>> fact( 3 ) 6 >>> fact( 5 ) 120 >>> fact( 20 ) >>> fact( 100 ) >>> { 1 if n<=1 n! = n * (n-1)! otherwise

43 Write the function fact(n) and it from main(), in Assembly

44 Compare to Non-Recursive Version

45 Question 1 Compare the execution time of the recursive version of factorial() to its non-recursive version.

46 Question 2 If the maximum stack size given to a program is 8 GBytes, how many terms could fact() compute, at most, if we didn't care about multiplication overflow? Note: We can get the default stack size linux uses with ulimit -s