include/qemu/int128.h

   1 #ifndef INT128_H
   2 #define INT128_H
   3
   4 #ifdef CONFIG_INT128
   5
   6 typedef __int128_t Int128;
   7
   8 static inline Int128 int128_make64(uint64_t a)
   9 {
  10     return a;
  11 }
  12
  13 static inline uint64_t int128_get64(Int128 a)
  14 {
  15     uint64_t r = a;
  16     assert(r == a);
  17     return r;
  18 }
  19
  20 static inline uint64_t int128_getlo(Int128 a)
  21 {
  22     return a;
  23 }
  24
  25 static inline int64_t int128_gethi(Int128 a)
  26 {
  27     return a >> 64;
  28 }
  29
  30 static inline Int128 int128_zero(void)
  31 {
  32     return 0;
  33 }
  34
  35 static inline Int128 int128_one(void)
  36 {
  37     return 1;
  38 }
  39
  40 static inline Int128 int128_2_64(void)
  41 {
  42     return (Int128)1 << 64;
  43 }
  44
  45 static inline Int128 int128_exts64(int64_t a)
  46 {
  47     return a;
  48 }
  49
  50 static inline Int128 int128_and(Int128 a, Int128 b)
  51 {
  52     return a & b;
  53 }
  54
  55 static inline Int128 int128_rshift(Int128 a, int n)
  56 {
  57     return a >> n;
  58 }
  59
  60 static inline Int128 int128_add(Int128 a, Int128 b)
  61 {
  62     return a + b;
  63 }
  64
  65 static inline Int128 int128_neg(Int128 a)
  66 {
  67     return -a;
  68 }
  69
  70 static inline Int128 int128_sub(Int128 a, Int128 b)
  71 {
  72     return a - b;
  73 }
  74
  75 static inline bool int128_nonneg(Int128 a)
  76 {
  77     return a >= 0;
  78 }
  79
  80 static inline bool int128_eq(Int128 a, Int128 b)
  81 {
  82     return a == b;
  83 }
  84
  85 static inline bool int128_ne(Int128 a, Int128 b)
  86 {
  87     return a != b;
  88 }
  89
  90 static inline bool int128_ge(Int128 a, Int128 b)
  91 {
  92     return a >= b;
  93 }
  94
  95 static inline bool int128_lt(Int128 a, Int128 b)
  96 {
  97     return a < b;
  98 }
  99
 100 static inline bool int128_le(Int128 a, Int128 b)
 101 {
 102     return a <= b;
 103 }
 104
 105 static inline bool int128_gt(Int128 a, Int128 b)
 106 {
 107     return a > b;
 108 }
 109
 110 static inline bool int128_nz(Int128 a)
 111 {
 112     return a != 0;
 113 }
 114
 115 static inline Int128 int128_min(Int128 a, Int128 b)
 116 {
 117     return a < b ? a : b;
 118 }
 119
 120 static inline Int128 int128_max(Int128 a, Int128 b)
 121 {
 122     return a > b ? a : b;
 123 }
 124
 125 static inline void int128_addto(Int128 *a, Int128 b)
 126 {
 127     *a += b;
 128 }
 129
 130 static inline void int128_subfrom(Int128 *a, Int128 b)
 131 {
 132     *a -= b;
 133 }
 134
 135 #else /* !CONFIG_INT128 */
 136
 137 typedef struct Int128 Int128;
 138
 139 struct Int128 {
 140     uint64_t lo;
 141     int64_t hi;
 142 };
 143
 144 static inline Int128 int128_make64(uint64_t a)
 145 {
 146     return (Int128) { a, 0 };
 147 }
 148
 149 static inline uint64_t int128_get64(Int128 a)
 150 {
 151     assert(!a.hi);
 152     return a.lo;
 153 }
 154
 155 static inline uint64_t int128_getlo(Int128 a)
 156 {
 157     return a.lo;
 158 }
 159
 160 static inline int64_t int128_gethi(Int128 a)
 161 {
 162     return a.hi;
 163 }
 164
 165 static inline Int128 int128_zero(void)
 166 {
 167     return int128_make64(0);
 168 }
 169
 170 static inline Int128 int128_one(void)
 171 {
 172     return int128_make64(1);
 173 }
 174
 175 static inline Int128 int128_2_64(void)
 176 {
 177     return (Int128) { 0, 1 };
 178 }
 179
 180 static inline Int128 int128_exts64(int64_t a)
 181 {
 182     return (Int128) { .lo = a, .hi = (a < 0) ? -1 : 0 };
 183 }
 184
 185 static inline Int128 int128_and(Int128 a, Int128 b)
 186 {
 187     return (Int128) { a.lo & b.lo, a.hi & b.hi };
 188 }
 189
 190 static inline Int128 int128_rshift(Int128 a, int n)
 191 {
 192     int64_t h;
 193     if (!n) {
 194         return a;
 195     }
 196     h = a.hi >> (n & 63);
 197     if (n >= 64) {
 198         return (Int128) { h, h >> 63 };
 199     } else {
 200         return (Int128) { (a.lo >> n) | ((uint64_t)a.hi << (64 - n)), h };
 201     }
 202 }
 203
 204 static inline Int128 int128_add(Int128 a, Int128 b)
 205 {
 206     uint64_t lo = a.lo + b.lo;
 207
 208     /* a.lo <= a.lo + b.lo < a.lo + k (k is the base, 2^64).  Hence,
 209      * a.lo + b.lo >= k implies 0 <= lo = a.lo + b.lo - k < a.lo.
 210      * Similarly, a.lo + b.lo < k implies a.lo <= lo = a.lo + b.lo < k.
 211      *
 212      * So the carry is lo < a.lo.
 213      */
 214     return (Int128) { lo, (uint64_t)a.hi + b.hi + (lo < a.lo) };
 215 }
 216
 217 static inline Int128 int128_neg(Int128 a)
 218 {
 219     uint64_t lo = -a.lo;
 220     return (Int128) { lo, ~(uint64_t)a.hi + !lo };
 221 }
 222
 223 static inline Int128 int128_sub(Int128 a, Int128 b)
 224 {
 225     return (Int128){ a.lo - b.lo, (uint64_t)a.hi - b.hi - (a.lo < b.lo) };
 226 }
 227
 228 static inline bool int128_nonneg(Int128 a)
 229 {
 230     return a.hi >= 0;
 231 }
 232
 233 static inline bool int128_eq(Int128 a, Int128 b)
 234 {
 235     return a.lo == b.lo && a.hi == b.hi;
 236 }
 237
 238 static inline bool int128_ne(Int128 a, Int128 b)
 239 {
 240     return !int128_eq(a, b);
 241 }
 242
 243 static inline bool int128_ge(Int128 a, Int128 b)
 244 {
 245     return a.hi > b.hi || (a.hi == b.hi && a.lo >= b.lo);
 246 }
 247
 248 static inline bool int128_lt(Int128 a, Int128 b)
 249 {
 250     return !int128_ge(a, b);
 251 }
 252
 253 static inline bool int128_le(Int128 a, Int128 b)
 254 {
 255     return int128_ge(b, a);
 256 }
 257
 258 static inline bool int128_gt(Int128 a, Int128 b)
 259 {
 260     return !int128_le(a, b);
 261 }
 262
 263 static inline bool int128_nz(Int128 a)
 264 {
 265     return a.lo || a.hi;
 266 }
 267
 268 static inline Int128 int128_min(Int128 a, Int128 b)
 269 {
 270     return int128_le(a, b) ? a : b;
 271 }
 272
 273 static inline Int128 int128_max(Int128 a, Int128 b)
 274 {
 275     return int128_ge(a, b) ? a : b;
 276 }
 277
 278 static inline void int128_addto(Int128 *a, Int128 b)
 279 {
 280     *a = int128_add(*a, b);
 281 }
 282
 283 static inline void int128_subfrom(Int128 *a, Int128 b)
 284 {
 285     *a = int128_sub(*a, b);
 286 }
 287
 288 #endif /* CONFIG_INT128 */
 289 #endif /* INT128_H */