1. Arithmetic and Logic Instructions

2. Outline Declarations Moving data The Flags register Logic instructions Addition & subtraction

3. Declarations section.text; Normally we put data in.data! myvar1:dw1234h; define word variable ; value=1234h myvar2:dw1234; define word variable ; value=1234d=4D2h myvar3:resw; define word variable ; value not specified myvar4:DW0ABCDh; define word variable ; value = ABCDh ; note the leading zero cs261msg:DB“CS 261 is great!” ; define strings as series of bytes ; this is not one byte but 16! _start:; denotes execution starting label

4. It’s all bytes stored in memory (in this case, in the code segment) CS – Code segment begins CS:_start 12 1 34 04D2 00 ABCD 53 = ‘S’43 = ‘C’ 32 = ‘2’20 = ‘ ’ 31 = ‘1’39 = ‘9‘ 69 = ‘i‘20 = ‘ ’ 3 5 7 9 B D F 0 2 4 6 8 A C E ‘ ’ 11 73 = ‘s’ 72 = ‘r’67 = ‘g’ 61 = ‘a’65 = ‘e’ 21 = ‘!’74 = ‘t’ ?? 13 15 17 19 1B 1D 1F 10 12 14 16 18 1A 1C 1E myvar1 myvar2 myvar3 myvar4 cs261msg

5. Moving data mov ax, cs; make data seg same as code seg mov ds, ax; we would only do this if we want ; get at data in the.text (code) seg mov ax, [myvar2]; move value of myvar2 to ax ; same as mov ax, [2] ; ax now contains 04D2h mov si, myvar2; si now points to myvar2 ; it contains 0002h mov ax, [si]; move value pointed to by si to ax ; ax again contains 04D2h ; this was an indirect reference

6. Moving Data mov bx, cs261msg; bx now points to the beginning of ; out “CS 261 is great!” string. ; bx points to the ‘C’ character dec byte [bx + 1]; new instruction! arg = arg – 1 ; Just changed the S in “CS” to an R mov si, 1; now lets use SI as an index inc byte [cs261msg + si]; new instruction! arg = arg + 1 ; evaluates to inc [8 + 1] = inc [9] ; R becomes an S again!

7. Moving Data ; Memory can be indexed using four registers only!!! ; SI -> offsets from DS ; DI -> offsets from DS ; BX -> offsets from DS ; BP -> offsets from SS mov ax, [bx]; ax = word in memory pointed to by bx mov al, [bx]; al = byte in memory pointed to by bx mov ah, [si]; ah = byte in memory pointed to by si mov cx, [di]; cx = word in memory pointed to by di mov ax, [bp]; ax = [SS:BP] Stack Operation! ; In addition, BX + SI, BX + DI, BP + SI, and BP + DI are allowed mov ax, [bx + si]; ax = [ds:bx+si] mov ch, [bp + di]; ch = [ss:bp+di]

8. Moving Data ; Furthermore, a fixed 8- or 16-bit displacement can be added mov ax, [23h]; ax = word at [DS:23h] mov ah, [bx + 5]; ah = byte at [DS:bx+5] mov ax, [bx + si + 107]; ax = word at [DS:bx+si+107] mov ax, [bp + di + 42]; ax = word at [SS:bp+di+42] ; Remember that memory to memory moves are illegal! mov [bx], [si]; BAD BAD BAD mov [di], [si]; BAD BAD BAD ; Special case with stack operations pop word [myvar]; moves data from top of stack to ; memory variable myvar

9. Flags register The flags register is a collection of bits that determines the state of the processor after an arithmetic or logic operation Flag bits change after arithmetic and logic instructions (e.g. carry, overflow, zero, sign, parity) 9 out of the 16 bits of the FLAGS register have meaning in the 8086, 11 out of the 32 bits in the EFLAGS register of the 80386, and 12 out of the 32 bits in the EFLAGS register of the 80486 and higher

10. Flags register 8086, 8088, 80186 80286 80386, 80486DX 80486SX AC (Alignment check) (VM) Virtual mode (RF) Resume (NT) Nested task (IOPL) Input/output privilege level (O) Overflow (D) Direction (I) Interrupt (T) Trace (S) Sign (Z) Zero (A) Auxiliary Carry (P) Parity (C) Carry

11. Important Flags  Z – set when the result of the last operation was zero  C – Set when there was a carry (or borrow) beyond the most significant bit in the last operation (unsigned overflow)  O – Set when the last operation overflowed, when interpreting the operands as signed  P – Indicates the parity of the result of the last operation  S – The sign bit (MSB) of the result of the last operation  D – direction flag, controls the direction of a string stored in memory (more later), changed by cld and std instructions

