Pl COURS.DOC: Difference between revisions

From Atari Wiki
Jump to navigation Jump to search
(Olivier.jan moved page Pl COURS.DOC to Pl COURS.DOC/fr: Renaming for language version)
Tag: New redirect
 
(Replacing content of with translated version)
Tag: Removed redirect
Line 1: Line 1:
−
#REDIRECT [[Pl COURS.DOC/fr]]
 +
{{Languages|Pl COURS.DOC}}
  +
  +
... 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]]
  +
[[Category: ASSEMBLEUR 68000 sur ATARI ST Part 1 ]]

Revision as of 01:01, 17 December 2023

Languages: 

English  • français

... 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

Retrieved from ‘https://www.atari-wiki.com/index.php?title=Pl_COURS.DOC&oldid=1000000887’