include/qemu/int128.h

   1 #ifndef INT128_H
   2 #define INT128_H
   3
   4
   5 typedef struct Int128 Int128;
   6
   7 struct Int128 {
   8     uint64_t lo;
   9     int64_t hi;
  10 };
  11
  12 static inline Int128 int128_make64(uint64_t a)
  13 {
  14     return (Int128) { a, 0 };
  15 }
  16
  17 static inline uint64_t int128_get64(Int128 a)
  18 {
  19     assert(!a.hi);
  20     return a.lo;
  21 }
  22
  23 static inline Int128 int128_zero(void)
  24 {
  25     return int128_make64(0);
  26 }
  27
  28 static inline Int128 int128_one(void)
  29 {
  30     return int128_make64(1);
  31 }
  32
  33 static inline Int128 int128_2_64(void)
  34 {
  35     return (Int128) { 0, 1 };
  36 }
  37
  38 static inline Int128 int128_exts64(int64_t a)
  39 {
  40     return (Int128) { .lo = a, .hi = (a < 0) ? -1 : 0 };
  41 }
  42
  43 static inline Int128 int128_and(Int128 a, Int128 b)
  44 {
  45     return (Int128) { a.lo & b.lo, a.hi & b.hi };
  46 }
  47
  48 static inline Int128 int128_rshift(Int128 a, int n)
  49 {
  50     int64_t h;
  51     if (!n) {
  52         return a;
  53     }
  54     h = a.hi >> (n & 63);
  55     if (n >= 64) {
  56         return (Int128) { h, h >> 63 };
  57     } else {
  58         return (Int128) { (a.lo >> n) | ((uint64_t)a.hi << (64 - n)), h };
  59     }
  60 }
  61
  62 static inline Int128 int128_add(Int128 a, Int128 b)
  63 {
  64     uint64_t lo = a.lo + b.lo;
  65
  66     /* a.lo <= a.lo + b.lo < a.lo + k (k is the base, 2^64).  Hence,
  67      * a.lo + b.lo >= k implies 0 <= lo = a.lo + b.lo - k < a.lo.
  68      * Similarly, a.lo + b.lo < k implies a.lo <= lo = a.lo + b.lo < k.
  69      *
  70      * So the carry is lo < a.lo.
  71      */
  72     return (Int128) { lo, (uint64_t)a.hi + b.hi + (lo < a.lo) };
  73 }
  74
  75 static inline Int128 int128_neg(Int128 a)
  76 {
  77     uint64_t lo = -a.lo;
  78     return (Int128) { lo, ~(uint64_t)a.hi + !lo };
  79 }
  80
  81 static inline Int128 int128_sub(Int128 a, Int128 b)
  82 {
  83     return (Int128){ a.lo - b.lo, (uint64_t)a.hi - b.hi - (a.lo < b.lo) };
  84 }
  85
  86 static inline bool int128_nonneg(Int128 a)
  87 {
  88     return a.hi >= 0;
  89 }
  90
  91 static inline bool int128_eq(Int128 a, Int128 b)
  92 {
  93     return a.lo == b.lo && a.hi == b.hi;
  94 }
  95
  96 static inline bool int128_ne(Int128 a, Int128 b)
  97 {
  98     return !int128_eq(a, b);
  99 }
 100
 101 static inline bool int128_ge(Int128 a, Int128 b)
 102 {
 103     return a.hi > b.hi || (a.hi == b.hi && a.lo >= b.lo);
 104 }
 105
 106 static inline bool int128_lt(Int128 a, Int128 b)
 107 {
 108     return !int128_ge(a, b);
 109 }
 110
 111 static inline bool int128_le(Int128 a, Int128 b)
 112 {
 113     return int128_ge(b, a);
 114 }
 115
 116 static inline bool int128_gt(Int128 a, Int128 b)
 117 {
 118     return !int128_le(a, b);
 119 }
 120
 121 static inline bool int128_nz(Int128 a)
 122 {
 123     return a.lo || a.hi;
 124 }
 125
 126 static inline Int128 int128_min(Int128 a, Int128 b)
 127 {
 128     return int128_le(a, b) ? a : b;
 129 }
 130
 131 static inline Int128 int128_max(Int128 a, Int128 b)
 132 {
 133     return int128_ge(a, b) ? a : b;
 134 }
 135
 136 static inline void int128_addto(Int128 *a, Int128 b)
 137 {
 138     *a = int128_add(*a, b);
 139 }
 140
 141 static inline void int128_subfrom(Int128 *a, Int128 b)
 142 {
 143     *a = int128_sub(*a, b);
 144 }
 145
 146 #endif