12. Logic instructions NOT, AND, OR, XOR NOT A ; A = ~A AND A, B ; A = A & B OR A, B; A = A | B XOR A, B ; A = A ^ B NOT does not modify any flags The other instructions affect –C (carry flag, they all clear it) –O (overflow flag, they all clear it) –Z (zero flag, they set it if result is 0) –S (sign flag, takes the high order bit of the result) –P (parity, number of 1’s in the result)

13. Examples of logic instructions 1100 1010 NOT AL AL 0011 0101AL BL 0011 0101 0110 1101 AND AL, BL 0010 0101AL BL 0011 0101 0110 1101 OR AL, BL 0111 1101AL BL 0011 0101 0110 1101 XOR AL, BL 0101 1000AL BL 0011 0101 0000 1111 AND AL, BL 0000 0101AL BL 0011 0101 0000 1111 OR AL, BL 0011 1111AL

14. Practical uses of AND/OR instructions Apply a bit mask to data –Masks are used to force individual bits to specific values –Isolate individual bits or bit fields for examination Example –In x86 operating systems virtual memory is organized in pages, i.e. chunks of 4096 (1000h) consecutive bytes, aligned with an address which is an integer multiple of the page size –Find the beginning of the page that contains address B9A2C07Eh (clear the least significant 12 bits) –Mask = page_size = FFFFF000h –ANDing B9A2C07E with mask yields B9A2C000

15. The TEST instruction TEST is a non-destructive version of AND –Logically ANDs two operands as AND would –Modifies FLAG bits like AND –Does not modify the contents of the destination –TEST AL,1 sets flags like AND AL,1 but does not modify AL –Useful prior to jump instructions

16. Shift left Syntax SHL reg, count (immediate) SHL reg, CL (count in register) Moves the left operand a bit position to the left as many times as specified by count or CL The empty positions are filled with 0’s The higher order bit is stored in the C flag The most efficient way to multiply by 2! 0 RegisterC SHL

17. Example ; Pack the lower nibbles from AH and AL into a single byte in AL ; for example AH = 0110 1101 and AL = 1010 0111 and al, 0Fh; clears upper nibble in AL ; AL = 0000 0111 shl ah, 4; Moves lower nibble in AH up ; AH = 1101 0000 or al, ah; combines nibbles ; AL = 1101 0111 ; Mission accomplished

18. Shift right Syntax SHR reg, count (immediate)Syntax SHR reg, count (immediate) SHR reg, CL (count in register) Moves the left operand a bit position to the right as many times as specified by count or CLMoves the left operand a bit position to the right as many times as specified by count or CL The empty positions are filled with 0’sThe empty positions are filled with 0’s The lower order bit is stored in the C flagThe lower order bit is stored in the C flag The most efficient way to divide by 2!The most efficient way to divide by 2! RegisterC SHR

19. Shift arithmetic right Syntax: SAR reg, count SAR reg, CL Moves each bit of the operant one position to the right as many times as specified by count/CL Lower order bit shifts to the carry flag High order bit is replicated RegisterC SAR

20. Shift arithmetic right Main effect is to perform a signed division by a power of two MOV AX, -15 SAR AX, 1; resulting AX = -8 In 80286 and later SAR can be used to sign extend one register into another MOV AH, AL; assume AL = 1111 0001 SAR AH, 7; AX = 1111 1111 1111 0001

21. Rotate through carry L/R Syntax:RCL reg, count (immediate) RCL reg, CL (count in register) Rotate bits to the left through the carry flag Bit in the carry flag is written back to bit 0 Syntax:RCR reg, count (immediate) RCR reg, CL (count in register) Rotate bits to the right through the carry flag Bit in the carry flag is written back to H.O. bit RCLRCR

22. Rotate left/right Syntax:ROL reg, count (immediate)Syntax:ROL reg, count (immediate) ROL reg, CL (count in register) Rotate bits to the leftRotate bits to the left H.O. bit goes to the L.O. bit and the carry flagH.O. bit goes to the L.O. bit and the carry flag Syntax:ROR reg, count (immediate)Syntax:ROR reg, count (immediate) ROR reg, CL (count in register) Rotate bits to the rightRotate bits to the right L.O. bit goes to the H.O. bit and the carry flagL.O. bit goes to the H.O. bit and the carry flag ROLROR

