include/qemu/bswap.h

   1 #ifndef BSWAP_H
   2 #define BSWAP_H
   3
   4 #include "config-host.h"
   5
   6 #include <inttypes.h>
   7 #include "fpu/softfloat.h"
   8
   9 #ifdef CONFIG_MACHINE_BSWAP_H
  10 # include <sys/endian.h>
  11 # include <sys/types.h>
  12 # include <machine/bswap.h>
  13 #elif defined(CONFIG_BYTESWAP_H)
  14 # include <byteswap.h>
  15
  16 static inline uint16_t bswap16(uint16_t x)
  17 {
  18     return bswap_16(x);
  19 }
  20
  21 static inline uint32_t bswap32(uint32_t x)
  22 {
  23     return bswap_32(x);
  24 }
  25
  26 static inline uint64_t bswap64(uint64_t x)
  27 {
  28     return bswap_64(x);
  29 }
  30 # else
  31 static inline uint16_t bswap16(uint16_t x)
  32 {
  33     return (((x & 0x00ff) << 8) |
  34             ((x & 0xff00) >> 8));
  35 }
  36
  37 static inline uint32_t bswap32(uint32_t x)
  38 {
  39     return (((x & 0x000000ffU) << 24) |
  40             ((x & 0x0000ff00U) <<  8) |
  41             ((x & 0x00ff0000U) >>  8) |
  42             ((x & 0xff000000U) >> 24));
  43 }
  44
  45 static inline uint64_t bswap64(uint64_t x)
  46 {
  47     return (((x & 0x00000000000000ffULL) << 56) |
  48             ((x & 0x000000000000ff00ULL) << 40) |
  49             ((x & 0x0000000000ff0000ULL) << 24) |
  50             ((x & 0x00000000ff000000ULL) <<  8) |
  51             ((x & 0x000000ff00000000ULL) >>  8) |
  52             ((x & 0x0000ff0000000000ULL) >> 24) |
  53             ((x & 0x00ff000000000000ULL) >> 40) |
  54             ((x & 0xff00000000000000ULL) >> 56));
  55 }
  56 #endif /* ! CONFIG_MACHINE_BSWAP_H */
  57
  58 static inline void bswap16s(uint16_t *s)
  59 {
  60     *s = bswap16(*s);
  61 }
  62
  63 static inline void bswap32s(uint32_t *s)
  64 {
  65     *s = bswap32(*s);
  66 }
  67
  68 static inline void bswap64s(uint64_t *s)
  69 {
  70     *s = bswap64(*s);
  71 }
  72
  73 #if defined(HOST_WORDS_BIGENDIAN)
  74 #define be_bswap(v, size) (v)
  75 #define le_bswap(v, size) bswap ## size(v)
  76 #define be_bswaps(v, size)
  77 #define le_bswaps(p, size) *p = bswap ## size(*p);
  78 #else
  79 #define le_bswap(v, size) (v)
  80 #define be_bswap(v, size) bswap ## size(v)
  81 #define le_bswaps(v, size)
  82 #define be_bswaps(p, size) *p = bswap ## size(*p);
  83 #endif
  84
  85 #define CPU_CONVERT(endian, size, type)\
  86 static inline type endian ## size ## _to_cpu(type v)\
  87 {\
  88     return endian ## _bswap(v, size);\
  89 }\
  90 \
  91 static inline type cpu_to_ ## endian ## size(type v)\
  92 {\
  93     return endian ## _bswap(v, size);\
  94 }\
  95 \
  96 static inline void endian ## size ## _to_cpus(type *p)\
  97 {\
  98     endian ## _bswaps(p, size)\
  99 }\
 100 \
 101 static inline void cpu_to_ ## endian ## size ## s(type *p)\
 102 {\
 103     endian ## _bswaps(p, size)\
 104 }\
 105 \
 106 static inline type endian ## size ## _to_cpup(const type *p)\
 107 {\
 108     return endian ## size ## _to_cpu(*p);\
 109 }\
 110 \
 111 static inline void cpu_to_ ## endian ## size ## w(type *p, type v)\
 112 {\
 113      *p = cpu_to_ ## endian ## size(v);\
 114 }
 115
 116 CPU_CONVERT(be, 16, uint16_t)
 117 CPU_CONVERT(be, 32, uint32_t)
 118 CPU_CONVERT(be, 64, uint64_t)
 119
 120 CPU_CONVERT(le, 16, uint16_t)
 121 CPU_CONVERT(le, 32, uint32_t)
 122 CPU_CONVERT(le, 64, uint64_t)
 123
 124 /* unaligned versions (optimized for frequent unaligned accesses)*/
 125
 126 #if defined(__i386__) || defined(_ARCH_PPC)
 127
 128 #define cpu_to_le16wu(p, v) cpu_to_le16w(p, v)
 129 #define cpu_to_le32wu(p, v) cpu_to_le32w(p, v)
 130 #define le16_to_cpupu(p) le16_to_cpup(p)
 131 #define le32_to_cpupu(p) le32_to_cpup(p)
 132 #define be32_to_cpupu(p) be32_to_cpup(p)
 133
 134 #define cpu_to_be16wu(p, v) cpu_to_be16w(p, v)
 135 #define cpu_to_be32wu(p, v) cpu_to_be32w(p, v)
 136 #define cpu_to_be64wu(p, v) cpu_to_be64w(p, v)
 137
 138 #else
 139
 140 static inline void cpu_to_le16wu(uint16_t *p, uint16_t v)
 141 {
 142     uint8_t *p1 = (uint8_t *)p;
 143
 144     p1[0] = v & 0xff;
 145     p1[1] = v >> 8;
 146 }
 147
 148 static inline void cpu_to_le32wu(uint32_t *p, uint32_t v)
 149 {
 150     uint8_t *p1 = (uint8_t *)p;
 151
 152     p1[0] = v & 0xff;
 153     p1[1] = v >> 8;
 154     p1[2] = v >> 16;
 155     p1[3] = v >> 24;
 156 }
 157
 158 static inline uint16_t le16_to_cpupu(const uint16_t *p)
 159 {
 160     const uint8_t *p1 = (const uint8_t *)p;
 161     return p1[0] | (p1[1] << 8);
 162 }
 163
 164 static inline uint32_t le32_to_cpupu(const uint32_t *p)
 165 {
 166     const uint8_t *p1 = (const uint8_t *)p;
 167     return p1[0] | (p1[1] << 8) | (p1[2] << 16) | (p1[3] << 24);
 168 }
 169
 170 static inline uint32_t be32_to_cpupu(const uint32_t *p)
 171 {
 172     const uint8_t *p1 = (const uint8_t *)p;
 173     return p1[3] | (p1[2] << 8) | (p1[1] << 16) | (p1[0] << 24);
 174 }
 175
 176 static inline void cpu_to_be16wu(uint16_t *p, uint16_t v)
 177 {
 178     uint8_t *p1 = (uint8_t *)p;
 179
 180     p1[0] = v >> 8;
 181     p1[1] = v & 0xff;
 182 }
 183
 184 static inline void cpu_to_be32wu(uint32_t *p, uint32_t v)
 185 {
 186     uint8_t *p1 = (uint8_t *)p;
 187
 188     p1[0] = v >> 24;
 189     p1[1] = v >> 16;
 190     p1[2] = v >> 8;
 191     p1[3] = v & 0xff;
 192 }
 193
 194 static inline void cpu_to_be64wu(uint64_t *p, uint64_t v)
 195 {
 196     uint8_t *p1 = (uint8_t *)p;
 197
 198     p1[0] = v >> 56;
 199     p1[1] = v >> 48;
 200     p1[2] = v >> 40;
 201     p1[3] = v >> 32;
 202     p1[4] = v >> 24;
 203     p1[5] = v >> 16;
 204     p1[6] = v >> 8;
 205     p1[7] = v & 0xff;
 206 }
 207
 208 #endif
 209
 210 #ifdef HOST_WORDS_BIGENDIAN
 211 #define cpu_to_32wu cpu_to_be32wu
 212 #define leul_to_cpu(v) glue(glue(le,HOST_LONG_BITS),_to_cpu)(v)
 213 #else
 214 #define cpu_to_32wu cpu_to_le32wu
 215 #define leul_to_cpu(v) (v)
 216 #endif
 217
 218 /* len must be one of 1, 2, 4 */
 219 static inline uint32_t qemu_bswap_len(uint32_t value, int len)
 220 {
 221     return bswap32(value) >> (32 - 8 * len);
 222 }
 223
 224 /* Unions for reinterpreting between floats and integers.  */
 225
 226 typedef union {
 227     float32 f;
 228     uint32_t l;
 229 } CPU_FloatU;
 230
 231 typedef union {
 232     float64 d;
 233 #if defined(HOST_WORDS_BIGENDIAN)
 234     struct {
 235         uint32_t upper;
 236         uint32_t lower;
 237     } l;
 238 #else
 239     struct {
 240         uint32_t lower;
 241         uint32_t upper;
 242     } l;
 243 #endif
 244     uint64_t ll;
 245 } CPU_DoubleU;
 246
 247 typedef union {
 248      floatx80 d;
 249      struct {
 250          uint64_t lower;
 251          uint16_t upper;
 252      } l;
 253 } CPU_LDoubleU;
 254
 255 typedef union {
 256     float128 q;
 257 #if defined(HOST_WORDS_BIGENDIAN)
 258     struct {
 259         uint32_t upmost;
 260         uint32_t upper;
 261         uint32_t lower;
 262         uint32_t lowest;
 263     } l;
 264     struct {
 265         uint64_t upper;
 266         uint64_t lower;
 267     } ll;
 268 #else
 269     struct {
 270         uint32_t lowest;
 271         uint32_t lower;
 272         uint32_t upper;
 273         uint32_t upmost;
 274     } l;
 275     struct {
 276         uint64_t lower;
 277         uint64_t upper;
 278     } ll;
 279 #endif
 280 } CPU_QuadU;
 281
 282 /* unaligned/endian-independent pointer access */
 283
 284 /*
 285  * the generic syntax is:
 286  *
 287  * load: ld{type}{sign}{size}{endian}_p(ptr)
 288  *
 289  * store: st{type}{size}{endian}_p(ptr, val)
 290  *
 291  * Note there are small differences with the softmmu access API!
 292  *
 293  * type is:
 294  * (empty): integer access
 295  *   f    : float access
 296  *
 297  * sign is:
 298  * (empty): for floats or 32 bit size
 299  *   u    : unsigned
 300  *   s    : signed
 301  *
 302  * size is:
 303  *   b: 8 bits
 304  *   w: 16 bits
 305  *   l: 32 bits
 306  *   q: 64 bits
 307  *
 308  * endian is:
 309  * (empty): host endian
 310  *   be   : big endian
 311  *   le   : little endian
 312  */
 313 static inline int ldub_p(const void *ptr)
 314 {
 315     return *(uint8_t *)ptr;
 316 }
 317
 318 static inline int ldsb_p(const void *ptr)
 319 {
 320     return *(int8_t *)ptr;
 321 }
 322
 323 static inline void stb_p(void *ptr, int v)
 324 {
 325     *(uint8_t *)ptr = v;
 326 }
 327
 328 /* Any compiler worth its salt will turn these memcpy into native unaligned
 329    operations.  Thus we don't need to play games with packed attributes, or
 330    inline byte-by-byte stores.  */
 331
 332 static inline int lduw_p(const void *ptr)
 333 {
 334     uint16_t r;
 335     memcpy(&r, ptr, sizeof(r));
 336     return r;
 337 }
 338
 339 static inline int ldsw_p(const void *ptr)
 340 {
 341     int16_t r;
 342     memcpy(&r, ptr, sizeof(r));
 343     return r;
 344 }
 345
 346 static inline void stw_p(void *ptr, uint16_t v)
 347 {
 348     memcpy(ptr, &v, sizeof(v));
 349 }
 350
 351 static inline int ldl_p(const void *ptr)
 352 {
 353     int32_t r;
 354     memcpy(&r, ptr, sizeof(r));
 355     return r;
 356 }
 357
 358 static inline void stl_p(void *ptr, uint32_t v)
 359 {
 360     memcpy(ptr, &v, sizeof(v));
 361 }
 362
 363 static inline uint64_t ldq_p(const void *ptr)
 364 {
 365     uint64_t r;
 366     memcpy(&r, ptr, sizeof(r));
 367     return r;
 368 }
 369
 370 static inline void stq_p(void *ptr, uint64_t v)
 371 {
 372     memcpy(ptr, &v, sizeof(v));
 373 }
 374
 375 static inline int lduw_le_p(const void *ptr)
 376 {
 377     return (uint16_t)le_bswap(lduw_p(ptr), 16);
 378 }
 379
 380 static inline int ldsw_le_p(const void *ptr)
 381 {
 382     return (int16_t)le_bswap(lduw_p(ptr), 16);
 383 }
 384
 385 static inline int ldl_le_p(const void *ptr)
 386 {
 387     return le_bswap(ldl_p(ptr), 32);
 388 }
 389
 390 static inline uint64_t ldq_le_p(const void *ptr)
 391 {
 392     return le_bswap(ldq_p(ptr), 64);
 393 }
 394
 395 static inline void stw_le_p(void *ptr, int v)
 396 {
 397     stw_p(ptr, le_bswap(v, 16));
 398 }
 399
 400 static inline void stl_le_p(void *ptr, int v)
 401 {
 402     stl_p(ptr, le_bswap(v, 32));
 403 }
 404
 405 static inline void stq_le_p(void *ptr, uint64_t v)
 406 {
 407     stq_p(ptr, le_bswap(v, 64));
 408 }
 409
 410 /* float access */
 411
 412 static inline float32 ldfl_le_p(const void *ptr)
 413 {
 414     CPU_FloatU u;
 415     u.l = ldl_le_p(ptr);
 416     return u.f;
 417 }
 418
 419 static inline void stfl_le_p(void *ptr, float32 v)
 420 {
 421     CPU_FloatU u;
 422     u.f = v;
 423     stl_le_p(ptr, u.l);
 424 }
 425
 426 static inline float64 ldfq_le_p(const void *ptr)
 427 {
 428     CPU_DoubleU u;
 429     u.ll = ldq_le_p(ptr);
 430     return u.d;
 431 }
 432
 433 static inline void stfq_le_p(void *ptr, float64 v)
 434 {
 435     CPU_DoubleU u;
 436     u.d = v;
 437     stq_le_p(ptr, u.ll);
 438 }
 439
 440 static inline int lduw_be_p(const void *ptr)
 441 {
 442     return (uint16_t)be_bswap(lduw_p(ptr), 16);
 443 }
 444
 445 static inline int ldsw_be_p(const void *ptr)
 446 {
 447     return (int16_t)be_bswap(lduw_p(ptr), 16);
 448 }
 449
 450 static inline int ldl_be_p(const void *ptr)
 451 {
 452     return be_bswap(ldl_p(ptr), 32);
 453 }
 454
 455 static inline uint64_t ldq_be_p(const void *ptr)
 456 {
 457     return be_bswap(ldq_p(ptr), 64);
 458 }
 459
 460 static inline void stw_be_p(void *ptr, int v)
 461 {
 462     stw_p(ptr, be_bswap(v, 16));
 463 }
 464
 465 static inline void stl_be_p(void *ptr, int v)
 466 {
 467     stl_p(ptr, be_bswap(v, 32));
 468 }
 469
 470 static inline void stq_be_p(void *ptr, uint64_t v)
 471 {
 472     stq_p(ptr, be_bswap(v, 64));
 473 }
 474
 475 /* float access */
 476
 477 static inline float32 ldfl_be_p(const void *ptr)
 478 {
 479     CPU_FloatU u;
 480     u.l = ldl_be_p(ptr);
 481     return u.f;
 482 }
 483
 484 static inline void stfl_be_p(void *ptr, float32 v)
 485 {
 486     CPU_FloatU u;
 487     u.f = v;
 488     stl_be_p(ptr, u.l);
 489 }
 490
 491 static inline float64 ldfq_be_p(const void *ptr)
 492 {
 493     CPU_DoubleU u;
 494     u.ll = ldq_be_p(ptr);
 495     return u.d;
 496 }
 497
 498 static inline void stfq_be_p(void *ptr, float64 v)
 499 {
 500     CPU_DoubleU u;
 501     u.d = v;
 502     stq_be_p(ptr, u.ll);
 503 }
 504
 505 #undef le_bswap
 506 #undef be_bswap
 507 #undef le_bswaps
 508 #undef be_bswaps
 509
 510 #endif /* BSWAP_H */