PARAMÈTRES ET SOUS-ROUTINES
L’entrée et la sortie de données nécessaires au
fonctionnement d’une sous-routine, peut se dérouler de quatre façons :
- En passant par les registres (A, X et / ou Y). C’est la meilleure méthode et la plus performante lorsqu’il s’agit de données constituées d’un ou deux octets
- En passant par des variables en RAM. Cette méthode est parfaite pour des données qui doivent rester en RAM et qui doivent servir à d’autres routines. Elle est souvent utilisée de manière conjointe à la première méthode.
- Les besoins en entrées de la sous-routine peuvent être intégrés au programme lui-même, juste après l’instruction JSR (comme par exemple une chaîne alphanumérique à afficher). Dans ce cas, la sous-routine utilise l’adresse de retour stockée sur la pile en guise d’adresse de début des données. Elle peut aussi utiliser un octet qui détermine le nombre de données ou un délimiteur afin de savoir de combien d’octets avancer l’adresse de retour avant d’exécuter l’instruction RTS (et d’éviter que le processeur ne traite les données comme une instruction).
- En passant par la pile matériel.
- Pile en page 1 : le programme appelant empile la (ou les) données grâce à PHA, puis récupère le (ou les) résultats grâce à PLA, au retour de la sous-routine.
- Pile virtuelle en page 0 : Idem précédemment, avec une pile de données différentes de la pile matérielle, ce qui peut faciliter certaines opérations sur la pile et l’adressage indirect. Par exemple, la pile de données peut être utilisée dans un processus en plusieurs étapes pour calculer une adresse, adresse qui à son tour peut être utilisée pour un accès indirect à un octet dans un tableau pour faire un calcul ou une opération logique.
- Pile en RAM : Idem pile virtuelle en page 0, mais pouvant typiquement servir pour des nombres en virgule flottante autres que des adresses nécessitant les modes d’adressage disponibles en page 0.
Examinons un
exemple dans lequel il s’agit d’utiliser la pile matériel pour une donnée
d’entrée. Dans cet exemple, notre sous-routine transforme un demi-octet
hexadécimal en octet ASCII, avec un octet en entrée et un octet en sortie, le
tout stocké sur la pile matériel.
<do_stuff> ; Get the nybble into A. Allowable value is 0-F.
PHA ; Other code can be put between the PHA and the PLA, as long
JSR NYB2ASCII ; as it doesn't care if NYB2ASCII overwrites A and X. The
PLA ; subroutine's input and output are protected on the stack though.
<do_stuff> ; Do something with the ASCII output, like add it to a string, display it, etc..
La sous-routine NYB2ASCII pourrait ressembler à ceci.
NYB2ASCII:
TSX
LDA $103,X ; 103 reaches past the return address, to
the input parameter.
CMP #$0A
; Anything below $0A will end up in the $30’s.
CLC ; CLC before the BMI so we only
have to do it once.
BMI n2a1
; For 9 or less, skip the next instruction.
ADC #7 ; $0A becomes $11, $0B becomes $12,
etc.. C is still clear.
n2a1:
ADC #$30 ; Whether the 7 got added above or not,
this gives the ASCII.
STA $103,X
; Put it on the stack, overwriting the input value. Note
RTS ; that we read and overwrote the
byte just behind the
; return address, leaving the return address
undisturbed.
Voici un autre
exemple dans lequel deux nombres de 16 bits non signés en entrée sur la pile,
sont multipliés pour donner un nombre de 32 bits non signé, en sortie sur la
pile.
On empile tout
d’abord les deux nombres à transformer, chacun avec le poids fort en premier,
de sorte que le poids fort prenne l’adresse la plus haute comme dans le
fonctionnement habituel du 6502.
<do_stuff> ; Get high byte of first input,
PHA ; and push it.
<do_stuff> ; Get low
byte of first input,
PHA ; and push it.
<do_stuff> ; Get high byte of second input,
PHA ; and push it.
<do_stuff> ; Get low byte of second input,
PHA ; and push it.
JSR UM_STAR
; Now you can call the subroutine below that does the multiplying.
; If you pull the product off
the stack now, the byte order will be:
PLA ; 2nd-highest byte
<do_stuff>
PLA ; high byte
<do_stuff>
PLA ; low byte
<do_stuff>
PLA ; 2nd lowest byte
<do_stuff>
Selon les opérations que vous souhaitez réaliser ensuite,
vous pouvez très bien laisser le premier résultat sur la pile.
Si l’opération
après la multiplication des deux nombres est de calculer la racine carrée pour
en obtenir la raison géométrique, alors il convient de ne pas toucher à la pile
tant que cette seconde opération n’est pas effectuée (la raison géométrique
équivaut à une moyenne logarithmique. La raison géométrique de 1 et 100 est de
10, et non de 50,5).
Pour accéder aux
données stockées sur la pile sans les dépiler et dans l’ordre de votre
préférence, vous pouvez continuer d’utiliser X comme index de pile (ainsi que
décrit dans l’exemple UM_STAR ci-dessous). En cas de TSX, vous devrez ajuster l’index en
tenant compte du fait que l’adresse de retour n’est plus sur la pile, et comme
décrit ci-après, qu’un PLA a déplacé les résultats sur la pile de $101,X à $104,X.
Par contre, sans TSX l’index est toujours valide et pointe bien sur les bonnes
données.
UM_STAR: LDA #0 ; Unsigned, mixed-precision
(16-bit by 16-bit input, 32-bit output)
PHA ; multiply. Add a variable byte to the stack,
initializing it as 0.
TSX ; Now 101,X holds that new
variable, $102,X and $103,X hold the return address
LSR $107,X ;and $104,X to $107,X holds the
inputs and later the outputs.
ROR $106,X
FOR_Y
16, DOWN_TO, 0 ; Loop 16x. The DEY, BNE in NEXT_Y below will drop
through on 0.
IF_CARRY_SET
CLC
PHA ; Note that the PHA (and PLA below)
doesn’t affect the indexing.
LDA $101,X
ADC $104,X
STA $101,X
PLA
ADC $105,X
END_IF
ROR
ROR $101,X
ROR $107,X
ROR $106,X
NEXT_Y
STA $105,X
PLA ; Retrieve the variable
byte we added at the top, cleaning up the stack.
STA $104,X ; Again note that the PLA changed
S but not X, so the $104 is still $104.
RTS
Note : Dans de nombreux cas, il serait plus judicieux de nommer les
données présentes sur la pile, en utilisant la macro EQU, plutôt que de se
contenter de $101,X ou équivalent.
Supposons
maintenant que vous ayez besoin d’une sous-routine avec quatre octets en entrée
et six octets en sortie.
Afin de servir de
la pile matérielle pour deux données supplémentaires en sortie, il faut donc
résoudre le problème de l’adresse de retour qui ne sera pas en haut de la pile
lors du RTS.
La meilleure
méthode consiste à faire de la place sur la pile avant d’appeler la
sous-routine :
PHA ; Push two dummy bytes onto the
stack to hold the
PHA ; positions open for outputs of
the subroutine called below.
<do_stuff> ; Prepare the subroutine input bytes to
be passed.
JSR subroutine
; Without changing the stack pointer, the subroutine
; can now give you two more bytes of output than
input.
Autre cas
pratique, celui où vous auriez besoin de plus de données en entrées qu’en
sortie.
Dans ce cas, il suffit
de dépiler les données inutiles après être sorti de la sous-routine.
Ainsi, pour
restaurer la hauteur de pile, faites :
<do_stuff> ; Set up inputs, reserve output byte
places in stack, etc..
TSX ; Mark the current stack position.
<do_more_stuff>
JSR <subroutine>
<do_stuff> ; Handle outputs, etc..
TXS ; Restore stack to the marker
set earlier, possibly also
; to put certain outputs at the top.
Évidemment le
registre X ne devra pas être modifié par la sous-routine, ou alors il faudra le
sauvegarder à son tour sur la pile.
Comme décrit
précédemment, la pile matériel n’est pas la seule solution en tant que pile de
stockage. Une pile en page zéro (ZP) présente par exemple l’avantage de
disposer de modes d’adressages supplémentaires.
Utiliser une autre
pile que la pile matériel permet aussi de résoudre le problème suivant : admettons
que la pile matériel en page 1 serve pour passer des paramètres à une
sous-routine qui elle-même doit fournir des paramètres à autre sous-routine.
Lors de l’entrée dans la seconde sous-routine, l’adresse de retour se retrouve
donc désormais au sommet de la pile, tandis que les données d’entrée sont
décalées vers le bas, ce qui donnera à coup sûr des résultats erronés.
Mettons en œuvre
cet exemple avec la sous-routine GEOMEAN.
GEOMEAN: JSR UM_STAR ; Multiply two 16-bit unsigned inputs on the
stack. Get 32-bit product.
JSR
SQRT ; Take a 32-bit input on the stack and get a
16-bit output, leaving two
RTS ; dummy bytes on stack (problem:
GEOMEAN’s return addr is still on top!)
Supposons que vous commenciez par empiler $1234 sur la pile matériel
(poids fort en premier, sur le dessus de la pile), puis que vous empiliez $5678
avant d’appeler la sous-routine GEOMEAN.
Lorsque le
pointeur de programme attend la première instruction après PHA et TSX dans le
programme UM_STAR, UM_STAR part à la recherche du premier nombre à multiplier ($1234
dans notre exemple), censé se trouver aux adresses $106,X et $107,X, puis du
second nombre ($5678 dans l’exemple) qui se trouve aux adresses $104,X et
$105,X. L’adresse de retour se trouve quant à elle indexée par $102,X et
$103,X.
Il y a cependant
maintenant deux adresses de retour au sommet de la pile : celle qui a fait
appel à UM_STAR et celle qui a fait appel à GEOMEAN. UM_STAR va donc ignorer
$1234 et multiplier $5678 avec l’adresse de retour de GEOMEAN, entraînant ainsi
un résultat erroné et l’écrasement de l’adresse de retour de GEOMEAN. C’est le
plantage assuré !
Vous vous
apercevez également que le fait d’utiliser JMP au lieu de la paire
d’instruction JSR / RTS peut entraîner des problèmes d’incompatibilité liés à
une mauvaise gestion des données empilées sur la pile matériel.
La pile en page zéro permet de contourner ce genre de problème, tout
simplement parce que l’adresse de retour n’est pas empilée sur cette dernière.
En plus de
l’adressage de la page zéro qui est plus performant que celui de la pile
matériel, signalons aussi les bénéfices suivants :
- Inutile de replacer les paramètres d’entrée sur la pile sans
arrêt, avec pour résultat immédiat une exécution plus rapide des étages de la
pile ;
- Réduction des effets liés à la récursivité (ce sujet sera
abordé dans un prochain article) ;
- Possibilité de placer plusieurs type (et quantité) de
valeurs ;
- Code plus compact qui permet un meilleur fonctionnement car
plus besoin de devoir empiler/dépiler des paramètres lors de l’appel de
sous-routines.
Revenons
maintenant à notre sous-routine qui transforme un demi-octet hexadécimal en
octet ASCII et voyons comment réaliser cette transformation en utilisant une
pile ZP.
X
servira de pointeur de pile, initialisé en début de programme pour indexer de
la manière suivante $00,X.
Pour
empiler en page zéro, il faut donc faire un DEX puis stocker en $0,X.
Voici
ce que donne la routine modifiée pour la pile ZP :
<do_stuff> ; Get the nybble into A. Allowable value is 0-F.
DEX
STA 0,X
; Other code can be put between the STA and the LDA, and
JSR NYB2ASCII
; NYB2ASCII’s input and output are protected on the stack.
LDA 0,X
; X must be preserved as the data stack pointer of course.
INX
<do_stuff> ; Do something with the ASCII output,
like add it to a string, display it, etc..
Note : Si vous avez besoin
du registre X dans le reste de votre programme, il vous faudra le sauver sur la
pile matériel.
La sous-routine NYB2ASCII devient :
NYB2ASCII: ; (The initial TSX is no longer
necessary.)
LDA
0,X ; Get the input
parameter from the data stack.
CMP
#$0A ; Anything below $0A
will end up in the $30’s.
CLC ; CLC before the BMI so we only
have to do it once.
BMI
n2a1 ; For 9 or less, skip
the next instruction.
ADC
#7 ; $0A becomes $11, $0B
becomes $12, etc.. C is still clear.
n2a1:
ADC #$30 ; Whether the 7 got added above or not,
this gives the ASCII.
STA
0,X ; Put it on the data
stack, overwriting the input value. Note
RTS ; that the return address is not
on this stack to worry about.
Procédons selon la
même logique pour la sous-routine UM_STAR.
UM_STAR: DEX ; Add a stack byte to use
as a temporary variable.
LDA #0
STA 0,X ; 0,X addresses the temporary
variable. These are in ZP.
LSR 4,X
ROR 3,X
FOR_Y 16, DOWN_TO, 0
IF_CARRY_SET ; The 1st time thru the loop, A needs 0;
so don’t use STZ above.
CLC
PHA
LDA 0,X
ADC 1,X
STA 0,X
PLA
ADC 2,X
END_IF
ROR
ROR 0,X
ROR
4,X
ROR 3,X
NEXT_Y
STA 2,X
LDA 0,X
STA 1,X
INX ; Take back the stack byte
we used as a temporary variable.
RTS
;——————
Ici, un octet est empilé sur la pile ZP grâce à l’instruction
DEX (puis dépilé grâce à INX), de la même manière que pour PHA (puis PLA). La
pile ZP permet donc d’éviter d’avoir à sauver/restaurer l’index X.
Il est en outre possible de se passer des instructions
DEX/INX en adressant le nouvel octet grâce à $FF,X qui permet de rester en page
zéro et qui économise au passage 2 octets et 4 cycles d’horloge.
Assurez-vous cependant de n’avoir aucune sous-routine ou
interruption susceptible d’écraser cet octet, car X semble indiquer que cet
emplacement est libre.
La sous-routine GEOMEAN quant à elle, peut désormais s’écrire :
GEOMEAN: JSR UM_STAR
; Multiply two 16-bit unsigned inputs on the stack and get a 32-bit
product.
JMP
SQRT ; (JSR, RTS) Take a 32-bit input on the stack and get a
16-bit output.
;——————
Voici dans le détail les avantages à travailler avec des
piles séparées :
- Le nombre d’octets
entrés est indépendant du nombre d’octets sortis. En d’autres termes, nul
besoin de nettoyer les octets de sortie factices ni de placer des octets
factices sur la pile ;
- En disposant de
données séparées, les adresses de retour ne sont pas traitées comme des
données. Le paramétrage devient implicite ;
- Une sous-routine
peut faire appel à une autre sous-routine sans avoir à faire le ménage sur la pile
matériel (qui devient désormais la pile de retour) ;
- La pile matériel
est maintenant disponible pour d’autres usages tels que la gestion des limites
et des index de boucles (y compris des boucles imbriquées) ;
- L’ajout d’une
nouvelle pile permet d’augmenter l’espace de stockage et d’éviter un crash sur
la pile matériel ;
- Grâce aux modes
d’adressages du 6502 en page zéro (ZP,X), nous pouvons adresser la pile ZP très
facilement.
Voyons justement comment mettre à profit les modes
d’adressage ZP,X dans l’exemple de routine de déplacement suivante.
Nous appellerons cette routine CMOVE, pour “character move”.
Avant de faire tourner cette routine, nous plaçons six octets
sur la pile ZP, sous la forme de 3 nombres de 16 bits (poids fort sur l’adresse
la plus haute dans chaque cas) :
- Adresse de départ
- Adresse de
destination
- Taille de mémoire
à déplacer (pouvant aller jusqu’à quelques dizaines de milliers d’octets)
CMOVE: LDA
0,X ; “See-move”
Character (memory) move ( from to len —
)
ORA
1,X
BEQ POP3
; If remaining length is 0, branch to POP3 which is just 6 INX’s, then
RTS.
LDA (4,X)
; Get a byte and
STA (2,X)
; transfer it.
INC 4,X
BNE cm1$
INC 5,X
; Increment the source addr
cm1$: INC
2,X
BNE cm2$
INC 3,X
; and the destination addr,
cm2$: DEC
0,X ; decrement the count
left,
LDA 0,X
CMP #$FF
BNE CMOVE
DEC 1,X
; and go back up for
another loop. If we’re
done,
BRA CMOVE
; that fact will be caught in the first three lines (BRA is for 65c02
only and stands for Branch Always).
Quand faut-il
éviter l’emploi d’une pile pour l’usage de paramètres d’entrées / sorties dans
des sous-routines ?
Déplacer des données dans une pile requiert du temps
processeur.
Aussi, si vous devez manipuler une grande quantité de
données, comme une chaîne alphanumérique, un tableau ou même une matrice,
placez là ailleurs en mémoire et indiquez son adresse de stockage sur la pile.
RÉCURSIVITÉ
Une sous-routine peut présenter la particularité d’être
récursive, à savoir qu’elle peut s’appeler elle-même à de nombreuses reprises.
Afin d’éviter que ce genre de sous-routine ne reboucle
indéfiniment, entraînant une surcharge de la pile matériel, il faut prévoir une
condition qui permette de quitter la sous-routine au bout de x boucles
récursives.
Lorsque cette (ou ces) condition(s) est respectée, on quitte
alors la sous-routine par une série de RTS.
Chaque sous-routine nidifiée (imbriquée) peut disposer de ses
propres variables ayant pourtant des
noms semblables.
Prenons l’exemple de la fonction de Fibonacci qui est
utilisée en calculs financiers, lors de la génération de nombres pseudo
aléatoires, dans des algorithmes de tri et de recherche ou encore pour la
compression de fichiers audio.
fiboIO: SETL $103
; For clarity, give names to the locals.
fiboTemp: SETL $102 ; (Record of X will be at $101,X.)
FIBO: CMP
#2 ; Test the input.
BCC end
; If it’s 0 or 1, so is the output, so just end.
; This
prevents endless nesting, too.
Otherwise,
PHA ; create local variable fiboIO,
and store A there.
PHA ; Create another local variable
byte, fiboTemp.
; (Its initial value
doesn’t matter.)
PHX ; Push X too, to protect the
calling routines.
TSX ; Prepare X to use for
stack-relative addressing.
DEA ; Get the n-1 term
JSR FIBO
; and calculate the number for it (recursing here)
STA fiboTemp,X
; and store its result in local variable fiboTemp.
LDA fiboIO,X
DEA
DEA ; Now get the n-2 term
JSR FIBO
; and calculate the number for it (recursing here).
CLC
ADC fiboTemp,X
; Add those two together, and
STA fiboIO,X
; store the answer. Don’t forget
the “,X”!
; Note that
there is no looping.
PLX ; Restore X for the calling
routines.
PLA ; Pull fiboTemp off the stack and
discard it.
PLA ; Pull the answer (fiboIO) off
the stack into A.
end: RTS
Cette sous-routine tient sur 34 octets et n’utilise pas la
RAM pour le stockage, hormis bien sûr la pile matériel.
La donnée d’entrée doit rester inférieure à 14 car la donnée
de sortie est sur 8 bits et le nombre de Fibonacci pour 13 est 233.
Avec une réponse sur deux octets ou plus, nous pourrions
avoir une donnée d’entrée plus grande sans manquer de place sur la pile, même
si ce genre de sous-routine en consomme beaucoup.
La place disponible sur la pile est largement suffisante pour
des sous-routines simples, mais rappelons que les routines récursives ne sont
pas des routines normales.
À suivre.
