int128.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	INT128

Macros
#define	USE_NATIVE_INT128   0
#define	PG_INT128_HI_INT64(i128)   ((i128).hi)
#define	PG_INT128_LO_UINT64(i128)   ((i128).lo)
#define	INT64_HI_INT32(i64)   ((int32) ((i64) >> 32))
#define	INT64_LO_UINT32(i64)   ((uint32) (i64))

Functions
static INT128	make_int128 (int64 hi, uint64 lo)
static void	int128_add_uint64 (INT128 *i128, uint64 v)
static void	int128_add_int64 (INT128 *i128, int64 v)
static void	int128_add_int128 (INT128 *i128, INT128 v)
static void	int128_sub_uint64 (INT128 *i128, uint64 v)
static void	int128_sub_int64 (INT128 *i128, int64 v)
static void	int128_add_int64_mul_int64 (INT128 *i128, int64 x, int64 y)
static void	int128_sub_int64_mul_int64 (INT128 *i128, int64 x, int64 y)
static void	int128_div_mod_int32 (INT128 *i128, int32 v, int32 *remainder)
static bool	int128_is_zero (INT128 x)
static int	int128_sign (INT128 x)
static int	int128_compare (INT128 x, INT128 y)
static INT128	int64_to_int128 (int64 v)
static int64	int128_to_int64 (INT128 val)

Macro Definition Documentation

INT64_HI_INT32

#define INT64_HI_INT32

(

i64

)

((int32) ((i64) >> 32))

Definition at line 196 of file int128.h.

INT64_LO_UINT32

#define INT64_LO_UINT32

(

i64

)

((uint32) (i64))

Definition at line 197 of file int128.h.

PG_INT128_HI_INT64

#define PG_INT128_HI_INT64

(

i128

)

((i128).hi)

Definition at line 65 of file int128.h.

PG_INT128_LO_UINT64

#define PG_INT128_LO_UINT64

(

i128

)

((i128).lo)

Definition at line 66 of file int128.h.

USE_NATIVE_INT128

#define USE_NATIVE_INT128   0

Definition at line 28 of file int128.h.

Function Documentation

int128_add_int128()

static void int128_add_int128 ( INT128 *  i128, INT128  v  )

inlinestatic

Definition at line 144 of file int128.h.

{
#if USE_NATIVE_INT128
    *i128 += v;
#else
    int128_add_uint64(i128, v.lo);
    i128->hi += v.hi;
#endif
}

References INT128::hi, int128_add_uint64(), and INT128::lo.

Referenced by int8_avg_combine(), and numeric_poly_combine().

int128_add_int64()

static void int128_add_int64 ( INT128 *  i128, int64  v  )

inlinestatic

Definition at line 117 of file int128.h.

{
#if USE_NATIVE_INT128
    *i128 += v;
#else
    /*
     * This is much like the above except that the carry logic differs for
     * negative v -- we need to subtract 1 from the .hi part if the new .lo
     * value is greater than the old .lo value.  That can be achieved without
     * any branching by adding the sign bit from v (v >> 63 = 0 or -1) to the
     * previous result (for negative v, if the new .lo value is less than the
     * old .lo value, the two terms cancel and we leave the .hi part
     * unchanged, otherwise we subtract 1 from the .hi part).  With modern
     * compilers this often produces machine code identical to the native
     * code.
     */
    uint64      oldlo = i128->lo;
 
    i128->lo += v;
    i128->hi += (i128->lo < oldlo) + (v >> 63);
#endif
}

References INT128::hi, and INT128::lo.

Referenced by do_int128_accum().

int128_add_int64_mul_int64()

static void int128_add_int64_mul_int64 ( INT128 *  i128, int64  x, int64  y  )

inlinestatic

Definition at line 203 of file int128.h.

{
#if USE_NATIVE_INT128
    /*
     * XXX with a stupid compiler, this could actually be less efficient than
     * the non-native implementation; maybe we should do it by hand always?
     */
    *i128 += (int128) x * (int128) y;
#else
    /* INT64_HI_INT32 must use arithmetic right shift */
    StaticAssertDecl(((int64) -1 >> 1) == (int64) -1,
                     "arithmetic right shift is needed");
 
    /*----------
     * Form the 128-bit product x * y using 64-bit arithmetic.
     * Considering each 64-bit input as having 32-bit high and low parts,
     * we can compute
     *
     *   x * y = ((x.hi << 32) + x.lo) * (((y.hi << 32) + y.lo)
     *         = (x.hi * y.hi) << 64 +
     *           (x.hi * y.lo) << 32 +
     *           (x.lo * y.hi) << 32 +
     *           x.lo * y.lo
     *
     * Each individual product is of 32-bit terms so it won't overflow when
     * computed in 64-bit arithmetic.  Then we just have to shift it to the
     * correct position while adding into the 128-bit result.  We must also
     * keep in mind that the "lo" parts must be treated as unsigned.
     *----------
     */
 
    /* No need to work hard if product must be zero */
    if (x != 0 && y != 0)
    {
        int32       x_hi = INT64_HI_INT32(x);
        uint32      x_lo = INT64_LO_UINT32(x);
        int32       y_hi = INT64_HI_INT32(y);
        uint32      y_lo = INT64_LO_UINT32(y);
        int64       tmp;
 
        /* the first term */
        i128->hi += (int64) x_hi * (int64) y_hi;
 
        /* the second term: sign-extended with the sign of x */
        tmp = (int64) x_hi * (int64) y_lo;
        i128->hi += INT64_HI_INT32(tmp);
        int128_add_uint64(i128, ((uint64) INT64_LO_UINT32(tmp)) << 32);
 
        /* the third term: sign-extended with the sign of y */
        tmp = (int64) x_lo * (int64) y_hi;
        i128->hi += INT64_HI_INT32(tmp);
        int128_add_uint64(i128, ((uint64) INT64_LO_UINT32(tmp)) << 32);
 
        /* the fourth term: always unsigned */
        int128_add_uint64(i128, (uint64) x_lo * (uint64) y_lo);
    }
#endif
}

