JSPM’s

Rajshri Shahu School of Engineering and Research, Narhe,Pune- 41

Microprocessor lab
Laboratory Manual

Computer Engineering

Class: S.E. (Sem-II)

A.Y.: 2021-22
 Microprocessor lab
Laboratory Manual
Table of Contents
Sr . No. Topic Page. No.
1. Course Objective
2. Program Outcomes
3. Experiment Learning Outcome (ELO)
Sessions
Write an X86/64 ALP to accept five 64 bit Hexadecimal numbers
1. from user and store them in an array and display the accepted
numbers.
Write an X86/64 ALP to accept a string and to display its
2.
length.
Write an X86/64 ALP to find the largest of given
3.
Byte/Word/Dword/64-bit numbers.
Write a switch case driven X86/64 ALP to perform 64 -bit
4. hexadecimal arithmetic operations (+,-,*, /) using suitable macros.
Define procedure for each operation.
Write X86/64 ALP to count number of positive and negative
5. numbers from the array

Write 64 bit ALP to convert 4-digit Hex number into its equivalent
BCD number and 5-digit BCD number into its equivalent HEX
number. Make your program user friendly to accept the choice
6. from user for:
(a) HEX to BCD b) BCD to HEX (c) EXIT.
Display proper strings to prompt the user while accepting the input
and displaying the result. (use of 64-bitregisters is expected)
7. Write X86/64 ALP to switch from real mode to protected mode and
display the values of GDTR, LDTR, IDTR, TR and MSW
Registers
Write X86/64 ALP to perform non-overlapped block transfer
8. without string specific instructions. Block containing data can be
defined in the data segment.
Write X86/64 ALP to perform overlapped block transfer with string
9. specific instructions. Block containing data can be defined in the
data segment.
Write X86/64 ALP to perform multiplication of two 8-bit
10. hexadecimal numbers. Use successive addition and add and shift
method. (use of 64-bit registers is expected)
 Course Outcomes:
CO1: Understand and compare Architecture of advanced processors and its resources.
CO2: Apply assembly language programming to develop real life applications.
CO3: Implement parallel processing and math Co-processor.
CO4: Compare different processor configurations.

Program Outcomes: - Students are expected to know and be able –

1. To apply knowledge of mathematics, science, engineering fundamentals, problem

solving skills, algorithmic analysis and mathematical modelling to the solution of
complex engineering problems.

2. To analyze the problem by finding its domain and applying domain specific skills.

3. To understand the design issues of the product/software and develop effective solutions
with appropriate consideration for public health and safety, and cultural, societal, and
environmental considerations.

4. To find solutions of complex problems by conducting investigations applying suitable

techniques.

5. To adapt the usage of modern tools and recent software.

6. To contribute towards the society by understanding the impact of Engineering on global

aspect.

7. To understand environment issues and design a sustainable system.

8. To understand and follow professional ethics.

9. To function effectively as an individual and as member or leader in diverse teams and

interdisciplinary settings.

10. To demonstrate effective communication at various levels.

11. To apply the knowledge of Computer Engineering for development of projects, finance
and management.

12. To keep in touch with current technologies and inculcate the practice of lifelong
learning.
Experiment Learning Outcome:

ELO1: Apply logical instruction sets to segregate positive and negative numbers.

ELO2: Apply the concept of overlapped and non-overlapped block transfer in the program with
or without using string instruction.

ELO3: Convert hexadecimal number to BCD and vice versa with the help of assembly language
programming.

ELO4: Choose different multiplication methods such as add & shift and successive addition for
multiplication of two numbers without using MUL instruction.

ELO5: Analyze the difference between near and far procedure to find number of lines, blank
spaces & occurance of character using nasm.

ELO6: Apply the concept of real mode and protected mode in 8086 ALP to implement a
program to display values from GDTR, LDTR, IDTR, TR and MSW registers.

ELO7: Apply the bubble sort technique in 8086 to sort the input from text file.

ELO8: Implement DOS commands like TYPE,COPY, DELET using file operations.

ELO9: Apply the concept of recursion to find factorial of a number.

ELO10: Implement ALP to Calculate the roots of the quadratic equation with the help of
assembly language programming.

ELO11: Implement ALP to plot Sine Wave, Cosine Wave & Sinc function.

ELO12: Evaluate mean, variance and standard deviation using 8087 math coprocessor‟s
instruction set.

ELO13: Create Real Time Application using TSR

ELO to CO Mapping

CO: 1 CO: 2 CO: 3 CO: 4

ELO: 1 2 2 - -
ELO: 2 2 2 3 -
ELO: 3 2 2 - -
ELO: 4 1 3 - -
ELO: 5 1 2 - -
ELO: 6 - 2 - -
ELO: 7 - 2 - -
ELO: 8 - 2 - -
ELO: 9 - 2 3 -
ELO: 10 - 2 3 -
ELO: 11 - 3 3 -
ELO: 12 - 2 3 -
ELO: 13 - 3 - -
 EXPERIMENT NO.1

TITLE: Write an X86/64 ALP to accept five 64 bit Hexadecimal numbers from user and store
them in an array and display the accepted numbers.

OBJECTIVES:
1. To be familiar with the format of assembly language program structure and instructions.

2. To study the format of assembly language program along with different assembler
directives and different functions of the NASM.

3. To learn the procedure how to store N hexadecimal number in memory.

PROBLEM DEFINITION:
Write an X86/64 ALP to accept five 64 bit Hexadecimal numbers from user and store them in an
array and display the accepted numbers.

WORKING ENVIRONMENT:
1) CPU: Intel I5 Processor
2) OS:- Windows XP (16 bit Execution ), Fedora 18 (32 & 64 bit Execution)
3) Editor: gedit, GNU Editor
4) Assembler: NASM (Netwide Assembler)
5) Linker:-LD, GNU Linker

