- General purpose registers in the CPU
- Memory
Operands used by M68000
- can provide source operands used in arithmetic (add, subtract, multiply, divide) and logic (and, or, not) operations
- can be used as destination to store results from arithmetic or logic operation
- if an instruction changes the content of a data register, the status flags N, Z, V and C will be set according the result in the modified portion of the data register.
- 3 types of operands in data registers:
- byte (8 bits)
- word (16 bits)
- long word (32 bits)
- Location of the different types of operands inside a data register:
- Example byte operation on data register
Before operation: +----------+----------+----------+----------+ D0 = | 10000000 | 00000000 | 01111111 | 11111111 | +----------+----------+----------+----------+ +----------+----------+----------+----------+ D1 = | 10000000 | 00000000 | 00000000 | 11111111 | +----------+----------+----------+----------+ Operation: ADD.B D0, D1 (add byte operands in D0 and D1 and store in D1) After the operation: +----------+----------+----------+----------+ D0 = | 10000000 | 00000000 | 01111111 | 11111111 | +----------+----------+----------+----------+ +----------+----------+----------+----------+ D1 = | 10000000 | 00000000 | 00000000 | 11111110 | +----------+----------+----------+----------+ Flags in PSR: N = 1 Z = 0 V = 0 C = 1 - Example word (16 bits) operation on data register
Before operation: +----------+----------+----------+----------+ D0 = | 10000000 | 00000000 | 01111111 | 11111111 | +----------+----------+----------+----------+ +----------+----------+----------+----------+ D1 = | 10000000 | 00000000 | 00000000 | 11111111 | +----------+----------+----------+----------+ Operation: ADD.W D0, D1 (add byte operands in D0 and D1 and store in D1) After the operation: +----------+----------+----------+----------+ D0 = | 10000000 | 00000000 | 01111111 | 11111111 | +----------+----------+----------+----------+ +----------+----------+----------+----------+ D1 = | 10000000 | 00000000 | 10000000 | 11111110 | +----------+----------+----------+----------+ Flags in PSR: N = 1 Z = 0 V = 1 C = 0 - Example long word (32 bits) operation on data register
Before operation: +----------+----------+----------+----------+ D0 = | 10000000 | 00000000 | 01111111 | 11111111 | +----------+----------+----------+----------+ +----------+----------+----------+----------+ D1 = | 10000000 | 00000000 | 00000000 | 11111111 | +----------+----------+----------+----------+ Operation: ADD.L D0, D1 (add byte operands in D0 and D1 and store in D1) After the operation: +----------+----------+----------+----------+ D0 = | 10000000 | 00000000 | 01111111 | 11111111 | +----------+----------+----------+----------+ +----------+----------+----------+----------+ D1 = | 00000000 | 00000000 | 10000000 | 11111110 | +----------+----------+----------+----------+ Flags in PSR: N = 0 Z = 0 V = 1 C = 1 - DEMO: click here
- Fact:
- Address registers are mainly used
to store address values
needed to access variables in memory
- We will not use an
address register to store
intermediate results of
computations
- Therefore, I will present a set of simplified rules on using address registers
- Address registers are mainly used
to store address values
needed to access variables in memory
- Rules for using address registers
- You cannot use
the .b mode
(byte size operand) with
address registers
Example:
move.b #-1, a0 not allowed add.b #-1, a0 not allowed add.b d0, a0 not allowed
- When you store a value into
an address register, the value is
always stored in
32 bits representation
(That is because an address in M68000 is always represented by 32 bit)
Example:
move.w #-1, a0 ; stores 11111111 1111111 11111111 11111111 in a0 move.l #-1, a0 ; stores 11111111 1111111 11111111 11111111 in a0Note: the difference between these 2 instructions is the encoding.
The first instruction uses 6 bytes, the second uses 10 bytes. (See a.lst in demo)
- The status flags (N,Z,V,C) are not updated when an operation updates an address register
(That is because the operation is not consider a data computational operation)
- The status flags (N,Z,V,C) are not updated when an operation updates an address register
- You cannot use
the .b mode
(byte size operand) with
address registers
- Example word size operation with
address register as destination
Before operation: +----------+----------+----------+----------+ D0 = | 00000000 | 00001001 | 10010010 | 10111000 | +----------+----------+----------+----------+ +----------+----------+----------+----------+ A0 = | 00000000 | 00000000 | 00000000 | 00000000 | +----------+----------+----------+----------+ Operation: MOVE.W D0, A0 (A0 is the destination) After operation: +----------+----------+----------+----------+ D0 = | 00000000 | 00001001 | 10010010 | 10111000 | +----------+----------+----------+----------+ +----------+----------+----------+----------+ A0 = | 11111111 | 11111111 | 10010010 | 10111000 | +----------+----------+----------+----------+ Flags in PSR are unchangedNote:
- Because the 16 bit representation indicates that the value is negative, it is automatically converted to a 32 bit representation for a negative value by prepending 1 bits before the representation.
- Example long word size operation with
address register as destination
Before operation: +----------+----------+----------+----------+ D0 = | 00000000 | 00001001 | 10010010 | 10111000 | +----------+----------+----------+----------+ +----------+----------+----------+----------+ A0 = | 00000000 | 00000001 | 00000000 | 00000000 | +----------+----------+----------+----------+ Operation: MOVE.L D0, A0 After operation: +----------+----------+----------+----------+ D0 = | 00000000 | 00001001 | 10010010 | 10111000 | +----------+----------+----------+----------+ +----------+----------+----------+----------+ A0 = | 00000000 | 00001001 | 10010010 | 10111000 | +----------+----------+----------+----------+ Flags in PSR are unchanged - DEMO:
click here
- Remember that:
- Any byte size
operation with
address register as destination are
NOT allowed !!!
Examples:
MOVEA.B #3, A0 (MOVEA = move to Address reg) - not allowed ADDA.B #3, A0 (ADDA = Add to Address register) - not allowed SUBA.B #3, A0 (SUBA = Subtract from Address reg) - not allowed
- Word size and
long size
operation with
address register as destination are
allowed !!!
Examples:
MOVEA.W #3, A0 allowed ADDA.W #3, A0 allowed SUBA.W #3, A0 allowed MOVEA.L #3, A0 allowed ADDA.L #3, A0 allowed SUBA.L #3, A0 allowed
- Any data size
operation with
data register as destination are
allowed !!!
Examples:
MOVE.B #3, D0 allowed ADD.B #3, D0 allowed SUB.B #3, D0 allowed MOVE.W #3, D0 allowed ADD.W #3, D0 allowed SUB.W #3, D0 allowed MOVE.L #3, D0 allowed ADD.L #3, D0 allowed SUB.L #3, D0 allowedNotice also that the instruction mnemonic for data destination registers do not have the trailing letter A !!!
- Any byte size
operation with
address register as destination are
NOT allowed !!!
- Memory operand is specified by a starting address
- Starting from that address, 1, 2 or 4 bytes are used
for byte, word and long word operands as follows:
Memory: +----------+ | ........ | Starting +----------+ address: | aaaaaaaa | +----------+ | bbbbbbbb | +----------+ | cccccccc | +----------+ | dddddddd | +----------+ | ........ | +----------+ Byte Operand at Starting Address: +----------+ | aaaaaaaa | +----------+ Word Operand at Starting Address: +----------+----------+ | aaaaaaaa | bbbbbbbb | +----------+----------+ Long Word Operand at Starting Address: +----------+----------+----------+----------+ | aaaaaaaa | bbbbbbbb | cccccccc | dddddddd | +----------+----------+----------+----------+
- Make dead sure
that you use the correct operand size
in assembler programs !!!
Example: move.l #-8, d0 Result: d0 = 11111111 11111111 11111111 11111000 move.l d0, 5672 Result in memory: 5672: 11111111 5673: 11111111 5674: 11111111 5675: 11111000 move.b 5672, d1 Will move BYTE at address 5672 (= 11111111) into (lower 8 bits) of d1 d1 will NOT be equal to -8 ! move.w 5672, d2 Will move WORD at address 5672 (= 11111111 11111111) into (lower 16 bits) of d1 d2 will NOT be equal to -8 ! move.l 5672, d3 d3 = -8 --- only this instruction will move -8 in a register - DEMO: click here
- Notice that:
- A register or
memory cell
contains a bit pattern
- There is no information about the data type (= encoding scheme) used !!!
- A register or
memory cell
contains a bit pattern
- How is the
data type "used" in
assembler programming:
- The computer (CPU) has different instructions that operate using different encoding methods !!!
Example:
- mulu:
perform a multiplication operation
assuming that the the
representation used is
for unsigned numbers
Example:
11111111 11111110 = 65534(10) (unsigned) 00000000 00000010 = 2(10) (unsigned) ---------------------------------------------- 000.0011111111 111111100 = 131068 <--- result of an unsigned multiplication
- muls:
perform a multiplication operation
assuming that the the
representation used is
for signed numbers
(= 2's complement encoding)
Example:
11111111 11111110 = -2(10) (2's complement) 00000000 00000010 = 2(10) (2's complement) ---------------------------------------------- 111..111111111 111111100 = -4(10) <--- result of an signed multiplication
Demo: data-type.s in the demo directory.