References INT128::hi, int128_add_uint64(), INT64_HI_INT32, INT64_LO_UINT32, StaticAssertDecl, x, and y.

Referenced by do_int128_accum(), int64_div_fast_to_numeric(), and interval_cmp_value().

int128_add_uint64()

static void int128_add_uint64 ( INT128 *  i128, uint64  v  )

inlinestatic

Definition at line 92 of file int128.h.

{
#if USE_NATIVE_INT128
    *i128 += v;
#else
    /*
     * First add the value to the .lo part, then check to see if a carry needs
     * to be propagated into the .hi part.  Since this is unsigned integer
     * arithmetic, which is just modular arithmetic, a carry is needed if the
     * new .lo part is less than the old .lo part (i.e., if modular
     * wrap-around occurred).  Writing this in the form below, rather than
     * using an "if" statement causes modern compilers to produce branchless
     * machine code identical to the native code.
     */
    uint64      oldlo = i128->lo;
 
    i128->lo += v;
    i128->hi += (i128->lo < oldlo);
#endif
}

References INT128::hi, and INT128::lo.

Referenced by int128_add_int128(), and int128_add_int64_mul_int64().

int128_compare()

static int int128_compare ( INT128  x, INT128  y  )

inlinestatic

Definition at line 425 of file int128.h.

{
#if USE_NATIVE_INT128
    if (x < y)
        return -1;
    if (x > y)
        return 1;
    return 0;
#else
    if (x.hi < y.hi)
        return -1;
    if (x.hi > y.hi)
        return 1;
    if (x.lo < y.lo)
        return -1;
    if (x.lo > y.lo)
        return 1;
    return 0;
#endif
}

References x, and y.

Referenced by interval_cmp_internal(), and interval_sign().

int128_div_mod_int32()

static void int128_div_mod_int32 ( INT128 *  i128, int32  v, int32 *  remainder  )

inlinestatic

Definition at line 308 of file int128.h.

{
#if USE_NATIVE_INT128
    int128      old_i128 = *i128;
 
    *i128 /= v;
    *remainder = (int32) (old_i128 - *i128 * v);
#else
    /*
     * To avoid any intermediate values overflowing (as happens if INT64_MIN
     * is divided by -1), we first compute the quotient abs(*i128) / abs(v)
     * using unsigned 64-bit arithmetic, and then fix the signs up at the end.
     *
     * The quotient is computed using the short division algorithm described
     * in Knuth volume 2, section 4.3.1 exercise 16 (cf. div_var_int() in
     * numeric.c).  Since the absolute value of the divisor is known to be at
     * most 2^31, the remainder carried from one digit to the next is at most
     * 2^31 - 1, and so there is no danger of overflow when this is combined
     * with the next digit (a 32-bit unsigned integer).
     */
    uint64      n_hi;
    uint64      n_lo;
    uint32      d;
    uint64      q;
    uint64      r;
    uint64      tmp;
 
    /* numerator: absolute value of *i128 */
    if (i128->hi < 0)
    {
        n_hi = 0 - ((uint64) i128->hi);
        n_lo = 0 - i128->lo;
        if (n_lo != 0)
            n_hi--;
    }
    else
    {
        n_hi = i128->hi;
        n_lo = i128->lo;
    }
 
    /* denomimator: absolute value of v */
    d = abs(v);
 
    /* quotient and remainder of high 64 bits */
    q = n_hi / d;
    r = n_hi % d;
    n_hi = q;
 
    /* quotient and remainder of next 32 bits (upper half of n_lo) */
    tmp = (r << 32) + (n_lo >> 32);
    q = tmp / d;
    r = tmp % d;
 
    /* quotient and remainder of last 32 bits (lower half of n_lo) */
    tmp = (r << 32) + (uint32) n_lo;
    n_lo = q << 32;
    q = tmp / d;
    r = tmp % d;
    n_lo += q;
 
    /* final remainder should have the same sign as *i128 */
    *remainder = i128->hi < 0 ? (int32) (0 - r) : (int32) r;
 
    /* store the quotient in *i128, negating it if necessary */
    if ((i128->hi < 0) != (v < 0))
    {
        n_hi = 0 - n_hi;
        n_lo = 0 - n_lo;
        if (n_lo != 0)
            n_hi--;
    }
    i128->hi = (int64) n_hi;
    i128->lo = n_lo;
#endif
}

