1. ## Somes Assembly Examples!

Some Assembly Language Examples

1. Describe the action of the following 68K assembly language instructions in RTL, register transfer language. That is, translate the assembly language syntax of the 68K instruction into the RTL notation that defines the action of the instruction.

Code:
```
a.     MOVE  3000,4000    ←        Copy contents of location 3000 to location 4000
b.     MOVE  D0,D4                  [D4] ← [D0]               Copy contents of D0 to D4
c.     MOVE  3000,D0             [D0] ←           Copy contents of location 3000 to D0
d.     MOVE  D0,3000              ← [D0]          Copy contents of  D0 to location 3000
e.     MOVE  #4000,D4           [D4] ← 4000               Copy the value 4000 to D4
f       MOVE  #4000,5000      ← 4000       Copy the value 4000 to location 5000
g.     MOVE  (A0),D3             [D3] ← [[A0]]          Copy contents of location pointed at by A0 to D3
h.     MOVE  #12,(A0)           [[A0]] ← 12               Copy 12 to location pointed at by A0
i.      MOVE  (A1),(A2)        [[A2]] ← [[A1]]    Copy contents of location pointed at by A1 to location pointed at by A2
j.      ADD   D2,D1       [D1] ← [D1]+[D2]  Add contents of D1 to D2 and put sum in D1
k.     ADD   #13,D4      [D4] ← [D4]+12       Add 13 to D4 and put sum in D4
l.      ADD   (A3),1234         ← [[A3]]    Add contents of location pointed at by A3 to location 1234```
2. Explain why the following assembly language and RTL constructs are incorrect.
Code:
```a.     MOVE  D3,#4                   Can't move to a literal destination
b.     MOVE  [D3],D2              Operand of form [D3] not defined for 68K
c.     MOVE  (D3),D2              Operand of form (D3) not defined for 68K  note (A3) is ok
d.  [D3] ← A0 + 3     A0 is an address register should be [A0]
e.  [D3] ← #3          Can't use # symbol in RTL
f.  3 ← [D3]           Can't have literal as destination in RTL```
3. Create a simple 68K program called ADDER. Your program should add together the numbers: 6, 4, 12, 16, 17, and 50. The program is to be assembled with the 68K cross-assembler and then run on the 68K simulator (either Easy68K or the Teesside assembler/simulator). Run the binary file you have created in the simulation mode.

A very simple program that does not use complex addressing modes and only uses very simple instructions is
Code:
```      ORG    \$1000     Location of the program
MOVE.B Nmb1,D0   Get first number
STOP   #\$2700    Stop execution
ORG    \$2000     Location of the data
Nmb1  DC.B   6
Nmb2  DC.B   4
Nmb3  DC.B   12
Nmb4  DC.B   16
Nmb5  DC.B   17
Nmb6  DC.B   50
END    \$1000    End of program (and address of first instruction)```
4. Give examples of valid 68K assembly language instructions that use:
Code:
```        a.     register-to-register addressing                     MOVE.B D0,D2
6. By means of a memory map explain the effect of the following sequence of 68K assembly language directives.
Code:
```         ORG   \$600
DS.L  2
DC.L  2
DC.B '1234'
Time  DC.B  6
Top   DS.B  6
BSc1  EQU   2
IT1   EQU   3
SE1   DS.B  IT1+BSc1

