8086 microprocessor Programming (Part 6)

8086 STATUS FLAGS

Aims of the Experiment: 

• To study the effect of different instructions on the 8086 status flags. 
• To introduce the students to the strategy for finding errors (debugging) in an assembly language program. 

Introduction: 

The 8086 microprocessor has nine flags. Out of these nine flags, six are called status flags. These flags indicate conditions that are produced as the result of executing an arithmetic or logic instruction. That is, specific flag bits are reset (logic 0) or set (logic 1) at the completion of execution of the instruction. These status flags are : the carry flag (CF), the parity flag (PF), the auxiliary carry flag (AC) , the zero flag (ZF), the sign flag (SF), and the overflow flag (OF). The remaining three (out of nine) flags are called the control flags, and they are : the trap flag (TF), the interrupt flag (IF), and the direction flag (DF).  

In the first part of this experiment, we’ll use DEBUG to study these flags (except TF). When you load a program in DEBUG, and then trace it, the contents of all the registers as well as the status of all but trace flag (TF) are displayed after the execution of each instruction. The flags are displayed in the order given below. The DEBUG syntax for set/reset condition of these flags is also included in the following table:

Flag Type	Syntax for Set (logic 1)	Syntax for Reset (logic 0)
Overflow	OV	NV
Direction	DN	UP
Interrupt	EI	DI
Sing	NG	PL
Zero	ZR	NZ
Auxiliary Carry	AC	NA
Parity	PE	PO
Carry	CY	NC

Following points are worth mentioning here:

• None of the data transfer instructions (mov, xchg, xlat, lea, lds, and les) changes any of the status flags, that is, the status of these flags remains the same after the execution of these instructions as it was before the execution. 
• The addition and subtraction instructions (add, adc, sub, sbb) affect all the six status flags. 

These flags are used in decision-making instructions like the ‘jnz’ and ‘jnc’ instructions that you are already familiar with. It is important to know before taking a decision based on these flags (for example using conditional jumps) whether the instruction you are using affects the flag used by the decision making instruction. It is a good  practice to consult a reference book to check if the instruction in use changes the status of a flag. 

Important Notes:

• Write the following program in a text editor, assemble, and link it, and then load it in DEBUG. Trace the program, and answer on your work sheet the questions asked in comments. Answer only for the six status flags. 

Page, 132 

Title # Program for studying flags # 

Dosseg 

.model small 

.stack 100h

.code 

order-word proc 

mov ax, @data ;initialize the DS register 

mov ds, ax 

mov al, 53h 

sub al, 53h ;1. which flags are set and why?

mov   ah, 73h 

add ah,38h ; 2. Which flags are set and why?

mov cx, 9FF8h

add cx, 9CCCh ; 3. Which flags are set and why?

clc ; clear carry flag command. It 

; will be reset (logic 0).

mov dl, 0Feh ; 4. Check if any flags changed. 

Inc dl ; 5 . Which flags are set and why?

Inc dl ; 6. which flags are set and why?

stc ; set carry flag. Check if so.

mov ax, 2000h

adc ax, 0Fh ; add with carry command 

; 7. Which flags are set and why?

mov al , 08h 

mov cl, 1Fh

mul cl ; 8. Note CF and OF status 

; the following segment contains 8086 logic instructions 

mov al, 01010101b ; load binary number 

and al, 00011111b ; 9. What is result? Why? Note 

; OF, CF, PF , ZF, and SF 

or al, 11000000b ;10. What is result now?

Xor al, 00001111b ;11. What is result now?

not al ;12.What now? (1’s comp.) 

Comment# The following segment contains 8086 shift instructions 

;13 Note the status of carry flag after each of the following instructions are executed. Also note the contents of AL after each SHL instruction. You’ll notice that shifting left by one position is equivalent to multiplying by 2, and shift right by one position is same as dividing by 2. # 

mov al, 0aah

shl al,1 ;shift AL left one position

shl al,1

shl al,1

shl al,1

mov cl, 04ch ;shift AL left 4 times

shl al, cl

mov bx, 0888h

mov cl, 05

shr bx,cl ;note the contents of BX register

mov ax, 0888h

mov cl, 20h

div cl ; note the contents of AL

; they should be the same as of BX

Comment # The following program segment uses the 8086 rotate instructions. They are different from shift instructions in that the contents of carry flag are also involved in this movement.

1b. Note the contents of carry flag and the AX register after each of the following instructions is executed #

mov ax, 5555h

ror ax, 1 ; rotate right one position

ror ax, 1

ror ax, 1

ror ax, 1

mov cl, 06h ; rotate right six position

ror ax, cl

rol ax, cl ; rotate left by six 

rol ax, l ; rotate left by one position

rol ax, l

rol ax, l

mov ax, 4C00h

int 21h

order_word endp

.data

end order_word

• In the last experiment there was a program for converting a string of binary numbers into a corresponding string of gray code numbers. There were some errors in the algorithm, because of which the program only converted the numbers between 0-7 (hex) correctly into gray code numbers. It returned garbage for the numbers between 8-F (hex). In the following program, we have improved the algorithm so that it should return the correct gray code string for a string of hex numbers 0-F (hex). There are, however two bugs deliberately placed in this program find out the bugs. Use DEBUG whenever you feel necessary. It will help you great deal if you make flow chart for this program.

Title program for converting binary string to gray code string.

Dosseg

.model small

.stack 100h

.code

order_word proc

mov ax, @data

mov ds, ax ;initialize data segment register

mov si, 1000h

mov dx, 08h ;initialize the counter

mov ah, 01h ;character with echo

next_word:

int21h

cmp al, 60h ;compare instructions

jc ab_cd ;from AL but Al remains unchanged

add al, 09h ;only flag is affected

ab_cd:

and al, 0fh

mov cl, al

call code_conv

cmp cl, 0ah

jc numeral

sub cl, 09h

or cl,60h

jmp alphabet

numeral:

or cl, 30h

alphabet:

mov [si], cl

inc si

dec dx

jnz next_word

mov si, 1000h

mov cx, 08h

mov ah, 02h

previous_word:

inc si

mov dl, [si]

int 21h

dec cx

jnz previous_word

mov ax, 4c00h

int 21h

order_word endp

code_conv proc

push ax

mov bx, offset values

mov al, cl

xlat

mov cl, al

pop ax

ret

code_conv endp

.data

values db 0h,1h,3h,2h,6h,7h,5h,0ch,0dh,0fh,0eh,0ah,9h,8h

end order_word

• Try the program for finding mean square of eight decimal numbers (0-9), that you were asked to do in the bonus part of the last experiment.