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