Introduction To 8086 Assembly

Introduction to 8086 Assembly Language
http://www.shsu.edu/~csc_tjm/spring2005/cs272/intro_to...

CS 272
Sam Houston State University
Dr. Tim McGuire
Structure of an assembly language program
Assembly language programs divide roughly into ve sections
header
equates
data
body
closing
The Header
The header contains various directives which do not produce machine code
Sample header:
%TITLE "Sample Header"
.8086
.model small
.stack 256
Named Constants
Symbolic names associated with storage locations represent addresses
Named constants are symbols created to represent specic values
determined by an expression
Named constants can be numeric or string
Some named constants can be redened
No storage is allocated for these values
Equates
Constant values are known as equates
Sample equate section:
Count EQU 10
Element EQU 5
Size = Count * Element
MyString EQU "Maze of twisty passages"
Size = 0
= is used for numeric values only

Cannot change value of EQU symbol
EQUated symbols are not variables
1 of 13
11/22/2015 10:29 AM
EQU expressions are evaluated where used; = expressions are evaluated

where dened
The Data Segment
Begins with the .data directive
Two kinds of variables, initialized and uninitialized.
Initialized variables take up space in the program's code le
Declare uninitialized variables after initialized ones so they do not take up
space in the program's code le
Reserving space for variables
Sample DATA SEGMENT
.data
numRows
DB 25
numColumns DB ?
videoBase DW 0800h
DB and DW are common directives (dene byte) and (dene word)

The symbols associated with variables are called labels
Strings may be declared using the DB directive:
aTOm DB "ABCDEFGHIJKLM"
Program Data and Storage

Pseudo-ops to dene data or reserve storage
DB - byte(s)
DW - word(s)
DD - doubleword(s)
DQ - quadword(s)
DT - tenbyte(s)
These directives require one or more operands
dene memory contents
specify amount of storage to reserve for run-time data
Dening Data
Numeric data values
100 - decimal
100b - binary
100h - hexadecimal
'100' - ASCII
"100" - ASCII
Use the appropriate DEFINE directive (byte, word, etc.)
A list of values may be used - the following creates 4 consecutive words
2 of 13
11/22/2015 10:29 AM
DW 40Ch,10b,-13,0
A ? represents an uninitialized storage location

DB 255,?,-128,'X'
Naming Storage Locations

Names can be associated with storage locations
ANum DB
DW
ONE
UNO DW
X
DD
-4
17
1
?
These names are called variables

ANum refers to a byte storage location, initialized to FCh
The next word has no associated name
ONE and UNO refer to the same word
X is an uninitialized doubleword
Arrays
Any consecutive storage locations of the same size can be called an array
X
Y
Z
DW
DB
DD
040Ch,10b,-13,0
'This is an array'
-109236, FFFFFFFFh, -1, 100b
Components of X are at X, X+2, X+4, X+6

Components of Y are at Y, Y+1, , Y+15
Components of Z are at Z, Z+4, Z+8, Z+12
DUP
Allows a sequence of storage locations to be dened or reserved
Only used as an operand of a dene directive
DB
DW
DB
DB
40 DUP(?)
10h DUP(0)
3 DUP("ABC")
4 DUP(3 DUP (0,1), 2 DUP('$'))
Word Storage
Word, doubleword, and quadword data are stored in reverse byte order (in
memory)
Directive
DW 256
3 of 13
Bytes in Storage
00 01
11/22/2015 10:29 AM
DD 1234567h
DQ 10
X DW 35DAh
67 45 23 01
0A 00 00 00 00 00 00 00
DA 35
Low byte of X is at X, high byte of X is at X+1
The Program Body

Also known as the code segment
Divided into four columns: labels, mnemonics, operands, and comments
Labels refer to the positions of variables and instructions, represented by
the mnemonics
Operands are required by most assembly language instructions
Comments aid in remembering the purpose of various instructions
An example
Label
Mnemonic
Operand
Comment
--------------------------------------------------------.data
exCode
DB
0
;A byte variable
myWord
DW
?
;Uninitialized word var.
.code
MAIN
PROC
mov
ax,@data
;Initialize DS to address
mov
ds,ax
; of data segment
jmp
Exit
;Jump to Exit label
mov
cx,10
;This line skipped!
Exit:
mov
ah,04Ch
;DOS function: Exit prog
mov
al, exCode ;Return exit code value
int
21h
;Call DOS. Terminate prog
MAIN
ENDP
;End Program
END
MAIN
; and specify entry point
The Label Field

Labels mark places in a program which other instructions and directives
reference
Labels in the code segment always end with a colon
Labels in the data segment never end with a colon
Labels can be from 1 to 31 characters long and may consist of letters,
digits, and the special characters ? . @ _ $ %
If a period is used, it must be the rst character
Labels must not begin with a digit
The assembler is case insensitive
Legal and Illegal Labels
Examples of legal names
COUNTER1
@character
4 of 13
11/22/2015 10:29 AM
SUM_OF_DIGITS
$1000
DONE?
.TEST
Examples of illegal names
TWO WORDS contains a blank
2abc begins with a digit
A45.28 . not rst character
YOU&ME contains an illegal character
The Mnemonic Field
For an instruction, the operation eld contains a symbolic operation code
(opcode)
The assembler translates a symbolic opcode into a machine language
opcode
Examples are: ADD, MOV, SUB
In an assembler directive, the operation eld contains a directive
(pseudo-op)
Pseudo-ops are not translated into machine code; they tell the assembler to
do something
The Operand Field
For an instruction, the operand eld species the data that are to be acted
on by the instruction. May have zero, one, or two operands
NOP
INC AX
ADD WORD1,2
;no operands -- does nothing

;one operand -- adds 1 to the contents of AX
;two operands -- adds 2 to the contents
; of memory word WORD1
In a two-operand instruction, the rst operand is the destination operand.

The second operand is the source operand.
For an assembler directive, the operand eld usually contains more
information about the directive.
The Comment Field
A semicolon marks the beginning of a comment eld
The assembler ignores anything typed after the semicolon on that line
It is almost impossible to understand an assembly language program
without good comments
Good programming practice dictates a comment on almost every line
Good and Bad Comments
Don't say something obvious, like
5 of 13
11/22/2015 10:29 AM
MOV CX,0 ;move 0 to CX

Instead, put the instruction into the context of the program
MOV CX,0 ;CX counts terms, initially 0
An entire line can be a comment, or be used to create visual space in a
program
;
; Initialize registers
;
MOV AX,0
MOV BX,0
The Closing
The last lines of an assembly language program are the closing
Indicates to assembler that it has reached the end of the program and
where the entry point is
MAIN
ENDP
END MAIN
;End of program
; entry point for linker use
END is a pseudo-op; the single "operand" is the label specifying the

beginning of execution, usually the rst instruction after the .code
pseudo-op
Assembling a Program
The source le of an assembly language program is usually named with an
extension of .asm
edit myprog.asm
The source le is processed (assembled) by the assembler (TASM) to
produce an object le (.obj)
tasm myprog produces myprog.obj
The object le must be linked by the linker (TLINK) to produce an
executable le (.exe)
tlink myprog produces myprog.exe
Dealing with Errors
TASM will report the line number and give an error message for each error
it nds
6 of 13
11/22/2015 10:29 AM
Sometimes it is helpful to have a listing le (.lst), created by using TASM