S/W AND H/W REQUIREMENT:

Software Requirements

1. CPU: Intel I5 Processor

2. OS:- Windows XP (16 bit Execution ), Fedora 18 (32 & 64 bit Execution)
3. Editor: gedit, GNU Editor
4. Assembler: NASM (Netwide Assembler)

INPUT: Five hexadecimal numbers

OUTPUT: Five hexadecimal numbers
THEORY

AssemblylanguageProgram is mnemonic representation ofmachine code.Three assemblers

available for assembling the programs for IBM-PC are:

1. Microsoft Micro Assembler(MASM)

2. Borland Turbo Assembler(TASM)
3. Net wide Assembler(NASM)
Assembly Basic Syntax
An assembly program can be divided into three sections:
1. The data section
2. The bss section
3. The text section
The data Section
The data section is used for declaring initialized data or constants. This data does not change at
runtime. Youcan declare various constant values, file names or buffer size etc. in this section.
The syntax for declaring data section is:
section.data

The bss Section

The bss section is used for declaring uninitialized data or variables. The syntax for declaring bss
section is:
section .bss

The text section

The text section is used for writing the actual code. This section must begin with the declaration
global _start, which tells the kernel where the program execution begins.
The syntax for declaring text section is:
section .text
global _start
_start:
Assembly Language Statements
Assembly language programs consist of three types of statements:
1. Executable instructions or instructions
2. Assembler directives or pseudo-ops
3. Macro
 The executable instructions or simply instructions tell the processor what to do. Each
instruction consists of an operation code (opcode). Each executable instruction generates one
machine language instruction.
The assembler directives or pseudo-ops tell the assembler about the various aspects of the
assembly process.
These are non-executable and do not generate machine language instructions.
Macros are basically a text substitution mechanism.
Assembly System Calls
System calls are APIs for the interface between user space and kernel space. We are using the
system calls sys_write and sys_exit for writing into the screen and exiting from the program
respectively.
Linux System Calls (32 bit)
You can make use of Linux system calls in your assembly programs. You need to take the
following steps for using Linux system calls in your program:
• Put the system call number in the EAX register.
• Store the arguments to the system call in the registers EBX, ECX, etc.
• Call the relevant interrupt (80h)
• The result is usually returned in the EAX register

There are six registers that stores the arguments of the system call used. These are the EBX,
ECX, EDX, ESI, EDI, and EBP. These registers take the consecutive arguments, starting with
the EBX register. If there are more than six arguments then the memory location of the first
argument is stored in the EBX register.
Instructions needed:

EQU- Assign single absolute values to symbols.

MOV- Copies byte or word from specified source to specified destination

CALL- The CALL instruction causes the procedure named in the operand to be executed.

JNZ-Jumps if not equal to Zero

JNC-Jumps if no carry is genera

 EXPERIMENT NO.2

TITLE: Accept a string and to display its length.

OBJECTIVES:
1. To learn the instructions related to String
2. To be familiar with data segments.
3. To learn the instructions related to String operation

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

WORKING ENVIRONMENT:
1. CPU: Intel I5 Processor
2. OS:- Windows XP (16 bit Execution ), Fedora 18 (32 & 64 bit Execution)
3. Editor: gedit, GNU Editor
4. Assembler: NASM (Netwide Assembler)
5. Linker:-LD, GNU Linker

S/W AND H/W REQUIREMENT:

Software Requirements

1. CPU: Intel I5 Processor

2. OS:- Windows XP (16 bit Execution ), Fedora 18 (32 & 64 bit Execution)
3. Editor: gedit, GNU Editor
4. Assembler: NASM (Netwide Assembler)
5. Linker:-LD, GNU Linker

INPUT: String data.

OUTPUT: Display input string and calculate its length

THEORY:

A few data-manipulation instructions implicitly use specialized addressing methods:

● For a few short forms of MOV that implicitly use the EAX register, the offset of the
operand is coded as a doubleword in the instruction. No base register, index register, or
 scaling factors are used.

● String operations implicitly address memory via DS:ESI, (MOVS, CMPS, OUTS,
LODS, SCAS) or via ES:EDI (MOVS, CMPS, INS, STOS).

● Stack operations implicitly address operands via SS:ESP registers; e.g., PUSH, POP,
PUSHA, PUSHAD, POPA, POPAD, PUSHF, PUSHFD, POPF, POPFD, CALL, RET,
IRET, IRETD, exceptions, and interrupts.

The instructions in this category operate on strings rather than on logical or numeric values.
Refer also to the section on I/O for information about the string I/O instructions (also known as
block I/O).

The primitive string operations operate on one element of a string. A string element may be a
byte, a word, or a doubleword. The string elements are addressed by the registers ESI and EDI.
After every primitive operation ESI and/or EDI are automatically updated to point to the next
element of the string. If the direction flag is zero, the index registers are incremented; if one, they
are decremented. The amount of the increment or decrement is 1, 2, or 4 depending on the size of
the string element.

The REP prefixes apply only to one string instruction at a time. To repeat a block of instructions,
use the LOOP instruction or another looping construct.

The precise action for each iteration is as follows:

1. If the address-size attribute is 16 bits, use CX for the count register; if the address-size
attribute is 32 bits, use ECX for the count register.
2. Check CX. If it is zero, exit the iteration, and move to the next instruction.
3. Acknowledge any pending interrupts.
4. Perform the string operation once.
5. Decrement CX or ECX by one; no flags are modified.
6. Check the zero flag if the string operation is SCAS or CMPS. If the repeat condition does not
hold, exit the iteration and move to the next instruction. Exit the iteration if the prefix is REPE
and ZF is 0 (the last comparison was not equal), or if the prefix is REPNE and ZF is one (the last
comparison was equal).
7. Return to step 1 for the next iteration.

