---
# System prepended metadata

title: assemnly language for 8086 part 2

---

# assemnly language for 8086 part 2


## FLAG CONTROL
The 8086 microprocessor has a set of flags that either monitors the status of 
executing instructions or controls options available in its operation. The 
instruction set includes a group of instructions that when executed directly 
affects the state of the flags. these instructions shown below: 
- LAHF (Load AH from flags)
- SAHF (Store AH into flags)
- CLC (Clear carry)
- STC (Set carry)
- CMC (Complement carry)
- CLI (Clear interrupt)
- STI (Set interrupt)

### LAHF
Load the AH register with the value of flag register, the AH flag will equal to `AH= [7=StatusFlag][6=ZeroFlag][5= 0 always][4=auxiliary carryflag][3=0 always][2=Parity Flag][1=1 always][0=Carry flag]`
### SAHF 
store the value of AH into flag register with same bit order, to set all flags to logic 1 we load AH with **FFH** then execute ***SAHF***

### CLC
clear carry flag 
### STC
set carry flag to one 
### CMC
reverse the logic of **CF** , for example if `CF=1` we use CMC to make `CF=0`
### CLI
stop hardware interrupt by making `*IF=0 
;*interrupt flag`
### STI
This instruction set the interrupt flag to one

---
## COMPARE 
 The comparison instruction (CMP) compares a **byte(8bit)** / **word(16bit)** from the specified 
source with a byte/word from the specified destination.
* The source and destination both can't be memory locations.
* The comparison is done by subtracting the source byte or word from the destination byte or word. But the result is not stored in the destination
*  Source and destination remain unchanged. only flags are updated.`Flags : The AF, OF, SF, ZF, PF and CF` are updated by the ***CMP*** instruction.
---
## TRANSFER
This group of instructions will always cause the 8086 to fetch its next instruction from the **location specified** or indicated by instruction rather than  from the next location after the JMP instruction.
###  unconditional jump (JMP)
there is two types of jump state divided by the change of IF 
* The first, called an intrasegment jump, is limited to addresses within the current code segment. This type of jump is achieved by just modifying the value in **IP**.
* The other kind of jump. the intersegment jump, permits jumps from one code segment to another. Implementation of this type of jump requires modification of the contents of both **CS** and **IP**
#### short , near and far label operands
The Short-label and Near-label operands specify the jump relative to the 
address of the jump instruction itself
##### The Short-label 
in a Short-label jump instruction an 8-bit number is coded as an immediate operand to specify the signed displacement of the next instruction to be executed from the location of the jump instruction. When the jump instruction is executed, IP is reloaded with a new value equal to the updated value in IP. which is (IP) + 2, plus the signed displacement. The new value of IP and current value in CS give the address of the next instruction to be fetched and executed
##### The near-lable
Near-label operands specify a new value for IP with a 16-bit immediate operand. This size of offset corresponds to the complete rangeof the current code segment. The value of the offset is automatically added to IP upon execution of the instruction. In this way, program control is passed to the location identified by the new IP
* Example:
    JMP BX
    Uses the contents of register BX for the displacement.
##### The far label
Far – label uses a 32-bit immediate operand to specify the jump to address. The first 16 bits of 32- bit pointer are loaded into IP and are an offset address relative to the contents of the code-segment register.
* Example: 
    JMP WORD [DI]
