Les articles Amstrad >Les produits Amstrad > Les CPC > Programmation > Assembleur > 3 : Les registres du Z80 [fr-en] (Amstradeus)

3 : Les registres du Z80 [fr-en] (Amstradeus)

[fr]

Maintenant que nous connaissons le binaire, l'hexadécimal et l'organisation mémoire du CPC, nous allons passer aux choses sérieuses...
Pour ceux qui ne le savent pas encore, le Z80 est le microprocesseur du CPC.


Le microprocesseur peut être considéré comme le cerveau de l'ordinateur. C'est lui qui exécute les programmes.


En basic, lorsque nous écrivons un programme, nous utilisons des variables. Le microprocesseur utilise lui, ce que l'on appelle des registres.


Les registres peuvent être considéré comme des variables, mais à la différence des variables, ils ont un nom et un nombre bien définis.
Ces registres sont des registres numériques de 16 bits, c'est à dire qu'ils peuvent contenir une valeur variant entre #0000 et #FFFF.
Chaque registre à également une fonction bien spécifique.
On peut séparer les registres en trois grandes catégories :
- les registres généraux, utilisés 90% du temps,
- les registres d'index, utilisés pour faire de l'adressage "indexé",
- les registres spéciaux, utilisés pour des fonctions spécifiques.

Les registres géréraux sont les suivants :
AF, BC, DE, HL


Le Z80 possède également des registres généraux "miroir" ou "prime" que l'on nommera :
AF', BC', DE', HL'
Donc, il dispose de 8 registres généraux de 16 bits.


Ces registres sont divisibles en paires de registres 8 bits, et que l'on nomme ainsi :
A, F, B, C, D, E, H, L


Et leurs équivalents
A', F', D', C', D', E', H', L'
Donc, A contient les 8 bits de poids fort de AF, et F contient les 8 bits de poids faibles de AF


Un exemple :
Si AF contient la valeur #1234 (hexadécimal), A contient #12 et F contient #34.
Le Z80 permet donc de manipuler les registres généraux sous leurs forme 8 bits ou 16 bits.
Les registres généraux sont utilisés dans des cas bien précis.
Par exemple, le registre A, appelé accumulateur, est utilisé pour les calculs arithmétiques et logiques.
Le registre F, appelé flags, est utilisé comme indicateur de validité des résultats.
En fait, le registre F se décompose en bits, que l'on pourra tester indivuellement.
Chaque bit est considéré comme un indicateur (flag) particulier.
Voici comment se décompose le registre des flags :

Numéro de bit 7 6 5 4 3 2 1 0
Nom du bit S Z x H x V N C

(Les bits 3 et 5 ne sont pas utilisés)

Maintenant, voyons la signification de ces bits :
- Bit S : Signe. Indique si le résultat d'une opération a donné un résultat positif ou négatif. Si le résultat est négatif, S vaut 1, sinon, S vaut 0.
- Bit Z : Zéro. Indique si le résultat d'une opération a donné un résultat nul. Si le résultat est nul Z vaut 1, sinon, Z vaut 0.
- Bit H : demi-retenue. Est égal à 1 si le résultat d'une opération a généré une retenue après le bit 4.
- Bit V : oVerflow ou parité. Est égal à 1 si le résultat d'une opération a donné un résultat invalide.
Dans le cas d'une opération logique, est égal à 1 lorsque la parité du résultat est impaire.
- Bit N : Négation. Est égal à 1 si l'opération qui a été effectuée est une opération de négation.
- Bit C : Retenue. Est égal à 1 si le résultat d'une opération a généré une retenue.
Ces bits sont positionnés automatiquement par le processeur après chaque opération.
Bon, voyons quelques exemples concret.

Si nous faisons l'addition suivante (signée sur 8 bits):
#74 116 (=%01110100, signe positif)
+#4F 79 (=%01001111, signe positif)
----
= #C3 -61 (=%11000011, signe négatif)

On voit tout de suite qu'il y a un problème : l'addition de deux nombres positifs donne un nombre négatif. Donc, nous pouvons déduire, qu'après ce calcul, notre registre F (flags) aura la valeur suivante :
S = 1 (signe du résultat négatif)
Z = 0 (résultat non égal à zéro)
x = ? (valeur indéterminée)
H = 1 (retenue entre le bit 3 et le bit 4)
x = ? (valeur indéterminée)
V = 1 (résultat incorrect : positif+positif=négatif)
N = 0 (opération n'était pas une soustraction)
C = 0 (pas de retenue du bit 7 au bit 8)

Soit la valeur #94 dans le registre F.

Autre exemple :
#74 116 (=%01110100, signe positif)
+#8C -116 (=%10001100, signe négatif)
----
=#(1)00 0 (=%00000000, signe positif, avec retenue bit 8)

Voici la valeurs de nos flags
S = 0 (signe du résultat négatif)
Z = 1 (résultat non égal à zéro)
x = ? (valeur indéterminée)
H = 1 (retenue entre le bit 3 et le bit 4) x = ? (valeur indéterminée)
V = 0 (correct : positif+négatif=positif)
N = 0 (opération n'était pas une soustraction)
C = 1 (retenue du bit 7 au bit 8)

Le Z80 calcule donc pour nous les flags. Il existe ensuite des instructions pour réaliser des conditions en fonction de la valeur de chaque flags.

Après le registre A et le registre F, voyons les autres registres généraux.
Le registre B est souvent utilisé comme compteur de boucle 8 bits. Une instruction particulière permet de le décrémenter (diminuer de 1) et de faire un saut si sa valeur n'est pas égale à zéro.
Combiné avec le regisgre C, il sert aussi de compteur 16 bits pour des instructions particulières, comme la copie de blocs.
Le registre HL est souvent utilisé comme pointeur. Un pointeur est en sorte une variable qui donne l'adresse d'une case mémoire.
Il suffit ensuite de se servir de ce pointeur pour lire la valeur d'une case mémoire ou de l'écrire.
Quand au regisgre DE, il n'a pas de fonctions particulière. Il peut servir lui aussi comme pointeur.

Tout ce que nous avons vu pour les registres AF, BC, DE, HL est valable pour les registres AF', BC', DE', HL'.
En fait, chaque double d'un registre n'est pas visible en même temps que son original.
Cela signifie que l'on ne peut pas voir en même temps le registre AF et le registre AF', le registre BC et le registre BC', et ainsi de suite.
Il existe dans le Z80 une instruction particulière qui "echange" les registres principaux et les registres miroirs.
Lorsque l'on utilise cette instruction, les registres principaux deviennent registres miroir, et inversement.
Il faut donc utiliser cette instruction avec prudence, pour ne pas s'emmeler les pinceaux, en quelques sorte.
De plus, le système de l'Amstrad utilise les registres miroirs. Il est donc déconseillé de les utiliser pour notre usage personnel.
Bien que cela soit quand même possible, mais bon... Nous n'allons pas (encore) nous étendre sur ce sujet.

Voyons maintenant les registres d'index.
Ils sont au nombre de deux, IX et IY. Ils sont utilisables exclusivement en mode 16 bits (bien que certaines instructions non documentées du Z80 permettent d'y accéder sous leur formes 8 bits... )
Ils servent donc de registres d'index.
Nous verrons plus tard, lorsque nous aborderons les modes d'adressages, à quoi cela correspond.

Reste les registres spéciaux, au nombre de 3 qui sont : PC, SP, et IR.

Tout d'abord, le PC, ou encore Program Counter, est un registre 16 bit qui indique l'adresse en mémoire de la prochaine instruction à exécuter.
Rappelez vous, la mémoire peut être considéré comme une grande armoire avec des tiroirs, chaque tiroir correspond à une adresse mémoire.
Et bien le PC contient l'adresse ou le Z80 va aller chercher l'instruction à exécuter.


Lorsque que le Z80 a lu l'instruction, le PC est automatiquement incrémenté, pour que le Z80 puisse ensuite lire l'instruction suivante, et ainsi de suite.
Il existe des instructions pour modifier le PC, en quelque sorte, comme si l'on faisait un "GOTO" en basic.

Ensuite le registre SP, ou encore Stack Pointer (pointeur de pile en Français) est utilisé pour permettre la sauvegarde des registres de la manière suivante :
Le registre SP contient une adresse mémoire. Des instructions spécialisées permettent d'écrire la valeur d'un registre à l'adresse indiquée par le registre SP, ou bien de lire dans un registre la valeur contenue à l'adresse indiquée par le SP.
Plus précisément, lorsque l'on sauve un registre, le SP est décrémenté de 2 (on sauve toujours les registres 16 bits), puis on écrit à la nouvelle adresse du SP le registre.
Pour restaurer un registre, on lit à l'adresse du SP, puis on l'incrémente de 2. Ainsi, le SP gère une "pile" de valeurs. Pile que l'on appelle aussi FIFO : First In First Out (premier entré, premier sorti).

Pour finir, le registre IR n'est pas utilisable sous sa forme 16 bits, mais sous forme de deux registres 8 bis : I et R.
Le registre I est utilisé pour les interruptions en mode 2, une chose que nous verrons sans doute plus tard...

Le registre R est utilisé comme registre de rafraichissement des mémoires RAM. En gros, il est incrémenté automatiquement par le processeur.
Il est souvent utilisé comme générateur de nombre aléatoires, sa valeur étant incrémenté très rapidement par le processeur.

Terminé pour ce chapitre !
Dans le chapitre suivant, nous verrons les modes d'adressages, et comment lire ou écrire un registre !

[/fr]

[en] 

Now that we understand binary, hexadecimal and the CPC memory organization, let's go deeper...
For those who still don't know it, the Z80 is the processor of the CPC.
It executes the programs.


In BASIC, when one writes a program, he uses variables.
But the microprocessor uses registers.
The registers can be considered as variables but they have a name and a number well defined.
The registers are 16 bits numeric registers, that is they can contain a value varying between #0000 and #FFFF.


They can be classified under 3 major categories:
- general registers (90% of the time)
- index registers, used for "indexed" addressing
- special registers, used for specific functions.

The generals registers are:
AF, BC, DE, HL


The Z80 also has "mirror" or "prime" general registers which will be named:
AF', BC', DE', HL'
So, it has 8 16 bits general registers.


These registers are divisible in 8 bit registers pair, which will be named:
A, F, B, C, D, E, H, L


and their equivalent:
A', F', B', C', D', E', H', L'
So, A contains the heavy weight 8 bits of AF and F the low weight 8 bits of AF.


An example:
If AF contains the value #1234, A contains #12 and F contains #34.
The Z80 allows to manipulate general registers under their 8 or 16 bits form.
The general registers are used in precise cases.
For example, the A register, called accumulator, is used for arithmetic and logic calculation.
The F register, called flag, is used as an indicator of the results validity.
In fact, the F register is decomposed in bits, which can be tested individually.
Each bit is considered as a particular flag.
Here is how the flag register is decomposed:

Number of the byte 7 6 5 4 3 2 1 0
Name of the byte S Z x H x V N C

(Bytes 3 & 5 are not used)

Now, let's see the signification of these bytes:
- Byte S: sign. Indicates if the result of a calculation has given a positive or negative result. If the result is negative, S is 1 otherwise it's 0.
- Byte Z: zero. Indicates if the result of an operation has given a null result. If the result is null Z is 1 otherwise 0.
- Byte H: half. Is equal to if the result of a calculation has generated a reserve after bit 4.
- Byte V: overflow or parity. Is equal to 1 if the result of an operation has given an invalid result.
In the case of a logic operation, is equal to 1 when the result parity is odd.


- Byte N: negation. Is equal to 1 if the operation is a negation.
- Byte C: reserve. Is equal to 1 if the result has generated a reserve.
These bytes are automatically positioned by the processor after each operation.
So, let's see some examples.

#74 116 (=%01110100, positive sign)
+#4F 79 (=%01001111, positive sign)
----
= #C3 -61 (=%11000011, negative sign)



S = 1 (sign of the negative result)
Z = 0 (result different from 0)
x = ? (undetermined value)
H = 1 (reserve between byte 3 and 4)
x = ? (undetermined value)
V = 1 (false result: positive+positive=negative)
N = 0 (was not a substraction)
C = 0 (no reserve from byte 7 to byte 8)

That is the value #94 in the register F.

Another example:
#74 116 (=%01110100, positive sign)
+#8C -116 (=%10001100, negative sign)
----
=#(1)00 0 (=%00000000, positive sign, with reserve on byte 8)

Here's the value of the flags
S = 0 (sign of the negative result)
Z = 1 (result different from 0)
x = ? (undetermined value)
H = 1 (reserve between byte 3 and 4) x = ? (undetermined value)
V = 0 (correct: positive+negative=positive)
N = 0 (not a substraction)
C = 1 (reserve from byte 7 to byte 8)

The Z80 does calculate the flags. It also exists instructions to deal with conditions according to the value of each flag.

After the F and A register, let's deal with the other general registers.
The B register is often used as an 8 bit loop counter. A particular instruction allows to diminish the value (minus 1) and to jump if its value is different from 0.
Combined with the C register, it's also a 16 bit counter for particular instructions, as the copy of blocks.
The HL register is ofter used as a pointer (a variable which give the address of a memory case.
As for the DE register, it has no particular functions. It can also be used as a pointer.

Everything that has been said about AF, BC, DE, HL variables is also ok with AF', BC', DE', HL'.
In fact, every double of a register is not visible at the same time than its original.
It means that one cannot see at the same time AF and AF', BC and BC' and so on.
When this instruction is used, the main registers become mirror and backwards.
This instruction must therefore be used with care.


Furthermore, the CPC uses the miror registers. So, they better not be used for our own use.
Even though it's not possible... We will talk about this later.

Let's see the index registers.
They're 2, IX and IY. They can only be used on 16 bit mode (even though certain undocumented instructions of the Z80 allow us to access them under their 8 bit form...)
Therefore they serve as index registers.
We'll see later on what this really means.

That leaves us the special registers, which are 3. PC, SP and IR.

First, the PC (Program Counter), is a 16 bit register which gives the memory address of the next instruction to be executed.
Keep in mind that the memory can be depicted as a huge desk with drawers, each of them corresponding to a memory address.
When the Z80 has read the instruction, the PC is automatically incremented so that it can read the next instruction, and so on.
They're are instruction to modify the PC (like a GOTO in Basic).

The SP register (Stack Pointer) is used to allow the saving of the registers. Like this:
The SP register contains a memory address. Special instructions allow to write the value of a register at the indicated address by the SP register, or to read in a register the value stored at the address indicated by the SP.
More precisely, when one saves a register, the SP is decremented by 2 (one always saves the 16 bit registers), then we write the register at the new SP address.
To restore a register, we read at the SP address, then increment it by 2. Thus the SP generates a stack of values. Stack which is also called FIFO: First In First Out.

To end it all, the IR register is not usable under its 16 bit form but under 2 8 bit registers: I and R.
The I register is used for the interruptions in mode 2, something we'll see later on...

The R register is used as a refresh register of the RAM. That is, it is automatically incremented by the processor.
It's often used as a random number generator, its value being incremented really quickly by the processor.

And this is the end of this chapter!
If the next chapter we'll study the adressing modes and how to read/write a register!

[/en]

  Voir cet article au format PDF Imprimer cet article

* Donathon 2018 *

340 €

 

 

 

 En savoir plus

RECHERCHE
Chat
 Smiles  Loading...
Connexion
Nom d'utilisateur :

Mot de passe :

Se souvenir de moi



Mot de passe oublié?

Inscrivez-vous!
EN LIGNE
9 utilisateur(s) en ligne (1utilisateur(s) en ligne sur Les articles Amstrad)

Membres: 1
Invités : 8

Golem13, plus...
Musiques CPC

Lecteur MP3
CPC-Scene Radio

 

 

ROLAND RADIO

 

Informations
________________________________

Suivre Amstrad.eu

________________________________

Autres Créations web

________________________________

 

Declaration CNIL : 1005884

Association : 0540200002843

Charte

Avertissements

Plan du site

Carte de France des membres

 

 

 

Facebook.

Twitter.

RSS forum.

RSS News.

Contact.

 

Gaston-Phoebus.com

Amstrad.eu

untour.fr

Cathydeco.com

Higoogle

Harloup.fr

** Faire un don **

 

Conception Phenix © 2000 - 2014