Annotation of qemu/bswap.h, revision 1.1.1.8
1.1 root 1: #ifndef BSWAP_H
2: #define BSWAP_H
3:
4: #include "config-host.h"
5:
6: #include <inttypes.h>
1.1.1.8 ! root 7: #include "softfloat.h"
1.1 root 8:
1.1.1.5 root 9: #ifdef CONFIG_MACHINE_BSWAP_H
1.1.1.3 root 10: #include <sys/endian.h>
11: #include <sys/types.h>
12: #include <machine/bswap.h>
13: #else
14:
1.1.1.5 root 15: #ifdef CONFIG_BYTESWAP_H
1.1 root 16: #include <byteswap.h>
17: #else
18:
19: #define bswap_16(x) \
20: ({ \
21: uint16_t __x = (x); \
22: ((uint16_t)( \
23: (((uint16_t)(__x) & (uint16_t)0x00ffU) << 8) | \
24: (((uint16_t)(__x) & (uint16_t)0xff00U) >> 8) )); \
25: })
26:
27: #define bswap_32(x) \
28: ({ \
29: uint32_t __x = (x); \
30: ((uint32_t)( \
31: (((uint32_t)(__x) & (uint32_t)0x000000ffUL) << 24) | \
32: (((uint32_t)(__x) & (uint32_t)0x0000ff00UL) << 8) | \
33: (((uint32_t)(__x) & (uint32_t)0x00ff0000UL) >> 8) | \
34: (((uint32_t)(__x) & (uint32_t)0xff000000UL) >> 24) )); \
35: })
36:
37: #define bswap_64(x) \
38: ({ \
39: uint64_t __x = (x); \
40: ((uint64_t)( \
41: (uint64_t)(((uint64_t)(__x) & (uint64_t)0x00000000000000ffULL) << 56) | \
42: (uint64_t)(((uint64_t)(__x) & (uint64_t)0x000000000000ff00ULL) << 40) | \
43: (uint64_t)(((uint64_t)(__x) & (uint64_t)0x0000000000ff0000ULL) << 24) | \
44: (uint64_t)(((uint64_t)(__x) & (uint64_t)0x00000000ff000000ULL) << 8) | \
45: (uint64_t)(((uint64_t)(__x) & (uint64_t)0x000000ff00000000ULL) >> 8) | \
46: (uint64_t)(((uint64_t)(__x) & (uint64_t)0x0000ff0000000000ULL) >> 24) | \
47: (uint64_t)(((uint64_t)(__x) & (uint64_t)0x00ff000000000000ULL) >> 40) | \
48: (uint64_t)(((uint64_t)(__x) & (uint64_t)0xff00000000000000ULL) >> 56) )); \
49: })
50:
1.1.1.5 root 51: #endif /* !CONFIG_BYTESWAP_H */
1.1 root 52:
53: static inline uint16_t bswap16(uint16_t x)
54: {
55: return bswap_16(x);
56: }
57:
1.1.1.2 root 58: static inline uint32_t bswap32(uint32_t x)
1.1 root 59: {
60: return bswap_32(x);
61: }
62:
1.1.1.2 root 63: static inline uint64_t bswap64(uint64_t x)
1.1 root 64: {
65: return bswap_64(x);
66: }
67:
1.1.1.5 root 68: #endif /* ! CONFIG_MACHINE_BSWAP_H */
1.1.1.3 root 69:
1.1 root 70: static inline void bswap16s(uint16_t *s)
71: {
72: *s = bswap16(*s);
73: }
74:
75: static inline void bswap32s(uint32_t *s)
76: {
77: *s = bswap32(*s);
78: }
79:
80: static inline void bswap64s(uint64_t *s)
81: {
82: *s = bswap64(*s);
83: }
84:
1.1.1.5 root 85: #if defined(HOST_WORDS_BIGENDIAN)
1.1 root 86: #define be_bswap(v, size) (v)
87: #define le_bswap(v, size) bswap ## size(v)
88: #define be_bswaps(v, size)
89: #define le_bswaps(p, size) *p = bswap ## size(*p);
90: #else
91: #define le_bswap(v, size) (v)
92: #define be_bswap(v, size) bswap ## size(v)
93: #define le_bswaps(v, size)
94: #define be_bswaps(p, size) *p = bswap ## size(*p);
95: #endif
96:
97: #define CPU_CONVERT(endian, size, type)\
98: static inline type endian ## size ## _to_cpu(type v)\
99: {\
100: return endian ## _bswap(v, size);\
101: }\
102: \
103: static inline type cpu_to_ ## endian ## size(type v)\
104: {\
105: return endian ## _bswap(v, size);\
106: }\
107: \
108: static inline void endian ## size ## _to_cpus(type *p)\
109: {\
110: endian ## _bswaps(p, size)\
111: }\
112: \
113: static inline void cpu_to_ ## endian ## size ## s(type *p)\
114: {\
115: endian ## _bswaps(p, size)\
116: }\
117: \
118: static inline type endian ## size ## _to_cpup(const type *p)\
119: {\
120: return endian ## size ## _to_cpu(*p);\
121: }\
122: \
123: static inline void cpu_to_ ## endian ## size ## w(type *p, type v)\
124: {\
125: *p = cpu_to_ ## endian ## size(v);\
126: }
127:
128: CPU_CONVERT(be, 16, uint16_t)
129: CPU_CONVERT(be, 32, uint32_t)
130: CPU_CONVERT(be, 64, uint64_t)
131:
132: CPU_CONVERT(le, 16, uint16_t)
133: CPU_CONVERT(le, 32, uint32_t)
134: CPU_CONVERT(le, 64, uint64_t)
135:
136: /* unaligned versions (optimized for frequent unaligned accesses)*/
137:
1.1.1.3 root 138: #if defined(__i386__) || defined(_ARCH_PPC)
1.1 root 139:
140: #define cpu_to_le16wu(p, v) cpu_to_le16w(p, v)
141: #define cpu_to_le32wu(p, v) cpu_to_le32w(p, v)
142: #define le16_to_cpupu(p) le16_to_cpup(p)
143: #define le32_to_cpupu(p) le32_to_cpup(p)
1.1.1.3 root 144: #define be32_to_cpupu(p) be32_to_cpup(p)
1.1 root 145:
146: #define cpu_to_be16wu(p, v) cpu_to_be16w(p, v)
147: #define cpu_to_be32wu(p, v) cpu_to_be32w(p, v)
1.1.1.7 root 148: #define cpu_to_be64wu(p, v) cpu_to_be64w(p, v)
1.1 root 149:
150: #else
151:
152: static inline void cpu_to_le16wu(uint16_t *p, uint16_t v)
153: {
154: uint8_t *p1 = (uint8_t *)p;
155:
1.1.1.4 root 156: p1[0] = v & 0xff;
1.1 root 157: p1[1] = v >> 8;
158: }
159:
160: static inline void cpu_to_le32wu(uint32_t *p, uint32_t v)
161: {
162: uint8_t *p1 = (uint8_t *)p;
163:
1.1.1.4 root 164: p1[0] = v & 0xff;
1.1 root 165: p1[1] = v >> 8;
166: p1[2] = v >> 16;
167: p1[3] = v >> 24;
168: }
169:
170: static inline uint16_t le16_to_cpupu(const uint16_t *p)
171: {
172: const uint8_t *p1 = (const uint8_t *)p;
173: return p1[0] | (p1[1] << 8);
174: }
175:
176: static inline uint32_t le32_to_cpupu(const uint32_t *p)
177: {
178: const uint8_t *p1 = (const uint8_t *)p;
179: return p1[0] | (p1[1] << 8) | (p1[2] << 16) | (p1[3] << 24);
180: }
181:
1.1.1.3 root 182: static inline uint32_t be32_to_cpupu(const uint32_t *p)
183: {
184: const uint8_t *p1 = (const uint8_t *)p;
185: return p1[3] | (p1[2] << 8) | (p1[1] << 16) | (p1[0] << 24);
186: }
187:
1.1 root 188: static inline void cpu_to_be16wu(uint16_t *p, uint16_t v)
189: {
190: uint8_t *p1 = (uint8_t *)p;
191:
192: p1[0] = v >> 8;
1.1.1.4 root 193: p1[1] = v & 0xff;
1.1 root 194: }
195:
196: static inline void cpu_to_be32wu(uint32_t *p, uint32_t v)
197: {
198: uint8_t *p1 = (uint8_t *)p;
199:
200: p1[0] = v >> 24;
201: p1[1] = v >> 16;
202: p1[2] = v >> 8;
1.1.1.4 root 203: p1[3] = v & 0xff;
1.1 root 204: }
205:
1.1.1.7 root 206: static inline void cpu_to_be64wu(uint64_t *p, uint64_t v)
207: {
208: uint8_t *p1 = (uint8_t *)p;
209:
210: p1[0] = v >> 56;
211: p1[1] = v >> 48;
212: p1[2] = v >> 40;
213: p1[3] = v >> 32;
214: p1[4] = v >> 24;
215: p1[5] = v >> 16;
216: p1[6] = v >> 8;
217: p1[7] = v & 0xff;
218: }
219:
1.1 root 220: #endif
221:
1.1.1.5 root 222: #ifdef HOST_WORDS_BIGENDIAN
1.1 root 223: #define cpu_to_32wu cpu_to_be32wu
1.1.1.6 root 224: #define leul_to_cpu(v) glue(glue(le,HOST_LONG_BITS),_to_cpu)(v)
1.1 root 225: #else
226: #define cpu_to_32wu cpu_to_le32wu
1.1.1.6 root 227: #define leul_to_cpu(v) (v)
1.1 root 228: #endif
229:
230: #undef le_bswap
231: #undef be_bswap
232: #undef le_bswaps
233: #undef be_bswaps
234:
1.1.1.6 root 235: /* len must be one of 1, 2, 4 */
236: static inline uint32_t qemu_bswap_len(uint32_t value, int len)
237: {
238: return bswap32(value) >> (32 - 8 * len);
239: }
240:
1.1.1.8 ! root 241: typedef union {
! 242: float32 f;
! 243: uint32_t l;
! 244: } CPU_FloatU;
! 245:
! 246: typedef union {
! 247: float64 d;
! 248: #if defined(HOST_WORDS_BIGENDIAN)
! 249: struct {
! 250: uint32_t upper;
! 251: uint32_t lower;
! 252: } l;
! 253: #else
! 254: struct {
! 255: uint32_t lower;
! 256: uint32_t upper;
! 257: } l;
! 258: #endif
! 259: uint64_t ll;
! 260: } CPU_DoubleU;
! 261:
! 262: typedef union {
! 263: floatx80 d;
! 264: struct {
! 265: uint64_t lower;
! 266: uint16_t upper;
! 267: } l;
! 268: } CPU_LDoubleU;
! 269:
! 270: typedef union {
! 271: float128 q;
! 272: #if defined(HOST_WORDS_BIGENDIAN)
! 273: struct {
! 274: uint32_t upmost;
! 275: uint32_t upper;
! 276: uint32_t lower;
! 277: uint32_t lowest;
! 278: } l;
! 279: struct {
! 280: uint64_t upper;
! 281: uint64_t lower;
! 282: } ll;
! 283: #else
! 284: struct {
! 285: uint32_t lowest;
! 286: uint32_t lower;
! 287: uint32_t upper;
! 288: uint32_t upmost;
! 289: } l;
! 290: struct {
! 291: uint64_t lower;
! 292: uint64_t upper;
! 293: } ll;
! 294: #endif
! 295: } CPU_QuadU;
! 296:
! 297: /* unaligned/endian-independent pointer access */
! 298:
! 299: /*
! 300: * the generic syntax is:
! 301: *
! 302: * load: ld{type}{sign}{size}{endian}_p(ptr)
! 303: *
! 304: * store: st{type}{size}{endian}_p(ptr, val)
! 305: *
! 306: * Note there are small differences with the softmmu access API!
! 307: *
! 308: * type is:
! 309: * (empty): integer access
! 310: * f : float access
! 311: *
! 312: * sign is:
! 313: * (empty): for floats or 32 bit size
! 314: * u : unsigned
! 315: * s : signed
! 316: *
! 317: * size is:
! 318: * b: 8 bits
! 319: * w: 16 bits
! 320: * l: 32 bits
! 321: * q: 64 bits
! 322: *
! 323: * endian is:
! 324: * (empty): 8 bit access
! 325: * be : big endian
! 326: * le : little endian
! 327: */
! 328: static inline int ldub_p(const void *ptr)
! 329: {
! 330: return *(uint8_t *)ptr;
! 331: }
! 332:
! 333: static inline int ldsb_p(const void *ptr)
! 334: {
! 335: return *(int8_t *)ptr;
! 336: }
! 337:
! 338: static inline void stb_p(void *ptr, int v)
! 339: {
! 340: *(uint8_t *)ptr = v;
! 341: }
! 342:
! 343: /* NOTE: on arm, putting 2 in /proc/sys/debug/alignment so that the
! 344: kernel handles unaligned load/stores may give better results, but
! 345: it is a system wide setting : bad */
! 346: #if defined(HOST_WORDS_BIGENDIAN) || defined(WORDS_ALIGNED)
! 347:
! 348: /* conservative code for little endian unaligned accesses */
! 349: static inline int lduw_le_p(const void *ptr)
! 350: {
! 351: #ifdef _ARCH_PPC
! 352: int val;
! 353: __asm__ __volatile__ ("lhbrx %0,0,%1" : "=r" (val) : "r" (ptr));
! 354: return val;
! 355: #else
! 356: const uint8_t *p = ptr;
! 357: return p[0] | (p[1] << 8);
! 358: #endif
! 359: }
! 360:
! 361: static inline int ldsw_le_p(const void *ptr)
! 362: {
! 363: #ifdef _ARCH_PPC
! 364: int val;
! 365: __asm__ __volatile__ ("lhbrx %0,0,%1" : "=r" (val) : "r" (ptr));
! 366: return (int16_t)val;
! 367: #else
! 368: const uint8_t *p = ptr;
! 369: return (int16_t)(p[0] | (p[1] << 8));
! 370: #endif
! 371: }
! 372:
! 373: static inline int ldl_le_p(const void *ptr)
! 374: {
! 375: #ifdef _ARCH_PPC
! 376: int val;
! 377: __asm__ __volatile__ ("lwbrx %0,0,%1" : "=r" (val) : "r" (ptr));
! 378: return val;
! 379: #else
! 380: const uint8_t *p = ptr;
! 381: return p[0] | (p[1] << 8) | (p[2] << 16) | (p[3] << 24);
! 382: #endif
! 383: }
! 384:
! 385: static inline uint64_t ldq_le_p(const void *ptr)
! 386: {
! 387: const uint8_t *p = ptr;
! 388: uint32_t v1, v2;
! 389: v1 = ldl_le_p(p);
! 390: v2 = ldl_le_p(p + 4);
! 391: return v1 | ((uint64_t)v2 << 32);
! 392: }
! 393:
! 394: static inline void stw_le_p(void *ptr, int v)
! 395: {
! 396: #ifdef _ARCH_PPC
! 397: __asm__ __volatile__ ("sthbrx %1,0,%2" : "=m" (*(uint16_t *)ptr) : "r" (v), "r" (ptr));
! 398: #else
! 399: uint8_t *p = ptr;
! 400: p[0] = v;
! 401: p[1] = v >> 8;
! 402: #endif
! 403: }
! 404:
! 405: static inline void stl_le_p(void *ptr, int v)
! 406: {
! 407: #ifdef _ARCH_PPC
! 408: __asm__ __volatile__ ("stwbrx %1,0,%2" : "=m" (*(uint32_t *)ptr) : "r" (v), "r" (ptr));
! 409: #else
! 410: uint8_t *p = ptr;
! 411: p[0] = v;
! 412: p[1] = v >> 8;
! 413: p[2] = v >> 16;
! 414: p[3] = v >> 24;
! 415: #endif
! 416: }
! 417:
! 418: static inline void stq_le_p(void *ptr, uint64_t v)
! 419: {
! 420: uint8_t *p = ptr;
! 421: stl_le_p(p, (uint32_t)v);
! 422: stl_le_p(p + 4, v >> 32);
! 423: }
! 424:
! 425: /* float access */
! 426:
! 427: static inline float32 ldfl_le_p(const void *ptr)
! 428: {
! 429: union {
! 430: float32 f;
! 431: uint32_t i;
! 432: } u;
! 433: u.i = ldl_le_p(ptr);
! 434: return u.f;
! 435: }
! 436:
! 437: static inline void stfl_le_p(void *ptr, float32 v)
! 438: {
! 439: union {
! 440: float32 f;
! 441: uint32_t i;
! 442: } u;
! 443: u.f = v;
! 444: stl_le_p(ptr, u.i);
! 445: }
! 446:
! 447: static inline float64 ldfq_le_p(const void *ptr)
! 448: {
! 449: CPU_DoubleU u;
! 450: u.l.lower = ldl_le_p(ptr);
! 451: u.l.upper = ldl_le_p(ptr + 4);
! 452: return u.d;
! 453: }
! 454:
! 455: static inline void stfq_le_p(void *ptr, float64 v)
! 456: {
! 457: CPU_DoubleU u;
! 458: u.d = v;
! 459: stl_le_p(ptr, u.l.lower);
! 460: stl_le_p(ptr + 4, u.l.upper);
! 461: }
! 462:
! 463: #else
! 464:
! 465: static inline int lduw_le_p(const void *ptr)
! 466: {
! 467: return *(uint16_t *)ptr;
! 468: }
! 469:
! 470: static inline int ldsw_le_p(const void *ptr)
! 471: {
! 472: return *(int16_t *)ptr;
! 473: }
! 474:
! 475: static inline int ldl_le_p(const void *ptr)
! 476: {
! 477: return *(uint32_t *)ptr;
! 478: }
! 479:
! 480: static inline uint64_t ldq_le_p(const void *ptr)
! 481: {
! 482: return *(uint64_t *)ptr;
! 483: }
! 484:
! 485: static inline void stw_le_p(void *ptr, int v)
! 486: {
! 487: *(uint16_t *)ptr = v;
! 488: }
! 489:
! 490: static inline void stl_le_p(void *ptr, int v)
! 491: {
! 492: *(uint32_t *)ptr = v;
! 493: }
! 494:
! 495: static inline void stq_le_p(void *ptr, uint64_t v)
! 496: {
! 497: *(uint64_t *)ptr = v;
! 498: }
! 499:
! 500: /* float access */
! 501:
! 502: static inline float32 ldfl_le_p(const void *ptr)
! 503: {
! 504: return *(float32 *)ptr;
! 505: }
! 506:
! 507: static inline float64 ldfq_le_p(const void *ptr)
! 508: {
! 509: return *(float64 *)ptr;
! 510: }
! 511:
! 512: static inline void stfl_le_p(void *ptr, float32 v)
! 513: {
! 514: *(float32 *)ptr = v;
! 515: }
! 516:
! 517: static inline void stfq_le_p(void *ptr, float64 v)
! 518: {
! 519: *(float64 *)ptr = v;
! 520: }
! 521: #endif
! 522:
! 523: #if !defined(HOST_WORDS_BIGENDIAN) || defined(WORDS_ALIGNED)
! 524:
! 525: static inline int lduw_be_p(const void *ptr)
! 526: {
! 527: #if defined(__i386__)
! 528: int val;
! 529: asm volatile ("movzwl %1, %0\n"
! 530: "xchgb %b0, %h0\n"
! 531: : "=q" (val)
! 532: : "m" (*(uint16_t *)ptr));
! 533: return val;
! 534: #else
! 535: const uint8_t *b = ptr;
! 536: return ((b[0] << 8) | b[1]);
! 537: #endif
! 538: }
! 539:
! 540: static inline int ldsw_be_p(const void *ptr)
! 541: {
! 542: #if defined(__i386__)
! 543: int val;
! 544: asm volatile ("movzwl %1, %0\n"
! 545: "xchgb %b0, %h0\n"
! 546: : "=q" (val)
! 547: : "m" (*(uint16_t *)ptr));
! 548: return (int16_t)val;
! 549: #else
! 550: const uint8_t *b = ptr;
! 551: return (int16_t)((b[0] << 8) | b[1]);
! 552: #endif
! 553: }
! 554:
! 555: static inline int ldl_be_p(const void *ptr)
! 556: {
! 557: #if defined(__i386__) || defined(__x86_64__)
! 558: int val;
! 559: asm volatile ("movl %1, %0\n"
! 560: "bswap %0\n"
! 561: : "=r" (val)
! 562: : "m" (*(uint32_t *)ptr));
! 563: return val;
! 564: #else
! 565: const uint8_t *b = ptr;
! 566: return (b[0] << 24) | (b[1] << 16) | (b[2] << 8) | b[3];
! 567: #endif
! 568: }
! 569:
! 570: static inline uint64_t ldq_be_p(const void *ptr)
! 571: {
! 572: uint32_t a,b;
! 573: a = ldl_be_p(ptr);
! 574: b = ldl_be_p((uint8_t *)ptr + 4);
! 575: return (((uint64_t)a<<32)|b);
! 576: }
! 577:
! 578: static inline void stw_be_p(void *ptr, int v)
! 579: {
! 580: #if defined(__i386__)
! 581: asm volatile ("xchgb %b0, %h0\n"
! 582: "movw %w0, %1\n"
! 583: : "=q" (v)
! 584: : "m" (*(uint16_t *)ptr), "0" (v));
! 585: #else
! 586: uint8_t *d = (uint8_t *) ptr;
! 587: d[0] = v >> 8;
! 588: d[1] = v;
! 589: #endif
! 590: }
! 591:
! 592: static inline void stl_be_p(void *ptr, int v)
! 593: {
! 594: #if defined(__i386__) || defined(__x86_64__)
! 595: asm volatile ("bswap %0\n"
! 596: "movl %0, %1\n"
! 597: : "=r" (v)
! 598: : "m" (*(uint32_t *)ptr), "0" (v));
! 599: #else
! 600: uint8_t *d = (uint8_t *) ptr;
! 601: d[0] = v >> 24;
! 602: d[1] = v >> 16;
! 603: d[2] = v >> 8;
! 604: d[3] = v;
! 605: #endif
! 606: }
! 607:
! 608: static inline void stq_be_p(void *ptr, uint64_t v)
! 609: {
! 610: stl_be_p(ptr, v >> 32);
! 611: stl_be_p((uint8_t *)ptr + 4, v);
! 612: }
! 613:
! 614: /* float access */
! 615:
! 616: static inline float32 ldfl_be_p(const void *ptr)
! 617: {
! 618: union {
! 619: float32 f;
! 620: uint32_t i;
! 621: } u;
! 622: u.i = ldl_be_p(ptr);
! 623: return u.f;
! 624: }
! 625:
! 626: static inline void stfl_be_p(void *ptr, float32 v)
! 627: {
! 628: union {
! 629: float32 f;
! 630: uint32_t i;
! 631: } u;
! 632: u.f = v;
! 633: stl_be_p(ptr, u.i);
! 634: }
! 635:
! 636: static inline float64 ldfq_be_p(const void *ptr)
! 637: {
! 638: CPU_DoubleU u;
! 639: u.l.upper = ldl_be_p(ptr);
! 640: u.l.lower = ldl_be_p((uint8_t *)ptr + 4);
! 641: return u.d;
! 642: }
! 643:
! 644: static inline void stfq_be_p(void *ptr, float64 v)
! 645: {
! 646: CPU_DoubleU u;
! 647: u.d = v;
! 648: stl_be_p(ptr, u.l.upper);
! 649: stl_be_p((uint8_t *)ptr + 4, u.l.lower);
! 650: }
! 651:
! 652: #else
! 653:
! 654: static inline int lduw_be_p(const void *ptr)
! 655: {
! 656: return *(uint16_t *)ptr;
! 657: }
! 658:
! 659: static inline int ldsw_be_p(const void *ptr)
! 660: {
! 661: return *(int16_t *)ptr;
! 662: }
! 663:
! 664: static inline int ldl_be_p(const void *ptr)
! 665: {
! 666: return *(uint32_t *)ptr;
! 667: }
! 668:
! 669: static inline uint64_t ldq_be_p(const void *ptr)
! 670: {
! 671: return *(uint64_t *)ptr;
! 672: }
! 673:
! 674: static inline void stw_be_p(void *ptr, int v)
! 675: {
! 676: *(uint16_t *)ptr = v;
! 677: }
! 678:
! 679: static inline void stl_be_p(void *ptr, int v)
! 680: {
! 681: *(uint32_t *)ptr = v;
! 682: }
! 683:
! 684: static inline void stq_be_p(void *ptr, uint64_t v)
! 685: {
! 686: *(uint64_t *)ptr = v;
! 687: }
! 688:
! 689: /* float access */
! 690:
! 691: static inline float32 ldfl_be_p(const void *ptr)
! 692: {
! 693: return *(float32 *)ptr;
! 694: }
! 695:
! 696: static inline float64 ldfq_be_p(const void *ptr)
! 697: {
! 698: return *(float64 *)ptr;
! 699: }
! 700:
! 701: static inline void stfl_be_p(void *ptr, float32 v)
! 702: {
! 703: *(float32 *)ptr = v;
! 704: }
! 705:
! 706: static inline void stfq_be_p(void *ptr, float64 v)
! 707: {
! 708: *(float64 *)ptr = v;
! 709: }
! 710:
! 711: #endif
! 712:
1.1 root 713: #endif /* BSWAP_H */
unix.superglobalmegacorp.com
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to bswap.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu