Discussion :

[SOA_j2EE]

Bonjour tout le monde
j'ai pas encore bien compris comment le processeur modifie le carry flag(CF):
voici des exemple, que j'ai testé avec turbo pascal mais jn'arrive pas à l'interpreter:
Exemple 1:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
mov ax,0
mov al,-127
add al, -1

aprés l'execution: CF=1 (pour moi c'est logique ,puisque cette opération a généré une retenue.

voici un aure exemple (presque la méme):
Exemple 2:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
mov ax,0
mov al,-127
sub al, 1

aprés l'execution: CF=0 ??? pour quoi (malgré cette opération a provoqué une retenue mais CF retste 0) ici on remarque que -127 < 1
un dernier exemple:

Exemple 3:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
mov ax,0
mov al,3
sub al,4

aprés l'exécution CF = 1 pour quoi car 3-4 = 3+ (-4) =0000 0011+1111 1100= FF (-1), pour moi cette opération n'a généré aucune retenue..!!

quelqu'un de vous pourrait m'expliquez pour quoi CF reste inchangé dans l'exemple 2 et il est changé dans l'exmple 3

merci

[Obsidian]

J'avoue que j'ai eu beaucoup de mal à répondre et la réponse, je l'ai trouvé dans les extraits visibles en ligne de « Assembly Language for Intel-based Computers » sur Google Books. Je m'offrirais bien le livre mais il est un peu cher (presque 100 dollars).

À la page 90, on apprend que :

• En cas de soustraction, CF est mis si l'opérande déduite est plus grande que la valeur dont on la retranche ;
• Que pour ce faire, lors d'une soustraction, le microprocesseur ajoute le complément à deux du soustracteur et récupère dans CF la valeur inversée de la retenue sortant du M.S.B. ;
• Que INC et DEC n'altèrent jamais la retenue ;
• Que NEG appliqué sur une valeur non nulle met toujours la retenue à 1.

J'imagine qu'il faut donc se souvenir qu'il ne s'agit pas d'opération signées : dans « mov al, -127; sub al, 1 », AL vaut en fait 129 et que, par conséquent 1 est plus petit.

Le fait que la retenue doive valoir 1 lorsque le soustracteur est le plus grand tient debout, puisque cette retenue sert en premier lieu à propager l'opération : si on voulait retrancher un registre sur huit bits à une valeur sur seize, il faudrait dans l'absolu faire la soustraction sur l'octet de poids faible, immédiatement suivie d'un « SBB 00h » sur l'octet de poids fort (ou de poids immédiatement supérieur).

[Jean-Marc.Bourguet]

A noter que les processeurs -- pas dans la famille X86, à l'extérieur -- varient quant à la définition de ce que contient ce flag ou l'équivalent après une soustraction. Et que le choix fait influence aussi la signification du flag en entrée pour une instruction comme SBB.

[Belgitaes]

quelqu'un de vous pourrait m'expliquez pour quoi CF
reste inchangé dans l'exemple 2 et il est changé dans l'exmple 3

(al) a la valeur 1000 0001 = (- 127) si on assome -1 a -127 on auras -128
comme l´instrucion fait un (add )on assome
L'instruction (add )effectue une addition des valeurs de ses deux opérandes
et stocke le résultat dans le premier opérande (la destination)
donc on obtient 1000 0001 = (- 127) + 1000 0000 = 1 0000 0001 et on obtient 1 carry

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
 
              ;       1000 0001 = Al - 127 
              ;     + 1000 0000  + add al, -1
              ;       ----------    
              ;     1 0000 0001  
                    C on obtient 1 carry on a 9 bits

Exemple 2:

mov ax,0
mov al,-127
sub al, 1

(al) a la valeur 1000 0001 = (- 127) si on soustrait (sub) 1 on obtient 1000 0000
L'instruction (sub) effectue une soustraction des valeurs de ses deux opérandes
et stocke le résultat dans le premier opérande (la destination)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
 
              ;       1000 0001 = Al - 127 
              ;             - 1  sub al, 1 
              ;       ----------    
              ;       1000 0000  on a 8 bits et pas de carry

