Suivez-nous sur X
|
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z,
ALL
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z
|
|
A propos d'Obligement
|
|
David Brunet
|
|
|
|
Programmation : Assembleur - les bases
(Article écrit par Jérôme Marchal - septembre 1999)
|
|
C'est quoi l'assembleur ?
L'assembleur est le langage de programmation par excellence. Vous connaissez
certainement le BASIC. Sur Amiga, les trois BASIC principaux sont : AMOS, Blitz Basic et
HiSoft Basic. Quand vous programmez en BASIC, vous utilisez des instructions texte
évidentes telles que print (imprimer) qui sont ensuite soit compilées soit interprétées.
Le problème est qu'à part les instructions fournies dans le BASIC, vous ne pouvez pas
vraiment faire ce que vous voulez.
La programmation en assembleur est totalement différente. Grâce à elle, il vous est possible de
faire n'importe quoi. Vous n'utilisez plus que des instructions préfabriquées... Au contraire,
vous allez directement taper dans le matériel de l'Amiga pour faire votre programme. On comprend
vite pourquoi les programmeurs de démos ont choisi l'assembleur : au lieu d'utiliser de lentes
instructions de BASIC, ils peuvent aller bidouiller chaque composante de la carte mère de l'Amiga
pour faire de la 3D toujours plus rapide et plus bourrine.
Les registres
Bon, pour coder en assembleur, il faut que vous compreniez bien une chose essentielle.
Quoi que vous vouliez faire, vous allez forcément utiliser les registres. D'un côté, on a
les registres d'adressages et de l'autre, les registres de données.
----------------------------
Registres Registres
d'adressage de données
----------------------------
A(0) D(0)
A(1) D(1)
A(2) D(2)
A(3) D(3)
A(4) D(4)
A(5) D(5)
A(6) D(6)
----------------------------
1) Les registres d'adressages
Ces derniers servent à stocker des adresses... Sans déconner ? Par exemple, si vous
ouvrez une bibliothèque, vous stockez son adresse au hasard en A(6). Les registres d'adresses
sont au nombre de 7 à savoir de A(0) a A(6).
2) Les registres de données
Idem que les registres d'adressages : Au nombre de 7 (de D(0) a D(6)), ils servent à
stocker des données numériques ou textuelles.
Exemples siou plait m'sieur !
Bon, puisque vous insistez lourdement, je vais vous donner des petits exemples... On ne
va pas voir ici un programme complet, mais juste des instructions au hasard pour vous
instruire un peu.
Bouge de là...
Bon, je vous ai parlé des registres de données et d'adressages. Maintenant, on va voir
comment on peut déplacer le contenu de D(0) en D(4).
Et ouaip, ce n'est pas plus compliqué que ça. Move est l'instruction qui sert à déplacer
et on lui précise ici que c'est le contenu de D(0) qui bouge en D(4). Et si on voulait
déplacer le contenu du registre d'adressage A(5) en A(3) ?
Autrement dit, l'instruction est exactement la même sauf qu'on remplace nos deux
registres de données (D(0) et D(4)) par deux registres d'adressages (A(5) et A(3)).
Va voir ailleurs si j'y suis
Bon, si vous voulez vous mettre à l'assembleur, c'est que vous avez sûrement déjà un
peu touché au BASIC. En BASIC, on utilise une instruction toute bête pour aller à un
endroit du programme : GOSUB. En assembleur, cette instruction existe aussi mais ne
possède pas le nom, c'est JSR. De la même manière que le BASIC, on place des étiquettes
dans le code et on peut s'y rendre quand on veut. Aller, trève de blabla, un exemple :
-Rulez
JSR -AcidOZine
move d(1),d(4)
-AcidOZine
JSR -Rulez
|
Bon, dans l'exemple à la con que je viens de faire, on utilise deux instructions
différentes : move dx,dx que l'on a vu précédemment et JSR -XXX que l'on est en train
de voir. A savoir que JSR, c'est les initiales de "Jump to Sub Routine" qui veut dire
saute à la sous-routine dont le nom est placé juste après JSR.
Pour en venir à ce petit programme : la première ligne est une étiquette. La
deuxième ligne dit à l'ordinateur de sauter à la sous-routine -AcidOZine. La troisième
ligne déplace le contenu de d(1) en d(4). La quatrième est l'étiquette -AcidOZine et
la cinquième dit de sauter à l'étiquette -Rulez. Donc, dans le concret, l'ordinateur
passe la première ligne puis en obéissant aux ordres de JSR, saute à l'étiquette
-AcidOZine. Arrivé là, il rencontre une autre instruction JSR qui lui dit d'aller à
l'étiquette -Rulez et il recommence à l'infinie sans jamais s'arrêter... Et notre
instruction move, là dedans, elle sert à quoi ? Eh bien à rien puisque l'on saute par
dessus, mais ça faisait plus "style" avec move entre les deux.
INSTRUCTIONS ÇA SERT A QUOI
------------------------------------------
ADD Addition
ADDA Addition avec résultat
Stocke en aX
AND Et logique
SUB Soustraction
JSR Saut à une sous-routine
MOVE Déplacer
MOVEQ Déplacer vite
OR Ou
TST Test
------------------------------------------
Conclusion
Bon, je vais m'arrêter là pour cet article-ci. En attendant, mattez les deux tableaux et
essayer de bien cogiter tout ça pour la prochaine fois... car les choses sérieuses vont
bientôt commencer !
Soutenez le travail d'Obligement
|
|
|
