354 39 Solutions Instructor Manual 15 8086 Interrupts Chapter 14

Chapter14Addressingmodes,instructionset,andProgrammingof8086

Think and Answer type questions

1. Let the content of different registers in 8086 be as follows: DS=1000H, SS=2000H, ES=3000H, BX=4000H, SI=5000H, DI= 6000H and BP=7000H. Find the memory address/addresses from where the 8086 accesses the data while executing the following instructions:

a. MOV AX,[BX] - 14000H and 14001H

b. MOV BX,[SI]- 15000H and 15001H

c. MOV CX,[BP]- 27000H and 27001H

d. MOV AL,[DI]- 16000H

e. MOV BH,SS:[SI]- 25000H

f. MOV CX, ES:[DI]- 36000H and 36001H

g. MOV AX,[BX+DI]- 1A000H and 1A001H

h. MOV BX,[BP+DI+5]- 2D005H and 2D006H

i. MOV AH,[BX+10H]- 14010H

j. MOV CX, DS:[BP+4]- 17004H and 17005H

k. MOV BX,[SI-5]- 14FFBH

l. MOV AX,[BX+10]- 1400AH

2. Which registers of 8086 are modified while executing intersegment and intrasegment jump instructions?

While executing intersegment jump instruction, the content of CS and IP are modified. While executing intrasegment jump instruction, the content of IP alone is modified.

3. Is it possible to exchange the content of two memory locations or content of two segment registers using the XCHG instruction? Why?

No. It is not possible since the exchange of data can be done only between a register and a memory location.

Microprocessors and Microcontrollers Kumar, Saravanan & Jeevananthan

Oxford University Press 2011

4. If the content of BP=1000H and SI=2000H, what is the value present in CX after 8086 executes the instruction LEA CX,[BP+SI] and LEA CX,[SI].

i) 3000H

ii) 2000H

5. Is it possible to use two memory operands in ADD and SUB instructions?

No. It is not possible since it is not allowed.

6. Is carry flag affected by the execution of INC and DEC instruction in 8086?

No. Carry flag is not affected by the execution of INC and DEC instruction in 8086.

7. What is the difference between SUB and CMP instruction?

Both instructions perform subtraction of the content of the source from the content of the destination and affect the AF, OF, SF, ZF, PF and CF flags. The content of destination is not affected by CMP instruction but it is affected by the SUB instruction as the result of subtraction is stored in the destination.

8. What is the difference between TEST and AND instructions?

Both instructions perform ANDing the content of the source and the content of the destination and affect the AF, OF, SF, ZF, PF and CF flags. The content of destination is not affected by TEST instruction but it is affected by the AND instruction as the result of AND is stored in the destination..

9. Which instructions of 8086 are used to handle procedure or subroutine?

CALL and RET instructions 8086 are used to handle procedure or subroutine.

10. What is the difference between arithmetic and logical right shift?

In arithmetic right shift, the sign bit is again inserted at the left end of operand for each bit shift. In logical right shift, bit 0 is inserted at the left end of operand for each bit shift.

11. What are the common applications of left shift and right shift operations?

Left shifting a number by 1 bit multiplies a number by 2 and right shifting a number by 1 bit divides a number by 2.

Left shift is also used while multiplying two binary numbers.



Left/right shift is also used in stepper motor control.

12. When is the CL register used with shift or rotate instructions?

When the number of bits to be shifted is more than one bit, CL register is used with shift or rotate instructions

13. Consider the following pair of partial programs: i) MOV AX, 4000H ii) MOV AX, 4000H ADD AX, AX ADD AX, AX ADC AX, AX RCL AX, 1 JZ DOWN JZ DOWN

For each case, what is the data in AX after execution of third instruction and from where does the processor fetch next instruction after execution of 4th instruction?

i) AX=C000H and the processor fetches the next instruction present after JZ DOWN in the program as the ZF flag is 0 after execution of third instruction.

ii) AX= 0000H and the processor fetches the next instruction present after JZ DOWN in the program as the ZF flag is not affected after execution of third instruction and ZF flag is 0 after execution of second (i.e. ADD) instruction in the program.

14. How is the WAIT instruction used to coordinate the operation between 8086 and 8087?

