COURS 3.TXT/fr

   ******************************************************************
   *                                                                *
   *               COURS D'ASSEMBLEUR 68000 SUR ATARI ST            *
   *                                                                *
   *                   par Le F�roce Lapin (from 44E)               *
   *                                                                *
   *                           Cours num�ro 3                       *
   *                                                                *
   ******************************************************************

   Si  vous  avez correctement �tudi� les deux premi�res le�ons, vous
   devez  normalement  avoir  un peu plus d'ordre qu'au d�part, et le
   binaire  et  l'hexad�cimal  ne  doivent  plus avoir de secret pour
   vous.

   Avant  de  commencer  je dois vous rappeler quelque chose d'essen-
   tiel: Il  est  tentant de r�fl�chir en chiffre alors que bien sou-
   vent  il  serait  pr�f�rable  de  se  souvenir qu'un chiffre n'est
   qu'une  suite de bits. Ainsi imaginons un jeu dans lequel vous de-
   vez  coder  des donn�es relatives � des personnages. En lisant ces
   donn�es  vous  saurez  de quel personnage il s'agit, et combien il
   lui  reste  de  point de vie. Admettons qu'il y ait 4 personnages.
   Combien  faut-il  de bits pour compter de 0 � 3 (c'est-�-dire pour
   avoir  4 possibilit�s) seulement 2 bits.   Mes personnages peuvent
   avoir, au  maximum, 63 points  de  vie (de 0 � 63 car � 0 ils sont
   morts), il  me faut donc 6 bits pour coder cette vitalit�. Je peux
   donc avoir sur un seul byte (octet) 2 choses totalement diff�rent-
   es: avec  les bits 0 et 1 (le bit de droite c'est le bit 0, le bit
   le  plus  �  gauche pour un byte est donc le 7) je code le type de
   mon personnage, et avec les bits 2 � 7 sa vitalit�.

   Ainsi  le chiffre 210 en lui m�me ne veut rien dire. C'est le fait
   de  le mettre en binaire: 11010010 et de penser en regroupement de
   bits  qui  va le rendre plus clair. S�parons les 2 bits de droite:
   10 ce qui fait 3 en d�cimal, je suis donc en pr�sence d'un person-
   nage de type 3.

   Pr�levons  maintenant  les  6 bits  de  gauche: 110100 et  conver-
   tissons.

   Nous  obtenons 52. Nous sommes donc en pr�sence d'un personnage de
   type 3, avec 52 points de vitalit�.

     Ceci  devant  maintenant  �tre  clair, passons � une explication
   succinte concernant la m�moire, avant d'aborder notre premier pro-
   gramme.

   STRUCTURE DE LA MEMOIRE

   La  m�moire, c'est  un  tube, tr�s  fin et tr�s long. Il nous faut
   distinguer 2 choses:

   1) Ce qu'il y a dans le tube.
   2) La distance par rapport au d�but du tube.

   ATTENTION, cette  notion  doit �tre parfaitement comprise car elle
   est perp�tuellement source d'erreur.
   Gr�ce  �  la  distance, nous  pourrons retrouver facilement ce que
   nous avons mis dans le tube. Cette distance est appel� 'adresse'.

   Le tube a un diam�tre de 1 byte (octet). Lorsque je vais parler de
   l'adresse  $6F00 (28416 en  d�cimal), c'est  un emplacement. A cet
   emplacement je peux mettre un byte.  Si la donn�e que je veux met-
   tre  tiens sur un word (donc 2 bytes car 1 word c'est bien 2 bytes
   accol�s), cette  donn�e  occupera  l'adresse  $6F00  et  l'adresse
   $6F01.

   Imaginons  que  je  charge  une  image  (32000 octets) � partir de
   l'adresse $12C52. Je vais donc boucler 32000 fois pour d�poser mon
   image, en augmentant � chaque fois mon adresse.

   Imaginons  maintenant  que je veuille noter cette adresse. Je vais
   par exemple la noter � l'adresse $6F00.

   Donc  si  je me prom�ne le long du tube jusqu'� l'adresse $6F00 et
   que  je  regarde  � ce niveau l� dans le tube, j'y vois le chiffre
   $12C52 cod� sur un long mot (les adresses sont cod�s sur des longs
   mots). Ce chiffre occupe donc 4 emplacements de tube correspondant
   �  $6F00, $6F01, $6F02 ,$6F03. Or, que  repr�sente ce chiffre: Une
   adresse, celle de mon image!!!! J'esp�re que c'est bien clair...

   Un  programme, c'est  donc  pour le 68000 une suite de lectures du
   contenu du tube. Il va y trouver des chiffres qu'il va interpr�ter
   comme des ordres (revoir le cours 2). Gr�ce � ces ordres, nous al-
   lons  lui  dire par exemple de continuer la lecture � un autre en-
   droit de ce tube, de revenir en arri�re, de pr�lever le contenu du
   tube  et d'aller le d�poser autre part (toujours dans ce m�me tube
   bien  s�r) etc... Pour savoir � quel endroit le 68000 est en train
   de  lire  les  ordres  qu'il ex�cute, il y a un compteur. Comme ce
   compteur sert pour le programme, il est appel� Program Counter, en
   abr�g� PC.

   Le  68000 a un PC sur 24 bits, c'est-�-dire qu'il peut prendre des
   valeurs  comprises  entre 0 et 16777215. Comme chaque valeur du PC
   correspond � une adresse et qu'en face de cette adresse (donc dans
   le  tube) on  ne peut mettre qu'un octet, une machine �quip�e d'un
   68000 peut  donc  travailler  avec 16777215 octets, ce qui fait 16
   M�ga. A  titre  indicatif, le  80286 de  chez Intel qui �quipe les
   'gros' compatibles  PC, ne  comporte  qu'un  PC sur 20 bits ce qui
   restreint son espace � 1 m�ga...

   A noter que la m�moire est destin�e � recevoir des octets mais que
   ce  que  repr�sente  ces  octets  (texte, programme, image...) n'a
   strictement aucune importance.

   PREMIER PROGRAMME
   Nous  allons  tout  de  suite illustrer notre propos. Nous lan�ons
   donc  GENST. Ceux  qui  ont  un �cran couleur devront le lancer en
   moyenne  r�solution, c'est  pr�f�rable pour un meilleur confort de
   travail.

   M�me  si  vous  avez  un 520, choisissez dans les 'pr�f�rences' de
   GENST (dans le menu 'Options') un chargement automatique de MONST
   (Load  MONST 'YES') mettez un Tab Setting de 11 et auto-indent sur
   YES.

   Si  MONST  est  d�j� charg� son option dans le menu 'program' doit
   �tre  disponible, sinon  elle  est en gris. Si c'est le cas, apr�s
   avoir sauv� les pr�f�rences, quitter GENST et relancez le.

   Maintenant, nous allons r�aliser le programme suivant:

       Met le chiffre $12345678 dans le registre D0
       Met le chiffre $00001012 dans le registre D1
       Additionne le registre D0 avec le registre D1

   Tout  d'abord  il  faut  savoir  que ces ordres seront mis dans le
   tube, et qu'il nous faudra parfois rep�rer ces endroits. Pour cela
   nous utiliserons des �tiquettes, que nous poserons � c�t� du tube.
   Ces �tiquettes (ou Label en Anglais) sont � inscrire tout � gauche
   dans notre listing alors que les instructions (ce qui est � mettre
   DANS  le  tube) seront  inscrites apr�s un espace ou mieux pour la
   lisibilit�, apr�s une tabulation.

   Ainsi notre programme devient:
          MOVE.L     #$12345678,D0
          MOVE.L     #$00001012,D1
          ADD.L      D0,D1

   Remarquer  le  signe  # avant les chiffres. Le signe $ indique que
   ces  chiffres sont inscrits en hexad�cimal. Le signe # indique que
   c'est la valeur $12345678 que nous voulons mettre dans D0.

   Si  nous  avions  fait  MOVE.L   $12345678,D0,  c'est la valeur se
   trouvant � l'adresse $12345678 que nous aurions mis en D0.

   Pourquoi  y a t-il .L apr�s les MOVE et le ADD ? Nous verrons cela
   dans quelques minutes.

   Pour le moment assemblons en maintenant appuy� [ALTERNATE] puis en
   appuyant sur A.

   Normalement, tout  s'est bien pass� ou alors c'est que vous n'avez
   pas scrupuleusement recopi� ce 'programme'. 

   Maintenant,  d�buggons   notre  programme,  en  maintenant  appuy�
   [ALTERNATE] et en appuyant sur D.

   Hop, nous nous retrouvons dans MONST qui, �tant appel� � partir de
   GENST, a automatiquement charg� notre programme.

   Jetons tout d'abord un coup d'oeil � ce ramassis de chiffre...

   En haut nous retrouvons nos registres de donn�es D0 � D7 ainsi que
   nos  registres  d'adresses A0 � A7 avec en prime A7'. Sous les re-
   gistres  de donn�es, nous voyons SR et en dessous PC. Nous pouvons
   remarquer  que  PC nous montre une adresse et la premi�re ligne de
   notre programme. Le PC indique donc ce qui va �tre ex�cut�.

   La  fen�tre  du  dessous (num�ro 2) montre notre programme. Sur la
   gauche  de  cette fen�tre nous voyons les adresses. Symboliquement
   nous pouvons dire que la partie droite de cette fen�tre montre nos
   instructions dans le tube et que les chiffres de gauche nous indi-
   que l'endroit, l'adresse par rapport au d�but du tube.

   La  fen�tre de droite (la 3) donne en fait la m�me chose que la 2,
   mais  avec  la vision du 68000. Nous avions vu dans le cours 2 que
   pour  la  machine  notre  suite  d'ordres  n'�tait qu'une suite de
   chiffres.

   Lorsque  nous  avons  assembl�, l'assembleur a simplement converti
   ligne par ligne notre programme en chiffres.

   Normalement dans la fen�tre 2 vous devez voir notre programme avec
   en  face  de  la premi�re instruction, une petite fl�che. Regardez
   l'adresse de cette instruction (c'est-�-dire le chiffre de gauche,
   qui indique a quel endroit dans le tube se trouve cet ordre). Avec
   un 1040 sous TOS 1.4, cela tourne autour de $61BF0.

   NOTE: Le 68000 permet � un programme de se placer n'importe o�.
   Sur  certains  micro-processeurs  les programmes doivent imp�rati-
   vement  tous  se placer au m�me endroit. Pour nous ce n'est pas le
   cas, ce  qui  explique  que si mon programme est en $61BF0 il n'en
   est pas forcement de m�me pour vous: c'est normal.

   Regardez maintenant la fen�tre 3 et cherchez-y la m�me adresse que
   celle  que  vous  avez lue dans la fen�tre 2 en face de notre pre-
   mi�re ligne de programme. Normalement si vous n'avez touch� � rien
   cette adresse doit normalement �tre la premi�re.

   Vous  devez  y voir 203C12345678. C'est ainsi que le micro-proces-
   seur re�oit MOVE.L #$12345678,D0!!!

   Retournons  sur la fen�tre 2. Notons l'adresse de la seconde ligne
   de  notre  programme  et  soustrayons ce chiffre � l'adresse de la
   premi�re ligne. Nous obtenons 6. Nous en d�duisons donc que :

   MOVE.L   #$12345678,D0  occupe 6 octets en m�moire.

   Faisons  maintenant  avancer  notre programme. Pour cela maintenez
   enfonc�  [CONTROL]  et  appuyez une fois sur Z. La petite fl�che a
   saut�  sur la seconde ligne, cette m�me ligne est maintenant indi-
   qu�e  par le PC et notre registre D0 contient maintenant la valeur
   $12345678. MONST  indique  tous  les chiffres en hexad�cimal, vous
   commencez � comprendre l'int�r�t de la calculatrice...

   Continuons  en refaisant Control+Z. C'est maintenant la ligne 3 de
   notre  programme  qui  est  indiqu�e par le PC tandis que D1 s'est
   trouv� rempli par $00001012.

   Continuons  avec Control+Z. L'addition entre D0 et D1 s'est effec-
   tu�e. Comme  nous  l'avions  vu  dans le cours 2, les possibilit�s
   sont  minimes  car  le  r�sultat a �cras� l'ancienne valeur de D1.
   Pour  r�aliser D0+D1=D2 il aurait d'abord fallu transf�rer D1 dans
   D2 puis faire ADD.L  D0,D2.

   Dans notre cas, D1 contient maintenant la valeur $1234668A.

   Notre  programme  n'ayant  pas  v�ritablement  de fin, quittons le
   artificiellement en tapant Control+C. 


   SECOND PROGRAMME

   Effacer le premier programme (alternate C) et tapez le suivant:

          MOVE.L     #$12345678,D0
          MOVE.W     D0,D1
          MOVE.B     D1,D2

   Nous  avons  vu  dans  Monst que D0-D7 �taient des registres assez
   grands. Nous avons r�ussi � mettre $12345678 dans D0, ce qui donne
   quand  m�me  305419896 en d�cimal! En effet le 68000 est un micro-
   processeur  16/32 bits  ce  qui fait que ces registres ne sont pas
   cod�s sur 16 bits mais sur 32.

   32 bits, cela  fait  un  long  mot (Long Word). Dans notre premier
   programme, nous voulions que l'instruction MOVE agisse sur tout le
   registre  donc  sur  un  long mot, c'est pour cela que nous avions
   pr�cis� .L apr�s le move.

   NOTE: Le vocabulaire est tr�s important et demande un petit effort
   au  d�but. Ainsi  MOVE.L ne veut rien dire. Il convient de lire ce
   mn�monique  (c'est  ainsi  que sont appel� les instructions assem-
   bleurs) MOVE  LONG. D'ailleurs  l'appellation  mn�monique  (qui  a
   rapport  avec  la m�moire, qui sert � aider la m�moire) est � rap-
   procher  de  mn�motechnique  (capable  d'aider  la m�moire par des
   moyens  d'association  mentale  qui facilitent l'acquisition et la
   restitution des souvenirs /CF dictionnaire Le Robert). Autant donc
   lire  les  instructions en Anglais ce qui facilitera grandement la
   compr�hension.

   Puisque  notre  registre  D0 (comme les autres d'ailleurs) et cod�
   sur  un  long  mot, il contient donc 2 words c�te-�-c�te. Pour les
   distinguer  nous appellerons celui de gauche word de poids fort et
   celui  de droite word de poids faible. Chacun de ces words est lui
   m�me  compos�  de  2 bytes, celui de gauche �tant de poids fort et
   celui  de  droite de poids faible. De poids faible car les change-
   ment qu'il peut apporter � la totalit� du nombre sont faible alors
   que les donn�es de gauche (donc de poids fort) y apportent des va-
   riations importantes.


   Assemblons notre programme et d�buggons.

   Ex�cutons  la  premi�re ligne. Le r�sultat est le m�me que pour le
   premier programme: le PC indique la seconde ligne, tandis que D0 �
   re�u la valeur $12345678.

   Maintenant ex�cutons la seconde ligne. Que dit-elle ?
   MOVE.W   D0,D1

   C'est-�-dire  d�placer  le  contenu  de D0 pour le mettre dans D1.
   Mais  attention, le d�placement doit se faire sur un word (pr�cis�
   par .W apr�s le move. Cela se lit MOVE WORD). Or les op�rations se
   font  toujours  sur  le  poids faible. Le MOVE va donc pr�lever le
   word  de  poids  faible de D0 pour le mettre dans le word de poids
   faible de D1. Celui-ci va donc recevoir $5678. 

   Continuons  en  ex�cutant  la  troisi�me  ligne. Celle-ci demande:
   MOVE.B   D1,D2       (move byte d1 d2)

   Donc transfert du byte de poids faible de D1 vers le byte de poids
   faible  de  D2. Regarder  bien les registres et les valeurs qu'ils
   re�oivent!

   Quittez maintenant le programme avec CONTROL+C


   TROISIEME PROGRAMME

          MOVE.L     #$12345678,D0
          MOVE.L     #$AAAAAAAA,D1
          MOVE.W     D0,D1
          SWAP       D0
          MOVE.W     D0,D2

   On  efface  le  programme pr�c�dent, on tape celui-ci, on assemble
   puis on d�bugue. L'ex�cution de la premi�re et de la seconde ligne
   ne doivent plus poser de probl�me.

   Nous devons obtenir
   D0=12345678
   D1=AAAAAAAA

   Ex�cutons  maintenant la troisi�me ligne. Il y a bien transfert du
   word  de  poids  faible  de D0 vers le word de poids faible de D1.
   Nous  constatons que le word de poids fort de D1 N'EST PAS AFFECTE
   par  ce  transfert, et qu'il reste tout � fait ind�pendant du word
   de poids faible.

   4�me  ligne. Ce  mn�monique 'SWAP' (To swap= �changer) va �changer
   les  16 bits de poids faible avec les 16 bits de poids fort. D0 va
   donc devenir 56781234.

   Derni�re  ligne. Transfert  du  word  de  poids  faible de D0 (qui
   maintenant  est 1234 et plus 5678) vers le word de poids faible de
   D2.

   Nous  avons  vu que D0 contenait en fait 2 donn�es et que ces don-
   n�es �taient totalement ind�pendantes. Ceci permet une grande sou-
   plesse  de travail mais demande aussi une grande rigueur car si au
   lieu  de  faire  MOVE.W  D0,D1 j'avais  juste  commis une faute de
   frappe en tapant MOVE.L  D0,D1 j'�crasais le word de poids fort de
   D1 et  apr�s  je  me serais �tonn� de trouver 1234 dans D1 � l'en-
   droit o� je devrais encore trouver AAAA.

   Nous  voyons  tout  de  suite les �normes avantages de ce syst�me.
   Nous  n'avons  � notre disposition que 8 'poches' de donn�es (D0 �
   D7) mais  si nous ne voulons garder que des words, nous pouvons en
   mettre  2 par  poche, c'est-�-dire  16 en  tout. De  m�me si notre
   codage  ne se fait que sur des bytes, c'est 32 bytes que nous pou-
   vons  garder  (4 par poche). Cela peut para�tre assez �vident mais
   par  exemple sur l'Archim�de, ce n'est pas possible. Sur cette ma-
   chine, un registre contient un long word ou rien!

   RESUM� DE VOCABULAIRE

   MOVE.L = move long
   MOVE.W = move word
   MOVE.B = move byte


   CONSEILS
   Prenez  votre  temps,  relisez  tranquillement  ce  cours  et  les
   pr�c�dents. Vous voyez ce n'est pas bien dur l'assembleur!

Back to ASM_Tutorial