git.ozlabs.org Git - ccan/blob - ccan/endian/endian.h

   1 /* CC0 (Public domain) - see LICENSE file for details */
   2 #ifndef CCAN_ENDIAN_H
   3 #define CCAN_ENDIAN_H
   4 #include <stdint.h>
   5 #include "config.h"
   6
   7 /**
   8  * BSWAP_16 - reverse bytes in a constant uint16_t value.
   9  * @val: constant value whose bytes to swap.
  10  *
  11  * Designed to be usable in constant-requiring initializers.
  12  *
  13  * Example:
  14  *      struct mystruct {
  15  *              char buf[BSWAP_16(0x1234)];
  16  *      };
  17  */
  18 #define BSWAP_16(val)                           \
  19         ((((uint16_t)val & 0x00ff) << 8)        \
  20          | (((uint16_t)val & 0xff00) >> 8))
  21
  22 /**
  23  * BSWAP_32 - reverse bytes in a constant uint32_t value.
  24  * @val: constant value whose bytes to swap.
  25  *
  26  * Designed to be usable in constant-requiring initializers.
  27  *
  28  * Example:
  29  *      struct mystruct {
  30  *              char buf[BSWAP_32(0xff000000)];
  31  *      };
  32  */
  33 #define BSWAP_32(val)                                   \
  34         ((((uint32_t)val & 0x000000ff) << 24)           \
  35          | (((uint32_t)val & 0x0000ff00) << 8)          \
  36          | (((uint32_t)val & 0x00ff0000) >> 8)          \
  37          | (((uint32_t)val & 0xff000000) >> 24))
  38
  39 /**
  40  * BSWAP_64 - reverse bytes in a constant uint64_t value.
  41  * @val: constantvalue whose bytes to swap.
  42  *
  43  * Designed to be usable in constant-requiring initializers.
  44  *
  45  * Example:
  46  *      struct mystruct {
  47  *              char buf[BSWAP_64(0xff00000000000000ULL)];
  48  *      };
  49  */
  50 #define BSWAP_64(val)                                           \
  51         ((((uint64_t)val & 0x00000000000000ffULL) << 56)        \
  52          | (((uint64_t)val & 0x000000000000ff00ULL) << 40)      \
  53          | (((uint64_t)val & 0x0000000000ff0000ULL) << 24)      \
  54          | (((uint64_t)val & 0x00000000ff000000ULL) << 8)       \
  55          | (((uint64_t)val & 0x000000ff00000000ULL) >> 8)       \
  56          | (((uint64_t)val & 0x0000ff0000000000ULL) >> 24)      \
  57          | (((uint64_t)val & 0x00ff000000000000ULL) >> 40)      \
  58          | (((uint64_t)val & 0xff00000000000000ULL) >> 56))
  59
  60 #if HAVE_BYTESWAP_H
  61 #include <byteswap.h>
  62 #else
  63 /**
  64  * bswap_16 - reverse bytes in a uint16_t value.
  65  * @val: value whose bytes to swap.
  66  *
  67  * Example:
  68  *      // Output contains "1024 is 4 as two bytes reversed"
  69  *      printf("1024 is %u as two bytes reversed\n", bswap_16(1024));
  70  */
  71 static inline uint16_t bswap_16(uint16_t val)
  72 {
  73         return BSWAP_16(val);
  74 }
  75
  76 /**
  77  * bswap_32 - reverse bytes in a uint32_t value.
  78  * @val: value whose bytes to swap.
  79  *
  80  * Example:
  81  *      // Output contains "1024 is 262144 as four bytes reversed"
  82  *      printf("1024 is %u as four bytes reversed\n", bswap_32(1024));
  83  */
  84 static inline uint32_t bswap_32(uint32_t val)
  85 {
  86         return BSWAP_32(val);
  87 }
  88 #endif /* !HAVE_BYTESWAP_H */
  89
  90 #if !HAVE_BSWAP_64
  91 /**
  92  * bswap_64 - reverse bytes in a uint64_t value.
  93  * @val: value whose bytes to swap.
  94  *
  95  * Example:
  96  *      // Output contains "1024 is 1125899906842624 as eight bytes reversed"
  97  *      printf("1024 is %llu as eight bytes reversed\n",
  98  *              (unsigned long long)bswap_64(1024));
  99  */
 100 static inline uint64_t bswap_64(uint64_t val)
 101 {
 102         return BSWAP_64(val);
 103 }
 104 #endif
 105
 106 /* Sanity check the defines.  We don't handle weird endianness. */
 107 #if !HAVE_LITTLE_ENDIAN && !HAVE_BIG_ENDIAN
 108 #error "Unknown endian"
 109 #elif HAVE_LITTLE_ENDIAN && HAVE_BIG_ENDIAN
 110 #error "Can't compile for both big and little endian."
 111 #endif
 112
 113 #if HAVE_LITTLE_ENDIAN
 114 /**
 115  * CPU_TO_LE64 - convert a constant uint64_t value to little-endian
 116  * @native: constant to convert
 117  */
 118 #define CPU_TO_LE64(native) (native)
 119
 120 /**
 121  * CPU_TO_LE32 - convert a constant uint32_t value to little-endian
 122  * @native: constant to convert
 123  */
 124 #define CPU_TO_LE32(native) (native)
 125
 126 /**
 127  * CPU_TO_LE16 - convert a constant uint16_t value to little-endian
 128  * @native: constant to convert
 129  */
 130 #define CPU_TO_LE16(native) (native)
 131
 132 /**
 133  * LE64_TO_CPU - convert a little-endian uint64_t constant
 134  * @le_val: little-endian constant to convert
 135  */
 136 #define LE64_TO_CPU(le_val) (le_val)
 137
 138 /**
 139  * LE32_TO_CPU - convert a little-endian uint32_t constant
 140  * @le_val: little-endian constant to convert
 141  */
 142 #define LE32_TO_CPU(le_val) (le_val)
 143
 144 /**
 145  * LE16_TO_CPU - convert a little-endian uint16_t constant
 146  * @le_val: little-endian constant to convert
 147  */
 148 #define LE16_TO_CPU(le_val) (le_val)
 149
 150 #else /* ... HAVE_BIG_ENDIAN */
 151 #define CPU_TO_LE64(native) BSWAP_64(native)
 152 #define CPU_TO_LE32(native) BSWAP_32(native)
 153 #define CPU_TO_LE16(native) BSWAP_16(native)
 154 #define LE64_TO_CPU(le_val) BSWAP_64(le_val)
 155 #define LE32_TO_CPU(le_val) BSWAP_32(le_val)
 156 #define LE16_TO_CPU(le_val) BSWAP_16(le_val)
 157 #endif /* HAVE_BIG_ENDIAN */
 158
 159 #if HAVE_BIG_ENDIAN
 160 /**
 161  * CPU_TO_BE64 - convert a constant uint64_t value to big-endian
 162  * @native: constant to convert
 163  */
 164 #define CPU_TO_BE64(native) (native)
 165
 166 /**
 167  * CPU_TO_BE32 - convert a constant uint32_t value to big-endian
 168  * @native: constant to convert
 169  */
 170 #define CPU_TO_BE32(native) (native)
 171
 172 /**
 173  * CPU_TO_BE16 - convert a constant uint16_t value to big-endian
 174  * @native: constant to convert
 175  */
 176 #define CPU_TO_BE16(native) (native)
 177
 178 /**
 179  * BE64_TO_CPU - convert a big-endian uint64_t constant
 180  * @le_val: big-endian constant to convert
 181  */
 182 #define BE64_TO_CPU(le_val) (le_val)
 183
 184 /**
 185  * BE32_TO_CPU - convert a big-endian uint32_t constant
 186  * @le_val: big-endian constant to convert
 187  */
 188 #define BE32_TO_CPU(le_val) (le_val)
 189
 190 /**
 191  * BE16_TO_CPU - convert a big-endian uint16_t constant
 192  * @le_val: big-endian constant to convert
 193  */
 194 #define BE16_TO_CPU(le_val) (le_val)
 195
 196 #else /* ... HAVE_LITTLE_ENDIAN */
 197 #define CPU_TO_BE64(native) BSWAP_64(native)
 198 #define CPU_TO_BE32(native) BSWAP_32(native)
 199 #define CPU_TO_BE16(native) BSWAP_16(native)
 200 #define BE64_TO_CPU(le_val) BSWAP_64(le_val)
 201 #define BE32_TO_CPU(le_val) BSWAP_32(le_val)
 202 #define BE16_TO_CPU(le_val) BSWAP_16(le_val)
 203 #endif /* HAVE_LITTE_ENDIAN */
 204
 205
 206 /**
 207  * cpu_to_le64 - convert a uint64_t value to little-endian
 208  * @native: value to convert
 209  */
 210 static inline uint64_t cpu_to_le64(uint64_t native)
 211 {
 212         return CPU_TO_LE64(native);
 213 }
 214
 215 /**
 216  * cpu_to_le32 - convert a uint32_t value to little-endian
 217  * @native: value to convert
 218  */
 219 static inline uint32_t cpu_to_le32(uint32_t native)
 220 {
 221         return CPU_TO_LE32(native);
 222 }
 223
 224 /**
 225  * cpu_to_le16 - convert a uint16_t value to little-endian
 226  * @native: value to convert
 227  */
 228 static inline uint16_t cpu_to_le16(uint16_t native)
 229 {
 230         return CPU_TO_LE16(native);
 231 }
 232
 233 /**
 234  * le64_to_cpu - convert a little-endian uint64_t value
 235  * @le_val: little-endian value to convert
 236  */
 237 static inline uint64_t le64_to_cpu(uint64_t le_val)
 238 {
 239         return LE64_TO_CPU(le_val);
 240 }
 241
 242 /**
 243  * le32_to_cpu - convert a little-endian uint32_t value
 244  * @le_val: little-endian value to convert
 245  */
 246 static inline uint32_t le32_to_cpu(uint32_t le_val)
 247 {
 248         return LE32_TO_CPU(le_val);
 249 }
 250
 251 /**
 252  * le16_to_cpu - convert a little-endian uint16_t value
 253  * @le_val: little-endian value to convert
 254  */
 255 static inline uint16_t le16_to_cpu(uint16_t le_val)
 256 {
 257         return LE16_TO_CPU(le_val);
 258 }
 259
 260 /**
 261  * cpu_to_be64 - convert a uint64_t value to big endian.
 262  * @native: value to convert
 263  */
 264 static inline uint64_t cpu_to_be64(uint64_t native)
 265 {
 266         return CPU_TO_BE64(native);
 267 }
 268
 269 /**
 270  * cpu_to_be32 - convert a uint32_t value to big endian.
 271  * @native: value to convert
 272  */
 273 static inline uint32_t cpu_to_be32(uint32_t native)
 274 {
 275         return CPU_TO_BE32(native);
 276 }
 277
 278 /**
 279  * cpu_to_be16 - convert a uint16_t value to big endian.
 280  * @native: value to convert
 281  */
 282 static inline uint16_t cpu_to_be16(uint16_t native)
 283 {
 284         return CPU_TO_BE16(native);
 285 }
 286
 287 /**
 288  * be64_to_cpu - convert a big-endian uint64_t value
 289  * @be_val: big-endian value to convert
 290  */
 291 static inline uint64_t be64_to_cpu(uint64_t be_val)
 292 {
 293         return BE64_TO_CPU(be_val);
 294 }
 295
 296 /**
 297  * be32_to_cpu - convert a big-endian uint32_t value
 298  * @be_val: big-endian value to convert
 299  */
 300 static inline uint32_t be32_to_cpu(uint32_t be_val)
 301 {
 302         return BE32_TO_CPU(be_val);
 303 }
 304
 305 /**
 306  * be16_to_cpu - convert a big-endian uint16_t value
 307  * @be_val: big-endian value to convert
 308  */
 309 static inline uint16_t be16_to_cpu(uint16_t be_val)
 310 {
 311         return BE16_TO_CPU(be_val);
 312 }
 313
 314 #endif /* CCAN_ENDIAN_H */