include/qemu/bswap.h

   1 #ifndef BSWAP_H
   2 #define BSWAP_H
   3
   4 #undef  bswap16
   5 #define bswap16(_x) __builtin_bswap16(_x)
   6 #undef  bswap32
   7 #define bswap32(_x) __builtin_bswap32(_x)
   8 #undef  bswap64
   9 #define bswap64(_x) __builtin_bswap64(_x)
  10
  11 static inline uint32_t bswap24(uint32_t x)
  12 {
  13     return (((x & 0x000000ffU) << 16) |
  14             ((x & 0x0000ff00U) <<  0) |
  15             ((x & 0x00ff0000U) >> 16));
  16 }
  17
  18 static inline void bswap16s(uint16_t *s)
  19 {
  20     *s = __builtin_bswap16(*s);
  21 }
  22
  23 static inline void bswap24s(uint32_t *s)
  24 {
  25     *s = bswap24(*s & 0x00ffffffU);
  26 }
  27
  28 static inline void bswap32s(uint32_t *s)
  29 {
  30     *s = __builtin_bswap32(*s);
  31 }
  32
  33 static inline void bswap64s(uint64_t *s)
  34 {
  35     *s = __builtin_bswap64(*s);
  36 }
  37
  38 #if HOST_BIG_ENDIAN
  39 #define be_bswap(v, size) (v)
  40 #define le_bswap(v, size) glue(__builtin_bswap, size)(v)
  41 #define le_bswap24(v) bswap24(v)
  42 #define be_bswaps(v, size)
  43 #define le_bswaps(p, size) \
  44             do { *p = glue(__builtin_bswap, size)(*p); } while (0)
  45 #else
  46 #define le_bswap(v, size) (v)
  47 #define le_bswap24(v) (v)
  48 #define be_bswap(v, size) glue(__builtin_bswap, size)(v)
  49 #define le_bswaps(v, size)
  50 #define be_bswaps(p, size) \
  51             do { *p = glue(__builtin_bswap, size)(*p); } while (0)
  52 #endif
  53
  54 /**
  55  * Endianness conversion functions between host cpu and specified endianness.
  56  * (We list the complete set of prototypes produced by the macros below
  57  * to assist people who search the headers to find their definitions.)
  58  *
  59  * uint16_t le16_to_cpu(uint16_t v);
  60  * uint32_t le32_to_cpu(uint32_t v);
  61  * uint64_t le64_to_cpu(uint64_t v);
  62  * uint16_t be16_to_cpu(uint16_t v);
  63  * uint32_t be32_to_cpu(uint32_t v);
  64  * uint64_t be64_to_cpu(uint64_t v);
  65  *
  66  * Convert the value @v from the specified format to the native
  67  * endianness of the host CPU by byteswapping if necessary, and
  68  * return the converted value.
  69  *
  70  * uint16_t cpu_to_le16(uint16_t v);
  71  * uint32_t cpu_to_le32(uint32_t v);
  72  * uint64_t cpu_to_le64(uint64_t v);
  73  * uint16_t cpu_to_be16(uint16_t v);
  74  * uint32_t cpu_to_be32(uint32_t v);
  75  * uint64_t cpu_to_be64(uint64_t v);
  76  *
  77  * Convert the value @v from the native endianness of the host CPU to
  78  * the specified format by byteswapping if necessary, and return
  79  * the converted value.
  80  *
  81  * void le16_to_cpus(uint16_t *v);
  82  * void le32_to_cpus(uint32_t *v);
  83  * void le64_to_cpus(uint64_t *v);
  84  * void be16_to_cpus(uint16_t *v);
  85  * void be32_to_cpus(uint32_t *v);
  86  * void be64_to_cpus(uint64_t *v);
  87  *
  88  * Do an in-place conversion of the value pointed to by @v from the
  89  * specified format to the native endianness of the host CPU.
  90  *
  91  * void cpu_to_le16s(uint16_t *v);
  92  * void cpu_to_le32s(uint32_t *v);
  93  * void cpu_to_le64s(uint64_t *v);
  94  * void cpu_to_be16s(uint16_t *v);
  95  * void cpu_to_be32s(uint32_t *v);
  96  * void cpu_to_be64s(uint64_t *v);
  97  *
  98  * Do an in-place conversion of the value pointed to by @v from the
  99  * native endianness of the host CPU to the specified format.
 100  *
 101  * Both X_to_cpu() and cpu_to_X() perform the same operation; you
 102  * should use whichever one is better documenting of the function your
 103  * code is performing.
 104  *
 105  * Do not use these functions for conversion of values which are in guest
 106  * memory, since the data may not be sufficiently aligned for the host CPU's
 107  * load and store instructions. Instead you should use the ld*_p() and
 108  * st*_p() functions, which perform loads and stores of data of any
 109  * required size and endianness and handle possible misalignment.
 110  */
 111
 112 #define CPU_CONVERT(endian, size, type)\
 113 static inline type endian ## size ## _to_cpu(type v)\
 114 {\
 115     return glue(endian, _bswap)(v, size);\
 116 }\
 117 \
 118 static inline type cpu_to_ ## endian ## size(type v)\
 119 {\
 120     return glue(endian, _bswap)(v, size);\
 121 }\
 122 \
 123 static inline void endian ## size ## _to_cpus(type *p)\
 124 {\
 125     glue(endian, _bswaps)(p, size);\
 126 }\
 127 \
 128 static inline void cpu_to_ ## endian ## size ## s(type *p)\
 129 {\
 130     glue(endian, _bswaps)(p, size);\
 131 }
 132
 133 CPU_CONVERT(be, 16, uint16_t)
 134 CPU_CONVERT(be, 32, uint32_t)
 135 CPU_CONVERT(be, 64, uint64_t)
 136
 137 CPU_CONVERT(le, 16, uint16_t)
 138 CPU_CONVERT(le, 32, uint32_t)
 139 CPU_CONVERT(le, 64, uint64_t)
 140
 141 /*
 142  * Same as cpu_to_le{16,32,64}, except that gcc will figure the result is
 143  * a compile-time constant if you pass in a constant.  So this can be
 144  * used to initialize static variables.
 145  */
 146 #if HOST_BIG_ENDIAN
 147 # define const_le64(_x)                          \
 148     ((((_x) & 0x00000000000000ffULL) << 56) |    \
 149      (((_x) & 0x000000000000ff00ULL) << 40) |    \
 150      (((_x) & 0x0000000000ff0000ULL) << 24) |    \
 151      (((_x) & 0x00000000ff000000ULL) <<  8) |    \
 152      (((_x) & 0x000000ff00000000ULL) >>  8) |    \
 153      (((_x) & 0x0000ff0000000000ULL) >> 24) |    \
 154      (((_x) & 0x00ff000000000000ULL) >> 40) |    \
 155      (((_x) & 0xff00000000000000ULL) >> 56))
 156 # define const_le32(_x)                          \
 157     ((((_x) & 0x000000ffU) << 24) |              \
 158      (((_x) & 0x0000ff00U) <<  8) |              \
 159      (((_x) & 0x00ff0000U) >>  8) |              \
 160      (((_x) & 0xff000000U) >> 24))
 161 # define const_le16(_x)                          \
 162     ((((_x) & 0x00ff) << 8) |                    \
 163      (((_x) & 0xff00) >> 8))
 164 #else
 165 # define const_le64(_x) (_x)
 166 # define const_le32(_x) (_x)
 167 # define const_le16(_x) (_x)
 168 #endif
 169
 170 /* unaligned/endian-independent pointer access */
 171
 172 /*
 173  * the generic syntax is:
 174  *
 175  * load: ld{type}{sign}{size}_{endian}_p(ptr)
 176  *
 177  * store: st{type}{size}_{endian}_p(ptr, val)
 178  *
 179  * Note there are small differences with the softmmu access API!
 180  *
 181  * type is:
 182  * (empty): integer access
 183  *   f    : float access
 184  *
 185  * sign is:
 186  * (empty): for 32 or 64 bit sizes (including floats and doubles)
 187  *   u    : unsigned
 188  *   s    : signed
 189  *
 190  * size is:
 191  *   b: 8 bits
 192  *   w: 16 bits
 193  *   24: 24 bits
 194  *   l: 32 bits
 195  *   q: 64 bits
 196  *
 197  * endian is:
 198  *   he   : host endian
 199  *   be   : big endian
 200  *   le   : little endian
 201  *   te   : target endian
 202  * (except for byte accesses, which have no endian infix).
 203  *
 204  * The target endian accessors are obviously only available to source
 205  * files which are built per-target; they are defined in cpu-all.h.
 206  *
 207  * In all cases these functions take a host pointer.
 208  * For accessors that take a guest address rather than a
 209  * host address, see the cpu_{ld,st}_* accessors defined in
 210  * cpu_ldst.h.
 211  *
 212  * For cases where the size to be used is not fixed at compile time,
 213  * there are
 214  *  stn_{endian}_p(ptr, sz, val)
 215  * which stores @val to @ptr as an @endian-order number @sz bytes in size
 216  * and
 217  *  ldn_{endian}_p(ptr, sz)
 218  * which loads @sz bytes from @ptr as an unsigned @endian-order number
 219  * and returns it in a uint64_t.
 220  */
 221
 222 static inline int ldub_p(const void *ptr)
 223 {
 224     return *(uint8_t *)ptr;
 225 }
 226
 227 static inline int ldsb_p(const void *ptr)
 228 {
 229     return *(int8_t *)ptr;
 230 }
 231
 232 static inline void stb_p(void *ptr, uint8_t v)
 233 {
 234     *(uint8_t *)ptr = v;
 235 }
 236
 237 /*
 238  * Any compiler worth its salt will turn these memcpy into native unaligned
 239  * operations.  Thus we don't need to play games with packed attributes, or
 240  * inline byte-by-byte stores.
 241  * Some compilation environments (eg some fortify-source implementations)
 242  * may intercept memcpy() in a way that defeats the compiler optimization,
 243  * though, so we use __builtin_memcpy() to give ourselves the best chance
 244  * of good performance.
 245  */
 246
 247 static inline int lduw_he_p(const void *ptr)
 248 {
 249     uint16_t r;
 250     __builtin_memcpy(&r, ptr, sizeof(r));
 251     return r;
 252 }
 253
 254 static inline int ldsw_he_p(const void *ptr)
 255 {
 256     int16_t r;
 257     __builtin_memcpy(&r, ptr, sizeof(r));
 258     return r;
 259 }
 260
 261 static inline void stw_he_p(void *ptr, uint16_t v)
 262 {
 263     __builtin_memcpy(ptr, &v, sizeof(v));
 264 }
 265
 266 static inline void st24_he_p(void *ptr, uint32_t v)
 267 {
 268     __builtin_memcpy(ptr, &v, 3);
 269 }
 270
 271 static inline int ldl_he_p(const void *ptr)
 272 {
 273     int32_t r;
 274     __builtin_memcpy(&r, ptr, sizeof(r));
 275     return r;
 276 }
 277
 278 static inline void stl_he_p(void *ptr, uint32_t v)
 279 {
 280     __builtin_memcpy(ptr, &v, sizeof(v));
 281 }
 282
 283 static inline uint64_t ldq_he_p(const void *ptr)
 284 {
 285     uint64_t r;
 286     __builtin_memcpy(&r, ptr, sizeof(r));
 287     return r;
 288 }
 289
 290 static inline void stq_he_p(void *ptr, uint64_t v)
 291 {
 292     __builtin_memcpy(ptr, &v, sizeof(v));
 293 }
 294
 295 static inline int lduw_le_p(const void *ptr)
 296 {
 297     return (uint16_t)le_bswap(lduw_he_p(ptr), 16);
 298 }
 299
 300 static inline int ldsw_le_p(const void *ptr)
 301 {
 302     return (int16_t)le_bswap(lduw_he_p(ptr), 16);
 303 }
 304
 305 static inline int ldl_le_p(const void *ptr)
 306 {
 307     return le_bswap(ldl_he_p(ptr), 32);
 308 }
 309
 310 static inline uint64_t ldq_le_p(const void *ptr)
 311 {
 312     return le_bswap(ldq_he_p(ptr), 64);
 313 }
 314
 315 static inline void stw_le_p(void *ptr, uint16_t v)
 316 {
 317     stw_he_p(ptr, le_bswap(v, 16));
 318 }
 319
 320 static inline void st24_le_p(void *ptr, uint32_t v)
 321 {
 322     st24_he_p(ptr, le_bswap24(v));
 323 }
 324
 325 static inline void stl_le_p(void *ptr, uint32_t v)
 326 {
 327     stl_he_p(ptr, le_bswap(v, 32));
 328 }
 329
 330 static inline void stq_le_p(void *ptr, uint64_t v)
 331 {
 332     stq_he_p(ptr, le_bswap(v, 64));
 333 }
 334
 335 static inline int lduw_be_p(const void *ptr)
 336 {
 337     return (uint16_t)be_bswap(lduw_he_p(ptr), 16);
 338 }
 339
 340 static inline int ldsw_be_p(const void *ptr)
 341 {
 342     return (int16_t)be_bswap(lduw_he_p(ptr), 16);
 343 }
 344
 345 static inline int ldl_be_p(const void *ptr)
 346 {
 347     return be_bswap(ldl_he_p(ptr), 32);
 348 }
 349
 350 static inline uint64_t ldq_be_p(const void *ptr)
 351 {
 352     return be_bswap(ldq_he_p(ptr), 64);
 353 }
 354
 355 static inline void stw_be_p(void *ptr, uint16_t v)
 356 {
 357     stw_he_p(ptr, be_bswap(v, 16));
 358 }
 359
 360 static inline void stl_be_p(void *ptr, uint32_t v)
 361 {
 362     stl_he_p(ptr, be_bswap(v, 32));
 363 }
 364
 365 static inline void stq_be_p(void *ptr, uint64_t v)
 366 {
 367     stq_he_p(ptr, be_bswap(v, 64));
 368 }
 369
 370 static inline unsigned long leul_to_cpu(unsigned long v)
 371 {
 372 #if HOST_LONG_BITS == 32
 373     return le_bswap(v, 32);
 374 #elif HOST_LONG_BITS == 64
 375     return le_bswap(v, 64);
 376 #else
 377 # error Unknown sizeof long
 378 #endif
 379 }
 380
 381 /* Store v to p as a sz byte value in host order */
 382 #define DO_STN_LDN_P(END) \
 383     static inline void stn_## END ## _p(void *ptr, int sz, uint64_t v)  \
 384     {                                                                   \
 385         switch (sz) {                                                   \
 386         case 1:                                                         \
 387             stb_p(ptr, v);                                              \
 388             break;                                                      \
 389         case 2:                                                         \
 390             stw_ ## END ## _p(ptr, v);                                  \
 391             break;                                                      \
 392         case 4:                                                         \
 393             stl_ ## END ## _p(ptr, v);                                  \
 394             break;                                                      \
 395         case 8:                                                         \
 396             stq_ ## END ## _p(ptr, v);                                  \
 397             break;                                                      \
 398         default:                                                        \
 399             g_assert_not_reached();                                     \
 400         }                                                               \
 401     }                                                                   \
 402     static inline uint64_t ldn_## END ## _p(const void *ptr, int sz)    \
 403     {                                                                   \
 404         switch (sz) {                                                   \
 405         case 1:                                                         \
 406             return ldub_p(ptr);                                         \
 407         case 2:                                                         \
 408             return lduw_ ## END ## _p(ptr);                             \
 409         case 4:                                                         \
 410             return (uint32_t)ldl_ ## END ## _p(ptr);                    \
 411         case 8:                                                         \
 412             return ldq_ ## END ## _p(ptr);                              \
 413         default:                                                        \
 414             g_assert_not_reached();                                     \
 415         }                                                               \
 416     }
 417
 418 DO_STN_LDN_P(he)
 419 DO_STN_LDN_P(le)
 420 DO_STN_LDN_P(be)
 421
 422 #undef DO_STN_LDN_P
 423
 424 #undef le_bswap
 425 #undef be_bswap
 426 #undef le_bswaps
 427 #undef be_bswaps
 428
 429 #endif /* BSWAP_H */