Lire un tableau - Page 1

Voilà je possède un tableau en assembleur à 2 dimensions mais je veut le lire linéairement. Le tableau ce présente comme-ci:

Table dc.w $0020,$0022,$0024,$0026
dc.w $1020,$1022,$1024,$1026
dc.w $8020,$8022,$8024,$8026
....

Je voudrais lire linéairement les éléments 0,1,2,3,4,5,6,7,8,9,10,11...

Pour ça je procéde comme-ça:
d0 possède le numéro de l'élément, il est codé sur 8 bits

lea Table(PC),a1
add.w d0,a1
move.w (a1),donnee

J'obtient un crash intercepted, je pense que le problème vient que la donnée dans d0 est sur 8 bits mais qu'il faut 16 bits pour accéder à un élément du tableau hors je ne voit pas comment contourner le problème

je connais pas gd chose à l'ASM, mais avec les modes d'addressage avec post incrémentation, tu devrait pouvoir faire quelque chose du style

move.w (a1)+,donnee
ce qui copierai le mot pointé par a1 dans donnee, et incrémenterai ensuite a1 pour qu'il pointe sur le mot suivant...
(enfin, on va dire, en théorie, si j'ai bien compris qd j'ai lu des docs il y a pasmal de temps)

Tu ne peux pas lire ou ecrire un .w ou .l dans une memoire pointée par un pointeur impair.
Dans ton cas, si d0 est impair, le crash est inevitable.

Ca ne changeras ien puisque si je fait (a1)+ j'avance encore de 1 dans le tableau.
J'ai essayé et toujours crash intercepted.

Si tu fais move.w (an)+,dn, tu avances de 2 car .w=2*.b.

Si la donnée dans d0 est sur 8 bits, tu dois d'abord faire un ext.w d0 avant d'ajouter le contenu du mot de poids faible de d0 à a0.
Ensuite, tu peux utiliser l'adressage indirect indexé : move.w 0(a1,d0.w),donnee.
Une dernière chose, si d0 contient le n° de l'élément que tu veux extraire de ton tableau, il faut le multiplier par deux avant de l'ajouter à a0 puisque ton tableau contient des words.

Merci jackiechan

Mais l'adressage indirect indexé move.w 0(a1,d0.w) à quoi de différent par rapport à move.w (a1),d0 ?

Houla!! erreur!
C'est
move.w 0(A1,D0.w),dest; -> A1 inchangé

ou

add.w D0,A1 ;j'ai des doutes: une adresse est sur 32/24 bits, alors je ne suis pas sur que ça marche
move.w (A1),dest; -> A1 modifié juste au-dessus

Link a écrit :
add.w D0,A1 ;j'ai des doutes: une adresse est sur 32/24 bits, alors je ne suis pas sur que ça marche

Oui, ça marche. Ça fait:
char *A1;
signed short D0;
A1+=(signed long)D0;

J'ai encore un problème bête en plus:
Je sauve des registres dans la pile:
movem.l d0/a0/a1,-(a7)
puis je fait une condition qui m'oblige à utiliser beq
mais je n'arrive pas à restaurer les registres correctement

bah je ne comprends pas ton pb. Pour restaurer les registres, il faudrait mettre movem.l (a7)+,d0/a0-a1

Bas le problème c'est ça:
movem.l d0/a0/a1,-(a7)
cmp.b #FF,var
beq end_var
movem.l (a7)+,d0/a0/a1
rts

end_var:
...
pour restaurer les registre je fait movem.l (a7)+,d0/a0/a1 ça plante
rts

Et ben, ça ne devrait pas planter.
Il doit y avoir quelque chose dans les 3 points en dessous de end_var: qui traffique la pile.

Ca plante pas, ça vient de moi

J'ai trouvé le problème mais y a encore un truc que je trouve bizarre:

Je possède une fonction en assembleur qui demande un paramètre sur 8 bits, en assembleur il suffit de faire:

move.b #20,-(a8)
jsr MaFonction
lea 2(a7),a7


Mais en C dans mon header j'ai définit MaFonction correspond à la librairie puis:
__attribute__((stkparm)) extern void MaFonction (unsigned char);

Et lorsque j'utilise ceci: MaFonction (20); ça ne fonctionne pas, je suis obligé de coder dans le header unsigned short puis de faire une rotation de 8 bits. Franchement y a pas une solution?

Change ta fonction en assembleur pour lire 5(a7) plutôt que 4(a7).

Si je comprend bien ça marcheras vraiment bien en C mais pas en assembleur car en assembleur je serait obligé de codé sur 16 bits et en plus faire une rotation de 8, ça inverse le problème mais si y a que ça, alors pourquoi pas.

Ben, en assembleur, tu passes le paramètre avec un move.w plutôt qu'avec un move.b. Ça va à la même vitesse de toute façon, et peu importe qu'il y a du non-sens dans l'octet de poids fort, tu ne le lis pas de toute façon.

Et d'ailleurs, tu peux aussi complètement éviter le problème en utilisant le passage par registres.

Je trouve ça pas sein le passage par registre car ça constitue un travail supplémentaire à celui qui utilise la fonction car ça lui oblige à sauvegarder son registre pour executer la fonction avec un paramètre correct....

De toute façon, de par la convention d'appel, le programmeur est obligé de sauvegarder d0-d2/a0-a1 quand il appelle une fonction, même s'il n'y passe pas de paramètre. GCC fera toujours ça, et tu ne peux pas lui dire de ne pas le faire même si ta routine ne détruit pas ces registres.

et passer par la pile oblige à empiler ou dépiler les arguments donc aussi du travail supplémentaire

jackiechan a dit: Une dernière chose, si d0 contient le n° de l'élément que tu veux extraire de ton tableau, il faut le multiplier par deux avant de l'ajouter à a0 puisque ton tableau contient des words.

Il ne faut surtout par multiplier par deux car sinon ça multiplie par 2 l'éléments que je souhaite accéder, j'ai essayé ça est j'avais des problèmes, j'ai donc retiré la ligne qui multiplie par 2 est là plus de problème.

Bah si tu dois multiplier par deux le numéro de l'élément :
tab:
dc.w 0 ; 2 octets
dc.w 1 ; 2 octets
dc.w 2 ; 2 octets
dc.w 3 ; 2 octets

L'élément 2 est placé 4 octets après tab. Donc si tu veaux accéder à l'élément 2, tu dois ajouter 4 à un pointeur contenant l'adresse désignée par tab et faire une indirection dessus.

Bas je peux t'assurer que si je multiplie par 2, je multiplie par 2 le numéro de l'élément que je veut accéder.

Bah oui, tu multiplies par 2 le n° de l'élément auquel tu veux accéder et ça te donne la bonne valeur.

En effet