Exemple 3:

mov ax,0
mov al,3 ; <- move permet de copier une valeur source vers un espace de stockage de destination
sub al,4

aprés l'exécution CF = 1 pour quoi??

De la même maniere que l'addition peut provoquer une retenue
la soustraction peut engendrer un reste (borrow)
qui est stocké dans le drapeau de retenue "carry"

(al) a la valeur de 0000 0011 (3)
(4) a la valeur de 0000 0100

si on soustrait 0000 0100 (4) a 0000 0011 (3) on obtient = 1 1111 1111

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
 
              ;       0000 0011 = Al = 3
              ;       -     100 - sub al, 4
              ;       ----------    
              ;     1 1111 1111 = 
                    C on obtient 1 carry on a 9 bits

[Obsidian]

(al) a la valeur 1000 0001 = (- 127) si on assome -1 a -127 on auras -128 comme l´instrucion fait un (add )on assomeL'instruction (add )effectue une addition des valeurs de ses deux opérandes et stocke le résultat dans le premier opérande (la destination)

Merci d'utiliser la balise [ QUOTE ] quand tu fais des citations. Attention également aux faux amis : en français, « assommer » ne concerne pas l'arithmétique.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
              ;       1000 0001 = Al - 127 
              ;     + 1000 0000  + add al, -1
              ;       ----------    
              ;     1 0000 0001  
                    C on obtient 1 carry on a 9 bits

Attention, encore une fois : « -1 » s'écrit 11111111 et pas 10000000 ! La retenue est quand même mise.

(al) a la valeur 1000 0001 = (- 127) si on soustrait (sub) 1 on obtient 1000 0000
L'instruction (sub) effectue une soustraction des valeurs de ses deux opérandes
et stocke le résultat dans le premier opérande (la destination)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
 
              ;       1000 0001 = Al - 127 
              ;             - 1  sub al, 1 
              ;       ----------    
              ;       1000 0000  on a 8 bits et pas de carry

Oui, mais comment le micro-processeur procède-t-il à cette soustraction ? Si tu additionnes le complément à deux de « -1 », tu te retrouves quand même avec une retenue.

De la même maniere que l'addition peut provoquer une retenue
la soustraction peut engendrer un reste (borrow) qui est stocké dans le drapeau de retenue "carry"

Non. Une soustraction n'engendre jamais de « reste » comme le fait une division. « to borrow » signifie « emprunter ». C'est la retenue dans l'autre sens : quand tu empruntes la valeur du bit de poids immédiatement supérieur pour effectuer ton calcul.

Et là encore, ça tient debout d'un point de vue arithmétique, mais ce n'est pas le complément à deux qui l'explique techniquement.

[anubis_1001]

Salut,
dans les opérations C2 on a 3 cas distincts:
1) addition de deux nombres positifs:
si le nombre est négatif alors il y a débordement -->CF=1
2)addition de deux nombres négatifs:
si le nombre est positif alors il y a débordement -->CF=1, sinon ignorer la retenue CF=0
3)addition d'un nombre négatif et positif
si il y a retenu l'ignorer

exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
-128-1
  10000000
 +11111111
__________
1 01111111           
nbr positif -->CF=1
 
127+1
  01111111
 +00000001
__________
1 10000000           
nbr negatif -->CF=1
 
127-1
 
  01111111
+ 11111111
__________
1 01111110
ignorer le 1, CF=0

normalement "sub al, 1" est équivalent à "add al, -1"... notez aussi que sur 1octet signé, en C2 les valeurs vont de -128 à 127, donc je ne vois pas pourquoi on aura une retenu pour -127-1.. aussi les résultats que donne SOA_j2EE m'intriguent beaucoup..

j'espère ne pas avoir dit de bêtises...

[Obsidian]

normalement "sub al, 1" est équivalent à "add al, -1"...

Pas tout-à-fait : dans les deux cas, le micro-processeur ignore s'il traite des nombres binaires négatifs signés ou des nombres binaire non-signés implicitement positifs.