600                  ??????        Reserve 2 x 4 = 8 bytes
608                  00000002      Put \$00000002 in memory
60C                  31            Put the ASCI string '1234' in memory
60D                  32
60E                  33
60F                  34
610       Time       6             Put byte value 6 in memory
611       Top        ??            Reserve 6 bytes of storage
BSc1 is 2
IT1 is 3
617       SE1        5             Reserve 5 bytes (IT1+BSc1 is 2+3=5)
61C                                Next free location```
7. What would the following 68K assembly language fragment store at address \$1002?
Code:
```
ORG   \$1000     Starting point for following data etc is 1000
P     EQU   5         P is given the value 5. Using P is the same as using 5
Q     DS.B  2         Store two byte locations in memory location 1000 and 1001.
Note that location 1000 is defined as Q
One   DC.W  P+Q       Store a 16-bit word constant in memory location 1002.
The value is P+Q=5+1000 = 1005```
8. What is wrong with each of the following 68K assembly language operations?
Code:
```a.     MOVE    Temp,#4    Literal can't be destination
c.  CMP.L   D0,#9      Can't have literal as destination
d.  MOVE.B  #500,D5    Biggest byte move is 255
e.     DS.B    1,2        Can't have multiple operands with DS
g.     ORG     #400       Assembly form � no #. Should be \$400
h.     BEQ.B   Loop_3     No .B extension to branch instructions```

a. What is the effect of the assembler directive ORG \$400?
Defines the address/location of the next data element of instruction to be loaded

b. What is the effect of the assembler directive DS.W 20?
This directive creates 20 words or 40 bytes of storage from the current location. The next free location is 40 bytes on.

c. What is the effect of the assembler directive DC.W 1234?
The directive DC.W 1234 loads the decimal value 1234 (in binary form) into the current location and moves the location counter on by two bytes.

d. What is the effect of the assembler directive DC.W \$1234?
The directive DC.W 1234 loads the hexadecimal value 1234 (in binary form) into the current location and moves the location counter on by two bytes.

e. What is the effect of the + in the effective address (A0)+?
This indicates auto incrementing (more strictly post-incrementing). After the address register pointer has been used, its contents are incremented by 1, 2, or 4 depending on whether the operand was B, W, or L.

f. What is the effect of the - in the effective address -(A0)?
This operand indicated predecrementing and is identical to auto-incrementing except that the address register is decremented before it is used to access the operand.

Many modern 68K assemblers don't force you to use this convention. However, the original assembler required you to write ADDA, SUBA, MOVEA, and CMPA if the destination operand was an address register. This was done to remind you that address registers behaved differently to data registers.

11. Translate the following fragment of high-level language into 68K assembly language.
Code:
```                  IF T = 5
THEN X = 4
END_IF```
Assume that T and X are in memory. Write a program to implement this fragment of code and run it on the 68K simulator. Select your own values for variables T and X. Use the simulator's trace mode to observe the behavior of the program.

If we are going to turn this fragment of code into a program, we will need to include assembly overheads and data. One possible solution is:
Code:
```     ORG     \$400      Start of program
MOVE.B  T,D0      Get the value of T
CMP.B   #4,T      Is the value of T equal to 5
BNE     Exit      If not then leave
MOVE.B  #4,X      Else made X = 4
Exit STOP    #\$2700    Exit point and termination for program

ORG     \$1000     Put data in here
T    DS.B    3         Let's make T = 3 on this run
X    DC.B    20        Let's make X  = 20

END     \$400      Last line of prog and starting pt for execution```
13. The 68K can operate with byte, word and longword operands. What does this mean? Which type of operand do you use in any particular circumstance?

The 68K's data and registers are 32 bits wide. A data operation may take part on the least-significant 8, 16, or the entire 32 bits of a register (as specified by a .B, >W, or .L suffix to the instruction). The operation ADD.B D0,D1 adds the least significant 8 bits of D0 to the least significant 8 bits of D1 and puts the result in the least-significant bits of D1. Note that bits 8 to 31 of register D1 are not affected by this instruction (some processors allows 8 bit operations but clear higher-order bits).

If operations take one clock cycle, it doesn't matter which format you use. However, if byte or word operations are faster, then it make sense to use smaller data sizes.

However, when dealing with natural 8-bit values such as ASCII characters, 8 bit operations are a good idea because you can read 8-bit values from memory and process them as 8-bit values.

24. Suppose you wish to pre-load memory with the value 1234 before executing a program. Which of the following operations is correct?
Code:
```a.   DC.B    #1234           Incorrect  no # and .B wrong
b.   DC.W    1234            Correct
c.   DC.W    #1234           Incorrect no #
d.   DS.B    \$1234           Incorrect this reserves storage
e.   MOVE.W  #1234,Location  Incorrect this loads memory at runtime```
25. The register transfer language definition of MOVE.B (A2)+,D3 is one of the following. CHECK
Code:
```a.  D3   ← [[A2]]; [A2] ← [A2] + 1
b.  [D3] ← [[A2]]; [A2] ← [A2] + 1
c.  [D3]  ← [[A2]]; [A2] ← [A2] + 1
d.  [A2] ← [A2] + 1; [D3] ← [A2];```
26. When a parameter is passed to a subroutine by reference (i.e., not by value),

a. the parameter can be put in an address register
b. the address of the parameter can be put in an address register
c. the address of the parameter can be pushed on the stack
d. the parameter can be pushed on the stack
e. parts a and d are correct
f. parts b and c are correct CORRECT you pass an address

27. Consider the following code:
Code:
```      MOVE.W X,-(A7)    Push X
MOVE.L Y,-(A7)    Push Y
BSR    PQR        Call PQR
Clean_up          Clean up the stack```
a. Why do you have to clean up the stack after returning from the subroutine?
b. What code would you use to clean up the stack?
c. Draw a memory map of the stack immediately before executing the RTS in the subroutine PQR.

