Carry und Overflow flag?

Wann wird Overflow, wann carry und wann beides gesetzt? Dabei gehts mir wies hardware technisch aussieht:

 0111
+0001
01000 => carrys
------
01000 =>result
=========
In arm nur V flag (overflow gesetzt)

.

 10011
+11001
100110 =>carrys
-----------
101100 =>result
=========
beides gesetzt

.

 11100
+00110
111000 =>carrys
------
100010 =>result
=======
carry nur gesetzt

Wie man sieht, ist das letzte carry gleichzeitig das carry bit. Beim overflow aber komplexer. Warum ist das so? Wann erkennt er den overflow und woran?

Answer 1

[KarlRanseierIII]

Nehmen wir mal folgendes:

0110 0100 (100)
0001 1110 ( 30)
1000 0010 (130 - unsigned)

Für Signed ergibt sich hierbei aber ein Überlauf, denn als Signed ist der Wert negativ. Zu einem Übertrag führt es aber noch nicht, weil die Bitstellen ausreichen.

Schau mal in die ISA-Doku, da wird das ja festgelegt. (Damit meine ich, für jede OP wird festgelegt, wann welche Flags gesetzt werden)

Answer 2

[Domainname]

Overflow: Wenn das Ergebnis größer ist als der Datentyp an Bits offeriert (zB 2^30 * 2^50 Integermultiplikation), das heißt ceil(ln(ERGEBNIS)/ln(2)) > sizeof(DATENTYP) * 8

Carry: Wenn binär zwei Zahlen addiert werden und für die i-te Position gilt: (bitsA[i] UND bitsB[i]) = 1 UND (bitsA[i] XOR bitsB[i]) = 0.

Und Gott alleine weiß es am allerbesten und besser.

Comments

[TheStalker64]

Das Carry bit ist doch das letzte carry bit. Also wenn 32. bit beider zahlen 1 ist und somit das "33." bit 1 ist.

Das overflow bit soll irwie per XOR errechnet werden laut wiki:

Internally, the overflow flag is usually generated by an  exclusive or of the internal  carry  into and  out of the sign bit.

https://en.wikipedia.org/wiki/Overflow_flag

Frage ist nun, was xor er da genau? 3 bits? Also das Carry, 1. sign bit und 2. sign bit?

[Domainname]

@TheStalker64

Carry ist einfach der Übertrag. Wenn du 55 + 19 rechnest, musst du doch (wenn du spaltenweise addierst) eine 1 im Hinterkopf behalten wenn, also

5 5

1 9

Zuerst 9 + 5 sind 14, du schreibst die 4 hin, behälst (überträgst) die 1 auf

5 + 1 = 6 + 1 = 7 also 74...

Overflow ist, wenn du zB 32 bit Interger hast, du aber ein Ergebnis berechnest, das über 32 bits hinausgeht. Das macht die CPU meines Wissens so, dass dieser erstmal spaltenweise alles addiert, und bei der LETZTEN Spalte macht er folgendes:

(BitsA[i] UND BitsB[i]) = 1 ODER ~((BitsA[i] ODER BitsB[i]) = 1 UND (BitsA[i] ODER BitsB[i]) XOR CARRY) = 0)

Wenn da 1 raus kommt, wird der Overflow-Flag gesetzt.

Und Gott alleine weiß es am allerbesten und besser.

[Domainname]

@Domainname

Erratum: *vorletzten Spalte. Die letzte Spalte ist ja eigentlich das sign-Bit.

'

[TheStalker64]

@Domainname

Also ists praktisch so:

 01
+01
010 => das sind die jeweiligen carrys
---
 10

Weil nun bei den jeweiligen carrys das 3. bit und das 2. bit XOR==1 ist, daher overflow

 11
+01
110 => das sind die jeweiligen carrys
---
 10

das 3. bit XOR 2. bit == 0

kein overflow

aber ein carry

[Domainname]

@TheStalker64

Das letzte ist ein overflow.

Wir haben doch gesagt: Wenn eines der Bits in der letzten Spalte XOR mit Carry 0 ergibt, dann ist overflow Flag eingeschaltet. Also: (0 ODER 1) XOR 1 = 0, das negiert ergibt 1.

-