Instructions needed:
MOVS: Move String
CMPS: Compare string
SCAS: Scan string
LODS: Load string
STOS: Store string
ESI: Source index register
EDI: Destination index register
REP: Repeat while ECX not xero
REPE/REPZ: Repeat while equal or zero
REPNE/REPNZ: Repeat while not equal or not zero
 EXPERIMENT NO.3
TITLE: Find the largest of given Byte/Word/Dword/64-bit numbers.

OBJECTIVES:
1. To understanding of basic data structure
2. To compare the different data structure
3. To make usage of different data structure for hexadecimal number

PROBLEM DEFINITION:
Write an X86/64 ALP to find the largest of given Byte/Word/Dword/64-bit numbers.

WORKING ENVIRONMENT:
6. CPU: Intel I5 Processor
7. OS:- Windows XP (16 bit Execution ), Fedora 18 (32 & 64 bit Execution)
8. Editor: gedit, GNU Editor
9. Assembler: NASM (Netwide Assembler)
10. Linker:-LD, GNU Linker

S/W AND H/W REQUIREMENT:

Software Requirements

6. CPU: Intel I5 Processor

7. OS:- Windows XP (16 bit Execution ), Fedora 18 (32 & 64 bit Execution)
8. Editor: gedit, GNU Editor
9. Assembler: NASM (Netwide Assembler)
10. Linker:-LD, GNU Linker

INPUT: No of hexadecimal numbers

OUTPUT: Largest number form entered numbers

THEORY:

Data Types

Integer:
A signed binary numeric value contained in a 32-bit doubleword,16-bit word, or
8-bit byte. All operations assume a 2's complement representation. The sign bit is located
in bit 7 in a byte, bit 15 in a word, and bit 31 in a doubleword. The sign bit has the value
zero for positive integers and one for negative. Since the high-order bit is used for a sign,
the range of an 8-bit integer is -128 through +127; 16-bit integers may range from -
32,768 through +32,767; 32-bit integers may range from -231 through +231-1. The value
zero has a positive sign.

Ordinal:
An unsigned binary numeric value contained in a 32-bit doubleword, 16-bit word,
or 8-bit byte. All bits are considered in determining magnitude of the number. The value
range of an 8-bit ordinal number is 0-255; 16 bits can represent values from 0 through
65,535; 32 bits can represent values from 0 through 232-1.

Near Pointer:
A 32-bit logical address. A near pointer is an offset within a segment. Near
pointers are used in either a flat or a segmented model of memory organization.

Far Pointer:
A 48-bit logical address of two components: a 16-bit segment selector component
and a 32-bit offset component. Far pointers are used by applications programmers only
when systems designers choose a segmented memory organization.

String:
A contiguous sequence of bytes, words, or doublewords. A string may contain
from zero bytes to 232-1 bytes (4 gigabytes).

Bit field:
A contiguous sequence of bits. A bit field may begin at any bit position of any
byte and may contain up to 32 bits.

Bit string:
A contiguous sequence of bits. A bit string may begin at any bit position of any
byte and may contain up to 232-1 bits.

BCD:
A byte (unpacked) representation of a decimal digit in the range0 through 9.
Unpacked decimal numbers are stored as unsigned byte quantities. One digit is stored in
each byte. The magnitude of the number is determined from the low-order half-byte;
hexadecimal values 0-9 are valid and are interpreted as decimal numbers.

Packed BCD:
A byte (packed) representation of two decimal digits, each in the range 0 through
9. One digit is stored in each half-byte. The digit in the high-order half-byte is the most
significant. Values 0-9 are valid in each half-byte. The range of a packed decimal byte is
0-99.
Instructions needed:

ROL: Rotate 32 bits r/m dword left CL times

JBE: Jump short if below or equal
INC: Increment dword register by 1
DEC: Decrement dword register by 1
 EXPERIMENT NO.4

TITLE
Switch case driven X86/64 ALP to perform 64-bit hexadecimal arithmetic operations (+,-,*, /)
using suitable macros.

OBJECTIVES:
1. To understand the looping stamens
2. To understand switch case
3. To analyze the different arithmetic operations

PROBLEM DEFINITION:

Write a switch case driven X86/64 ALP to perform 64-bit hexadecimal arithmetic operations (+,-
,*, /) using suitable macros. Define procedure for each operation.

WORKING ENVIRONMENT:
11. CPU: Intel I5 Processor
12. OS:- Windows XP (16 bit Execution ), Fedora 18 (32 & 64 bit Execution)
13. Editor: gedit, GNU Editor
14. Assembler: NASM (Netwide Assembler)
15. Linker:-LD, GNU Linker

S/W AND H/W REQUIREMENT:

Software Requirements

11. CPU: Intel I5 Processor

12. OS:- Windows XP (16 bit Execution ), Fedora 18 (32 & 64 bit Execution)
13. Editor: gedit, GNU Editor
14. Assembler: NASM (Netwide Assembler)
15. Linker:-LD, GNU Linker

INPUT: Two hexadecimal numbers

OUTPUT: Arithmetic operation performed on two entered numbers

THEORY:

Conditional Transfer Instructions

The conditional transfer instructions are jumps that may or may not transfer control, depending
on the state of the CPU flags when the instruction executes.

• Conditional Jump Instructions

The conditional jumps that are listed as pairs are actually the same instruction.
The assembler provides the alternate mnemonics for greater clarity within a program
listing. Conditional jump instructions contain a displacement which is added to the EIP
register if the condition is true. The displacement may be a byte, a word, or a
doubleword. The displacement is signed; therefore, it can be used to jump forward or
backward.

