Question 1: Explain the concept of Interrupts in 8086 with suitable examples.

●​ Describe the different types of interrupts (hardware and software).

●​ Explain the interrupt vector table.
●​ Provide examples of interrupt usage (e.g., keyboard input, timer interrupts).
Answer:
●​ Concept: Interrupts are a mechanism that allows the 8086 microprocessor to respond to
events asynchronously. Instead of the CPU constantly checking (polling) devices, an
interrupt signals the CPU to suspend its current task, handle the interrupting event, and
then resume the original task.
●​ Types of Interrupts:
○​ Hardware Interrupts: These are triggered by external hardware devices. The 8086
has two pins dedicated to hardware interrupts:
■​ INTR (Interrupt Request): This is a maskable interrupt. The CPU can
choose to ignore it using the Interrupt Flag (IF) in the flags register.
■​ NMI (Non-Maskable Interrupt): This interrupt cannot be ignored by the CPU.
It is typically used for critical events like memory errors.
■​ Examples:
■​ Keyboard input: Pressing a key triggers a hardware interrupt.
■​ Timer interrupts: A timer chip signals the CPU at regular intervals.
■​ Disk controller: When a disk operation is complete, an interrupt may be
generated.
○​ Software Interrupts: These are triggered by the INT n instruction within a program,
where 'n' is the interrupt type number (0-255).
■​ Examples:
■​ Operating system services: Programs use software interrupts to
request services from the OS (e.g., file I/O).
■​ Debugging: Debuggers can use interrupts for breakpoints.
●​ Interrupt Vector Table (IVT):
○​ The IVT is a table in low memory (starting at address 00000h) that stores the
addresses of Interrupt Service Routines (ISRs).
○​ Each interrupt type (0-255) has a 4-byte entry in the IVT: 2 bytes for the offset
address and 2 bytes for the segment address of the ISR.
○​ When an interrupt occurs, the CPU uses the interrupt type number to index into the
IVT and retrieve the address of the corresponding ISR.
●​ Examples of Interrupt Usage:
○​ Keyboard Input:
1.​ A key press generates a hardware interrupt.
2.​ The CPU determines the interrupt type.
3.​ The CPU fetches the ISR address from the IVT.
4.​ The CPU executes the ISR to read the keystroke.
5.​ The ISR returns control to the interrupted program.
○​ Timer Interrupts:
1.​ A timer chip generates an interrupt signal periodically.
2.​ The CPU uses the IVT to find the timer ISR.
3.​ The ISR can update a system clock, schedule tasks, etc.
Question 2: Discuss the working of the address and data buses in 8086.
●​ Explain the function of the address bus and its width.
●​ Explain the function of the data bus and its width.
 ●​ Illustrate how the address and data buses are used for memory access.
Answer:
●​ Address Bus:
○​ Function: The address bus is used to specify the memory location or I/O port that
the CPU wants to access. It is unidirectional (CPU to memory/I/O).
○​ Width: The 8086 has a 20-bit address bus. This allows it to address 1MB
(2²⁰ bytes) of memory. The 8086 achieves this 20-bit address using
segment registers and offset addresses.
●​ Data Bus:
○​ Function: The data bus is used to transfer data between the CPU, memory, and
I/O devices. It is bidirectional.
○​ Width: The 8086 has a 16-bit data bus, meaning it can transfer 16 bits of data at a
time.
●​ Memory Access:
○​ Reading from Memory:
1.​ The CPU calculates the physical memory address using a segment register
and an offset. It places this 20-bit address on the address bus.
2.​ The memory system decodes the address.
3.​ The memory system puts the data from the addressed location onto the data
bus.
4.​ The CPU reads the data from the data bus.
○​ Writing to Memory:
1.​ The CPU calculates the physical memory address and places it on the
address bus.
2.​ The CPU places the data to be written on the data bus.
3.​ The memory system decodes the address.
4.​ The memory system writes the data from the data bus into the addressed
memory location.
Question 3: Explain the purpose of Stack Pointer (SP) and Base Pointer (BP) in 8086.
●​ Describe the role of the stack in subroutine calls and interrupt handling.
●​ Explain how SP is used to manage the stack.
●​ Explain how BP is used to access parameters and local variables on the stack.
Answer:
●​ Role of the Stack: The stack is a LIFO (Last-In, First-Out) memory area.
○​ Subroutine Calls:
■​ The CALL instruction pushes the return address onto the stack.
■​ The RET instruction pops the return address from the stack to return to the
caller.
■​ Subroutines can also use the stack to save registers and allocate local
variables.
○​ Interrupt Handling:
■​ When an interrupt occurs, the CPU automatically pushes the flags register
and the return address onto the stack.
■​ The IRET instruction is used to return from an ISR, and it pops the return
address and flags from the stack.
●​ Stack Pointer (SP):
○​ Management: The SP register holds the offset of the top of the stack within the
stack segment (SS). The stack grows downwards in memory.
 ○​ Usage:
