Pl NR

From Atari Wiki
Revision as of 21:44, 16 December 2023 by Olivier.jan (talk | contribs)
Jump to navigation Jump to search


                       ------------------------------
                              CHAPITRE nr° 2:
         
                       * PREMIERS PAS EN ASSEMBLEUR *
           
                       ------------------------------



              *** UTILISATION LOGICIELLE DE L'ASSEMBLEUR ***
              ----------------------------------------------

 -   Comme  nous l'avons vu dans le chapitre précédent, programmer en
     assembleur n'est possible qu'avec : un EDITEUR, un ASSEMBLEUR et
     un LINKER.

 1) l'EDITEUR:    .C'est l'EDITEUR qui permet la saisie de votre listing:
    ----------
                   Vous  écrirez  votre  programme grâce aux fonctions de
                   l'éditeur. L'éditeur sauvera et chargera vos listings.

                   Les fichiers sauvés sont des fichiers ASCII (tout com-
                   me les fichiers de ce livre digital) et peuvent être
                   modifiés à volonté avec l'éditeur.

                   Un tel fichier est nommé CODE SOURCE.

                   Les fonctions de l'éditeur varient avec l'utilitaire
                   (DEVPAC,METACOMCO,PROFIMAT...) et simplifient l'entrée
                   du texte (listing).

                  .Un fichier issu d'un éditeur ne peut pas être exécuté!

                   Il faudra d'abord l'ASSEMBLER puis le LINKER.


 2) l'ASSEMBLEUR .l'ASSEMBLAGE constitue la deuxième étape:
    ------------
                  Les codes ASCII (texte) du listing sonts traduits par
                  l'Assembleur et sont convertis (codés) en BINAIRE (le
                  binaire est reconnu directement par l'ordinateur,con-
                  trairement au texte ASCII)

                  Le fichier (listing) une fois traité (Assemblé) est
                  sauvé sur la disquette  sous le format d'un fichier
                  en BINAIRE appelé CODE OBJET.

3) le LINKER     .l'EDITION DE LIENS est la dernière étape:
   ---------
                  Le CODE OBJET est chargé et le LINKER intègrera les
                  MACROS INSTRUCTIONS qui constituent la bibliothèque
                  si le fichier SOURCE le demandait. -->

                                    -------------
Je m'explique:
--------------
  .En assembleur vous pouvez creér des MACRO-INSTRUCTIONS
   (voir chapitre précédent).

  .Une MACRO n'est rien d'autre qu'une nouvelle instruction (paramétrable)
   qui sera incluse par le LINKER chaque fois qu'il rencontrera son nom
   dans le CODE OBJET.

