mith College Computer Science CSC231 - Assembly Week #8 Dominique Thiébaut

Transcription

1 mith College Computer Science CSC231 - Assembly Week #8 Dominique Thiébaut dthiebaut@smith.edu

2 Can't Sleep

3 Logic Design

4 Logic Design

5 Image from Apple II Motherboard

6 Nasa Computer (Apollo)

7 A Bit of History Claude Shannon 21 years old 1937 MIT Master's Thesis All arithmetic operations on binary numbers can be performed using boolean logic operators

8

9 Designing a 2-bit Adder with Logic

10

11 Processor CU ALU

12 xi yi ALU Compute add x, y carryi sumi

13 x y xn yn x3 y3 x2 y2 x1 y1 x0 y0 zn z3 z2 z1 z0 z

14 y0 x = 0 0 = 0 1 = 0 1 = 1 0 carry z0

15 x0 y0 Carry z

16 x0 y0 Carry z Carry = x0 and y0 z0 = x0 xor y

17 x0 y0 AND XOR carry z0

18 Moral of the Story: Addition is performed by logic operations using natural binary numbers (unsigned arithmetic)

19 NEGATIVE NUMBERS

20 How can we represent signed binary numbers when all we have are bits (0/1)? Whichever system we use should work with the binary adder in the ALU

21 4-bit Nybble Binary Hex Unsigned Decimal A B C D E F 15

22 Sign Bit 4-bit Nybble Binary Hex Unsigned Decimal A B C D E F 15

23 4-bit Nybble Binary Hex Unsigned Decimal A B C D E F 15 Positive Numbers Negative Numbers

24 Signed Magnitude Number System

25 Signed Magnitude Rule: To find the opposite of a number, just flip its MSB (+5) (-5) and vice versa

26 4-bit Nybble Binary Hex Unsigned Decimal Signed Magnitude A B C D E F 15-7

27 Does this System work With the ALU Adder? Binary Hex Unsigned Decimal Signed Magnitud e A B C D E F = = 3

28 1's Complement Number System

29 1's Complement Rule: To find the opposite of a number, just flip all its bits (+5) (-5) and vice versa

30 4-bit Nybble Binary Hex Unsigned Decimal 1's Complement A B C D E F 15-0

31 Does this System work With the ALU Adder? Binary Hex Unsigned Decimal 1's Complement A B C D E F = = = 3

32 2's Complement Number System

33 2's Complement Rule: To find the opposite of a number, just flip all its bits, and add (+5) (-5) and vice versa

34 4-bit Nybble Binary Hex Unsigned Decimal 2's Complement A B C D E F 15-1

35 Does this System work With the ALU Adder? Binary Hex Unsigned Decimal 2's Complement A B C D E F = = = 3

36 Interesting Property What is the binary representation of -1 as a byte? What is the binary representation of -1 as a word? What is the binary representation of -1 as a dword?

37 int x = 0x7fffffff - 5; for ( int i=0; i<10; i++ ) System.out.println( x++ ); getcopy Loop0x7fffffff.java

38 What did you just learn about Java ints?

39 neg neg oprnd neg op8 neg op16 neg op32 op: mem, reg alpha db 1 beta dw 4 x dd 0xF06 neg byte[alpha] mov ax,1234 neg ax To get the 2's complement of an int neg dword[x]

40 Range of 2's Comp't. ints Binary Hex Unsigned Decimal A B C D E F 15

41 Type Minimum Maximum unsigned byte signed byte unsigned short signed short unsigned int signed int # Bytes , ,768 32, ,294,967, ,147,483,648 2,147,483,647 4 signed long 9,223,372,036,854,775,808 9,223,372,036,854,775,807 8

42 We Stopped Here Last Time (and finished first exercise on next slide)

43 watch?v=dtydzkpmfou The 13th Floor

44 The LOOP Instruction

45 loop loop label loop label x dd 1 sum dd 0 mov ecx, 10 addup: mov eax, dword[x] add dword[sum], eax inc dword[x] loop addup ;ecx< ecx-1 ;if ecx!=0, ; goto addup

46 loop loop label loop label x dd 1 sum dd 0 Label mov ecx, 10 addup: mov eax, dword[x] add dword[sum], eax inc dword[x] loop addup ;ecx< ecx-1 ;if ecx!=0, ; goto addup

47 loop loop label loop label ;ecx < ecx-1 ;if ecx!= 0, ; goto label ;else continue x dd 1 sum dd 0 Label mov ecx, 10 addup: mov eax, dword[x] add dword[sum], eax inc dword[x] loop addup ;ecx< ecx-1 ;if ecx!=0, ; goto addup

48 _start: mov eax, 4 Labels for1: for2: mov ecx, 10 loop for1 loop for2 Start with a letter (or a dot) End with a colon (when declared) Represent an address in the code section Must be unique in program

49 Tracing a Code Example

50 eax ecx mov ecx, 3 mov eax, 1 for: call _printdec inc eax loop for ;ecx< ecx-1 ;if ecx!=0, ; goto for

51 eax ecx? 3 mov ecx, 3 mov eax, 1 for: call _printdec inc eax loop for ;ecx< ecx-1 ;if ecx!=0, ; goto for

52 eax ecx 1 3 mov ecx, 3 mov eax, 1 for: call _printdec inc eax loop for ;ecx< ecx-1 ;if ecx!=0, ; goto for

53 1 eax ecx 1 3 mov ecx, 3 mov eax, 1 for: call _printdec inc eax loop for ;ecx< ecx-1 ;if ecx!=0, ; goto for

