émulateur, carry flag, et overflow flag - Page 1

-

Tu programmes sur quelle plate-forme ?
J'avoue que ce n'est pas super pratique. Mais en général, ça dépend de l'opération : par exemple, pour la soustraction, le bit V n'est armé que si le ou exclusif des msb des opérandes est vrai (ou un truc du genre, il faut vérifier).

Sinon, perso, je n'ai jamais vraiment compris la différence entre le flag C et le flag V. Quelqu'un peut m'expliquer ?

-

Ben V = FL alors, ce n'est pas important.

Sinon je te conseil de créer une matrice avec les flags à active suivant l'instruction. Ensuite une matrice de conditions, genre pour activer le flag V il faut que l'instruction soit du type...

-

Oui faut voir si le processeur est un processeur 8 bits, 16 bits ou 32 bits. Dans le cas d'un processeur 32 bits voir même 16 bits ma solution n'est pas envisageable.

geogeo> tjs avec tes tables ?


Bon sinon c pas très compliqué, je dois pouvoir retrouver le code du projet de processeur qu'on avait fait au premier semestre... Par contre c sous GPL, donc tu n'as pas le droit de le mettre dans du code non-copyleft

Moi j'ai bien un code de proc, mais en VHDL, je sais pas si ça aidera

-

Sinon, perso, je n'ai jamais vraiment compris la différence entre le flag C et le flag V. Quelqu'un peut m'expliquer ?

Grosso modo, un moyen de s'en rappeler est de se dire que V est aux nombres signés ce que C est aux nombres non signés, il me semble.

Pour vérifier le carry, tu peux faire un truc simple sinon. Puisque le CPU émulé fonctionne en 24 bits, il te suffit de faire les opérations en 32 bits. (en vérifiant bien que les bits non utilisés soient effacées avant l'opération). Et si (result & 0x01000000) est vrai (24 bits) ou si (result & 0x010000) est vrai (16 bits), alors il y a retenue (Sinon, l'overflow, c quand (result & 0xfe000000) est vrai pour 24 bits, ou (result & 0xfe0000) est vrai pour 16 bits je pense)

-

[23:33:14] (Onori`i) je pense pas que sa soit un risc
[23:33:18] (Ximoon) un sisc donc ?
[23:33:21] (Onori`i) surement
[23:33:36] (Onori`i) un 8bits hybrid 16/24bits

Par contre faudrait que tu vérifies que ce que j'ai donné est bon, car après y avoir réfléchi, le carry est peut-être plutôt "if ((result & 0xFF0000[00]) == 0x010000[00])" et l'overflow, soit comme je l'ai dit, soit avec ff au lieu de fe

Ce topic aurait mieux eu sa place dans la section Assembleur, non ?

Le problème des flags Carry et Overflow, c'est que leur signification dépend de l'instruction, tout en étant logique uniquement dans le cas de l'addition.
Pour simplifier, on peut dire que le CF détecte les résultats erronés d'opérations non signées, et que l'OF détecte les résultats erronés d'opérations signées.

Ainsi, en non signé (valeurs entre 0 et 255 pour du 8 bits), si l'addition donne un résultat > 255, alors CF = 1, et si résultat € [[ 0 ; 255 ]], alors CF = 0.
En signé (valeurs entre -128 et 127), si l'addition de 2 nombres positifs donne un résultat négatif, ou si l'addition de 2 nombres négatifs donne un résultat positif, alors OF = 1, et dans les autres cas ( positif + positif => positif ; négatif + négatif => négatif ; addition de 2 nombres de signe différents), OF = 0.

Pour toutes les autres opérations (même la soustraction), l'affectation de CF et OF dépend de la convention utilisée pour le processeur cible.
Par exemple, si la soustraction de 2 nombres non signés (donc forcément positifs) donne un résultat strictement négatif, la convention x86 est de faire CF = 1 ( Carry Flag = Borrow Flag ), alors que la convention PIC est de faire CF = 0 ( Carry Flag = not (Borrow Flag) ).
Pour toutes les autres opérations, seul le traçage d'un programme test permet de conclure ...

@++

ça n'a rien à faire dans la catégorie "assembleur pc"
à la limite s'il y avait un forum "architecture des microprocesseurs", je dis pas ...

Il suffit de remonter au forum contenant la catégorie Assembleur pour voir que le terme 'PC' n'a rien à faire là. Petit rappel du contenu du forum :

Assembleur
C - C++ - C#
Pascal - Delphi - Visual Basic
Java
Programmation Graphique
Autres langages de programmation

Algorithmie et optimisation
Rebol-Python-Perl-Shell
Système d'exploitation
Electronique

Matériel & Logiciels / Dépannage

HTML - Javascript - DHTML
XML - XHTML - XSL - WML - MATHML
PHP - ASP - JSP
Flash - Shockwave Bases de données

De toute façon, là n'est pas la question ...

@++

Ethaniel > Et tu m'explique comment ton CPU il différencie additions et soustrations signées de additions et soustractions non signées ?

Excepté pour les multiplications et divisions où les résultats ne sont pas comparables (d'où les opérandes MUL et IMUL, DIV et IDIV, mais là, c'est le programmeur qui dit au CPU si ses valeurs sont signées ou non), le CPU ne fait pas la différence entre les valeurs signées et non signées.
Et c'est justement parce qu'il ne fait pas la différence qu'à chaque opération, il affecte à la fois le Carry Flag ET l'Overflow Flag.
Ensuite, c'est au programmeur de décider s'il est en arithmétique signée (en vérifiant l'OF pour détecter un éventuel dépassement de capacité) ou non signée (en vérifiant le CF).
Donc, dans TOUS les cas, c'est le programmeur seul qui décide du type d'arithmétique utilisée.
Le CPU en est incapable, tout comme tu est incapable de me dire ce que signifie mon utilisation de l'octet 0xAE ...
La valeur non signée 174 ? La valeur signée -82 ? L'ensemble de flags indépendants 10101110 ? L'instruction x86 scasb ?
Alors ?

@++