68000 Addressing Modes

Addressing modes are concerned with the way data is accessed

Addressing can be by actual address or based on a offset from
a known position.
Theoretically, only absolute addressing is required; however, other
addressing modes are introduced in order to improve efficiency.

1 Absolute Addressing:
Absolute Addressing uses the actual address of an operand;
either a memory location (e.g., CLR.B $1234) or,
If a register is involved, this type is also called data register
direct, e.g., MOVE.B D2,$2000

2 Immediate Addressing:
With Immediate Addressing, the actual operand is part of the
instruction; e.g., MOVE.B #25,D2

EECC250 - Shaaban
#1 Lec # 2 Winter99 12-1-99

68000 Addressing Modes

3 Address Register Indirect Addressing:
This addressing mode uses the 8 address registers.
These registers are assumed to contain the address of the data
rather than the data itself. e.g. CLR.B (A0)

4 Address Register Indirect with Post-incrementing:

A variation of address register indirect in which the operand
address is incremented after the operation is performed. The
syntax is (Ai)+

5 Address Register Indirect with Pre-decrementing:

a variation of address register indirect in which the operand is
decremented before the operation is performed.
The
syntax is -(Ai)

EECC250 - Shaaban
#2 Lec # 2 Winter99 12-1-99

Address Register Indirect with

Post-incrementing / Pre-decrementing

Examples

MOVE.B (A0)+,D3

Byte data addressed by A0 are copied to D3. Then

the contents of A0 are incremented by 1.

MOVE.W (A0)+,D3

The word data addressed by A0 are copied to D3.

Then the contents of A0 are incremented by 2.

MOVE.L (A0)+,D3

The long word data addressed by A0 are copied to

D3. Then the contents of A0 are incremented by 4.

MOVE.B -(A0),D3

The address stored in A0 is first decremented by 1.

Then the data addressed are copied to D3.

MOVE.W -(A0),D3

The address stored in A0 is first decremented by 2.

Then the data addressed are copied to D3.

MOVE.L -(A0),D3

The address stored in A0 is first decremented by 4.

Then the data addressed are copied to D3.

EECC250 - Shaaban
#3 Lec # 2 Winter99 12-1-99

68000 Instructions Summary

Instr
ABCD
ADD
AND
ASL
ASR
Bcc
BCHG
BCLR
BRA
BSET
BSR
BTST
CHK
CLR
CMP
DBcc
DIVS
DIVU
EOR
EXG
EXT
JMP
JSR
LEA
LINK
LSL
LSR

Description
Add decimal with extend
Add
Logical AND
Arithmetic shift left
Arithmetic shift right
Branch conditionally
Bit test and change
Bit test and clear
Branch always
Bit test and set
Branch to subroutine
Bit test
Check register against bounds
Clear operand
Compare
Decrement and branch
conditionally
Signed divide
Unsigned divide
Exclusive OR
Exchange registers
Sign extend
Jump
Jump to subroutine
Load Effective Address
Link stack
Logical shift left
Logical shift right

Instr
MOVE
MULS
MULU
NBCD
NEG
NOP
NOT
OR
PEA
RESET
ROL
ROR
ROXL
ROXR
RTD
RTE

Description
Move source to destination
Signed multiply
Unsigned multiply
Negate Decimal with Extend
Negate
No operation
Ones complement
Logical OR
Push effective address on stack
Reset External devices
Rotate left without extend
Rotate right without extend
Rotate left with extend
Rotate right with extend
Return and deallocate
Return from exception

RTR
RTS
SBCD
Scc
STOP
SUB
SWAP
TAS
TRAP
TRAPV
TST

Return and restore

Return from subroutine
Subtract decimal with extend
Set conditional
Stop
Subtract
Swap data register halves
Test and set operand
Trap
Trap on overflow
Test

EECC250 - Shaaban
#4 Lec # 2 Winter99 12-1-99

Classification of 68000 Instructions

