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 /* Needed for Glibc like endiness check */
 107 #define __LITTLE_ENDIAN 1234
 108 #define __BIG_ENDIAN    4321
 109
 110 /* Sanity check the defines.  We don't handle weird endianness. */
 111 #if !HAVE_LITTLE_ENDIAN && !HAVE_BIG_ENDIAN
 112 #error "Unknown endian"
 113 #elif HAVE_LITTLE_ENDIAN && HAVE_BIG_ENDIAN
 114 #error "Can't compile for both big and little endian."
 115 #elif HAVE_LITTLE_ENDIAN
 116 #ifndef __BYTE_ORDER
 117 #define __BYTE_ORDER    __LITTLE_ENDIAN
 118 #elif __BYTE_ORDER != __LITTLE_ENDIAN
 119 #error "__BYTE_ORDER already defined, but not equal to __LITTLE_ENDIAN"
 120 #endif
 121 #elif HAVE_BIG_ENDIAN
 122 #ifndef __BYTE_ORDER
 123 #define __BYTE_ORDER    __BIG_ENDIAN
 124 #elif __BYTE_ORDER != __BIG_ENDIAN
 125 #error "__BYTE_ORDER already defined, but not equal to __BIG_ENDIAN"
 126 #endif
 127 #endif
 128
 129
 130 #ifdef __CHECKER__
 131 /* sparse needs forcing to remove bitwise attribute from ccan/short_types */
 132 #define ENDIAN_CAST __attribute__((force))
 133 #define ENDIAN_TYPE __attribute__((bitwise))
 134 #else
 135 #define ENDIAN_CAST
 136 #define ENDIAN_TYPE
 137 #endif
 138
 139 typedef uint64_t ENDIAN_TYPE leint64_t;
 140 typedef uint64_t ENDIAN_TYPE beint64_t;
 141 typedef uint32_t ENDIAN_TYPE leint32_t;
 142 typedef uint32_t ENDIAN_TYPE beint32_t;
 143 typedef uint16_t ENDIAN_TYPE leint16_t;
 144 typedef uint16_t ENDIAN_TYPE beint16_t;
 145
 146 #if HAVE_LITTLE_ENDIAN
 147 /**
 148  * CPU_TO_LE64 - convert a constant uint64_t value to little-endian
 149  * @native: constant to convert
 150  */
 151 #define CPU_TO_LE64(native) ((ENDIAN_CAST leint64_t)(native))
 152
 153 /**
 154  * CPU_TO_LE32 - convert a constant uint32_t value to little-endian
 155  * @native: constant to convert
 156  */
 157 #define CPU_TO_LE32(native) ((ENDIAN_CAST leint32_t)(native))
 158
 159 /**
 160  * CPU_TO_LE16 - convert a constant uint16_t value to little-endian
 161  * @native: constant to convert
 162  */
 163 #define CPU_TO_LE16(native) ((ENDIAN_CAST leint16_t)(native))
 164
 165 /**
 166  * LE64_TO_CPU - convert a little-endian uint64_t constant
 167  * @le_val: little-endian constant to convert
 168  */
 169 #define LE64_TO_CPU(le_val) ((ENDIAN_CAST uint64_t)(le_val))
 170
 171 /**
 172  * LE32_TO_CPU - convert a little-endian uint32_t constant
 173  * @le_val: little-endian constant to convert
 174  */
 175 #define LE32_TO_CPU(le_val) ((ENDIAN_CAST uint32_t)(le_val))
 176
 177 /**
 178  * LE16_TO_CPU - convert a little-endian uint16_t constant
 179  * @le_val: little-endian constant to convert
 180  */
 181 #define LE16_TO_CPU(le_val) ((ENDIAN_CAST uint16_t)(le_val))
 182
 183 #else /* ... HAVE_BIG_ENDIAN */
 184 #define CPU_TO_LE64(native) ((ENDIAN_CAST leint64_t)BSWAP_64(native))
 185 #define CPU_TO_LE32(native) ((ENDIAN_CAST leint32_t)BSWAP_32(native))
 186 #define CPU_TO_LE16(native) ((ENDIAN_CAST leint16_t)BSWAP_16(native))
 187 #define LE64_TO_CPU(le_val) BSWAP_64((ENDIAN_CAST uint64_t)le_val)
 188 #define LE32_TO_CPU(le_val) BSWAP_32((ENDIAN_CAST uint32_t)le_val)
 189 #define LE16_TO_CPU(le_val) BSWAP_16((ENDIAN_CAST uint16_t)le_val)
 190 #endif /* HAVE_BIG_ENDIAN */
 191
 192 #if HAVE_BIG_ENDIAN
 193 /**
 194  * CPU_TO_BE64 - convert a constant uint64_t value to big-endian
 195  * @native: constant to convert
 196  */
 197 #define CPU_TO_BE64(native) ((ENDIAN_CAST beint64_t)(native))
 198
 199 /**
 200  * CPU_TO_BE32 - convert a constant uint32_t value to big-endian
 201  * @native: constant to convert
 202  */
 203 #define CPU_TO_BE32(native) ((ENDIAN_CAST beint32_t)(native))
 204
 205 /**
 206  * CPU_TO_BE16 - convert a constant uint16_t value to big-endian
 207  * @native: constant to convert
 208  */
 209 #define CPU_TO_BE16(native) ((ENDIAN_CAST beint16_t)(native))
 210
 211 /**
 212  * BE64_TO_CPU - convert a big-endian uint64_t constant
 213  * @le_val: big-endian constant to convert
 214  */
 215 #define BE64_TO_CPU(le_val) ((ENDIAN_CAST uint64_t)(le_val))
 216
 217 /**
 218  * BE32_TO_CPU - convert a big-endian uint32_t constant
 219  * @le_val: big-endian constant to convert
 220  */
 221 #define BE32_TO_CPU(le_val) ((ENDIAN_CAST uint32_t)(le_val))
 222
 223 /**
 224  * BE16_TO_CPU - convert a big-endian uint16_t constant
 225  * @le_val: big-endian constant to convert
 226  */
 227 #define BE16_TO_CPU(le_val) ((ENDIAN_CAST uint16_t)(le_val))
 228
 229 #else /* ... HAVE_LITTLE_ENDIAN */
 230 #define CPU_TO_BE64(native) ((ENDIAN_CAST beint64_t)BSWAP_64(native))
 231 #define CPU_TO_BE32(native) ((ENDIAN_CAST beint32_t)BSWAP_32(native))
 232 #define CPU_TO_BE16(native) ((ENDIAN_CAST beint16_t)BSWAP_16(native))
 233 #define BE64_TO_CPU(le_val) BSWAP_64((ENDIAN_CAST uint64_t)le_val)
 234 #define BE32_TO_CPU(le_val) BSWAP_32((ENDIAN_CAST uint32_t)le_val)
 235 #define BE16_TO_CPU(le_val) BSWAP_16((ENDIAN_CAST uint16_t)le_val)
 236 #endif /* HAVE_LITTE_ENDIAN */
 237
 238
 239 /**
 240  * cpu_to_le64 - convert a uint64_t value to little-endian
 241  * @native: value to convert
 242  */
 243 static inline leint64_t cpu_to_le64(uint64_t native)
 244 {
 245         return CPU_TO_LE64(native);
 246 }
 247
 248 /**
 249  * cpu_to_le32 - convert a uint32_t value to little-endian
 250  * @native: value to convert
 251  */
 252 static inline leint32_t cpu_to_le32(uint32_t native)
 253 {
 254         return CPU_TO_LE32(native);
 255 }
 256
 257 /**
 258  * cpu_to_le16 - convert a uint16_t value to little-endian
 259  * @native: value to convert
 260  */
 261 static inline leint16_t cpu_to_le16(uint16_t native)
 262 {
 263         return CPU_TO_LE16(native);
 264 }
 265
 266 /**
 267  * le64_to_cpu - convert a little-endian uint64_t value
 268  * @le_val: little-endian value to convert
 269  */
 270 static inline uint64_t le64_to_cpu(leint64_t le_val)
 271 {
 272         return LE64_TO_CPU(le_val);
 273 }
 274
 275 /**
 276  * le32_to_cpu - convert a little-endian uint32_t value
 277  * @le_val: little-endian value to convert
 278  */
 279 static inline uint32_t le32_to_cpu(leint32_t le_val)
 280 {
 281         return LE32_TO_CPU(le_val);
 282 }
 283
 284 /**
 285  * le16_to_cpu - convert a little-endian uint16_t value
 286  * @le_val: little-endian value to convert
 287  */
 288 static inline uint16_t le16_to_cpu(leint16_t le_val)
 289 {
 290         return LE16_TO_CPU(le_val);
 291 }
 292
 293 /**
 294  * cpu_to_be64 - convert a uint64_t value to big endian.
 295  * @native: value to convert
 296  */
 297 static inline beint64_t cpu_to_be64(uint64_t native)
 298 {
 299         return CPU_TO_BE64(native);
 300 }
 301
 302 /**
 303  * cpu_to_be32 - convert a uint32_t value to big endian.
 304  * @native: value to convert
 305  */
 306 static inline beint32_t cpu_to_be32(uint32_t native)
 307 {
 308         return CPU_TO_BE32(native);
 309 }
 310
 311 /**
 312  * cpu_to_be16 - convert a uint16_t value to big endian.
 313  * @native: value to convert
 314  */
 315 static inline beint16_t cpu_to_be16(uint16_t native)
 316 {
 317         return CPU_TO_BE16(native);
 318 }
 319
 320 /**
 321  * be64_to_cpu - convert a big-endian uint64_t value
 322  * @be_val: big-endian value to convert
 323  */
 324 static inline uint64_t be64_to_cpu(beint64_t be_val)
 325 {
 326         return BE64_TO_CPU(be_val);
 327 }
 328
 329 /**
 330  * be32_to_cpu - convert a big-endian uint32_t value
 331  * @be_val: big-endian value to convert
 332  */
 333 static inline uint32_t be32_to_cpu(beint32_t be_val)
 334 {
 335         return BE32_TO_CPU(be_val);
 336 }
 337
 338 /**
 339  * be16_to_cpu - convert a big-endian uint16_t value
 340  * @be_val: big-endian value to convert
 341  */
 342 static inline uint16_t be16_to_cpu(beint16_t be_val)
 343 {
 344         return BE16_TO_CPU(be_val);
 345 }
 346
 347 /* Whichever they include first, they get these definitions. */
 348 #ifdef CCAN_SHORT_TYPES_H
 349 /**
 350  * be64/be32/be16 - 64/32/16 bit big-endian representation.
 351  */
 352 typedef beint64_t be64;
 353 typedef beint32_t be32;
 354 typedef beint16_t be16;
 355
 356 /**
 357  * le64/le32/le16 - 64/32/16 bit little-endian representation.
 358  */
 359 typedef leint64_t le64;
 360 typedef leint32_t le32;
 361 typedef leint16_t le16;
 362 #endif
 363 #endif /* CCAN_ENDIAN_H */