8086 MICROPROCESSOR

Suresh.P HOD / ECE MEA Engineering College Perinthalmanna

8086 Microprocessor

8086 Features

16-bit Arithmetic Logic Unit

16-bit data bus (8088 has 8-bit data bus) 20-bit address bus - 220 = 1,048,576 = 1 meg The address refers to a byte in memory. In the 8088, these bytes come in on the 8-bit data bus. In the 8086, bytes at even addresses come in on the low half of the data bus (bits 0-7) and bytes at odd addresses come in on the upper half of the data bus (bits 8-15). The 8086 can read a 16-bit word at an even address in one operation and at an odd address in two operations. The 8088 needs two operations in either case. The least significant byte of a word on an 8086 family microprocessor is at the lower address.

Simplified CPU Design

Data Bus

Data Registers Control Unit Address Registers Arithmetic Logic Unit Status Flags Memory

Address Bus

Intel 16-bit Registers

General Purpose
AH AL

Index BP SP

AX

BH

BL

BX

SI
CH CL

CX

DI

DH

DL

DX

Segment CS Status and Control Flags IP SS DS ES

8086 Architecture

The 8086 has two parts, the Bus Interface Unit (BIU) and the Execution Unit (EU). The BIU fetches instructions, reads and writes data, and computes the 20-bit address. The EU decodes and executes the instructions using the 16-bit ALU. The BIU contains the following registers: IP - the Instruction Pointer CS - the Code Segment Register DS - the Data Segment Register SS - the Stack Segment Register ES - the Extra Segment Register The BIU fetches instructions using the CS and IP, written CS:IP, to contract the 20-bit address. Data is fetched using a segment register (usually the DS) and an effective address (EA) computed by the EU depending on the addressing mode.

The EU contains the following 16-bit registers: AX - the Accumulator BX - the Base Register CX - the Count Register DX - the Data Register SP - the Stack Pointer \ defaults to stack segment BP - the Base Pointer / SI - the Source Index Register DI - the Destination Register These are referred to as general-purpose registers, although, as seen by their names, they often have a special-purpose use for some instructions. The AX, BX, CX, and DX registers can be considers as two 8-bit registers, a High byte and a Low byte. This allows byte operations and compatibility with the previous generation of 8-bit processors, the 8080 and 8085. 8085 source code could be translated in 8086 code and assembled. The 8-bit registers are: AX --> AH,AL BX --> BH,BL CX --> CH,CL DX --> DH,DL

Registers

8086 Programmers Model

BIU registers (20 bit adder)

ES CS SS DS IP AX BX CX DX AH BH CH DH SP BP SI DI FLAGS AL BL CL DL

Extra Segment Code Segment Stack Segment Data Segment Instruction Pointer Accumulator Base Register Count Register Data Register Stack Pointer Base Pointer Source Index Register Destination Index Register

EU registers

8086/88 internal registers 16 bits (2 bytes each) AX, BX, CX and DX are two bytes wide and each byte can be accessed separately These registers are used as memory pointers.

Flags will be discussed later

Segment registers are used as base address for a segment in the 1 M byte of memory

The 8086/8088 Microprocessors: Registers

Registers
Registers are in the CPU and are referred to by specific names Data registers
Hold data for an operation to be performed There are 4 data registers (AX, BX, CX, DX)

Address registers
Hold the address of an instruction or data element Segment registers (CS, DS, ES, SS) Pointer registers (SP, BP, IP) Index registers (SI, DI)

Status register
Keeps the current status of the processor On an IBM PC the status register is called the FLAGS register

In total there are fourteen 16-bit registers in an 8086/8088

Data Registers: AX, BX, CX, DX

Instructions execute faster if the data is in a register AX, BX, CX, DX are the data registers Low and High bytes of the data registers can be accessed separately
AH, BH, CH, DH are the high bytes AL, BL, CL, and DL are the low bytes

