Suivez-nous sur Mastodon
|
|
|
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 68k - Optimiser le code
(Article écrit par Orlando et extrait de ZINE - octobre 1990)
|
|
J'ai déjà lu plusieurs articles dans d'autres magazines sur l'optimisation du code, mais je n'ai jamais
vu un livre d'astuces complet sur l'optimisation. Le voici, du moins le début, présenté par Orlando de
Brainstorm. Les valeurs de tactcycle et la plupart des exemples sont tirés d'un article de John A. Toebes.
(Motorola compiler-manager).
Note : les commandes déplaisantes commencent par "D:" et les commande optimisées par "O:".
b=bytes, c=tactcycles.
1. Toujours utiliser "moveq" avec des constantes 32 bits
D: and.l #$e,d2 ( 6b, 16c )
O: moveq #$e,d0 ( 2b, 4c )
and.l d0,d2 ( 2b, 8c )
-----------
( 4b, 12c )
~
D: cmp.l #1,d4 ( 6b, 14c )
O: moveq #1,d0 ( 2b, 4c )
cmp.l d0,d4 ( 2b, 8c )
-----------
( 4b, 12c )
~
D: move.l #6,label (10b, 28c )
O: moveq #6,d0 ( 2b, 4c )
move.l d0,label ( 6b, 20c )
-----------
( 8b, 24c )
~
D: move.l #4,d0 ( 4b, 12c )
O: moveq #4,d0 ( 2b, 4c )
~
D: clr.l d0 ( 2b, 6c )
O: moveq #0,d0 ( 2b, 4c )
|
Voici une astuce spéciale pour les valeurs qui sont trop grandes pour être utilisées avec la commande
"moveq". Par exemple, si vous voulez charger la valeur 200 dans d0.
D: move.l #200,d0
O: moveq #256-200,d0
neg.b d0
|
N'oubliez pas non plus les commandes "addq" et "subq".
D: add.l #3,d0 ( 6b, 16c )
O: addq.l #3,d0 ( 2b, 8c )
|
2. Utilisation d'un registre
Mais il n'est pas nécessaire de toujours utiliser un registre ! Si vous voulez soustraire
un petit nombre d'un registre, utilisez deux instructions "subq.l" !
d: sub.l #10,d0 ( 6b, 16c )
O: subq.l #8,d0 ( 2b, 8c )
subq.l #2,d0 ( 2b, 8c )
-----------
( 4b, 16c )
|
Cela n'accélère pas, mais diminue la taille du code !
3. lea
La commande "lea" est très utile, mais peu de gens l'utilisent de la manière suivante :
D: add.l #12,a0 ( 6b, 16c )
O: lea 12(a0),a0 ( 4b, 8c )
|
4. lea et les registres d'adresses
Vous pouvez également utiliser l'instruction "lea" pour charger des constantes dans un
registre d'adresses.
D: move.l #443,a1 ( 6b, 12c )
O: lea 443.w,a1 ( 4b, 8c )
|
5. Registre de données
Si vous voulez écrire la valeur $4f0000 dans un registre de données, vous pouvez certainement utiliser
cette méthode :
D: move.l #$4f0000,d0 (6b, 12c)
|
La version optimisée se présente comme suit :
O: moveq #$4f,d0 ( 2b, 4c )
swap d0 ( 2b, 4c )
-----------
( 4b, 8c )
|
6. Piles
Quelques conseils sur la manipulation des piles.
D: move.l #1,-(sp) ( 6b, 20c )
|
Vous le remplaceriez certainement par :
O1:moveq #1,d0 ( 2b, 4c )
move.l d0,-(sp) ( 2b, 12c )
-----------
( 4b, 16c )
|
Mais la commande "pea" peut également être utilisée dans ce cas.
7. Commandes mulu
Si votre objectif est la vitesse, utilisez les onglets avec des valeurs précalculées. Si votre
objectif est la taille du code, utilisez la commande "mulu". La troisième méthode consiste à
remplacer les commandes "mulu" par "lsl" et "add".
D: muls.w #10,d0 ( 4b, 70c )
O: move.l d0,d1 ( 2b, 4c )
lsl.l #2,d1 ( 2b, 12c )
add.l d1,d0 ( 2b, 8c )
add.l d0,d0 ( 2b, 8c )
-----------
( 8b, 32c )
|
8. Registres d'adresses
N'effacez pas les registres d'adresses avec la commande "move" ou "clr". Utilisez "sub" !
D1:move.l #0,a1 ( 6b, 12c )
D2:clr.l a1 ( 2b, 6c )
|
Ces lignes de commande appartiennent au passé. Les plus récentes sont :
O: sub.l a1,a1 ( 2b, 4c )
|
9. Code relatif au PC
Utiliser si possible un code relatif au PC (distance d'adresse de 16 bits seulement).
D: move.l zine,label
O: lea label(pc),a0
lea zine(pc),a1
move.l (a1),(a0)
~
D: move.l a0,hello
O: lea hello(pc),a1
move.l a0,(a1)
|
10. Décalages
Vous pouvez gagner beaucoup de temps processeur en utilisant les différentes commandes
de décalage. Voici quelques règles pour les commandes de décalage :
- Si le nombre de positions de décalage est supérieur à 15, utilisez la commande "swap"
et soustrayez 16 du nombre de décalages.
- Si le nombre est égal ou supérieur à 8, utilisez les décalages avec la constante 8 et
soustrayez 8 du nombre de décalages.
- Si le nombre est un et que vous souhaitez effectuer un décalage vers la gauche, utilisez
la commande "add".
Voici quelques exemples :
d0=1 left --> add.l d0,d0
d0=2 left --> lsl.l #2,d0
d0=4 left --> lsl.l #4,d0
d0=8 left --> lsl.l #8,d0
d0=9 left --> lsl.l #8,d0
add.l d0,d0
d0=10 left --> lsl.l #8,d0
lsl.l #2,d0
d0=16 left --> swap d0
clr.w d0
d0=24 left --> swap d0
clr.w d0
lsl.l #8,d0
d0=25 left --> swap d0
clr.w d0
lsl.l #8,d0
add.l d0,d0
d0= 1 right --> lsr.l #1,d0
d0=16 right --> clr.w d0
swap d0
d0=25 right --> clr.w d0
swap d0
lsr.l #8,d0
lsr.l #1,d0
|
|