Un exp:
-------
  .Vous créez une MACRO qui affiche 'SALUT' sur l'écran:

   Cette MACRO délimite en réalité un PROGRAMME dont la fonction
   est d'afficher 'SALUT' sur l'écran et vous la nommez 'ECRIS':

             début de la Macro

   ECRIS     .
             .
             .                      le listing qui permet d'afficher
             .                      'SALUT' sur l'écran
             .

             Fin de la Macro  
  
   Chaque fois que le LINKER rencontrera 'ECRIS' (le nom de la MACRO) ,
   dans le CODE OBJET, il reécrira la portion de programme 'ECRIS' à la 
   place de la MACRO.

     .Une MACRO n'est donc pas un sous-programme, elle permet juste une
      une meilleur lisibilité dans le listing.

     .Une macro sera reécrite entièrement à chaque appel: On perd donc
      un peu plus de MEMOIRE , mais c'est bien plus rapide qu'un sous-
      programme.

     .Les Macros permettent une meilleur lisibilité du listing puisque
      Vous n'avez plus à taper la ROUTINE correspondant au nom de la
      Macro, le Linker s'en charge.

  .Vous pouvez donc vous créer une BIBLIOTHEQUE de MACROS ( c.à.d. des
   fichiers  définissant  des  MACROS ) pour les appeler quand vous en 
   aurrez besoin dans votre listing...

   Le LINKER s'occupe de charger les MACROS utilisées dans le listing
   (si le listing en contient...) et de les reécrires entièrement.

   Il suffira d'indiquer (au début du listing) le nom du fichier qui
   contient les MACROS utilisées, ou de définir les MACROS utilisées
   au début du listing.
                            (NOUS VERRONS COMMENT EN DETAIL ...)

  .Nous,nous créerons des MACROS pour les fonctions du GEM,de l'XBIOS,
   du BIOS et du VDI ( Des MACROS qui se chargent d'appeler les fonc-
   tions désirées en passant les paramètres nécessaires pour plus de
   rapidité et de convivialité )

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

                .le LINKER créera aussi la PAGE DE BASE, qui contient
                 des renseignements sur le prg indispensables au sys-
                 tème d'exploitation pour pouvoir charger et executer
                 le prg LINKE.
                 Voilà pourquoi le LINKAGE est indispensable mème si
                 le listing ne contient pas de Macros.
                 
                      (Je détaillerais quand je parlerais du GEMDOS)


                .Le fichier ainsi obtenu sera sauvé et pourra ètre 
                 executé.



 RESUME:
 ------
     * EDITEUR *              * ASSEMBLEUR *              * LINKER *

      |listing|    ------->    |code objet|   -------> |prg executable|





                    *** QUELQUES NOTIONS ELEMENTAIRES ***
                    -------------------------------------

Voilà quelques notions TRES IMPORTANTES:

1)  le BINAIRE: 
    -----------
 .         Habituellement, pour calculer, on utilise un système décimal,
  c.à.d. que ce système est composé de 10 chiffres: 0,1,2,3,4,5,6,7,8,9
  :C'est une BASE de 10.

  Si on désire exprimmer un ensemble dont la quantité dépasse 9: on aug-
  mente le chiffre d'une unité et on obtient un nombre:10,11,12,13,14...

 .Le système BINAIRE (ou de BASE 2),est composé de 2 chiffres: 0 et 1

   Ainsi, si on veut exprimmer un ensemble dont la quantité dépasse 1
   ( c.à.d. >1 en système décimal !! ) on augmente d'une unité.

Donc:
Voilà comment on compte en BINAIRE:0,1,10,11,100,101,111,1000,1001,1011...

.On SUPPOSERA que toute composante de la mémoire de l'ordi est représentée
 (ou codée) en BINaire.

.On nomme le 0 et le 1 du système BINaire présent dans les composantes de
 la structure de l'ordi par BIT.

.Un BIT peut ètre nul (ou éteint):0    OU     activé (ou encore allumé):1
                                       --
.Le BIT est donc la plus petite structure modifiable et reconnaissable 
 par l'ordi.

.On définit par OCTET un groupe de 8 BITS. (L'OCTET est aussi appelé BYTE 
 en Anglais, ne le confondez pas avec 'bit' !)

.On définit par  MOT un groupe de 2 OCTETS (donc de 16 BITS)

.On définit par LONG MOT un groupe de 2 MOTS (donc de 4 OCTETS ou 32 BITS)

.Ces regroupements sont arbitraires et conscernent des BITS consécutifs
 (qui se suivent) en mémoire.

 CONSEQUENCES: Les composantes internes de l'ordi. peuvent être exprimées
 ------------ en BITS,OCTETS,MOTS ou LONGS MOTS.

RESUME:
-------
-  Un BIT prend soit la valeur 1 (activé) soit la valeur 0 (éteind)
      ---
-  Un OCTET est un groupe de 8 BITS consécutifs en mémoire
      -----
-  Un MOT est un groupe de 2 OCTETS consécutifs en mémoire
      ---
-  Un LONG MOT est un groupe de 2 MOTS consécutifs en mémoire
      --------
Pour schématiser, on pourrait dire que la mémoire de l'ordi. est composée
d'une multitude de petites cases (BITS) pouvant prendre soit 1 soit 0 com-
me valeurs suivant les actions du Microprocesseur et pouvant ètres regrou-
pées (arbitrairement) sous la forme d'OCTETS, de MOTS ou de LONGS MOTS.

