Download Labwork 1

CENG 222 – Computer Organization
Lab Work 1
16-bits Intel microprocessors have some capabilities of moving data from register to register;
register to memory, and vice versa.
Commonly used 16-bits registers are:
AX, BX, CX, DX, SI, DI, SP, DS
First four registers (AX, BX, CX, and DX) consist of two 8-bits parts called high part
(denoted by ‘H’) and low part (denoted by ‘L’).
AX = AH, AL
BX = BH, BL
CX = CH, CL
DX = DH, DL
Note that the high part register is the most significant byte and the low part is the least
significant byte of the whole 16-bits register.
Assembly instructions of moving data using memory and registers are given below:


Parameters of instructions are denoted by <…> symbols for explaining the usage of
the instruction.
[] braces in Macro assembly has the same function with * operator in C language.
For example, [AX] denotes the data or memory location where AX points to.
1- Immediate data to register
MOV <destination register>, <data>
MOV AX, 4C00H
MOV DL, 120
; AX = 4C00h
; DL = 120
Size of data and destination register must be equal!
2- Register to register
MOV <destination register>, <source register>
MOV AX, CX
MOV CL, BH
; AX=CX
; CL=BH
Note that size of destination and source registers must be the same!
3- Memory to register (Direct addressing)
MOV <destination register>, [<address>]
MOV AX, [1BFFH]
; Copy 2-bytes (word) data stored at address 1BFF to AX
MOV DL, [offset msg]
; Copy 1-byte data at msg to DL
Important: Size of the data read from memory is determined by the size of the
destination register!
4- Memory to register (Indirect addressing)
MOV <destination register>, [<register>]
MOV AX, [BX]
MOV DL, [BX]
; AX = (*BX)
; DL = (*BX)
Important: Size of the data read from the memory location pointed by register,
is determined by the size of the destination register!
5- Register to memory
MOV [<register>], <source register>
MOV [BX], DX
; *BX = DX (Writes 2 bytes)
MOV [BX], DL
; *BX = DL (Writes 1 byte)
MOV [1BFFH], AX ; *(1BFFH) = AX; (Writes 2 bytes)
Note: Size of the data written is the size of register.
6- Immediate data to memory
MOV [<register>], <data>
MOV [BX], 20h
; *BX = 0020h
MOV [BX], 4C00h ; *BX = 4C00h
MOV [1BFFH], 20h ; *(1BFFH) = 20h;
If the source data is 1-byte, size of the data written to the memory is 16-bits
unless you state the size. Leading zeros will be added automatically.
MOV [BX], 20h
; Copy the word (2-bytes) data to the memory
; block started at BX. (*BX = 0020h)
MOV WORD PTR [BX], 20h
; Exactly the same as above
MOV BYTE PTR [BX], 20h
; Copy 1 byte (*BX = 20h)
If the source data is 2-bytes, size of the data written to the memory is 16-bits and
you cannot state the size.
Experiments
Analyze the assembly code below:
title Register test program
.model small
.stack 100h
.data
msg db "AB",0dh,0ah,'$'
.code
main proc
mov ax,@data
mov ds,ax
; Add your code here
; -----------------; -----------------mov ah,9
mov dx,offset msg
int 21h
mov ax, 4c00h
int 21h
main endp
end main
The program above prints “AB” to the console. The message “AB” is stored at msg in data
segment. Therefore, “offset msg” is the starting address of the string. Modify the code
according to the following experiments:
1- Copy the second byte stored at “msg” (which is ‘B’ currently) to the first byte. The
output should be “BB”. In order to do that, load 2-bytes data stored at “msg” into a
16-bits register. Copy one part of the register to the other part. Then, write your
register back to msg.
2- Copy the first byte stored at “msg” (which is ‘A’ currently) to the second byte. The
output should be “AA”. To achieve this, load the first byte stored at “msg” into one 8bits register (high or low part) and copy it onto the other part and write the data stored
in register back to msg.
3- Load the data stored at “msg” into one register and swap the high and low parts of the
register using a temporary 8-bits register. Then write back your “swapped” register
onto msg. The output should be “BA”.