Data Movement Instructions

Compare Instructions
Branch Instructions:
Conditional
Unconditional
Special Instructions for Address Registers
Arithmetic Instructions
Logic Instructions
Bit Manipulation Instructions
Stack and Subroutine Related Instructions
EECC250 - Shaaban
#5 Lec # 2 Winter99 12-1-99

Data Movement Instructions

A total of 13 instructions in all:

MOVE, MOVEA, MOVE to CCR, MOVE to SR, MOVE from SR,
MOVE
USP, MOVEM, MOVEQ, MOVEP, LEA, PEA, EXG, SWAP
MOVE copies data from one location to another and may be qualified by ".B" to move
8 bits; ".W" to move 16 bits; and ".L" to move 32 bits.
MOVE does not change the source location only the destination location.
MOVE updates the CCR as follows:

N
Z
V
C
X

Set (=1) if the result (destination) is negative, cleared (=0) otherwise.

Set if the result is zero, cleared otherwise.
Always cleared.
Always cleared.
Not affected.

Examples:
MOVE.B D1,D2
MOVE.B D1,1234
MOVE.B 1234,D1
MOVE.B 1234,2000
MOVE.B #4,D0
MOVE.B #4,1234

Register to register
Register to memory
Memory to register
Memory to memory
Literal to register
Literal to memory

EECC250 - Shaaban
#6 Lec # 2 Winter99 12-1-99

EECC250 - Shaaban
#7 Lec # 2 Winter99 12-1-99

Data Movement Instructions

MOVEA
Copies a source operand to an address register. May use only ".W and ".L".
In the case of ".W", the source operand is sign extended. No effect on CCR
Source Operand: All addressing modes.
Destination Operand: Address register direct.

Move to CCR
Copies the lower order byte of the operand to the CCR register.
Source Operand: All except address register direct.
Destination Operand: CCR register.

EXG
Exchanges the entire 32-bit contents of two registers. Frequently used to copy
an address register to a data register for processing. No effect on CCR.
Source Operand: Address or data register.
Destination Operand: Address or data register.

EECC250 - Shaaban
#8 Lec # 2 Winter99 12-1-99

EECC250 - Shaaban
#9 Lec # 2 Winter99 12-1-99

Data Movement Instructions

SWAP
Exchanges the upper and lower order words of a data register.
Source Operand: Data register
Destination Operand: N/A
CCR set according to the resulting register value.

LEA
Copies an effective address into an address register.
Source Operand:
All except data register, address register direct, address register
indirect with pre-decrement or post-increment or immediate.
Destination Operand: Address register
No effect on CCR.

EECC250 - Shaaban
#10 Lec # 2 Winter99 12-1-99

EECC250 - Shaaban
#11 Lec # 2 Winter99 12-1-99

Load Effective Address, LEA Examples

Instruction

Action

LEA $0010FFFF,A5

Loads the absolute address

LEA (A0),A5

Loads the contents of another

address register

LEA (12,A0),A5

Loads the contents of an address

register plus a displacement.

LEA (12,A0,D4.L),A5

Loads the contents of an address

register plus a data register plus
a displacement (used for index
addressing).
EECC250 - Shaaban
#12 Lec # 2 Winter99 12-1-99

Compare Instructions
All compare instructions subtract the source operand, usually the contents
of one register (or memory location) from the contents of the destination
operand, usually another register (or memory location) in order to set the
CCR (except the X-bit). The results of the subtraction are discarded.
Compare instructions include the following:
CMP

Source operand: Any of the addressing modes

Destination: Must be a data register.

CMPA

Source operand: Any of the addressing modes

Destination: Must be an address register.

CMPI

Source operand: An immediate value

Destination: Any of the addressing modes except address register
direct or immediate.

CMPM

Compares one memory location with another

Only addressing mode permitted is address register indirect with
auto- incrementing.

EECC250 - Shaaban
#13 Lec # 2 Winter99 12-1-99

