Instructor: Rob Nash
Readings: Chap 7-9
Midterm next Monday!
◦ Review this Wednesday
◦ You will see code again…
Lets declare a message to display to the world
org $600 *start of data
HMSG DC.B 'Hello!'
EOM DC.B 0 *eom
end $400
A way to get the attention of the CPU in an
asynronous manner without polling
Also referred to as Traps, we’ll be interested
in the following
◦ Trap #3 *prints out what is pointed to by A3
◦ Trap #9 *ends the program (convention)
ORG $400
MOVEA.L #HMSG, A3
TRAP #3
TRAP #9
ORG $600 *start of data
HMSG DC.B 'Hello!'
DC.B 0 *eom
END $400
FTOC SUBI.W #32, D0
MULS#5, D0
DIVS #9, D0
RTS
See p.28, section 2.6
If register D3 contains 100030FF and register
D4 contains 8E552900, what is the result of
MOVE.W D3, D4?
8E5530FF
MOVE.L D3, D4?
What if I wanted to move the upper half?
A word op, so the upper half of D4 remains
constant. The lower half will be loaded as
follows: 8E5530FF
What will A2 contain after the execution of
MOVEA.L A5,A2
Note that, even though the address registers are
32 bits long, only the lower 24 are used to
address memory in the 68K
◦ There are no external address lines for the upper 8 bits!
So, if A0 contains 00007F00, what happens when
executing:
◦ MOVE.B (A0), D7
0x007F00 holds “0009”
D7 contains 1234FEDC
D7 contains 1234FE09
This implements a pop
◦ Use the value, then increment (pop off stack)
◦ The stack grows to lower addresses, shrinks to
higher addrs
A5 : 0x00007F00
D2 : 0x4E4F2000
0x007EFF : 3C
0x007F00 : 09
0x007F01 : BA
MOVE.W (A5)+, D2
Use what A5 is pointing to, then decrement
◦ A5 thus looks up 7F00
Since a word operation, post decrement by 2
◦ A5 is now 0x007F02
This implements a push
◦ Decrement our stack first to make space
◦ Then overwrite this new location with our data
Stacks shrink “downwards”, or to higher addresses
Relocatable code is critically important today,
and compilers provide this type of code
automatically
Contrast this to code with all absolute
memory locations specified – how do we
shuffle this around in memory?
A2: 0x007F00
D4: F3052BC9
//Mem
0x007EFF : 3C
0x007F00 : 09
0x007F01 : BA
MOVE.B –(A2),D4
MOVE.B D4, -(A2) *push
Answer:
Decrement A2 first, so 0x007EFF
Copy from that location into the lower byte of
D4
MOVE.B D3, (A5)+
00 01 101 011 000 011 => 0x1AC3
MOVE .B 5 for A5 Mode (An)+ Mode Dn 3 (D3)
Dest (ea) Source (ea)
Trap #3, Address in A3 of string
Trap #15
◦ D0 holds the “task number”
2 is for user input, A1 points to this for you
0 is for terminal output
◦ A1 holds the memory addr of the start of string
◦ D1 holds the length of the str to print
What does this code look like in ASM?
adder( int x, int y) {
◦ int z;
◦ z = x + y;
}
*assuming D0 holds x, D1 holds y, D2 is z
adder AND.W #0, D2
ADD.W D0, D2
ADD.W D1, D2
RTS
We wanted to compare two lists of bytes?
A1 points to the first list
A2 points to the second list
Each list is 5 elements long
D0 holds 0 if different, 1 if identical.
For 2 reapers!!
What does the asm look like for the
following?
branch( int a, int b) {
◦ if( a > b ) {
b=a
◦ } else {
a=b
◦ }
}
Write an ASM module that defines two (3x3)
matrices and sums up the first row
Data section:
What does the following code look like in
ASM?
◦ for(int a = 0; a < 10; a++ ) {
nop
◦ }
Implement the overriding feature of
inheritance at the ASM level
Data Section holds a VTable
◦ A table of function pointers
◦ To override a function, we’ll need to update its table
entry
◦ I’ll give you the table in A0
◦ The offset of the function to override in D0 (in longs)
◦ The address of the new function in A1
What is a good HW problem for us to
consider?
