{"id":796,"date":"2019-06-15T18:51:14","date_gmt":"2019-06-15T16:51:14","guid":{"rendered":"https:\/\/ceobeta.oric.org\/?p=796"},"modified":"2019-06-15T18:51:14","modified_gmt":"2019-06-15T16:51:14","slug":"fonctionnement-de-la-pile-materiel-du-6502-4-8","status":"publish","type":"post","link":"https:\/\/oric.bqtt.net\/index.php\/2019\/06\/15\/fonctionnement-de-la-pile-materiel-du-6502-4-8\/","title":{"rendered":"Fonctionnement de la pile mat\u00e9rielle du 6502 (4\/8)"},"content":{"rendered":"\n

PARAM\u00c8TRES ET SOUS-ROUTINES<\/strong><\/p>\n\n\n\n

L\u2019entr\u00e9e et la sortie de donn\u00e9es n\u00e9cessaires au\nfonctionnement d\u2019une sous-routine, peut se d\u00e9rouler de quatre fa\u00e7ons :<\/p>\n\n\n\n

  1. En passant par les registres (A, X et \/ ou Y). C\u2019est la meilleure m\u00e9thode et la plus performante lorsqu\u2019il s\u2019agit de donn\u00e9es constitu\u00e9es d\u2019un ou deux octets<\/li>
  2. En passant par des variables en RAM. Cette m\u00e9thode est parfaite pour des donn\u00e9es qui doivent rester en RAM et qui doivent servir \u00e0 d\u2019autres routines. Elle est souvent utilis\u00e9e de mani\u00e8re conjointe \u00e0 la premi\u00e8re m\u00e9thode.<\/li>
  3. Les besoins en entr\u00e9es de la sous-routine peuvent \u00eatre int\u00e9gr\u00e9s au programme lui-m\u00eame, juste apr\u00e8s l\u2019instruction JSR (comme par exemple une cha\u00eene alphanum\u00e9rique \u00e0 afficher). Dans ce cas, la sous-routine utilise l\u2019adresse de retour stock\u00e9e sur la pile en guise d\u2019adresse de d\u00e9but des donn\u00e9es. Elle peut aussi utiliser un octet qui d\u00e9termine le nombre de donn\u00e9es ou un d\u00e9limiteur afin de savoir de combien d\u2019octets avancer l\u2019adresse de retour avant d\u2019ex\u00e9cuter l\u2019instruction RTS (et d\u2019\u00e9viter que le processeur ne traite les donn\u00e9es comme une instruction).<\/li>
  4. En passant par la pile mat\u00e9riel.
    • Pile en page 1 : le programme appelant empile la (ou les) donn\u00e9es gr\u00e2ce \u00e0 PHA, puis r\u00e9cup\u00e8re le (ou les) r\u00e9sultats gr\u00e2ce \u00e0 PLA, au retour de la sous-routine.<\/li>
    • Pile virtuelle en page 0 : Idem pr\u00e9c\u00e9demment, avec une pile de donn\u00e9es diff\u00e9rentes de la pile mat\u00e9rielle, ce qui peut faciliter certaines op\u00e9rations sur la pile et l\u2019adressage indirect. Par exemple, la pile de donn\u00e9es peut \u00eatre utilis\u00e9e dans un processus en plusieurs \u00e9tapes pour calculer une adresse, adresse qui \u00e0 son tour peut \u00eatre utilis\u00e9e pour un acc\u00e8s indirect \u00e0 un octet dans un tableau pour faire un calcul ou une op\u00e9ration logique.<\/li>
    • Pile en RAM : Idem pile virtuelle en page 0, mais pouvant typiquement servir pour des nombres en virgule flottante autres que des adresses n\u00e9cessitant les modes d\u2019adressage disponibles en page 0.<\/li><\/ul><\/li><\/ol>\n\n\n\n

      Examinons un\nexemple dans lequel il s\u2019agit d\u2019utiliser la pile mat\u00e9riel pour une donn\u00e9e\nd\u2019entr\u00e9e. Dans cet exemple, notre sous-routine transforme un demi-octet\nhexad\u00e9cimal en octet ASCII, avec un octet en entr\u00e9e et un octet en sortie, le\ntout stock\u00e9 sur la pile mat\u00e9riel.<\/p>\n\n\n\n

      <do_stuff>      ; Get the nybble into A.  Allowable value is 0-F.\nPHA             ; Other code can be put between the PHA and the PLA, as long\nJSR  <\/code>NYB2ASCII<\/code><\/strong> ; as it doesn't care if NYB2ASCII overwrites A and X. The\nPLA             ; subroutine's input and output are protected on the stack though.\n<do_stuff>      ; Do something with the ASCII output, like add it to a string, display it, etc..<\/code><\/pre>\n\n\n\n
      La sous-routine NYB2ASCII pourrait ressembler \u00e0 ceci.<\/p>\n\n\n\n
      NYB2ASCII<\/strong>:<\/p>\n\n\n\n
      TSX<\/p>\n\n\n\n
      LDA  $103,X     ; 103 reaches past the return address, to\nthe input parameter.<\/p>\n\n\n\n
      CMP  #$0A      \n; Anything below $0A will end up in the $30’s.<\/p>\n\n\n\n
      CLC             ; CLC before the BMI so we only\nhave to do it once.<\/p>\n\n\n\n
      BMI  n2a1      \n; For 9 or less, skip the next instruction.<\/p>\n\n\n\n
      ADC  #7         ; $0A becomes $11, $0B becomes $12,\netc..  C is still clear.<\/p>\n\n\n\n
       n2a1: \nADC  #$30       ; Whether the 7 got added above or not,\nthis gives the ASCII.<\/p>\n\n\n\n
      STA  $103,X    \n; Put it on the stack, overwriting the input value.  Note<\/p>\n\n\n\n
      RTS             ; that we read and overwrote the\nbyte just behind the<\/p>\n\n\n\n
      ; return address, leaving the return address\nundisturbed.<\/p>\n\n\n\n
      Voici un autre\nexemple dans lequel deux nombres de 16 bits non sign\u00e9s en entr\u00e9e sur la pile,\nsont multipli\u00e9s pour donner un nombre de 32 bits non sign\u00e9, en sortie sur la\npile.<\/p>\n\n\n\n
      On empile tout\nd\u2019abord les deux nombres \u00e0 transformer, chacun avec le poids fort en premier,\nde sorte que le poids fort prenne l\u2019adresse la plus haute comme dans le\nfonctionnement habituel du 6502.<\/p>\n\n\n\n
      <do_stuff>     ; Get high byte of first input,<\/p>\n\n\n\n
      PHA            ; and push it.<\/p>\n\n\n\n
      <do_stuff>     ; Get low \nbyte of first input,<\/p>\n\n\n\n
      PHA            ; and push it.<\/p>\n\n\n\n
      <do_stuff>     ; Get high byte of second input,<\/p>\n\n\n\n
      PHA            ; and push it.<\/p>\n\n\n\n
      <do_stuff>     ; Get low byte of second input,<\/p>\n\n\n\n
      PHA            ; and push it.<\/p>\n\n\n\n
      JSR  UM_STAR  \n; Now you can call the subroutine below that does the multiplying.<\/p>\n\n\n\n
                     ; If you pull the product off\nthe stack now, the byte order will be:<\/p>\n\n\n\n
      PLA            ; 2nd-highest byte<\/p>\n\n\n\n
      <do_stuff><\/p>\n\n\n\n
      PLA            ; high byte<\/p>\n\n\n\n
      <do_stuff><\/p>\n\n\n\n
      PLA            ; low byte<\/p>\n\n\n\n
      <do_stuff><\/p>\n\n\n\n
      PLA            ; 2nd lowest byte<\/p>\n\n\n\n
      <do_stuff><\/p>\n\n\n\n
      Selon les op\u00e9rations que vous souhaitez r\u00e9aliser ensuite,\nvous pouvez tr\u00e8s bien laisser le premier r\u00e9sultat sur la pile.<\/p>\n\n\n\n
      Si l\u2019op\u00e9ration\napr\u00e8s la multiplication des deux nombres est de calculer la racine carr\u00e9e pour\nen obtenir la raison g\u00e9om\u00e9trique, alors il convient de ne pas toucher \u00e0 la pile\ntant que cette seconde op\u00e9ration n\u2019est pas effectu\u00e9e (la raison g\u00e9om\u00e9trique\n\u00e9quivaut \u00e0 une moyenne logarithmique. La raison g\u00e9om\u00e9trique de 1 et 100 est de\n10, et non de 50,5).<\/p>\n\n\n\n
      Pour acc\u00e9der aux\ndonn\u00e9es stock\u00e9es sur la pile sans les d\u00e9piler et dans l\u2019ordre de votre\npr\u00e9f\u00e9rence, vous pouvez continuer d\u2019utiliser X comme index de pile (ainsi que\nd\u00e9crit dans l\u2019exemple UM_STAR<\/strong> ci-dessous). En cas de TSX, vous devrez ajuster l\u2019index en\ntenant compte du fait que l\u2019adresse de retour n\u2019est plus sur la pile, et comme\nd\u00e9crit ci-apr\u00e8s, qu\u2019un PLA a d\u00e9plac\u00e9 les r\u00e9sultats sur la pile de $101,X \u00e0 $104,X.\nPar contre, sans TSX l\u2019index est toujours valide et pointe bien sur les bonnes\ndonn\u00e9es.<\/p>\n\n\n\n
      UM_STAR<\/strong>: LDA #0                 ; Unsigned, mixed-precision\n(16-bit by 16-bit input, 32-bit output)<\/p>\n\n\n\n
               PHA                    ; multiply.  Add a variable byte to the stack,\ninitializing it as 0.<\/p>\n\n\n\n
               TSX                    ; Now 101,X holds that new\nvariable, $102,X and $103,X hold the return address<\/p>\n\n\n\n
               LSR $107,X             ;and $104,X to $107,X holds the\ninputs and later the outputs.<\/p>\n\n\n\n
               ROR $106,X<\/p>\n\n\n\n
               FOR_Y \n16, DOWN_TO, 0  ; Loop 16x.  The DEY, BNE in NEXT_Y below will drop\nthrough on 0.<\/p>\n\n\n\n
                   IF_CARRY_SET<\/p>\n\n\n\n
                       CLC<\/p>\n\n\n\n
                       PHA            ; Note that the PHA (and PLA below)\ndoesn’t affect the indexing.<\/p>\n\n\n\n
                          LDA $101,X<\/p>\n\n\n\n
                          ADC $104,X<\/p>\n\n\n\n
                          STA $101,X<\/p>\n\n\n\n
                       PLA<\/p>\n\n\n\n
                       ADC $105,X<\/p>\n\n\n\n
                   END_IF<\/p>\n\n\n\n
                   ROR<\/p>\n\n\n\n
                   ROR $101,X<\/p>\n\n\n\n
                   ROR $107,X<\/p>\n\n\n\n
                   ROR $106,X<\/p>\n\n\n\n
               NEXT_Y<\/p>\n\n\n\n
               STA $105,X<\/p>\n\n\n\n
               PLA                    ; Retrieve the variable\nbyte we added at the top, cleaning up the stack.<\/p>\n\n\n\n
               STA $104,X             ; Again note that the PLA changed\nS but not X, so the $104 is still $104.<\/p>\n\n\n\n
               RTS<\/p>\n\n\n\n
      Note : Dans de nombreux cas, il serait plus judicieux de nommer les\ndonn\u00e9es pr\u00e9sentes sur la pile, en utilisant la macro EQU, plut\u00f4t que de se\ncontenter de $101,X ou \u00e9quivalent.<\/p>\n\n\n\n
      Supposons\nmaintenant que vous ayez besoin d\u2019une sous-routine avec quatre octets en entr\u00e9e\net six octets en sortie.<\/p>\n\n\n\n
      Afin de servir de\nla pile mat\u00e9rielle pour deux donn\u00e9es suppl\u00e9mentaires en sortie, il faut donc\nr\u00e9soudre le probl\u00e8me de l\u2019adresse de retour qui ne sera pas en haut de la pile\nlors du RTS.<\/p>\n\n\n\n
      La meilleure\nm\u00e9thode consiste \u00e0 faire de la place sur la pile avant d\u2019appeler la\nsous-routine :<\/p>\n\n\n\n
      PHA              ; Push two dummy bytes onto the\nstack to hold the<\/p>\n\n\n\n
      PHA              ; positions open for outputs of\nthe subroutine called below.<\/p>\n\n\n\n
      <do_stuff>       ; Prepare the subroutine input bytes to\nbe passed.<\/p>\n\n\n\n
      JSR  subroutine \n; Without changing the stack pointer, the subroutine<\/p>\n\n\n\n
      ; can now give you two more bytes of output than\ninput.<\/p>\n\n\n\n
      Autre cas\npratique, celui o\u00f9 vous auriez besoin de plus de donn\u00e9es en entr\u00e9es qu\u2019en\nsortie.<\/p>\n\n\n\n
      Dans ce cas, il suffit\nde d\u00e9piler les donn\u00e9es inutiles apr\u00e8s \u00eatre sorti de la sous-routine.<\/p>\n\n\n\n
      Ainsi, pour\nrestaurer la hauteur de pile, faites :<\/p>\n\n\n\n
      <do_stuff>        ; Set up inputs, reserve output byte\nplaces in stack, etc..<\/p>\n\n\n\n
      TSX               ; Mark the current stack position.<\/p>\n\n\n\n
      <do_more_stuff><\/p>\n\n\n\n
      JSR  <subroutine><\/p>\n\n\n\n
      <do_stuff>        ; Handle outputs, etc..<\/p>\n\n\n\n
      TXS               ; Restore stack to the marker\nset earlier, possibly also<\/p>\n\n\n\n
      ; to put certain outputs at the top.<\/p>\n\n\n\n
      \u00c9videmment le\nregistre X ne devra pas \u00eatre modifi\u00e9 par la sous-routine, ou alors il faudra le\nsauvegarder \u00e0 son tour sur la pile.<\/p>\n\n\n\n
      Comme d\u00e9crit\npr\u00e9c\u00e9demment, la pile mat\u00e9riel n\u2019est pas la seule solution en tant que pile de\nstockage. Une pile en page z\u00e9ro (ZP) pr\u00e9sente par exemple l\u2019avantage de\ndisposer de modes d\u2019adressages suppl\u00e9mentaires.<\/p>\n\n\n\n
      Utiliser une autre\npile que la pile mat\u00e9riel permet aussi de r\u00e9soudre le probl\u00e8me suivant : admettons\nque la pile mat\u00e9riel en page 1 serve pour passer des param\u00e8tres \u00e0 une\nsous-routine qui elle-m\u00eame doit fournir des param\u00e8tres \u00e0 autre sous-routine.\nLors de l\u2019entr\u00e9e dans la seconde sous-routine, l\u2019adresse de retour se retrouve\ndonc d\u00e9sormais au sommet de la pile, tandis que les donn\u00e9es d\u2019entr\u00e9e sont\nd\u00e9cal\u00e9es vers le bas, ce qui donnera \u00e0 coup s\u00fbr des r\u00e9sultats erron\u00e9s.<\/p>\n\n\n\n
      Mettons en \u0153uvre\ncet exemple avec la sous-routine GEOMEAN<\/strong>.<\/p>\n\n\n\n
      GEOMEAN<\/strong>: JSR  UM_STAR  ; Multiply two 16-bit unsigned inputs on the\nstack.  Get 32-bit product.<\/p>\n\n\n\n
               JSR \nSQRT     ; Take a 32-bit input on the stack and get a\n16-bit output, leaving two<\/p>\n\n\n\n
               RTS           ; dummy bytes on stack (problem:\nGEOMEAN’s return addr is still on top!)<\/p>\n\n\n\n
      Supposons que vous commenciez par empiler $1234 sur la pile mat\u00e9riel\n(poids fort en premier, sur le dessus de la pile), puis que vous empiliez $5678\navant d\u2019appeler la sous-routine GEOMEAN.<\/p>\n\n\n\n
      Lorsque le\npointeur de programme attend la premi\u00e8re instruction apr\u00e8s PHA et TSX dans le\nprogramme UM_STAR, UM_STAR part \u00e0 la recherche du premier nombre \u00e0 multiplier ($1234\ndans notre exemple), cens\u00e9 se trouver aux adresses $106,X et $107,X, puis du\nsecond nombre ($5678 dans l\u2019exemple) qui se trouve aux adresses $104,X et\n$105,X. L\u2019adresse de retour se trouve quant \u00e0 elle index\u00e9e par $102,X et\n$103,X.<\/p>\n\n\n\n
      Il y a cependant\nmaintenant deux adresses de retour au sommet de la pile : celle qui a fait\nappel \u00e0 UM_STAR et celle qui a fait appel \u00e0 GEOMEAN. UM_STAR va donc ignorer\n$1234 et multiplier $5678 avec l\u2019adresse de retour de GEOMEAN, entra\u00eenant ainsi\nun r\u00e9sultat erron\u00e9 et l\u2019\u00e9crasement de l\u2019adresse de retour de GEOMEAN. C\u2019est le\nplantage assur\u00e9 !<\/p>\n\n\n\n
      Vous vous\napercevez \u00e9galement que le fait d\u2019utiliser JMP au lieu de la paire\nd\u2019instruction JSR \/ RTS peut entra\u00eener des probl\u00e8mes d\u2019incompatibilit\u00e9 li\u00e9s \u00e0\nune mauvaise gestion des donn\u00e9es empil\u00e9es sur la pile mat\u00e9riel.<\/p>\n\n\n\n
      La pile en page z\u00e9ro permet de contourner ce genre de probl\u00e8me, tout\nsimplement parce que l\u2019adresse de retour n\u2019est pas empil\u00e9e sur cette derni\u00e8re.<\/p>\n\n\n\n
      En plus de\nl\u2019adressage de la page z\u00e9ro qui est plus performant que celui de la pile\nmat\u00e9riel, signalons aussi les b\u00e9n\u00e9fices suivants :<\/p>\n\n\n\n
      • Inutile de replacer les param\u00e8tres d\u2019entr\u00e9e sur la pile sans\narr\u00eat, avec pour r\u00e9sultat imm\u00e9diat une ex\u00e9cution plus rapide des \u00e9tages de la\npile ;<\/li>
      • R\u00e9duction des effets li\u00e9s \u00e0 la r\u00e9cursivit\u00e9 (ce sujet sera\nabord\u00e9 dans un prochain article) ;<\/li>
      • Possibilit\u00e9 de placer plusieurs type (et quantit\u00e9) de\nvaleurs ;<\/li>
      • Code plus compact qui permet un meilleur fonctionnement car\nplus besoin de devoir empiler\/d\u00e9piler des param\u00e8tres lors de l\u2019appel de\nsous-routines.<\/li><\/ul>\n\n\n\n
        Revenons\nmaintenant \u00e0 notre sous-routine qui transforme un demi-octet hexad\u00e9cimal en\noctet ASCII et voyons comment r\u00e9aliser cette transformation en utilisant une\npile ZP.<\/p>\n\n\n\n
        X\nservira de pointeur de pile, initialis\u00e9 en d\u00e9but de programme pour indexer de\nla mani\u00e8re suivante $00,X.<\/p>\n\n\n\n
        Pour\nempiler en page z\u00e9ro, il faut donc faire un DEX puis stocker en $0,X.<\/p>\n\n\n\n
        Voici\nce que donne la routine modifi\u00e9e pour la pile ZP :<\/p>\n\n\n\n
        <do_stuff>      ; Get the nybble into A.  Allowable value is 0-F.<\/p>\n\n\n\n
        DEX<\/p>\n\n\n\n
        STA  0,X       \n; Other code can be put between the STA and the LDA, and<\/p>\n\n\n\n
        JSR  NYB2ASCII \n; NYB2ASCII’s input and output are protected on the stack.<\/p>\n\n\n\n
        LDA  0,X       \n; X must be preserved as the data stack pointer of course.<\/p>\n\n\n\n
        INX<\/p>\n\n\n\n
        <do_stuff>      ; Do something with the ASCII output,\nlike add it to a string, display it, etc..<\/p>\n\n\n\n
        Note : Si vous avez besoin\ndu registre X dans le reste de votre programme, il vous faudra le sauver sur la\npile mat\u00e9riel.<\/p>\n\n\n\n
        La sous-routine NYB2ASCII<\/strong> devient :<\/p>\n\n\n\n
        NYB2ASCII<\/strong>:              ; (The initial TSX is no longer\nnecessary.)<\/p>\n\n\n\n
                LDA \n0,X        ; Get the input\nparameter from the data stack.<\/p>\n\n\n\n
                CMP \n#$0A       ; Anything below $0A\nwill end up in the $30’s.<\/p>\n\n\n\n
                CLC             ; CLC before the BMI so we only\nhave to do it once.<\/p>\n\n\n\n
                BMI \nn2a1       ; For 9 or less, skip\nthe next instruction.<\/p>\n\n\n\n
                ADC \n#7         ; $0A becomes $11, $0B\nbecomes $12, etc..  C is still clear.<\/p>\n\n\n\n
         n2a1: \nADC  #$30       ; Whether the 7 got added above or not,\nthis gives the ASCII.<\/p>\n\n\n\n
                STA \n0,X        ; Put it on the data\nstack, overwriting the input value.  Note<\/p>\n\n\n\n
                RTS             ; that the return address is not\non this stack to worry about.
        <\/p>\n\n\n\n
        Proc\u00e9dons selon la\nm\u00eame logique pour la sous-routine UM_STAR<\/strong>.<\/p>\n\n\n\n
        UM_STAR<\/strong>: DEX                    ; Add a stack byte to use\nas a temporary variable.<\/p>\n\n\n\n
                 LDA  #0<\/p>\n\n\n\n
                 STA  0,X               ; 0,X addresses the temporary\nvariable.  These are in ZP.<\/p>\n\n\n\n
                 LSR  4,X<\/p>\n\n\n\n
                 ROR  3,X<\/p>\n\n\n\n
                 FOR_Y  16, DOWN_TO, 0<\/p>\n\n\n\n
                     IF_CARRY_SET       ; The 1st time thru the loop, A needs 0;\nso don’t use STZ above.<\/p>\n\n\n\n
                         CLC<\/p>\n\n\n\n
                         PHA<\/p>\n\n\n\n
                            LDA  0,X<\/p>\n\n\n\n
                            ADC  1,X<\/p>\n\n\n\n
                            STA  0,X<\/p>\n\n\n\n
                         PLA<\/p>\n\n\n\n
                         ADC  2,X<\/p>\n\n\n\n
                     END_IF<\/p>\n\n\n\n
                     ROR<\/p>\n\n\n\n
                     ROR  0,X<\/p>\n\n\n\n
                     ROR \n4,X<\/p>\n\n\n\n
                     ROR  3,X<\/p>\n\n\n\n
                 NEXT_Y<\/p>\n\n\n\n
                 STA  2,X<\/p>\n\n\n\n
                 LDA  0,X<\/p>\n\n\n\n
                 STA  1,X<\/p>\n\n\n\n
                 INX                    ; Take back the stack byte\nwe used as a temporary variable.<\/p>\n\n\n\n
                 RTS<\/p>\n\n\n\n
         ;——————<\/p>\n\n\n\n
        Ici, un octet est empil\u00e9 sur la pile ZP gr\u00e2ce \u00e0 l\u2019instruction\nDEX (puis d\u00e9pil\u00e9 gr\u00e2ce \u00e0 INX), de la m\u00eame mani\u00e8re que pour PHA (puis PLA). La\npile ZP permet donc d\u2019\u00e9viter d\u2019avoir \u00e0 sauver\/restaurer l\u2019index X.<\/p>\n\n\n\n
        Il est en outre possible de se passer des instructions\nDEX\/INX en adressant le nouvel octet gr\u00e2ce \u00e0 $FF,X qui permet de rester en page\nz\u00e9ro et qui \u00e9conomise au passage 2 octets et 4 cycles d\u2019horloge.<\/p>\n\n\n\n
        Assurez-vous cependant de n\u2019avoir aucune sous-routine ou\ninterruption susceptible d\u2019\u00e9craser cet octet, car X semble indiquer que cet\nemplacement est libre.<\/p>\n\n\n\n
        La sous-routine GEOMEAN<\/strong> quant \u00e0 elle, peut d\u00e9sormais s\u2019\u00e9crire :<\/p>\n\n\n\n
        GEOMEAN<\/strong>: JSR  UM_STAR \n; Multiply two 16-bit unsigned inputs on the stack and get a 32-bit\nproduct.<\/p>\n\n\n\n
                 JMP \nSQRT     ; (JSR, RTS)  Take a 32-bit input on the stack and get a\n16-bit output. <\/p>\n\n\n\n
         ;——————<\/p>\n\n\n\n
        Voici dans le d\u00e9tail les avantages \u00e0 travailler avec des\npiles s\u00e9par\u00e9es :<\/p>\n\n\n\n
        • Le nombre d\u2019octets\nentr\u00e9s est ind\u00e9pendant du nombre d\u2019octets sortis. En d\u2019autres termes, nul\nbesoin de nettoyer les octets de sortie factices ni de placer des octets\nfactices sur la pile ;<\/li>
        • En disposant de\ndonn\u00e9es s\u00e9par\u00e9es, les adresses de retour ne sont pas trait\u00e9es comme des\ndonn\u00e9es. Le param\u00e9trage devient implicite ;<\/li>
        • Une sous-routine\npeut faire appel \u00e0 une autre sous-routine sans avoir \u00e0 faire le m\u00e9nage sur la pile\nmat\u00e9riel (qui devient d\u00e9sormais la pile de retour) ;<\/li>
        • La pile mat\u00e9riel\nest maintenant disponible pour d\u2019autres usages tels que la gestion des limites\net des index de boucles (y compris des boucles imbriqu\u00e9es) ;<\/li>
        • L\u2019ajout d\u2019une\nnouvelle pile permet d\u2019augmenter l\u2019espace de stockage et d\u2019\u00e9viter un crash sur\nla pile mat\u00e9riel ;<\/li>
        • Gr\u00e2ce aux modes\nd\u2019adressages du 6502 en page z\u00e9ro (ZP,X), nous pouvons adresser la pile ZP tr\u00e8s\nfacilement.<\/li><\/ul>\n\n\n\n
          Voyons justement comment mettre \u00e0 profit les modes\nd\u2019adressage ZP,X dans l\u2019exemple de routine de d\u00e9placement suivante.<\/p>\n\n\n\n
          Nous appellerons cette routine CMOVE<\/strong>, pour “character move”.<\/p>\n\n\n\n
          Avant de faire tourner cette routine, nous pla\u00e7ons six octets\nsur la pile ZP, sous la forme de 3 nombres de 16 bits (poids fort sur l\u2019adresse\nla plus haute dans chaque cas) :<\/p>\n\n\n\n
          • Adresse de d\u00e9part<\/li>
          • Adresse de\ndestination<\/li>
          • Taille de m\u00e9moire\n\u00e0 d\u00e9placer (pouvant aller jusqu\u2019\u00e0 quelques dizaines de milliers d\u2019octets)<\/li><\/ul>\n\n\n\n
            CMOVE<\/strong>:  LDA \n0,X      ; “See-move”\nCharacter (memory) move  ( from to len —\n)<\/p>\n\n\n\n
                    ORA \n1,X<\/p>\n\n\n\n
                    BEQ  POP3    \n; If remaining length is 0, branch to POP3 which is just 6 INX’s, then\nRTS.<\/p>\n\n\n\n
                    LDA  (4,X)   \n; Get a byte and<\/p>\n\n\n\n
                    STA  (2,X)   \n; transfer it.<\/p>\n\n\n\n
                    INC  4,X<\/p>\n\n\n\n
                    BNE  cm1$<\/p>\n\n\n\n
                    INC  5,X     \n; Increment the source addr<\/p>\n\n\n\n
             cm1$:  INC \n2,X<\/p>\n\n\n\n
                    BNE  cm2$<\/p>\n\n\n\n
                    INC  3,X     \n; and the destination addr,<\/p>\n\n\n\n
             cm2$:  DEC \n0,X      ; decrement the count\nleft,<\/p>\n\n\n\n
                    LDA  0,X<\/p>\n\n\n\n
                    CMP  #$FF<\/p>\n\n\n\n
                    BNE  CMOVE<\/p>\n\n\n\n
                    DEC  1,X<\/p>\n\n\n\n
                                  ; and go back up for\nanother loop.  If we’re\ndone,<\/p>\n\n\n\n
                    BRA  CMOVE   \n; that fact will be caught in the first three lines (BRA is for 65c02\nonly and stands for Branch Always).<\/p>\n\n\n\n
            Quand faut-il\n\u00e9viter l\u2019emploi d\u2019une pile pour l\u2019usage de param\u00e8tres d\u2019entr\u00e9es \/ sorties dans\ndes sous-routines ?<\/strong><\/p>\n\n\n\n
            D\u00e9placer des donn\u00e9es dans une pile requiert du temps\nprocesseur.<\/p>\n\n\n\n
            Aussi, si vous devez manipuler une grande quantit\u00e9 de\ndonn\u00e9es, comme une cha\u00eene alphanum\u00e9rique, un tableau ou m\u00eame une matrice,\nplacez l\u00e0 ailleurs en m\u00e9moire et indiquez son adresse de stockage sur la pile.<\/p>\n\n\n\n
            R\u00c9CURSIVIT\u00c9<\/strong><\/p>\n\n\n\n
            Une sous-routine peut pr\u00e9senter la particularit\u00e9 d\u2019\u00eatre\nr\u00e9cursive, \u00e0 savoir qu\u2019elle peut s\u2019appeler elle-m\u00eame \u00e0 de nombreuses reprises.<\/p>\n\n\n\n
            Afin d\u2019\u00e9viter que ce genre de sous-routine ne reboucle\nind\u00e9finiment, entra\u00eenant une surcharge de la pile mat\u00e9riel, il faut pr\u00e9voir une\ncondition qui permette de quitter la sous-routine au bout de x boucles\nr\u00e9cursives.<\/p>\n\n\n\n
            Lorsque cette (ou ces) condition(s) est respect\u00e9e, on quitte\nalors la sous-routine par une s\u00e9rie de RTS.<\/p>\n\n\n\n
            Chaque sous-routine nidifi\u00e9e (imbriqu\u00e9e) peut disposer de ses\npropres variables ayant  pourtant des\nnoms semblables.<\/p>\n\n\n\n
            Prenons l\u2019exemple de la fonction de Fibonacci qui est\nutilis\u00e9e en calculs financiers, lors de la g\u00e9n\u00e9ration de nombres pseudo\nal\u00e9atoires, dans des algorithmes de tri et de recherche ou encore pour la\ncompression de fichiers audio.<\/p>\n\n\n\n
            fiboIO:    SETL $103   \n; For clarity, give names to the locals.<\/p>\n\n\n\n
            fiboTemp:  SETL $102    ; (Record of X will be at $101,X.)<\/p>\n\n\n\n
            FIBO<\/strong>:  CMP \n#2          ; Test the input.<\/p>\n\n\n\n
                   BCC  end        \n; If it’s 0 or 1, so is the output, so just end.<\/p>\n\n\n\n
                                    ; This\nprevents endless nesting, too. \nOtherwise,<\/p>\n\n\n\n
                   PHA              ; create local variable fiboIO,\nand store A there.<\/p>\n\n\n\n
                   PHA              ; Create another local variable\nbyte, fiboTemp.<\/p>\n\n\n\n
                                    ; (Its initial value\ndoesn’t matter.)<\/p>\n\n\n\n
                   PHX              ; Push X too, to protect the\ncalling routines.<\/p>\n\n\n\n
                   TSX              ; Prepare X to use for\nstack-relative addressing.<\/p>\n\n\n\n
                   DEA              ; Get the n-1 term<\/p>\n\n\n\n
                   JSR  FIBO       \n; and calculate the number for it (recursing here)<\/p>\n\n\n\n
                   STA  fiboTemp,X \n; and store its result in local variable fiboTemp.<\/p>\n\n\n\n
                   LDA  fiboIO,X<\/p>\n\n\n\n
                   DEA<\/p>\n\n\n\n
                   DEA              ; Now get the n-2 term<\/p>\n\n\n\n
                   JSR  FIBO       \n; and calculate the number for it (recursing here).<\/p>\n\n\n\n
                   CLC<\/p>\n\n\n\n
                   ADC  fiboTemp,X \n; Add those two together, and<\/p>\n\n\n\n
                   STA  fiboIO,X   \n; store the answer.  Don’t forget\nthe “,X”!<\/p>\n\n\n\n
                                    ; Note that\nthere is no looping.<\/p>\n\n\n\n
                   PLX              ; Restore X for the calling\nroutines.<\/p>\n\n\n\n
                   PLA              ; Pull fiboTemp off the stack and\ndiscard it.<\/p>\n\n\n\n
                   PLA              ; Pull the answer (fiboIO) off\nthe stack into A.<\/p>\n\n\n\n
            end:   RTS<\/p>\n\n\n\n
            Cette sous-routine tient sur 34 octets et n\u2019utilise pas la\nRAM pour le stockage, hormis bien s\u00fbr la pile mat\u00e9riel.<\/p>\n\n\n\n
            La donn\u00e9e d\u2019entr\u00e9e doit rester inf\u00e9rieure \u00e0 14 car la donn\u00e9e\nde sortie est sur 8 bits et le nombre de Fibonacci pour 13 est 233.<\/p>\n\n\n\n
            Avec une r\u00e9ponse sur deux octets ou plus, nous pourrions\navoir une donn\u00e9e d\u2019entr\u00e9e plus grande sans manquer de place sur la pile, m\u00eame\nsi ce genre de sous-routine en consomme beaucoup.<\/p>\n\n\n\n
            La place disponible sur la pile est largement suffisante pour\ndes sous-routines simples, mais rappelons que les routines r\u00e9cursives ne sont\npas des routines normales.<\/p>\n\n\n\n
            \u00c0 suivre.<\/p>\n","protected":false},"excerpt":{"rendered":"
            PARAM\u00c8TRES ET SOUS-ROUTINES L\u2019entr\u00e9e et la sortie de donn\u00e9es n\u00e9cessaires au fonctionnement d\u2019une sous-routine, peut se d\u00e9rouler de quatre fa\u00e7ons : En passant par les registres (A, X et \/ ou Y). C\u2019est la meilleure m\u00e9thode et la plus performante lorsqu\u2019il s\u2019agit de donn\u00e9es constitu\u00e9es d\u2019un ou deux octets En passant par des variables en RAM. […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[346,22],"tags":[376,658],"class_list":["post-796","post","type-post","status-publish","format-standard","hentry","category-assembleur","category-ceomag","tag-376","tag-ceomag350"],"_links":{"self":[{"href":"https:\/\/oric.bqtt.net\/index.php\/wp-json\/wp\/v2\/posts\/796","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/oric.bqtt.net\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/oric.bqtt.net\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/oric.bqtt.net\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/oric.bqtt.net\/index.php\/wp-json\/wp\/v2\/comments?post=796"}],"version-history":[{"count":0,"href":"https:\/\/oric.bqtt.net\/index.php\/wp-json\/wp\/v2\/posts\/796\/revisions"}],"wp:attachment":[{"href":"https:\/\/oric.bqtt.net\/index.php\/wp-json\/wp\/v2\/media?parent=796"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/oric.bqtt.net\/index.php\/wp-json\/wp\/v2\/categories?post=796"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/oric.bqtt.net\/index.php\/wp-json\/wp\/v2\/tags?post=796"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}