Why does a 4-bit adder / subtracter implement overflow detection by looking at BOTH the last two transactions?

Question

This is the diagram we gave for the class:

Why don't you just use C4 in this image? If C4 is 1, then the last addition led to overflow, which is of interest to us. Why do we need to look at C3?

Answer 1

the overflow flag indicates the overflow state for the <signed> signed strong> operation.

Some points to remember in a signed operation:

• MSB is always reserved to indicate the sign of a number
• Negative numbers are presented in 2 additions
• Overflow leads to invalid operation

Overflow rules for two additions:

• If the sum of two positive numbers gives a negative result, the amount is full.
• If the sum of two negative numbers gives a positive result, the amount is full.
• Otherwise, the amount is not overflowed.

Example:

**Ex1:** 111 (carry) 0101 ( 5) + 0011 ( 3) ================== 1000 ( 8) ;invalid (V=1) **Ex2:** 1011 (carry) 1001 (-7) + 1011 (−5) ================== 0100 ( 4) ;invalid (V=1) **Ex3:** 1110 (carry) 0111 ( 7) + 1110 (−2) ================== 0101 ( 5) ;valid (V=0) 

In a signed operation, if the two left carrier bits (those that are to the left of the top line in these examples) are 1 or two 0, the result is valid; if the left two carry bits are "1 0" or "0 1", the character overflowed. Conveniently, the XOR operation on these two bits can quickly determine if an overflow condition exists. (Ref: Two add-ons )

Overflow vs Curry :. Overflow can be considered as two additions to Carry’s form in the signed operation overflow flag, and the carry flag is ignored. Similarly, in an unsigned transaction transfer flag is controlled, and the overflow flag is ignored.

Answer 2

Overflow for signed numbers occurs when the transfer to the most significant bit is not equal to that performed.

For example, working with 8 bits 65 + 64 = 129 actually leads to overflow. This is due to the fact that it is 1000 0001 in binary format, which also amounts to -127 in 2 additions. If you are working with this example, you can see that this is the result of execution not equal to carry.

A correct calculation is possible, even if the carry flag is high.

Consider

  1000 1000 = -120 + 1111 1111 = -1 =(1) 10000111 = -121 

Running 1, but there was no overflow.