EXP:
---         {    0                                est un BIT
extraits de {    01011101                         est un OCTET, ou 8 BITS
  mémoire   {    0101110111010110                 est un MOT,  ou 16 BITS
            {    01011101110101101000100100101101 est un LONG MOT,ou 32 B


2) L'HEXADECIMAL:
   -------------
 .l'HEXADECIMAL est un système de BASE 16,les 16 composantes de ce système
  sont:0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F

  Ainsi, pour exprimer un ensemble dont la quantité dépasse F (soit 16 en
  BASE de 10), on change d'unité: 0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F,10,11,12,
  ,13,14,15,16,17,18,19,1A,1B,1C,1D,1E,1F,20,21,22...

  Comme vous pouvez le constater, la véritable utilité de ce système est
  qu'un grand nombre est représenté par un minimum de chiffres.


 .Un OCTET est représenté en HEXA. par 2 chiffres 

 .Un MOT est représenté en HEXA. par 4 chiffres

 .Un LONG MOT est représenté en HEXA. par 8 chiffres 


 3) NOTATIONS:
    ----------
-      Dans un listing en ASS. ,les chiffres codés  en BINaire sont 
  représentés avec le préfixe ' % ', ceux codés en HEXAdécimal avec
  le préfixe ' $ '.

  ( L'utilisation de la BASE de 10 n'a pas besoin d'ètre indiquée )

  Après le Linkage, tous les chiffres seront automatiquement codés en
  Hexadécimal.

EXP:           %01001011   est un chiffre codé en BINAIRE (et un OCTET)
----           $1F0A       est un chiffre codé en HEXA.   (et un MOT)
                101001     est un chiffre codé en DECIMAL !


 4) REMARQUES:
    ----------
 -  Le BIT le plus à gauche d'un OCTET,d'un MOT,d'un LONG MOT est appellé
    M.S.B ( Most Significant Bit ) ou Bit de plus fort poids.

 -  C'est ce bit qui permet de signer ( positif / négatif ) un nombre.
    Il est activé pour un nombre négatif.

 -  Il n'est utilisé que pour signer un nombre !

  EXP:  $FFFFFFFF est un L-M qui vaut -1 en décimal
  ----  %1111111111111111 est un MOT qui vaut -1 en décimal
        %11111110 est un OCTET qui vaut -2 en décimal et
        %00000010 en est un qui vaut 2:Pour inverser le signe de l'OCTET,
         on a donc 'prolongé' le 1 le plus à gauche jusqu'au MSB.

  :Exemples très théoriques, pas de panique,ce n'est pas vraiment utile
   en pratique (et même franchement inutile, je vous rassure...) car il
   existe des instructions qui font toutes sortes d'opérations sur les
   BITS,OCTETS,MOTS et L-M... (et personne ne vous oblige à travailler en
   système Binaire!)

  - D'après nos définitions: (le MSB n'est utilisé que pour signer le bit,
                              l'octet,le mot ou le long-mot)

             donc:            *         -2^7  ó OCTET < 2^7
                                        -128  ó OCTET < 128

                              *        -2^15  ó  MOT  < 2^15
                                       -32768 ó  MOT  < 32768

                              *        -2^31  ó  L-M  < 2^31
                                  -2147483648 ó  L-M  < 2147483648

  ça par contre, c'est à retenir: Les débordements (OCTET trop grand...)
  provoquent des erreurs.

 5) RECAPITULATION:
     ---------------
 .Une composante de la structure de l'ordi. : REGISTRE,VARIABLE... (termes
  expliqués bientot) peut prendre la forme de BIT,OCTET,MOT ou LONG MOT.

  En théorie... Nous étudierons les exceptions:Le choix est plus limité en
                réalité.


    CONSEQUENCES:   .Une VARIABLE définie en tant que MOT ne pourra donc
    -------------    pas avoir une valeur supérieure à 32768. (par exp.)

              NB:    Cette variable ne pourra qu'ètre un Long Mot (Si sa
              ---    valeur peut être contenue dans un L-M , sinon cela
                     provoquerait une erreur puisque l'ordi ne reconnait
                     pas de composante dont la quantité depasse le L-M.)
                     (en théorie...)

       REMARQUES:   .Une Variable pouvant ètre contenue dans un OCTET,
       ----------    donc dont la valeur est <128 peut aussi ètre con-
                     tenue dans un MOT ou un L-M.

                     Mais il faut faire attention à ce que la composante
                     (ici la variable) puisse ètre définie sur un MOT ou
                     un L-M (Dans cet exemple précis, c'est possible)

                    .Il faudra donc pour chaque composante de la structure
                     interne de l'ordi. indiquer les différentes formes
                     qu'elle peut prendre (BIT,OCTET,MOT,L-M...).

                     Nous le feront avec précision.

  C'est pour cela qu'il faudra savoir les différentes formes que peut 
  prendre ce que nous utilisons pour programmer (Registres,variables...)
  et aussi par quoi sont définit ces formes (BIT,OCTET...).
  Voilà pourquoi l'Assembleur est très stricte dans sa programmation.


6) IMPORTANT:
   ----------

