Transcript Chapter 3 Introduction to the 68000

Chapter 3
Introduction to the 68000
• Register Set: data, address, condition
code, status.
• Basic Instruction Set
• Basic addressing modes: register,
absolute, immediate, register indirect, etc.
• Assembling and debugging a program
Register Set
• 8 general-purpose data registers. Word
operation on D -D , byte operation on D -D
00
D31
D16
15
00
D08
D00
D0
D6
D7
• PC points at the next instruction to be
executed.
31
00
PC
07
Address Register: A0-A7
• 8 address registers of 32 bits.
• Information in an address register
represents a location in memory.
• Special one: A7 is used as stack pointer.
A31
A16
Memory
A00
A0
A1
A7
1004
1005
1006
1007
4A
57
0E
07
A0
1005
[M(A0)] = [M(1005)] = 57
Condition Code Register
7
N
Z
V
eXtend
Negative
Zero
oVerflow
Carry
X
0
C
• The CCR is updated to reflect the result of the
operation.
• Z=1
if the result is 0
C=1
if there is carry-out from MSB
V=1
if there is overflow
N=1
if the result is negative
Instruction Set
• The 68000 has a large instruction set.
–
–
–
–
•
e.g.
Move data
Modify or operate the data
Change execution sequence
Determine the operation mode of CPU
MOVE.B
D3,1234
MOVE.B
#25,D2
• Classification of instruction set architecture
– CISC (Complex instruction set computer):
large instruction set, powerful, but difficult to optimize
code
– RISC (Reduced instruction set computer):
smaller instruction set, easy to optimize code, but longer
program
Data Movement
• Register-to-register, register-to-memory,
memory-to-register, memory-to-memory,
constant-to-memory/register.
• 8-bit, 16-bit, 32-bit correspond to
MOVE.B, MOVE.W, MOVE.L
• Legal:
• Illegal:
Assembler Form
RTL
MOVE.B D1,D2
[D2]  [D1]
MOVE.B D3, 1234
MOVE.B 1234,2000
MOVE.B #12,1234
[M(1234)]  [D3]
[M(2000)]  [M(1234)]
[M(1234)]  12
MOVE.B D3,#12
12  [D3] ???
Unconditional Branch
• BRA: Branch
BRA address
; GOTO address
Example:
NEXT
BRA
NEXT
MOVE.B
D1,D2
MOVE.B
#1,D4
Which instruction will be executed after BRA NEXT is executed?
Conditional Branch
• BEQ, BNE, BCC, BCS, BVS
Example:
BCC
Check_5
MOVE.B
D1,D2
IF c=0 THEN branch to Check_5
…
Check_5
MOVE.B
#1,D4
BCC
C=0
Check_5
MOVE.B #1,D4
Check_5
C=1
MOVE.B D1,D2
Conditional Branches (con.)
BNE
Branch on [CCR(Z)]=0
BEQ
Branch on [CCR(Z)]=1
BCC
Branch on [CCR(C)]=0
BCS
Branch on [CCR(C)]=1
BVC
Branch on [CCR(V)]=0
BVS
Branch on [CCR(V)]=1
• The complete set of 68000 conditional
branch instructions is given in Table 5.2 on
page 208. (e.g., BLT, BLE, BGT, BGE, etc.)
CMP and TST
• Useful for changing program flow
• CMP: Compare
– Syntax: CMP src,Dn
– Operation: [Dn] - [src]
– Result of - is not saved
• TST: Test an operand
– Syntax: TST dest
– Compare [dest] to 0, no result saved
• TST D1 is the same as CMP __,D1
Change Program Flow
IF1
Set Flag
Test Opposite Condition and
BR to ENDIF if TRUE
THEN1 IF-Part
ENDIF1 ...
IF
X1 = 0
X1 := Y1
IF1
THEN1
ENDIF1
THEN
MOVE.B X1,D0
(or “TST.B X1”)
BNE
ENDIF1
MOVE.B Y2,X1
…
other code
Change Program Flow (con.)
IF
X1 = 0
Wrong
IF1
MOVE.B X1,D0
BEQ THEN1
ELSE1 MOVE.B Y2,X1
THEN1 MOVE.B Y1,X1
ENDIF1 …
THEN
ELSE
Right
IF1
X1 := Y1
X1 := Y2
MOVE.B X1,D0
BEQ THEN1
ELSE1 MOVE.B Y2,X1
BRA ENDIF1
THEN1 MOVE.B Y1,X1
ENDIF1 ...
Change Program Flow (con.)
IF
X1 = 0
THEN
ELSE
MOVE.B X1,D0
BNE ELSE1
THEN1 MOVE.B Y1,X1
BRA ENDIF1
ELSE1 MOVE.B Y2,X1
ENDIF1 ...
X1 := Y1
X1 := Y2
IF1
must have this branch
Change Program Flow (con.)
WHILE (K > 0) DO S
WHILE
ENDWH
TST.B K
BLE
ENDWH test opposite condition
S
loop body
BRA WHILE
...
Change Program Flow (con.)
FOR I = N1 TO N2 DO S
NEXT
ENDFOR ...
MOVE.B
CMP.B
BGT
S
ADD.B
BRA
N1,D0
D0: loop counter
N2,D0
ENDFOR
loop body
#1,D0
NEXT
• 1 assembly language instruction
= 1 machine language instruction
• 1 high-level language instruction
 1 machine language instructions