a. The stack should be balanced in the sense that after you modify it, you should eventually reverse the modification. If a subroutine builds on top of the stack, you should restore the stack before returning.

b. If you push a word and a longword on the stack, you move the stack pointer up by 6 bytes; that is [A7]←[A7] 6. You can undo this by adding 6 to the stack pointer with LEA 6(A7),A7.

c. Assume the stack is, say, \$1000 before this code is executed. The first move, moves the stack up by 2 bytes to \$0FFE. The second instruction moves the stack pointer up by 4 bytes to \$0FFA. The subroutine call saves the 4-byte return address on the stack and pushes up the stack pointer to \$0FF6
Code:
```0FF6  Ret    Return address pushed on stack as a 16-bit word
0FFA  YYYY   Y pushed on stack as a 32-bit word
0FFE  XX     X pushed on stack as a 16-bit word
1000  0000   initial stack```
28. Write an assembly language program to reverse the bits of a byte.

There are many ways of doing this. One technique is to shift the bits out of a register left (one-by one) and capture them in the eXtend bit. Then to shift the bits of another register right through the eXtend bit to move the bits in but in the reverse order; for example:
Code:
```       ORG      \$400
MOVE.B   Test,D0       Get the string to reverse
MOVE.B   #7,D7         Use D7 as a loop counter for 8 cycles
CLR.L    D1            Use D1 to catch the reversed bits
Shft   LSL.B    #1,D0         Shift the byte one place left catch ms bit
ROXR.B   #1,D1
DBRA     D7,Shft       Repeat 8 times
STOP     #\$2700        Stop execution
Test   DC.B     %11001010     Test string```
29. Explain why the following assembly language and RTL constructs are incorrect
Code:
```a.  MOVE  D4,#\$64
Cannot use literal as destination operand
b.  MOVE  (D3),D2
Cannot use data register as pointer
c.  [D3] ← A0 + 3
This is RTL. Assume A0 should be [A0]
d.  [D3] ← #3
This is RTL. The assembly language literal symbol is not required with a literal```
32. Assume that a string of ASCII characters is located in memory starting at location \$2000. The string ends with the character 'Z'. Design and write a 68K assembly language program to count the number of 'E's, if any, in the string.
Code:
```   Point to first character
Set Es counter to 0
Point to next character
If character == 'E' then increment Es counter
If character == 'Z' then stop
End loop

ORG    \$400
LEA    Ptr,A0       A0 points at string
CLR.B  D0           Use D0 as Es counter assume < 255
Loop  MOVE.B (A0)+,D1     Loop: reach char into D1 and update pointer
CMP.B  #'Z',D1            test for'E'
BNE    NotE               if not E then try Z
ADD.B  #1,D0              if E then increment Es counter
NotW  CMP.B  #'Z',D1            test for 'Z'
BNE    Loop         Repeat until 'Z' found
STOP   #\$2700       Halt
ORG    \$1000        Dummy data
Ptr   DS.B   'ACDEMEEMDNEEEMEMZ'
END   \$400```
33. Express the following sequence of 68K assembly language instructions in register transfer language and explain in plain English what each instruction does.
Code:
```a.     LEA     4(A2),A1
Load A1 with the contents of A2 plus 4
[A1] ← [A2] + 4

b.     MOVEA.L A3,A2
Copy the contents of A3 into A2
[A2] ← [A3] + 4

c.     MOVE.B  (A1),D3
Copy the byte at the memory location pointed at by A1 into register D3
[D3] ← [D3] + [[A1]]

d.     MOVE.B  #5,(A1)
Copy the literal value 5 in to the memory location pointed at by A1
[[A1]] ← 5

e.     BCS     ABC
IF (C == 1) THEN [PC] ← ABC

f.      MOVE.B  (A1)+,-(A3)
Move the byte pointed at by A1 to the memory location one less than the location pointed at by A3. Increment A1 by 1 and decrement S3 by 1
[A3] ← [A3] 1
[[A3]] ← [[A1]]
[A1] ← [A1] + 1```

35. Suppose you are given an algorithm and asked to design and test a program written in 68K assembly language. How would you carry out this activity? Your answer should include considerations of program design and testing, and the necessary software tools.

The answer to this question is long and depends on the available tools and the complexity of the algorithm to be coded. In principle, for a relatively small algorithm, you would turn the algorithm into pseudocode and then translate the pseudocode fragments into assembly language.

To debug a program you can use a simulator such as EASy68k. You can step through instructions and observe the way in which registers change to see whether the code does something you didn't expect. Moreover, you can add breakpoints (places where execution stops) and run the code until a breakpoint is reached. This helps you when there are thousands of instructions to execute and step-by-step mode would be to slow. 