with the -l option
The .lst le contains a complete listing of the program, along with line
numbers, object code bytes, and the symbol table
Using the Debugger
Useful for logic errors that the assembler misses
See the text for a complete tutorial
You do not need to use the TDH386.SYS driver or the TD386.EXE debugger
with the latest version of the assembler
To use the debugger on myprog.asm
tasm /zi myprog
tlink /v myprog
td myprog
.COM and .EXE les
The .COM code le format is a relic of the rst version of MS-DOS
Not recommended for general purposes
All code, data, and the stack occupy one 64K segment (Borland's "tiny"
model)
.EXE code les are more ecient in use of RAM
Data and code occupy separate segments
The programmer is responsible for setting up the data and code segments
properly
Ending a Program
All programs, upon termination, must return control back to another
program -- the operating system
Under MS-DOS, this is COMMAND.COM
This is done by doing a DOS system call
Data Transfer Instructions
MOV destination,source
reg, reg
mem, reg
reg, mem
mem, immed
reg, immed
Sizes of both operands must be the same
reg can be any non-segment register except IP cannot be the target register
MOV's between a segment register and memory or a 16-bit register are
possible
7 of 13
11/22/2015 10:29 AM
Examples
mov ax, word1
"Move word1 to ax"
Contents of register ax are replaced by the contents of the memory
location word1
xchg ah, bl
Swaps the contents of ah and bl
Illegal: mov word1, word2
can't have both operands be memory locations
Sample MOV Instructions
b
w
db
dw
mov
mov
mov
mov
mov
mov
4Fh
2048
bl,dh
ax,w
ch,b
al,255
w,-100
b,0
When a variable is created with a dene directive, it is assigned a default

size attribute (byte, word, etc)
You can assign a size attribute using LABEL
LoByte LABEL BYTE
aWord DW
97F2h
Addresses with Displacements
b
w
db
dw
mov
mov
mov
mov
4Fh, 20h, 3Ch

2048, -100, 0
bx, w+2
b+1, ah
ah, b+5
dx, w-3
Type checking is still in eect

The assembler computes an address based on the expression
NOTE: These are address computations done at assembly time
MOV ax,b-1
will not subtract 1 from the value stored at b
eXCHanGe
XCHG destination,source
8 of 13
11/22/2015 10:29 AM
reg, reg
reg, mem
mem, reg
MOV and XCHG cannot perform memory to memory moves
This provides an ecient means to swap the operands
No temporary storage is needed
Sorting often requires this type of operation
This works only with the general registers
Arithmetic Instructions
ADD dest, source
SUB dest, source
INC dest
DEC dest
NEG dest
Operands must be of the same size
source can be a general register, memory location, or constant
dest can be a register or memory location
except operands cannot both be memory
ADD and INC
ADD is used to add the contents of
two registers
a register and a memory location
a register and a constant
INC is used to add 1 to the contents of a register or memory location
Examples
add ax, word1
"Add word1 to ax"
Contents of register ax and memory location word1 are added, and
the sum is stored in ax
inc ah
Adds one to the contents of ah
Illegal: add word1, word2
SUB, DEC, and NEG
SUB is used to subtract the contents of
one register from another register
a register from a memory location, or vice versa
a constant from a register
DEC is used to subtract 1 from the contents of a register or memory location
9 of 13
11/22/2015 10:29 AM
NEG is used to negate the contents of a register or memory location

Examples
sub ax, word1
"Subtract word1 from ax"
Contents of memory location word1 is subtracted from the contents of
register ax, and the sum is stored in ax
dec bx
Subtracts one from the contents of bx
Illegal: sub byte1, byte2
Type Agreement of Operands
The operands of two-operand instructions must be of the same type (byte
or word)
mov ax, bh
;illegal
mov ax, byte1 ;illegal
mov ah,'A'
;legal -- moves 41h into ah
mov ax,'A'
;legal -- moves 0041h into ax
Translation of HLL Instructions
B=A
mov ax,A
mov B,ax
memory-memory moves are illegal

A = B - 2*A
mov
sub
sub
mov
ax,B
ax,A
ax,A
A,ax
Program Segment Structure

