Assembly language programming_fundamentals 8086

Assembly Language
Programming
Fundamentals
Presented By: Shehrevar Davierwala
Do Visit: http://sites.google.com/site/techwizardin
http://www.authorstream.com/shehrevard

Introduction To Programming Languages
• Machine Languages -“natural language” of a
computer
• Low Level Languages-In low level language,
instructions are coded using mnemonics
• High Level Languages

Data Representation & Numbering Systems
• Binary Numbering Systems
• Octal Numbering Systems
• Decimal Numbering Systems
• Hexadecimal Numbering Systems

Types Of Encoding
• American Standard Code For Information
Interchange ( ASCII )
• Binary Coded Decimal ( BCD )
• Extended Binary Coded Decimal Interchange
Code ( EBCDIC )

Mode of data representation
• Integer Representation
• Floating Point Representation

Format of Assembly Language Instructions
[Label] Operation [Operands] [; Comment]
• Example: Examples of instructions with varying numbers of fields.
• [Label] Operation [Operands] [; Comment]
L1: cmp bx, cx ; Compare bx with cx all fields present
add ax, 25 operation and 2
operands
inc bx operation and 1 operand
ret operation field only
; Comment: whatever you wish !! comment field only

program syntax
Type 1( MASM) TYPE 2(MASM) Kit
.model small
.data
Mes db ‘Hello $’
Op1 db 20h
Op2 db 30h
.code
Start:
Mov ax,@data
Mov ds,ax
Mov ax,op1
Mov bx,op2
Add ax,bx
Int 3
End start
Assume CS:code segment,DS:Data segment
DATA SEGMENT
Mes db ‘Hello $’
Op1 db 20h
Op2 db 30h
DATA ENDS
CODE SEGMENT
Start:
Mov ax,data
Mov ds,ax
Mov ax,op1
Mov bx,op2
Add ax,bx
Int 3
CODE ENDS
End start
Mov ax,20
Mov bx,30
Add ax,bx
Int 3

• Assembler Directives
• Procedures
• Macros

Assembler Directives
• Assembler Directives are directions to the
assembler.
• Assembler directives are the commands to the
assembler that direct the assembly process.
• They indicate how an operand is treated by
the assembler and how assembler handles the
program.
• They also direct the assembler how program
and data should be arranged in the memory.

List of Assembler Directives
ASSUME DB DW DD DQ
DT END ENDP ENDS EQU
EVEN EXTRN GLOBAL GROUP INCLUDE
LABEL LENGTH NAME OFFSET ORG
PROC PTR SEGMENT SHORT TYPE

Procedures
• A procedure is a collection of instructions to which we can direct the flow
of our program, and once the execution of these instructions is over
control is given back to the next line to process of the code which called
on the procedure.
• At the time of invoking a procedure the address of the next instruction of
the program is kept on the stack so that, once the flow of the program has
been transferred and the procedure is done, one can return to the next
line
of the original program, the one which called the procedure.
• Intrasegment procedure(IP in stack)
• Intersegment procedure(CS:IP in stack)

• Syntax:
Procedure name PROC near
instruction 1
instruction 2
RET
Procedure name ENDP
Example:
ADD2 PROC near
ADD AX,BX
RET
ADD2 ENDP
ADD2 PROC FAR
ADD AX,BX
RET
ADD2 ENDP

MACROS
• A macro is a group of repetitive instructions in
a program which are codified only once and
can be used as many times as necessary.
• Macro with in a macro is a nested MACRO
• A macro can be defined anywhere in program
using the directives MACRO and ENDM

• Syntax of macro:
Read MACRO
mov ah,01h
int 21h
ENDM
Display MACRO
mov dl,al
Mov ah,02h
int 21h
ENDM

Passing parameters to a macro
• Display MACRO MSG
mov dx, offset msg
mov ah,09h
int 21h
ENDM
The parameter MSG can be replaced by msg1 or msg2 while calling…
Calling macro:
DISPLAY MSG1
DISPLAY MSG2
MSG1 db “I am Fine $”
MSG2 db “Hello, How are you..? $”
Here parameter is
MSG

