Carry can be a difficult concept to understand. Hopefully this page will help.

If you went to school in an English-speaking country, you might be familiar with the word in this context but it is still confusing. If you speak another language you probably have a word for it too.

For example, when adding two numbers:

27 + 35 ----

You can do this easily but consider it at a methodical level. We add seven to five to get twelve; we write a 2 and "carry" the 1 to the next column:

27 + 35 ---- 2 1

Next we add two, three and the "carried" one to get six and hence the result:

27 + 35 ---- 62 1

That's great. Now let's do it in binary.

%01 + %01 ----- %10 1

There: we "carried" a 1 from bit 0 into bit 1 of the result. For a more realistic case:

%11111111 + %00000001 ----------- %100000000

The problem here is that the result is bigger than 8 bits; so, we cut off the 1 at the start and store that in the carry bit. This tells us that there was a "carry out" of the high bit of the result and a "carry in" to the Carry flag.

You may remember that at school there was something similar for subtraction; sometimes, you need to "borrow" from the next digit to have enough to make a positive result. Example:

43 - 15 ----

You can't subtract five from three, so you "borrow" one from the next column; thirteen minus five is eight:

1 3 3 - 1 5 ------ 8

The next digit is then found by subtracting one from three and it is finished.

1 3 3 - 1 5 ----- 2 8

In binary, much the same happens:

%110 - %101 ------ %001

As we get up to eight bits, sometimes we need to "borrow" from an imaginary ninth column:

%00000000 %100000000 - %10000000 - %010000000 ----------- ------------ ???????? %010000000

In these cases, we just "borrow" whatever we need to make it possible to get a result; the carry bit can tell whether anything was "borrowed" from the imaginary ninth bit. You can also describe it as a "carry in" to the high bit from the Carry flag.

Whenever an addition would make a result bigger then eight bits, the carry flag will become `1`

; you can use this (with instructions like `adc`

) to add that "carry out" onto another byte so you can effectively chain bytes together to make large numbers.

When a subtraction would make a negative number, the carry flag will become `1`

and the result will instead be that negative number plus 256 (in signed notation; in two's complement notation it is a negative number).

When using the carry/no carry conditions with decrements in Z80 code, you need to remember that it becomes `1`

on the transition from 0 to -1, which is one step later than the transition from 1 to 0 which triggers the zero condition. This can be useful or equally a tricky bug to discover.

Retrieved from //www.smspower.org/Development/Carry

Page last modified on Fri May 14, 2010 9:25 am