Compare Instructions
CMP <source>,<destination>

The compare instruction, CMP <source>,<destination>, subtracts the

source operand from the destination operand and updates the bits of the
condition code register (CCR), according to the result. The result of the
subtraction is discarded.
CMP or another compare instruction is usually followed immediately by a
conditional branch (e.g., BEQ branch on zero, BNE branch on zero, BGT
branch if greater than, BLT branch if less than, etc). Consider the highlevel language construct:
MOVE.B
CMP.B
BGE
MOVE.B
BRA

X_Bigger MOVE.B
Exit

STOP #$2700

X,D0
Y,D0
X_Bigger
Q,P
Exit
R,P

IF X < Y THEN P = Q
ELSE P = R

Evaluate X - Y
If X is greater or equal to Y branch
IF X < Y THEN P = Q
IF X >= Y THEN P = R
Exit point for code-fragment

EECC250 - Shaaban
#14 Lec # 2 Winter99 12-1-99

EECC250 - Shaaban
#15 Lec # 2 Winter99 12-1-99

EECC250 - Shaaban
#16 Lec # 2 Winter99 12-1-99

EECC250 - Shaaban
#17 Lec # 2 Winter99 12-1-99

Conditional Branch Instructions

Identified by the mnemonic Bcc where "cc" represents the
condition to be checked.
General form:
Bcc Address_Label
If the condition is true, then control will branch to
"Address_Label".
No effect on condition codes.
These instructions can be grouped according the type of
condition being checked:
Instructions that depend on a single CCR flag:
BNE BEQ BPL BMI BCC BCS BVC

BVS

Instructions for signed comparison:

BGE BGT BLE
BLT
Instructions for unsigned comparison:
(BHS

or BCC)

BHI

BLS

(BLO or BCS)

EECC250 - Shaaban
#18 Lec # 2 Winter99 12-1-99

Conditional Branch Instructions

Depending on A Single CCR Flag
Mnemonic
BNE
BEQ
BPL
BMI
BCC
BCS
BVC
BVS

Instruction
Branch on not equal
Branch on equal
Branch on not negative
Branch on negative
Branch on carry clear
Branch on carry set
Branch on overflow clear
Branch on overflow set

Branch Taken If
Z=0
Z=1
N=0
N=1
C=0
C=1
V=0
V=1
EECC250 - Shaaban
#19 Lec # 2 Winter99 12-1-99

Conditional Branch Instructions

For
Signed
Comparison
Mnemonic
Instruction
Branch Taken If
BGE

Branch on greater than or equal

OR

BGT

Branch on greater than

BLE

Branch on less than or equal

BLT

Branch on less than

( N=1 AND V=1)

(N = 0 AND V=0)

(N=1 AND V=1 AND Z=0)

OR (N=0 AND V=0 AND Z=0)
Z=1 OR ( N=1 AND V=0)
OR (N=0 AND V =1)

OR

(N=1 AND V=0)

(N=0 AND V=1)

EECC250 - Shaaban
#20 Lec # 2 Winter99 12-1-99

Conditional Branch Instructions

For Unsigned Comparison

Mnemonic

Instruction

Branch Taken If

BHS, BCC

Branch on higher than or equal

C=0

BHI

Branch on higher than

C=0 AND Z =0

BLS

Branch on less than or equal

C=1 AND

BLO, BCS

Branch on less than

C=1

Z=1

EECC250 - Shaaban
#21 Lec # 2 Winter99 12-1-99

Unconditional Branch Instructions

Two types of unconditional branch instructions:
BRA Address_Label
Branches to a statically determined address indicated by
Address_Label
Examples:

BRA START
BRA EXIT

JMP
Jump to an address that can be changed during execution
Examples:

JMP (A0)
JMP D0
EECC250 - Shaaban
#22 Lec # 2 Winter99 12-1-99