When the 8086 executes the WAIT instruction, it checks the TEST pin which is connected to the BUSY output of 8087. If the TEST pin is high, the 8086 keeps waiting until TEST pin becomes low. As long as the 8087 executes the floating point instruction, it keeps the BUSY pin high and hence the 8086 also waits. When the floating point instruction is completely executed by 8087, it makes its BUSY pin low and WAIT instruction in 8086 will be treated as NOP instruction.

Programming Exercises:

1. Write 8086 assembly language program to find the sum of 100 words present in an array stored from the address 3000H:1000H in data segment and store the result from the address 3000H:2000H.

Solution: If all the words in the array is equal to FFFFH (max. value of a word), the result will be 63FF9CH. Hence the result will have maximum of 3 bytes.

MOV CX, 100

MOV AX, 3000H



MOV DS, AX

MOV BL,00H ; BL is used to accumulate the carry generated in the addition

MOV AX,0000H

MOV SI,1000H

L1: ADD AX, [SI]

JNC NO_CARRY

INC BL

NO_CARRY: ADD SI,02H

LOOP L1

MOV DI,2000H

MOV [DI],AX ; Storing lower word of the result in AX in memory

MOV [DI+2], BL

HLT

2. Write 8086 assembly language program to find the prime numbers among 100 bytes of data in an array stored from the address 4000H:1000H in the data segment and store the result from the address 4000H:3000H.

Algorithm:

Each byte in the array (say N) is first compared with 1 and 2. If the byte N is equal to 1 or 2, it is stored as a prime number. If the byte N in the array is above 2, then the byte is divided from the value 2 to N-1 one by one and if the byte N gets divided by any one number during this operation, then it is not a prime number.

For example, if the byte is equal to 05H , then 05H is divided by 2, 3 and 4 one by one. If the remainder is 0 in any one division then it is not a prime number.

MOV AX, 4000H

MOV DS,AX

MOV SI,1000H

MOV CX,100 ; CX= NO. OF BYTES IN THE ARRAY



MOV BX,3000H ; BX= OFFSET ADDRESS OF RESULT

CHECK: MOV AH,00

MOV AL,[SI] ; GET ONE DATA (=N) FROM ARRAY

CMP AL,01H

JZ PRIME; IF NUMBER IS EQUAL TO 1, GOTO PRIME

CMP AL,02H

JZ PRIME

DEC AL; FIND N-1

MOV DH, AL; STORE N-1 IN DH

MOV DL,02H ; START DIVIDING THE BYTE N FROM 2 TO N-1 ONE BY ONE

DIVIDE: MOV AH,00H

MOV AL,[SI] ; Get the byte N again in AL

DIV DL

CMP AH,00H; CHECK REMAINDER IS ZERO

JZ NEXT; IF ZERO THEN NOT A PRIME NUMBER, GOTO NEXT

INC DL

CMP DL,DH

JBE DIVIDE

PRIME: MOV AL,[SI] ; Get the byte N again in AL for storing

MOV [BX],AL

INC BX

NEXT: INC SI

LOOP CHECK

HLT



3. Write 8086 assembly language program to find the number of occurrences of the character A among 50 characters of a string type data stored from the address 5000H:1000H in data segment and store the result in the address 2000H:5000H.

MOV CX,50

MOV AX, 5000H

MOV ES,AX

MOV DI, 1000H

CLD

MOV BL,00H; BL is used to store number of occurrence of A

MOV AL, A

L1: SCASB

JNZ NO_MATCH

INC BL

NO_MATCH: LOOP L1

MOV AX,2000H

MOV DS,AX

MOV [5000H], BL

HLT

4. Write 8086 assembly language program to check whether the two strings, one stored from the address 2000H:1000H in data segment and the other stored from the address 2000H:3000H are equal or not . If they are equal, store the value 00H in AL otherwise store the value 01H in AL.

Let us assume that both strings are having 5 characters each.

MOV AX, 2000H

MOV DS,AX

MOV ES,AX

MOV SI, 1000H



MOV DI,3000H

CLD

MOV CX,5

REPE CMPSB

JCXZ L1

L3: MOV AL,01H

JMP L2

L1: JNZ L3

MOV AL,00H

L2: HLT

