1. Morgan Kaufmann Publishers Computer Organization and Assembly Language
August 25, 2018
CS 206 D
Computer Organization and Assembly Language
Chapter 1 — Computer Abstractions and Technology

2. Introduction to 8086 Assembly Language
01/22/08
Introduction to 8086 Assembly Language
Assembly Language Programming

3. MOV CX, 0 ; CX counts terms, initially 0
01/22/08
Program Statements
Assembly Language Features
1- Program comments 2-Reserved
3-Words Identifiers Statements Directives
Comments begin with semicolon and the assembler ignores anything typed after the semicolon.
MOV CX, 0 ; CX counts terms, initially 0
Operation is a predefined or reserved word (MOV; ADD)
mnemonic - symbolic operation code
directive – pseudo - operation code (END)
Space or tab separates initial fields
Most assemblers are not case sensitive

4. Program Data and Storage
01/22/08
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
Bit - Binary digit
Byte - 8 Bits
smallest addressable memory location

5. Identifiers Can be from 1 to 31 characters long (not case sensitive).
May consist of letters, digits, and the special characters
? _ $ % (Thus, embedded blanks are not allowed).
Names may not begin with a digit.
If a dot is used, it must be the first character.
Examples:
COUNTER1
2abc
@CHARACTER
A45. 28
TWO WORDS
STD_NUM
.TEST
Begins with a digit
. Not first character
Contains a blank
YOU&ME
Contains an illegal character

6. 01/22/08
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

7. Naming Storage Locations
01/22/08
Names can be associated with storage locations
Var1 DB 255,?,-128,'X'
ANum DB -4
DW 17
X DD ?
Anum, X and Var1 names are called variables
A list of values may be used - the Var1 creates 4 consecutive bytes
ANum refers to a byte storage location, initialized to FCh ??
Negative numbers are represented by its 2’s complement
The next word has no associated name
A ? represents an uninitialized storage location
X is an unitialized double word

8. Numeric Constant
In an assembly language program, we may express data as:
Binary: bit string followed by ‘B’ or ‘b’
Decimal: string of decimal digits followed by an optional ‘D’ or ‘d’
Hex: begins with a decimal digit and ends with ‘H’ or ‘h’
Real : end with ‘R’ and the assembler converts a given a decimal or hex constant to floating point number
Any number may have an optional sign.
The decimal range is:
Unsigned representation: 0 to 255
Signed representation: -128 to 127
Number Type
11011
1101B
64223
-21843D
1,234
1B4DH
1B4D
FFFFH
0BFFFH
decimal
binary
illegal
hex

9. Defining Types of data – Array
an array is a sequence of memory bytes or words.
Example:
Org 200H
B_ARRAY DB 10H,20H,30H
W_ARRAY DW ,40,29887,329
Symbol Address Contents
B_ARRAY H 10H
B_ARRAY H 20H
B_ARRAY H 30H
W_ARRAY H 1000D
W_ARRAY H 40D
W_ARRAY H D
W_ARRAY H D

10. DUP Allows a sequence of storage locations to be defined or reserved
01/22/08
Allows a sequence of storage locations to be defined or reserved
Only used as an operand of a define directive
DB 40 DUP (?)‏ ; 40 unitialized bytes
DW 10h DUP (0)‏ ; 16 words with zero ; initial values
DB 3 dup ("ABC") ; means sequence
;"ABC" three times
;"ABCABCABC"

11. Word Storage
01/22/08
Word, doubleword, and quadword data are stored in reverse byte order (in memory)‏
Directive Bytes in Storage DW
DD H
DQ A
X DW 35DAh DA 35
Low byte of X is at X, high byte of X is at X+1

12. Equal Sign Directive (=)
01/22/08
name = expression
expression must be numeric
these symbols may be redefined at any time
DW count (?)
count = 1
Sum = count * 2
= expressions are evaluated where defined

13. EQU Directive name EQU expression expression can be string or numeric
01/22/08
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>
Note: no memory is allocated for EQU names.
EQU expressions are evaluated where used

14. Statements Both instructions and directives have up to four fields:
[identifier ] operation [operand(s)] [comment]
[Name Fields are optional]
At least one blank or tab character must separate the fields.
The fields do not have to be aligned in a particular column, but they
must appear in the above order.
An example of an instruction:
START: MOV CX,5 ; initialize counter
An example of an assembler directive:
MAIN PROC

15. Program Segment Structure
01/22/08
.SEGMENT Directive
.END Directive
ENDP directive ends a procedure
END directive ends the entire program and appears as the last statement
Each segment can not be larger than 64K byte=216 byte
Data Segments
Storage for variables
Variable addresses are computed as offsets 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 offsets into this segment
Segment directives
.data
.code
.stack size

16. Program Structure - Stack Segment
The purpose of the stack segment declaration is to set aside a block
of memory (the stack area) to store the stack.
The stack area should be big enough to contain the stack at its
maximum size.
Syntax:
.STACK size ; where size is an optional number that specifies
; the stack area size in bytes.
Example:
.STACK 100H ; sets aside 100H bytes for the stack area.
; (reasonable size for most applications).
If size is omitted, 1KB is set aside for the stack area.

17. Program Structure - Data Segment
A program’s data segment contains all the variable definitions.
Constant definitions are often made here as well. (they may be
placed elsewhere in the program since no memory allocation is
involved).
To declare a data segment, we use the directive .DATA, followed by
variable and constant declarations.
Example:
.DATA
WORD1 DW 2
MSG DB ‘this is a message’

18. Program Structure - Code Segment
The code segment contains a program’s instructions.
Syntax:
.CODE name ; where name is an optional name of segment.
There is no need for a name in a SMALL program, However, the assembler will generate an error.
Inside a code segment, instructions are organized as procedures.
The simplest procedure definition is:
name PROC ; name: is the name of the procedure.
; body of the procedure ; PROC & ENDP: are pseudo-ops that
name ENDP ; delineate the procedure
Example of a code segment definition:
.CODE
MAIN PROC
; main procedure instructions
MAIN ENDP
; other procedures go here

19. Program Structure Memory Models
01/22/08
Program Structure Memory Models
The size of code and data that a program can have, is determined by
specifying a memory model using the .MODEL directive.
Syntax:
.MODEL memory_model
Model Description
SMALL code in 1 segment data in 1 segment
MEDIUM code > 1 segment data in 1 segment
COMPACT code in 1 segment data > 1 segment
LARGE code > 1 segment data > 1 segment
no array larger than 64k bytes
HUGE code > 1 segment data > 1 segment
arrays may be larger than 64k bytes

20. Program Skeleton .model small .stack 100H .data ;declarations .code
01/22/08
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

21. Instruction Set of 8086 •Data moving instructions.
–Data can be moved from register to register, register to memory and memory to register.
•Arithmetic - add, subtract, increment, decrement, convert byte/word and compare.
•Logic - AND, OR, exclusive OR, shift/rotate and test.
•String manipulation - load, store, move, compare and scan for byte/word.
•Control transfer - conditional, unconditional, call subroutine and return from subroutine.
•Input/Output instructions.
•Other - setting/clearing flag bits, stack operations, software interrupts, etc
Lecture 2 :

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

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

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

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

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

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

28. 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 SEGMENT BYTE 'DATA' ;Define the data segment
dos_print EQU ;define a constant via EQU
strng DB 'Hello World',13,10,'$' ;Define the character string
hellodat ENDS
hellocod SEGMENT BYTE 'CODE' ;Define the Code segment
START: 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
hellocod ENDS
END START ; ‘END label’ defines program entr

29. Creating and Running a Program
A text editor or word processor is used to create a
source program file.
Editor
.ASM file
An assembler is used to translate the source file
into a machine language object file.
Assembling: translate source program (written in assembly language) into machine code (object code)
Assembler
.OBJ file
Linker
A linker is used to link one or more object files
to create a run file.
Linking: complete machine code for the object program, generate an executable module
.EXE file

30. Step 2: Assembling & Linking the program
After printing the copyright information, the assembler will check
the source file for syntax errors:
If one or more errors were found:
The assembler will display the line number of each error and
a short description.
If no errors were found:
The assembler will translate the assembly language code into
the assembly machine language object file (.obj file).
The linker will take one or more object files, fills any
missing addresses, and combines the object files into a
single executable file (.exe file).