EECC250 - Shaaban
#23 Lec # 2 Winter99 12-1-99

Special Instructions for Address Registers

If an address register is specified as the destination operand, then
the following address register instructions:

MOVEA,

ADDA,

SUBA,

CMPA

must be used instead of MOVE, ADD, SUB and CMP,

respectively.
Address instructions only apply to words and long words.
In the case of a word operation, the source operand is sign
extended to a long word,
e.g, $0004 becomes $00000004 and $FFF4 becomes
$FFFFFFF4.

Address instructions do not change any of condition codes (bits

of the CCR).

EECC250 - Shaaban
#24 Lec # 2 Winter99 12-1-99

Example: Min(X,Y) Using Comparison

* This program demonstrates how to find the smaller of

* two numbers X and Y using the comparison operator.

* if (X <= Y) then
*
D0 := X
* else
*
D0 := Y
* X and Y are stored in memory and the result of the comparison is stored in
* register D0
ORG $400
Program origin
MOVE.B
X,D0
CMP.B
Y,D0
BLE
Exit
MOVE.B
Y,D0
Exit
STOP
#$2700
ORG
$1000
X
DC.B
4
Y DC.B
5
END
$400

Store X in D0
Compare Y and D0
Branch if X <= Y
Otherwise, Y is smaller
Halt processor at end of program

EECC250 - Shaaban
#25 Lec # 2 Winter99 12-1-99

Example: Comparing Two Memory Blocks

This program compares two blocks of memory. If the memory is equal,

then FF is stored in address register D0, otherwise, 00 is stored.

ORG $400
Program origin
LEA Block1,A0
Point to the beginning of memory block 1
LEA Block2,A1
Point to the beginning of memory block 2
MOVE.W
#Size,D0 Store the long word count in size
LOOP
CMPM.L (A0)+,(A1)+
Compare the long words
BNE NotEq
Branch if not equal
SUBQ.W
#1,D0
Otherwise, decrement the count
BNE
LOOP
Go back for another comparison
CLR.L
D0
Two strings are equal so set
MOVE.B #$FF,D0
D0 to FF
BRA
Exit
NotEq
CLR.L
D0
Otherwise, set D0 to 00
ExitSTOP
#$2700
SizeEQU
2
Compare 2 words
ORG
$600
Block1
DC.L
'Bloc',1234'
Block 1
ORG
$700
Block2
DC.L
'Bloc',1234 '
Block 2
END
$400

EECC250 - Shaaban
#26 Lec # 2 Winter99 12-1-99

Example: Reversing a String

This program reverses the contents of a string.
Address register A0 points to the beginning of the string
Address register A1 points to the end of the string.
These pointers move towards each other and swap bytes until the
A0 pointer meets or passes A1.
Register D0 is used for temporary storage.
ORG
$400
Program origin
* This section moves the A1 pointer to the end (0 character) of the string
LEAString,A1
Point to the beginning of the string
Loop1 TST.B (A1)+
Move to the end of the string
BNELoop1
Until the EOS is encountered
SUBA
#1,A1 Back up to the EOS

EECC250 - Shaaban
#27 Lec # 2 Winter99 12-1-99

Example: Reversing a String (Continued)

* This section swaps the bytes at the opposite ends and moves the

* pointers towards the middle of the string until they meet.

LEA
String,A0 Make A0 point to the beginning
Loop2 MOVE.B -(A1),D0
Save the bottom byte
CMPA.L A1,A0
If A0 has reached or passed A1
BHS
Exit
Then the string is reversed
MOVE.B (A0),(A1) Move the top to the bottom byte
MOVE.B D0,(A0)+ Move the previously saved bottom byte
*
to the top byte
BRA
Loop2 Loop back for another byte
Exit
STOP
#$2700
ORG
$1000
String DS.B
128 Reserve up to 128 bytes for the string
END
$400

EECC250 - Shaaban
#28 Lec # 2 Winter99 12-1-99