include/qemu/host-utils.h

   1 /*
   2  * Utility compute operations used by translated code.
   3  *
   4  * Copyright (c) 2007 Thiemo Seufer
   5  * Copyright (c) 2007 Jocelyn Mayer
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a copy
   8  * of this software and associated documentation files (the "Software"), to deal
   9  * in the Software without restriction, including without limitation the rights
  10  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  11  * copies of the Software, and to permit persons to whom the Software is
  12  * furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included in
  15  * all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  20  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  21  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  22  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  23  * THE SOFTWARE.
  24  */
  25 #ifndef HOST_UTILS_H
  26 #define HOST_UTILS_H 1
  27
  28 #include "qemu/compiler.h"   /* QEMU_GNUC_PREREQ */
  29 #include <limits.h>
  30
  31 #ifdef CONFIG_INT128
  32 static inline void mulu64(uint64_t *plow, uint64_t *phigh,
  33                           uint64_t a, uint64_t b)
  34 {
  35     __uint128_t r = (__uint128_t)a * b;
  36     *plow = r;
  37     *phigh = r >> 64;
  38 }
  39
  40 static inline void muls64(uint64_t *plow, uint64_t *phigh,
  41                           int64_t a, int64_t b)
  42 {
  43     __int128_t r = (__int128_t)a * b;
  44     *plow = r;
  45     *phigh = r >> 64;
  46 }
  47
  48 static inline int divu128(uint64_t *plow, uint64_t *phigh, uint64_t divisor)
  49 {
  50     if (divisor == 0) {
  51         return 1;
  52     } else {
  53         __uint128_t dividend = ((__uint128_t)*phigh << 64) | *plow;
  54         __uint128_t result = dividend / divisor;
  55         *plow = result;
  56         *phigh = dividend % divisor;
  57         return result > UINT64_MAX;
  58     }
  59 }
  60
  61 static inline int divs128(int64_t *plow, int64_t *phigh, int64_t divisor)
  62 {
  63     if (divisor == 0) {
  64         return 1;
  65     } else {
  66         __int128_t dividend = ((__int128_t)*phigh << 64) | *plow;
  67         __int128_t result = dividend / divisor;
  68         *plow = result;
  69         *phigh = dividend % divisor;
  70         return result != *plow;
  71     }
  72 }
  73 #else
  74 void muls64(uint64_t *phigh, uint64_t *plow, int64_t a, int64_t b);
  75 void mulu64(uint64_t *phigh, uint64_t *plow, uint64_t a, uint64_t b);
  76 int divu128(uint64_t *plow, uint64_t *phigh, uint64_t divisor);
  77 int divs128(int64_t *plow, int64_t *phigh, int64_t divisor);
  78 #endif
  79
  80 /**
  81  * clz32 - count leading zeros in a 32-bit value.
  82  * @val: The value to search
  83  *
  84  * Returns 32 if the value is zero.  Note that the GCC builtin is
  85  * undefined if the value is zero.
  86  */
  87 static inline int clz32(uint32_t val)
  88 {
  89 #if QEMU_GNUC_PREREQ(3, 4)
  90     return val ? __builtin_clz(val) : 32;
  91 #else
  92     /* Binary search for the leading one bit.  */
  93     int cnt = 0;
  94
  95     if (!(val & 0xFFFF0000U)) {
  96         cnt += 16;
  97         val <<= 16;
  98     }
  99     if (!(val & 0xFF000000U)) {
 100         cnt += 8;
 101         val <<= 8;
 102     }
 103     if (!(val & 0xF0000000U)) {
 104         cnt += 4;
 105         val <<= 4;
 106     }
 107     if (!(val & 0xC0000000U)) {
 108         cnt += 2;
 109         val <<= 2;
 110     }
 111     if (!(val & 0x80000000U)) {
 112         cnt++;
 113         val <<= 1;
 114     }
 115     if (!(val & 0x80000000U)) {
 116         cnt++;
 117     }
 118     return cnt;
 119 #endif
 120 }
 121
 122 /**
 123  * clo32 - count leading ones in a 32-bit value.
 124  * @val: The value to search
 125  *
 126  * Returns 32 if the value is -1.
 127  */
 128 static inline int clo32(uint32_t val)
 129 {
 130     return clz32(~val);
 131 }
 132
 133 /**
 134  * clz64 - count leading zeros in a 64-bit value.
 135  * @val: The value to search
 136  *
 137  * Returns 64 if the value is zero.  Note that the GCC builtin is
 138  * undefined if the value is zero.
 139  */
 140 static inline int clz64(uint64_t val)
 141 {
 142 #if QEMU_GNUC_PREREQ(3, 4)
 143     return val ? __builtin_clzll(val) : 64;
 144 #else
 145     int cnt = 0;
 146
 147     if (!(val >> 32)) {
 148         cnt += 32;
 149     } else {
 150         val >>= 32;
 151     }
 152
 153     return cnt + clz32(val);
 154 #endif
 155 }
 156
 157 /**
 158  * clo64 - count leading ones in a 64-bit value.
 159  * @val: The value to search
 160  *
 161  * Returns 64 if the value is -1.
 162  */
 163 static inline int clo64(uint64_t val)
 164 {
 165     return clz64(~val);
 166 }
 167
 168 /**
 169  * ctz32 - count trailing zeros in a 32-bit value.
 170  * @val: The value to search
 171  *
 172  * Returns 32 if the value is zero.  Note that the GCC builtin is
 173  * undefined if the value is zero.
 174  */
 175 static inline int ctz32(uint32_t val)
 176 {
 177 #if QEMU_GNUC_PREREQ(3, 4)
 178     return val ? __builtin_ctz(val) : 32;
 179 #else
 180     /* Binary search for the trailing one bit.  */
 181     int cnt;
 182
 183     cnt = 0;
 184     if (!(val & 0x0000FFFFUL)) {
 185         cnt += 16;
 186         val >>= 16;
 187     }
 188     if (!(val & 0x000000FFUL)) {
 189         cnt += 8;
 190         val >>= 8;
 191     }
 192     if (!(val & 0x0000000FUL)) {
 193         cnt += 4;
 194         val >>= 4;
 195     }
 196     if (!(val & 0x00000003UL)) {
 197         cnt += 2;
 198         val >>= 2;
 199     }
 200     if (!(val & 0x00000001UL)) {
 201         cnt++;
 202         val >>= 1;
 203     }
 204     if (!(val & 0x00000001UL)) {
 205         cnt++;
 206     }
 207
 208     return cnt;
 209 #endif
 210 }
 211
 212 /**
 213  * cto32 - count trailing ones in a 32-bit value.
 214  * @val: The value to search
 215  *
 216  * Returns 32 if the value is -1.
 217  */
 218 static inline int cto32(uint32_t val)
 219 {
 220     return ctz32(~val);
 221 }
 222
 223 /**
 224  * ctz64 - count trailing zeros in a 64-bit value.
 225  * @val: The value to search
 226  *
 227  * Returns 64 if the value is zero.  Note that the GCC builtin is
 228  * undefined if the value is zero.
 229  */
 230 static inline int ctz64(uint64_t val)
 231 {
 232 #if QEMU_GNUC_PREREQ(3, 4)
 233     return val ? __builtin_ctzll(val) : 64;
 234 #else
 235     int cnt;
 236
 237     cnt = 0;
 238     if (!((uint32_t)val)) {
 239         cnt += 32;
 240         val >>= 32;
 241     }
 242
 243     return cnt + ctz32(val);
 244 #endif
 245 }
 246
 247 /**
 248  * cto64 - count trailing ones in a 64-bit value.
 249  * @val: The value to search
 250  *
 251  * Returns 64 if the value is -1.
 252  */
 253 static inline int cto64(uint64_t val)
 254 {
 255     return ctz64(~val);
 256 }
 257
 258 /**
 259  * clrsb32 - count leading redundant sign bits in a 32-bit value.
 260  * @val: The value to search
 261  *
 262  * Returns the number of bits following the sign bit that are equal to it.
 263  * No special cases; output range is [0-31].
 264  */
 265 static inline int clrsb32(uint32_t val)
 266 {
 267 #if QEMU_GNUC_PREREQ(4, 7)
 268     return __builtin_clrsb(val);
 269 #else
 270     return clz32(val ^ ((int32_t)val >> 1)) - 1;
 271 #endif
 272 }
 273
 274 /**
 275  * clrsb64 - count leading redundant sign bits in a 64-bit value.
 276  * @val: The value to search
 277  *
 278  * Returns the number of bits following the sign bit that are equal to it.
 279  * No special cases; output range is [0-63].
 280  */
 281 static inline int clrsb64(uint64_t val)
 282 {
 283 #if QEMU_GNUC_PREREQ(4, 7)
 284     return __builtin_clrsbll(val);
 285 #else
 286     return clz64(val ^ ((int64_t)val >> 1)) - 1;
 287 #endif
 288 }
 289
 290 /**
 291  * ctpop8 - count the population of one bits in an 8-bit value.
 292  * @val: The value to search
 293  */
 294 static inline int ctpop8(uint8_t val)
 295 {
 296 #if QEMU_GNUC_PREREQ(3, 4)
 297     return __builtin_popcount(val);
 298 #else
 299     val = (val & 0x55) + ((val >> 1) & 0x55);
 300     val = (val & 0x33) + ((val >> 2) & 0x33);
 301     val = (val & 0x0f) + ((val >> 4) & 0x0f);
 302
 303     return val;
 304 #endif
 305 }
 306
 307 /**
 308  * ctpop16 - count the population of one bits in a 16-bit value.
 309  * @val: The value to search
 310  */
 311 static inline int ctpop16(uint16_t val)
 312 {
 313 #if QEMU_GNUC_PREREQ(3, 4)
 314     return __builtin_popcount(val);
 315 #else
 316     val = (val & 0x5555) + ((val >> 1) & 0x5555);
 317     val = (val & 0x3333) + ((val >> 2) & 0x3333);
 318     val = (val & 0x0f0f) + ((val >> 4) & 0x0f0f);
 319     val = (val & 0x00ff) + ((val >> 8) & 0x00ff);
 320
 321     return val;
 322 #endif
 323 }
 324
 325 /**
 326  * ctpop32 - count the population of one bits in a 32-bit value.
 327  * @val: The value to search
 328  */
 329 static inline int ctpop32(uint32_t val)
 330 {
 331 #if QEMU_GNUC_PREREQ(3, 4)
 332     return __builtin_popcount(val);
 333 #else
 334     val = (val & 0x55555555) + ((val >>  1) & 0x55555555);
 335     val = (val & 0x33333333) + ((val >>  2) & 0x33333333);
 336     val = (val & 0x0f0f0f0f) + ((val >>  4) & 0x0f0f0f0f);
 337     val = (val & 0x00ff00ff) + ((val >>  8) & 0x00ff00ff);
 338     val = (val & 0x0000ffff) + ((val >> 16) & 0x0000ffff);
 339
 340     return val;
 341 #endif
 342 }
 343
 344 /**
 345  * ctpop64 - count the population of one bits in a 64-bit value.
 346  * @val: The value to search
 347  */
 348 static inline int ctpop64(uint64_t val)
 349 {
 350 #if QEMU_GNUC_PREREQ(3, 4)
 351     return __builtin_popcountll(val);
 352 #else
 353     val = (val & 0x5555555555555555ULL) + ((val >>  1) & 0x5555555555555555ULL);
 354     val = (val & 0x3333333333333333ULL) + ((val >>  2) & 0x3333333333333333ULL);
 355     val = (val & 0x0f0f0f0f0f0f0f0fULL) + ((val >>  4) & 0x0f0f0f0f0f0f0f0fULL);
 356     val = (val & 0x00ff00ff00ff00ffULL) + ((val >>  8) & 0x00ff00ff00ff00ffULL);
 357     val = (val & 0x0000ffff0000ffffULL) + ((val >> 16) & 0x0000ffff0000ffffULL);
 358     val = (val & 0x00000000ffffffffULL) + ((val >> 32) & 0x00000000ffffffffULL);
 359
 360     return val;
 361 #endif
 362 }
 363
 364 /* Host type specific sizes of these routines.  */
 365
 366 #if ULONG_MAX == UINT32_MAX
 367 # define clzl   clz32
 368 # define ctzl   ctz32
 369 # define clol   clo32
 370 # define ctol   cto32
 371 # define ctpopl ctpop32
 372 #elif ULONG_MAX == UINT64_MAX
 373 # define clzl   clz64
 374 # define ctzl   ctz64
 375 # define clol   clo64
 376 # define ctol   cto64
 377 # define ctpopl ctpop64
 378 #else
 379 # error Unknown sizeof long
 380 #endif
 381
 382 #endif