5. Write 8086 assembly language program to find the number of bytes that have the hexadecimal digit F in its upper nibble among 100 bytes of data in an array stored from the address 8000H:1000H in data segment and store the result in the address 8000H:3000H.

MOV AX, 8000H

MOV DS,AX

MOV CX,100

MOV SI,1000H

MOV BX,3000H

AGAIN: AND [SI],F0H

CMP [SI], F0H

JNZ NEXT

INC BYTE PTR [BX]

NEXT: INC SI

LOOP AGAIN



HLT

6. Write 8086 assembly language program to complement the lower nibble of each byte in 100 bytes of data in an array stored from the address 8000H:1000H in the data segment and store the result from the address 8000H:3000H.

MOV AX, 8000H

MOV DS,AX

MOV CX,100

MOV SI,1000H

MOV BX,3000H

AGAIN: MOV AL,[SI]

XOR AL, 0FH

MOV [BX], AL

INC SI

INC BX

LOOP AGAIN

HLT

7. Write 8086 assembly language program to add two matrices having word type data in each element of the matrix. Assume that each element of the result after addition of the corresponding elements of the matrix is also word type data. The data for one matrix is present in an array stored from the address 8000H:1000H in the data segment and the corresponding data for another matrix is present in an array stored from the address 8000H:2000H in data segment. The result is to be stored from the address 7000H:1000H.

Let the matrices to be added are 2x2 matrices and the elements of first matrix namely (1,1),(1,2), (2,1) and (2,2) are stored from the address 8000H:1000H successively. Let the elements of second matrix namely (1,1),(1,2), (2,1) and (2,2) are stored from the address 8000H:2000H successively. Let the elements of resultant



matrix namely (1,1),(1,2), (2,1) and (2,2) are stored from the address 7000H:1000H successively.

MOV AX, 8000H

MOV DS,AX

MOV CX,4

MOV SI, 1000H

MOV BX, 2000H

AGAIN: MOV AX, [SI]

ADD AX, [BX]

MOV DX, 7000H

MOV DS, DX

MOV [SI], AX

MOV AX, 8000H

MOV DS,AX

ADD SI,02H

ADD BX,02H

LOOP AGAIN

HLT

8. Write 8086 assembly language program to multiply two square matrices having byte type data for each element of the matrix. Assume that each element of the resultant matrix is of word type. The data for one matrix is present in an array stored from the address 8000H:1000H in the data segment and the corresponding data for other matrix is present in an array stored from the address 8000H:2000H in the data segment. The result is to be stored from the address 7000H:1000H.

Let the matrices to be multiplied are 2x2 square matrices namely A and B and the resultant matrix is C. The elements of A and B matrices are stored in the following addresses:

Element A B C



(1,1) 8000H:1000H 8000H:2000H 7000H:1000H

(1,2) 8000H:1001H 8000H:2001H 7000H:1002H

(2,1) 8000H:1002H 8000H:2002H 7000H:1004H

(2,2) 8000H:1003H 8000H:2003H 7000H:1006H

MOV AX,8000H

MOV DS,AX

MOV SI, 1000H

MOV BX,2000H

MOV AL, [SI] ; To find element (1,1) of C

MUL [BX]

MOV CX, AX

MOV AL, [SI+1]

MUL [BX+2]

ADD AX,CX

PUSH DS

MOV DX, 7000H

MOV DS, DX

MOV [SI], AX

POP DS

MOV AL, [SI] ; To find element (1,2) of C

MUL [BX+1]

MOV CX, AX

MOV AL, [SI+1]

MUL [BX+3]



ADD AX,CX

PUSH DS

MOV DX, 7000H

MOV DS, DX

MOV [SI+2], AX

POP DS

MOV AL, [SI+2] ; To find element (2,1) of C

MUL [BX]

MOV CX, AX

MOV AL, [SI+3]

MUL [BX+2]

ADD AX,CX

PUSH DS

MOV DX, 7000H

MOV DS, DX

MOV [SI+4], AX

POP DS

MOV AL, [SI+2] ; To find element (2,2) of C

MUL [BX+1]

MOV CX, AX

MOV AL, [SI+3]

MUL [BX+3]

ADD AX,CX

MOV DX, 7000H

MOV DS, DX



MOV [SI+6], AX

HLT

