Chapter 4 programming concepts III

PROGRAMMING
CONCEPTS-III
CHAPTER 4

STRING INSTRUCTIONS
 The 8086 has a set of instructions for handling
blocks of data in the form of bytes or words.
 They are called ‘string’ instructions.
 A string is an array of data of the same type – for
example, a character string or a byte string
 The usefulness of string instructions can be
seen when in the memory data has to be moved,
searched or compared in blocks.

PRE-REQUISITES FOR USING STRING
INSTRUCTIONS
i. DS and ES are to be defined: Initializing & using
these segment makes DS as the source & ES as
the destination segment
ii. SI and DI acts as pointers: SI to point to DS & DI top
point to ES, means SI should contain the address (offset) of
the first location in the DS and DI should contain the
address of the first location in ES
iii. DF should be set/reset: control flag called as direction
flag, used exclusively for string operations. Purpose in
string operation is, if flag is set, the pointers get
automatically decremented, and if reset, the reverse
occurs. So, during string instructions are used, DF should
be set/reset depending on the direction.
iv. CX should act as a counter: counter CX should be
loaded with the count of number of operations required.

LIST OF INSTRUCTIONS/PREFIXES USED IN
STRING OPERATIONS

THE MOVS INSTRUCTION
 Can be used as MOVSB or MOVSW
 It moves data from the source segment (data
segment) to the destination segment (extra
segment)
 CX acts as the count register
 DF is to be set/reset
 SI and DI have to be intialiased to the source
address in the data segment ,and the destination
address in the extra segment

MOVING A STRING -USING THE FULL SEGMENT
MODEL

 Two segments DAT & EXTR are defined
 Two segment registers DS & ES are initialized
 SI & DI point to the source data & destination data
 CLD is used to clear the DF for auto incrementing the
pointer registers
 This causes the value of SI and DI to be incremented after
each move operation
 Here, SI & DI are incremented only by one each time
 String instruction is used here is MOVSB
 This causes the data in location pointed by SI to be moved
to the location pointed by DI
 After each such move operation, two actions occur
 One is that CX decrements by 1 and the other is that the
pointer registers are incremented
 This sequence continues until CX=0

THE CMPS INSTRUCTION
 This instruction is for string comparison, byte
by byte or word by word as the case may be.
The conditional flags are modified according
to the result of the comparison.
String comparison has to be accompanied by
the use of the conditional REP prefix.
Since string comparison checks only for
equality, the Zero flag is made use of
automatically.

 Example
 Compare two character strings (of length six) which
are saved in the data segment.
 One of two messages is to be displayed, depending
on whether the strings are equal or not.

THE SCAS INSTRUCTION
 The SCAS instruction scans a byte or word string to
ascertain the presence of a specific byte or word. This
specific data is loaded into AL or AX.
 The string which is to be scanned has to be in the
extra segment, and is to be pointed by DI. This is
mandatory and cannot be overridden.

 Write a program to search for a character in an
ASCII string .
 Express the result using appropriate messages

THE STOS AND LODS
INSTRUCTIONS
 i) STOS
 The STOS instruction is the mnemonic for ‘storing’ a
string in memory.
 As such, we need to define a memory area in which
‘storing’ is to be done. This memory area is defined to
be the extra segment, and it is addressed by DI as it
is the destination segment.
 The data to be stored is placed in the AL or AX register.
 An area in memory can be filled with the required data,
with this instruction.

 Write a program to fill an area of memory with a
specific word

THE LODS
INSTRUCTION
 This is an instruction for ‘loading’.
 Here, the source memory is the data
segment and the pointer to it is SI
 The data segment is the source segment
and the destination register is the AL or AX
register.
 There is no sense in using the REP prefix
for the LODS instruction as data can be
loaded to AL/AX only once.

PROCEDURES
When a main program calls a subsidiary
program ,the latter is called a procedure
 To avoid writing the sequence of instructions
in the program each time you need them,
you can write the sequence as a separate
subprogram called a procedure
 You use the CALL instruction to send the
