lib/librte_eal/common/include/generic/rte_byteorder.h

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2010-2014 Intel Corporation
   3  */
   4
   5 #ifndef _RTE_BYTEORDER_H_
   6 #define _RTE_BYTEORDER_H_
   7
   8 /**
   9  * @file
  10  *
  11  * Byte Swap Operations
  12  *
  13  * This file defines a generic API for byte swap operations. Part of
  14  * the implementation is architecture-specific.
  15  */
  16
  17 #include <stdint.h>
  18 #ifdef RTE_EXEC_ENV_BSDAPP
  19 #include <sys/endian.h>
  20 #else
  21 #include <endian.h>
  22 #endif
  23
  24 #include <rte_common.h>
  25
  26 /*
  27  * Compile-time endianness detection
  28  */
  29 #define RTE_BIG_ENDIAN    1
  30 #define RTE_LITTLE_ENDIAN 2
  31 #if defined __BYTE_ORDER__
  32 #if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
  33 #define RTE_BYTE_ORDER RTE_BIG_ENDIAN
  34 #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
  35 #define RTE_BYTE_ORDER RTE_LITTLE_ENDIAN
  36 #endif /* __BYTE_ORDER__ */
  37 #elif defined __BYTE_ORDER
  38 #if __BYTE_ORDER == __BIG_ENDIAN
  39 #define RTE_BYTE_ORDER RTE_BIG_ENDIAN
  40 #elif __BYTE_ORDER == __LITTLE_ENDIAN
  41 #define RTE_BYTE_ORDER RTE_LITTLE_ENDIAN
  42 #endif /* __BYTE_ORDER */
  43 #elif defined __BIG_ENDIAN__
  44 #define RTE_BYTE_ORDER RTE_BIG_ENDIAN
  45 #elif defined __LITTLE_ENDIAN__
  46 #define RTE_BYTE_ORDER RTE_LITTLE_ENDIAN
  47 #endif
  48 #if !defined(RTE_BYTE_ORDER)
  49 #error Unknown endianness.
  50 #endif
  51
  52 #define RTE_STATIC_BSWAP16(v) \
  53         ((((uint16_t)(v) & UINT16_C(0x00ff)) << 8) | \
  54          (((uint16_t)(v) & UINT16_C(0xff00)) >> 8))
  55
  56 #define RTE_STATIC_BSWAP32(v) \
  57         ((((uint32_t)(v) & UINT32_C(0x000000ff)) << 24) | \
  58          (((uint32_t)(v) & UINT32_C(0x0000ff00)) <<  8) | \
  59          (((uint32_t)(v) & UINT32_C(0x00ff0000)) >>  8) | \
  60          (((uint32_t)(v) & UINT32_C(0xff000000)) >> 24))
  61
  62 #define RTE_STATIC_BSWAP64(v) \
  63         ((((uint64_t)(v) & UINT64_C(0x00000000000000ff)) << 56) | \
  64          (((uint64_t)(v) & UINT64_C(0x000000000000ff00)) << 40) | \
  65          (((uint64_t)(v) & UINT64_C(0x0000000000ff0000)) << 24) | \
  66          (((uint64_t)(v) & UINT64_C(0x00000000ff000000)) <<  8) | \
  67          (((uint64_t)(v) & UINT64_C(0x000000ff00000000)) >>  8) | \
  68          (((uint64_t)(v) & UINT64_C(0x0000ff0000000000)) >> 24) | \
  69          (((uint64_t)(v) & UINT64_C(0x00ff000000000000)) >> 40) | \
  70          (((uint64_t)(v) & UINT64_C(0xff00000000000000)) >> 56))
  71
  72 /*
  73  * These macros are functionally similar to rte_cpu_to_(be|le)(16|32|64)(),
  74  * they take values in host CPU order and return them converted to the
  75  * intended endianness.
  76  *
  77  * They resolve at compilation time to integer constants which can safely be
  78  * used with static initializers, since those cannot involve function calls.
  79  *
  80  * On the other hand, they are not as optimized as their rte_cpu_to_*()
  81  * counterparts, therefore applications should refrain from using them on
  82  * variable values, particularly inside performance-sensitive code.
  83  */
  84 #if RTE_BYTE_ORDER == RTE_BIG_ENDIAN
  85 #define RTE_BE16(v) (rte_be16_t)(v)
  86 #define RTE_BE32(v) (rte_be32_t)(v)
  87 #define RTE_BE64(v) (rte_be64_t)(v)
  88 #define RTE_LE16(v) (rte_le16_t)(RTE_STATIC_BSWAP16(v))
  89 #define RTE_LE32(v) (rte_le32_t)(RTE_STATIC_BSWAP32(v))
  90 #define RTE_LE64(v) (rte_le64_t)(RTE_STATIC_BSWAP64(v))
  91 #elif RTE_BYTE_ORDER == RTE_LITTLE_ENDIAN
  92 #define RTE_BE16(v) (rte_be16_t)(RTE_STATIC_BSWAP16(v))
  93 #define RTE_BE32(v) (rte_be32_t)(RTE_STATIC_BSWAP32(v))
  94 #define RTE_BE64(v) (rte_be64_t)(RTE_STATIC_BSWAP64(v))
  95 #define RTE_LE16(v) (rte_be16_t)(v)
  96 #define RTE_LE32(v) (rte_be32_t)(v)
  97 #define RTE_LE64(v) (rte_be64_t)(v)
  98 #else
  99 #error Unsupported endianness.
 100 #endif
 101
 102 /*
 103  * The following types should be used when handling values according to a
 104  * specific byte ordering, which may differ from that of the host CPU.
 105  *
 106  * Libraries, public APIs and applications are encouraged to use them for
 107  * documentation purposes.
 108  */
 109 typedef uint16_t rte_be16_t; /**< 16-bit big-endian value. */
 110 typedef uint32_t rte_be32_t; /**< 32-bit big-endian value. */
 111 typedef uint64_t rte_be64_t; /**< 64-bit big-endian value. */
 112 typedef uint16_t rte_le16_t; /**< 16-bit little-endian value. */
 113 typedef uint32_t rte_le32_t; /**< 32-bit little-endian value. */
 114 typedef uint64_t rte_le64_t; /**< 64-bit little-endian value. */
 115
 116 /*
 117  * An internal function to swap bytes in a 16-bit value.
 118  *
 119  * It is used by rte_bswap16() when the value is constant. Do not use
 120  * this function directly; rte_bswap16() is preferred.
 121  */
 122 static inline uint16_t
 123 rte_constant_bswap16(uint16_t x)
 124 {
 125         return RTE_STATIC_BSWAP16(x);
 126 }
 127
 128 /*
 129  * An internal function to swap bytes in a 32-bit value.
 130  *
 131  * It is used by rte_bswap32() when the value is constant. Do not use
 132  * this function directly; rte_bswap32() is preferred.
 133  */
 134 static inline uint32_t
 135 rte_constant_bswap32(uint32_t x)
 136 {
 137         return RTE_STATIC_BSWAP32(x);
 138 }
 139
 140 /*
 141  * An internal function to swap bytes of a 64-bit value.
 142  *
 143  * It is used by rte_bswap64() when the value is constant. Do not use
 144  * this function directly; rte_bswap64() is preferred.
 145  */
 146 static inline uint64_t
 147 rte_constant_bswap64(uint64_t x)
 148 {
 149         return RTE_STATIC_BSWAP64(x);
 150 }
 151
 152
 153 #ifdef __DOXYGEN__
 154
 155 /**
 156  * Swap bytes in a 16-bit value.
 157  */
 158 static uint16_t rte_bswap16(uint16_t _x);
 159
 160 /**
 161  * Swap bytes in a 32-bit value.
 162  */
 163 static uint32_t rte_bswap32(uint32_t x);
 164
 165 /**
 166  * Swap bytes in a 64-bit value.
 167  */
 168 static uint64_t rte_bswap64(uint64_t x);
 169
 170 /**
 171  * Convert a 16-bit value from CPU order to little endian.
 172  */
 173 static rte_le16_t rte_cpu_to_le_16(uint16_t x);
 174
 175 /**
 176  * Convert a 32-bit value from CPU order to little endian.
 177  */
 178 static rte_le32_t rte_cpu_to_le_32(uint32_t x);
 179
 180 /**
 181  * Convert a 64-bit value from CPU order to little endian.
 182  */
 183 static rte_le64_t rte_cpu_to_le_64(uint64_t x);
 184
 185
 186 /**
 187  * Convert a 16-bit value from CPU order to big endian.
 188  */
 189 static rte_be16_t rte_cpu_to_be_16(uint16_t x);
 190
 191 /**
 192  * Convert a 32-bit value from CPU order to big endian.
 193  */
 194 static rte_be32_t rte_cpu_to_be_32(uint32_t x);
 195
 196 /**
 197  * Convert a 64-bit value from CPU order to big endian.
 198  */
 199 static rte_be64_t rte_cpu_to_be_64(uint64_t x);
 200
 201
 202 /**
 203  * Convert a 16-bit value from little endian to CPU order.
 204  */
 205 static uint16_t rte_le_to_cpu_16(rte_le16_t x);
 206
 207 /**
 208  * Convert a 32-bit value from little endian to CPU order.
 209  */
 210 static uint32_t rte_le_to_cpu_32(rte_le32_t x);
 211
 212 /**
 213  * Convert a 64-bit value from little endian to CPU order.
 214  */
 215 static uint64_t rte_le_to_cpu_64(rte_le64_t x);
 216
 217
 218 /**
 219  * Convert a 16-bit value from big endian to CPU order.
 220  */
 221 static uint16_t rte_be_to_cpu_16(rte_be16_t x);
 222
 223 /**
 224  * Convert a 32-bit value from big endian to CPU order.
 225  */
 226 static uint32_t rte_be_to_cpu_32(rte_be32_t x);
 227
 228 /**
 229  * Convert a 64-bit value from big endian to CPU order.
 230  */
 231 static uint64_t rte_be_to_cpu_64(rte_be64_t x);
 232
 233 #endif /* __DOXYGEN__ */
 234
 235 #ifdef RTE_FORCE_INTRINSICS
 236 #if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)
 237 #define rte_bswap16(x) __builtin_bswap16(x)
 238 #endif
 239
 240 #define rte_bswap32(x) __builtin_bswap32(x)
 241
 242 #define rte_bswap64(x) __builtin_bswap64(x)
 243
 244 #endif
 245
 246 #endif /* _RTE_BYTEORDER_H_ */