■​ PUSH decrements SP and then stores the data.
■​ POP retrieves the data and then increments SP.
●​ Base Pointer (BP):
○​ Usage: BP is used to provide a convenient way to access function parameters and
local variables within a stack frame.
○​ Advantage: SP changes during function execution, but BP, if set at the beginning of
the function, provides a fixed reference point for accessing data on the stack.
Question 4: Describe the concept of pipelining and instruction pipeline in
microprocessors.
●​ Define pipelining and its benefits.
●​ Explain the stages of an instruction pipeline (e.g., fetch, decode, execute).
●​ Discuss potential pipeline hazards (e.g., data hazards, control hazards).
Answer:
●​ Pipelining:
○​ Definition: Pipelining is a technique that overlaps the execution of multiple
instructions. Each instruction is broken down into stages, and different instructions
are in different stages at the same time.
○​ Benefits:
■​ Increased throughput: The number of instructions completed per unit of time
increases.
■​ Improved performance: Overall execution speed is improved.
●​ Stages of an Instruction Pipeline: Common stages include:
○​ Fetch (IF): Retrieve the instruction from memory.
○​ Decode (ID): Decode the instruction and fetch operands.
○​ Execute (EX): Perform the operation.
○​ Write Back (WB): Write the result to a register.
●​ Pipeline Hazards:
○​ Data Hazards: Occur when an instruction depends on the result of a previous
instruction that is still in the pipeline.
■​ Example:​
ADD AX, BX​
SUB CX, AX ; SUB needs result from ADD​

○​ Control Hazards: Occur due to branch instructions. The next instruction's address
may not be known until the branch is executed.
■​ Example:​
JNZ target ; If not zero, jump​
; Instructions here might be wrong​
target:​
; Correct instructions​

Question 5: Draw a flowchart for finding the largest number in an array.

●​ Provide a clear flowchart with start, end, and decision points.
●​ Use appropriate symbols to represent operations and data flow.
Answer:
+-------+​
| Start |​
 +-------+​
|​
V​
+----------+​
| max = array[0] |​
+----------+​
|​
V​
+----------+​
| i = 1 |​
+----------+​
|​
V​
+---------------+​
| i < array.length? |​
+---------------+​
| Yes​
V​
+-----------------+​
| array[i] > max? |​
+-----------------+​
| Yes​
V​
+-------------+​
| max = array[i] |​
+-------------+​
|​
V​
+----------+​
| i = i + 1 |​
+----------+​
|​
^ No​
|​
+-------+​
| Print max |​
+-------+​
|​
V​
+-------+​
| End |​
+-------+​

Question 6: Write an 8086 program to load a value from memory location 2000h into AX
and display.
●​ Include the 8086 assembly code.
●​ Provide screenshots of the Emu8086 output showing the value in AX.
ORG 100h​
​
MOV AX, 2000h ; Load segment address into AX​
MOV DS, AX ; Set Data Segment register​
​
MOV AX, [0] ; Load word from DS:0000 into AX (2000:0000)​
​
; Code to display AX (using Emu8086's features)​
; ... (Emu8086 display code) ...​
​
MOV AH, 4Ch​
INT 21h​

Question 7: Write an 8086 program to copy contents of AX register into five consecutive
memory locations.
●​ Include the 8086 assembly code.
●​ Provide screenshots of the Emu8086 memory view showing the copied values.
ORG 100h​
​
MOV AX, 1234h ; Example value​
MOV BX, 3000h ; Starting segment address​
MOV DS, BX ; Set Data Segment register​
​
MOV [0], AX​
MOV [2], AX​
MOV [4], AX​
MOV [6], AX​
MOV [8], AX​
​
MOV AH, 4Ch​
INT 21h​

Question 8: Write an 8086 program to find the sum of digits of a 2-digit number.
●​ Include the 8086 assembly code.
●​ Provide screenshots of the Emu8086 output showing the sum.
ORG 100h​
​
MOV AX, 45h ; Example number (assuming decimal for simplicity)​
MOV BL, 10 ; Divisor​
XOR DX, DX ; Clear DX for division​
​
DIV BL ; AX = quotient, DX = remainder​
MOV CL, AL ; Save ones digit​
MOV AL, AH ; Move tens digit to AL​
ADD AL, CL ; Sum digits​
​
; Result is in AL​
​
MOV AH, 4Ch​
 INT 21h​

Question 9: Write an 8086 program to calculate the difference between two hexadecimal
numbers.
●​ Include the 8086 assembly code.
●​ Provide screenshots of the Emu8086 output showing the difference.
ORG 100h​
​
MOV AX, 50h ; Example number 1​
MOV BX, 20h ; Example number 2​
​
SUB AX, BX ; AX = AX - BX​
​
; Result in AX​
​
MOV AH, 4Ch​
INT 21h​

Question 10: Write an 8086 program to calculate the product of elements in an array of
five numbers.
●​ Include the 8086 assembly code.
●​ Provide screenshots of the Emu8086 output showing the product.
ORG 100h​
​
MOV CX, 5 ; Array size​
MOV SI, 4000h ; Array address​
MOV DS, SI ; Set Data Segment​
​
MOV AX, 1 ; Initialize product to 1 (important!)​
​
LOOP_START:​
MOV BX, [SI] ; Get array element​
MUL BX ; Multiply with product​
ADD SI, 2 ; Next word​
LOOP LOOP_START ; Repeat CX times​
​
; Result in AX​
​
MOV AH, 4Ch​
INT 21h​