1
CS2032 - Computer Organization
and Assembly Language
Sheeza Zaheer
Lecturer
University of Management and Technology
Lahore Campus
OUTLINE
2
● Introduction
■ About this course
■ About Assembly Language
■ Syntax of Assembly Language
■ Basic Instructions
■ Variables
■ Translation
■ Program Structure
● References
■ Chapter 4, Ytha Yu and Charles Marut, “Assembly
Language Programming and Organization of IBM PC
3
ASSEMBLY LANGUAGE
Computer Level Hierarchy
4
Figure Reference:
4 http://users.dickinson.edu/~braught/courses/cs251f09/topics/slides/intro.pdf
Programming Languages
5
● High-Level Languages (HLL)
● Assembly Language
● Machine Language
5
High-Level Language
6
● Allow programmers to write programs that look more like
natural language.
● Examples: C++, Java, C#.NET etc
● A program called Compiler is needed to translate a high-level
language program into low-level language program
6
Machine Language
7
● The "native" language of the computer
● Numeric instructions and operands that can be stored in
memory and are directly executed by computer system.
● Each ML instruction contains an op code (operation
code) and zero or more operands.
● Examples:
Opcode Operand Meaning
-------------------------------------------------
40 increment the AX register
05 0005 add 0005 to AX
7
Assembly Language
8
● Use instruction mnemonics that have one-to-one
correspondence with machine language.
An instruction is a symbolic representation of a single
machine instruction
Consists of:
label always optional
mnemonic always required
operand(s) required by some instructions
comment always optional
8
Sample Program
1. mov ax, 5 ax 05 Memory
011C
2. add ax, 10 ax 15 011E
35 0120
3. add ax, 20 ax 35 0122
0124
4. mov [0120], ax ax 35 0126
5. int 20
9
Essential Tools
10
● Assembler is a program that converts source-code programs
into a machine language (object file).
● Linker joins two or more object files and produces a single
executable file.
● Debugger loads an executable program, displays the source
code, and lets the programmer step through the program one
instruction at a time, and display and modify memory.
● Emulator allows you to load and run assembly language
programs, examine and change contents of registers. Example:
EMU8086
10
Why Learn Assembly Language?
11
● Learn how a processor works
■ Explore the internal representation of data and instructions
■ How to structure a program so it runs more efficiently. (High Level
Language Low Level Language)
● Compilers/Device Drivers/ OS codes
● Games
11
12
BASIC ELEMENTS
Statements
13
● Syntax:
name operation operand(s) comments
■ name and comment are optional
■ Number of operands depend on the instruction
■ One statement per line
○ At least one blank or tab character must separate the field.
■ Each statement is either:
○ Instruction (translated into machine code)
○ Assembler Directive (instructs the assembler to perform
some specific task such as creating a procedure)
13
Statement Example
14
operation Operands
Comment
Label
; Code
Here: mov ax,count ;store count into ax
MAIN PROC ;creates a procedure called MAIN
Assembler Directive
Name
Comment
14
Name/Label Field
15
● The assembler translates names into memory addresses.
● Names can be 1 to 31 character long and may consist of letter, digit or
special characters ? . @ _ $ %. If period is used, it must be first character.
● Embedded blanks are not allowed.
● May not begin with a digit.
● Not case sensitive
Examples of legal names Examples of illegal names
COUNTER_1 TWO WORDS
@character 2abc
.TEST A45.28
DONE? YOU&ME
15
Operation Field: Symbolic operation (Op code)
16
● Symbolic op code translated into Machine Language op code
● Examples: ADD, MOV, SUB
● In an assembler directive, the operation field represents Pseudo-op code
● Pseudo-op is not translated into Machine Language op code, it only tells
assembler to do something.
● Example: PROC psuedo-op is used to create a procedure
16
Operand Field
17
■ An instruction may have zero, one or more operands.
■ In two-operand instruction, first operand is
destination, second operand is source.
■ Examples
PUSHF ;no operand
INC AX ;one operand, adds 1 to the contents of AX
ADD AX, 2 ;two operands, adds value 2 to the contents of AX
17
Comments
18
■ Optional
■ Marked by semicolon in the beginning
■ Ignored by assembler
■ Good practice
;
;initialize registers
;
MOV AX, 0
MOV BX, 0
18
Program Data
19
● Processor operates only on binary data.
● In assembly language, you can express data in:
■ Binary
■ Decimal
■ Octal
■ Hexadecimal
■ Characters
● Numbers
■ For Hexadecimal, the number must begin with a decimal digit. E.g.:
write 0ABCh not only ABCH.
■ Cannot contain any non-digit character. E.g.: 1,234 not allowed
● Characters enclosed in single or double quotes.
■ ASCII codes can be used
19
■ No difference in “A” and 41h
Contd..
20
● Use a radix symbol (suffix) to select binary, octal, decimal, or
hexadecimal
6A15h ; hexadecimal
0BAF1h ; leading zero required
32o ; octal
1011b ; binary
35d ; decimal (default)
20
Variables
21
● Each variable has a data type and is assigned a memory
address by the program.
● Possible Values:
■ 8 Bit Number Range: Signed (-128 to 127), Unsigned (0-255)
■ 16 Bit Number Range: Signed (-32,678 to 32767), Unsigned (0-
65,535)
■ ? To leave variable uninitialized
21
Contd..
22
● Syntax
variable_name type initial_value
variable_name type value1, value2, value3
● Data Definition Directives Or Data Defining Pseudo-ops
■ DB, DW, DD, DQ, DT
Data Definition Directives Values
myArray dw 1000h,2000h
dw 3000h,4000h
Variable name
Remember: you can skip variable name!
22
Contd..
23
Pseudo-ops Description Bytes Examples
DB Define Byte 1 var1 DB ‘A’
Var2 DB ?
array1 DB 10, 20,30,40
DW Define Word 2 var2 DW ‘AB’
array2 DW 1000, 2000
DD Define Double Word 4 Var3 DD -214743648
Note:
Consider
var2 DW 10h
Still in memory the value saved will be 0010h
23
Arrays
24
● Sequence of memory bytes or words
● Example 1:
B_ARRAY DB 10h, 20h, 30h
Symbol Address Contents
B_ARRAY 0200h 10h
B_ARRAY+1 0201h 20h
B_ARRAY+2 0202h 30h
*If B_ARRAY is assigned offset address 0200h by assembler
24
Example 2
25
● W_ARRAY DW 1000, 40, 29887, 329
*If W_ARRAY is assigned offset address 0300h by assembler
Symbol Address Contents
W_ARRAY 0300h 1000d
W_ARRAY+ 2 0302h 40d
W_ARRAY+ 4 0304h 29887d
W_ARRAY+ 6 0306h 329d
High & Low Bytes of a Word
WORD1 DW 1234h
Low Byte = 34h, symbolic address is WORD1
High Byte = 12h, symbolic address is WORD1+1
25
Character String
26
LETTERS DB ‘ABC’
Is equivalent to
LETTERS DB 41h, 42h, 43h
● Assembler differentiates between upper case and lower case.
● Possible to combine characters and numbers.
MSG DB ‘HELLO’, 0Ah, 0Dh, ‘$’
Is equivalent to
MSG DB 48h, 45h, 4Ch, 4Ch, 4Fh, 0Ah, 0Dh, 24h
26
Example 3
27
● Show how character string “RG 2z” is stored
in memory starting at address 0.
● Solution:
Address Character ASCII Code (HEX) ASCII Code (Binary)
[Memory Contents]
0 R 52 0101 0010
1 G 47 0100 0111
2 Space 20 0010 0000
3 2 32 0011 0010
4 z 7A 0111 1010
27
Named Constants
28
● Use symbolic name for a constant quantity
● Syntax:
name EQU constant
● Example:
LF EQU 0Ah
● No memory allocated
28
29
A FEW BASIC INSTRUCTIONS
MOV
30
● Transfer data
■ Between registers (mov ax, bx)
■ Between register and a memory location (mov ax, var1)
■ Move a no. directly to a register or a memory location (mov ax,
1234h)
● Syntax
Before After
MOV destination, source
● Example AX 0006 0008
MOV AX, WORD1 WORD1 0008 0008
● Difference?
■ MOV AH, ‘A’
30
■ MOV AX, ‘A’
Legal Combinations of Operands for MOV
31
Destination Operand Source Operand Legal
General Register General Register YES
General Register Memory Location YES
General Register Segment Register YES
General Register Constant YES
Memory Location General Register YES
Memory Location Memory Location NO
Memory Location Segment Register YES
Memory Location Constant YES
31
XCHG
32
● Exchange the contents of
■ Two registers (xchg ax, bx)
■ Register and a memory location (xchg ax, var1)
● Syntax
XCHG destination, source
● Example
XCHG AH, BL
Before After
1A 00 05 00
AH AL AH AL
00 05 00 1A
BH BL BH BL
32
Legal Combinations of Operands for XCHG
33
Destination Operand Source Operand Legal
General Register General Register YES
General Register Memory Location YES
Memory Location General Register YES
Memory Location Memory Location NO
ADD Instruction
34
● To add contents of:
■ Two registers (Add ax, bx)
■ A register and a memory location (Add ax, var1)
■ A number to a register (Add ax, 1234h)
■ A number to a memory location (Add var1, 1234h)
● Syntax: ADD destination, source
● Example
ADD WORD1, AX
Before After
AX 01BC 01BC
WORD1 0523 06DF
34
SUB Instruction
35
● To subtract the contents of:
■ Two registers (Sub ax, bx)
■ A register and a memory location (sub ax, var1)
■ A number from a register (sub ax, 1234h)
■ A number from a memory location (sub var1, 1234h)
● Syntax: SUB destination, source
● Example
SUB AX, DX
Before After
AX 0000 FFFF
DX 0001 0001
35
Legal Combinations of Operands for
ADD & SUB instructions
36
Destination Operand Source Operand Legal
General Register General Register YES
General Register Memory Location YES
General Register Constant YES
Memory Location General Register YES
Memory Location Memory Location NO
Memory Location Constant YES
36
Contd..
37
ADD BYTE1, BYTE2 ILLEGAL instruction
● Solution?
MOV AL, BYTE2
ADD BYTE1, AL
● How can you add two word variables?
37
INC & DEC
38
● INC (increment) instruction is used to add 1 to the contents of
a register or memory location.
■ Syntax: INC destination
■ Example: INC WORD1
● DEC (decrement) instruction is used to subtract 1 from the
contents of a register or memory location.
■ Syntax: DEC destination
■ Example: DEC BYTE1
● Destination can be 8-bit or 16-bits wide.
● Destination can be a register or a memory location.
38
Contd..
39
INC WORD1
Before After
WORD1 0002 0003
DEC BYTE1
Before After
BYTE1 FFFE FFFD
39
NEG
40
● Used to negate the contents of destination.
● Replace the contents by its 2’s complement.
● Syntax
NEG destination
● Example
NEG BX
Before After
BX 0002 FFFE
How?
40
41
TRANSLATION
Examples
42
● Consider instructions: MOV, ADD, SUB, INC, DEC, NEG
● A and B are two-word variables
● Translate statements into assembly language:
Statement Translation
B =A MOV AX, A
MOV B, AX
A=5-A MOV AX, 5
SUB AX, A
MOV AX, A
OR
NEG A
ADD A, 5
42
Contd..
43
Statement Translation
A=B– 2xA MOV AX, B
SUB AX, A
SUB AX, A
MOV A, AX
Remember: Solution not unique!
Be careful! Word variable or byte variable?
43
44
PROGRAM STRUCTURE
Program Segments
45
● Machine Programs consists of
■ Code
■ Data
■ Stack
● Each part occupies a memory segment.
● Same organization is reflected in an assembly language
program as Program Segments.
45
Memory Models
46
● Determines the size of data and code a program can have.
● Syntax:
.MODEL memory_model
Model Description
SMALL code in one segment, data in one segment
MEDIUM code in more than one segment, data in one segment
COMPACT code in one segment, data in more than one segment
LARGE Both code and data in more than one segments
No array larger than 64KB
HUGE Both code and data in more than one segments
46 array may be larger than 64KB
Data Segment
47
● All variable definitions
● Use .DATA directive
● For Example:
.DATA
WORD1 DW 2
BYTE1 DB 10h
47
Stack Segment
48
● A block of memory to store stack
● Syntax
.STACK size
■ Where size is optional and specifies the stack area size in bytes
■ If size is omitted, 1 KB set aside for stack area
● For example:
.STACK 100h
48
Code Segment
49
● Contains a program’s instructions
● Syntax
.CODE name
■ Where name is optional
■ Do not write name when using SMALL as a memory model
49
Putting it Together!
50
ORG 0100h
.MODEL SMALL
.STACK 100h
.DATA
;data definition go here
.CODE
;instructions go here
50
