src/base/condcodes.hh
/**
 * Calculate the carry flag from an addition. This should work even when
 * a carry value is also added in.
 *
 * Parameters:
 *   dest: The result value of the addition.
 *   src1: One of the addends that was added.
 *   src2: The other addend that was added in.
 *
 * Rationale:
 *   This code analyzes the most sig. bits of the source addends and result,
 *   and deduces the carry out flag from them without needing the carry in bit.
 *
 *   Observe that we have four cases after an addition regarding the carry
 *   in and carry out bits:
 *
 *   If we have no carry in but a carry out:
 *     src1 and src2 must both be 1, with the result bit being 0. Hence,
 *     ~0 + 1 + 1 => 11, which has a high second bit. We return true.
 *
 *   If we have a carry in and a carry out:
 *     src1 and src2 can either be 1 and 0, or vice versa. In this case,
 *     the addition with the carry in gives a result bit of 0 but a carry out.
 *     Hence,
 *     ~0 + 1 + 0 => 10, or ~0 + 0 + 1 => 10. We return true.
 *
 *     Or, src1 and src2 can both be one. Along with the carry, this gives
 *     a result of 1 and a carry out of 1. Hence,
 *     ~1 + 1 + 1 => 10. We return true.
 *
 *   If we have no carry in and no carry out:
 *     src1 and src2 can either be 1 and 0, 0 and 1, or 0 and 0.
 *     In the first two cases the result bit is 1, which when negated does not
 *     contribute to the sum algorithm at all. In the last case the result bit
 *     is zero, but neither src1 nor src2 contribute to the sum either. Hence,
 *     ~1 + 1 + 0 => 1,
 *     ~1 + 0 + 1 => 1,
 *     ~0 + 0 + 0 => 1.
 *     So we return false for all of these cases.
 *
 *   If we have a carry in, but no carry out:
 *     src1 and src2 can neither be 1. So the overall result bit is 1. Hence:
 *     ~1 + 0 + 0 => 0. We return false.
 *
 * @ingroup api_base_utils
 */
Calculate the carry flag from an addition. This should work even when
a carry value is also added in.

The result value of the addition.
src1: One of the addends that was added.
src2: The other addend that was added in.

This code analyzes the most sig. bits of the source addends and result,
and deduces the carry out flag from them without needing the carry in bit.

Observe that we have four cases after an addition regarding the carry
in and carry out bits.

If we have no carry in but a carry out:
src1 and src2 must both be 1, with the result bit being 0. Hence,
~0 + 1 + 1 => 11, which has a high second bit. We return true.

If we have a carry in and a carry out:
src1 and src2 can either be 1 and 0, or vice versa. In this case,
the addition with the carry in gives a result bit of 0 but a carry out.

Or, src1 and src2 can both be one. Along with the carry, this gives
a result of 1 and a carry out of 1.

If we have no carry in and no carry out:
src1 and src2 can either be 1 and 0, 0 and 1, or 0 and 0.
In the first two cases the result bit is 1, which when negated does not
contribute to the sum algorithm at all. In the last case the result bit
is zero, but neither src1 nor src2 contribute to the sum either.

If we have a carry in, but no carry out:
src1 and src2 can neither be 1. So the overall result bit is 1.


Calculate the carry flag from an addition . This should work even when a carry value is also added in . The result value of the addition . src1 : One of the addends that was added . src2 : The other addend that was added in . This code analyzes the most sig . bits of the source addends and result and deduces the carry out flag from them without needing the carry in bit . Observe that we have four cases after an addition regarding the carry in and carry out bits . If we have no carry in but a carry out : src1 and src2 must both be 1 with the result bit being 0 . Hence ~0 + 1 + 1 = > 11 which has a high second bit . We return true . If we have a carry in and a carry out : src1 and src2 can either be 1 and 0 or vice versa . In this case the addition with the carry in gives a result bit of 0 but a carry out . Or src1 and src2 can both be one . Along with the carry this gives a result of 1 and a carry out of 1 . If we have no carry in and no carry out : src1 and src2 can either be 1 and 0 0 and 1 or 0 and 0 . In the first two cases the result bit is 1 which when negated does not contribute to the sum algorithm at all . In the last case the result bit is zero but neither src1 nor src2 contribute to the sum either . If we have a carry in but no carry out : src1 and src2 can neither be 1 . So the overall result bit is 1 .
static inline bool
findCarry(int width, uint64_t dest, uint64_t src1, uint64_t src2)
{
    int shift = width - 1;
    return ((~(dest >> shift) & 1) +
            ((src1 >> shift) & 1) +
            ((src2 >> shift) & 1)) & 0x2;
}
static inline bool findCarry ( int width , uint64_t dest , uint64_t src1 , uint64_t src2 ) { int shift = width - 1 ; return ( ( ~ ( dest >> shift ) & 1 ) + ( ( src1 >> shift ) & 1 ) + ( ( src2 >> shift ) & 1 ) ) & 0x2 ; }
Calculate the carry flag from an addition.
Calculate the carry flag from an addition .