Data Registers are general purpose registers but they also perform special functions AX
Accumulator Register Preferred register to use in arithmetic, logic and data transfer instructions because it generates the shortest Machine Language Code Must be used in multiplication and division operations Must also be used in I/O operations

 BX
Base Register Also serves as an address register

CX
Count register Used as a loop counter Used in shift and rotate operations

DX
Data register Used in multiplication and division Also used in I/O operations

Pointer and Index Registers

Contain the offset addresses of memory locations Can also be used in arithmetic and other operations SP: Stack pointer
Used with SS to access the stack segment

BP: Base Pointer

Primarily used to access data on the stack Can be used to access data in other segments

SI: Source Index register

is required for some string operations When string operations are performed, the SI register points to memory locations in the data segment which is addressed by the DS register. Thus, SI is associated with the DS in string operations.

 DI: Destination Index register

is also required for some string operations. When string operations are performed, the DI register points to memory locations in the data segment which is addressed by the ES register. Thus, DI is associated with the ES in string operations.

The SI and the DI registers may also be used to access data stored in arrays

Segment Registers - CS, DS, SS and ES

Are Address registers Store the memory addresses of instructions and data Memory Organization
Each byte in memory has a 20 bit address starting with 0 to 220-1 or 1 meg of addressable memory Addresses are expressed as 5 hex digits from 00000 - FFFFF Problem: But 20 bit addresses are TOO BIG to fit in 16 bit registers! Solution: Memory Segment
Block of 64K (65,536) consecutive memory bytes A segment number is a 16 bit number Segment numbers range from 0000 to FFFF Within a segment, a particular memory location is specified with an offset

An offset also ranges from 0000 to FFFF

Segmented Memory
Segmented memory addressing: absolute (linear) address is a combination of a 16-bit segment value added to a 16-bit offset

F0000 E0000 D0000 C0000 B0000 A0000 90000 80000 70000 60000 50000 40000 30000 20000 10000 00000 seg ofs 8000:0000
0250

8000:FFFF

one segment

8000:0250

Intel

Memory Address Generation

The BIU has a dedicated adder for determining physical memory addresses
Offset Value (16 bits)

Segment Register (16 bits)

0000

Adder

Physical Address (20 Bits)

Intel

Example Address Calculation

If the data segment starts at location 1000h and a data reference contains the address 29h where is the actual data?
2 Offset: Segment: Address: 9
0000000000101001 0001000000000000 0000 0001000000000010 1001

Segment:Offset Address

Logical Address is specified as segment:offset Physical address is obtained by shifting the segment address 4 bits to the left and adding the offset address Thus the physical address of the logical address A4FB:4872 is
A4FB0 + 4872 A9822

Your turn . . .
What linear address corresponds to the segment/offset address 028F:0030?

028F0 + 0030 = 02920

Always use hexadecimal notation for addresses.

Your turn . . .
What segment addresses correspond to the linear address 28F30h?

Many different segment-offset addresses can produce the linear address 28F30h. For example: 28F0:0030, 28F3:0000, 28B0:0430, . . .

The Code Segment

0H

CS:

0400H IP 0056H

4000H 4056H

CS:IP = 400:56 Logical Address Memory

Segment Register Offset Physical or Absolute Address +

0400 0 0056 04056H

0FFFFFH

The offset is the distance in bytes from the start of the segment. The offset is given by the IP for the Code Segment. Instructions are always fetched with using the CS register.
The physical address is also called the absolute address.

The Data Segment

0H

DS:

05C0 SI 0050

05C00H 05C50H DS:EA Memory

Segment Register Offset Physical Address +

05C0 0050

05C50H

0FFFFFH

Data is usually fetched with respect to the DS register. The effective address (EA) is the offset. The EA depends on the addressing mode.

The Stack Segment

0H

SS:

0A00 SP 0100

0A000H 0A100H SS:SP

Memory Segment Register Offset Physical Address + 0A00 0 0100 0A100H