### Conditional Jump 
Conditional jumps are always **short** jumps in the 8086,The destination must be in the range of –128 bytes to +127 bytes from the address of the instruction after the conditional transfer instruction
* Above and Below used for comparison of unsigned numbers.
* Less and Greater used for comparison of signed numbers.
###  Jump above (JA)
if (CF = 0) and (ZF = 0) then **jump** Used after a *CMP* or *SUB* instruction, JA transfers control to short-label if the first operand (which should be unsigned) was greater thanthe second operand (also unsigned).The target of the jump must bewithin -128 to +127 bytes of the next instruction
### Jump above or equal (JAE ≡ JNB ≡ JNC)
if `CF = 0 `then jump.
###  Jump below (JB ≡ JC ≡ JNAE)
Short Jump if first operand is Below second operand (as set by CMP instruction). for Unsigned. 
if `CF = 1` then jump.
### Jump below or equal (JBE = JNA)
Short Jump if first operand is Below or Equal to second operand (as set by CMP instruction) for Unsigned. 
if `CF = 1 ;or ZF = 1 `then jump 
###  Jump equal (JE)
Short Jump if first operand is Equal to second operand (as set by CMP instruction). **Signed**/**Unsigned**. if `ZF = 1 `then jump 
### Jump greater (JG)
Short Jump if first operand is Greater than second operand (as set by CMP instruction). for **Signed**.
if `ZF = 0` and (SF=OF) then jump 
### Jump greater or equal (JGE)
Short Jump if first operand is Greater or Equal to second operand (as set by CMP instruction). for **Signed**. 
### Jump less (JL)
Short Jump if first operand is Less then second operand (as set by CMP instruction).for **Signed**. 
###  Jump less or equal (JLE)
Short Jump if first operand is Less or Equal to second operand (as set by CMP instruction). for **Signed**. 
### Jump carry (JC)
Short Jump if **Carry flag** is set to 1.
if `CF = 1` then jump 
###  Jump no carry (JNC)
Short Jump if Carry flag is set to 0. 
###  Jump if CX is zero (JCXZ)
Short Jump if CX register is 0.
if `CX = 0 {(CF or ZF)=0}` then jump 
### Jump not overflow instruction (JNO)
if `OF = 0` then jump
###  Jump not parity (JNP)
Short Jump if No Parity (**odd**). Only 8 low bits of result are checked. Set by CMP, SUB, ADD, TEST, AND, OR, XOR instructions.
### Jump parity (JP)
Short Jump if Parity (**even**). Only 8 low bits of result are checked.
### Jump not sign (JNS)
Short Jump if Not Signed (if **positive**). Set by CMP
### Jump sign (JS)
Short Jump if Signed (if **negative**)
### Jump not zero (JNZ)
Short Jump if Not Zero (not equal zero).
###  Jump zero (JZ)
Short Jump if Zero (equal to zero)

---
## Counter OR Loop
The 8086 microprocessor has three instructions specifically designed for implementing loop operations. These instructions can be use in place of certain conditional jump instruction and give the programmer a simpler wayof writing loop sequences. The loop instructions are listed below
### LOOP
CX must be preloaded with a count representing the number of times the loop is to be repeated **Decrease CX**, jump to label if **CX not zero**.
### LOOPE 
Decrease CX, jump to label if CX not zero and Equal **(ZF = 1)**. 
### LOOPNE
Decrease CX, jump to label if CX not zero and Not Equal **(ZF = 0)**. 
### LOOPZ
Decrease CX, jump to label if CX not zero and ZF = 1

---
## Stack (push and pop)
the main use of push and pop to store values in register then use the *push* instruction to store the value in spearated place then change the register and do any operations and after that *pop* back register value to the old value.

## Subroutines
A subroutine is a special segment of program that can be called for 
execution from any point in a program.
## CALL & RET
the call (CALL) and return (RET) provide the mechanism for calling a 
subroutine into operation and returning control back to the main program at 
its completion
* examples 
    CALL **BX**
    RET
    When this instruction is executed, the contents of BX are loaded into IP and execution continues with the subroutine starting at a physical address derived from CS and the new value of IP
    
    CALL **[BX]**
    RET
    the instruction has its subroutine offset address at the memory location whose physical address is derived from the contents of DS and BX. The value stored at this memory location is loaded into IP

every subroutine must end by executing an instruction that returns control to 
the main program. This is the return (RET) instruction

---
## ARRAY PROCESSING
just store the offset in any reggister then put it in DS then define the size of array

---
## Strings
String: A series of data words (or bytes) that reside in consecutive memory locations.
### MOVSB
Copy byte at DS:[SI] to ES:[DI]. Update SI and DI.
### MOVSW
Copy word at DS:[SI] to ES:[DI]. Update SI and DI.
### CMPSB
Compare bytes: ES:[DI] from DS:[SI]. 