9. Write 8086 assembly language program to find the factorial of the given byte of data using recursive algorithm. The result is to be stored at the address 7000H:1000H.

The factorial of 0 or 1 is equal to 1. In general, the factorial of a number n is obtained by multiplying n with the factorial of (n-1). The factorial of the number (n-1) is obtained by multiplying (n-1) with the factorial of (n-2). This is repeated until the factorial of one has to be found which is equal to 1. For example to find factorial of 3 which is denoted by 3!, the following steps are done:

3! = 3 x 2! = 3 x (2 x 1!) = 3 x 2 x 1 = 6

The following program finds the factorial of the number n which is any one number between 0 to 8 (since its result is 16 bits) using the above technique. It uses stack and BP register to store and retrieve the temporary results obtained while executing the same factorial subroutine again and again which is known as recursive procedure.

MOV AX, n ; Load AX with the number n whose factorial has to be found

SUB SP,02; make space for one word output (factorial value)

PUSH AX ; push input parameter n into stack

CALL FACT ; call the FACT recursive subroutine

ADD SP,02; clear the stack of the input (i.e. to undo the PUSH AX above)

POP AX; get the result (i.e. factorial value) in AX

HLT ; Halt

;recursive procedure FACT starts here

FACT: PUSH BP ;BP is the frame pointer (defaulting to stack segment), so save its old

value belonging to the calling process and make space to have its new

value

MOV BP,SP; BP is now the (new) frame pointer for the subroutine



PUSH AX ; stack space of subroutine is used to save registers AX,BX,DX

PUSH BX

PUSH DX

MOV BX, [BP+4]; get the value of n which is at [BP+4] in BX

MOV AX,01; prepare for checking termination condition

CMP AX,BX; check for termination

JAE TERMI; If AX is above or equal to BX, (i.e. if n= 0 or 1) go to label TERMI

; the result is already in register AX.

DEC BX ; else prepare to recursively call FACT (n-1)

SUB SP,2; make space for output of the procedure for FACT (n-1)

PUSH BX; input to the procedure to find FACT (n-1)

CALL FACT ; recursive call

ADD SP,2; discard the input variable of the called procedure

POP AX; get FACT (n-1) in AX, output of the called procedure

MOV BX,[BP+4]; get the input variable to this procedure, n, in BX.

MUL BX; The product n* FACT (n-1) goes to DX:AX, but DX will be 0 since

the result is 16 bits only.

TERMI: MOV [BP+6], AX; store the result in AX in the output space provided in the

stack frame. In case n is 1 or 0, we directly come here with

the result 1 in AX.

POP DX ; retrieve the saved registers from stack and clean the procedure stack

POP BX

POP AX

MOV SP,BP; ensure that stack is clean

POP BP ; get back the original BP



RET; procedure over, go back to the calling program

10. Write a non-recursive assembly language subroutine of 8086, to evaluate the number

Fn = Fn-1 + Fn-2 for any given n > 1 given that F0 = 0 and F1 = 1. Consider the number n to be such that Fn is not more than a 16 bit number.

The result will be within 16 bits only when the value of n is 24. Hence the maximum value of n is 24 in this program. The logic used in the program is as follows:

First according to the value of n, the function value from F0, F1, F2,.. up to Fn-1 are calculated and successively stored in memory from the address 1000H:1000H in the form of words. Then the last two words in the memory (i.e. Fn-1 and Fn-2) are added to get the result.

MOV CX, n ; load CX with the value of n

MOV BX,1000H ; initialize segment and offset address registers

MOV DS,BX

MOV WORD PTR [BX], 00H ; store the value of F0

ADD BX,02


SUB CX, 02 ; check whether n is equal to 2

JZ ZERO ; if cx=n=2 then go to label ZERO to perform addition of F0 & F1

;else find the remaining values of F using following loop L1

L1: MOV AX, [BX] ; get last calculated value of F

ADD AX, [BX-2] ; add it with the previously calculated value of F

ADD BX,2 ; Increment pointer BX to store next value of F in memory

MOV [BX],AX ; store the newly calculated function value

DEC CX ; decrement CX

JNZ L1; if CX is not zero, find the next value of F by jumping to L1



ZERO: MOV BX,1000H ; initialize BX to point the first location


DEC CX ; decrement CX by 1