Les ensembles tels que les OCTETS,MOTS,L-M sont composés de BITS,ces BITS
sont numérotés ainsi (dans les OCTETS,MOT,L-M,REGISTRES,VARIABLES...):

                        De la DROITE vers la GAUCHE.

     31 30 .  .  .     .  .  . 15  .  .  .  9  8  7  6  5  4  3  2  1  0
    [*][ ][.][.][.][ ][ ][ ][ ][*][.][.][.][ ][ ][*][ ][ ][ ][ ][ ][ ][*]

 - Un OCTET est donc numéroté de la droite vers la gauche de 0 à 7

 - Un MOT , de 0 à 15

 - Un L-M , de 0 à 31

 - Le BIT 0 est le bit de PLUS FAIBLE POIDS (ou LSB:Least significant Bit)

 - Le BIT 7 (15 pour un MOT,31 pour un L-M) est le bit de POIDS le plus
   FORT (ou MSB)

   AINSI:
   ------                     <-----------  poids FORT

                     31<-- ...[][][][][][][][][][][][][]...  -->0

                               poids FAIBLE ---------->

   DONC: Un MOT est composé de 2 OCTETS, un de poids FAIBLE (bits 0 à 7) et
   ----- un de poids FORT: (bits 8 à 15)

         Un L-M est composé de 2 MOTS, un de poids FAIBLE (bits 0 à 15) et
         un de poids FORT (bits 16 à 31)

                           CETTE NOTION EST FONDAMENTALE 
                           -----------------------------


                              *** LA MEMOIRE ***
                              ------------------

 - On admettra que la mémoire est une suite de nombres codés en BINaire.

    :Nous savons maintenant que ces nombres peuvent ètres regrouppés en
     OCTETS,MOTS,L-M.

 -      La programmation en assembleur permet de changer le contenu 
        de la mémoire.

.La mémoire est changée quand l'ordinateur effectue une tàche (un calcul,
 une recherche quelconque...).
 Dans ce cas, l'ordi. s'occupe  d'ordonner sa mémoire , c'est en fonction
 de cet ordre que telle ou telle action se produit,l'utilisateur n'inter-
 vient donc pas: C'est ce qui se passe à chaque instant, un ordinateur 
 n'est donc jamais au repos (il verifie si on change de disquette,efface
 l'ecran cinquante fois par seconde).

