include/uapi/linux/swab.h

   1 #ifndef _UAPI_LINUX_SWAB_H
   2 #define _UAPI_LINUX_SWAB_H
   3
   4 #include <linux/types.h>
   5 #include <linux/compiler.h>
   6 #include <asm/swab.h>
   7
   8 /*
   9  * casts are necessary for constants, because we never know how for sure
  10  * how U/UL/ULL map to __u16, __u32, __u64. At least not in a portable way.
  11  */
  12 #define ___constant_swab16(x) ((__u16)(                         \
  13         (((__u16)(x) & (__u16)0x00ffU) << 8) |                  \
  14         (((__u16)(x) & (__u16)0xff00U) >> 8)))
  15
  16 #define ___constant_swab32(x) ((__u32)(                         \
  17         (((__u32)(x) & (__u32)0x000000ffUL) << 24) |            \
  18         (((__u32)(x) & (__u32)0x0000ff00UL) <<  8) |            \
  19         (((__u32)(x) & (__u32)0x00ff0000UL) >>  8) |            \
  20         (((__u32)(x) & (__u32)0xff000000UL) >> 24)))
  21
  22 #define ___constant_swab64(x) ((__u64)(                         \
  23         (((__u64)(x) & (__u64)0x00000000000000ffULL) << 56) |   \
  24         (((__u64)(x) & (__u64)0x000000000000ff00ULL) << 40) |   \
  25         (((__u64)(x) & (__u64)0x0000000000ff0000ULL) << 24) |   \
  26         (((__u64)(x) & (__u64)0x00000000ff000000ULL) <<  8) |   \
  27         (((__u64)(x) & (__u64)0x000000ff00000000ULL) >>  8) |   \
  28         (((__u64)(x) & (__u64)0x0000ff0000000000ULL) >> 24) |   \
  29         (((__u64)(x) & (__u64)0x00ff000000000000ULL) >> 40) |   \
  30         (((__u64)(x) & (__u64)0xff00000000000000ULL) >> 56)))
  31
  32 #define ___constant_swahw32(x) ((__u32)(                        \
  33         (((__u32)(x) & (__u32)0x0000ffffUL) << 16) |            \
  34         (((__u32)(x) & (__u32)0xffff0000UL) >> 16)))
  35
  36 #define ___constant_swahb32(x) ((__u32)(                        \
  37         (((__u32)(x) & (__u32)0x00ff00ffUL) << 8) |             \
  38         (((__u32)(x) & (__u32)0xff00ff00UL) >> 8)))
  39
  40 /*
  41  * Implement the following as inlines, but define the interface using
  42  * macros to allow constant folding when possible:
  43  * ___swab16, ___swab32, ___swab64, ___swahw32, ___swahb32
  44  */
  45
  46 static inline __attribute_const__ __u16 __fswab16(__u16 val)
  47 {
  48 #if defined (__arch_swab16)
  49         return __arch_swab16(val);
  50 #else
  51         return ___constant_swab16(val);
  52 #endif
  53 }
  54
  55 static inline __attribute_const__ __u32 __fswab32(__u32 val)
  56 {
  57 #if defined(__arch_swab32)
  58         return __arch_swab32(val);
  59 #else
  60         return ___constant_swab32(val);
  61 #endif
  62 }
  63
  64 static inline __attribute_const__ __u64 __fswab64(__u64 val)
  65 {
  66 #if defined (__arch_swab64)
  67         return __arch_swab64(val);
  68 #elif defined(__SWAB_64_THRU_32__)
  69         __u32 h = val >> 32;
  70         __u32 l = val & ((1ULL << 32) - 1);
  71         return (((__u64)__fswab32(l)) << 32) | ((__u64)(__fswab32(h)));
  72 #else
  73         return ___constant_swab64(val);
  74 #endif
  75 }
  76
  77 static inline __attribute_const__ __u32 __fswahw32(__u32 val)
  78 {
  79 #ifdef __arch_swahw32
  80         return __arch_swahw32(val);
  81 #else
  82         return ___constant_swahw32(val);
  83 #endif
  84 }
  85
  86 static inline __attribute_const__ __u32 __fswahb32(__u32 val)
  87 {
  88 #ifdef __arch_swahb32
  89         return __arch_swahb32(val);
  90 #else
  91         return ___constant_swahb32(val);
  92 #endif
  93 }
  94
  95 /**
  96  * __swab16 - return a byteswapped 16-bit value
  97  * @x: value to byteswap
  98  */
  99 #ifdef __HAVE_BUILTIN_BSWAP16__
 100 #define __swab16(x) (__u16)__builtin_bswap16((__u16)(x))
 101 #else
 102 #define __swab16(x)                             \
 103         (__builtin_constant_p((__u16)(x)) ?     \
 104         ___constant_swab16(x) :                 \
 105         __fswab16(x))
 106 #endif
 107
 108 /**
 109  * __swab32 - return a byteswapped 32-bit value
 110  * @x: value to byteswap
 111  */
 112 #ifdef __HAVE_BUILTIN_BSWAP32__
 113 #define __swab32(x) (__u32)__builtin_bswap32((__u32)(x))
 114 #else
 115 #define __swab32(x)                             \
 116         (__builtin_constant_p((__u32)(x)) ?     \
 117         ___constant_swab32(x) :                 \
 118         __fswab32(x))
 119 #endif
 120
 121 /**
 122  * __swab64 - return a byteswapped 64-bit value
 123  * @x: value to byteswap
 124  */
 125 #ifdef __HAVE_BUILTIN_BSWAP64__
 126 #define __swab64(x) (__u64)__builtin_bswap64((__u64)(x))
 127 #else
 128 #define __swab64(x)                             \
 129         (__builtin_constant_p((__u64)(x)) ?     \
 130         ___constant_swab64(x) :                 \
 131         __fswab64(x))
 132 #endif
 133
 134 /**
 135  * __swahw32 - return a word-swapped 32-bit value
 136  * @x: value to wordswap
 137  *
 138  * __swahw32(0x12340000) is 0x00001234
 139  */
 140 #define __swahw32(x)                            \
 141         (__builtin_constant_p((__u32)(x)) ?     \
 142         ___constant_swahw32(x) :                \
 143         __fswahw32(x))
 144
 145 /**
 146  * __swahb32 - return a high and low byte-swapped 32-bit value
 147  * @x: value to byteswap
 148  *
 149  * __swahb32(0x12345678) is 0x34127856
 150  */
 151 #define __swahb32(x)                            \
 152         (__builtin_constant_p((__u32)(x)) ?     \
 153         ___constant_swahb32(x) :                \
 154         __fswahb32(x))
 155
 156 /**
 157  * __swab16p - return a byteswapped 16-bit value from a pointer
 158  * @p: pointer to a naturally-aligned 16-bit value
 159  */
 160 static __always_inline __u16 __swab16p(const __u16 *p)
 161 {
 162 #ifdef __arch_swab16p
 163         return __arch_swab16p(p);
 164 #else
 165         return __swab16(*p);
 166 #endif
 167 }
 168
 169 /**
 170  * __swab32p - return a byteswapped 32-bit value from a pointer
 171  * @p: pointer to a naturally-aligned 32-bit value
 172  */
 173 static __always_inline __u32 __swab32p(const __u32 *p)
 174 {
 175 #ifdef __arch_swab32p
 176         return __arch_swab32p(p);
 177 #else
 178         return __swab32(*p);
 179 #endif
 180 }
 181
 182 /**
 183  * __swab64p - return a byteswapped 64-bit value from a pointer
 184  * @p: pointer to a naturally-aligned 64-bit value
 185  */
 186 static __always_inline __u64 __swab64p(const __u64 *p)
 187 {
 188 #ifdef __arch_swab64p
 189         return __arch_swab64p(p);
 190 #else
 191         return __swab64(*p);
 192 #endif
 193 }
 194
 195 /**
 196  * __swahw32p - return a wordswapped 32-bit value from a pointer
 197  * @p: pointer to a naturally-aligned 32-bit value
 198  *
 199  * See __swahw32() for details of wordswapping.
 200  */
 201 static inline __u32 __swahw32p(const __u32 *p)
 202 {
 203 #ifdef __arch_swahw32p
 204         return __arch_swahw32p(p);
 205 #else
 206         return __swahw32(*p);
 207 #endif
 208 }
 209
 210 /**
 211  * __swahb32p - return a high and low byteswapped 32-bit value from a pointer
 212  * @p: pointer to a naturally-aligned 32-bit value
 213  *
 214  * See __swahb32() for details of high/low byteswapping.
 215  */
 216 static inline __u32 __swahb32p(const __u32 *p)
 217 {
 218 #ifdef __arch_swahb32p
 219         return __arch_swahb32p(p);
 220 #else
 221         return __swahb32(*p);
 222 #endif
 223 }
 224
 225 /**
 226  * __swab16s - byteswap a 16-bit value in-place
 227  * @p: pointer to a naturally-aligned 16-bit value
 228  */
 229 static inline void __swab16s(__u16 *p)
 230 {
 231 #ifdef __arch_swab16s
 232         __arch_swab16s(p);
 233 #else
 234         *p = __swab16p(p);
 235 #endif
 236 }
 237 /**
 238  * __swab32s - byteswap a 32-bit value in-place
 239  * @p: pointer to a naturally-aligned 32-bit value
 240  */
 241 static __always_inline void __swab32s(__u32 *p)
 242 {
 243 #ifdef __arch_swab32s
 244         __arch_swab32s(p);
 245 #else
 246         *p = __swab32p(p);
 247 #endif
 248 }
 249
 250 /**
 251  * __swab64s - byteswap a 64-bit value in-place
 252  * @p: pointer to a naturally-aligned 64-bit value
 253  */
 254 static __always_inline void __swab64s(__u64 *p)
 255 {
 256 #ifdef __arch_swab64s
 257         __arch_swab64s(p);
 258 #else
 259         *p = __swab64p(p);
 260 #endif
 261 }
 262
 263 /**
 264  * __swahw32s - wordswap a 32-bit value in-place
 265  * @p: pointer to a naturally-aligned 32-bit value
 266  *
 267  * See __swahw32() for details of wordswapping
 268  */
 269 static inline void __swahw32s(__u32 *p)
 270 {
 271 #ifdef __arch_swahw32s
 272         __arch_swahw32s(p);
 273 #else
 274         *p = __swahw32p(p);
 275 #endif
 276 }
 277
 278 /**
 279  * __swahb32s - high and low byteswap a 32-bit value in-place
 280  * @p: pointer to a naturally-aligned 32-bit value
 281  *
 282  * See __swahb32() for details of high and low byte swapping
 283  */
 284 static inline void __swahb32s(__u32 *p)
 285 {
 286 #ifdef __arch_swahb32s
 287         __arch_swahb32s(p);
 288 #else
 289         *p = __swahb32p(p);
 290 #endif
 291 }
 292
 293
 294 #endif /* _UAPI_LINUX_SWAB_H */