• Loop Instructions
The loop instructions are conditional jumps that use a value placed in ECX to
specify the number of repetitions of a software loop. All loop instructions automatically
decrement ECX and terminate the loop when ECX=0. Four of the five loop instructions
specify a condition involving ZF that terminates the loop before ECX reaches zero.
LOOP (Loop While ECX Not Zero) is a conditional transfer that automatically
decrements the ECX register before testing ECX for the branch condition. If ECX is non-
zero, the program branches to the target label specified in the instruction. The LOOP
instruction causes the repetition of a code section until the operation of the LOOP
instruction decrements ECX to a value of zero. If LOOP finds ECX=0, control transfers
to the instruction immediately following the LOOP instruction. If the value of ECX is
initially zero, then the LOOP executes 232 times.
 EXPERIMENT NO.5

TITLE: Write an ALP to count numbers of positive and negative numbers from the array.

OBJECTIVES:
4. To be familiar with the format of assembly language program structure and instructions.

5. To study the format of assembly language program along with different assembler
directives and different functions of the NASM.

6. To learn the procedure how to store N hexadecimal number in memory.

PROBLEM DEFINITION:
Write X86/64 Assembly language program (ALP) to count number of positive and negative
numbers from array.

WORKING ENVIRONMENT:
6) CPU: Intel I5 Processor
7) OS:- Windows XP (16 bit Execution ), Fedora 18 (32 & 64 bit Execution)
8) Editor: gedit, GNU Editor
9) Assembler: NASM (Netwide Assembler)
10) Linker:-LD, GNU Linker

S/W AND H/W REQUIREMENT:

Software Requirements

5. CPU: Intel I5 Processor

6. OS:- Windows XP (16 bit Execution ), Fedora 18 (32 & 64 bit Execution)
7. Editor: gedit, GNU Editor
8. Assembler: NASM (Netwide Assembler)

INPUT:Hexadecimal numbers
OUTPUT:Number of Negative numbers, Number of Positive numbers
The following code snippet shows the use of the system call sys_exit:
MOV EAX, 1 ; system call number (sys_exit)
INT 0x80 ; call kernel
The following code snippet shows the use of the system call sys_write:
MOV EAX,4; system call number (sys_write)
MOV EBX,1; file descriptor (stdout)
MOV ECX, MSG ; message to write
MOV EDX, 4; message length
INT0x80; call kernel
Linux System Calls (64 bit)
Sys_write:
MOV RAX,1
MOV RDI,1
MOV RSI,message
MOV RDX,message_length
SYSCALL

Sys_read:
MOV RAX,0
MOV RDI,0
MOV RSI,array_name
MOV RDX,array_size
SYSCALL

Sys_exit:
MOV RAX,60
MOV RDI,0
SYSCALL

Assembly Variables
NASM provides various define directives for reserving storage space for variables. The define
Assembler directive is used for allocation of storage space. It can be used to reserve as well as
initialize one or more bytes.
Allocating Storage Space for Initialized Data
There are five basic forms of the define directive:

Allocating Storage Space for Uninitialized Data

The reserve directives are used for reserving space for uninitialized data. The reserve directives
take a single operand that specifies the number of units of space to be reserved. Each define
directive has a related reserve directive.
There are five basic forms of the reserve directive:

Instructions needed:

1. MOV-Copies byteorword from specified sourceto specified destination

2. ROR-Rotates bits ofbyteorwordright,LSBto MSBand to CF

3. AND-AND each bit in abyteorword with correspondingbit in anotherbyteorword

 4. INC-Increments specified byte/word by1

5. DEC-Decrements specified byte/word by1

6. JNZ-Jumps ifnot equal to Zero

7. JNC-Jumps ifno carryisgenerated

8. CMP-Compares to specified bytes orwords

9. JBE-Jumps ifbelow ofequal

10. ADD-Adds specified byteto byteorword to word

11. CALL-Transfers the control from callingprogramto procedure.

12. RET-Return from where call is made

MATHEMATICAL MODEL:

Let S = { s , e , X, Y, Fme, mem│Φs } be the programmer’s perspective of Array Addition

Where

S = System
s =Distinct Start of System
e = Distinct End Of System
X = Set of Inputs
Y= Set Of outputs
Fme = Central Function
Mem= Memory Required
Φs = Constraits

Let X be the input such that

X= { X1, X2,X3, ------ }
Such that there exists function fx1 : X1 {0,1}
X2 Source Array
Let X2 = {{b7-----b0}{ b7-------b0}--------{b7 b6 b5 b4 b3 b2 b1 b0}} where  bi Є X1
There exists a function fX2 :X2 { {00h----FFh}{00h----FFh }{00h----FFh} ------ }

X3 is the two digit count value

Let X3 = b7 b6 b5 b4 b3 b2 b1 b0 where  bi Є X1
There exists a function fX3: X3 { 01h,02h,-,- FFh}

Let Y is the Output

Let Y= b15 b14 b13 b12 b11 b10 b9 b8 b7 b6 b5 b4 b3 b2 b1 b0
Where bi Є X1
Y { 0000h,0001h, ------ FFFFh}

Let Fme = { F1 ,F2,F3 }

Where F1 = Accept
F2 = Count
F3 = Display

F1 1) Accept the number stored in array.

F2 Y = ∑ ( X2)

F3 Display Output

Output:

;[root@comppl2022 ~]# nasm -f elf64 Exp9.asm

;[root@comppl2022 ~]# ld -o Exp9 Exp9.o
;[root@comppl2022 ~]# ./Exp9
;Welcome to count +ve and -ve numbers in an array
;Count of +ve numbers::04
;Count of -ve numbers::03
;[root@comppl2022 ~]#

OUTCOME

Upon completion Students will be able to:

ELO1: Apply logical instruction sets to segregate positive and negative numbers.
EXPERIMENT NO.6
TITLE: Hex to BCD & BCD to Hex Conversion.
OBJECTIVES:
To Learn the implementation of ALP for conversion of Hex to BCD & vice a versa.

