home *** CD-ROM | disk | FTP | other *** search
/ Enigma Amiga Life 109 / EnigmaAmiga109CD.iso / software / testi / corsoasm / sorgenti4 / lezione8p1a.s < prev    next >
Text File  |  1995-09-29  |  8KB  |  181 lines
  1.  
  2. ; Lezione8p1a.s    Funzionamento dei Condition Codes con l'istruzione MOVE
  3.  
  4. ; Ecco qui il programma di questa lezione: 2 istruzioni.
  5. ; Pensate che vi stia prendendo in giro? Dopo tutto quello che avete visto
  6. ; finora pensate di sapere gia` tutto su questo semplice programma?
  7. ; Ebbene vi sbagliate. Seguite le istruzioni nel commento.
  8.  
  9.     SECTION    CondC,CODE
  10.  
  11. Inizio:
  12.     move.w    #$0000,d0
  13. stop:
  14.     rts
  15.  
  16.     end
  17.  
  18. ;     oO
  19. ;    \__/
  20. ;     U
  21.  
  22. In questa lezione e nelle successive vedremo il funzionamento dei
  23. Condition Codes (detti CC, codici di condizione) del registro di stato.
  24. I CC sono stati ampiamente descritti nella lezione 68000-2.TXT.
  25. Se non vi ricordate bene cosa sono e come funzionano vi consiglio di rileggere
  26. meglio 68000-2.TXT.
  27. Ricordiamo brevemente che i CC sono dei bit presenti nel registro di stato che
  28. vengono modificati dalle istruzioni assembler per dare informazioni sul
  29. risultato dell'operazione eseguita.
  30. Vi sono istruzioni che modificano tutti i CC, altre che ne modificano solo
  31. alcuni e altre che non ne modificano nessuno.
  32. Inoltre ogni istruzione che modifica i CC, lo fa in una sua propria maniera.
  33. Nella lezione 68000-2.TXT per ogni istruzione assembler viene descritto
  34. sinteticamente l'effetto che essa ha sui CC. In questi listati presenteremo
  35. dei piccoli esempi pratici di come le istruzioni piu` usate modificano i CC.
  36. Si tratta di listati piu` noiosi di quelli che avete visto sinora, ma e`
  37. necessario che voi li studiate bene, se volte diventare dei VERI coders.
  38. In questa lezione esamineremo l'istruzione MOVE.
  39. Si tratta, come dovreste sapere, di un istruzione che copia il contenuto
  40. di un registro o di una locazione di memoria e modifica di conseguenza i CC.
  41. Per osservare bene come opera questa istruzione utilizzeremo l'ASMONE per
  42. eseguire il programma PASSO PASSO, cioe` un'istruzione per volta.
  43. Per farlo assemblate come al solito il programma, ma NON eseguitelo.
  44. Date, invece all'ASMONE il comando X che serve per stampare il contenuto di
  45. tutti i registri del 68000 e la prossima istruzione che verra` eseguita.
  46. Queste informazioni vengono rappresentate sinteticamente dall'ASMONE nelle 4
  47. righe riportate sotto:
  48.  
  49. D0: 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 
  50. A0: 00000000 00000000 00000000 00000000 00000000 00000000 00000000 07CAAE9C 
  51. SSP=07CABFD3 USP=07CAAE9C SR=0000 -- -- PL=0 ----- PC=07CAE030
  52. PC=07CAE030 303C0000             MOVE.W  #$0000,D0
  53. >
  54.  
  55. Spieghiamo brevemente il significato di queste 4 righe.
  56. La prima riga rappresenta il contenuto degli 8 registri dati del 68000.
  57. Potete infatti osservare come ci siano 8 numeri separati da uno spazio che
  58. rappresentano il contenuto dei registri, cominciando da D0 (il piu` a sinistra)
  59. e proseguendo ordinatamente fino a D7.
  60. Notate come prima di eseguire il programma i registri siano tutti azzerati.
  61.  
  62. La seconda riga rappresenta il contenuto dei registri indirizzi, esattamente
  63. nello stesso modo in cui la prima rappresenta il contenuto dei registri dati.
  64. Notate che i registri sono tutti azzerati tranne A7 che contiene l'indirizzo
  65. dello stack di sistema.
  66.  
  67. Nella terza riga sono rappresentati altri registri del processore.
  68. Per il momento ci occuperemo soltanto del PC (Program Counter) e del SR (Status
  69. Register)
  70. Il PC contiene l'indirizzo della prossima istruzione da eseguire. Come sapete
  71. le istruzioni che compongono un programma assembler si trovano in memoria!
  72. Nel PC e` appunto contenuto l'indirizzo di memoria dal quale verra` prelevata
  73. la prossima istruzione. In questo caso l'indirizzo e' 07CAE030, che fa parte
  74. della memoria FAST a 32bit montata su a1200/a4000 e simili. E' ovvio che se
  75. assemblate su diversi computer con memoria in diversi locazioni questo valore
  76. cambiera', e anche sullo stesso computer volta per volta potra' essere diverso,
  77. dato che i programmi sono rilocabili e non SCHIFOSAMENTE non rilocabili.
  78.  
  79. Di SR, il registro di stato abbiamo gia` parlato in 68000-2.TXT. Ci occuperemo
  80. per ora solo del byte basso che contiene i CC. Notate che il contenuto di SR
  81. viene rappresentato in forma esadecimale. Quindi leggere il contenuto dei
  82. singoli CC potrebbe risultare scomodo. Per questo motivo i CC vengono
  83. rappresentati separatamente. Noterete infatti che subito prima del contenuto
  84. del PC ci sono 5 trattini. Ogni trattino rappresenta un diverso CC e indica
  85. che esso e` azzerato. Quando uno dei CC assume il valore 1 al posto del
  86. trattino viene stampata la lettera che denomina il trattino: se ad esempio
  87. il Carry diventa 1, al posto del trattino corrispondente viene stampata la
  88. lettera C.
  89.  
  90. Nella quarta riga infine possiamo leggere la prossima istruzione che verra`
  91. eseguita. In questo caso si tratta della prima istruzione del programma.
  92.  
  93. NOTA: se volete stampare su un file l'output di ASMONE lo potete fare
  94.  usando il comando > o equivalentemente selezionando la voce Output dal Menu
  95.  command. L'ASMONE vi chiedera` il nome del file dove volete stampare l'output
  96.  e il gioco e` fatto. E` esattamente in questo modo che sono stato stampato
  97.  l'output del comando X
  98.  
  99. A questo punto possiamo eseguire la prima istruzione del programma, cioe`
  100.  
  101.           MOVE.W  #$0000,D0
  102.  
  103. Diamo all'ASMONE il comando K. L'istruzione verra` eseguita e ci viene stampato
  104. automaticamente il contenuto dei registri:
  105.  
  106. D0: 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 
  107. A0: 00000000 00000000 00000000 00000000 00000000 00000000 00000000 07CAAE9C 
  108. SSP=07CABFCF USP=07CAAE9C SR=8004 T1 -- PL=0 --Z-- PC=07CAE034
  109. PC=07CAE034 4E75         RTS
  110. >
  111.  
  112. La nostra istruzione ha messo il valore $0000 nel registro D0. Inoltre essa ha
  113. anche variato i CC. Notate infatti che ora il contenuto di SR e` $8004, cioe`
  114. il byte basso vale $04 che in binario si scrive %00000100. Cio` vuol dire che
  115. il bit 2, corrispondente al CC "Zero", ha assunto il valore 1. Come vi avevo
  116. anticipato, uno dei 5 trattini che comparivano in precedenza e` stato
  117. sostituito dal Carattere "Z" che indica appunto che il Flag "Zero" ha assunto
  118. il valore 1.
  119. L'istruzione MOVE infatti modifica i CC nel modo seguente:
  120. I flag V e C vengono azzerati
  121. Il flag X non viene modificato
  122. Il flag Z assume il valore 1 se il dato che viene copiato e` 0
  123. Il flag N assume il valore 1 se il dato che viene copiato e` negativo.
  124.  
  125. Nel nostro caso, poiche` il dato che copiamo in D0 e` $0000, il flag Z assume
  126. il valore 1 e il flag N assume il valore 0 (perche` $0000 NON E` un numero
  127. negativo).
  128.  
  129. Vediamo ora qualche altro esempio di uso dell'istruzione MOVE. Modificate nel
  130. sorgente la MOVE, scrivendo: 
  131.  
  132.     move.w    #$1000,d0
  133.  
  134. Ripetete ora la procedura per eseguire il programma PASSO PASSO.
  135. Dopo aver eseguito la MOVE avremo la seguente situazione:
  136.  
  137. D0: 00001000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 
  138. A0: 00000000 00000000 00000000 00000000 00000000 00000000 00000000 07C9EDFC 
  139. SSP=07C9FF2F USP=07C9EDFC SR=8000 T1 -- PL=0 ----- PC=07CA2E40
  140. PC=07CA2E40 4E75         RTS     
  141.  
  142. Possiamo notare che ora D0 contiene il valore $00001000, ovvero proprio
  143. quello che gli abbiamo copiato noi con la MOVE. Inoltre questa volta i CC
  144. sono tutti azzerati. Cio` dipende dal fatto che il valore $1000 che noi
  145. abbiamo spostato e` diverso da zero ed inoltre e` un numero positivo.
  146.  
  147. Facciamo ora un'altra modifica.
  148. Invece del valore $1000 mettiamo $8020, ottenendo:
  149.  
  150.     move.w    #$8020,d0    ; ossia "move.w #-32736,d0
  151.  
  152. Questa volta dopo l'esecuzione della MOVE otteniamo:
  153.  
  154. D0: 00008020 00000000 00000000 00000000 00000000 00000000 00000000 00000000 
  155. A0: 00000000 00000000 00000000 00000000 00000000 00000000 00000000 07C9EDFC 
  156. SSP=07C9FF2F USP=07C9EDFC SR=8008 T1 -- PL=0 -N--- PC=07CA2E40
  157. PC=07CA2E40 4E75         RTS
  158.  
  159. Come potete vedere, D0 ha assunto il valore desiderato e il flag N ha assunto
  160. valore 1. Cio` dipende dal fatto che il numero $8020 e` un numero negativo
  161. perche` il suo bit piu` significativo vale 1.
  162.  
  163. Trasformiamo ora la MOVE come segue:
  164.  
  165.     move.l    #$8020,d0
  166.  
  167. Abbiamo semplicemente cambiato la dimensione del dato spostato. Questo fatto
  168. comporta che ora dobbiamo considerare il valore $8020 come un numero a 32 bit
  169. ovvero come $00008020. Ora il bit piu` significativo e` il bit 31, non il
  170. bit 15 come in precedenza! Quindi in questo caso abbiamo a che fare con un
  171. numero POSITIVO. Eseguendo la MOVE si ottiene infatti:
  172.  
  173. D0: 00008020 00000000 00000000 00000000 00000000 00000000 00000000 00000000 
  174. A0: 00000000 00000000 00000000 00000000 00000000 00000000 00000000 07C9EDC4 
  175. SSP=07C9FEF7 USP=07C9EDC4 SR=8000 T1 -- PL=0 ----- PC=07CA33CA
  176. PC=07CA33CA 4E75         RTS
  177. >
  178.  
  179. dove potete notare che il flag "N" e` azzerato. 
  180.  
  181.