23. Examples mov ax,3; Initial register valuesAX = 0000 0000 0000 0011 mov bx,5;BX = 0000 0000 0000 0101 or ax,9; ax <- ax | 0000 1001AX = 0000 0000 0000 1011 and ax,10101010b; ax <- ax & 1010 1010AX = 0000 0000 0000 1010 xor ax,0FFh; ax <- ax ^ 1111 1111AX = 0000 0000 1111 0101 neg ax; ax <- (-ax)AX = 1111 1111 0000 1011 not ax; ax <- (~ax)AX = 0000 0000 1111 0100 or ax,1; ax <- ax | 0000 0001AX = 0000 0000 1111 0101 shl ax,1; logical shift left by 1 bitAX = 0000 0001 1110 1010 shr ax,1; logical shift right by 1 bitAX = 0000 0000 1111 0101 ror ax,1; rotate right (LSB=MSB)AX = 1000 0000 0111 1010 rol ax,1; rotate left (MSB=LSB)AX = 0000 0000 1111 0101 mov cl,3; Use CL to shift 3 bitsCL = 0000 0011 shr ax,cl; Divide AX by 8AX = 0000 0000 0001 1110 mov cl,3; Use CL to shift 3 bitsCL = 0000 0011 shl bx,cl; Multiply BX by 8BX = 0000 0000 0010 1000

24. Addition Syntax: ADD A,B –A, B can be register or memory, but not both memory –B can also be immediate data Examples –ADD AX, BX; register addition –ADD AX, 5h; immediate addition –ADD [BX], AX; addition to memory location –ADD AX, [BX]; memory location added to register –ADD DI, MYVAR; memory offset added to the register Flags modified: S, C, Z, O, A, P

25. Examples ; multiply AX by the decimal 10 (1010b) ; (multiply by 2 and 8, then add results) shl ax, 1; AX x 2 mov bx, ax; save 2AX shl ax, 2; 2 x (original AX) x 4 = 8 x (orig AX) add ax, bx; 2AX + 8AX = 10AX ; multiply AX by decimal 18 (10010b) ; (multiply by 2 and 16, then add results) shl ax, 1; AX x 2 mov bx, ax; save 2AX shl ax, 3; 2AX x 2 x 2 x 2 = 16AX add ax, bx; 2AX + 16AX = 18AX

26. Increment Syntax: INC A –A can be register or memory location Examples: –INC AX; AX=AX+1 –INC byte [BX]; memory location increased by 1 –INC word [BX]; memory location increased by 1 Flags modified: S, Z, O, A, P But not the carry flag!

27. Add with carry Syntax:ADC A,B –A, B can be registers or memory –B can also be immediate Function: A = A + B + carry flag Used to add numbers larger than 16 bits (in 16-bit mode) or larger than 32 bits in (32-bit mode) Examples –ADD AX,CX; produces a 32-bit sum –ADC BX,DX; of BX:AX + DX:CX -> BX:AX Flags modified: S, C, A, Z, O, P

28. Subtraction Syntax:SUB A,B –A, B can be register or memory (not both memory) –B can be immediate Function: A=A-B –Carry flag is interpreted as a borrow request from H.O. bit Flags modified S, C, A, Z, P, O Example: MOV CH, 22h SUB CH, 34h; result = -12h, S=1 (negative), Z=0, C=1 ; (borrow from high order bit), P=0 (even ; parity)

29. Decrement Syntax:DEC A –A can be register or memory Function: A=A-1 Examples –DEC AX; AX=AX-1 –DEC BYTE [BX]; memory location decreased by 1 –DEC WORD [BX] ; memory location decreased by 1 Flags modified: S, A, Z, P, O Carry flag not modified!

30. Subtract with borrow Syntax:SBBA,B –A, B can be register or memory (not both memory) –B can be immediate Function:A=A - B - carry flag –Used to subtract numbers which are wider than 16 bits (in 16-bit mode) or wider than 32 bits (in 32-bit mode) Flags modified S, C, A, Z, P, O Examples: SUB AX, DI; this subtracts the 32-bit numbers SBB BX, SI; BX:AX-SI:DI -> BX:AX

31. The carry flag Indicates a carry from the H.O. bit after addition or a borrow after subtraction Carry is set when an unsigned number goes out of range Example (8 bit operands) –FFh + 01h = 00h with C=1 –02h – 03h = FFh with C=1

32. The overflow flag Condition set when signed numbers go out of range Example (8 bit operands) – 7Fh + 01h = 80h (expected +128 but got –128) – 80h – 01h = 7Fh (expected –127 but got +127)

33. Overflows and carries mov ax,0fffeh; 65534 interpreted as unsigned add ax,3 ; C = 1, O = 0 --- Unsigned Overflow Condition mov ax,0FFFEh ; -2 interpreted as signed add ax,3; C = 1, O = 0 --- Okay as signed mov bx,07FFFh; 32767 interpreted as signed add bx,1; C = 0, O = 1 --- Signed Overflow Condition mov bx,07FFFh; 32767 interpreted as unsigned add bx,1; C = 0, O = 1 --- Okay as unsigned mov ax,07h; 7 interpreted as either signed or unsigned add ax,03h; C = 0, O = 0 --- Okay as either

34. CMP - Compare Analogous to TEST instruction, but for arithmetic operands Performs a SUB on its operands but does not modify its destination It sets the Flags just as SUB would Useful to arithmetically compare two operands prior to making a conditional branch (jump)