PROBLEM STATEMENT:
To write 64 bit ALP to convert 4-digit Hex number into its equivalent BCD number and 5-digit
BCD number into its equivalent HEX number. Make your program user friendly to accept the
choice from user for: (a) HEX to BCD b) BCD to HEX (c) EXIT.
Display proper strings to prompt the user while accepting the input and displaying the result.

SOFTWARE REQUIRED:
9. CPU: Intel I5 Processor
10. OS:- Windows XP (16 bit Execution ), Fedora 18 (32 & 64 bit Execution)
11. Editor: gedit, GNU Editor
12. Assembler: NASM (Netwide Assembler)
13. Linker:-LD, GNU Linker

INPUT:

1. Hexadecimal number
2. BCD Number

OUTPUT:
1. Conversion of hex to BCD number

2. Coversion of BCD to hex number

MATHEMATICAL MODEL:

Let S = { s , e , X, Y, Fme, mem│Φs } be the programmer‟s perspective of Hex to BCD

& BCD to hex conversion .
 Let X be the input such that
X= { X1, X2,X3, ------ }
Such that there exists function fx1 : X1 {0,1}

X2 is the four Digit Hex Number.

Let X2 = b15 b14 b13 b12 b11 b10 b9 b8 b7 b6 b5 b4 b3 b2 b1 b0 where
 bi Є X1. There exists a function fX2 : X2 { 0000h,0001h,0002h,-,- FFFFh}

X3 is the Five digit BCD number.

Let X3 = b19 b18 b17 b16 b15 b14 b13 b12 b11 b10 b9 b8 b7 b6 b5b4 b3 b2 b1 b0
where  bi Є X1
There exists a function fX3: X3 { 00000,00001, ------ 99999}

X4 is the Single digit choice.

Let X4 = b3 b2 b1 b0 where  bi Є X1
There exists a function fX4: X4 { 1,2,3}

Let Y1 is the 5 Digit BCD Output

Let Y= b19 b18 b17 b16 b15 b14 b13 b12 b11 b10 b9 b8 b7 b6 b5 b4 b3 b2 b1 b0
Where  bi Є X1
Y1 { 00000,00001, ------ 99999}

Let Y2 is the 4 Digit Hex Output

Let Y= b15 b14 b13 b12 b11 b10 b9 b8 b7 b6 b5 b4 b3 b2 b1 b0
Where  bi Є X1
Y1 { 0000h,0001h, ------ FFFFh}

Fme 1( Hex to bcd ) = { F1 ,F2,F3 }

Where F1 = Accept X2
F2 = Repeat (X2/10) till quotient =0 & push Remainder on stack
F3 = Pop remainder from stack & display

Fme 2(bcd to hex) = { F1 ,F2,F3,F4 }

Where F1 = Accept BCD digit X3i
F2 = Result= Result*10 + X3i & i=i-1 (Initially Result=0)
F3= repeat F1 onwards untill i=0
F4= Display Result
Fme 3(exit)= {F1}
Where F1= Call Sys_exit Call

Fme = { F1,F2,F3,F4}
Where F1= Accept X4
F2= If X4=1, Call Fme1
F3= If X4=2,Call Fme2
F4= If X4=3, Call Fme3

THEORY:
1. Hexadecimal to BCD conversion:

Conversion of a hexadecimal number can be carried out in different ways e.g. dividing
number by 000Ah and displaying quotient in reverse way.

2. BCD to Hexadecimal number:

Conversion of BCD number to Hexadecimal number can be carried out by multiplying the
BCD digit by its position value and the adding it in the final result.

Special instructions used:

DIV: Unsigned Divide. Result → Quotient in AL and Remainder in AH for 8-bit division
and for 16-bit division Quotient in AX and Remainder in DX

MUL: Unsigned Multiply. For 8-bit operand multiplication result will be stored in AX and
for 16-bit multiplication result is stored in DX:AX

Commands

• To assemble

nasm –f elf 64 hello.nasm -o hello.o

• To link

ld –o hello hello.o

• To execute -
 ./hello

Output:
;[admin@localhost ~]$ vi conv.nasm
;[admin@localhost ~]$ nasm -f elf64 conv.nasm -o conv.o
;[admin@localhost ~]$ ld -o conv conv.o
;[admin@localhost ~]$ ./conv

;###### Menu for Code Conversion ######

;1: Hex to BCD
;2: BCD to Hex
;3: Exit

;Enter Choice:1

;Enter 4 digit hex number::FFFF

;BCD Equivalent::65535

;###### Menu for Code Conversion ######

;1: Hex to BCD
;2: BCD to Hex
;3: Exit

;Enter Choice:1

;Enter 4 digit hex number::00FF

;BCD Equivalent::255

;###### Menu for Code Conversion ######

;1: Hex to BCD
;2: BCD to Hex
;3: Exit

;Enter Choice:2

;Enter 5 digit BCD number::65535

;Hex Equivalent::0FFFF

OUTCOME
Upon completion Students will be able to:

ELO3: Convert hexadecimal number to BCD and vice versa with the help of assembly language
programming.
 EXPERIMENT NO.7

TITLE: Write X86/64 ALP to switch from real mode to protected mode and display the values
of GDTR, LDTR, IDTR, TR and MSW Registers.

OBJECTIVES:

1. To be familiar with the format of assembly language program structure and instructions.

2. To study GDTR, LDTR and IDTR.

PROBLEM DEFINITION:
Write X86/64 ALP to switch from real mode to protected mode and display the values of GDTR,
LDTR, IDTR, TR and MSW Registers.

WORKING ENVIRONMENT:

1) CPU: Intel I5 Processor

