[PDF] Examples123 In the following section we

View - Download Examples123

Previous PDF

Next PDF

The Art of Assembly

Language Programming

with B□BG/8□88

INTRODUCTION

In the previous chapter, the 8086/8088 instruction set and assembler directives were discussed in significant

detail. This chapter aims at making the reader more familiar with the instructions and assembler directives and

their use in implementing the different structures required for the implementation of algorithms. In this chapter,

the

different structures are implemented by using the instruction set of 8086. A number of example programs are dis

cussed to explain the use of these structures. While in the second chapter, a qualitative study of all the addressing

modes has been presented, in this chapter, the ideas about the addressing modes and their typical uses will be

presented more clearly through example programs. After studying this chapter , one will be in a position to use

the instructions and directives properly to translate an algorithm into a program. While emphasizing on different

programming techniques, we have stressed more on managing the processor resources and capabilities because

while solving a particular problem, the programmer may find a number of solutions (instruction sequences). A

skilled programmer selects an optimum solution out of them for that specific application. For example, the instruc

tion INC AL and ADD AL,01 H may serve the same purpose but the first one requires less memory and execution

time than the second one. Hence, the INC instruction will be preferred over ADD. Also the improper use of general

purpose and special purpose registers may lead to the requirement of more instructions for a particular algorithm

resulting in more execution time and memory requirement. While implementing an algorithm, the processor ca

pabilities should be optimally utilized. For example, while writing a simple program to move a string of data from

the source to destination location, a programmer may initialize a pointer to memory source, another pointer to

destination and a counter to count the number of data elements to be moved. Each data element is then fetched

from the source loc ation and transferred to the destination location. This process should continue till all the data

elements are transferred. He may use the INR, OCR, JNZ instructions to update pointers, counters, and check

the counter for zero. All these instructions are available in the instruction set of 8085 as well as 8086. They can

be used to implement the same algorithm in a similar fashion but by using the MOVS instruction of 8086, the

same algorithm can be implemented with less number of instructions and memory requirement. When all these

elements come into picture, the assembly language programming becomes a skill rather than a technique.

In the following section, we will consider some program examples. Starting from simple arithmetic operation

programs, the discussion concludes with some example programs based on DOS function calls. Before sta

rting

to write a program, the task must be put in a clear form so that the simplest required algorithm may be put for

ward in terms of a flow chart. The implementation of the flow chart may then require the different structures like

IF-THEN-ELSE, DO WHILE, REPEAT (NUMBER OF TIMES), REPEAT UNTIL, etc. The implementation of these structures by using the instruction set completely depends upon the skill of the programmer.

80 Advanced Microprocessors and Peripherals

3.1 A FEW MACHINE LEVEL PROGRAMS

In this section, a few machine level programming examples, rather, instruction sequences are presented for

comparing the 8086 programming with that of 8085. These programs are in the form of instruction sequences

just like 8085 programs. These may even be hand-coded, entered byte by byte and executed on an 8086 based

system but due to the complex instruction set of 8086 and its tedious opcode conversion procedure, most of

the programmers prefer to use assemblers. However, we will briefly discuss the hand-coding ( opcode conver

sion) technique in the next section.

Example 3.1

Write a program to add a data byte located at offset 0500H in 2000H segment to another data byte available at 0600H in the same segment and store the result at 0700H in the same segment. Solution The flow chart for this problem may be drawn as shown in Fig. 3.1. START

Initialise Seg. Register

Get content of 0500H

in a G.P. register

MOV AX, 2OOOH ; Initialising DS with value

MOV DS, AX ; 2OOOH

MOV AX, [5OOH] ; Get first data byte from O5OOH

offset

ADD AX, [6OOH] ; Add this to the second byte

from O6OOH

MOV [?OOH], AX Store AX in O7OOH (result).

HLT Stop Fig.3.1 Perform addition

Store result in 0700H

STOP

Flow Chart for Example 3.1

The above instruction sequence is quite straightforward. As the immediate data cannot be loaded into a

segment register, the data is transferred to one of the general purpose registers, say AX, and then the register

content is moved to the segment register DS. Thus the data segment register DS contains 2000H. The instruc