54 1 eax ecx mov ecx, 3 mov eax, 1 for: call _printdec inc eax loop for ;ecx< ecx-1 ;if ecx!=0, ; goto for

55 1 eax ecx mov ecx, 3 mov eax, 1 for: call _printdec inc eax loop for ;ecx< ecx-1 ;if ecx!=0, ; goto for

56 12 eax ecx mov ecx, 3 mov eax, 1 for: call _printdec inc eax loop for ;ecx< ecx-1 ;if ecx!=0, ; goto for

57 12 eax ecx mov ecx, 3 mov eax, 1 for: call _printdec inc eax loop for ;ecx< ecx-1 ;if ecx!=0, ; goto for

58 12 eax ecx mov ecx, 3 mov eax, 1 for: call _printdec inc eax loop for ;ecx< ecx-1 ;if ecx!=0, ; goto for

59 123 eax ecx mov ecx, 3 mov eax, 1 for: call _printdec inc eax loop for ;ecx< ecx-1 ;if ecx!=0, ; goto for

60 123 eax ecx mov ecx, 3 mov eax, 1 for: call _printdec inc eax loop for ;ecx< ecx-1 ;if ecx!=0, ; goto for

61 123 eax ecx mov ecx, 3 mov eax, 1 for: call _printdec inc eax loop for ;ecx< ecx-1 ;if ecx!=0, ; goto for

62 123 eax ecx mov ecx, 3 mov eax, 1 for: call _printdec inc eax loop for ;ecx< ecx-1???? ;if ecx!=0, ; goto for

63 Example 1 Sum of 1..10

64 ; computes sum(1,2, 10) x dd 1 sum dd 0 mov ecx, 10 mov eax, dword[x] addup: add dword[sum], eax inc eax loop addup ;ecx< ecx-1 ;if ecx!=0, ; goto addup mov eax, dword[sum] call _printdec

65 ; computes sum(1,2, 10) x dd 1 sum dd 0 Do we need eax? mov ecx, 10 addup: add dword[sum], ecx loop addup ;ecx< ecx-1 ;if ecx!=0, ; goto addup mov eax, dword[sum] call _printdec

66 Example 2 Fibonaccis

67 ; print the first 10 Fibonacci terms _start: mov eax, 1 ; fibn mov ebx, 1 ; fibn-1 call _printdec call _println mov ecx, 10-1 ; we printed 1, 9 more to go for: mov edx, ebx mov ebx, eax add eax, edx call _printdec call _println loop for getcopy fib.asm

68 Looping Through Arrays

69 LOOP INSTRUCTION Looping Through Arrays INDIRECT ADDRESSING MODE

70 Indirect Addressing Mode The addressing mode refers to the way the operand of an instruction is generated. We already know register mode, immediate mode, and direct mode.

71 Tracing One Example of Indirect Addressing (Base Addressing)

72 ebx??? 0x1104C 0x1104B Memory al section.data A db 1,3,0xF0,0x3E,0x56 B db 0x78,0x33,0x12? 0x1104A 0x x E section.text _start: mov al, 'z' mov ebx, A mov byte[ebx], 0 0x x11046 F0 3 mov ebx, B mov byte[ebx], al 0x

73 ebx??? 0x1104C 0x1104B Memory al section.data A db 1,3,0xF0,0x3E,0x56 B db 0x78,0x33,0x12 'z' 0x1104A 0x x E section.text _start: mov al, 'z' mov ebx, A mov byte[ebx], 0 0x x11046 F0 3 mov ebx, B mov byte[ebx], al 0x

74 0x1104C 0x1104B 0x1104A 0x x x x x11045 Memory E F0 3 1 ebx al section.data A db 1,3,0xF0,0x3E,0x56 B db 0x78,0x33,0x12 section.text _start: mov al, 'z' mov ebx, A mov byte[ebx], 0 mov ebx, B mov byte[ebx], al 'z'

75 0x1104C 0x1104B 0x1104A 0x x x x x11045 Memory E F ebx al section.data A db 1,3,0xF0,0x3E,0x56 B db 0x78,0x33,0x12 section.text _start: mov al, 'z' mov ebx, A mov byte[ebx], 0 mov ebx, B mov byte[ebx], al 'z'

76 0x1104C 0x1104B 0x1104A 0x x x x x11045 Memory E F ebx al section.data A db 1,3,0xF0,0x3E,0x56 B db 0x78,0x33,0x12 section.text _start: mov al, 'z' mov ebx, A mov byte[ebx], 0 mov ebx, B mov byte[ebx], al 1104A 'z'

77 0x1104C 0x1104B 0x1104A 0x x x x x11045 Memory 'z' 56 3E F ebx al section.data A db 1,3,0xF0,0x3E,0x56 B db 0x78,0x33,0x12 section.text _start: mov al, 'z' mov ebx, A mov byte[ebx], 0 mov ebx, B mov byte[ebx], al 1104A 'z'

78 Example 2: Setting an Array to All 0s

79 ; Array Table contains 10 words Table dw 1,2,3,4,5,6 dw 7,8,9,10 mov ecx, ;# of elements mov ebx, ;address of ;Table clear: mov word[ebx], ;value to store add ebx, ;make ebx point ;to next word loop clear ;ecx< ecx-1 ;if ecx!=0, ; goto clear

80 Exercises Problem #1: Store the first 10 Fibonacci terms in an array of ints (32 bits) Problem #2: Given a DNA sequence of 1,000,000 characters stored in an array of bytes, and all characters in uppercase, transform it into its lowercase equivalent. The characters are A, C, G, T and N.

81 We stopped here last time