Progressive Education Society's

Modern College of Engineering, Pune-05.

DEPARTMENT OF COMPUTER ENGINEERING

EXP NO: 03

AIM: Write an X86/64 ALP to accept a string and to display its length.

OBJECTIVES:
To learn and understand the operation of accept and display string.

ENVIRONMENT:
Operating System: 64-bit Open source Linux or its derivative.
Programming Tools: Preferably using Linux equivalent or MASM/TASM/NASM/FASM.
Text Editor: geditor

THEORY:
The 80x86 String Instructions: All members of the 80 x 86 families support five different string
instructions: MOVS, CMPS, SCAS, LODS and STOS. They are the string primitives since you
can build most other string operations from these five instructions.

How the String Instructions Operate:The string instructions operate on blocks (contiguous
linear arrays) of memory. For example, the MOVS instruction moves a sequence of bytes from
one memory location to another. The CMPS instruction compares two blocks of memory. The
SCAS instruction scans a block of memory for a particular value. These string instructions often
require three operands a destination block address a source block address and (optionally) an
element count. For example, when using the MOVS instruction to copy a string you need a
source
address a destination address and a count (the number of string elements to move).
Unlike other instructions which operate on memory the string instructions are single-byte
instructions which don't have any explicit operands. The operands for the string instructions
include

The SI (source index) register

The DI (destination index) register
The CX (count) register
The AX register and
The direction flag in t e FLAGS register.

For example one variant of the MOVS (move string) instruction copies a string from the source
address specified by DS:SI to the destination address sspecified by ES:DI of length CX.
Likewise,
the CMPS instruction compares the string pointed at by DS:SI of length CX to the string pointed
at by ES: DI.
Not all instructions have source and destination operands (only MOVS and CMPS support
them).
 Progressive Education Society's
Modern College of Engineering, Pune-05.
DEPARTMENT OF COMPUTER ENGINEERING

For example, the SCAS instruction (scan a string) compares the value in the accumulator to
values in memory. Despite their differences the 80x86's string instructions all have one thing in
common - using them requires that you deal with two segments the data segment and the extra
segment.
The REP/REPE/REPZ and REPNZ/REPNE Prefixes
The string instructions by themselves do not operate on strings of data. The MOVS instruction
for
example will move a single byte word or double word. When executed by itself the MOVS
instruction ignores the value in the CX register. The repeat prefixes tell the 80x86 to do a multi-
byte string operation.
The syntax for the repeat prefix is:
Field: Label repeat mnemonic operand; comment
For MOVS:
REP MOVS
For CMPS:
REPE CMPS REPZ
REPNE REPNZ CMPS
For SCAS:
REPE SCAS
REPZ SCAS
REPNE SCAS
REPNZ SCAS
For STOS:
REP STOS {operands}

You don't normally use the repeat prefixes with the LODS instruction.
As you can see the presence of the repeat prefixes introduces a new field in the source line
- the repeat prefix field. This field appears only on source lines containing string instructions. In
your source file:
The label field should always begin in column one

The repeat field should begin at the first tab stop and
The mnemonic field should begin at the second tab stop.

When specifying the repeat prefix before a string instruction the string instruction repeats CX
times. Without the repeat prefix the instruction operates only on a single byte word or double
word.
You can use repeat prefixes to process entire strings with a single instruction. You can use the
string instructions without the repeat prefix as string primitive operations to synthesize more
powerful string operations.

The operand field is optional. If present MASM simply uses it to determine the size of the string
to

SNJB’s LS KBJ COE Chandwad

 Progressive Education Society's
Modern College of Engineering, Pune-05.
DEPARTMENT OF COMPUTER ENGINEERING

Department of Computer Engineering Microprocessor Laboratory (2019 course)

operate on. If the operand field is the name of a byte variable the string instruction operates on
bytes. If the operand is a word address the instruction operates on words. Likewise for double
words. If the operand field is not present you must append a "B" "W" or "D" to the end of the
string instruction to denote the size e.g. MOVSB MOVSW or MOVSD.
The Direction Flag
Besides the SI, DI and ax registers one other register controls the 80x86's string instructions - the
flags register. Specifically, the direction flag in the flags register controls how the CPU processes
strings.
If the direction flag is clear the CPU increments SI and DI after operating upon each string
element. For example if the direction flag is clear then executing MOVS will move the byte
word
or double word at DS:SI to ES:DI and will increment SI and DI by one two or four. When
specifying the REP prefix before this instruction the CPU increments SI and DI for each element
in the string. At completion the SI and DI registers will be pointing at the first item beyond the
string.
If the direction flag is set, then the 80x86 decrements si and di after processing each string
element. After a repeated string operation, the si and di registers will be pointing at the first byte
or
word before the strings if the direction flag was set.
The direction flag may be set or cleared using the cld (clear direction flag) and std (set direction
flag) instructions. When using these instructions inside a procedure keep in mind that they
modify
the machine state. Therefore you may need to save the direction flag during the execution of that
procedure.