References INT128::hi, INT128::lo, and remainder.

Referenced by int128_to_numericvar().

int128_is_zero()

static bool int128_is_zero ( INT128  x )

inlinestatic

Definition at line 389 of file int128.h.

{
#if USE_NATIVE_INT128
    return x == 0;
#else
    return x.hi == 0 && x.lo == 0;
#endif
}

References x.

Referenced by int128_to_numericvar().

int128_sign()

static int int128_sign ( INT128  x )

inlinestatic

Definition at line 402 of file int128.h.

{
#if USE_NATIVE_INT128
    if (x < 0)
        return -1;
    if (x > 0)
        return 1;
    return 0;
#else
    if (x.hi < 0)
        return -1;
    if (x.hi > 0)
        return 1;
    if (x.lo > 0)
        return 1;
    return 0;
#endif
}

References x.

Referenced by int128_to_numericvar().

int128_sub_int64()

static void int128_sub_int64 ( INT128 *  i128, int64  v  )

inlinestatic

Definition at line 179 of file int128.h.

{
#if USE_NATIVE_INT128
    *i128 -= v;
#else
    /* Like int128_add_int64() with the sign of v inverted */
    uint64      oldlo = i128->lo;
 
    i128->lo -= v;
    i128->hi -= (i128->lo > oldlo) + (v >> 63);
#endif
}

References INT128::hi, and INT128::lo.

Referenced by do_int128_discard().

int128_sub_int64_mul_int64()

static void int128_sub_int64_mul_int64 ( INT128 *  i128, int64  x, int64  y  )

inlinestatic

Definition at line 266 of file int128.h.

{
#if USE_NATIVE_INT128
    *i128 -= (int128) x * (int128) y;
#else
    /* As above, except subtract the 128-bit product */
    if (x != 0 && y != 0)
    {
        int32       x_hi = INT64_HI_INT32(x);
        uint32      x_lo = INT64_LO_UINT32(x);
        int32       y_hi = INT64_HI_INT32(y);
        uint32      y_lo = INT64_LO_UINT32(y);
        int64       tmp;
 
        /* the first term */
        i128->hi -= (int64) x_hi * (int64) y_hi;
 
        /* the second term: sign-extended with the sign of x */
        tmp = (int64) x_hi * (int64) y_lo;
        i128->hi -= INT64_HI_INT32(tmp);
        int128_sub_uint64(i128, ((uint64) INT64_LO_UINT32(tmp)) << 32);
 
        /* the third term: sign-extended with the sign of y */
        tmp = (int64) x_lo * (int64) y_hi;
        i128->hi -= INT64_HI_INT32(tmp);
        int128_sub_uint64(i128, ((uint64) INT64_LO_UINT32(tmp)) << 32);
 
        /* the fourth term: always unsigned */
        int128_sub_uint64(i128, (uint64) x_lo * (uint64) y_lo);
    }
#endif
}

References INT128::hi, int128_sub_uint64(), INT64_HI_INT32, INT64_LO_UINT32, x, and y.

Referenced by do_int128_discard().

int128_sub_uint64()

static void int128_sub_uint64 ( INT128 *  i128, uint64  v  )

inlinestatic

Definition at line 158 of file int128.h.

{
#if USE_NATIVE_INT128
    *i128 -= v;
#else
    /*
     * This is like int128_add_uint64(), except we must propagate a borrow to
     * (subtract 1 from) the .hi part if the new .lo part is greater than the
     * old .lo part.
     */
    uint64      oldlo = i128->lo;
 
    i128->lo -= v;
    i128->hi -= (i128->lo > oldlo);
#endif
}

References INT128::hi, and INT128::lo.

Referenced by int128_sub_int64_mul_int64().

int128_to_int64()

static int64 int128_to_int64 ( INT128  val )

inlinestatic

Definition at line 468 of file int128.h.

{
#if USE_NATIVE_INT128
    return (int64) val;
#else
    return (int64) val.lo;
#endif
}

References val.

Referenced by interval_hash(), and interval_hash_extended().

int64_to_int128()

static INT128 int64_to_int128 ( int64  v )

inlinestatic

Definition at line 450 of file int128.h.

{
#if USE_NATIVE_INT128
    return (INT128) v;
#else
    INT128      val;
 
    val.lo = (uint64) v;
    val.hi = (v < 0) ? -INT64CONST(1) : INT64CONST(0);
    return val;
#endif
}

References INT64CONST, and val.

Referenced by int64_div_fast_to_numeric(), interval_cmp_value(), and interval_sign().

make_int128()

static INT128 make_int128 ( int64  hi, uint64  lo  )

inlinestatic

Definition at line 75 of file int128.h.

{
#if USE_NATIVE_INT128
    return (((int128) hi) << 64) + lo;
#else
    INT128      val;
 
    val.hi = hi;
    val.lo = lo;
    return val;
#endif
}

References val.

Referenced by int128_deserialize().