2) OS:- Windows XP (16 bit Execution ), Fedora 18 (32 & 64 bit Execution)
3) Editor: gedit, GNU Editor
4) Assembler: NASM (Netwide Assembler)
5) Linker:-LD, GNU Linker

S/W AND H/W REQUIREMENT:

Software Requirements
1. CPU: Intel I5 Processor
2. OS:- Windows XP (16 bit Execution ), Fedora 18 (32 & 64 bit Execution)
3. Editor: gedit, GNU Editor
4. Assembler: NASM (Netwide Assembler)

INPUT: system file

OUTPUT: contents of GDTR, LDTR and IDTR.
THEORY:

Four registers of the 80386 locate the data structures that control segmented memory
management called as memory management registers:
1. GDTR :Global Descriptor Table Register
These register point to the segment descriptor tables GDT. Before any segment register is
changed in protected mode, the GDT register must point to a valid GDT. Initialization of the
GDT and GDTR may be done in real-address mode. The GDT (as well as LDTs) should reside in
RAM, because the processor modifies the accessed bit of descriptors. The instructions LGDT
and SGDT give access to the GDTR.
2. LDTR :Local Descriptor Table Register
These register point to the segment descriptor tables LDT. The LLDT instruction loads a linear
base address and limit value from a six-byte data operand in memory into the LDTR. The SLDT
instruction always store into all 48 bits of the six-byte data operand.
3. IDTR Interrupt Descriptor Table Register
This register points to a table of entry points for interrupt handlers (the IDT). The LIDT
instruction loads a linear base address and limit value from a six-byte data operand in memory
into the IDTR. The SIDT instruction always store into all 48 bits of the six-byte data operand.
4. TR Task Register
This register points to the information needed by the processor to define the current task.
These registers store the base addresses of the descriptor tables (A descriptor table is
simply a memory array of 8-byte entries that contain
Descriptors and descriptor stores all the information about segment) in the linear address space
and store the segment limits.
SLDT: Store Local Descriptor Table Register
Operation: DEST ← 48-bit BASE/LIMIT register contents;
Description: SLDT stores the Local Descriptor Table Register (LDTR) in the two-byte register
or memory location indicated by the effective address operand. This register is a selector that
points into the Global Descriptor Table. SLDT is used only in operating system software. It is
not used in application programs.
Flags Affected: None
SGDT: Store Global Descriptor Table Register
Operation: DEST ← 48-bit BASE/LIMIT register contents;
Description: SGDT copies the contents of the descriptor table register the six bytes of memory
indicated by the operand. The LIMIT field of the register is assigned to the first word at the
effective address. If the operand-size attribute is 32 bits, the next three bytes are assigned the
BASE field of the register, and the fourth byte is written with zero. The last byte is undefined.
Otherwise, if the operand-size attribute is 16 bits, the next 4 bytes are assigned the 32-bit BASE
field of the register. SGDT and SIDT are used only in operating system software; they are not
used in application programs.
Flags Affected: None
SIDT: Store Interrupt Descriptor Table Register
Operation: DEST ← 48-bit BASE/LIMIT register contents;
Description: SIDT copies the contents of the descriptor table register the six bytes of memory
indicated by the operand. The LIMIT field of the register is assigned to the first word at the
effective address. If the operand-size attribute is 32 bits, the next three bytes are assigned the
BASE field of the register, and the fourth byte is written with zero. The last byte is undefined.
Otherwise, if the operand-size attribute is 16 bits, the next 4 bytes are assigned the 32-bit BASE
field of the register. SGDT and SIDT are used only in operating system software; they are not
used in application programs.
Flags Affected: None

OUTCOME:

Upon completion Students will be able to:

ELO6: Apply the concept of real mode and protected mode in 8086 ALP to implement a
program to display values from GDTR, LDTR, IDTR, TR and MSW registers.
 EXPERIMENT NO. 08 and 09

TITLE: Non-overlapped and overlapped block transfer

OBJECTIVES:
4. To be familiar with the format of assembly language program along with different
assembler directives and different functions of the DOS Interrupt.
5. To learn the instructions related to String and use of Direction Flag.
6. To be familiar with data segments.
7. Implement non-overlapped and overlapped block transfer.

PROBLEM DEFINITION:
Write X86/64 ALP to perform non-overlapped and overlapped block transfer (with and without
string specific instructions). Block containing data can be defined in the data segment.

WORKING ENVIRONMENT:
11) CPU: Intel I5 Processor
12) OS:- Windows XP (16 bit Execution ), Fedora 18 (32 & 64 bit Execution)
13) Editor: gedit, GNU Editor
14) Assembler: NASM (Netwide Assembler)
15) Linker:-LD, GNU Linker

S/W AND H/W REQUIREMENT:

Software Requirements

14. CPU: Intel I5 Processor

15. OS:- Windows XP (16 bit Execution ), Fedora 18 (32 & 64 bit Execution)
16. Editor: gedit, GNU Editor
17. Assembler: NASM (Netwide Assembler)
Linker:-LD, GNU Linker

INPUT: Input data specified in program.

OUTPUT: Display the data present in destination block.

THEORY:

1. Non-overlapped blocks:
 In memory, two blocks are known as non-overlapped when none of the element is
common.

AD
9D
Memory Block 2
78
09
FF
28 Memory Block 1
F4
3F
FD
BB
AA

0D

In above example of non-overlapped blocks there is no common element between block 1

& 2.
While performing block transfer in case of non-overlapped blocks, we can start transfer
from starting element of source block to the starting element of destination block and
then we can transfer remaining elements one by one.

2. Overlapped block:
In memory, two blocks are known as overlapped when at least one element is common
between two blocks.

While performing block transfer we have to see which element/s of source block is/are
overlapped. If ending elements are overlapped then start transferring elements from last
and if starting elements are overlapped then start transfer from first element.
 AD