8086 to the starting address of the
procedure in memory

CONTD..
 A RET instruction at the end of the procedure
returns execution to the next instruction in the main
line
 Procedures can even be nested

THE SEQUENCE OF CALLING PROCEDURES
 Near procedure –which resides in the same code
segment as the main (calling) program
 A procedure is called by a CALL instruction
 At the time the CALL instruction is being executed,
the IP (instruction pointer) will be pointing to the
next instruction in the main program

THE STEPS TAKEN BY THE PROCESSOR FOR
CALLING PROCEDURES
 It saves the current IP content on the stack (this is
the ‘return’ address for coming back to the main
program after executing the procedure).
 The CALL destination (specified in the CALL
instruction) will be the address of the procedure.
The IP is now loaded with this address and
execution proceeds from that location
 The procedure is executed until a RET (return)
instruction in the procedure is encountered.
 Then, the old value of the IP is retrieved from the
stack and control returns to the main program at the
return address.

25
MAINLINE OR CALLING
PROGRAM
NEXT MAINLINE
INSTRUCTIONS
PROCEDURE
INSTRUCTIONS
CALL
RET
Fig. Single Procedure Call

26
Main Line Instructions
RET
Lower level
Procedure
CALL
RET
Procedure
CALL
Next Main Line
Instructions
Fig. Nested Procedures Call

WRITING A PROCEDURE
 The procedure should begin with the
procedure name followed by the directive
PROC.
 We also use the directives NEAR or FAR
which specify the ‘type’ of the procedure.
 The procedure should end with the
procedure name and ENDP.

EXAMPLE 4.5
 Write a program, which enters 10 single digit
numbers through the keyboard, finds their squares
and stores the squares in memory.
 Only byte locations need be allocated in memory
for the squares as the square of the highest single
digit number is 81, which will fi t into a byte space

THE CALL INSTRUCTION
 Intrasegment or ‘Near’ Call
 i) Direct CALL
Usage: CALL label
 The direct call is like a direct jump instruction, and is
three bytes long. It is relative and the destination can be
−32,768 bytes to +32,767 bytes from the address of the
instruction following
 the call (this will be the current content of the IP).
 the off set can be a 16-bit signed number.
 When this call is executed, the new value of IP = old IP
+ off set,

FIGURE 4.3 | FORMAT OF THE DIRECT NEAR
CALL INSTRUCTION

II) INDIRECT CALL
 Usage: CALL reg16, CALL [reg16]
In this case, the destination is specified in a 16-bit
register or in a memory location pointed by a
register.
 This is not a ‘relative’ call. The content of the
referred register or memory location is loaded into
IP for using the procedure.
 Examples
 CALL BX ;the procedure’s address is in BX
 CALL WORD PTR[BX] ;the address of the
procedure is in memory and is pointed by BX

INTERSEGMENT OR FAR CALL
 Direct Far Call A far call is an intersegment call,
which means that the destination address is in a
different code segment.
 This will be a 5-byte instruction, the first byte being
the opcode, the second and third bytes being the
new value of IP, and the fourth and fi fth, the new
values of CS.
 This is not a relative call.
 When the procedure is called, the IP and CS values
are replaced by the corresponding values in the call
instruction

FIGURE 4.4 | FORMAT OF THE FAR JUMP
INSTRUCTION

INDIRECT FAR CALL
• The destination address is not in the instruction –
rather, it is in a register or memory.
 For a far call, four bytes are needed to specify a
destination. a register cannot specify it. Hence the
four bytes needed to specify a destination are
stored in
memory and pointed by a register.

 Example of an indirect far call
 CALL DWORD PTR [SI] can be a far call instruction.
[SI] and [SI + 1] gives the new value of IP and [SI + 2]
and [SI + 3] gives the new value of CS.
 Far calls and procedures are specified using the ‘far’
directive when defining the procedure.
 In Chapter 5, we will see how the EXTRN directive is
used in this context.