. La mémoire de l'ordi. peut aussi être changée par l'utilisateur,c'est le
 but de la programmation.La conséquence en est un état prévu (programmé)
 de la mémoire,donc telle ou telle action est effectuée.
 Ceci est possible en utilisant des instructions propres au langage uti-
 lisé ou en modifiant directement une portion de la mémoire.Cette derni-
 ère opération s'effectue très facilement en ASSembleur et avec une pré-
 cision de l'ordre du BIT.
 On peut donc Déplacer un OCTET,un MOT, un L-M (qu'on aura pu définir)
 dans la mémoire.(là o— c'est possible...)

 Pour se repérer dans la vaste mémoire de notre ordi. , on a découpé la
 mémoire et on a nommé chaque portion de la mémoire par une ADRESSE (com-
 me pour des Adresses dans une rue...)

 Théoriquement, il serait possible de mettre un BIT,OCTET,MOT ou L-M à
 n'importe quelle ADRESSE, mais en réalité ceci n'est pas possible.

     - L'utilisateur n'a accès qu'à une partie de la mémoire.
       (nous verrons laquelle)

     - Il faut tenir compte de la parité et de l'imparité des ADRESSES:
       On ne peut pas mettre n'importe quoi à n'importe quelle adresse.

 EN EFFET: Si on SCHEMATISE la structure de la mémoire, celle-ci ressemble 
 --------  à une bande de longueur limitée (début et fin) et d'une LAR-
           GEUR de 16 BITS, dont les différentes parties sont numérotées 
           ADRESSEES) tout les 8 BITS. (à chaque OCTET)




                             etc...

              bits: 15        7        0
              ----- .|        |        |
                  x-2|--------|--------|
        |           x|10001011|--------|   OCTET :10001011 à l'adresse x
        |         x+2|--------|10001101|   OCTET :10001101 en x+3 octets
        |         x+4|--------|--------|
        |         x+6|00101100|10110011|   MOT  :0010110010110011
        |           .|--------|--------|         en x+6 octets
       \|/          .|--------|--------|
        '        x+12|11011111|01110100|   L-M  :110111110111010001011011-
     SENS des       .|01011011|01110100|         01110100
     adresses       .|--------|--------|         en x+12 octets
    CROISSANTES     .|--------|--------|
    -----------  x+20|--------|-------1|   BIT  :1  à l'adresse x+21 octets
        |           .|--------|--------|
        |           .|OCT FORT| FAIBLE |
       \|/          .|--------| ------ |
        '           15        7        0

                             ETC...

                          +-------+
                          |MEMOIRE| : ( Exemple d'organisation )
                          +-------+


- Observez bien cet exemple, il est très simple à comprendre et ce schéma
  devra être dans votre tète à chaque fois que vous programmerez en ASS.

- Vous pouvez constater que:

             * La mémoire est adressable au niveau de l'octet *
               ----------------------------------------------
      *    :Entre 2 adresses différentes X et X+1 ou X-1, il y a   *
      *     8 BITS ou un OCTET.                                    *

                     bits n° 7  6  5  4  3  2  1  0

            X-1  ---------->
                            [ ][ ][ ][ ][ ][ ][ ][ ]
            X    ---------->
                            [ ][ ][ ][ ][ ][ ][ ][ ]
            X+1  ---------->
                            [ ][ ][ ][ ][ ][ ][ ][ ]


       * La mémoire peut ètre représentée comme un PUITS dans lequel on
         JETTE des données:BITS,OCTET,MOTS,L-M:

         La largeur de ce puit est d'un MOT (soit 16 Bits)
         La profondeur dépend de la taille de la mémoire.

         Le but du jeu:  Jetter nos données dans le puit sans déformer
                         les données.

   c.à.d: Si vous y jettez un MOT: 1010101110110110 (=2 octets,1 de
          poids fort (à droite) et un de poids faible (à gauche) ) à
          une adresse x paire.


                      1010101110110110
                             |
                            \|/

                    |--------|--------|
  ADRESSES PAIRES   |--------|--------|  ADRESSES IMPAIRES
  ---------------   |--------|--------|  -----------------
           bit nr° 15        7        0

                   
                       vous obtenez:

  ADRESSES PAIRES  x|10101011|10110110|  ADRESSES IMPAIRES
  ---------------x+2|--------|--------|  -----------------
                    |--------|--------|
           bit nr° 15        7        0

               - Le MOT a été posé à l'adresse x (PAIRE)

               . L'Oct de poids FORT est à l'adresse x (PAIRE)
               . L'Oct de poids FAIBLE à l'adresse x+1 (IMPAIRE)


            par contre, si vous jetez ce mot à une adresse impaire:



                               10101011
                      10110110
                              |
                             \|/

                     |--------|--------|
  ADRESSES PAIRES    |--------|--------|    ADRESSES IMPAIRES
  ---------------    |--------|--------|    -----------------
            bit nr° 15        7        0

                   
                   
                        vous obtenez:

                  x-3|--------|--------|
  ADRESSES PAIRES x-1|--------|10101011|x   ADRESSES IMPAIRES
  ---------------    |10110110|--------|x+2 -----------------
                     |--------|--------|
            bit nr° 15        7        0


               - Le MOT a été posé à l'adresse x (IMPAIRE)

               . L'Oct de poids FORT est à une adresse IMPAIRE :x
               . L'Oct de poids FAIBLE à une adresse PAIRE     :x+1

            Dans ce cas, on ne respecte plus les règles de notre 'jeu'
            Si on devait jeter un autre MOT à l'adresse x-3 dans notre
            puits, son Oct FORT ne pourrait pas se maintenir et dégrin-
            golerait en x-1!

            ATTENTION,en réalité ceci ne se produirait pas, Je simplifie
            seulement mon explication...

     En fait, pour pouvoir déplacer (poser) des MOTS dans la mémoire, il
     faut veiller à ce que l'adresse de destination soit PAIRE!

            Pour notre exemple, il faut donc poser le MOT sous cette
            forme dans la mémoire (dans notre 'puits')

                        +----------------+
                        |1010101110110110|
                        +----------------+
                                 |
                                \|/

                        |--------|--------|
  ADRESSES PAIRES      x|10101011|10110110|x+1   ADRESSES IMPAIRES
  ---------------       |--------|--------|      -----------------
               bit nr° 15        7        0

                  .L'Oct de poids FORT (10101011) est à l'adresse x
                   qui est PAIRE

                  .L'Oct de poids FAIBLE (10110110) est à l'adresse x+1
                   qui est IMPAIRE


            * Il en est de mème lorsqu'il s'agit d'un L-M:
              --------------------------------------------

       Voilà comment poser un L-M, là aussi il faut que l'adresse de
       destination soit PAIRE, pour  éviter les mémes  complications
       que dans notre exemple précédent.



                        +-----------------+
                        |1110001001100100-|
                        |1010110011010001 |
                        +-----------------+
                                 |
                                \|/

                        |--------|--------|
  ADRESSES PAIRES       |--------|--------|      ADRESSES IMPAIRES
  ---------------       |--------|--------|      -----------------
                       x|11100010|01100100|x+1
                     x+2|10101100|11010001|x+3
                        |--------|--------|
               bit nr° 15        7        0

                  .Le MOT de poids FORT (1110001001100100) est à
                   l'adresse x ,qui est PAIRE

                  .Le MOT de poids FAIBLE (1010110011010001) est à
                   l'adresse x+2 ,qui est PAIRE


            * Pour un OCTET ou un BIT
              -----------------------

                 - La parité n'a plus d'importance!

      Ainsi, pour un Octet: on a:
             --------------

                      01000110
                          |
                         \|/

                     |--------|--------|
  ADRESSES PAIRES   x|01000110|--------|x+1   ADRESSES IMPAIRES
  ---------------    |--------|--------|      -----------------
            bit nr° 15        7        0


                     .L'Oct (01000110) est à une adresse x ,PAIRE

           OU:
           --
                              01000110
                                  |
                                 \|/

                     |--------|--------|
  ADRESSES PAIRES x-1|--------|01000110|x     ADRESSES IMPAIRES
  ---------------    |--------|--------|      -----------------
            bit nr° 15        7        0


                     .L'Oct (01000110) est à une adresse x ,IMPAIRE


             Pour un BIT: on a
             ------------


                         0
                         |
                        \|/

                     |--------|--------|
  ADRESSES PAIRES   x|-------0|--------|x+1   ADRESSES IMPAIRES
  ---------------    |--------|--------|      -----------------
            bit nr° 15        7        0


                     .Le BIT (0) est à une adresse x ,PAIRE

          OU:
          ---


                                  0
                                  |
                                 \|/

                     |--------|--------|
  ADRESSES PAIRES x-1| -------|-------0|x     ADRESSES IMPAIRES
  ---------------    |--------|--------|      -----------------
            bit nr° 15        7        0


                     .Le BIT (0) est à une adresse x ,IMPAIRE




                          *** RECAPITULATION ***
                          ----------------------

 * Un BIT peut ètre, soit à une adresse PAIRE, soit à une adresse IMPAIRE
      ---                               -----                     -------
 * Un OCTET peut ètre, soit à une adresse PAIRE, soit une adresse IMPAIRE
      -----                               -----                   -------
 * Un MOT est toujours situé à une adresse PAIRE en mémoire
      ---                                  -----
 * Un L-M est toujours situé à une adresse PAIRE en mémoire
      ---                                  -----
   ( Le non respect de cette règle entraine un 'plantage' de l'ordi ! )

 * STRUCTURE de la MEMOIRE:
                   --------


                            etc...
              bits: 15        7        0
              ----- .|        |        |
                  x-2|--------|--------|x-1
        |           x|00001011|--------|  OCTET :00001011 à l'adresse x
        |         x+2|--------|10110010|  OCTET :10110010 en x+3 octets
        |         x+4|--------|--------|         (impaire)
        |         x+6|10001011|10110110|  MOT  :1000101110110110
        |           .|--------|--------|        en x+6 octets (paire)
       \|/          .|--------|--------|
        '        x+12|01101100|00000000|  L-M  :011011000000000010111010-
     SENS des       .|10111010|01110111|        01110111
     adresses       .|--------|--------|        en x+12 octets (paire)
    CROISSANTES     .|--------|--------|
    -----------  x+20|--------|-------1|  BIT  :1  à l'adresse x+21 octets
        |           .|--------|--------|           (impaire)
        |           .|oct FORT| FAIBLE |
       \|/          .|--------| ------ |
        '           15        7        0
                     |       etc...    |
 Adresses PAIRES     |        |        |     Adresses IMPAIRES
 ---------------                             -----------------
                          +-------+
                          |MEMOIRE|
                          +-------+

              Exemple d'organisation de la mémoire.
              -------------------------------------
                 (Octets,Mots,L-M,Bits fictifs)





                   *** ORGANISATION DE LA MEMOIRE ***
                   ----------------------------------

- On distingue: .L'espace programme, qui contient les instructions de vos
                 programmes codées en BINaire.

                .L'espace données, qui contient les données du prg et les
                 zones de la mémoire que vous avez initalisé. (en BIN)

                .Ces 2 zones sont dans la mémoire vive (RAM), on ne peut
                 pas écrire sur la mémoire morte (ROM) car elle contient
                 tous les renseignements dont l'ordi a besoin pour fonc-
                 tionner correctement.
                 La RAM est la mémoire disponible en écriture au progra-
                 mmeur (elle peut bien sur aussi être effacée.)

                 On dispose d'environ 512 Ko de mémoire vive sur un 520ST
                 (un Kilo Octet=1024 Octets.) et d'1 Méga Octet soit 1024
                 Ko sur un 1040ST.   




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

- Vous voilà prêts à présent à commencer la programmation proprement dite:
  retenez bien tout ce qui a été dit ici (notez le quelquepart si vous le
  jugez utile), relisez encore une fois  si la tête vous tourne, car dans
  le prochain chapitre, les choses sérieuses commencent.





     PIECHOCKI Laurent
     8,impasse Bellevue                           Suite dans DEBUTS.DOC
     57980 TENTELING                                         ----------


Back to ASM_Tutorial