File:  [Qemu by Fabrice Bellard] / qemu / bswap.h
Revision 1.1.1.8 (vendor branch): download - view: text, annotated - select for diffs
Tue Apr 24 19:17:40 2018 UTC (2 years, 3 months ago) by root
Branches: qemu, MAIN
CVS tags: qemu1101, qemu1001, HEAD
qemu 1.0.1

    1: #ifndef BSWAP_H
    2: #define BSWAP_H
    3: 
    4: #include "config-host.h"
    5: 
    6: #include <inttypes.h>
    7: #include "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: #else
   14: 
   15: #ifdef CONFIG_BYTESWAP_H
   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: 
   51: #endif /* !CONFIG_BYTESWAP_H */
   52: 
   53: static inline uint16_t bswap16(uint16_t x)
   54: {
   55:     return bswap_16(x);
   56: }
   57: 
   58: static inline uint32_t bswap32(uint32_t x)
   59: {
   60:     return bswap_32(x);
   61: }
   62: 
   63: static inline uint64_t bswap64(uint64_t x)
   64: {
   65:     return bswap_64(x);
   66: }
   67: 
   68: #endif /* ! CONFIG_MACHINE_BSWAP_H */
   69: 
   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: 
   85: #if defined(HOST_WORDS_BIGENDIAN)
   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: 
  138: #if defined(__i386__) || defined(_ARCH_PPC)
  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)
  144: #define be32_to_cpupu(p) be32_to_cpup(p)
  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)
  148: #define cpu_to_be64wu(p, v) cpu_to_be64w(p, v)
  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: 
  156:     p1[0] = v & 0xff;
  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: 
  164:     p1[0] = v & 0xff;
  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: 
  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: 
  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;
  193:     p1[1] = v & 0xff;
  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;
  203:     p1[3] = v & 0xff;
  204: }
  205: 
  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: 
  220: #endif
  221: 
  222: #ifdef HOST_WORDS_BIGENDIAN
  223: #define cpu_to_32wu cpu_to_be32wu
  224: #define leul_to_cpu(v) glue(glue(le,HOST_LONG_BITS),_to_cpu)(v)
  225: #else
  226: #define cpu_to_32wu cpu_to_le32wu
  227: #define leul_to_cpu(v) (v)
  228: #endif
  229: 
  230: #undef le_bswap
  231: #undef be_bswap
  232: #undef le_bswaps
  233: #undef be_bswaps
  234: 
  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: 
  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: 
  713: #endif /* BSWAP_H */

unix.superglobalmegacorp.com