You are on page 1of 108

CHAPTER 3

INSTRUCTION SET AND ASSEMBLY
LANGUAGE PROGRAMMING
COURSE LEARNING OUTCOME –
WRITE A SIMPLE PROGRAM IN ASSEMBLY LANGUAGE TO
PERFORM GIVEN TASK. (C3, P3, A2, PLO1, PLO2, PLO4)
3.1 UNDERSTAND INSTRUCTION SET AND ASSEMBLY LANGUAGE.
3.1.1 Define Instruction set, machine and assembly language.
3.1.2 Describe the addressing modes using proper instruction format
3.1.3 Describe various types of addressing modes with example.

3.2 APPLY ASSEMBLY LANGUAGE.
3.2.1 Write a simple program in assembly language for:
a. arithmetic operation
b. logic operation
3.2.2 Use tools in analyzing and debugging assembly language programs



Capability of processor determine the capability of the computer system.
Therefore, processor is the key element or heart of a computer system.
Other than PC, microprocessors are used in various computerized system
such as industrial automation.

Message sent by programmers (program instructions)
understood by the computer and vice versa.
Language that friendly to human also understandable to
computer systems.
Three level of language:
• Low level – machine language
• Middle level – assembly language
• High level – high-level language
3.1. UNDERSTAND THE INSTRUCTION
SET AND ASSEMBLY LANGUAGE.

Instruction Set :

The complete collection of instructions that are
understood by a CPU
• Known also as Machine Code/Machine
Instruction
• Binary representation
• Usually represented by assembly codes
Machine language:
• Machine language is a binary program (or binary code). Binary
code is a sequence of instruction and operand in binary that list the
exact representation instruction as they appear in computer
memory.
• Natural language of a particular computer system.
• Strings of numbers or binary codes (0 or 1).
• Machine-dependant (differ from one µP to other µP.
• Program written in any other language must be translated to binary
representation of instruction before they can be executed by
computer.
• Programmers need to know specifically the architecture of CPU.



The program is
difficult to
understand
The program is slow
to key-in to the
computer due to the
input one bit by one
bit at a time
The program did not
specify the tasks we
perform require a
computer.
The program
is long and
arduous
Limitations in
programming
using machine
language
To overcome these problems, the use of
easily remembered code (mnemonic)
was introduced. It is apply with the use
of Assembly Language
6
Assembly language:
• Assembly language is a symbolic representation of a machine
language of specific processor. Assembly language is a form that is
very dependent on the underlying architecture.
• Using english-like abbreviations (MUL).
• Assembler as translator.
• Assembler - Translate ordinary mnemonics such as MOVE Data,
Acc, into their corresponding machine language (the only form of
instruction that computer can executed)
• Assembly Process - Process of translating an assembly language
programs into a machine language programs. The assembly process
is straightforward (one-to-one mapping of assembly languages
statements to their machine language counterpart) and rather simple
• Programmer need to know the basic architecture.

Why assembly language study is important?
• It clarifies the execution of instruction.
• It shows how the data represent in memory.
• It show how a program interacts with the operating system (OS),
processor and, input and output (I/O) system.
• It clarify how a program access external devices
• Sometimes difficult to access hardware drive and system tool if using
(register transfer languages) RTL

Advantages using assembly languages
• Easy to make compilers, debuggers and other device tools.
• Allow accessing information that is not accessible (restricted) from high
level languages.
• More function library that can be used in programming development.
• Possibility to make library function that compatible with different compiler
and operating system

Disadvantages using assembly languages
• (Development) Requires longer development time
• (Reliability & Security) Easy to makes error
• (Debug) More possibility for errors
• (Maintain) Difficult to modify because it allows unstructured
code.
• (Portability) Difficult to porting to different platforms.

High-level language:
• Using everyday English and common mathematical notation. (x = I + j)
• Overcome problems : assembly language require many instruction to
accomplish a simple task.
• Single instruction in HLL = several AL instructions.
• Compiler as translator.
• Programmers do not need to know the architecture of CPU.
MICROPROCESSOR OVERVIEW
The term microprocessor typically refers to the central processing
unit (CPU) of a microcomputer, containing the arithmetic logic unit
(ALU) and the control units (CU).
Performs the main tasks for the computer system
• data transfer between (registers) and memory or I/O
• arithmetic and logic operations. Example: ADD, SUB, AND, OR, etc
• program flow via simple decisions. Example: Zero, Sign, Carry, etc
8
There are many MC68000 instructions. However, theses
instructions comply to a standard instruction format:






LABEL – A user-defined symbol representing the address associated with the
instruction. Up to 8 alphanumeric, begin with letter, terminated by a space.
OPERATOR - A mnemonic code for MC68000 instructions. An assembler
directive / pseudo-instruction / pseudo-operation. Macro call (repetitive
instructions in a program which are
codified only once and can be used as many times as necessary)
OPERAND – Depends on the operator, may has more than one operand.
COMMENT – Explanation about the execution of instruction.
Data format - Byte | Word | Longword | Sign-extended







The physical operation of an instruction is manipulating data contained in the
internal register and memory locations. Thus it is essential to familiarize the
data format. In the operator field (column-2), we may see the mnemonics are
postfixed with symbol “.B”, “.W”, “.L”. This is actually specifying the data size of
operand (column-3) which is to be working on. In other words, how many bits
of the data cells are to be involved.
One digit of hexadecimal is represented by 4 bits, 2
n
= 2
4
= 16. If 1 digit of
hexadecimal is labelled “H”, thus:



p/s: We know that MC68000 has :
- 32 bits of data registers
- 32 bits of address registers, but only 24 least significant bits are
accountable.


In other words, the prosffixer allow only a portion (at LSD side) of the whole
register bits is put on operation, whereas the remaining bit are either
unchanged or sign-extended. The minimum data size allowed is byte, thus we
may ignore the nibble: the postfixer provided are byte (.B), Word (.W) and
Lognword (.L), i.e. all bits in the registers.








We may see the word “sign-extended” is frequently stated within this
module. We know that a data register can store up to maximum of 32
bits but it also allows data operations to be working on with fewer bits
(effective data) at the LSB side; thus, the remaining bits have to be
either unchanged or sign-extended, i.e. filled with bits 1 or 0, depends
on the sign bit (MSB) of the effective data.




















The microprocessor is only accessible by the users via the instructions specifically
developed to accompany that particular hardware as a package. The instructions
are just like tools, a program may consists several of the instructions and some of
them may be used repeatedly. However, we still needs to know all the tools i.e. all
the instructions provided by the microprocessor manufacture, even thought we may
not be using all of them. Table below shows a list of MC68000 instructions in the
alphabetic order. These instructions are actually listed as reference instructions
groups, where by each group in the list may have several instructions with related
function. For instance: ADD: ADD, ADDA, ADDQ, ADDI, ADDX. MOVE: MOVE,
MOVEA, MOVEQ
• Data Movement
• Arithmetic operation
• Logical operation
• Rotate and shift
• Control transfer group. (Jump and branch)
• Stack, stack pointer
• Block transfer.
• Other microprocessor instruction












Example 1:
• MOVE.W #$72,D1
• Before : D1 = $00200500
• After : D1 = $00200072
Example 2:
• MOVE.B D0,D1
• Before : D1 = $00200500 , D0 = $00002222
• After : D1 = $00200522 , D0 = $00002222
Example 3:
• MOVE.B $3000,D1
• Before : D1 = $00200500
• After : D1 = $00200532

Example 4:
• MOVE.W D6,$4000
• Before: D6 = $AB206541
• After : D6 = $AB206541

$3000 32
$3001 43
$3002 98
Example 5:
• MOVEA.W D6,A2
• Before : D6 = $AB206541 , A2 = $ABCD1234
• After : D6 = $AB206541 , A2 = $00006541
Example 6:
• MOVEA.W D6,A2
• Before : D6 = $AB20A541 , A2 = $ABCD1234
• After : D6 = $AB20A541 , A2 = $FFFFA541
Example 7:
• MOVEA.L D6,A2
• Before : D6 = $AB206541 , A2 = $ABCD1234
• After : D6 = $AB206541 , A2 = $AB206541

Example 8:
• MOVEA.L A0,A1
• Before : A0 = $12345678 , A1 = $00000000
• After : A0 = $12345678, A1 = $12345678
Example 9:
• MOVEA.W D1,A1
• Before : D1 = $12345678, A1 = $11111111
• After : D1 = $12345678, A1 = $00005678


Example 10:
• MOVEA.L #$7000,A1
• Before : A1 = $12122030 , A1 = $00007000

Example 11:
• MOVEA.L #$8000,A4
• Before : A4 = $12122030 , A1 = $FFFF8000

Example 12:
• MOVEQ #$04,D3 (MOVEQ #XXX,Dn)
• Before : D3 = $AB206541
• After : D3 = $00000004
Example 13:
• MOVEQ #$80,D3
• Before : D3 = $AB206541
• After : D3 = $FFFFFF80

-128 (80) hingga 127 (7F)
Example 14:
• MOVEQ #$F1,D1
• Before : D1 = $12345678
• After : D3 = $FFFFFFF1
Example 15:
• MOVEQ #$71,D1
• Before : D1 = $12345678
• After : D3 = $00000071

Example 16:
EXG D1,D5
Before : D1 = $11223344 , D5 = $66778899
After : D1 = $66778899 , D5 = $11223344

Example 17:
SWAP D1
Before : D1 = $11223344
After : D1 = $33441122

Example 18:
CLR.B D1
Before : D1 = $11223344
After : D1 = $ 11223300





Example 19:
• ADD.B D0, D1
• Before : D0 = $00002222 , D1 = $00004444
• After : D0 = $00002222 , D1 = $00204466



Example 20:
• ADDI.W #$72,D1
• Before : D1 = $00200500
• After : D1 = $00200572

Example 21:
• ADD.L D0,D1
• Before : D1 = $00200500 , D0 = $00002222
• After : D1 = $00202722 , D0 = $00002222

Example 22:
• ADD.W $3000,D1
• Before : D1 = $00200500
• After : D1 = $00203743


$3000 32
$3001 43
$3002 98

Example 23:
• ADDA.W D6,A2
• Before : D6 = $AB206541 , A2 = $ABCD1234
• After : D6 = $AB206541 , A2 = $ABCD7775
Example 24:
• ADDA.L D6,A2
• Before : D6 = $AB20A541 , A2 = $ABCD1234
• After : D6 = $AB206541 , A2 = $56EDB775 , C = 1


Example 25:
ADDX.B D2,D3
Before : D2 = $AB206541 , D3 = $ABCD1234 , X = 1
After : D2 = $AB206541 , D3 = $AB206576 , X = 1

Example 26:
• ADDQ.B #$04,D3 (ADDQ #XXX,Dn)
• Before : D3 = $AB206541
• After : D3 = $AB206545
-128 (80) hingga 127 (7F)
Example 27:
SUB.W #$80,D3
Before : D3 = $AB206541
After : D3 = $AB2064C1
Example 28:
SUB.W #$02,D1
Before : D1 = $12345678
After : D1 = $12345676

@ menunjukkan
nombor octal
% menunjukkan
nombor binari

Example 29:
SUB.W D0,D1
Before : D0 = $12345678 , D1 = $98745432
After : D0 = $12345676 , D1 = $98760246
Example 30:
• MULU #2,D2 ;16 bit x 16 bit = 32 bit
• Before : D2 = $AB206541
• After : D2 = $0000CA82
Example 31:
• MULU #2,D2
• Before : D2 = $AB20FFFF
• After : D2 = $0001FFFE
Example 32:
• DIVU #2,D3 ;32 bit / 16 bit = 16 bit lower (result)
16 bit upper ( remainder)
• Before : D3 = $00006541
• After : D3 = $000132A0


@ menunjukkan nombor
octal
% menunjukkan nombor
binari


6541F
=
25921

32A0
16
=
12960
10

Example 33:
• AND.B #$3E,D1
• Before : D1 = $12345674
• After : D1 = $12345634


Example 34:
• OR.B D0,D1
• Before : D1 = $1234563E , D0 = $98765474
• After : D1 = $1234567E , D0 = $98765474


Example 35:
• NOT.B D1
• Before : D1 = $12345655
• After : D1 = $123456AA


Example 36:
• EOR.B D0,D1
• Before : D0 = $ 98765474 , D1 = $1234563E
• After : D0 = $98765474 , D1 = $1234364A




















Microprocessor Programming Environment









Internal registers of MC68000
This whole or portion of this structure will be used to show the
data changes and movement throughout the rest of this unit.









MC68000 : 14
different
addressing
modes divided
into 6 groups.
By understanding
the addressing
modes, we have
EA (effective
address).
EA will help us
identifies the
location of an
operand.









C.1REGISTER DIRECT ADDRESSING
Dn – Data register direct addressing. (D1,D2,D3,D4,D5,D6,D7)
An – Address register direct addressing. (A1,A2,A3,A4,A5,A6,A7)
Fastest and most compact because no reference to memory.
C.2 REGISTER INDIRECT ADDRESSING
p/s: Using () for those address register which represented the register indirect addressing
C.2 REGISTER INDIRECT ADDRESSING
C.2 REGISTER INDIRECT ADDRESSING

+1 = byte
+2 = word
+3 = longword

C.2 REGISTER INDIRECT ADDRESSING

+1 = byte
+2 = word
+3 = longword

C.2 REGISTER INDIRECT ADDRESSING
C.2 REGISTER INDIRECT ADDRESSING
C.3 ABSOLUTE DATA ADDRESING
C.3 ABSOLUTE DATA ADDRESING
C.3 ABSOLUTE DATA ADDRESING
C.4 IMMEDIATE DATA ADDRESSING
C.4 IMMEDIATE DATA ADDRESSING
C.4 IMMEDIATE DATA ADDRESSING
C.4 IMPLIED ADDRESSING
INCORRECT INSTRUCTIONS
EASY68K