- Connections between the
M68000 CPU and the
(computer) memory:
Comments:
- Each data register contains 32 bits (= 4 bytes)
- Each address register contains
32 bits (= 4 bytes)
(The other registers in the CPU have been omitted for brevity)
- Each memory cell contains 8 bits (= 1 byte)
- Each memory cell is
identified by its
(memory) address
- A (memory) address in M68000
is a 32 bits binary number
(I used decimal numbers for address in the figure for convenience !!!)
- A (memory) address in M68000
is a 32 bits binary number
- Recall:
- All variables used in a computer program are store in the (computer) memory !!!
- Therefore:
- What you learn in this webpage is allow you to access the variables defined in a computer program (because these variables are stored in memory !)
- Types
of values:
- byte typed value are 1 byte long
- short typed value are 2 bytes long
- int typed value are 4 bytes long
- float typed value are 4 bytes long
- And so on...
- Memory cells:
- Each memory cell can store 1 byte
- Storing the
different types of
values:
- byte typed value
are 1 byte long
- a byte typed value is stored in 1 memory cell
- short typed value
are 2 bytes long
- a short typed value is stored in 2 consecutive memory cells
- int typed value
are 4 bytes long
- an int typed value is stored in 4 consecutive memory cells
- float typed value
are 4 bytes long
- an int typed value is stored in 4 consecutive memory cells
- And so on...
Graphically:
- Storing a
byte typed value in
memory:
- Storing a
short typed value in
memory:
- Storing a
int typed value in
memory:
- Storing a
float typed value in
memory:
(Use this webpage to verify that the float representation is 3.0: click here )
- byte typed value
are 1 byte long
- Important fact
(illustrated through question/answer:)
- $64,000 question:
- How can the
computer tell
that a binary pattern is
a 2's complement (int) number
or a
IEEE 754 (float) number ???
Example:
Answer:
- It is impossible
to tell by
looking
only at the
bits in the
memory cells !!!
- We must remember the data type of the data that is stored in every memory location !!!
- How can the
computer tell
that a binary pattern is
a 2's complement (int) number
or a
IEEE 754 (float) number ???
- Programming in
assembler:
- When you write a
Java program,
the
Java compiler will
keep track of the
data type stored in
each memory cell
(when the Java compiler
creates the variable in
memory)
- When you write an assembler program, YOU must keep track of the data type stored in each memory cell (when YOU create the variable in memory using the DS assembler directive !!!)
- When you write a
Java program,
the
Java compiler will
keep track of the
data type stored in
each memory cell
(when the Java compiler
creates the variable in
memory)
- $64,000 question:
- Information
needed to
identify an
operand in
memory:
- We need the starting address
where the operand is
stored in memory
- We need to know (= remember) the data type of the operand stored at that memory location (see above !!!)
- We need the starting address
where the operand is
stored in memory
- Example 1 on
how to
identify the
value of an
operand stored in
memory:
- What value is
stored at
memory location 4000 ???
- Answer:
-
If the data type of the
stored value is
byte,
then the value
stored in the
memory location is:
- But
,
if the data type of the
stored value is
char,
then the value
stored in the
memory location is:
- And
,
if the data type of the
stored value is
short,
then the value
stored in the
memory location is:
- And
,
if the data type of the
stored value is
int,
then the value
stored in the
memory location is:
- And
,
if the data type of the
stored value is
float,
then the value
stored in the
memory location is:
-
If the data type of the
stored value is
byte,
then the value
stored in the
memory location is:
- What value is
stored at
memory location 4000 ???
- Recall the different
MOVE assembler instruction:
MOVE.B Src, Dest // Copy the byte operand from Src to Dest MOVE.W Src, Dest // Copy the short (or word) operand from Src to Dest MOVE.L Src, Dest // Copy the int (or long word) operand from Src to DestNotice that:
- Each assembler instruction
has a
data type:
MOVE.B Src, Dest will only works on byte type data ! MOVE.W Src, Dest will only works on short (or word) type data ! MOVE.L Src, Dest will only works on int (or long word) type data !
- Each assembler instruction
has a
data type:
- Syntax of the
MOVE instruction
using memory operands:
MOVE.B Src, MemAddr // Copy the byte operand from Src to memory location MemAddr MOVE.W Src, MemAddr // Copy the short (or word) operand from Src to memory location MemAddr MOVE.L Src, MemAddr // Copy the int (or long word) operand from Src to memory location MemAddr
MOVE.B MemAddr, Dest // Copy the byte operand from memory location MemAddr to Dest MOVE.W MemAddr, Dest // Copy the short (or word) operand from memory location MemAddr to Dest MOVE.L MemAddr, Dest // Copy the int (or long word) operand from memory location MemAddr to Dest
- I will show you 2 groups of
examples:
- First group of examples illustrates the effect of the MOVE instruction when you store data into the memory (= variable)
- Writing/storing
data to
memory
(= updating a
variable in memory)
- Before executing the
MOVE instruction:
- After executing
MOVE.B D0,
4000
(= copy the byte typed value
from D0 to
memory location 4000):
The MOVE.B instruction is used to update a byte typed variable in memory
- After executing
MOVE.W D0,
4000
(= copy the short (or word)
typed value
from D0 to
memory location 4000):
The MOVE.W instruction is used to update a short typed variable in memory
- After executing
MOVE.L D0,
4000
(= copy the int (or long word) typed value
from D0 to
memory location 4000):
The MOVE.L instruction is used to update a int typed variable in memory
- Before executing the
MOVE instruction:
- Reading (= accessing)
data from memory
(= obtaining the
value of a
variable in memory)
- Before executing the
MOVE instruction:
- After executing
MOVE.B 4000, D0
(= copy the byte typed
value
from
memory location 4000 to
register D0):
The MOVE.B instruction is used to retrieve a byte typed variable from memory (e.g., into a register in the CPU)
- After executing
MOVE.W 4000, D0
(= copy the short (or word)
typed value
from
memory location 4000
to register D0):
The MOVE.W instruction is used to retrieve a short typed variable from memory (e.g., into a register)
- After executing
MOVE.L 4000, D0
(= copy the int (or long word)
typed value
from
memory location 4000
to register D0)
The MOVE.L instruction is used to retrieve a int typed variable from memory (e.g., into a register in the CPU)
- Before executing the
MOVE instruction:
- Example Program:
(Demo above code)
- Prog file: click here
How to run the program:
- Right click on link(s) and
save in a scratch directory
- To compile: as255 mem-operands
- To run: use m68000 (a.k.a. Egtapi)
- Suppose we
have the following
situation:
- Quiz 1:
- What is the
content of
the memory and
of the register D0
after we
execute these
2 assembler instructions:
MOVE.L D0, 4000 MOVE.L 4000, D0Answer:
- After
MOVE.L
D0, 4000, we have:
- Then, after
MOVE.L
4000, D0, we have:
- After
MOVE.L
D0, 4000, we have:
- What is the
content of
the memory and
of the register D0
after we
execute these
2 assembler instructions:
- Quiz 2:
- What is the
content of
the memory and
of the register D0
after we
execute these
2 assembler instructions:
MOVE.L D0, 4000 MOVE.W 4000, D0Answer:
- After
MOVE.L
D0, 4000, we have:
- Then, after
MOVE.W
4000, D0, we have:
- After
MOVE.L
D0, 4000, we have:
Moral of the quiz:
- You must use the correct data type in every assembler instruction !!!
- What is the
content of
the memory and
of the register D0
after we
execute these
2 assembler instructions:
- Example Program:
(Demo a similar program as
the above example)
- Prog file: click here
How to run the program:
- Right click on link(s) and
save in a scratch directory
- To compile: as255 caveat-0
- To run: use m68000
- Fact:
- All variables
in a computer program are
stored in
memory (RAM)
- Memory variables are accessed using the address (= location) of the memory cell(s) where the variable is stored in memory
Example:
- If an int typed
variable is stored at
memory location 4000, we
must use
these instructions to
access the variable:
MOVE.L D0, 4000 * Update the variable and MOVE.L 4000, D0 * Retrieve the value in the variable
- All variables
in a computer program are
stored in
memory (RAM)
- Important observation:
- No human being would like to memorize the location of each variable in his/her program !!!
- Help from the
assembler in
writing
an assembler program:
- Recall that:
- When we define a
variable using the
DS
(or DC)
assembler directive:
.... .... L: ds.b 4 * Defines an int (4 bytes) variable ....The label L will:
- The symbolic name L is equated (equals) to the address of the variable !!!
- We can use the symbolic name (= label) instead of the actual address in an assembler instruction !!!
- When we define a
variable using the
DS
(or DC)
assembler directive:
- Recall that:
- Example:
- Suppose we
define an int variable
as follows:
.... .... L: ds.b 4 * Defines an int (4 bytes) variable ....Suppose this variable is located as memory address 4000:
- Then:
- Every symbol L in the assembler program will be replaced (= equated to) 4000 !!!
Example:
The assembler instruction: MOVE.L D0, L ====> "equated to" MOVE.L D0, 4000 and MOVE.L L, D0 ====> "equated to" MOVE.L 4000, D0
- Suppose we
define an int variable
as follows: