Results 1 to 1 of 1
  1. #1
    DarkT
    DarkT is offline
    Member-in-training DarkT's Avatar
    Join Date
    2012 Jan
    Posts
    116
    Thanks
    60
    Thanked 103 Times in 30 Posts
    Rep Power
    0

    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   [4000] ← [300]       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] ← [3000]          Copy contents of location 3000 to D0
    d.     MOVE  D0,3000             [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     [50004] ← 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        [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
          ADD.B  Numb2,D0  Add in second number
          ADD.B  Numb3,D0  Add in second number
          ADD.B  Numb4,D0  Add in second number
          ADD.B  Numb5,D0  Add in second number
          ADD.B  Numb6,D0  Add in second 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
            b.     register-to-memory addressing                    MOVE.W D0,$1234
            c.     memory-to-register addressing                    MOVE.W $1234,D0            
            d.     memory-to-memory addressing                    MOVE.L (A1),(A3)
    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
     
    Address   Name       Value         Comment
    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
    b.     ADD.B   #1,A3      Can't do byte operation on address register
    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
    f.      ADD.W   +(A2),D3   Can't have preincrementing addressing mode
    g.     ORG     #400       Assembly form � no #. Should be $400
    h.     BEQ.B   Loop_3     No .B extension to branch instructions
    9. Answer the following questions about 68K assembler conventions.

    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.

    g. Why ADDA.L #4,A0 and ADD.L #4,D0?
    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
       Loop: Read character at pointer
         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 the carry bit is set, jump to the location 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.

  2. The Following 2 Users Say Thank You to DarkT For This Useful Post:


Similar Threads

  1. Examples For Newbies - MousePos
    By RodizipaZX in forum AutoIt
    Replies: 0
    Last Post: 2012-12-13, 07:33 PM
  2. A new assembly challenge!
    By zeronoctis in forum Other MMO
    Replies: 0
    Last Post: 2012-11-15, 07:52 PM
  3. Using assembly in AutoIT
    By proseco91 in forum Forsaken World
    Replies: 1
    Last Post: 2012-08-04, 03:47 AM
  4. [Asm] Basic assembly instructions (opcodes) and examples
    By Dwar in forum Programming Tutorials
    Replies: 2
    Last Post: 2011-03-16, 01:15 PM
  5. IDA offset finding examples
    By Dwar in forum Programming Tutorials
    Replies: 0
    Last Post: 2010-11-20, 05:00 AM
Visitors found this page by searching for:

68k instruction into rtl notation

translate the following fragment of high level language into 68k assembly language

assembly examples games

create a simple 68k program to add together the number 2 4 6 8 10 12

IF T= 7 THEN X = 10 END_IF . assume that t and x are in memory . write a program to implement this fragment of code . select your own value for variables t and x

Assembly Language game example

assembly language games examples

create a simple 68k program called adder. your program should add together the numbers

create a simple 68k program called ADDER

assembly language games example

Posting Permissions

  • You may not post new threads
  • You may not post replies
  • You may not post attachments
  • You may not edit your posts
  •