This document provides an introduction to 8086 assembly language programming. It discusses program statements, data storage directives, defining and naming data, data transfer instructions, and the basic structure of an assembly language program, including segments for code, data, and stack. Pseudo-operations and directives are used to define variables and reserve memory. Data types like bytes, words, and doublewords are stored in reverse order in memory.

1. Introduction to 8086 Assembly
Language
Assembly Language Programming
University of Akron
Dr. Tim Margush

2. Program Statements
name operation operand(s) comment
• Operation is a predefined or reserved word
› mnemonic - symbolic operation code
› directive - pseudo-operation code
• Space or tab separates initial fields
• Comments begin with semicolon
• Most assemblers are not case sensitive
10/21/12 Dr. Tim Margush - Assembly Language Program
2

3. Program Data and Storage
• Pseudo-ops to define • These directives
data or reserve storage require one or more
› DB - byte(s) operands
› DW - word(s) › define memory
› DD - doubleword(s) contents
› DQ - quadword(s) › specify amount of
› storage to reserve for
DT - tenbyte(s)
run-time data
10/21/12 Dr. Tim Margush - Assembly Language Program
3

4. Defining Data
• Numeric data values • A list of values may be
› 100 - decimal used - the following
› 100B - binary creates 4 consecutive
› 100H - hexadecimal words
› '100' - ASCII DW 40CH,10B,-13,0
› "100" - ASCII • A ? represents an
• Use the appropriate uninitialized storage
DEFINE directive location
(byte, word, etc.) DB 255,?,-128,'X'
10/21/12 Dr. Tim Margush - Assembly Language Program
4

5. Naming Storage Locations
• Names can be • ANum refers to a byte
associated with storage location,
storage locations initialized to FCh
ANum DB -4 • The next word has no
DW 17 associated name
ONE
• ONE and UNO refer
UNO DW 1
X DD ? to the same word
• These names are called • X is an unitialized
variables doubleword
10/21/12 Dr. Tim Margush - Assembly Language Program
5

6. Arrays
• Any consecutive storage locations of the
same size can be called an array
X DW 40CH,10B,-13,0
Y DB 'This is an array'
Z DD -109236, FFFFFFFFH, -1, 100B
• Components of X are at X, X+2, X+4, X+8
• Components of Y are at Y, Y+1, …, Y+15
• Components of Z are at Z, Z+4, Z+8, Z+12
10/21/12 Dr. Tim Margush - Assembly Language Program
6

7. DUP
• Allows a sequence of storage locations to
be defined or reserved
• Only used as an operand of a define
directive
DB 40 DUP (?)
DW 10h DUP (0)
DB 3 dup ("ABC")
db 4 dup(3 dup (0,1), 2 dup('$'))
10/21/12 Dr. Tim Margush - Assembly Language Program
7

8. Word Storage
• Word, doubleword, and quadword data are
stored in reverse byte order (in memory)
Directive Bytes in Storage
DW 256 00 01
DD 1234567H 67 45 23 01
DQ 10 0A 00 00 00 00 00 00 00
X DW 35DAh DA 35
Low byte of X is at X, high byte of X is at X+1
10/21/12 Dr. Tim Margush - Assembly Language Program
8

9. Named Constants
• Symbolic names associated with storage locations
represent addresses
• Named constants are symbols created to represent
specific values determined by an expression
• Named constants can be numeric or string
• Some named constants can be redefined
• No storage is allocated for these values
10/21/12 Dr. Tim Margush - Assembly Language Program
9

10. Equal Sign Directive
• name = expression
› expression must be numeric
› these symbols may be redefined at any time
maxint = 7FFFh
count = 1
DW count
count = count * 2
DW count
10/21/12 Dr. Tim Margush - Assembly Language Program
10

11. EQU Directive
• name EQU expression
› expression can be string or numeric
› Use < and > to specify a string EQU
› these symbols cannot be redefined later in the
program
sample EQU 7Fh
aString EQU <1.234>
message EQU <This is a message>
10/21/12 Dr. Tim Margush - Assembly Language Program
11

12. Data Transfer Instructions
• MOV target, source • reg can be any non-
› reg, reg segment register
› mem, reg except IP cannot be
› reg, mem the target register
› mem, immed • MOV's between a
› reg, immed segment register and
• Sizes of both operands memory or a 16-bit
must be the same register are possible
10/21/12 Dr. Tim Margush - Assembly Language Program
12

13. Sample MOV Instructions
b db 4Fh • When a variable is created with a
w dw 2048 define directive, it is assigned a
default size attribute (byte, word,
mov bl,dh etc)
mov ax,w • You can assign a size attribute
mov ch,b using LABEL
mov al,255 LoByte LABEL BYTE
mov w,-100 aWord DW 97F2h
mov b,0
10/21/12 Dr. Tim Margush - Assembly Language Program
13

14. Addresses with Displacements
b db 4Fh, 20h, 3Ch • The assembler
w dw 2048, -100, 0 computes an address
based on the
mov bx, w+2 expression
mov b+1, ah • NOTE: These are address
mov ah, b+5 computations done at
mov dx, w-3 assembly time
MOV ax, b-1
• Type checking is still in
will not subtract 1 from
effect the value stored at b
10/21/12 Dr. Tim Margush - Assembly Language Program
14

15. eXCHanGe
• XCHG target, source • This provides an
› reg, reg efficient means to
› reg, mem swap the operands
› mem, reg › No temporary storage
• MOV and XCHG is needed
› Sorting often requires
cannot perform
this type of operation
memory to memory
› This works only with
moves the general registers
10/21/12 Dr. Tim Margush - Assembly Language Program
15

16. Arithmetic Instructions
ADD dest, source • source can be a
SUB dest, source general register,
INC dest memory location, or
constant
DEC dest
• dest can be a register
NEG dest or memory location
• Operands must be of › except operands cannot
the same size both be memory
10/21/12 Dr. Tim Margush - Assembly Language Program
16

17. Program Segment Structure
• Data Segments • Stack Segment
› Storage for variables › used to set aside
› Variable addresses are storage for the stack
computed as offsets › Stack addresses are
from start of this computed as offsets
segment into this segment
• Code Segment • Segment directives
› contains executable .data
instructions .code
.stack size
10/21/12 Dr. Tim Margush - Assembly Language Program
17

18. 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
› flat: no segments, 32-bit addresses, protected
mode only (80386 and higher)
10/21/12 Dr. Tim Margush - Assembly Language Program
18

19. Program Skeleton
.model small • Select a memory model
.stack 100H • Define the stack size
.data • Declare variables
;declarations • Write code
.code › organize into procedures
main proc • Mark the end of the
;code source file
main endp › optionally, define the
;other procs entry point
end main
10/21/12 Dr. Tim Margush - Assembly Language Program
19