354 39 Solutions Instructor Manual 15 8086 Interrupts Chapter 14

Microprocessors and Microcontrollers

Kumar, Saravanan & Jeevananthan

Chapter – 14 Addressing modes, instruction set, and Programming of 8086 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.

© 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 MOV WORD PTR [BX], 01H ; store the value of F1 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 MOV CX, n ; load CX with the value of n 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

12. Solve problem 7 assuming that the program is to be assembled by an assembler. 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). ASSUME CS: CODE, DS: DATA 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

13. Solve problem 10 assuming that the program is to be assembled by an assembler. ASSUME CS: CODE, DS: DATA 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 CX, n ; load CX with the value of n MOV BX, OFFSET ARRAY ; initialize segment and offset address registers MOV WORD PTR [BX], 00H ; store the value of F0 ADD BX,02 MOV WORD PTR [BX], 01H ; store the value of F1 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 MOV CX, n ; load CX with the value of n 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


354 39 Solutions Instructor Manual 15 8086 Interrupts Chapter 14

Recommend Documents