ADD CX,CX ; multiply CX by 2 since each function is stored in the form of

;word

ADD BX, CX ; add BX with CX to get the location of Fn-1

MOV AX, [BX] ; get the value of Fn-1 in AX

ADD AX, [BX-2] ; add Fn-1 and Fn-2 to get Fn which is in AX

HLT ; Stop

11. Solve problem 1 assuming that the program is to be assembled by an assembler.

The problem is to write 8086 assembly language program to find the sum of 100 words present in an array stored in data segment and store the result in data segment assuming that the program is to be assembled by an assembler.

ASSUME CS: CODE, DS: DATA

DATA SEGMENT

ARRAY DW 2000H, 3000H, 5000H,.. ; 100 WORDS ARE STORED HERE

RESULT_LSW DW 0000H ; RESERVE SPACE FOR STORING RESULT

RESULT_MSB DB 00H

DATA ENDS

CODE SEGMENT

START: MOV AX, DATA

MOV DS,AX

MOV CX, 100

MOV BL,00H ; BL is used to accumulate the carry generated in the addition



MOV AX,0000H

MOV SI, OFFSET ARRAY

L1: ADD AX, [SI]

JNC NO_CARRY

INC BL

NO_CARRY: ADD SI,02H

LOOP L1

MOV RESULT_LSW, AX ; Storing lower word of the result in AX in memory

MOV RESULT_MSB, BL ; Storing the upper byte of the result in BL in memory

MOV AH,4CH

INT 21H

CODE ENDS

END START


Let the matrices to be added are 2x2 matrices and the elements of first matrix namely (1,1),(1,2), (2,1) and (2,2) are first stored successively in the data segment. Let the elements of second matrix namely (1,1),(1,2), (2,1) and (2,2) are stored next successively in the data segment. This is followed by memory space for storing the elements of resultant matrix namely (1,1),(1,2), (2,1) and (2,2).


DATA SEGMENT

MATRIX_A DW 2000H, 3000H, ; Elements of Matrix A are stored here

MATRIX_B DW 1000H, 3000H ; Elements of Matrix B are stored here

RESULT_MATRIX DW 4 DUP (0)

DATA ENDS

CODE SEGMENT

START: MOV AX, DATA



MOV DS,AX

MOV CX,4

MOV SI, OFFSET MATRIX_A

MOV BX, OFFSET MATRIX_B

MOV DI, OFFSET RESULT_MATRIX

AGAIN: MOV AX, [SI]

ADD AX, [BX]

MOV [DI], AX

ADD SI,02H

ADD BX,02H

ADD DI,02H

LOOP AGAIN

MOV AH,4CH

INT 21H

CODE ENDS

END START



DATA SEGMENT

ARRAY DW 25 DUP (0); reserve 25 words to store different function values

RESULT DW 1 DUP (0); reserve one word for storing result

DATA ENDS

CODE SEGMENT

START: MOV AX, DATA



MOV DS,AX


MOV BX, OFFSET ARRAY ; initialize segment and offset address registers


ADD BX,02


SUB CX, 02 ; check whether n is equal to 2

JZ ZERO ; if cx=n=2 then go to label ZERO to perform addition of F0 & F1

;else find the remaining values of F using following loop L1

L1: MOV AX, [BX] ; get last calculated value of F in AX

ADD AX, [BX-2] ; add it with the previously calculated value of F

ADD BX,2 ; Increment pointer BX to store next value of F in memory

MOV [BX],AX ; store the newly calculated function value

DEC CX ; decrement CX

JNZ L1; if CX is not zero, find the next value of F by jumping to L1

ZERO: MOV BX, OFFSET ARRAY ; initialize BX to point the first location


DEC CX ; decrement CX by 1

ADD CX,CX ; multiply CX by 2 since each function is stored in the form of

;word

ADD BX, CX ; add BX with CX to get the location of Fn-1

MOV AX, [BX] ; get the value of Fn-1 in AX

ADD AX, [BX-2] ; add Fn-1 and Fn-2 to get Fn



MOV RESULT, AX ; store AX in the location RESULT

MOV AH,4CH

INT 21H

CODE ENDS

END START



Documents

354 39 Solutions Instructor Manual 15 8086 Interrupts Chapter 14