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