notez aussi que sur 1octet signé, en C2 les valeurs vont de -128 à 127, donc je ne vois pas pourquoi on aura une retenu pour -127-1.. aussi les résultats que donne SOA_j2EE m'intriguent beaucoup.. j'espère ne pas avoir dit de bêtises...

Parce qu'encore une fois, ça dépend de la façon dont le micro-processeur va procéder pour effectuer sa soustraction. Et généralement, c'est en calculant d'abord le complément à deux, donc inversion et incrémentation, puis en effectuant une banale addition.

[Jean-Marc.Bourguet]

Et généralement, c'est en calculant d'abord le complément à deux, donc inversion et incrémentation, puis en effectuant une banale addition.

Généralement c'est plutôt en faisant une inversion puis l'addition en ayant trafiqué la carry entrante pour que celle-ci ait l'effet du +1 en plus.

[Obsidian]

Généralement c'est plutôt en faisant une inversion puis l'addition en ayant trafiqué la carry entrante pour que celle-ci ait l'effet du +1 en plus.

Tout-à-fait ! C'est d'ailleurs très pratique quand on construit un additionneur-soustracteur en filtrant l'un des ports d'entrées avec des OU exclusifs. Le même signal envoyé aux portes et à la retenue. C'est très appréciable :-)

[Belgitaes]

merci beoucoup pour les corrections

voila j´ai fait une simulacion du code avec un compilateur
c´est un compilateur pour les micro atmel
c´est pas pascal mais les principes sont les mêmes je croit
je vous montre le code fait avec mon compilateur et aussi
sa simulation avec PC sur un petit video fait avec camstudio
voici la page ou je l´ai placé

http://rapidshare.com/files/198286871/Code.zip.html

Code:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
 
; Definicion de constantes y variables
 
.def	AL	=r30
.def	AH	=r31
.def	CL	=r28
.def	CH	=r29
 
.EQU BH = (0)
.EQU BL = (-127)
.EQU SUB1 = (-1)
 
.EQU Entrada = (3) 
.EQU Salida = (-4) 
 
RESET:  cli ; Reset
;.............................................................
;Exemple 1:
 
ldi AH,BH   ; Valeur De 0 Dans AH
ldi AL,BL   ; Valeur De -127 Dans AL
out SPL,AL  ; Comme Je Suis Curieuse Je Regarde Les Valeurs
            ; Dans SREG Des Drapeux Et Dans SPL Les Valeurs Des Bits 
ldi CL,SUB1 ; Valeur De -1 Dans CL = FF
add AL,CL   ; J,aditionne Le Resultat Dans AL 
out SPL,AL  ; Je Regarde Les Valeurs Des Drapeaux Et Bits 
 
 
; Dans Cette Exercice J´ai Recu Un Carry Et Le Resultat 
; Seras 128 Dans SPL
;......................................................................
;Exemple 2:
 
ldi AH,BH   ; Valeur De 0 Dans AH
out SREG,AH ; J´en Profitte Pour Nettoyer SREG 
 
ldi AL,BL   ; Valeur De -127 Dans AL
out SPL,AL  ; Je Regarde Les Valeurs Dans SREG 
            ; Des Drapeux Et Dans SPL Les Valeurs Des Bits 
dec AL      ; Je Decremente De 1 AL = Sub   
out SPL,AL  ; Je Regarde Les Valeurs Des Drapeaux Et Bits 
 
; Dans Cette Exercice Pas De Carry Et Le Resultat 
; Seras 128 Dans SPL
;......................................................................
;Exemple 3:
 
ldi AH,BH      ; Valeur De 0 Dans AH
out SREG,AH    ; J´en Profitte Pour Nettoyer SREG 
ldi AL,Entrada ; Valeur De 3 Dans AL
ldi CH,Salida  ; Valeur De -4 Dans CH
sub AL,CH      ; Je Decremente De 4 AL 
out SPL,AL     ; Je Regarde Les Valeurs Des Drapeaux Et Bits 
 
; Dans Cette Exercice J´ai Recu Un Carry Et Le Resultat 
; Seras 7 Dans SPL
;......................................................................
 
STOP:        rjmp        STOP   ;Fin Del Programa