Registre d'indicateurs CPU : retenue, zéro, débordement, signe
Découvrez comment Z, C, N et V sont produits, pourquoi les conventions de retenue diffèrent pour la soustraction et comment les CPU transforment les indicateurs en branchements signés et non signés corrects.
En bref : Z, N, C et V ne sont pas quatre formes interchangeables de « débordement ». Z et N décrivent le résultat tronqué, C décrit la retenue non signée et V décrit le débordement signé. La soustraction demande une décision supplémentaire : certains jeux d’instructions stockent l’emprunt, tandis que d’autres stockent l’absence d’emprunt. Énoncez cette convention avant de déduire les conditions de branchement non signées.
Un registre d’indicateurs est un petit état qui a un grand effet sur le flot du programme. Une ALU produit un résultat ; une logique de génération des indicateurs résume certaines propriétés de cette opération ; puis un branchement ultérieur, une addition avec retenue ou une instruction conditionnelle lit ces bits.
L’idée est simple. Les détails ne le sont pas. Une conception peut produire le bon résultat de soustraction et tout de même prendre le mauvais branchement non signé si elle confond la retenue sortante avec l’emprunt. Elle peut aussi mal classer des valeurs signées si elle teste le bit de signe du résultat sans tenir compte du débordement.
Cet article développe un modèle précis à quatre indicateurs pour une ALU de bits, montre comment le vérifier avec des exemples sur 8 bits et explique en quoi les vrais jeux d’instructions diffèrent volontairement.
Les indicateurs font partie du contrat de l’ISA
Les noms Z, C, N et V sont courants, mais leur comportement est défini par une architecture et par chaque instruction — pas par les lettres seules.
| Architecture | Où l’état apparaît | Distinction importante |
|---|---|---|
| x86-64 | bits sélectionnés dans RFLAGS | SUB active CF lorsqu’un emprunt non signé se produit |
| AArch32 | indicateurs de condition dans APSR/CPSR | la soustraction avec indicateurs utilise C comme absence d’emprunt |
| AArch64 | N, Z, C et V dans PSTATE | de nombreuses opérations ont des formes séparées qui mettent les indicateurs à jour, comme ADDS et SUBS |
| ISA de base RISC-V | pas de registre de codes de condition arithmétiques | les branchements conditionnels comparent directement les registres |
| ALU pédagogique de DigiSim | quatre sorties : Z, C, N, V | SUB met C à 1 lorsque la soustraction non signée nécessite un emprunt |
Même au sein d’une architecture, les instructions ne mettent pas forcément tous les indicateurs à jour. Certaines en préservent un, certaines le remplacent et certaines le laissent indéfini au niveau architectural. La bonne question n’est donc pas « Que fait une opération AND aux indicateurs en général ? », mais « Que spécifie cette ISA pour cette forme d’instruction ? »
Le composant FLAGS_REGISTER de DigiSim stocke les entrées Z, C, N et V lorsque son entrée de chargement est activée sur un front montant. Il ne décide pas ce que ces entrées signifient. L’ALU et la logique de contrôle environnantes établissent ce contrat.
Un modèle précis à quatre indicateurs
Soient et des opérandes de bits, le résultat stocké sur bits et son bit de poids fort.
Zéro : Z
Z vaut exactement 1 lorsque tous les bits du résultat valent 0 :
Le matériel implémente généralement cela par un NOR de réduction, souvent synthétisé sous forme d’arbre plutôt que comme une seule porte physique gigantesque.
Pour une soustraction, exactement lorsque les deux opérandes de bits sont égaux. C’est pourquoi une instruction de comparaison peut effectuer une soustraction, abandonner et conserver Z pour un branchement d’égalité.
Négatif : N
N recopie le bit de résultat de poids fort :
Si est interprété comme une valeur en complément à deux sur bits, ce bit est son bit de signe. N seul ne dit toutefois pas si la réponse mathématique exacte était négative. En cas de débordement signé, le résultat tronqué peut avoir le signe opposé. Les comparaisons signées utilisent donc , et non N seul.
Retenue : C
Pour l’addition, définissons C comme la retenue sortante du bit de poids fort :
Elle indique que la somme non signée exacte est au moins égale à . Par exemple, l’addition 8 bits produit et .
La soustraction est l’endroit où la terminologie peut induire en erreur. Un additionneur calcule souvent
Soit la retenue sortante finale de cet additionneur. Alors :
En d’autres termes, une retenue finale signifie qu’aucun emprunt n’a été nécessaire. Deux encodages architecturaux également valides en découlent :
- Convention emprunt : . Un indicateur à 1 signifie . CF de x86 suit cette interprétation pour
SUB. - Convention absence d’emprunt : . Un indicateur à 1 signifie . Les codes de condition Arm utilisent cette interprétation après une soustraction qui met les indicateurs à jour.
Le circuit arithmétique peut être identique dans les deux CPU. Seuls l’encodage de l’indicateur et le décodeur de branchement diffèrent.
Les ALU 4 bits et 8 bits de DigiSim appliquent la convention d’emprunt après une soustraction :
Ainsi, C=1 exactement lorsque en arithmétique non signée. Une conception personnalisée qui expose directement la retenue sortante non inversée doit inverser les conditions de soustraction non signées déduites plus loin.
Débordement signé : V
V indique que le résultat signé exact est en dehors de l’intervalle représentable
Pour l’addition :
Deux opérandes de même signe débordent lorsque le résultat stocké a le signe opposé.
Pour la soustraction :
Des opérandes de signes différents débordent lorsque le signe du résultat diffère de celui de A.
Si la soustraction est implémentée comme , la formule familière des retenues
fonctionne également, où entre dans l’additionneur du bit de signe et en sort. Les formules fondées sur les bits de signe ci-dessus sont souvent plus faciles à vérifier à la frontière de l’ALU, car elles ne nécessitent pas d’exposer une retenue interne.
Quatre cas sur 8 bits à tester
Les petites valeurs ordinaires ne révèlent pas les erreurs d’indicateurs. Il faut tester les limites.
1. Addition ordinaire : 8 + 8
0000 1000
+ 0000 1000
-----------
0001 0000
Le résultat est 16, donc , , et .
2. Débordement signé sans retenue non signée : 127 + 1
0111 1111 (+127)
+ 0000 0001
-----------
1000 0000 (-128 when interpreted as signed)
La réponse non signée sur 8 bits, 128, est représentable, donc . La réponse signée +128 ne l’est pas, donc . Le résultat stocké a son MSB à 1, ce qui donne , tandis que .
Ce cas montre pourquoi C et V sont indépendants.
3. Retenue non signée sans débordement signé : 255 + 1
1111 1111
+ 0000 0001
-----------
1 0000 0000
Le résultat stocké sur 8 bits est zéro : et . Le neuvième bit rend . Interprété comme valeurs signées, il s’agit de , donc .
4. Soustraction avec emprunt : 0 - 1
L’additionneur évalue :
0000 0000
+ 1111 1110
+ 1
------------
1111 1111
La retenue sortante finale vaut 0 ; la sortie C de DigiSim, qui code l’emprunt, vaut donc 1. Les indicateurs du résultat sont par conséquent , , et .
C’est le test essentiel de la convention. Si la valeur C attendue n’est pas écrite avant la simulation, les deux réponses peuvent sembler plausibles.
Conditions de branchement correctes après A - B
Supposons qu’une comparaison calcule et mette à jour Z, N, C et V.
Égalité
L’égalité est indépendante du signe :
| Relation | Condition |
|---|---|
Comparaison signée
Le « inférieur » signé doit corriger le signe du résultat lorsque la soustraction a débordé :
| Relation signée | Condition |
|---|---|
Considérons 8 bits . Le résultat stocké est 1000 0000, donc N vaut 1, mais le résultat exact +128 est positif et a débordé, donc V vaut également 1. indique correctement que 127 n’est pas inférieur à -1.
Comparaison non signée
Avec la convention C d’emprunt de DigiSim :
| Relation non signée | Condition |
|---|---|
Avec un indicateur de retenue non inversée, ou d’absence d’emprunt, , les mêmes lignes deviennent , , et .
C’est pourquoi mélanger les mnémoniques de branchement de différentes architectures est dangereux. HS/CS d’Arm après CMP correspond à C=1 avec absence d’emprunt, tandis que JB/JC de x86 après CMP correspond à CF=1 avec emprunt. Les mots « carry set » ne suffisent pas ; l’opération précédente et la convention de l’ISA comptent.
Le registre et la logique qui l’entoure
Le registre d’indicateurs lui-même n’est qu’un stockage :
result[n-1:0] ── reduction NOR ── Z_next ─┐
result[n-1] ─────────────────── N_next ─┤
adder carry ── operation select ─ C_next ├─▶ FLAGS register ─▶ branch decoder
operand/result signs ───────────── V_next ─┤
clock + flags_load ────────────────────────┘
Trois choix de conception doivent être faits en dehors de l’élément de stockage :
- Génération : l’ALU produit des valeurs candidates telles que
Z_next,C_next,N_nextetV_next. - Sélection : l’opcode détermine quelle valeur candidate s’applique. La retenue d’un décalage peut provenir du bit éjecté plutôt que d’un additionneur.
- Politique d’écriture : l’unité de contrôle détermine si chaque indicateur est chargé, effacé ou conservé.
Un CPU pédagogique simple peut mettre les quatre indicateurs à jour après ADD, SUB et CMP, et les conserver après les mouvements et les opérations mémoire. C’est cohérent tant que l’ISA le spécifie. Ne généralisez pas silencieusement cette politique à un processeur commercial. Par exemple, AArch64 distingue normalement ADD de ADDS (forme qui met les indicateurs à jour), et SUB de SUBS ; x86 définit les effets propres à chaque instruction dans sa référence.
Les indicateurs doivent également respecter le timing synchrone ordinaire. Les entrées candidates doivent respecter les exigences setup et hold autour du front actif, et le décodeur de branchement doit recevoir des sorties enregistrées stables avant son prochain point de capture. La simulation fonctionnelle peut valider les tables de vérité et le séquencement de contrôle, mais elle ne remplace pas l’analyse statique du timing d’une puce ou d’un FPGA implémenté.
Pourquoi RISC-V n’a pas besoin d’indicateurs arithmétiques
L’ISA entière de base RISC-V compare les opérandes de registre dans ses branchements conditionnels :
BEQ rs1, rs2, target
BNE rs1, rs2, target
BLT rs1, rs2, target # signed
BLTU rs1, rs2, target # unsigned
BGE rs1, rs2, target # signed
BGEU rs1, rs2, target # unsigned
Il n’existe pas d’état architectural de codes de condition qu’une instruction intermédiaire pourrait écraser. Il s’agit d’un contrat d’ISA différent, et non de la disparition de la logique de comparaison : le branchement doit toujours établir la relation demandée.
RISC-V peut comparer l’égalité à zéro en utilisant son registre x0 câblé à zéro. D’autres constantes se trouvent peut-être déjà dans un registre ou doivent être matérialisées, selon le code environnant. Une arithmétique multímot peut former un bit de retenue explicite avec des comparaisons non signées comme SLTU.
Les conceptions fondées sur des indicateurs et celles qui comparent dans le branchement peuvent toutes deux être implémentées efficacement. La leçon importante est que l’état visible par le logiciel et la sémantique des instructions déterminent comment les résultats arithmétiques atteignent le flot de contrôle.
Construire et vérifier dans DigiSim
Le composant FLAGS_REGISTER accepte Z, C, N et V comme entrées de données et les capture sur un front montant lorsque LD est à 1. Construisez la logique environnante dans cet ordre :
- choisissez une largeur, par exemple 8 bits ;
- écrivez la convention de soustraction sur le schéma : dans DigiSim,
C after SUB = borrow = NOT raw carry-out; - produisez Z par un NOR de réduction et N à partir du MSB du résultat ;
- produisez V avec les formules d’addition et de soustraction propres à l’opération ;
- sélectionnez la bonne source de C pour ADD et SUB ;
- activez LD uniquement pour les instructions que votre ISA pédagogique définit comme mettant les indicateurs à jour ;
- décodez séparément les conditions de branchement signées et non signées.
Utilisez une table de vérification compacte plutôt que quelques entrées choisies au hasard :
| Opération | A | B | R attendu | Z | C | N | V |
|---|---|---|---|---|---|---|---|
| ADD | 8 | 8 | 16 | 0 | 0 | 0 | 0 |
| ADD | 127 | 1 | 128 | 0 | 0 | 1 | 1 |
| ADD | 255 | 1 | 0 | 1 | 1 | 0 | 0 |
| SUB | 0 | 1 | 255 | 0 | 1 | 1 | 0 |
| SUB | 1 | 1 | 0 | 1 | 0 | 0 | 0 |
| SUB | 127 | 255 | 128 | 0 | 1 | 1 | 1 |
| SUB | 128 | 1 | 127 | 0 | 0 | 0 | 1 |
Ici, C suit la convention d’emprunt documentée de DigiSim pour la soustraction. Si un circuit personnalisé expose volontairement la retenue non inversée, c’est-à-dire l’absence d’emprunt, il faut inverser la colonne C des soustractions et le décodeur non signé.
Testez ensuite le comportement d’état : gardez LD à 0 tout en modifiant les entrées de l’ALU et vérifiez que les indicateurs stockés ne changent pas ; envoyez une impulsion sur LD et vérifiez que tous les indicateurs activés se chargent ensemble ; puis exécutez comparaison–opération ne mettant pas les indicateurs à jour–branchement afin de vérifier que les indicateurs de comparaison persistent.
Liste de contrôle de conception
Avant de relier les indicateurs au compteur ordinal, confirmez que :
- la convention de retenue de la soustraction est explicite ;
- C et V sont testés comme des propriétés indépendantes ;
- le « inférieur » signé utilise , et non N seul ;
- les comparaisons non signées utilisent C avec la bonne polarité ;
- chaque opcode possède une politique documentée d’écriture des indicateurs ;
- le registre d’indicateurs stocke des entrées et n’infère pas la sémantique de l’ALU ;
- les vecteurs limites incluent zéro, tous les bits à 1, le maximum positif et le minimum négatif ;
- les conclusions de simulation se limitent à la logique et au séquencement, sauf si le timing physique a également été analysé.
Une fois ces conditions réunies, un registre d’état à quatre bits devient un pont fiable entre l’ALU, l’unité de contrôle et le compteur ordinal, plutôt qu’une source de surprises dépendantes de l’architecture.