9D
Memory Block 2
78
09
Common Element
FF
28
F4
Memory Block 1
3F
FD
BB
AA
0D

Instructions needed:
1. MOVSB-Move string bytes.

2. JNE-Jump if not equal

3. AND-AND each bit in a byte or word with corresponding bit in another byte or word

4. INC-Increments specified byte/word by 1

5. DEC-Decrements specified byte/word by 1

6. JNZ-Jumps if not equal to Zero

7. CMP-Compares to specified bytes or words

8. JBE-Jumps if below of equal

9. CALL-Transfers the control from calling program to procedure.0

10. RET-Return from where call is made

 Mathematical Model:
Let S = { s , e , X, Y, Fme, mem│Φs } be the programmer’s perspective of Non-over
Lapped & overlapped Block Transfer.

1) Non-Overlapped Block Transfer.

Let X be the input such that
X= { X1, X2,X3, ------ }
Such that there exists function fx1 : X1 {0,1}

X2 Source Array
Let X2 = {{b7-----b0}{ b7-------b0}--------{b7 b6 b5 b4 b3 b2 b1 b0}} where  bi Є X1
There exists a function fX2 : X2 { {00h----FFh}{00h----FFh }{00h----FFh} ----- }

X3 is destination array before transfer

Let X3={{b7-----b0}{ b7-------b0}--------{b7 b6 b5 b4 b3 b2 b1 b0}} where  bi Є X1
There exists a function fX3 : X3 {{00h----FFh}{00h----FFh }{00h----FFh} ------- }

X4 is the two digit count value equal to length of block

Let X4 = b7 b6 b5 b4 b3 b2 b1 b0 where  bi Є X1
There exists a function fX4: X4 { 01h,02,-,- ,- FFh}

X5 is the Single digit choice.

Let X5 = b3 b2 b1 b0 where  bi Є X1
There exists a function fX5: X5 { 1,2,3}

Let Y is the Destination Block after transfer

Let Y= ={{b7-----b0}{ b7-------b0}--------{b7 b6 b5 b4 b3 b2 b1 b0}} where  bi Є X1
Where  bi Є X1
Y { {00h----FFh}{00h----FFh }{00h----FFh} ----- }

Fme = { F1 ,F2,F3 ,F4}

Where F1 = Display X2 & X3 (Source block & Destination block before Transfer)
F2 = Copy Byte from X2 (source block) to Y( destination block)
F3 = Increment Source & destination pointer, X4=X4-1, If not zero repeat F2
& F3
F4= Display Y
 2) Overlapped Block Transfer.
Let X be the input such that
X= { X1, X2,X3, ------ }
Such that there exists function fx1 : X1 {0,1}

X2 Source Array
Let X2 = {{b7-----b0}{ b7-------b0}--------{b7b6 b5 b4 b3 b2 b1
b0}{00H}{00H}{00H}{00H}{00H}} where  bi Є X1
There exists a function fX2 : X2 { {00h----FFh}{00h----FFh }{00h----FFh}------
{00h}{00h}{00h}{00h}{00h}}

X3 is the two digit count value equal to length of block

Let X3 = b7 b6 b5 b4 b3 b2 b1 b0 where  bi Є X1
There exists a function fX3: X3 { 01h,02,-,- ,- FFh}

X4 is the Single digit choice.

Let X4 = b3 b2 b1 b0 where  bi Є X1
There exists a function fX4: X4 { 1,2,3}

X5 is the position of overlapping

Let X4 = b7 b6 b5 b4 b3 b2 b1 b0 where  bi Є X1
There exists a function fX5: X5 { 01h,02h,03h,04h,05h}

Let Y is the Destination Block after transfer

Let Y= ={{b7-----b0}{ b7-------b0}--------{b7 b6 b5 b4 b3 b2 b1 b0}} where  bi Є X1
Where  bi Є X1
Y { {00h----FFh}{00h----FFh }{00h----FFh} ----- }

Fme = { F1 ,F2,F3 ,F4,F5,F6}

Where F1 = Accept X5
F2 = Point to end of source block X2
F3 = pointer to Y= (pointer to X2)+X5
F4 = Copy Byte from X2 (source block) to Y( destination block)
F5 = Decrement Source & destination pointer, X3=X3-1, If not zero repeat F4&F5
F6 = Display Y
Commands
• To assemble
nasm –f elf 64 hello.nasm -o hello.o
• To link
ld –o hello hello.o
• To execute -
./hello

Output:

[root@comppl208 nasm-2.10.07]# gedit nonoverlap26.asm

[root@comppl208 nasm-2.10.07]# nasm -f elf64 nonoverlap26.asm
[root@comppl208 nasm-2.10.07]# ld -o nonoverlap26 nonoverlap26.o
[root@comppl208 nasm-2.10.07]# ./nonoverlap26

**Block contents before transfer:

*_*Source block contents 01 02 03 04 05
*_*Destination block contents 00 00 00 00 00

***Nonoverlap block transfer***

1.Block transfer without string
2.Block transfer with string
3.exit 1

**Block contents after transfer:

*_*Source block contents 01 02 03 04 05
*_*Destination block contents 01 02 03 04 05

[root@comppl208 nasm-2.10.07]# ./nonoverlap26

**Block contents before transfer:

*_*Source block contents 01 02 03 04 05
*_*Destination block contents 00 00 00 00 00

***Nonoverlap block transfer***

1.Block transfer without string
2.Block transfer with string
3.exit 2
*_*Source block contents 01 02 03 04 05
*_*Destination block contents 01 02 03 04 05
**Block contents after transfer:
*_*Source block contents 01 02 03 04 05
*_*Destination block contents 01 02 03 04 05

[root@comppl208 nasm-2.10.07]# ./nonoverlap26

**Block contents before transfer:

*_*Source block contents 01 02 03 04 05
*_*Destination block contents 00 00 00 00 00

***Nonoverlap block transfer***

1.Block transfer without string

2.Block transfer with string
3.exit 3
[root@comppl208 nasm-2.10.07]#

OUTCOME
Upon completion Students will be able to:

ELO2: Apply the concept of overlapped and non-overlapped block transfer in the program with
or without using string instruction.
 EXPERIMENT NO.10

TITLE: Multiplication of two 8 bit nos. using Successive addition and Shift and add
method
OBJECTIVES:
1. Understand the implementation.
2. To interpret the Microprocessor Interfacing paradigms.
3. To express and apply the method of odd, add and shift method.
4. Understand implememtation of arithmetic instruction of 8086.
PROBLEM STATEMENT:
Write 8086/64 ALP to perform multiplication of two 8 bit hexadecimal nos. Use successive
addition & shift & add method, Accept i/p from the user.

HARDWARE REQUIRED:
CPU: Intel i5 Processor
OS:Windows XP (16 bit execution), Fedora 18 32 & 64 bit execution

SOFTWARE REQUIRED:

Editer: gedit, GNU Editor

Assembler: NASM (Netwide Assembler)

Linker: GNU Linker

INPUT: Two hex nos.

For e.g. AL=12H, BL= 10H

OUTPUT:

Result : D120H

THEORY:
There are 5 basic form of define reverse directives.
Directives Purpose
DD Define byte
DW Define word
DD Define doubleword
DQ Define quad word
DT Define Ten byte
RESB Reserve byte
RESW Reserve word
RESQ Reserve quad word
REST Reserve ten word

Instructions Needed:
MOV : Move or copy word
ROR : Rotate to right
AND : Logical AND
INC : Increment
DEC : Decrement
JNZ : Jump if not zero
CMP : Compare
JNC : Jump if no carry
JBE : Jump if below

Shift & Add method:

The method taught in school for multiplying decimal no. is based on calculated partial products,
shifting it to the left & then adding them together. Shift & add multilplication is similar to the
multiplication performed by paper & pencil. This method adds the multiplicand X to itself Y
times where Y denotes the multiplier. To multiply two nos. by paper & pencil placing the
intermediate product in the appropriate positions to the left of earlier product.

1. Consider 1 byte is in AL & another in BL

2. We have to multiply byte in AL with byte in BL
3. In this method, you add 1 with itself & rotate other no. each times &shift it by 1 bit n left
along with carry
4. If carry is present add 2 NOS.
5. Initialize count to n as we are scanning for n digit decrement counter each time, the bits
are added

The result is stored in AX, display the result.

Eg., AH=11H, BL=10H, Count=n

Step 1:

AX=11 + 11 = 22H

Rotate BL by 1 bit to left along with carry 0001 0000

B1=10H 0010 0000 (20)

Step 2:

Decrement count =3

Check for carry, carry is not there So Add with itself

AX=22+22=44H

Rotate BL to left

BL=0 0000 0000 (00)

No carry
Step 3:

Decrement count=2

Add no. with itself

AX=44+44=88H

Rotate BL to left

B2=0 (carry) 1000 0000 (80)

Step 4:

Decrement count=0

Add no. with itself,

AX=88+88=110H

Rotate BL to left

BL=0 (carry) 1000 0000 (80)

Step 5:

Decrement count =0, carry is generated

Add Ax, BX

0110+0000=0110H

i.e.,

11H+10H=0110H

MATHEMATICAL MODEL:
Let S={s, e, x, y, time, mem ᶲs} be program perspective of multiplication of two 8 bit
hexadecimal Nos.

Let X be the input such that

X={x1, x2, x3, .................... }

Such that there exists function fx1: x{0, 1}

X2={s the two digit multiplicate }

Let x2= b7 b6 b5 b4 b3 b2 b1 b0

Where xb1 € x1 Here exists a function fx2:x2 {00h, 01h, 02h, .............. ffh}

X3 is the single digit choice

Let x4 = b3 b2 b1 b0 where (bi x € x1 there Let y is the output)

Y= b15 b14 b13 b12 bb11 b10 b09 b08 b07 b06 b05 b04 b03 b02 b01 b00 (where bi€ x1)

Y= {0000b,0001b ................................. ffffb}

Time ( for successive addition) = {f1,f2,f3,f4}

Where f1 = Accept x2 & x3

F2= Addition (Repeat x2+x1+ ............................................. & till x3=00)

F3= display

Time (for shift and add)= {f1,f2,f3}

Where

F1= Accept x1&x3

F2= shift x3>>

C=0 c=1

Shift x2 << & x5 = x5-1

Shift x2 << & add with y, x5=x5-1

Repeat till x5=0

F3 = display y

C=0 c=1

Shift x2 << x5 << x5-1

Shift x2 << & add with y x5 = x5-1

Repeat till x5=0

F3= display

Add it with result & then decrement counter display result.

Output:

;[root@comppl208 nasm-2.10.07]# nasm -f elf64 multi26.asm

[root@comppl208 nasm-2.10.07]# ld -o multi26 multi26.o
[root@comppl208 nasm-2.10.07]# ./multi26

***Multiplication by add & shift***

Enter two digit number: 50
Enter two digit number: 02

Multiplication is: 00A0

;[root@comppl208 nasm-2.10.07]# nasm -f elf64 muladd26.asm

[root@comppl208 nasm-2.10.07]# ld -o muladd26 muladd26.o
[root@comppl208 nasm-2.10.07]# ./muladd26

***Multiplication by successive addition***

Enter two digit number: 05

Enter two digit number: 20

Multiplication is: 00A0

OUTCOME

Upon completion Students will be able to:

ELO4: Choose different multiplication methods such as add & shift and successive addition for
multiplication of two numbers without using MUL instruction.