tion MOV AX, [SOOH] signifies that the contents of the particular location, whose offset is specified in the

brackets with the segment pointed to by DS as segment register, is to be moved to AX. The MOV [0700H],

AX instruction moves the contents of the register AX to an offset 0700H in DS (DS = 2000H). Note that the

code segment register CS gets automatically loaded by the code segment address of the program whenever

it is executed. Actually it is the monitor program that accepts the CS:IP address of the program and passes it

to the corresponding registers at the time of execution. Hence no instructions like DS or SS are required for

loading the CS register.

Example 3.2

Write a program to move the contents of the memory location 0500H to register BX and to CX. Add immediate byte 05H to the data residing in memory location, whose address is computed using DS =

2000H and offset= 0600H. Store the result of the addition in 0700H. Assume that the data is located

in the segment specified by the data segment register DS which contain 2000H. Solution The flow chart for the program is shown in Fig. 3.2.

MOV AX, 2OOOH

MOV DS, AX

MOV BX, [O5OOH] Initialize data segment register

Get contents of O5OOH in BX

The Art of Assembly Language Programming with 8086/8088 81

MOV CX, BX ; Copy the same contents in

ex ADD [0600H], 05H; Add byte 05H to contents of 0600H

MOV DX, [0600H]

MOV [0700H], DX

HLT Store the result in DX

Store the result in 0700H

Stop START

Move content of 0500H to BX

Move content of Bx to CX

After initialising the data segment register, the content of location 0500H are moved to the BX register using MOV in struction. The same data is moved also to the CX register. For this data transfer, there may be two options as shown.

Ca) MOV CX, BX As the contents of BX will be

same as 0500H after execution of MOV BX,[0500HJ.

Cb) MOV CX, [0500HJ; Move directly from 0500H

to register CX Add immediate data 05H to [0600H)

Store result in 0700H

STOP

Fig. 3.2 Flow Chart for Example 3.2

Example 3.3

Add the contents of the memory location 2000H:0500H to con tents of 3000H:0600H and store the result in 5000H:0700H. Solution Unlike the previous example programs, this pro gram refers to the memory locations in different segments, hence, while referring to each location, the data segment will have to be newly initialised with the required value. Figure 3.3 shows the flow chart. The instruction sequence for the above flow chart is given along with the comments.

MOV ex. 2000H Initialize DS at 2000H

MOV DS. ex MOV AX, [500H] Get first operand in AX

MOV ex. 3000H Initialize DS at 3000H

MOV DS. ex MOV BX, [0600H] Get second operand in BX.

ADD AX, BX Perform addition

MOV ex. 5000H Initialize DS at 5000H

MOV DS. ex MOV [O?OOHJ,AX Store the result of

addition in

HLT 0700H and stop START

Initialise DS at 2000H

Get content of 0500H in AX

Initialise DS at 3000H

Get content of 0600H in BX

Add AX and BX

Initialise DS with 5000H

Store AX in 0700H

STOP

Fig. 3.3 Flow Chart for Example 3.2

The opcode in the first option is only of2 bytes, while the second option will have 4 bytes of opcode. Thus the

second option will require more memory and execution time. Due to these reasons, the first option is preferable.

The immediate data byte 0SH is added to the content of0600H using the ADD instruction. The result will be

quotesdbs_dbs7.pdfusesText_5

[PDF] 8086 instruction encoding format

[PDF] 8086 instruction set with examples ppt

[PDF] 8086 manual pdf

[PDF] 8086 microprocessor architecture and instruction set pdf

[PDF] 8086 microprocessor architecture ppt

[PDF] 8086 microprocessor architecture ppt free download

[PDF] 8086 microprocessor assembler directives pdf

[PDF] 8086 microprocessor book by ramesh gaonkar pdf

[PDF] 8086 microprocessor book pdf free download

[PDF] 8086 microprocessor books pdf free download

[PDF] 8086 microprocessor family pdf

[PDF] 8086 microprocessor instruction set ppt

[PDF] 8086 microprocessor instruction set ppt free download

[PDF] 8086 microprocessor notes pdf free download

[PDF] 8086 microprocessor pdf free download