Академический Документы
Профессиональный Документы
Культура Документы
Microprocessor
Registers (Dn).
Address Registers (An)
Arithmetic-Logic Unit (ALU).
movement (MOVE).
Arithmetic (ADD, SUB, MUL, DIV).
Logic (AND, OR, NOT, EOR)
Microprocessor
The microprocessor can be used to
perform complex operations by giving it
instructions.
These instructions are called programs.
Programs are loaded into memory, and
are executed line-by line by the
microprocessor.
Example Program
Microprocessor
Systems
Memory Address
Each memory location is always given a
unique address.
The address is usually represented using
a hexadecimal number.
The microprocessor refers to this address
when it wants to take data/instruction from
memory.
Memory Address
Address
Data
$000000
$03
$000001
$AB
$000002
$11
$000003
$000004
$FFFFFE
$FFFFFF
Serial I/O
Interrupt
Circuit
System Bus
Timing
CPU
Memory
Serial I/O
Interrupt
Circuit
System Bus
Timing
CPU
Memory
Serial I/O
Interrupt
Circuit
System Bus
Timing
CPU
Execute Instruction
Memory
Serial I/O
Interrupt
Circuit
System Bus
Timing
CPU
Memory
The M68000
We will be using a specific microprocessor
called the M68k.
It is a 16-bit microprocessor manufactured
by Motorola in 1979.
Its speed is around 8-12 MHz.
Still being used today.
16,15
8,7
MSB
31
LSB
0
D0
D1
D2
D3
DATA
REGISTERS
MSB
ADDRESS
REGISTERS
16,15
A7 (USP)
USER STACK POINTER
31
0
PC
D4
D5
D6
D7
31
LSB
0
PROGRAM COUNTER
0
CCR
16,15
LSB
A0
A1
A2
A3
A4
A5
A6
16,15
0
A7 (SSP)
8,7
CCR
STATUS REGISTER
SR
Add.
Contents
D0
$12340000
D1
$00005678
Contents
D2
D3
D4
D5
D6
D7
MEMORY
Contents
Add.
Contents
D0
$12340000
$12340000
D1
$00005678
D2
$00005678
D3
D4
D5
D6
D7
G
H
MEMORY
Add.
Contents
$12340000
D2
$00005678
D3
D4
Contents
D0
$12345678
D1
$00005678
D5
D6
D7
F
G
H
Addressing Modes
Introduction
Addressing Modes
registers.
Memory.
reference.
Indirect reference.
ARI + Predecrement
ARI + Displacement
ARI + Index
Absolute Short Address
Absolute Long Address
AM
PC with Displacement
PC with Index
Mem. Addressing Mode
Immediate Data
Quick Immediate Data
Implied Addressing
Register Addressing
Modes
Register.
Address Register.
Consists of 2 methods:
Data
DRD Example
MOVE.B
ADD.W
MULU
D0,D1
D4,(A0)
D5,D7
A represents
address register.
n is register number.
From A0 to A7.
A7 = stack pointer.
ARD Example
MOVEA.L
ADDA.W
MOVEA.W
A0,A4
A3,A6
#$1234,A2
Memory Addressing
Modes
Memory
Example: ARI
D0 = $12345678
A1 = $007A92
MOVE.B
D0,(A1)
(This command does not move the data
inside D0 into A1, but moves the data
inside D0 into the memory location pointed
by A1).
Example: ARI
D0 = $12345678
A1 = $00007A92
MOVE.L
D0,(A1)
D0.L = $12345678
A1 = $007A92 (A1 is still unchanged).
Memory Contents
$7A90
$7A91
$7A92
$12
$7A93
$34
$7A94
$56
$7A95
$78
Example: ARI
MOVE.B
D1,(A4)
Moves
ADD.W
Adds
(A3),D3
.B is used, An is incremented by 1.
If
.W is used, An is incremented by 2.
If
.L is used, An is incremented by 4.
Example 1: ARI + PI
D0 = $12345678
A1 = $001002
MOVE.W
D0,(A1)+
D0.W = $5678
Memory Content
$1001
A1 (new)
$1002
$56
$1003
$78
$1004
$1005
$1006
.B is used, An is decremented by 1.
If
.W is used, An is decremented by 2.
If
.L is used, An is decremented by 4.
Memory Contents
A7 (new)
$1001
A7 (old)
$1002
$1003
$1004
D0.B = $78
$1005
$1006
$78
An
d
is address register.
Example: ARI + D
D3 = $12345678
A4 = $004500
MOVE.B
Memory Contents
A4
D3, $750(A4)
A4=$004500, Disp.=$750
***$750 = %0111 0101 0000
Effective Address (EA):
A4:
$004500
D:
$000750 +
EA: $004C50
$4500
$4501
+$750
$4C50
$4C51
$78
Example: ARI + D
D3 = $00000000
A4 = $004500
MOVE.B
Memory Contents
$FFF3(A4),D3
-$000D
A4
$44F1
$11
$44F2
$22
$44F3
$33
..
..
$44FF
$55
$4500
$66
ARI + D Example
MOVE.B
ADD.B
D1,34(A0)
$1254(A2),D4
Example: ARI + D
D3 = $00000000
A4 = $004500
MOVE.B
-5(A4),D3
Memory Contents
$44F9
$44FA
$44FB
$14
$44FC
$44FD
Effective Address:
A4
$004500
Disp. $000005
$0044FB
$44FE
D3 = $00000014
Dn.W)
D(An, An.W)
ARI + I Example
MOVE.B
ADD.B
D1,34(A0,D3.W)
$54(A2,A4.W),D4
ARI + I Example
D1 = $00000012
A4 = $00001000
MOVE.B
#$FF,$78(A4,D1.W)
Effective Address (ARI + D + I):
A4
+
+
ARI $00001000
D1.W $
0012
D
$
78
EA
$0000108A
$1000
$108A
$108B
$108C
$108D
$108E
$FF
ALA Example
MOVE.L
ADD.B
MOVE.B
D0,$100100
$001000,D3
$000100,$400400
Example: ALA
MOVE.B
Moves
$001000,D0
to D0.
ADD.W $400400,D1
Adds
MOVE.L
Moves
D4,$003000
a long-word from D4 to address $3000.
*Address length must always be 24-bits
$12
$1001
$34
$1002
$FF
$1003
$56
$1004
$AA
$1005
$AC
$1006
$12
D1 =
0 0 0 0 1 2 3 4
to $007FFF.
$FF8000 to $FFFFFF.
SUB.B $4601,D4
4
6
0
1
0100 0110 0000 0001
MSB is 0
0
0
4
6
0
0000 0000 0100 0110 0000 0001
sign-extended to 24-bits
E.A. is $004601
Will subtract the byte value in address $004601 from D4
MOVE.B
$8432,D3
8
4
3
2
1000 0100 0011 0010
MSB is 1
F
F
8
4
3
2
1111 1111 1000 0100 0011 0010
sign-extended to 24-bits
E.A. is $FF8432
Will move byte value from address $FF8432 to D3.
Can
Format: d(PC)
PC
is program counter.
d is 16-bit displacement value.
16 bit displacement:
Data #3
Instruction #1
Instruction #2
Instruction #3
Instruction #n
In PC + D, the location of data is always
stated as relative to instruction.
PC
Instruction #3
Instruction #n
When the program is run, PC is incremented
as instructions are executed.
Data #3
Instruction #1
Instruction #2
Instruction #3
Instruction #n
When program running,
data location referred to PC.
Address Space
Address Space
Data #1
Data #2
Data #3
Instruction #1
Instruction #2
Data #1
Instruction #3
Data #2
Data #3
Instruction #1
Instruction #n
Instruction #2
Data #1
Instruction #3
Data #2
Data #3
Instruction #1
Instruction #n
Instruction #2
Data #1 is located
3 memory
locations above PC
Instruction #3
Instruction #n
*Assuming PC @ Instruction #1
PC + D Example
PC = $004000
D1 = $12345678
MOVE.B
$32(PC),D1
Memory
Effective Address:
PC =
+ D =
$004000
$
32
EA =
$004032
$4031
$4032
$4033
$4034
$4035
$4036
$12
$23
34
$45
$56
$67
D1 =
1 2 3 4 5 6 2 3
d(PC,Dn)
d(PC,
An)
PC is program counter.
d is 8-bit displacement value.
8-bit displacement:
PC + I Example
D1 = $00000388
PC = $00003000
MOVE.B
#$A2,$FA(PC,D1.W)
+
-
PC
$00003000
D1.W $
0388
D
$
06
$3381
EA
$3385
$00003382
$3382
$3383
$3384
$3386
$A2
Immediate Data
Used to transfer constant values into
registers/memory locations.
Consists of 2 parts:
The
constant value.
The register/memory location to store it in.
Types of Constant
Symbol
Data Type
Example
Binary
#%01101010
Octal
#@123
<none>
Decimal
#45
Hexadecimal
#$35
Character
#B
D0 = $FFFFFFFF
MOVE.B
#12,D0
Constant value: #12 = #$0C
D0 =
Final D0 = F
$3FFF
$4000
$12
$4001
$34
$4002
A3 = $00000000
MOVEA.L#$00400400,A3
Constant variable: 00400400 (hex)
Target: A3.
A3 = $00000000
A3 = $00400400
D0 =
2
B
5
U
B
K
5
U
D0 =
Sign-extended to 32-bits
Sign-extended to 32-bits
Sign-extended to 32-bits
SR
Status Register
USP User Stack Pointer.
SSP Supervisor Stack Pointer.
CCR Condition Code Register
TRAPV Trap exception if V-bit set.
ORI.W #$8000,SR
T
I2
I1
I0
X N
V C
OLD SR= 0
OR
NEW SR= 1
ANDI.B #$00,CCR
OLD CCR =
AND
Z V C
NEW CCR = 0
Conclusion
D0 D7
A0 A7
ARI
ARI+PI
ARI+PD
ARI+D
ARI+I
PC+D
PC+I
ALA
ASA
IA
(An)
(An)+
-(An)
D(An)
D(An,Dn/An.s)
D(PC)
D(An,Dn/An.s)
$001001
$FFAA
CCR, SR
Conclusion
Addressing modes allow flexibility in
accessing registers memory locations.
Try to understand how to calculate EA:
ARI
(PI, PD, D, I)
PC (D, I)
Shifts
Example: LSL
Initial set-up:
D0 = $000000AA
D1 = $00000008
LSL.W D1, D0
Pushed out
new D0.W =
New D0 = $0000AA00
Example: LSR
D0 = $000000AA
LSR.W #4,D0
0
D0.W =
% 0000
LSR
D0.W =
A
Pushed out
D0.W =
New D0 = $0000000A
MSB
LSB
Example: ROL
1) source: D1.B = $03 = 3 digits (in binary)
2) target: D0.B = $AB = %1010 1011
D0 = $000000AB,
D1 = $00000003
ROL.B D1,D0
D0.B =
D0.B =
1
And sent to back
Pushed out
D0.B =
New D0 = $0000005D
Example: ROR
D0 = $000000AB
ROR.B #4,D0
D0.B =
D0.B =
Pushed out
D0.B =
New D0 = $000000BA