Scribd
Upload
7 views

Assembly Language Program

The document discusses assembly language programming assignments including writing a program to calculate factorials, describing addressing modes with examples, explaining data transfer, arithmetic, and logical instructions with examples, explaining rotate and shift instructions with examples, determining addresses from instructions, and writing a program to print patterns.

Uploaded by

yabera528
Copyright
© © All Rights Reserved
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
7 views

Assembly Language Program

The document discusses assembly language programming assignments including writing a program to calculate factorials, describing addressing modes with examples, explaining data transfer, arithmetic, and logical instructions with examples, explaining rotate and shift instructions with examples, determining addresses from instructions, and writing a program to print patterns.

Uploaded by

yabera528
Copyright
© © All Rights Reserved
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 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