0FFFFFH

The offset is given by the SP register. The stack is always referenced with respect to the stack segment register. The stack grows toward decreasing memory locations. The SP points to the last or top item on the stack. PUSH - pre-decrement the SP POP - post-increment the SP

Flags

Overflow Direction Interrupt enable Trap 6 are status flags 3 are control flag Sign Zero

Carry flag Parity flag Auxiliary flag

Flag Register
Conditional flags: They are set according to some results of arithmetic operation. You do not need to alter the value yourself. Control flags: Used to control some operations of the MPU. These flags are to be set by you in order to achieve some specific purposes.
Flag Bit no. 15 14 13 12 O 11 D 1 0 I 9 T 8 S 7 Z 6 5 A 4 3 P 2 1 C 0

CF (carry) Contains carry from leftmost bit following arithmetic, also contains last bit from a shift or rotate operation.

Flag Register

OF (overflow) Indicates overflow of the leftmost bit during arithmetic. DF (direction) Indicates left or right for moving or comparing string data. IF (interrupt) Indicates whether external interrupts are being processed or ignored. TF (trap) Permits operation of the processor in single step mode.

 SF (sign) Contains the resulting sign of an arithmetic operation (1=negative) ZF (zero) Indicates when the result of arithmetic or a comparison is zero. (1=yes) AF (auxiliary carry) Contains carry out of bit 3 into bit 4 for specialized arithmetic. PF (parity) Indicates the number of 1 bits that result from an operation.

 Addressing modes
Register and immediate modes we have already seen MOV AX,1 MOV BX,AX register immediate

3F03 - 80x86 assembler

Typical addressing modes
Absolute address mode

MOV AX,[0200] value stored in memory location DS:0200

3F03 - 80x86 assembler

Typical addressing modes
Register indirect

MOV AX,[BX] value stored at address contained in DS:BX

3F03 - 80x86 assembler

Typical addressing modes
Displacement

MOV DI,4 MOV AX,[0200+DI] value stored at DS:0204

3F03 - 80x86 assembler

Typical addressing modes
Indexed MOV BX,0200 MOV DI,4 MOV AX,[BX+DI] value stored at DS:0204

3F03 - 80x86 assembler

Typical addressing modes
Memory indirect MOV DI,0204 MOV BX,[DI] MOV AX,[BX] If DS:0204 contains 0256, then AX will contain whatever is stored at DS:0256

3F03 - 80x86 assembler

Typical addressing modes
Memory indirect MOV DI,0204 MOV BX,[DI] MOV AX,[BX]
0250 Byte addresses in memory 0200 0204

DI

56 02 BX
0256

If DS:0204 contains 0256, then AX will contain whatever is stored at DS:0256

AX = 1234

34 12

8086 in Maximum Mode

The IBM PC is a maximum mode 8088 system. When an 8086/8088 is used in the maximum mode (MN/MX pin grounded) it requires the use of an 8288 Bus Controller. The system can support multiple processors on the system bus by the use of an 8289 Bus Arbiter. The following signals now come from the 8288: ALE, DT/R, DEN, and INTA. The M/IO, RD, and WR signals are replaced by: MRDC - memory read command MWTC - memory write command IORC - I/O read command IOWC - I/O write command AMWC - Advanced memory write command AIOWC - Advanced I/O write command The advanced commands become active earlier in the cycle to give devices an earlier indication of a write operation.

IV-1

8086 Maximum Mode

When in the maximum mode, the 8086/8088 has 3 status lines that are connected to the 8288 and provide it with the information it needs to generate the system bus signals. The information provided by the status bits is as follows. S2 S1 S0 0 0 0 0 0 1 0 1 0 0 1 1 1 0 0 1 0 1 1 1 0 1 1 1 operation Interrupt Acknowledge Read I/O port Write I/O port Halt Instruction Fetch Read Memory Write Memory Passive signal INTA IORC IOWC, AIOWC none MRDC MRDC MWTC, AMWC none

IV-2

Direct Memory Access - DMA

DMA allows data to go between memory and a peripheral, such as a disk drive, without going through the cpu. The DMA controller takes over the address bus, data bus, and control bus. The 8237A DMA Controller is a commonly used device and is in the IBM PC. Figure 11-4 is a simplified block diagram showing the use of a DMA controller. For example, to read a disk file the following operations occur. 1. Send a series of commands to the disk controller to find and read a block of data. 2. When the controller has the first byte of the block, it sends a DMA request DREQ to the DMA controller. 3. If that input of the DMA controller is unmasked, the DMA controller sends a hold-request HQR to the cpu. 4. The cpu responds with a hold-acknowledge HLDA and floats its buses. 5. The DMA controller then takes control of the buses. 6. The DMA controller sends out the memory address and DMA acknowledge DACK0 to the disk controller. 7. The DMA controller asserts the MEMW and IOR lines.

IV-4

Memory
Terminology Volatile - data is lost when power is turned off. Nonvolatile - retains data when powered off. Random Access - all data locations accessed in the same amount of time. Sequential Access - data accessed in varying amounts of time, e.g., tape. ROM - Read Only Memory. RAM - Random Access Memory By convention, RAM in a PC is really Read/Write Memory and ROM (EPROM) in a PC, although random access memory, is not referred to as RAM. Examples VOLATILE Static RAM Dynamic RAM

NONVOLATILE ROM, PROM, EPROM, EEPROM, FLASH Disk, tape Magnetic core, magnetic bubble
IV-6

Interface 8086 to 6116 static RAM

8086
A ____ BHE ALE D
20 21 A0, BHE* A(11-1) D(7-0) A(19-12) 16

6116 (2K x8)

A(10-0) D(7-0) __ R/W OE* CS*

Latch

low byte (even)

Addr Decoder RAMCS* __ M/IO ___ WR ___ RD READY

RLH - Fall 1997

A0 MEM*

A(11-1) D(15-8)

BHE* Wait State Gen

A(10-0) D(7-0) __ R/W OE* CS*

hi byte (odd)

47

Introduction to 8086 Assembly Language Programming

What Is Assembly Language

Machine-Specific Programming Language
one-one correspondence between statements and native machine language matches machine instruction set and architecture

IBM-PC Assembly Language

refers to 8086, 8088, 80186, 80286, 80386, 80486, and Pentium Processors

What Is An Assembler?
Systems Level Program
translates assembly language source code to machine language
object file - contains machine instructions, initial data, and information used when loading the program listing file - contains a record of the translation process, line numbers, addresses, generated code and data, and a symbol table

Why Learn Assembly Language?

Learn how a processor works Understand basic computer architecture Explore the internal representation of data and instructions Gain insight into hardware concepts Allows creation of small and efficient programs Allows programmers to bypass high-level language restrictions Might be necessary to accomplish certain operations

Data Representation
Binary 0-1
represents the state of electronic components used in computer systems

Word - 16 Bits
Each architecture may define its own wordsize

Bit - Binary digit Byte - 8 Bits

smallest addressable memory location (on the IBM-PC)

Doubleword - 32 Bits Quadword - 64 Bits Nybble - 4 Bits

Numbering Systems
Binary - Base 2
0, 1

Raw Binary format

All information is coded for internal storage Externally, we may choose to express the information in any numeration system, or in a decoded form using other symbols

Octal - Base 8
0, 1, 2, 7

Decimal - Base 10
0, 1, 2, , 9

Hexadecimal (Hex)
0, 1, , 9, A, B, , F

Decoding a Byte
Raw
01010000b

Machine Instruction
Push AX

Hex
50h

ASCII Character code

P

Octal
1208

Integer
80 (eighty)

Decimal
80d

BCD
50 (fifty)

Custom code ???

Machine Language
A language of numbers, called the Processors Instruction Set
The set of basic operations a processor can perform

Each instruction is coded as a number Instructions may be one or more bytes Every number corresponds to an instruction

Assembly Language vs Machine Language Programming

Machine Language Programming
Writing a list of numbers representing the bytes of machine instructions to be executed and data constants to be used by the program

Assembly Language Programming

Using symbolic instructions to represent the raw data that will form the machine language program and initial data constants

Assembly Language Instructions

Mnemonics represent Machine Instructions
Each mnemonic used represents a single machine instruction The assembler performs the translation

Some mnemonics require operands

Operands provide additional information
register, constant, address, or variable

Assembler Directives

8086 Instruction - Basic Structure

Label Operator Operand[s] ;Comment Label - optional alphanumeric string 1st character must be a-z,A-Z,?,@,_,$ Last character must be : Operator - assembly language instruction mnemonic: an instruction format for humans Assembler translates mnemonic into hexadecimal opcode example: mov is f8h Operand[s] - 0 to 3 pieces of data required by instruction Can be several different forms Delineated by commas immediate, register name, memory data, memory address Comment - Extremely useful in assembler language These fields are separated by White Space (tab, blank, \n, etc.)

8086 Instruction - Example

Label
INIT: mov

Operator
ax, bx

Operand[s]

;Comment

; Copy contents of bx into ax

Label Operator Operands Comment

INIT: mov ax and bx alphanumeric string between ; and \n

Not case sensitive Unlike other assemblers, destination operand is first mov is the mnemonic that the assembler translates into an opcode

Assembler Language Segment Types

Stack For dynamic data storage Source file defines size Must have exactly 1 Data For static data Storage Source file defines size Source file defines content (optional) Can have 0 or more Code For machine Instructions Must have 1 or more

Using MASM Assembler

to get help: C:\> masm /h Can just invoke MASM with no arguments: C:\> masm Source Filename [.ASM]: Object Filename [HELLO.OBJ]: Source Listing [NUL.LST]: Cross Reference [NUL.CRF]:

hello

.ASM - Assembler source file prepared by programmer .OBJ - Translated source file by assembler .LST - Listing file, documents Translation process Errors, Addresses, Symbols, etc .CRF Cross reference file

x86 Instruction Set Summary

(Data Transfer)
CBW CWD IN LAHF LDS LEA LES LODS MOV MOVS OUT POP POPF PUSH PUSHF SAHF STOS XCHG XLAT ;Convert Byte to Word AL AX ;Convert Word to Double in AX ;Input ;Load AH from Flags ;Load pointer to DS ;Load EA to register ;Load pointer to ES ;Load memory at SI into AX ;Move ;Move memory at SI to DI ;Output ;Pop ;Pop Flags ;Push ;Push Flags ;Store AH into Flags ;Store AX into memory at DI ;Exchange ;Translate byte to AL DX,AX

x86 Instruction Set Summary

(Arithmetic/Logical)
AAA AAD AAM AAS ADC ADD AND CMC CMP CMPS DAA DAS DEC DIV IDIV MUL IMUL INC ;ASCII Adjust for Add in AX ;ASCII Adjust for Divide in AX ;ASCII Adjust for Multiply in AX ;ASCII Adjust for Subtract in AX ;Add with Carry ;Add ;Logical AND ;Complement Carry ;Compare ;Compare memory at SI and DI ;Decimal Adjust for Add in AX ;Decimal Adjust for Subtract in AX ;Decrement ;Divide (unsigned) in AX(,DX) ;Divide (signed) in AX(,DX) ;Multiply (unsigned) in AX(,DX) ;Multiply (signed) in AX(,DX) ;Increment

x86 Instruction Set Summary

(Arithmetic/Logical Cont.)
NEG NOT OR RCL RCR ROL ROR SAR SBB SCAS SHL/SAL SHR SUB TEST XLAT XOR ;Negate ;Logical NOT ;Logical inclusive OR ;Rotate through Carry Left ;Rotate through Carry Right ;Rotate Left ;Rotate Right ;Shift Arithmetic Right ;Subtract with Borrow ;Scan memory at DI compared to AX ;Shift logical/Arithmetic Left ;Shift logical Right ;Subtract ;AND function to flags ;Translate byte to AL ;Logical Exclusive OR

x86 Instruction Set Summary

(Control/Branch Cont.)
CALL CLC CLD CLI ESC HLT INT INTO IRET JB/JNAE JBE/JNA JCXZ JE/JZ JL/JNGE JLE/JNG JMP JNB/JAE JNBE/JA JNE/JNZ JNL/JGE ;Call ;Clear Carry ;Clear Direction ;Clear Interrupt ;Escape (to external device) ;Halt ;Interrupt ;Interrupt on Overflow ;Interrupt Return ;Jump on Below/Not Above or Equal ;Jump on Below or Equal/Not Above ;Jump on CX Zero ;Jump on Equal/Zero ;Jump on Less/Not Greater or Equal ;Jump on Less or Equal/Not Greater ;Unconditional Jump ;Jump on Not Below/Above or Equal ;Jump on Not Below or Equal/Above ;Jump on Not Equal/Not Zero ;Jump on Not Less/Greater or Equal

x86 Instruction Set Summary

(Control/Branch)
JNLE/JG JNO JNP/JPO JNS JO JP/JPE JS LOCK LOOP LOOPNZ/LOOPNE LOOPZ/LOOPE NOP REP/REPNE/REPNZ REPE/REPZ RET SEG STC STD STI TEST WAIT ;Jump on Not Less or Equal/Greater ;Jump on Not Overflow ;Jump on Not Parity/Parity Odd ;Jump on Not Sign ;Jump on Overflow ;Jump on Parity/Parity Even ;Jump on Sign ;Bus Lock prefix ;Loop CX times ;Loop while Not Zero/Not Equal ;Loop while Zero/Equal ;No Operation (= XCHG AX,AX) ;Repeat/Repeat Not Equal/Not Zero ;Repeat Equal/Zero ;Return from call ;Segment register ;Set Carry ;Set Direction ;Set Interrupt ;AND function to flags ;Wait

Assembler Directives
end label proc far|near end of program, label is entry point begin a procedure; far, near keywords specify if procedure in different code segment (far), or same code segment (near) end of procedure set a page format for the listing file title of the listing file mark start of code segment mark start of data segment set size of stack segment

endp page title .code .data .stack

Assembler Directives
db dw dd dq dt equ Examples: db 100 dup (?) db Hello maxint equ count equ define 100 bytes, with no initial values for bytes define 5 bytes, ASCII equivalent of Hello. 32767 10 * 20 ; calculate a value (200) define byte define word (2 bytes) define double word (4 bytes) define quadword (8 bytes) define tenbytes equate, assign numeric expression to a name

Program Example
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; ; ; This is an example program. It prints the ; ; character string "Hello World" to the DOS standard output ; ; using the DOS service interrupt, function 9. ; ; ; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; hellostk SEGMENT BYTE STACK 'STACK' ;Define the stack segment DB 100h DUP(?) ;Set maximum stack size to 256 bytes (100h) hellostk ENDS hellodat dos_print strng hellodat hellocod START: SEGMENT BYTE 'DATA' ;Define the data segment EQU 9 ;define a constant via EQU DB 'Hello World',13,10,'$' ;Define the character string ENDS SEGMENT BYTE 'CODE' ;Define mov ax, SEG hellodat mov ds, ax mov ah, dos_print mov dx,OFFSET strng int 21h mov ax, 4c00h int 21h ENDS END START the Code segment ;ax <-- data segment start address ;ds <-- initialize data segment register ;ah <-- 9 DOS 21h string function ;dx <-- beginning of string ;DOS service interrupt ;ax <-- 4c DOS 21h program halt function ;DOS service interrupt ; END label defines program entry