Procedures Vs Macros
Procedures Macros
Accessed by CALL and RET mechanism
during program execution
Accessed by name given to macro when
defined during assembly
Machine code for instructions only put in
memory once
Machine code generated for instructions
each time called
Parameters are passed in registers,
memory locations or stack
Parameters passed as part of statement
which calls macro
Procedures uses stack Macro does not utilize stack
A procedure can be defined anywhere in
program using the directives PROC and
ENDP
A macro can be defined anywhere in
program using the directives MACRO and
ENDM
Procedures takes huge memory for
CALL(3 bytes each time CALL is used)
instruction
Length of code is very huge if macro’s are
called for more number of times

Key common aspects for any
programming language
• Variables: declaration
• Assignment: assigning values to variable
• Input/output: displaying messages or
displaying variable values
• Control Flow: If Then, Loops
• Sub Programs: Definition , usage

Declaring Variables
• In c , java data types are used
• In Assembly language, Assembler Directives
are used(db , dw , dd , dq , dT)
• Example:
– reply db ‘y’ ( reply is a character variable)
– prompt db ‘Enter your favourite colour: ’, 0( prompt is a string terminated by
null)
– colour db 80 dup(?) (colour is an array of size 80)
– i db 20
– k db ?
– num dw 4000
– large dd 50000

• Indirect addressing
– Strings stored in memory
Message db ‘Hello’,0

8086 stack
• The stack is a block of memory that may be used for temporarily storing
the contents of registers inside CPU.
• Stack is accessed by using SP and SS.
• Stack is a Top Down Data Structure whose elements are accessed by using
a pointer (SP,SS).
• The stack is required when CALL instruction is used.
• Push
• Pop
• Top of stack
• Stack pointer
• LIFO

• Example: Using the stack, swap the values of the ax and bx registers, so that ax
now contains what bx contained and bx contains what ax contained. (This is not
the most efficient way to exchange the contents of two variables). To carry out this
operation, we need at least one temporary variable:
push ax ; Store ax on stack
push bx ; Store bx on stack
pop ax ; Copy last value on stack to ax
pop bx ; Copy first value to bx
Push ax
Mov ax,bx
popbx

Assignment
• For assigning values, MOV
• Mov ax,42
• Mov bx,45
So here MOV instruction carries out assignment
Syntax of MOV: MOV destination, source
Destination – a register or memory location
Source- - a constant or another register or memory
location.

• Example1: Store the ASCII code for the letter
A in register bx.
Ans: ????
Comments: we can give comments with help of
semicolon(;).the text written after semicolon
is treated as semicolon.
Add ax,bx; addition of ax,bx contents
Note: In assembly language, only one
Arithmetic operation can be performed at a
single time.

Exercises
• 1) Write instructions to:
– Load character ? into register bx
– Load space character into register cx
– Load 26 (decimal) into register cx
– Copy contents of ax to bx and dx
• 2) What errors are present in the following :
• mov ax 3d
• mov 23, ax
• mov cx, ch
• move ax, 1h
• add 2, cx
• add 3, 6
• inc ax, 2
• 3) Write instructions to evaluate the arithmetic expression 5 +(6-2) leaving the result in ax using (a)
1 register, (b) 2 registers,(c) 3 registers
• 4) Write instructions to evaluate the expressions:
• a = b + c –d
• z = x + y + w – v +u

Input / output
• i/o devices—keyboard , screen
• IN & OUT( complicated instructions)
• So a mechanism is needed to call operating
system to carryout I/O .
• Also what kind of I/O operation to be
performed should be specified.( read or write
etc)
• Here we do it with help of SOFTWARE
INTERRUPTS

SOFTWARE INTERRUPT
• Software interrupt is generated by program
• The INT instruction generates a software
interrupt
• INT instruction uses a single operand to indicate
which MS-DOS sub program should be invoked.
• FOR I/O operations, We have INT 21H
• Here number stored in AH register is used to
specify which kind of I/O operation is to be done.

• Write a code fragment to display the
character ’a’ on the screen?
• Write a code fragment to read a character
from the keyboard?
• Reading and displaying a character?

• Example: The following code fragment illustrates the use of indirect addressing. It is a loop to count the
number of characters in a string terminated by the Null character (ASCII 0). It uses the cx register to
store the number of characters in the string.
message db ‘Hello’, 0
mov cx, 0 ; cx stores number ofcharacters
mov bx, offset message ; store address of message in bx
begin:
cmp byte ptr [bx], 0 ; is this end of string?
je fin ; if yes goto Finished
inc cx ; cx = cx + 1
inc bx ; bx points to next character
jmp begin
fin:

Control Flow
• Example : This example illustrates the use of the jmp instruction to
implement an endless loop – not something you would noramlly wish to
do!
again:
call getc ; read a character
call putc ; display character
jmp again ; jump to again

Unconditional jump
• Example : The following code fragment
illustrates a forward jump, as control is
transferred to a later place in the program:
call getc ; read a character
call putc ; display the character
jmp finish ; jump to label finish
<do other things>; Never gets done !!!
finish:
mov ax, 4c00h
int 21h

Conditional jump
• conditional jump instructions can handle the various conditions (==, !=, <,
>, <=, >=) that arise when comparing values. Je/jz
ax = 2;
if ( ax != bx )
{
ax = ax + 1 ;
}
bx = bx + 1 ;
mov ax, 2 ; ax = 2
sub ax, bx ; ax = 2 - bx
jz nextl ; jump if (ax-bx) == 0
inc ax ; ax = ax + 1
nextl:
inc bx

If then
if ( i == 10 )
{
i = i + 5 ;
j = j + 5 ;
}
/* Rest of program */

If else
c = getchar() ;
if ( c == ‘A’ )
printf(“You guessed correctly !! “);
else
printf(“Sorry incorrect guess “) ;

• Upper case to lower case:
if ( c >= ‘A‘ && c <= ‘Z‘ ) or if ( c < ‘A‘ || c > ‘Z‘ )
main() /* char.c: convert letter to lowercase */
{
char c;
printf(“nEnter an uppercase letter: “);
c = getchar();
if ( c >= ‘A‘ && c <= ‘Z‘ )
{
c = c + ( ‘a’ - ‘A’ ) ; /* convert to
lowercase */
printf(“nThe lowercase equivalent is: %c “,c);
}
else
printf(“nNot an uppercase letter %c “, c );
}

In the code fragments below where will execution
continue from when <jump-on-condition> is replaced by (a)
je lab1 ; (b) jg lab1; (c) jle lab1; (d) jz lab1
(i) mov ax, 10h
cmp ax, 9h
<jump-on-condition>
; rest of program
...........
...........
lab1:
(ii) mov cx, 0h
cmp cx, 0d
<jump-on-condition>
; rest of program
...........
. ..........
lab1:

LOOPS-deterministic loopcount = 1 ;
while ( count <= 60 )
{
putchar(‘*’) ;
count = count + 1 ;
}

Write a code fragment to display the characters from ‘a’ to ‘z’ on the screen using the
knowledge that the ASCII codes form a collating sequence. This means that the code
for ‘b’ is one greater than the code for ‘a’ and the code for ‘c’ is one greater than that
for ‘b’ and so on.
c = ‘a‘ ; /* c = 97 (ASCII for ‘a‘)
while ( c <= ‘z‘ )
{
putchar( c );
c = c + 1 ;
}

Non deterministic loop
main()
{
char c, reply;
reply = ‘y‘;
while ( reply == ‘y‘ )
{
printf(“nEnter an uppercase letter: “);
c = getchar();
c = c + ( ‘a’ - ‘A’ ) ; /* convert to lowercase
*/
printf(“nThe lowercase equivalent is: %c “, c);
printf(“nEnter y to continue: “);
reply = getchar();
}
}

• Bit manipulations
• Nuber conversions(packed,unpacked)
• Shift operations

• Clear bit 5 of a given byte
• Converting a lowercase letter to its uppercase equivalent
• Specify the instructions and masks would you use to
a) set bits 2, 3 and 4 of the ax register
b) clear bits 4 and 7 of the bx register
• How would al be affected by the following instructions:
(a) and al, 00fh
(b) and al, 0f0h
(c) or al, 00fh
(d) or al, 0f0h
• Toggle bits 0, 1 and 6 of the value in al (here 67h)
• compliment

or cx, cx ; compares cx with 0
je label
and ax, ax ; compares ax with 0
jg label2

Assembly language programming_fundamentals 8086

More Related Content

What's hot

Similar to Assembly language programming_fundamentals 8086

More from Shehrevar Davierwala

Recently uploaded

Assembly language programming_fundamentals 8086