endian.h (9908B)
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 */