Assembly Language Program

Download as docx, pdf, or txt
Download as docx, pdf, or txt
You are on page 1of 8

Machine Organization and Assembly Language Programming Assignment

1. Write an assembly program to find the factorial of the first 5 numbers


and display the result on the screen.

2. List and describe addressing modes types with 1 example for each type.

A. Immediate Addressing:

* The operand is directly specified within the instruction itself.


* Example: MOV AX, 5 ; Load the value 5 into register AX

B. Direct Addressing:

* The operand's memory address is given explicitly in the instruction.


* Example: MOV BX, [1000h] ; Load the value stored at memory address
1000h into register BX

C. Register Addressing:

* The operand is located in a CPU register.


* Example: ADD AX, BX ; Add the values in registers AX and BX, store the
result in AX

D. Register Indirect Addressing:

* The operand's memory address is stored in a register.


* Example: MOV CX, [BX] ; Load the value from the memory address
pointed to by register BX into register CX

E. Indexed Addressing:

* The operand's memory address is calculated by adding a base address


(specified in the instruction) to an index value (usually stored in a register).
* Example: MOV DX, [ARRAY + SI] ; Load the value from the element of
array ARRAY whose offset is specified by register SI into register DX

F. Base Register Addressing:

* Similar to indexed addressing, but the base address is stored in a designated


base register.
* Example: MOV AL, [BP + OFFSET] ; Load the value from the memory
location relative to the base address in register BP into register AL

G. Auto-Increment/Decrement Addressing:

* The register used for indirect addressing is automatically incremented or


decremented after the operand is accessed.
* Example: INC [DI] ; Increment the value stored at the memory address
pointed to by register DI, then increment DI itself

H. Implicit Addressing:

* The operand is implicitly specified by the instruction itself, often involving


accumulator registers.
* Example: PUSH AX ; Push the value in register AX onto the stack (implied
operand is the stack pointer register)

I. Relative Addressing:

* The operand's memory address is calculated relative to the current program


counter (PC).
* Example: JMP LOOP ; Jump to a label named "LOOP" relative to the
current instruction

3. Explain data transfer, Arithmetic and logical instruction with example

Data Transfer Instructions:

* Purpose: Move data between registers, memory locations, and I/O ports.
* Examples:
- MOV AX, BX (moves the value in register BX to register AX)
- MOV [1000h], CX (moves the value in register CX to memory address
1000h)
- IN AL, 60h (reads a byte from I/O port 60h into register AL)
- OUT 40h, DX (sends a byte from register DX to I/O port 40h)

Arithmetic Instructions:

* Purpose: Perform arithmetic operations on data.


* Examples:
- ADD AX, BX (adds the values in registers AX and BX, stores the result in
AX)
- SUB CX, DX (subtracts the value in register DX from register CX, stores
the result in CX)
- MUL BX (multiplies the value in register AX by the value in register BX,
stores the 16-bit result in DX:AX)
- DIV CX (divides the value in DX:AX by the value in register CX, stores
the quotient in AX and remainder in DX)

Logical Instructions:

* Purpose: Perform bitwise logical operations on data.


* Examples:
- AND AX, BX (performs a bitwise AND operation on the values in
registers AX and BX, stores the result in AX)
- OR CX, DX (performs a bitwise OR operation on the values in registers
CX and DX, stores the result in CX)
- XOR BX, CX (performs a bitwise XOR operation on the values in registers
BX and CX, stores the result in BX)
- NOT AX (inverts all bits in register AX)

Additional Insights:

* These instruction types form the core of most assembly languages.


* Data transfer instructions are essential for loading data, storing results, and
interacting with I/O devices.
* Arithmetic instructions enable calculations and data manipulation.
* Logical instructions provide fine-grained control over individual bits, often
used for masking, testing, and setting specific bits within data.

4. Explain rotate and shift (Arithmetic and logical) instruction with


example.

Shift Instructions:
* Move bits to the left or right within a register or memory location.
* Types:
- Logical Shifts:
* Bits shifted out are discarded.
* Bits shifted in are zeros.
* Used for unsigned numbers.
- Arithmetic Shifts:
* Bits shifted out are discarded.
* Bits shifted in are copies of the original sign bit.
* Preserves the sign of signed numbers.

Rotate Instructions:

* Circle bits around within a register or memory location.


* Types:
- Rotate Left (ROL):
* Bits shifted out from the left end are moved to the right end.
- Rotate Right (ROR):
* Bits shifted out from the right end are moved to the left end.

Examples:
Logical Shift Left (LSL):

MOV AL, 10110101b ; AL = 181


SHL AL, 2 ; Shift left by 2 bits
; AL becomes 01101000b (64)

Arithmetic Shift Right (SAR):

MOV BL, 11110101b ; BL = -75 (signed)


SAR BL, 3 ; Shift right by 3 bits
; BL becomes 11111110b (-2)

Rotate Left (ROL):

MOV CL, 10011011b ; CL = 155


ROL CL, 1 ; Rotate left by 1 bit
; CL becomes 00110111b (55)
5) For the following given instruction determine the addresses.

DS= 2102h
Offset= 481
Logical Address= 2102:481
Physical Address= 2180h

_
DS:
Value: Unknown
Reason: The code doesn't explicitly set the DS register. Its value depends on
previous instructions or assembly context.

Offset:
In MOV [0018h], 0005h: 0018h (decimal 24)
In MOV AX, [BX+022h]: 022h (decimal 34)

Logical Addresses:
MOV [0018h], 0005h: Depends on DS value. If DS were 1000h, it would be
1000:0018h.
MOV AX, [BX+022h]: Depends on DS and BX values. If DS were 1000h, BX
were 0010h, it would be 1000:0032h.

Physical Addresses:
Cannot be determined without knowing DS

DS:
- Value: Unknown (not explicitly set in the code)
- For this analysis, let's assume DS = 1000h (hypothetical)

Offsets:
- MOV [0022h], 0100h: Offset is 0022h (decimal 34).
- MOV SI, 0013h: No memory access, so no offset.
- MOV AX, [SI + 012h]: Offset is 025h (calculated as 013h + 012h).

Logical Addresses:
- MOV [0022h], 0100h: 1000:0022h
- MOV AX, [SI + 012h]: 1000:0025h
Physical Addresses:
- MOV [0022h], 0100h: 10220h (calculated as 1000h * 10h + 0022h)
- MOV AX, [SI + 012h]: 10250h (calculated as 1000h * 10h + 0025h)

DS:
- Value: Unknown (not explicitly set in the code)
- For this analysis, let's assume DS = 1000h (hypothetical)

Offsets:
- MOV [0033h], 0110h: Offset is 0033h.
- MOV SI, 0011h: No memory access, so no offset.
- MOV BX, 0013h: No memory access, so no offset.
- MOV AX, [BX + SI + 012h]: Offset is 036h (calculated as 0013h + 0011h +
012h).

Logical Addresses:
- MOV [0033h], 0110h: 1000:0033h
- MOV AX, [BX + SI + 012h]: 1000:0036h

Physical Addresses:
- MOV [0033h], 0110h: 10330h (calculated as 1000h * 10h + 0033h)
- MOV AX, [BX + SI + 012h]: 10360h (calculated as 1000h * 10h + 0036h)

6 .Write an assembly language program to print the following patterns:


Name: Yohannes Abera
ID: RCD/2453/2014
Section: J

You might also like