CHAPTER 7 - Arithmetic instructions, more on flags

In this chapter you will learn how to perform basic math operations in assembly language. Then you will get deeper into how processor does it and thus learn more on flags.

7.1. Addition and substraction
Simplest case of addition is addition of one, called "incrementing". For example, if we increment variable holding value 5, it will contain 6 etc.

Instruction which performs incrementing is `inc` (obvious why). It has one operand, which tells what should be incremented (eg. to what will 1 be added). Operand can be register or memory variable. It can't be constant, of course, because such instruction, even if it would exist, wouldn't have any effect. Example of incrementing:
```mov ax,5
inc ax	     ;increment (add 1 to) value in ax
;here ax holds value 6
```

I think it is clear (it isn't, you'll see later why).

Substracting of value 1 is called "decrementing". Decrementing is opposite of incrementing. Instruction which performs decrementing is `dec`. Example:
```mov ax,5
inc ax	     ;increment (add 1 to) value in ax
;here ax holds value 6
dec ax	     ;decrement (substract 1 from) value in ax
;here ax holds value 5 again
```
terms: incrementing (adding 1), decrementing (substracting 0)
instructions: inc, dec
If you wan't to add or substract more than 1, you can use more `inc`s or `dec`s, but that is quite ugly way, requires more typing, and code is big and slow. So there is instruction which can add any value, this instruction is `add`. It takes two arguments, first one is destination eg. value to which will be added, and second is value to be added. Argument types are same as for `mov`, first can be register or memory variable, second can be constant, register or memory variable (if first one isn't memory variable, remember - one instruction can't access two memory locations). Example:
```mov ax,5
add ax,5
;here ax contains 10
```

Another example:
```mov ax,5
mov bx,5
add bx,[five]
add ax,bx
;here ax contains 15, bx contains 10
five dw 5
```

Instruction for substracting is `sub`. It is exact opposite of `add`, everything is same for it as for `add`.
```mov ax,15
mov bx,10
sub bx,[five]
sub ax,bx
;here ax contains 10, bx contains 5
five dw 5
```

7.2. Overflows
There are some cases with addition and substraction that I haven't already mentioned. For example if you try to add 10 to byte sized variable containing 250 (biggest number byte sized variable can hold is 255). In such case, we say that `overflow` has occured.

But question is, what happens with result of operation that has overflown. When upper limit of variable is crossed, then result of operation will be rest of value to be added. We can say the operation will be "wrapped" from max value to minimal value. For example:
byte 255 + 1 = 0
byte 255 + 2 = 1
byte 254 + 3 = 1
byte 250 + 10 = 5
byte 255 + 255 = 254
word 65535 + 1 = 0
word 65535 + 65535 = 65534
etc.

There is also other case, when result of operation falls below lower limit (which is 0 for any size of variable). In this case result of operation will be wrapped from lower limit to upper limit. This case is called `underflow`. For example:
byte 0 - 1 = 255
byte 0 - 255 = 1
byte 254 - 254 = 0
byte 254 - 255 = 255
etc.

NOTE: Word `oveflow` is usually used for both `overflow` and `underflow`.
Terms: Overflow, Underflow
We also need to know how to check if overflow has occured after performing operation to prevent bugs. For this, flags are used. I mentioned flags in chapter 5.3. We used flags for checking results of comparison at conditional jumps, and I also said that there shouldn't be any instrcutions between comparison and jumps, because many instructions change flags (of course you can place instruction there if you are sure it won't change any needed flag). Arithmetic instructions `add` and `sub` use one bit of flags called CF (carry flag). If overflow occurs, then they set it to 1, otherwise they set it to 0. You can test carry flag with conditional jumps `jc` and `jnc` (see chapter 5.3 about conditional jumps). `jc` jumps if carry flag is set, `jnc` jumps if carry flag is not set.

Here is example of testing overflows:
```add ax,bx
jc overflow
no_overflow:

sub cx,dx
jc underflow
no_underflow:
```
carry flag (CF) - ont bit (flag) of "flags" register
conditional jump instructions: jc, jnc

7.3. Zero Flag
Instructions `inc` and `dec` doesn't set CF, so you can't test overflow using CF with them. But there is another rule that can be used to prevent overflow with `inc` and `dec`. This rule is that when result of operation is zero, then flag called "zero flag" (ZF) is set. This flag is tested with `jz` (jump if zero flag is set) and `jnz` (jump if zero flag is clear) conditional jump instructions.

With this you can create loops, eg. repeat some part of code several times.
For example code
```  org 256
mov cx,5
here:
mov dl,'a'
mov ah,2
int 21h
dec cx
jnz here

int 20h
```
will write
aaaaa
NOTE: You can optimize that part of code to
```  org 256
mov cx,5
mov dl,'a'
mov ah,2
here:
int 21h
dec cx
jnz here

int 20h
```
because value of `dl` and `ah` isn't changed anywhere in loop, so we don't have to set it each time.

Not only `add` and `sub` instructions set ZF if result is zero (and clear it otherwise). All basic arithmetic instructions do this. For now, you know these arithmetic instructions: `add`, `sub`, `and`, `xor` and `or`. So afer any of these instruction, ZF tells you if destination (first argument) of operation holds 0. For example, You can use this behavior to check if value of register is 0. Before, you would do this with
```cmp ax,0
jz ax_is_zero
```
but you can also use "or" to do this:
```or ax,ax
jz ax_is_zero
```
Or won't change `ax`, because 1 ored with 1 is 1, and 0 ored with 0 is 0. Reread chapter 6 if you don't comprehend that. Btw, this was used on older computers because such code was faster and is few bytes smaller than with `cmp`.