MACRO:
Writing a macro is another way of ensuring modular programming in assembly language.
A macro is a sequence of instructions, assigned by a name and could be used anywhere in the
program.
In NASM, macros are defined with %macro and %endmacro directives.
The macro begins with the %macro directive and ends with the %endmacro directive.
The Syntax for macro definition −
%macro macro_name number_of_params
<macro body>
%endmacro
Where, number_of_params specifies the number parameters, macro_name specifies the name of
the macro.
The macro is invoked by using the macro name along with the necessary parameters. When you
need to use some sequence of instructions many times in a program, you can put those
instructions in a macro and use it instead of writing the instructions all the time.

PROCEDURE:
 Progressive Education Society's
Modern College of Engineering, Pune-05.
DEPARTMENT OF COMPUTER ENGINEERING

Procedures or subroutines are very important in assembly language, as the assembly language
programs
tend to be large in size. Procedures are identified by a name. Following this name, the body of
the procedure is described which performs a well-defined job. End of the procedure is indicated
by a return statement.
Syntax
Following is the syntax to define a procedure −
proc_name:
procedure body
...
ret
The procedure is called from another function by using the CALL
instruction. The CALL instruction should have the name of the called
procedure as an argument as shown below −
CALL proc_name
The called procedure returns the control to the calling procedure by using the RET instruction.

LIST OF INTERRRUPTS USED: NA

LIST OF ASSEMBLER DIRECTIVES USED: EQU, PROC, GLOBAL, DB,
LIST OF MACROS USED: DISPMSG
LIST OF PROCEDURES USED: DISPLAY

ALGORITHM:
INPUT: String
OUTPUT: Length of String in hex
STEP 1: Start.
STEP 2: Initialize data section.
STEP 3: Display msg1 on monitor
STEP 4: accept string from user and store it in Rsi Register (Its length gets stored in Rax register
by
default).
STEP 5: Display the result using “display” procedure. Load length of string in data register.
STEP 6. Take counter as 16 int cnt variable
STEP 7: move address of “result” variable into rdi.
STEP 8: Rotate left rbx register by 4 bit.

STEP 9: Move bl into al.

STEP 10: And al with 0fh
STEP 11: Compare al with 09h
STEP 12: If greater add 37h into al
STEP 13: else add 30h into al
STEP 14: Move al into memory location pointed by rdi
STEP 14: Increment rdi
 Progressive Education Society's
Modern College of Engineering, Pune-05.
DEPARTMENT OF COMPUTER ENGINEERING

STEP 15: Loop the statement till counter value becomes zero
STEP 16: Call macro dispmsg and pass result variable and length to it. It will print length of
string.
STEP 17: Return from procedure
STEP 18: Stop
FLOWCHART:
PROGRAM:
section .data
msg1 db 10,13,"Enter a string:"
len1 equ $-msg1
section .bss
str1 resb 200 ;string declaration
result resb 16
section .text
global _start
_start:
;display
mov Rax,1
mov Rdi,1
mov Rsi,msg1
mov Rdx,len1
syscall
;store string
mov rax,0
mov rdi,0

mov rsi,str1
mov rdx,200
syscall
call display
;exit system call
mov Rax ,60
mov Rdi,0
syscall

%macro dispmsg 2
mov Rax,1
mov Rdi,1
mov rsi,%1
mov rdx,%2
syscall
%endmacro

display:
mov rbx,rax ; store no in rbx
 Progressive Education Society's
Modern College of Engineering, Pune-05.
DEPARTMENT OF COMPUTER ENGINEERING

mov rdi,result ;point rdi to result variable

mov cx,16 ;load count of rotation in cl
up1:
rol rbx,04 ;rotate no of left by four bits
mov al,bl ; move lower byte in al
and al,0fh ;get only LSB
cmp al,09h ;compare with 39h
jg add_37 ;if greater than 39h skip add 37
add al,30h
jmp skip ;else add 30
add_37:
add al,37h
skip:
mov [rdi],al ;store ascii code in result variable
inc rdi ; point to next byte
dec cx ; decrement counter
jnz up1 ; if not zero jump to repeat
dispmsg result,16 ;call to macro

ret
OUTPUT:

CONCLUSION:

Assignment Questions (write-ups)

1. What is the use of addressing mode? And Explain its type.
2. Explain File Descriptor of Assembly program?
3. Explain with example string instructions of 80386 Microprocessor.
4. What is the maximum size of the instruction in 80386?
5. Which are string instructions?
6. In string operations which is by default a string source pointer?
7. In string operations which is by default a string destination pointer?
8. What is LEA? What is its use in our program?
9. Write Code of Hex to Ascii Procedure ?
10. What is a MacroProcessor?
11. What are the types of registers and their use?
12. What is addressing mode and its type?
13. Which file descriptors are used in an Assembly program?
14. What is a System call?Give examples of the same.
15. What is the use of Macro?
16. Which Assembler directive is used for macro?