Data Segments
Storage for variables
Variable addresses are computed as osets from start of this segment
Code Segment
contains executable instructions
Stack Segment
used to set aside storage for the stack
Stack addresses are computed as osets into this segment
Segment directives
10 of 13
11/22/2015 10:29 AM
.DATA
.CODE
.STACK size
Memory Models
.Model memory_model
tiny: code+data <= 64K (.com program)
small: code<=64K, data<=64K, one of each
medium: data<=64K, one data segment
compact: code<=64K, one code segment
large: multiple code and data segments
huge: allows individual arrays to exceed 64K
at: no segments, 32-bit addresses, protected mode only (80386 and
higher)
Program Skeleton
.MODEL small
.STACK 100h
.DATA
;declarations
.CODE
MAIN PROC
;main proc code
;return to DOS
ENDP MAIN
;other procs (if any) go here
end MAIN
Select a memory model
Dene the stack size
Declare variables
Write code
organize into procedures
Mark the end of the source le
dene the entry point
Input and Output Using 8086 Assembly Language
Most input and output is not done directly via the I/O ports, because
port addresses vary among computer models
it's much easier to program I/O with the service routines provided by
the manufacturer
There are BIOS routines (which we'll look at later) and DOS routines for
handling I/O (using interrupt number 21h)
Interrupts
11 of 13
11/22/2015 10:29 AM
The interrupt instruction is used to cause a software interrupt (system call)

An interrupt interrupts the current program and executes a subroutine,
eventually returning control to the original program
Interrupts may be caused by hardware or software
int interrupt_number
;software interrupt
Output to Monitor
DOS Interrupts : interrupt 21h
This interrupt invokes one of many support routines provided by DOS
The DOS function is selected via AH
Other registers may serve as arguments
AH = 2, DL = ASCII of character to output
Character is displayed at the current cursor position, the cursor is
advanced, AL = DL
Output a String
Interrupt 21h, function 09h
DX = oset to the string (in data segment)
The string is terminated with the '$' character
To place the address of a variable in DX, use one of the following
lea
DX,theString
mov
DX, offset theString ;immediate data
;load effective address
Print String Example

%TITLE "First Program -- HELLO.ASM"
.8086
.MODEL
small
.STACK
256
.DATA
msg
DB
"Hello, World!$"
.CODE
MAIN
PROC
mov
ax,@data
;Initialize DS to address
mov
ds,ax
; of data segment
lea
dx,msg
;get message
mov
ah,09h
;display string function
int
21h
;display message
Exit:
mov
ah,4Ch
;DOS function: Exit program
mov
al,0
;Return exit code value
int
21h
;Call DOS. Terminate program
MAIN
ENDP
;End of program
END
MAIN
; entry point
Input a Character
Interrupt 21h, function 01h
Filtered input with echo
12 of 13
11/22/2015 10:29 AM
This function returns the next character in the keyboard buer (waiting
if necessary)
The character is echoed to the screen
AL will contain the ASCII code of the non-control character
AL=0 if a control character was entered
An Example Program
%TITLE "Case Conversion"
.8086
.MODEL small
.STACK 256
.DATA
MSG1
DB 'Enter a lower case letter: $'
MSG2
DB 0Dh,0Ah,'In upper case it is: '
CHAR
DB ?,'$'
exCode
DB 0
.CODE
MAIN
PROC
;initialize ds
mov
ax,@data
; Initialize DS to address
mov
ds,ax
; of data segment
;print user prompt
mov
ah,9
; display string fcn
lea
dx,MSG1
; get first message
int
21h
; display it
;input a character and convert to upper case
mov
ah,1
; read char fcn
int
21h
; input char into AL
sub
al,20h
; convert to upper case
mov
CHAR,al
; and store it
;display on the next line
mov
dx,offset MSG2 ; get second message
mov
ah,9
; display string function
int
21h
; display message and upper case
;return to DOS
Exit:
mov
ah,4Ch
; DOS function: Exit program
mov
al,exCode
; Return exit code value
int
21h
; Call DOS. Terminate program
MAIN ENDP
END
MAIN
; End of program / entry point
13 of 13
11/22/2015 10:29 AM

Introduction To 8086 Assembly

Uploaded by

Copyright:

Available Formats

Introduction To 8086 Assembly

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Introduction To 8086 Assembly

Uploaded by

Copyright:

Available Formats

Introduction to 8086 Assembly Language