1) Identify the addressing modes used in the following instructions: [4 POINTS]
a. MOV AX, [BX]:
b. MOV AX, [SI+5]:
c. MOV AX, CS: [BX+SI]:
d. JE END:
e. MOV CX, [BX+DI+5]:
a. MOV AX, [BX]: Indirect addressing mode
b. MOV AX, [SI+5]: Indexed addressing mode
c. MOV AX, CS:[BX+SI]: Base-index addressing mode
d. JE END: Relative addressing mode
e. MOV CX, [BX+DI+5]: Indexed addressing mode
2) Consider the following program segment and the variables declaration given below: [4 POINTS]
ORG 0400
MOV BX, MICRO1
MOV DI, MICRO1
MOV AX, [BX]
MOV DX, [DI + 2]
ADD AX, DX
XCHG AX, DX
MOV WORD[MICRO1], AX
MOV WORD [MICRO2], DX
INT3
MICRO1 DW 5566H
MICRO2 DW AABBH
After executing the above code what would be content of locations MICRO1 and MICRO2? You must show your work.
Given the program segment and variable declaration:
ORG 0400
MOV BX, MICRO1
MOV DI, MICRO1
MOV AX, [BX]
MOV DX, [DI + 2]
ADD AX, DX
XCHG AX, DX
MOV WORD[MICRO1], AX
MOV WORD [MICRO2], DX
INT3
MICRO1 DW 5566H
MICRO2 DW AABBH
Let's analyze the code step by step:
1. MOV BX, MICRO1: BX is loaded with the address of MICRO1, which is 040E in this case.
2. MOV DI, MICRO1: DI is also loaded with the address of MICRO1, which is 040E.
3. MOV AX, [BX]: AX is loaded with the value at the address stored in BX, which is the value at 040E.
4. MOV DX, [DI + 2]: DX is loaded with the value at the address stored in DI plus 2, which is the value at 0410.
5. ADD AX, DX: The values in AX and DX are added together.
6. XCHG AX, DX: The values in AX and DX are exchanged.
7. MOV WORD[MICRO1], AX: The value in AX is stored at the address MICRO1, which is 040E.
8. MOV WORD [MICRO2], DX: The value in DX is stored at the address MICRO2, which is 0410.
9. INT3: Program interruption.
After executing the code, the content of locations MICRO1 and MICRO2 will be:
- MICRO1: 040E (same as initial value)
- MICRO2: 0410 (same as initial value)
The code does some operations on the values in the memory locations, but it does not modify the content of the locations MICRO1 and MICRO2.
3) Consider the following code and the variables declared in the memory: [5 POINTS]
MOV BX, QUIZ3
MOV SI, 02H
MOV DX, 08H
INC [BX + 2]
MOV AX, [BX+SI+0]
MOV DI, 04H
ADD DX, [BX+DI+8]
SUB AX, [BX+SI+6]
DEC AX
MOV WORD[RESULT], AX
INT3
QUIZ3 DW 05H, 09H,56H,67H,09H, AAH, BBH, 17H, 19H, 45H
RESULT DW ?
After executing the above code what would be the content of AX, DX, and RESULT location? You must show your work.
Given the code and variable declaration:
MOV BX, QUIZ3
MOV SI, 02H
MOV DX, 08H
INC [BX + 2]
MOV AX, [BX + SI + 0]
MOV DI, 04H
ADD DX, [BX + DI + 8]
SUB AX, [BX + SI + 6]
DEC AX
MOV WORD[RESULT], AX
INT3
QUIZ3 DW 05H, 09H, 56H, 67H, 09H, AAH, BBH, 17H, 19H, 45H
RESULT DW ?
Let's analyze the code step by step:
1. MOV BX, QUIZ3: BX is loaded with the address of QUIZ3, which is 040E in this case.
2. MOV SI, 02H: SI is loaded with the value 02H.
3. MOV DX, 08H: DX is loaded with the value 08H.
4. INC [BX + 2]: The value at the address BX + 2 is incremented. In this case, it increments the value 56H to 57H.
5. MOV AX, [BX + SI + 0]: AX is loaded with the value at the address BX + SI + 0. In this case, it loads the value 67H.
6. MOV DI, 04H: DI is loaded with the value 04H.
7. ADD DX, [BX + DI + 8]: The value at the address BX + DI + 8 is added to DX. In this case, it adds the value 19H to 08H, resulting in 21H.
8. SUB AX, [BX + SI + 6]: The value at the address BX + SI + 6 is subtracted from AX. In this case, it subtracts the value 19H from 67H, resulting in 4EH.
9. DEC AX: AX is decremented by 1. In this case, it decrements the value 4EH to 4DH.
10. MOV WORD[RESULT], AX: The value in AX is stored at the address RESULT.
11. INT3: Program interruption.
After executing the code, the content of AX would be 4DH, the content of DX would be 21H, and the content of the RESULT location would also be 4DH.
Consider the following code and the memory. [5 POINTS]
CPU 8086
ORG 0400
MOV SP, 0480H
MOV AX, 67H
MOV BX, 89H
ADD AX, BX
MOV WORD[DATA1], AX
PUSH WORD[DATA1]
DEC AX
PUSH AX
PUSH BX
POP WORD [DATA1]
POP BX
POP AX
INT3
DATA1 DW?
After executing the above code, determine the content of:
AX =?
BX =?
[DATA1] =?
You must show your work.
Given the code and memory:
CPU 8086
ORG 0400
MOV SP, 0480H
MOV AX, 67H
MOV BX, 89H
ADD AX, BX
MOV WORD[DATA1], AX
PUSH WORD[DATA1]
DEC AX
PUSH AX
PUSH BX
POP WORD [DATA1]
POP BX
POP AX
INT3
DATA1 DW?
Let's analyze the code step by step:
1. MOV SP, 0480H: Stack pointer (SP) is loaded with the value 0480H.
2. MOV AX, 67H: AX is loaded with the value 67H.
3. MOV BX, 89H: BX is loaded with the value 89H.
4. ADD AX, BX: The values in AX and BX are added together. 67H + 89H = F0H.
5. MOV WORD[DATA1], AX: The value in AX (F0H) is stored at the address DATA1.
6. PUSH WORD[DATA1]: The value at the address DATA1 (F0H) is pushed onto the stack.
7. DEC AX: AX is decremented by 1. F0H - 1 = EFH.
8. PUSH AX: The value in AX (EFH) is pushed onto the stack.
9. PUSH BX: The value in BX (89H) is pushed onto the stack.
10. POP WORD [DATA1]: The top of the stack is popped and stored at the address DATA1.
11. POP BX: The value on top of the stack (89H) is popped into BX.
12. POP AX: The value on top of the stack (EFH) is popped into AX.
13. INT3: Program interruption.
After executing the code, the content of:
- AX = EFH
- BX = 89H
- [DATA1] = F0H
5) Write a segment program to exchange contents of AX and BX registers without using the MOV/XCHNG or other instructions. You must use the stack to do so. [2 POINTS]
Here is a segment of assembly code that exchanges the contents of AX and BX registers using the stack:
```
ORG 0400
PUSH AX ; Push contents of AX onto the stack
PUSH BX ; Push contents of BX onto the stack
POP AX ; Pop the top of the stack into AX, which was originally BX
POP BX ; Pop the second element of the stack into BX, which was originally AX
INT3 ; Program interruption
END
```
In this code segment, the values of AX and BX are pushed onto the stack in reversed order. Then, the top of the stack is popped into AX, and the second element of the stack is popped into BX. This effectively exchanges the contents of AX and BX registers without using the MOV or XCHG instructions.
To identify the addressing modes used in the given instructions, we need to analyze the syntax and operands of each instruction.
a. MOV AX, [BX]:
In this instruction, the square brackets [] indicate indirect addressing mode. The content of the memory location addressed by the value in the register BX is moved into the AX register. Therefore, the addressing mode used here is indirect addressing.
b. MOV AX, [SI+5]:
Similar to the previous instruction, this instruction also uses indirect addressing. The content of the memory location addressed by the sum of the value in the SI register and 5 is moved into the AX register. Therefore, the addressing mode used here is indirect addressing with displacement.
c. MOV AX, CS: [BX+SI]:
In this instruction, we have two addressing modes involved. We first have the segment register CS followed by indirect addressing. The segment register specifies the segment of memory to use, while the indirect addressing mode specifies the displacement based on the sum of the values in the registers BX and SI. Therefore, the addressing modes used here are segment and indirect addressing with displacement.
d. JE END:
This instruction is an example of a control transfer instruction called "Jump if Equal" (JE). It does not involve any specific addressing mode as it is used to modify the program flow based on a condition.
e. MOV CX, [BX+DI+5]:
Similar to the previous instructions, this instruction uses indirect addressing with displacement. The content of the memory location addressed by the sum of the values in the registers BX, DI, and 5 is moved into the CX register. Therefore, the addressing mode used here is indirect addressing with displacement.
In summary, the addressing modes used in the given instructions are as follows:
a. Indirect addressing
b. Indirect addressing with displacement
c. Segment addressing and indirect addressing with displacement
d. No specific addressing mode (control transfer instruction)
e. Indirect addressing with displacement