Pl COURS.DOC

From Atari Wiki
Jump to navigation Jump to search
... continuation on addressing modes


7) PC RELATIVE ADDRESSING WITH DISPLACEMENT: (schematized as d(pc) )
   --------------------------------------------------------

  It is written as follows:
  ----------------        +-----------------------------------------+
                          | Instruction       d(pc),destination    |
                          +-----------------------------------------+

  And is read as:
  ---------------
  We add the value of the signed displacement 'd' coded on a WORD to the PC (of
  the considered instruction!), we take the data thus pointed to and place it in
  (at) the destination operand.

   d(pc)= d+pc

  Example:  I use the 'JMP destination' instruction, which causes a jump
  --------  in the program to the 'destination' address by loading the value of PC
            with the value of 'destination'.
            (JMP as in JuMP=jump in English)

    if I write:                          JMP  10(pc)

    Before the execution of the JMP instruction, the PC points to the address of
    this instruction (JMP  10(pc) )

Writing JMP  10(pc) causes a jump of 10 Bytes after the address pointed to
by the PC which points to this instruction (i.e., JMP 10(pc)), if at address
PC+10 there is a Label ('A') for example, the instruction JMP  10(pc) causes
a jump (by adding 10 to PC) to this Label.
(Of course, there could be other instructions or something else, it all depends
on your listing...)


     Example:
     --------

                  Labels      program instructions

                               .
                               .
  here, PC=$AF00       X      JMP  10(pc)       , there's a jump to PC+10
                               .
                               .
                               .
  here, PC=$AF10       A      ............      , we continue at $AF10
                               .
                               .


Therefore, the size of the JMP d(pc) instruction must be taken into account
for the displacement because the preceding PC of the considered instruction
plays a role.
Indeed, the size of the instructions in memory varies according to the
addressing mode used. At the end of this chapter on addressing modes, I will
provide the size and representation of addressing modes in memory.
So, the real displacement is the actual displacement + the size of the
instruction and its operands.



8) PC RELATIVE ADDRESSING WITH INDEX AND DISPLACEMENT: (d(pc,rn))
   --------------------------------------------------------------

  It is written as follows:
  ----------------        +-----------------------------------------+
                          | Instruction     d(pc,rn),destination    |
                          +-----------------------------------------+

  And is read as:
  ---------------
 We add the value of the signed displacement 'd' coded on a WORD and that of
 the 'rn' register to the PC (of the considered instruction!), we take the data
 thus pointed to and place it in (at) the destination operand.

 d(pc,rn)= d+an+pc   OR   d(pc,rn)= d+dn,pc


   This addressing mode is therefore identical to the previous one, except that here we
   add the displacement and the content of the 'rn' register to the preceding PC of
   the considered instruction.

   If 'rn' is a WORD (.W), the lower WORD of the 'rn' register is used during
   the operation.

   If 'rn' is a LONG (.L), the 'rn' index register is entirely used.



9) LONG ABSOLUTE ADDRESSING: (schematized as BBBB )
   ------------------------------------------------

   It is written as follows:
   ----------------        +-----------------------------------+
                           | Instruction      source,Address   |
                           +-----------------------------------+
                                           OR
                                           --
                           +-----------------------------------+
                           | Instruction  Address,destination  |
                           +-----------------------------------+


   And is read as:
   ---------------
   The source operand is placed in (at) the address specified by the
   destination operand.
                                           OR
                                           --
   The data pointed to by the 'Address' operand is taken and placed in
   (at) the destination operand.

   Example:              MOVE   labas,d0
   --------              .
                         .
                         .
                         DATA

                labas    DC.W   12            at 'labas', there's a
                                              WORD=12


     The data register d0 will contain 12.


   Another example:      MOVE     D0,$AFFB48   if $AFFB48 is in a DATA
   --------------                                segment (details soon)

   The low WORD of d0 is placed at address $AFFB48



10) SHORT ABSOLUTE ADDRESSING: (schematized as BB )
    ------------------------------------------------

   It is written as follows:
   ----------------        +-----------------------------------+
                           | Instruction      source,Address   |
                           +-----------------------------------+
                                           OR
                                           --
                           +-----------------------------------+
                           | Instruction  Address,destination  |
                           +-----------------------------------+


   And is read as:
   ---------------
   The source operand is placed in (at) the address specified by the
   destination operand.
                                           OR
                                           --
   The data pointed to by the 'Address' operand is taken and placed in
   (at) the destination operand.

   Addressing mode identical to the previous mode, but here the value of
   the address must be able to be contained within a WORD.




     INTERNAL REPRESENTATION OF ADDRESSING MODES AND EXTENSION WORDS:
     -----------------------------------------------------------------

   Each addressing mode is associated with 0,1 or 2 EXTENSION WORDS, 
   this can be important for the representation (size) of the
   different addressing modes in memory: 
   (refer to the mode d(pc) or d(pc,rn) )


           +-------------------------+---------------------+
           |        MODES            |    NUMBER OF WORDS   |
           |     ADDRESSING          |      EXTENSION       |
           +-------------------------+---------------------+
           |         BBBB            |          2           |
           +-------------------------+---------------------+
           |          BB             |          1           |
           +-------------------------+---------------------+
           |        #...             |   1 if .B or .W      |
           |                         |      2 if  .L        |
           +-------------------------+---------------------+
           |         (an)            |          0           |
           +-------------------------+---------------------+
           |         (an)+           |          0           |
           +-------------------------+---------------------+
           |        -(an)            |          0           |
           +-------------------------+---------------------+
           |        d(an)            |          1           |
           +-------------------------+---------------------+
           |        d(an,rn)         |          1           |
           +-------------------------+---------------------+
           |        d(pc)            |          1           |
           +-------------------------+---------------------+
           |        d(pc,rn)         |          1           |
           +-------------------------+---------------------+

 -   Please note that the size of the operands (if any) also plays a role in
     the memory representation of the instructions.

     In general, it is 1 WORD for the instruction + extension words and the size of the operands.

   Examples:
   ---------
   Thus:  MOVE.W  #14,D0 will be represented by 1 word (instruction) + 1 word
   (for the number 14) + 1 word (for the low WORD of d0) + 1 word (for
   immediate addressing with .W size which admits one extension word) = 4 words in memory.

   Another example: JMP $AFFA02 will be represented by 3 Words in memory (long
   absolute addressing mode that admits 2 extension words + 1 word for JMP)




- This covers the addressing modes, but before moving on to the exercises, let me
  explain the different assembly directives you will find in the listings.


                      *** ASSEMBLY DIRECTIVES ***
                      ----------------------------

  You already know:

  - TEXT   : Resets the PC, placed at the beginning of the listing.

  - EQU    : Associates a numerical value with an address. (A Label)

  Here are some other directives:

  - END    : Indicates to the assembler that what follows this directive
             should no longer be assembled (thus ignored).
             Attention, it does not trigger the 'end' of the program.

  - DATA   : This directive delimits a DATA SEGMENT, the PC is reset in the same
             way as with 'text'.

             In the DATA SEGMENT, data (or datas) is defined.

             Then, the directives DC.B, DC.W or DC.L can be used:

    DC.B   : Allows placing constants (data) in memory as bytes.
             For example, a constant can be associated with an address, 
             the data must be separated by commas.

             Example:  LABEL     DC.B  0,1,6,3,11,46,$4F,%10110010
             ----
             Here, at the LABEL address, there is a BYTE (.B) that equals 0,
             at LABEL+1 there is a BYTE (.B) that equals 1...
             at LABEL+6 there is a BYTE (.B) that equals $4F, etc...

    DC.W   : Similar to DC.B except that here, Words are stored in memory.

    DC.L   : Similar to DC.W or DC.B except that here, Long Words are stored
             in memory.


  - BSS    : This directive also resets the PC.
             It delimits a BSS SEGMENT.

             In a BSS segment, space is reserved in memory in the form of
             BYTES, WORDS or LONG WORDS.

             Indeed, one cannot place data in memory if one does not reserve
             that portion of the memory!!!
             (except for specific cases that we will study)

             Then, the 'DS.suffix quantity' directive is used to reserve 
             space in memory without initializing it.


     DS.B  : Reserves a certain quantity of Bytes in memory.

             Example:  LABEL     DS.B   120     : at the LABEL address, there
             ----      is a sequence of 120 Bytes reserved. One can then place
                       data in it.


     DS.W  : Reserves a certain quantity of Words in memory.

     DS.L  : Reserves a certain quantity of Long Words in memory.




 - That's all, go do the exercises (file EXOS_1.DOC), there are loads of them, but after that, I hope there
   will no more problems (hopefully!!) with the addressing modes.

 - Then you'll come back to continue the lessons in the file:

   INSTRUC.DOC
   -----------


                            ------------------

Back to ASM_Tutorial