Why the carry flag is set in this substitution equation?

Question

In this article, it says the following:

1111 + 0001 = 0000 (carry flag is turned on)

As far as I know, a carry happens when the result does not fit in a certain number of bits (4 bits in this example), so the above equation indeed caused a carry (because the result is in effect 10000, which does not fit in 4 bits).

---

But look at the following from the same article:

0000 - 0001 = 1111 (carry flag is turned on)

I don't understand why the carry flag is set in this case, I mean the result is 1111, so it fits in 4 bits!

Answer 1

we know from grade school that a - b = a + (-b) and we know that using twos complement to negate something means invert and add one. and some know that processors dont subtract they add instead so

  0000
 -0001
=======

is really

      1
   0000
+  1110
========

invert and add one, since we have to carry in anyway we add the one there rather than do extra work. so we invert the carry in and we invert the second operand on the way into the adder.

  00001
   0000
+  1110
========
   1111

And you are correct that is the answer but some processors invert the carry out, and it sounds like the one you are using does that. Why? Because if you examine some other sets of numbers you see that the bit can be used as a borrow or not borrow bit rather than an unsigned overflow which is what it means for unsigned numbers, as in this case. 0000 + 1111 = 1111 which is not an unsigned overflow.

So from one architecture to the next (ARM, MIPS, AVR, x86, etc) if you want to use that flag (well not MIPS) you read the documentation, or do an experiment as the docs are not that good on this topic. Sometimes the add with carry or subtract with borrow instructions will hint at which way that architecture works (inverts the carry flag on the way out of a subtract).

Answer 2

On most CPUs (including x86 CPUs) the carry flag behaves the following way for both addition and subtraction:

The carry flag is the highest bit of the result when extending the "length" of the numbers by one bit.

Example:

 1110 +  0011 = 01110 + 00010 (extending 4 bits to 5 bits)
01110 + 00011 = 10001 (5 bit result)
 1110 +  0011 =  0001, Carry=1 (highest of the 5 bits is the carry flag)

 0010 -  0011 = 00010 - 00010 (extending 4 bits to 5 bits)
00010 - 00011 = 11111 (5 bit result)
 0010 -  0011  = 1111, Carry=1 (highest of the 5 bits is the carry flag)

(However there are CPUs where the carry flag bahaves differently on subtractions; Example: the historic 6502)

Answer 3

If you disregard the size of the type, then

1111 + 0001 = 10000

That is why you get a carry (simply to indicate that the result is larger than the stored 0). This is important if you must add additional (hex) "digits".

---

With subtraction, you can get a similar problem:

0000 - 0001 = 1111

That actually says: 0 - 1 = 15. That is not true, so the carry is set to indicate that a borrow was performed, i.e. that, more or less, the following is performed:

10000 - 0001 = 1111 (16 - 1 = 15)

You do the same when you subtract in decimal:

    34
    18
  ---- -

To subtract 8 from 4, you must borrow 1 from the next digit, to get 14 − 8 = 6. That borrow is needed to get the subtraction of the next pair of higher digits right. 3 − 1 = 2, but you must subtract the borrow too, so now 3 − 1 − borrow = 1. That is why you (correctly) get 16 and not 26 as a result.

    34
    18
  ---- -
    16

The binary borrow has the same function: it is stored in the carry flag and can be subtracted (e.g. in x86 assembler), using SBB (subtract with borrow) instead of a plain SUB (subtract). The value of the carry flag (which is functioning as a "borrow flag" now) is additionally subtracted from the two operands:

Value1  DW      0x1234  ; alternatively: DB 0x34,0x12
Value2  DW      0x0678  ;                DB 0x78,0x06  
Result  DW      0

        MOV     AL,BYTE PTR [Value1]      ; 0011 0100
        SUB     AL,BYTE PTR [Value2]      ; 0111 1000
        MOV     BYTE PTR [Result],AL      ; 0xBC = 1011 1100, but a borrow was needed!
        MOV     AL,BYTE PTR [Value1 + 1]  ; 0001 0010
        SBB     AL,BYTE PTR [Value2 + 1]  ; 0000 0110 (0x12 - 0x06 - carry = 0x0B)
        MOV     BYTE PTR [Result + 1],AL  ; 0x0B = 0000 1011 

Answer 4

So you said that this equation...

0000 - 0001 = 1111 (carry flag is on)

... set Carry flag on?

Yes, it will because when Addition is performed Carry will set when data is overflowed! In case of Subtraction operation Carry flag is Borrow flag.

As you can see in Intels 8085 Programming Guide, Subtraction complements the carry flag!

How "SBB" works explained in Intel's 8085 Programming Guide!

That equation generates no carry, but Complemented by Subtraction! Hope it helps!