Subroutine
…
BSR
ADD12
BSR
ADD12
…
…
ADD12 ADD.B D1,D2
SUB.B #12,D2
RTS
Data Typing
• Most high-level language, like Pascal, Java,
Ada, are said to be strongly typed.
• Assembly language is not strongly typed.
• How about C/C++?
– Example: A character can be multiplied by an
integer.
• JAVA?
Data Typing (con.)
A
B
C
D
ORG
DC.B
DC.W
DS.B
DS.L
$1000
$12
$3456
1
1
A
B
C
D
1000
1002
1004
1006
MOVE.B
ADD.B
A,D0
B,D0
[D0]  $12 + $34
MOVE.B
ADD.W
A,D0
B,D0
[D0]  $12 + $3456
MOVE.W
ADD.W
A,D0
B,D0
[D0]  $1200 + $3456
MOVE.L
ADD.L
A,D0
B,D0
[D0]  ?
Memory
12
34
00
00
00
Map
00
56
00
00
00
Arithmetic Operation
•
•
•
•
Data
Program
ADD, SUB, CLR, NEG, ASL, ASR
ADD.B 1234,D3 ; [D3]  [M(1234)]+[D3]
The CCR is updated accordingly.
Example: V3 = V1 + V2
signed integers
unsigned integers
V1
V2
V3
ORG
DC.B
DC.B
DS.B
ORG
MOVE.B
ADD.B
MOVE.B
BVS
...
$400
12
14
1
$600
V1,D0
V2,D0
D0,V3
Error1
V1
V2
V3
ORG
DC.B
DC.B
DS.B
ORG
MOVE.B
ADD.B
MOVE.B
BCS
...
$400
12
14
1
$600
V1,D0
V2,D0
D0,V3
Error1
Are the
codes
correct?
Where is
the right
place for
BVS/BCS?
Arithmetic Operation (con.)
Subtraction: SUB src, dest ; [dest]  [dest] - [src]
• SUB.B
D2,D0 ; [D0(0:7)]  [D0(0:7)] - [D2(0:7)]
SUB.W
D2,D0 ; [D0(0:15)]  [D0(0:15)] - [D2(0:15)]
SUB.L
D2,D0 ; [D0]  [D0] - [D2]
Clear
• CLR.B
D0
; [D0(0:7)]  0
Negation: negative value, i.e,, 2’s complement
• NEG.B
D4
; 2’s complement of D4
If [D4] = 01101100, after [D4] = 10010100
ASL (Arithmetic Shift Left)
C
Operand
0
• Format:
– ASL #n,dest
or
ASL Di,dest
shifts bits in dest LEFT by n or [Di] places, respectively
• The bit shifted out is shifted in C-bit of CCR.
•
Example: ASL.B #3,D0
[D0] = 0 1 0 1 1 1 0 0
[C]=0
10111000
[C]=1
01110000
[C]=0
11100000
ASL (Arithmetic Shift Left)
• Why is ASL useful?
ASL is the fastest way to perform
“multiply by 2’s power”
• ASL dest = ASL #1,dest
• What does ASL #n, dest do?
[dest]  [dest] x 2n
How to multiply D0 by 2 ?
[D0] = 00000110
610
After ASL.B #1,D0
Can ASR cause
overflow?
[D0] = 00001100
1210
ASR (Arithmetic Shift Right)
MSB
Operand
C
• Same as ASL, but
– bits shifted to RIGHT
– MSB is duplicated back into MSB (Why?)
• ASR.B #1,D0 is equivalent to dividing D0
by 2
Example: [D0] = -22 = 11101010
After “ASR.B #1,D0”
[D0] = 11110101 = -11
[CCR(c)] = 0
How to divide
D1 by 32 ?
Can ASR cause
overflow?
Effect of Arithmetic Operations on CCR
• Addition:
 1, if carry out from MSB
C=
 0, otherwise
 1, if operands are of same sign and
V=
their sum is of the opposite sign
 0, otherwise
____
____
____
V= an-1  bn-1  sn-1 + an-1  bn-1  sn-1
where an-1, bn-1, sn-1 are the MSBs of
source destination and result, respectively
Effect of Arithmetic Operations on CCR
• Subtraction:
 1, if NO carry out from MSB
C=
 0, otherwise
 1, if operands are of opposite sign and
V =  the result is of same sign as the source
 0, otherwise
____________
V= (an-1  bn-1)  (dn-1  an-1)
where an-1, bn-1, dn-1 are the MSBs of
source destination and result, respectively
Logical Operation
• AND, OR, EOR, NOT
• If [D0] = 11110000
AND.B #%10100110,D0
OR.B #%10100110,D0
EOR.B #%10100110,D0
;[D0]=10100000
;[D0]=11110110
;[D0]=01010110
Use Registers
• Accesses to data registers are faster than
accesses to memory.
• Shorter instruction, 3 bits to indicate either one
of 8 general-purpose registers.
• Use comments to indicate how registers are used
in program.
* GetChar:
Input an ASCII-coded character into D0
* Input Parameters: None
* Output parameters: ASCII character in D0, Error code in D6
* Registers modified: D0, D1, D6
GetChar
MOVE.B
ACIAC,D1
BTST.B
#RDRF,D1
BEQ
GetChar
MOVE.B
ACIAC,D0
AND.B
#%01111100,D1
MOVE.B
D1,D6
RTS
Addressing Modes
• Concerned with the way in which data is
accessed (where operand can be found)
• Data register direct, absolute, immediate,
and address register indirect.
• Looking for a house in a familiar
neighborhood, “The house next to Tim’s”
(relative location) is enough.
• Looking for a house in a new environment,
“61 William Street” (actual address) is
necessary, even with a city name.
Absolute Addressing
• Use the actual or absolute address of the
operand, e.g. CLR.B $234
• MOVE.B D2, $2000
The source is data register direct, a type
of absolute addressing mode. $2000 is
memory location 2000
• Symbols can also be used
Example:
MOVE.B
Input,D0
SUB.B
Time,D0
Immediate Addressing
• MOVE.B #25,D2
; [D2]  25
• Immediate addressing is faster than the
absolute addressing.
• Data 25 is part of the instruction
 stored in IR.
Absolute Addressing:
Immediate Addressing:
Hours DC.B
25
ADD.B Hours,D2
Hours EQU
25
ADD.B #Hours,D2
What about “ADD.B #Hours,D2
What about “ADD.B Hours,D2
MOVE.B P,D0
IF 7<P<25 THEN
X := 6
if ((7<P) && (P<25))
X = 6;
OutOfRange
CMP.B
#7,D0
BLE
OutOfRange
CMP.B
#25,D0
BGE
OutOfRange
MOVE.B #6,X
…
CLR.B D1
X := 0
FOR I := 1 TO 10
X=X+I
X = 0;
for (I = 1; I <= 10; I++)
X = X + I;
D1: X
MOVE.B
#1,D0
NEXT
D0: I
ADD.B D0,D1
ADD.B #1,D0
CMP.B #10,D0
BLE
NEXT
MOVE.B D1,X
Address Register Indirect
• The address of an operand is found in an address
register, A0 to A7
• Pointer or reference
• MOVEA: copy an address to address reg
• MOVEA.L #$1000,A0
CLR.B
(A0)
same effect as
CLR.B $1000
0FFF
1000
1001
1002
1003
00
1000
A0
Indirect Addressing
• Two accesses:
1) to the address register A0 to find the
actual address of operand, 1000.
2) to the memory location 1000 to get the
operand.
• Why is address register indirect
addressing useful?
Example: Add 100 numbers together, the
data starts at memory location 200016
MOVE.B
ADD.B
ADD.B
ADD.B
:
ADD.B
$2000,D0
$2001,D0
$2002,D0
$2003,D0
$2063,D0
CLR.B
MOVEA.L
NEXT ADD.B
ADDA.L
CMPA.L
BNE
D0
#$2000,A0
(A0),D0
#1,A0
#$2064,A0
NEXT
Different Addressing
1
* Program to test the different addressing modes.
2
* [D2]  [M(0)] + 26.
By Mingrui Zhang
3
4 00001000
ORG
$1000
5 00001000 1A
ABSOL: DC.B
26
6 0000001A
IMMED: EQU
26
7
8 00002000
ORG
$2000
9 00002000 207C00001000
MOVEA.L
#$1000,A0
10 00002006 24380000
MOVE.L
$0,D2
11 0000200A D410
ADD.B
(A0),D2
12
13 0000200C 24380000
MOVE.L
$0,D2
14 00002010 D4381000
ADD.B
ABSOL,D2
15
16 00002014 24380000
MOVE.L
$0,D2
17 00002018 0602001A
ADD.B
#IMMED,D2
18
19 0000201C 4E722700
STOP
#$2700
20
00002000
END
$2000
The Teesside MC68000 Crossassembler and Simulator
TOOLS
FILES
Desing the program
Edit source file
Cross-assemble the program
Run the program
text editor Test.X68
X68K
E68K
Test.BIN (and Test.LIS)
Debugging Commands
• HELP: Provide information about commands
• MD (.): Displays the contents of memory
e.g. MD 400
MD 400 -DI ;disassemble the contents of
memory.
• MM: Memory modification
e.g. MM 400 -B
MM 2100 -W
MM 400 -B -DEC
MM 2100 -W -DEC
• DF: Displays the contents of all registers
• .PC: set PC
e.g. .PC 400
• GO: Execute program, (ESC to escape)
• TR: Executes a single instruction at a time
• BR 10000: Places a marker at location 10000
• QU: Quit