THE RET INSTRUCTION
 i) Usage: RET
 The execution of RET causes the return address to
be popped from the stack to IP or IP and CS.
 (Whenever a procedure is defined, it is known
whether it is a far or near procedure. From this, it is
determined whether the stack has saved just the
old IP value or both IP and CS.)

RET N
 Usage: RET n
 This is another form of the RET instruction. This
adds the number ‘n’ to the stack pointer (SP) after
the return address has been popped off the stack,
on return from a procedure

THE USE OF THE STACK IN PROCEDURE
CALLS
 When both the main program and the procedures
need the same registers, the content of the
registers are pushed onto the stack when going to
a procedure ,and popped back on returning.
 MASM 6.x has a construct ‘USES’ which
automatically pushes the specified registers onto
the stack.
 The popping will be automatic on returning from the
procedure.

EXAMPLE 4.7A –THE USES DIRECTIVE

PASSING PARAMETERS TO AND FROM
PROCEDURES
Can be done using
o Registers
o Memory and memory pointers
o Stack

EXAMPLE 4.8
 Write a program which calculates and places in
memory the Nth term of an arithmetic progression.
The formula for the Nth term of an A.P. is A + (N −
1) D, where A is the fi rst term and D is the common
difference.
 Pass the values of the operands using registers

PASSING PARAMETERS THROUGH
MEMORY
 Example 4.9 is a program for arranging a set of
numbers (stored in memory) in descending order.
 The values are passed to the program through
memory pointers.
 The method involves comparing numbers pair-wise
and repeating this N − 1 times, if there are N
numbers to be sorted.

PASSING PARAMETERS THROUGH THE
STACK
 There may be reasons where the stack, which is an
area in the memory, can be used to store data. The
procedure can take data from the stack for its
computation.
 Example 4.10 shows BP being used to access data in
the stack
 Here, four words which are in the data segment are
pushed on to the stack by the main program.
 The procedure accesses the data using the indexing
features of BP. Remember that BP is a register
associated (by default) with the stack segment, and
that BP cannot be used without an off set.

EXAMPLE 4.10
 Calculate (A + B) − (E + D) where A, B, E and D are
words stored in data memory. The result is also to
be saved in the data segment.
 Use BP for accessing the stack
 Note We do not use C as a label because ‘C’ is a
reserved word in MASM

FIGURE 4.5 | STACK OPERATION FOR THE
PUSH AND RET 8 INSTRUCTIONS OF EXAMPLE
4.10

STACK OVERFLOW AND
UNDERFLOW
 SP can have a maximum value of FFFFH. For each
PUSH operation, the SP value decrements by 2,
and in the limiting case, it can go to SP = 0000.
 Any PUSH operation beyond this will cause a
‘stack overflow’.
 This creates a condition when there is no space in
the stack for new data.
 Stack underflow is the other case when POP
operations cause SP to have values beyond the
defined stack.

MACROS
 What is a macro? It is like an opcode – when used,
it executes.
 A macro when called by name, executes the
instructions that are listed under that name.
 Thus essentially, a macro is a short hand notation
for a number of instruction lines.
 It makes assembly language coding more readable
and helps to avoid repetitive coding.

WRITING A MACRO –THE FORMAT
MACRO-NAME MACRO [parameter list]
Instructions (body of the macro)
ENDM

Macros Procedures
Accessed during assembly when
name given to macro is written as
an instruction in the assembly
program.
Accessed by CALL and RET
instructions during program
execution.
Machine code is generated for
instructions each time a macro is
called.
Machine code for instructions is put
only once in the memory.
This due to repeated generation of
machine code requires more
memory.
This as all machine code is defined
only once so less memory is
required.
Parameters are passed as a part of
the statement in which macro is
called.
Parameters can be passed in
register memory location or stack.

Chapter 4 programming concepts III

More Related Content

What's hot

Similar to Chapter 4 programming concepts III

More from SHREEHARI WADAWADAGI

Recently uploaded

Chapter 4 programming concepts III