hellocod

Another Way to define Segments

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; Use 'assume' directive to define segment types ; ; ; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; hellostk SEGMENT ;Define a segment DB 100h DUP(?) hellostk ENDS hellodat dos_print strng hellodat hellocod START: SEGMENT ;define a segment EQU 9 ;define a constant DB 'Hello World',13,10,'$' ;Define the character string ENDS SEGMENT ;define a segment assume cs:hellocod, ds:hellodat, ss: hellostk mov ax, hellodat ;ax <-- data segment start address mov ds, ax ;ds <-- initialize data segment register mov ah, dos_print ;ah <-- 9 DOS 21h string function mov dx,OFFSET strng ;dx <-- beginning of string int 21h ;DOS service interrupt mov ax, 4c00h ;ax <-- 4c DOS 21h program halt function int 21h ;DOS service interrupt ENDS START

hellocod END

Yet another way to define Segs

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; Use .stack,.data,.code directives to define segment types ; ; ; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; .stack 100h ; reserve 256 bytes of stack space .data dos_print EQU 9 strng DB 'Hello World',13,10,'$'

;define a constant ;Define the character string

.code START: mov mov mov mov int mov int ax, SEG strng ds, ax ah, dos_print dx,OFFSET strng 21h ax, 4c00h 21h ;ax <-- data segment start address ;ds <-- initialize data segment register ;ah <-- 9 DOS 21h string function ;dx <-- beginning of string ;DOS service interrupt ;ax <-- 4c DOS 21h program halt function ;DOS service interrupt

END

START

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

Program Data and Storage

Pseudo-ops to define 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

define memory contents specify amount of storage to reserve for run-time data

Defining Data
Numeric data values
100 - decimal 100B - binary 100H - hexadecimal '100' - ASCII "100" - ASCII

A list of values may be used - the following creates 4 consecutive words

DW 40CH,10B,-13,0

Use the appropriate DEFINE directive (byte, word, etc.)

A ? represents an uninitialized storage location

DB 255,?,-128,'X'

Naming Storage Locations

Names can be associated with storage locations
ANum DB -4 DW 17 ONE UNO DW 1 X DD ? 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 unitialized doubleword

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

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")

Word Storage
Word, doubleword, and quadword data are stored in reverse byte order (in memory)
Directive DW 256 DD 1234567H DQ 10 X DW 35DAh Bytes in Storage 00 01 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

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

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

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>

Data Transfer Instructions

MOV target, source
reg, reg mem, reg reg, mem mem, immed reg, immed

Sizes of both operands must be the same

reg can be any nonsegment register except IP cannot be the target register MOV's between a segment register and memory or a 16-bit register are possible

Sample MOV Instructions

b db 4Fh w dw 2048 mov mov mov mov mov mov bl,dh ax,w ch,b al,255 w,-100 b,0

When a variable is created with a define 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 db 4Fh, 20h, 3Ch w dw 2048, -100, 0 mov mov mov mov bx, w+2 b+1, ah ah, b+5 dx, w-3

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

Type checking is still in effect

eXCHanGe
XCHG target, source
reg, reg reg, mem mem, reg

This provides an efficient means to swap the operands

No temporary storage is needed Sorting often requires this type of operation This works only with the general registers

MOV and XCHG cannot perform memory to memory moves

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

Program Segment Structure

Data Segments
Storage for variables Variable addresses are computed as offsets from start of this segment

Stack Segment
used to set aside storage for the stack Stack addresses are computed as offsets into this segment

Code Segment
contains executable instructions

Segment directives
.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 flat: no segments, 32-bit addresses, protected mode only (80386 and higher)

Program Skeleton
.model small .stack 100H .data ;declarations .code main proc ;code main endp ;other procs end main Select a memory model Define the stack size Declare variables Write code
organize into procedures

Mark the end of the source file

optionally, define the entry point