Plein de chtit question sur l'assembleur 68000 - Page 2

lol

PpHd :
Il l'est. Tu as juste inverse les deux instructions

ah oui, la pile croît à l'envers, pour empiler sur pile, il faut faire
move.b Dn, -(a7)

(j'avais même pas grillé )

>les données ont-elles toutes la même taille ?

sinon tu peux faire une table de saut :

; on va supposer que d0 == 1 ou 2 
 lea   _table_saut(pc),a0
 lsl.w #1,d0 ; d0 * 2 -> d0
 move.w  0(a0,d0.w),d0
 lea     offset(pc,d0.w),a0
 ;a0 contient l'adresse de donnee1 ou de donnee2
 
_table_saut:
  dc.w  donnee1-offset
  dc.w  donnee2-offset

offset:
donnee1:
 <- ici tout plein de dc ->
donnee2:
 <- tout pareil ->

of course, il faudra faire gaffe aux tailles des données (genre être sûr que ça tient sur un word, tousssa)

bonne idée pour la table de saut, il va falloir que je regarde de ce coté là...

[Edit] dsl unee erreur de manip

mézencor ?

Tu as découvert tout seul la façon rapide de lire un mot de 16 bits à une adresse impaire sur un 68000 (regarde les timings): move.b <ea>, -(sp); move.b (sp)+,dn; move.b <ea>,dn. Elle est utilisée dans les routines de décompression PPG pour plus de vitesse.

move.b <ea>, -(sp); move.W (sp)+,dn; move.b <ea>,dn

lol je suis un génie qui s'ignore

Oups, typo.

<vince>c'est pas typo, c'est Riri </vince>

Euh... Vous lisez deux fois le même octet en mémoire, ou bien le mot entier est empilé malgré le move.b ?
Ou bien encore, le deuxième move n'est pas <ea> mais <ea+1> ou <ea+2> ?

il me semble que le mot entier nest pas empilé, mais en hardware move.b Dn,-(A7) revient à faire move.b Dn,-(A7) subq.l #1,A7
car A7 ne peut pas être impair

(à ce propos, il me semble qu'il y a bug sur VTI, genre un superviseur A7 peut être impair ou un truc du style)

Rien ne t'empêche de faire de faire un move.l #impair,a7, ou même un subq #1,a7.

Flanker merci bien pour l'idée de la table de saut, ça marche vraiment très bien.
J'avais pas bien compris ton code, alors je l'ai repondu, et en optimisant, je trouve quasiment la même chose que ce que tu m'avais donné...

en plus au niveau du lea offset(..., ça ne passait pas à la compile, le saut étant trop long

il fait combien ton programme ?

Flanker> je sais pas exactement et je suis à la boîte là, mais ça doit faire dans les 1500 octets

Martial> ben pas trop étaonnant vu que l'index dans ce cas n'est codé que sur 8 octets.

Sinon pour la table de saut, il y avait quasimment la soluce dans a68k guide, je ne sais pas comment j'avais pu ne pas le voir.

sur 8 bits plutôt ? code sur 16 dans l'index
et si ton programme fait moins de 32ko, je te conseille de mettre le label offset au point de démarage du programme, pour éviter toute merde avec les signes
sinon, si offset est trop loin, tu fais en 2 étapes :
lea offset(pc),a0
lea 0(a0, d0.w),a0

Ba je ne me suis pas fait chier, voilà ce que j'ai fait:

;Ma table de saut
;------------------------------------------------------------------------------------------------------------------------------
	moveq	#0,D0
	move.b	no_niveau,D0			;D0 contient le niveau à charger
	lsl.b	#1,D0				; d0 * 2 -> d0 ; (la table de saut est composée de word)
	lea	table_saut(PC),A2		;A2 pointe vers la table de saut
	movea.w	0(A2,D0.w),A2			;A2 contient l'offset entre le label origine et le niveau à charger
;;;;;;;;;	adda.l	origine,A2			;A2 pointe vers le début du niveau à charger
	lea	origine,A0
	adda.l	A0,A2	
	adda.w	offset_map,A2			;A2 pointe maintenant vers le début de la map à charger

origine
niveau1
		dc.b ....


table_saut
	dc.w  niveau1-origine

Sinon il me smble que dans le 68k guide, il est dit que movea ne se fait que sur des .l, alors que en débuggant avec Ti-Emu, j'ai vu que si l'on ne précisait pas, c'était compilé en .w

nan, movea peut prendre un w en argument, mais les 32 bits sont toujours affectés, nuance ça efface la partie supérieure du registre

Martial Demolins :
>> movea.w 0(A2,D0.w),A2 ;A2 contient l'offset entre le label origine et le niveau à charger
dangereux ça. mieux vaut nettoyer la partie supérieure de d0, et adresser avec d0.l Ca a peu de chances de te jouer des tours, mais un jour ça peut crasher sans crier gare

un moveq #0,d0 ne peut pas faire de mal

en fait il fait bien un moveq, donc c'est bon ^^
par contre, pour ton lea origine,A0 , tu devrais le remplacer par lea origine(pc),a0
edit: mais effectivement, le décalage est avec .w et pas .l

Ca sert qu'on se fout des 16 bits de poid fort de d0

il serati insensé que le proc prenne a2.l et d0.w pour faire son addition...
et pourtant c'est le cas
le bit de signe est étendu avant de faire l'addition