7.4. Carry flag, more binary arithmetic instructions
I mentioned carry flag a little in connection with overflow. But CF is really general-purpose flag because it can be tested easily (`jc`,`jnc` and few more), and it's value can be easily set. You will find many more uses of CF later.

How to set CF? There are two instructions for this. `stc` stays for "SeT Carry", and so it "sets" carry flag (eg. sets it's value to 1), so `jc` jump is taken and `jnc` is not taken etc etc, you should understand this aleady. Instruction `clc` (CLear Carry) clears CF.

When we know how to work with CF, we can learn about rest of bit arihmetic operations. First will be `shl`. It shift bits of register to left, eg. 0th bit becomes 1st, 1st becomes 2nd etc. Last bit (7th of byte or 15th of word) is moved to CF. First bit becomes 0. This way (if highest bit wa zero) we have multiplied the shifted register by 2.

Before shifting: `bit7:bit6:bit5:bit4:bit3:bit2:bit1:bit0`
After shifting: `bit6:bit5:bit4:bit3:bit2:bit1:bit0:0`, `CF=bit7`

To explain why number is multipied by 2. If you remember beginning of chapter 6, you know that number before shifting is ```128*bit7 + 64*bit6 + 32*bit5 + 16*bit4 + 8*bit3 + 4*bit2 + 2*bit1 + bit0``` so after shifting it becomes ```128*bit6 + 64*bit5 + 32*bit4 + 16*bit3 + 8*bit2 + 4*bit1 + 2*bit0``` which is ```2*(64*bit6 + 32*bit5 + 16*bit4 + 8*bit3 + 4*bit2 + 2*bit1 + bit0)```. So if highest bit is zero, then number is multiplied by two. This way we can easily multiply by powers of two (2, 2^2=4, 2^3=8, 2^4=16 etc.). Also upper bit is stored in CF so we can test overflow of mulitplication with `jc` and `jnc`

Usually we want to shift more than once (multiply by 4, 8, 16...), so `shl` takes second argument, which tells how many times we want to shift. If we shift by number greater than 1, CF contains 1 if ANY of discarded bits (x highest bits, where x is value we are shifting by) contained 1. This way we can still check for overflow. If you are beginner, don't care about overflow checking too much, you probably won't do it anyway :) (and your program will probably contains bugs then)

There is one limitation to `shl` - it's arguments doesn't follow same rules as other instructions you know (`mov`,`add` etc.) Fisrt argument can be register or memory location, but second can be only numeric constant or CL register (really, no other).

NOTE: Orignially, at 8086 (that's 086, first of 80x86 series known as x86, like 286 or 486), there was only `shl` instruction which could shift by one, and so for example `shl ax,3` was compiled into 3 `shl`s. There also wasn't any shifting by register, you had to make loop for that. Fortunately 80286 had shifting by constant and by CL so it is now OK.

That was about shifting left, but there is also other type of shifting, that is shifting to right. I hope you can now imagine what it does, just few notes to it. Instruction that performs this is `shr` (shift right). It's effect is division by two (or powers of two) without remainder. If we shift right by two, then remainder (0 or 1) is in CF, otherwise CF beheaves like with shifting left by number higher than two: If remainder isn't 0 (at least one of discarded bits was 1) then CF is set, otherwise it is clear.

7.5. Some examples
At least we are able to make output of number (write number to screen). Too bad we can only write it in binary :). So here is our task: Write program that outputs any binary number. For now, we will hardcode number into program, eg. `mov`e it into some register as constant. Here is the source.
```org 100h

mov bx,65535 ;we store number we want to display in bx
;(because it's not used by DOS services we use)
mov cx,16 ;we are diplaying 16 digits (bits)

;display one digit from BX each loop

display_digit:
shl bx,1
jc display_one

;display '0'
mov ah,2
mov dl,'0'
int 21h
jmp continue

;display '1'
display_one:
mov ah,2
mov dl,'1'
int 21h

;check if we want to continue
continue:
dec cx
jnz display_digit

;end program
int 20h
```

I hope you understand this, it's quite simple. Each loop we shift BX register left by one, so upper bit is moved to CF, then we write '0' or '1' depending on value of CF (previously upper bit of number) and continue loop until we write 16 digits (because word has 16 bits).

Example of stepping thru code:
``` Start: CF=16, BX=1100101000001011b Pass1: CX=15, BX=1001010000010110b, CF=1 Pass2: CX=14, BX=0010100000101100b, CF=1 Pass3: CX=13, BX=0101000001011000b, CF=0 ... Pass14: CX=2, BX=1100000000000000b, CF=0 Pass15: CX=1, BX=1000000000000000b, CF=1 Pass16: CX=0, BX=0000000000000000b, CF=1 ```

In my opinion, if you made it here, with (generaly) understing everything, you can consider yourself to be more than beginner, congratulations!!! There is much to learn to become well-armed assembly programmer, but you now have the sufficent base which you will only extend, with or without use of this tutorial. (But there are several parts which will be explained further which are hard to find in any tutorial)