)
que veut dire et que fait l'instruction: lea
pourquoi est il mieux de remplacer: lea par addq.l lorsque l'on doit dé-empiler moins de 8.
optimisation valable pour des valeurs immédiates inférieures à #8)
pourquoi utilise t'on un .w avec move lorsque l'on veut indiquer les coordonnée
X et Y d'une ligne ou d'un texte: vu que les coordonnée ne dépasse pas 255 ou pourrait metre un .b a la place de .w
et pourquoi utilise t'on pea.l bighw(pc)
Orion_ a écrit :
c mieux d'utilise un :
move.l Fonction*4(a5),a0
jsr (a0)
plutôt qu'un : jsr doorsos::fonction ???
sinon, y'a pas plus rapide pour afficher un texte ou quelque chose comme
sa ?? parceque 7 ligne pour juste un "print",
sinon, PpHd ma dit que mon prog etait optimisable j'aimerais bien savoir ou ? et comment ? SVP
zdrubal a écrit :
LEA : Load Effective Address
Empile une adresse.
; Assembly Source File
; Created 19/04/2002, 16:29:29
; Taille de départ sous TIGCC : 353 octets.
; Taille en mettant la sauvegarde et restauration de la pile en 1 seule fois : 329 octets.
; Taille après quelques magouilles (deux move.w transformés en un move.l) : 321
section ".data"
include "os.h"
xdef _nostub
xdef _ti89
xdef _ti92plus
_main:
movem.l a5-a6,-(a7)
link a6,#0 ; On sauvegarde l'adresse du sommet de la pile dans a6
; => Il faudra la restaurer à la fin du programme.
; Si on fait cela, il n'est plus nécessaire de le restaurer après chaque appel de fonction : on le fait une fois pour toutes.
; Sauvegarde ecran
move.l $c8,a5
pea.l 3840
move.l HeapAllocPtr*4(a5),a0
jsr (a0)
move.l a0,d4
tst.l d4
beq nomem
move.l #3840,(a7)
pea.l LCD_MEM
move.l d4,-(a7)
move.l memcpy*4(a5),a0
jsr (a0)
;;;;;;;;;;;;;;;;;;
; Prog principal ;
;;;;;;;;;;;;;;;;;;
; ClrScr
move.l ScreenClear*4(a5),a0
jsr (a0)
; FontSetSys
move.w #2,-(a7)
move.l FontSetSys*4(a5),a0 ; Fonction
jsr (a0) ; Execute
; DrawStrXY
move.w #4,-(a7) ; noir sur blanc
pea.l bighw(pc) ; Texte
; move.w #10,-(a7) ; y=10
; move.w #10,-(a7) ; x=10
move.l #$000A000A,-(a7) ; y=10 et x=10 (10 en décimal == 000A en hexa)
; La doc que j'ai sur les cycles dit que empiler deux word prend 2*12 cycles... alors qu'empiler un long prend 20 cycles...
; Si la doc a raison (et que je sais la lire !), ça sera plus rapide, et ne prend pas plus de place-memoire.
; SI J'AI TORD DE FAIRE çA, çA SERAIT COOL DE ME LE FAIRE SAVOIR... (PpHd, si tu me reçois...)
move.l DrawStr*4(a5),a0 ; Fonction
jsr (a0) ; Execute
; DrawLine
move.w #1,-(a7) ; c=1
; move.w #95,-(a7) ; y1=95
; move.w #5,-(a7) ; x1=5
move.l #$0005005F,-(a7) ; 95==$005F et 5==$0005 d'ailleur, cette fois-ci, ça fait économiser de la mémoire ! bizarre...
; move.w #65,-(a7) ; y2=65
; move.w #145,-(a7) ; x2=145
move.l #$00910041,-(a7) ; 65==$41 et 145==$91
move.l DrawLine*4(a5),a0 ; Fonction
jsr (a0) ; Execute
; car w+w+w+w+w=2+2+2+2+2=10
; FontSetSys
move.w #0,-(a7)
move.l FontSetSys*4(a5),a0 ; Fonction
jsr (a0) ; Execute
; DrawStrXY
move.w #4,-(a7) ; noir sur blanc
pea.l msg1(pc) ; Texte
; move.w #40,-(a7) ; y=40
; move.w #10,-(a7) ; x=10
move.l #$000A0028,-(a7) ; 10==$A et 40==$28 Ici aussi, ça fait gagner de la meme... je comprend pas : ça en fait gagner une fois sur deux ?
move.l DrawStr*4(a5),a0 ; Fonction
jsr (a0) ; Execute
; DrawStrXY
move.w #4,-(a7) ; noir sur blanc
pea.l msg2(pc) ; Texte
; move.w #48,-(a7) ; y=48
; move.w #10,-(a7) ; x=10
move.l #$000A0030,-(a7)
move.l DrawStr*4(a5),a0 ; Fonction
jsr (a0) ; Execute
; ngetchx
move.l ngetchx*4(a5),a0
jsr (a0)
; Restore l'ecran
pea.l 3840
move.l d4,-(a7)
pea.l LCD_MEM
move.l memcpy*4(a5),a0
jsr (a0)
move.l d4,(a7)
move.l HeapFreePtr*4(a5),a0
jsr (a0)
nomem:
; ST_helpMsg
pea.l stmsg(pc) ; Texte
move.l ST_helpMsg*4(a5),a0 ; Fonction
jsr (a0) ; Execute
unlk a6 ; On restaure l'adresse du sommet de la pile, qu'on avait mémorisé dans a6
; Restore Registres
movem.l (a7)+,d4/a5
rts
; Datas
bighw: dc.b 'Hello World !',0
msg1: dc.b 'This is my first ASM program',0
msg2: dc.b 'Coded OnCalc With AS by ORION',0
stmsg: dc.b 'Hello: Coded oncalc with AS by Orion',0
)
Jimmy Mardell a écrit dans sont 68k guide :
L'instruction LINK crée une stackframe, une mémoire allouée temporairement
sur la pile. L'instruction est souvent utilisée dans les languages de haut
niveau quand il faut allouer de la mémoire pour des procédures comportant
des variables locales. Quand la procédure est désactivée, les variables
siparaissent se qui fait gagner de la mémoire.
LINK à deux opérandes. La première est un registre d'adresse et la seconde
une valeur complémentaire à deux, qui est la taille du frame (souvent négative
sauf si la pile grandie à l'envers). Quand l'instruction est éxécutée, le
registre d'adresse est empilé et le registre A7 nouvellement mis à jour est
copié dans le registre d'adresse. La valeur immédiate est ajoutée au registre
de la pile (A7).
La mémoire locale est accessible avec un décalage négatif depuis le registre
d'adresses. De cette façon vous pouvez utiliser des variables locales sans
déranger d'autres données qui sont empilées ou enlevées de la pile crée et garde
a la portée que vous précisez pendant l'appel de LINK.
L'instruction UNLK enleves le stackframe et restore le pointeur de pile.
METHODE D'ADRESSAGE : Aucune
TAILLE DES DONNEES : -
FLAGS: Unaffected
SYNTAXE : LINK An,#<shifting>
L'utilisation de LINK permet des programmes récurents.
)