WORKING WITH DATA TRANSFER AND ARITHMETIC INSTRUCTIONS
Aims of the Experiment:
- Give an introduction to the use of Microsoft Macro-Assembler MASM.
- To develop more programs using data transfer and arithmetic instruction.
Important Notes:
- The Assembly Process:
The first step in assembly language programming is the writing of the source program with the help of a text editor. The source program is a collection of text characters making up a program that follows the rules of assembly language. We’ll be using the ‘EDIT’ editor available with the newer versions of DOS for writing the source program. You can, of course, use a text editor of your choice. The source program should be saved as a filename with extension ‘asm’ (*.asm).
The assembly language programs must be converted to machine language before they can be executed. Following steps are involved in this assembly process:
Assembly Step: An assembler is a program designed to read an assembly language source program as input and generate an object program (*.obj) as output. The assembler may also create a listing file (*.lst), which lists both the source statements and the machine code, and a cross-reference file (* .crf). An object program (.obj) is a machine language interpretation of the original source program, lacking certain information needed by DOS before it may be executed. To assemble a program (*.asm file) we’ll use the following command typed in either lowercase or uppercase at the DOS prompt:
MASM/L/N Filename;
Note that the ‘asm’ extension is not written with the file-name. The /L option specifies an assembly listing file, and the /N option suppresses tables in the listing file. Refer to chapter 4 of [1] for more details.
Link Step: The linker supplied with the Macro Assembler reads an object program (*.obj) and generates an executable (*.exe) program. The executable program can be executed just by typing its name. To link an object program, use the following command at the DOS prompt:
LINK Filename;
TASM (Turbo Assembler)
Step1: Edit a file using any editor with .asm extension
Step 2: Assemble the program and create an .obj file by writing tasm filename.asm at the DOS prompt
Step 3: Link the file using tlink.exe. The command is tlink filename.obj
Step 4: Load the exe file in the debugger. The command is debug filename.exe. Load the file, Unassemble it and execute it using either of g, t or p debug commands
The Program Template:
Use the following program template for creating new programs:
Page 132
Title name/purpose of the program
Dosseg
.Model small
.Stack 100h
.Data ; variable here
.Code ;code here
Name of the main procedure proc
mov ax, @data ;initialize the DS register
mov ds, Ax
…
…
…
mov ax,4c00h :end program
int 21h
name of the main procedure endp
end name of the main procedure
The actual assembly language program is written in the space where ellipses (…) are shown. All text typed to the right of semicolon (;) is ignored, you can use it for your comments. MASM is case insensitive, meaning that it doesn’t recognize the difference between uppercase and lowercase letters.
Assembler Directives:
Assembler directives are different form assembly language instructions in that the former are directions to the assembler whereas the latter are directions to the 8086 microprocessor. The following directives are used in the above template:
.CODE Mark the beginning of the code segment
.DATA Mark the beginning of the data segment
DOSSEG Use standard segment ordering
END End of program assembly
ENDP End of procedure
.MODEL Determine the program model memory size
PAGE Set a page format for the listing file
PROC Begin procedure
.STACK Set the size of the stack segment
TITLE Title of listing file
Another important directive that we’ll be using is ‘offset’
OFFSET Returns the offset address of the following memory location.
For more details on these and other assembler directives, refer to chapter 4 of [1].
- Write the following program in a text editor.
Page, 132
Title program for adding 8 data words
Dosseg
.model small
.stack 100h
.data ; variable here
value dw 0024h, 2357h, 001Fh, 0123h, 01FBh, 0F45h, 089Fh, 1FDBh
.code
add-word proc
mov ax, @data ; initialize the DS register
mov ds ,ax
mov si, 0h ; initialize source index
mov ax,0h ; initialize the sum register
mov cx, 08 h ; initialize the counter reg.
Next-word: ; this a label
add ax, [si+offset value] ;add each number
inc si ; inc si twice to point it to
Inc si ;the next word
Dec cx ; decrement counter
Jnz next-word ; go back if count not zero
mov [si+offset value],ax ; data
mov ax, 4c00h ; end program
Int 21h
Add-word endp
end add-word
save it with the name ‘prog1.asm.’ assemble and link by typing ‘tasm prog1.asm’ and ‘tlink prog1.obj’ at the DOS prompt. Load the program in DEBUG by typing ‘debug prog1.exe’ and then trace it. The following points are worth paying attention:
- In the ‘jnz’ instruction, we have specified a return label rather than a return address as we have been doing while writing programs with the help of DEBUG. This results in ease of programming especially when the source program is relatively bigger.
- The value parameter in the add instruction represents the address of the first memory location in the data segment where the eight words are stored.
- The following program converts the binary code to reflected Gray code. Write the following assembly language program using a text editor:
Page, 132
Title program for converting Binary code to Gray Code
Comment #This program takes the binary number in CL as input and replaces it with its Gray code equivalent number. #
Dosseg
.model small
.stack 100h
.data ; variables here
values db oh, 1h, 3h,2h, 6h, 7h, 5h, 4h, 0ch, 0dh, 0fh, 0eh, 0ah, , 6h, 8h.
.code
code_conv proc
mov ax, @data ; initialize the DS register
mov ds, ax
mov bx,offset values ; use offset directive to load
; the offset address. Of values in BX
mov al, cl
xlat ; replace AL by contents of DS:BX+Al
mov cl, al
mov ax, 4C00h ; end program
int 21h
code-conv endp
end code-conv
Save the program, assemble and link it, and finally load it in DEBUG. Load CL with some value between 0h and Fh, trace this program, and verify if it gives correct results. Repeat for some other values in CL.
Note: Use ‘r cx’ command in DEBUG for loading various values in CL.
- You have used a new assembler directive in this program:
COMMENT# tex# - you can write as many lines of comment between the two delimiters # as you may think to be necessary.
- The XLAT instruction is used to simplify implementation of the look-up table operation. In the above program, we have saved the Gray code at the starting address of DS value. The first byte corresponds to Gray code of 0h, the second to that of 1h, the third to that of 2h, and so on. The usefulness of this program may not become clear to you now, however, if you think this program as a subroutine of some big program then you may think the main program passing an input argument in the form of a binary number to this subroutine. In reply, this subroutine will return the corresponding Gray code, which may later be used in the main program.
- Write, assemble, and debug the following program, and find out its purpose. There are two new commands used in this program:
MUL DL – it multiplies the contents of AL with DL and puts the result in AX.
DIV CL – it divides AX by CL, puts quotient in AL and remainder in AH.
Page, 132
Title quiz program
Comment # Find the purpose of the following program. Add comments were you feel necessary. #
Dossag
.model small
.stack 100h
.data
value db 01,02, 03, 04, 05,06, 07, 08
.code
main proc
mov ax, @data
mov ds, ax
mov cl, 08h
mov si, 0h
mov bx, 0h
next-byte:
mov al, [offset value+si]
mov dl, al
mul dl
add bx, ax
inc si
dec cl
jnz next-byte
mov cl, 08h
mov ax, bx
div cl
mov [offset value+si] , ax
mov ax, 4C00h
int 21h
main endp
end main
- Write, assemble, and debug an assembly language program that calculates the average of following positive words:
0123h, 00FBh, 00BDh, 0223h, 02CDh, 1100h, 0223h, 019Bh.
- REFERENCES:
- Kip R. Irvine, Assembly Language for the IBM-PC. Macmillan Publishing Commpany,1990.
- Avtar Singh and Walter A. Triebel, The 8086and 80286 Microprocessors, Hardware, Software, and Interfacing. Prentice-Hall Inc. 1990.
0 comments:
Post a Comment