Arithmetic and Logic Instructions

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

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

It’s all bytes stored in memory (in this case, in the code segment) CS – Code segment begins CS:_start D2 00 ABCD 53 = ‘S’43 = ‘C’ 32 = ‘2’20 = ‘ ’ 31 = ‘1’39 = ‘9‘ 69 = ‘i‘20 = ‘ ’ B D F A C E ‘ ’ = ‘s’ 72 = ‘r’67 = ‘g’ 61 = ‘a’65 = ‘e’ 21 = ‘!’74 = ‘t’ ?? B 1D 1F A 1C 1E myvar1 myvar2 myvar3 myvar4 cs261msg

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

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!

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]

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

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 and higher

Flags register 8086, 8088, , 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

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

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)

Examples of logic instructions NOT AL AL AL BL AND AL, BL AL BL OR AL, BL AL BL XOR AL, BL AL BL AND AL, BL AL BL OR AL, BL AL

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

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

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

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

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

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

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 and later SAR can be used to sign extend one register into another MOV AH, AL; assume AL = SAR AH, 7; AX =

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

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

Examples mov ax,3; Initial register valuesAX = mov bx,5;BX = or ax,9; ax <- ax | AX = and ax, b; ax <- ax & AX = xor ax,0FFh; ax <- ax ^ AX = neg ax; ax <- (-ax)AX = not ax; ax <- (~ax)AX = or ax,1; ax <- ax | AX = shl ax,1; logical shift left by 1 bitAX = shr ax,1; logical shift right by 1 bitAX = ror ax,1; rotate right (LSB=MSB)AX = rol ax,1; rotate left (MSB=LSB)AX = mov cl,3; Use CL to shift 3 bitsCL = shr ax,cl; Divide AX by 8AX = mov cl,3; Use CL to shift 3 bitsCL = shl bx,cl; Multiply BX by 8BX =

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

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

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!

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

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)

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!

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

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

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)

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

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)