The document discusses memory segmentation and registers in the 8086 processor. Memory is divided into 64K segments identified by a 16-bit number, and locations within segments are specified with a 16-bit offset. There are 14 registers for data, addresses, segments, pointers, indexes, status flags, and instructions. The registers are used for arithmetic, logic, and flow control operations. Instructions include data transfer, arithmetic, logic, shifts, and flow control. Memory addressing uses segment and offset addresses, and the stack uses push and pop instructions.

1. Programming in Assembly Language
Memory Segmentation
 Memory segments are a direct consequence of using a 20 bit address in a 16 bit processor
 Memory is partitioned into 64K (216
) segments
 Each segment is identified by a 16-bit segment number ranging from 0000h-FFFFh
 Within a segment, a memory location is specified by a 16-bit offset (the number of bytes from the
beginning of the segment)
 The Segment:Offset address is a logical address
Segment:Offset Addresses
 A4FB:4872h means offset 4872h within segment A4FBh
 To get the physical address, the segment number is multiplied by 16 (shifted 4 bits to the left) and the offset
is added
 A4FB0h + 4872h = A9822h (20 bit physical address)
 There is a lot of overlap between segments; a new segment begins every 16 bytes (addresses ending in 0h)
 We call these 16 bytes a paragraph
 Because segments may overlap, the segment:offset address is not unique
8086 Registers
 Information inside the microprocessor is stored in registers (fourteen 16-bit registers)
 data registers hold data for an operation
 address registers hold the address of an instruction or data
 The address registers are divided into segment, pointer, and index registers
 a status register (called FLAGS) keeps the current status of the processor
Data Registers: AX, BX, CX, and DX
 Available to the programmer for general data manipulation
 Some operations require a particular register
 High and low bytes of data registers can be accessed separately, i.e., AX is divided into AH and AL
 AX (accumulator) is preferred for arithmetic, logic, and data transfer operations
 BX (base register) serves as an address register
 CX (count register) frequently serves as a loop counter
 DX (data register) is used in multiplication and division
Pointer and Index Registers: SP, BP, SI, DI
 SP (stack pointer) points to the top of the processor's stack
 BP (base pointer) usually accesses data on the stack
 SI (source index) used to point to memory locations in the data segment
 DI (destination index) performs same functions as SI.
 DI and SI are often used for string operations
Segment Registers: CS, DS, SS, ES
 CS (code segment) addresses the start of the program's machine code in memory
 DS (data segment) addresses the start of the program's data in memory

2.  SS (stack segment) addresses the start of the program's stack space in memory
 ES (extra segment) addresses and additional data segment, if necessary
Instruction Pointer: IP
 8086 uses registers CS and IP to access instructions
 CS register contains the segment number of the next instruction and the IP contains the offset
 The IP is updated each time an instruction is executed so it will point to the next instruction
 The IP is not directly accessible to the user
The FLAGS register
 Indicates the status of the microprocessor
 Two kinds of flag bits: status flags and control flags
 Status flags reflect the result of an instruction, e.g., when the result of an arithmetic operation is 0, ZF (zero
flag) is set to 1 (true)
 Control flags enable or disable certain operations of the processor, e.g., if the IF (interrupt flag) is cleared
(set to 0), inputs from the keyboard are ignored by the processor
Instructions Groups and Concepts
 Data Transfer Instructions
 Arithmetic Instructions
 Logic Instructions
 Flow-control Instructions
 Processor Control Instructions
 String Instructions
Data Transfer Instructions
 General instructions
o mov, pop, push, xchg, xlat/xlatb
 Input/Output instructions
o in, out
 Address instructions
o lds, lea, les
 Flag instructions
o lahf, popf, pushf, sahf
General Instructions
 mov destination, source
 pop destination
 push source
 xchg destination, source
 xlat(b)table
 Note that the destination comes first, just as in an assignment statement in C
Examples

3.  mov ax, [word1]
o "Move word1 to ax"
o Contents of register ax are replaced by the contents of the memory location word1
o The brackets specify that the contents of word1 are stored -- word1==address,
[word1]==contents
 xchg ah, bl
o Swaps the contents of ahand bl
 Illegal: mov [word1], [word2]
o can't have both operands be memory locations
The Stack
 A data structure in which items are added and removed only from one end (the "top")
 A program must set aside a block of memory to hold the stack by declaring a stack segment
stack 256
 SS will contain the segment number of the stack segment -- SP will be initialized to 256 (100h)
 The stack grows from higher memory addresses to lower ones
PUSH and POP
 New words are added with push
 push source
o SP is decreased by 2
o a copy of the source contents is moved to SS:SP
 Items are removed with pop
 pop destination
o Content of SS:SP is moved to the destination
o SP is increased by 2
Stack example
push ax ;Save ax and bx
push bx ; on the stack
mov ax, -1 ;Assign test values
mov bx, -2
mov cx, 0
mov dx, 0
push ax ;Push ax onto stack
push bx ;Push bx onto stack
pop cx ;Pop cx from stack
pop dx ;Pop dx from stack
pop bx ;Restore saved ax and bx
pop ax ; values from stack
Arithmetic Instructions
 Addition instructions
o aaa, adc, add, daa, inc
 Subtraction instructions
o aas, cmp, das, dec, neg, sbb, sub
 Multiplication instructions
o aam, imul, mul

4.  Division instructions
o aad, cbw, cwd, div, idiv
Addition Instructions
 aaa
o ASCII adjust for addition
 adc destination, source
o Add with carry
 add destination, source
o Add bytes or words
 daa
o Decimal adjust for addition
 inc destination
o Increment
ADD and INC
 ADD is used to add the contents of
o two registers
o a register and a memory location
o a register and a constant
 INC is used to add 1 to the contents of a register or memory location
Examples
 add ax, [word1]
o "Add word1to ax"
o Contents of register ax and memory location word1 are added, and the sum is stored in ax
 inc ah
o Adds one to the contents of ah
 Illegal: add [word1], [word2]
o can't have both operands be memory locations
Subtraction instructions
 aas
o ASCII adjust for subtraction
 cmp destination, source
o Compare
 das
o Decimal adjust for subtraction
 dec destination
o Decrement byte or word
 neg destination
o Negate (two's complement)
 sbb destination, source
o Subtract with borrow
 sub destination, source
o Subtract
Examples

5.  sub ax, [word1]
o "Subtract word1 from ax"
o Contents of memory location word1 is subtracted from the contents of register ax, and the sum is
stored in ax
 dec bx
o Subtracts one from the contents of bx
 Illegal: sub [byte1], [byte2]
o can't have both operands be memory locations
Multiplication instructions
 aam
o ASCII adjust for multiply
 imul source
o Integer (signed) multiply
 mul source
o Unsigned multiply
Byte and Word Multiplication
 If two bytes are multiplied, the result is a 16-bit word
 If two words are multiplied, the result is a 32-bit doubleword
 For the byte form, one number is contained in the source and the other is assumed to be in al -- the product
will be in ax
 For the word form, one number is contained in the source and the other is assumed to be in ax -- the most
significant 16 bits of the product will be in dx and the least significant 16 bits will be in ax
Examples
 If ax contains 0002h and bx contains 01FFh
mul bx
dx = 0000h ax = 03FEh
 If ax contains 0001h and bx contains FFFFh
mul bx
dx = 0000h ax = FFFFh
imul bx
dx = FFFFh ax = FFFFh
Division instructions
 aad
o ASCII adjust for divide
 cbw
o convert byte to word
 cwd
o convert word to doubleword
 div source
o unsigned divide
 idiv source
o integer (signed) divide

6. Byte and Word Division
 When division is performed, there are two results, the quotient and the remainder
 These instructions divide 8 (or 16) bits into 16 (or 32) bits
 Quotient and remainder are same size as the divisor
 For the byte form, the 8 bit divisor is contained in the source and the dividend is assumed to be in ax -- the
quotient will be in al and the remainder in ah
 For the word form, the 16 bit divisor is contained in the source and the dividend is assumed to be in dx:ax -
- the quotient will be in ax and the remainder in dx
Examples
 If dx = 0000h, ax = 00005h, and bx = 0002h
div bx
ax = 0002h dx = 0001h
 If dx = 0000h, ax = 0005h, and bx = FFFEh
div bx
ax = 0000h dx = 0005h
idiv bx
ax = FFFEh dx = 0001h
Divide Overflow
 It is possible that the quotient will be too big to fit in the specified destination (al or ax)
 This can happen if the divisor is much smaller than the dividend
 When this happens, the program terminates and the system displays the message "Divide Overflow"
Sign Extension of the Dividend
 Word division
o The dividend is in dx:ax even if the actual dividend will fit in ax
o For div, dx should be cleared
o For idiv, dx should be made the sign extension of ax using cwd
 Byte division
o The dividend is in ax even if the actual dividend will fit in al
o For div, ah should be cleared
o For idiv, ah should be made the sign extension of al using cbw
Logic Instructions
 and destination, source
o Logical AND
 not destination
o Logical NOT (one's complement)
 or destination, source
o Logical OR
 test destination, source
o Test bits
 xor destination, source
o Logical Exclusive OR

7.  The ability to manipulate bits is one of the advantages of assembly language
 One use of and, or, and xor is to selectively modify the bits in the destination using a bit pattern (mask)
 The and instruction can be used to clear specific destination bits
 The or instruction can be used to set specific destination bits
 The xor instruction can be used to complement specific destination bits
Examples
 To clear the sign bit of al while leaving the other bits unchanged, use the and instruction with 01111111b
=7Fh as the mask
and al,7Fh
 To set the most significant and least significant bits of al while preserving the other bits, use the or
instruction with 10000001b = 81h as the mask
or al,81h
 To change the sign bit of dx, use the xor instruction with a mask of 8000h
xor dx,8000h
The NOT instruction
 The not instruction performs the one's complement operation on the destination
 The format is
o not destination
 To complement the bits in ax:
o not ax
 To complement the bits in WORD1
o not [WORD1]
The TEST instruction
 The test instruction performs an and operation of the destination with the source but does not change the
destination contents
 The purpose of the test instruction is to set the status flags (discussed later)
Status Flags
Bit Name Symbol
0 Carry flag cf
2 Parity flag pf
4 Auxiliary carry flag af
6 Zero flag zf
7 Sign flag sf
11 Overflow flag of
The Carry Flag (CF)
 CF = 1 if there is a carry out from the msb (most significant bit) on addition, or there is a borrow into the
msb on subtraction
 CF = 0 otherwise

8.  CF is also affected by shift and rotate instructions
The Parity Flag (PF)
 PF = 1 if the low byte of a result has an even number of one bits (even parity)
 PF = 0 otherwise (odd parity)
The Auxiliary Carry Flag (AF)
 AF = 1 if there is a carry out from bit 3 on addition, or there is a borrow into the bit 3 on subtraction
 AF = 0 otherwise
 AF is used in binary-coded decimal (BCD) operations
The Zero Flag (ZF)
 ZF = 1 for a zero result
 ZF = 0 for a non-zero result
The Sign Flag (SF)
 SF = 1 if the msb of a result is 1; it means the result is negative if you are giving a signed interpretation
 SF = 0 if the msb is 0
The Overflow Flag (OF)
 OF = 1 if signed overflow occurred
 OF = 0 otherwise
Shift Instructions
 Shift and rotate instructions shift the bits in the destination operand by one or more positions either to the
left or right
 The instructions have two formats:
o opcode destination, 1
o opcode destination, cl
 The first shifts by one position, the second shifts by N positions, where cl contains N (cl is the only register
which can be used)
Left Shift Instructions
 The SHL (shift left) instruction shifts the bits in the destination to the left.
 Zeros are shifted into the rightmost bit positions and the last bit shifted out goes into CF
 Effect on flags:
o SF, PF, ZF reflect the result
o AF is undefined
o CF = last bit shifted out
o OF = 1 if result changes sign on last shift
SHL example
 dh contains 8Ah and cl contains 03h

9.  dh = 10001010, cl = 00000011
 after shl dh,cl
o dh = 01010000, cf = 0
The SAL instruction
 The shl instruction can be used to multiply an operand by powers of 2
 To emphasize the arithmetic nature of the operation, the opcode sal (shift arithmetic left) is used in
instances where multiplication is intended
 Both instructions generate the same machine code
Right Shift Instructions
 The SHR (shift right) instruction shifts the bits in the destination to the right.
 Zeros are shifted into the leftmost bit positions and the last bit shifted out goes into CF
 Effect on flags:
o SF, PF, ZF reflect the result
o AF is undefined
o CF = last bit shifted out
o OF = 1 if result changes on last shift
SHR example
 dh contains 8Ah and cl contains 02h
 dh = 10001010, cl = 00000010
 after shr dh,cl
o dh = 001000010, cf = 1
The SAR instruction
 The sar (shift arithmetic right) instruction can be used to divide an operand by powers of 2
 sar operates like shr, except the msb retains its original value
 The effect on the flags is the same as for shr
 If unsigned division is desired, shr should be used instead of sar
Rotate Instructions
 Rotate Left
o The instruction rol (rotate left) shifts bits to the left
o The msb is shifted into the rightmost bit
o The cf also gets the the bit shifted out of the msb
 Rotate Right
o ror (rotate right) rotates bits to the right
o the rightmost bit is shifted into the msb and also into the cf
Rotate through Carry
 Rotate through Carry Left
o The instruction rcl shifts bits to the left
o The msb is shifted into cf
o cf is shifted into the rightmost bit
 Rotate through Carry Right

10. o rcr rotates bits to the right
o The rightmost bit is shifted into cf
o cf is shifted into the msb
 See SHIFT.ASM for an example
Flow-Control Instructions
%TITLE "IBM Character Display -- XASCII.ASM"
IDEAL
MODEL small
STACK 256
CODESEG
Start: mov ax, @data ; Initialize DS to address
mov ds, ax ; of data segment
mov ah, 02h ; display character function
mov cx,256 ; no. of chars to display
mov dl, 0 ; dl has ASCII code of null char
Ploop: int 21h ; display a character
inc dl ; increment ASCII code
dec cx ; decrement counter
jnz Ploop ; keep going if cx not zero
Exit: mov ah, 04Ch ; DOS function: Exit program
mov al, 0 ; Return exit code value
int 21h ; Call DOS. Terminate program
END Start ; End of program / entry point
Conditional Jumps
 jnz is an example of a conditional jump
 Format is
jxxx destination_label
 If the condition for the jump is true, the next instruction to be executed is the one at destination_label.
 If the condition is false, the instruction immediately following the jump is done next
 For jnz, the condition is that the result of the previous operation is not zero
Range of a Conditional Jump
 Table 4.6 (and Table 16.4) shows all the conditional jumps
 The destination_label must precede the jump instruction by no more than 126 bytes, or follow it by no
more than 127 bytes
 There are ways around this restriction (using the unconditional jmp instruction)
The CMP Instruction
 The jump condition is often provided by the cmp (compare) instruction:
cmp destination, source
 cmp is just like sub, except that the destination is not changed -- only the flags are set
 Suppose ax = 7FFFh and bx = 0001h
cmp ax, bx
jg below

11. zf = 0 and sf = of = 0, so control transfers to label below
Types of Conditional Jumps
 Signed Jumps:
o jg/jnle, jge/jnl, jl/jnge, jle/jng
 Unsigned Jumps:
o ja/jnbe, jae/jnb, jb/jnae, jbe/jna
 Single-Flag Jumps:
o je/jz, jne/jnz, jc, jnc, jo, jno, js, jns, jp/jpe, jnp/jpo
Signed versus Unsigned Jumps
 Each of the signed jumps has an analogous unsigned jump (e.g., the signed jump jg and the unsigned jump
ja)
 Which jump to use depends on the context
 Using the wrong jump can lead to incorrect results
 When working with standard ASCII character, either signed or unsigned jumps are OK (msb is always 0)
 When working with the IBM extended ASCII codes, use unsigned jumps
Conditional Jump Example
 Suppose ax and bx contained signed numbers. Write some code to put the biggest one in cx:
mov cx,ax ; put ax in cx
cmp bx,cx ; is bx bigger?
jle NEXT ; no, go on
mov cx,bx ; yes, put bx in cx
NEXT:
The JMP Instruction
 jmp causes an unconditional jump
 jmp destination
 jmp can be used to get around the range restriction of a conditional jump
 e.g, (this example can be made shorter, how?)
TOP: TOP:
; body of loop ; body of loop
; over 126 bytes dec cx
dec cx jnz BOTTOM
jnz TOP jmp EXIT
mov ax, bx BOTTOM:
jmp TOP
EXIT:
mov ax, bx
Branching Structures
 IF-THEN
 IF-THEN-ELSE
 CASE
 AND conditions
 OR conditions
IF-THEN structure

12.  Example -- to compute |ax|:
if ax < 0 then
ax = -ax
endif
 Can be coded as:
; if ax < 0
cmp ax, 0 ; ax < 0 ?
jnl endif ; no, exit
; then
neg ax ; yes, change sign
; endif
IF-THEN-ELSE structure
 Example -- Suppose al and bl contain extended ASCII characters. Display the one that comes first in the
character sequence:
if al <= bl then
display the character in al
else
display the character in bl
endif
 This example may be coded as:
mov ah, 2 ; prepare for display
; if al <= bl
cmp al, bl ; al <= bl ?
jnbe else ; no, display bl
; then ; al <= bl
mov dl, al ; move it to dl
jmp display
else: ; bl < al
mov dl, bl
display:
int 21h ; display it
; endif
The CASE structure
 Multi-way branch structure with following form:
case expression
value1 : statement1
value2 : statement2
�
valuen : statementn
endcase
 Example -- If ax contains a negative number, put -1 in bx; if 0, put 0 in bx; if positive, put 1 in bx:

13. case ax
< 0: put -1 in bx
= 0: put 0 in bx
> 0: put 1 in bx
endcase
 This example may be coded as:
; case ax
cmp ax, 0 ; test ax
jl neg ; ax < 0
je zero ; ax = 0
jg pos ; ax > 0
neg:
mov bx, -1
jmp endcase
zero:
xor bx,bx ; put 0 in bx
jmp endcase
pos:
mov bx, 0
endcase:
 Only one cmp is needed, because jump instructions do not affect the flags
AND conditions
 Example -- read a character and display it if it is uppercase:
read a character into al
if char >= 'A' and char <= 'Z' then
display character
endif
; read a character
mov ah, 1 ;prepare to read
int 21h ;char in al
; if char >= 'A' and char <= 'Z'
cmp al,'A' ;char >= 'A'?
jnge endif ;no, exit
cmp al,'Z' ;char <= 'Z'?
jnle endif ;no, exit
;then display character
mov dl,al ;get char
mov ah,2 ;prep for display
int 21h ;display char
endif:
OR conditions
 Example -- read a character and display it if it is 'Y' or 'y':
read a character into al
if char = 'y' or char = 'Y' then
display character
endif

14. ; read a character
mov ah, 1 ;prepare to read
int 21h ;char in al
; if char = 'y' or char = 'Y'
cmp al,'y' ;char = 'y'?
je then ;yes, display it
cmp al,'Y' ;char = 'Y'?
je then ;yes, display it
jmp endif ;no, exit
then:
mov ah,2 ;prep for display
mov dl,al ;move char
int 21h ;display char
endif:
Looping Structures
 FOR loop
 WHILE loop
 REPEAT loop
The FOR Loop
 The loop statements are repeated a known number of times (counter-controlled loop)
for loop_count times do
statements
endfor
 The loop instruction implements a FOR loop:
loop destination_label
 The counter for the loop is the register cx which is initialized to loop_count
 The loop instruction causes cx to be decremented, and if cx¹ 0, jump to destination_label
 The destination label must precede the loop instruction by no more than 126 bytes
 A FOR loop can be implemented as follows:
;initialize cx to loop_count
TOP:
;body of the loop
loop TOP
FOR loop example
 a count-controlled loop to display a row of 80 stars
mov cx,80 ; # of stars
mov ah,2 ; disp char fnctn
mov dl,'*' ; char to display
TOP:
int 21h ; display a star
loop TOP ; repeat 80 times
FOR loop "gotcha"

15.  The FOR loop implemented with the loop instruction always executes at least once
 If cx = 0 at the beginning, the loop will execute 65536 times!
 To prevent this, use a jcxz before the loop
jcxz SKIP
TOP:
; body of loop
loop TOP
SKIP:
The WHILE Loop
while condition do
statements
endwhile
 The condition is checked at the top of the loop
 The loop executes as long as the condition is true
 The loop executes 0 or more times
WHILE example
 Count the number of characters in an input line
count = 0
read char
while char <> carriage_return do
increment count
read char
endwhile
mov dx,0 ;DX counts chars
mov ah,1 ;read char fnctn
int 21h ;read char into al
WHILE_:
cmp al,0Dh ;ASCII CR?
je ENDWHILE ;yes, exit
inc dx ;not CR, inc count
int 21h ;read another char
jmp WHILE_ ;loop back
ENDWHILE:
 The label WHILE_ is used because WHILE is a reserved word
The REPEAT Loop
repeat
statements
until condition
 The condition is checked at the bottom of the loop
 The loop executes until the condition is true
 The loop executes 1 or more times
REPEAT example
 read characters until a blank is read

16. repeat
read character
until character is a blank
mov ah,1 ;read char fnctn
REPEAT:
int 21h ;read char into al
;until
cmp al,' ' ;a blank?
jne REPEAT ;no, keep reading
 Using a while or a repeat is often a matter of personal preference. The repeat may be a little shorter
because only one jump instruction is required, rather than two
Digression: Displaying a String
 We've seen INT 21h, functions 1 and 2, to read and display a single character
 INT 21h, function 9 displays a character string
o Input: dx = offset address of string
o The string must end with a '$' character -- The '$' is not displayed
The LEA Instruction
 INT 21h, function 9, expects the offset address of the string to be in dx
 To get it there, use the lea (load effective address) instruction
lea destination,source
 destination is a register, and source is a memory location
 For example, lea dx, msg puts the offset address of the variable msg into dx
A digression from our digression -- program segment prefix (PSP)
 DOS prefaces each program it loads with a PSP
 The PSP contains information about the program, including any command line arguments
 The segment number of the PSP is loaded in ds, so ds does not contain the segment number of the
DATASEG
 To correct this
mov ax,@data
mov ds,ax
 The assembler translates@data into a segment number
 Two instructions are necessary since a number cannot be moved directly into a segment register
So, back to printing a string...
%TITLE "Print String Program -- PRTSTR.ASM"
IDEAL
MODEL small
STACK 256
DATASEG
msg DB "Hello!$"
CODESEG
Start:

17. 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
END Start ;End of program / entry point