Scribd
Upload
77 views

Instructor: Rob Nash Readings: Chap 7-9 Midterm Next Monday!

The document discusses a computer science lecture that covers chapters 7-9 in the readings and has a midterm exam coming up on Monday. It also provides examples of assembly language code, including using traps to print messages, implementing functions like FTOC temperature conversion, and examples manipulating data in registers and memory using MOVE instructions. It asks questions about the results of various MOVE operations and manipulating the stack and memory.

Uploaded by

Vaibhav Rai
Copyright
© © All Rights Reserved
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
77 views

Instructor: Rob Nash Readings: Chap 7-9 Midterm Next Monday!

The document discusses a computer science lecture that covers chapters 7-9 in the readings and has a midterm exam coming up on Monday. It also provides examples of assembly language code, including using traps to print messages, implementing functions like FTOC temperature conversion, and examples manipulating data in registers and memory using MOVE instructions. It asks questions about the results of various MOVE operations and manipulating the stack and memory.

Uploaded by

Vaibhav Rai
Copyright
© © All Rights Reserved
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
You are on page 1/ 28

 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?

You might also like