Borrow and Carry Bit for Subtraction

Similar to the usage of the carry bit when adding there are mechanisms for subtracting that allow to integrate the result of subtraction of the lower bits into the subtraction of the next higher block of bits, where necessary.

There are two ways to do this, that are trivially equivalent by a simple not operation:

borrow bit (also borrow flag)
carry bit (also carry flag)

Often CPUs use what is the carry bit for addition and interpret it as borrow bit for subtraction.

Here are the two ways:

Borrow Bit

It is assumed, that the CPU-word is $n$ bits long, so calculations are performed modulo $N=2^n$ . Further it is assumed, that the range $0\ldots N-1$ is preferred, so all sign issues are excluded for the moment.

When subtracting two numbers $x$ , $y$ from each other like $x-y$ and $y > x$ , the provided result is

$x-y+N \equiv x-y \mod N$

and the borrow bit is set ( $b=1$ ), to indicate that the subtraction caused „underflow“, which had to be corrected by added $N$ in order to get into the desired range.

In the „normal“ case where $y \le x$ , the provided result is simply

$x-y$

and the borrow bit is not set ( $b=0$ ).

The next round of subtraction takes the borrow bit into account and calculates $x-y-b$ , where the condition becomes $y+b > x$ and the result is

$x-y-b+N \equiv x-y \mod N$

$x-y-b$

respectively. This is how some of the older readers used to do it in school on paper, but of course with $N=10$ .

Now the typical integer arithmetic of current CPUs uses Two’s complement, which means that $-y=(\mathrm{NOT}\; y)+1$ . Combining this with the previous results in calculating

$x-y = x + (\mathrm{NOT}\; y) + 1 - b \mod N$

At this point some CPU-designers found it more natural, to use the carry bit $c=1-b$ instead of the borrow bit $b$ .

Carry Bit

When subtracting two numbers $x$ , $y$ from each other like $x-y$ and we have $y > x$ , the provided result is

$x-y+N \equiv x-y \mod N$

and the carry bit is not set ( $c=0$ ), to indicate that the subtraction caused „underflow“, which had to be corrected by added $N$ in order to get into the desired range.

In the „normal“ case where $y \le x$ , the provided result is simply

$x-y$

and the carry bit is set ( $c=1$ ).

The next round of subtraction takes the borrow bit into account and calculates $x-y-1+c$ , where the condition becomes $y+1-c > x$ and the result is

$x-y-1+c+N \equiv x-y \mod N$

$x-y-1+c$

respectively.

Now two’s complement with $-y=(\mathrm{NOT}\; y)+1$ this can be written as

$x-y = x + (\mathrm{NOT}\; y) + 1 - b \mod N$

or with $c=1-b$

$x-y = x + (\mathrm{NOT}\; y) + c \mod N$

These two ways are really equivalent and easily transformed into each other. Neither of them provides big advantages, apart from the fact that we have the unnecessary confusion, because it depends on the CPU design, which of the two variants is used.

Recovery of Borrow or Carry bit

The borrow bit is calculated and used during subtractions that are done at assembly language level, but higher languages like C or Java do provide access to this information. It is relatively easy to recover the carry bit in the case of addition based on $x$ , $y$ and $x+y \mod N$ .

This possible as well for the subtraction. Quite easily the comparison between $x$ and $y$ or $y+b$ could be done before the subtraction. This would work, but it is kind of inefficient, because under the hood the comparison is just a subtraction with discarding the result and keeping the flags. So the subtraction is performed twice. This might not be such a bad idea, because a compiler could recognize it or the work of subtracting twice could be neglectable compared to the logic for an „optimized“ recovery, based on some logic expression of certain bits from $x$ , $y$ and $x-y \mod N$ .

Borrow Bit

Carry Bit

Recovery of Borrow or Carry bit

Links

Beteilige dich an der Unterhaltung

Schreibe einen Kommentar

Antworten abbrechen