Pl NR/fr
------------------------------
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