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

   1 /*-
   2  *   BSD LICENSE
   3  *
   4  *   Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
   5  *   All rights reserved.
   6  *
   7  *   Redistribution and use in source and binary forms, with or without
   8  *   modification, are permitted provided that the following conditions
   9  *   are met:
  10  *
  11  *     * Redistributions of source code must retain the above copyright
  12  *       notice, this list of conditions and the following disclaimer.
  13  *     * Redistributions in binary form must reproduce the above copyright
  14  *       notice, this list of conditions and the following disclaimer in
  15  *       the documentation and/or other materials provided with the
  16  *       distribution.
  17  *     * Neither the name of Intel Corporation nor the names of its
  18  *       contributors may be used to endorse or promote products derived
  19  *       from this software without specific prior written permission.
  20  *
  21  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  24  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  25  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  26  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  27  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  28  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  29  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  30  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  31  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32  */
  33
  34 #ifndef _RTE_BYTEORDER_H_
  35 #define _RTE_BYTEORDER_H_
  36
  37 /**
  38  * @file
  39  *
  40  * Byte Swap Operations
  41  *
  42  * This file defines a generic API for byte swap operations. Part of
  43  * the implementation is architecture-specific.
  44  */
  45
  46 #include <stdint.h>
  47 #ifdef RTE_EXEC_ENV_BSDAPP
  48 #include <sys/endian.h>
  49 #else
  50 #include <endian.h>
  51 #endif
  52
  53 #include <rte_common.h>
  54
  55 /*
  56  * Compile-time endianness detection
  57  */
  58 #define RTE_BIG_ENDIAN    1
  59 #define RTE_LITTLE_ENDIAN 2
  60 #if defined __BYTE_ORDER__
  61 #if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
  62 #define RTE_BYTE_ORDER RTE_BIG_ENDIAN
  63 #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
  64 #define RTE_BYTE_ORDER RTE_LITTLE_ENDIAN
  65 #endif /* __BYTE_ORDER__ */
  66 #elif defined __BYTE_ORDER
  67 #if __BYTE_ORDER == __BIG_ENDIAN
  68 #define RTE_BYTE_ORDER RTE_BIG_ENDIAN
  69 #elif __BYTE_ORDER == __LITTLE_ENDIAN
  70 #define RTE_BYTE_ORDER RTE_LITTLE_ENDIAN
  71 #endif /* __BYTE_ORDER */
  72 #elif defined __BIG_ENDIAN__
  73 #define RTE_BYTE_ORDER RTE_BIG_ENDIAN
  74 #elif defined __LITTLE_ENDIAN__
  75 #define RTE_BYTE_ORDER RTE_LITTLE_ENDIAN
  76 #endif
  77
  78 /*
  79  * The following types should be used when handling values according to a
  80  * specific byte ordering, which may differ from that of the host CPU.
  81  *
  82  * Libraries, public APIs and applications are encouraged to use them for
  83  * documentation purposes.
  84  */
  85 typedef uint16_t rte_be16_t; /**< 16-bit big-endian value. */
  86 typedef uint32_t rte_be32_t; /**< 32-bit big-endian value. */
  87 typedef uint64_t rte_be64_t; /**< 64-bit big-endian value. */
  88 typedef uint16_t rte_le16_t; /**< 16-bit little-endian value. */
  89 typedef uint32_t rte_le32_t; /**< 32-bit little-endian value. */
  90 typedef uint64_t rte_le64_t; /**< 64-bit little-endian value. */
  91
  92 /*
  93  * An internal function to swap bytes in a 16-bit value.
  94  *
  95  * It is used by rte_bswap16() when the value is constant. Do not use
  96  * this function directly; rte_bswap16() is preferred.
  97  */
  98 static inline uint16_t
  99 rte_constant_bswap16(uint16_t x)
 100 {
 101         return (uint16_t)(((x & 0x00ffU) << 8) |
 102                 ((x & 0xff00U) >> 8));
 103 }
 104
 105 /*
 106  * An internal function to swap bytes in a 32-bit value.
 107  *
 108  * It is used by rte_bswap32() when the value is constant. Do not use
 109  * this function directly; rte_bswap32() is preferred.
 110  */
 111 static inline uint32_t
 112 rte_constant_bswap32(uint32_t x)
 113 {
 114         return  ((x & 0x000000ffUL) << 24) |
 115                 ((x & 0x0000ff00UL) << 8) |
 116                 ((x & 0x00ff0000UL) >> 8) |
 117                 ((x & 0xff000000UL) >> 24);
 118 }
 119
 120 /*
 121  * An internal function to swap bytes of a 64-bit value.
 122  *
 123  * It is used by rte_bswap64() when the value is constant. Do not use
 124  * this function directly; rte_bswap64() is preferred.
 125  */
 126 static inline uint64_t
 127 rte_constant_bswap64(uint64_t x)
 128 {
 129         return  ((x & 0x00000000000000ffULL) << 56) |
 130                 ((x & 0x000000000000ff00ULL) << 40) |
 131                 ((x & 0x0000000000ff0000ULL) << 24) |
 132                 ((x & 0x00000000ff000000ULL) <<  8) |
 133                 ((x & 0x000000ff00000000ULL) >>  8) |
 134                 ((x & 0x0000ff0000000000ULL) >> 24) |
 135                 ((x & 0x00ff000000000000ULL) >> 40) |
 136                 ((x & 0xff00000000000000ULL) >> 56);
 137 }
 138
 139
 140 #ifdef __DOXYGEN__
 141
 142 /**
 143  * Swap bytes in a 16-bit value.
 144  */
 145 static uint16_t rte_bswap16(uint16_t _x);
 146
 147 /**
 148  * Swap bytes in a 32-bit value.
 149  */
 150 static uint32_t rte_bswap32(uint32_t x);
 151
 152 /**
 153  * Swap bytes in a 64-bit value.
 154  */
 155 static uint64_t rte_bswap64(uint64_t x);
 156
 157 /**
 158  * Convert a 16-bit value from CPU order to little endian.
 159  */
 160 static rte_le16_t rte_cpu_to_le_16(uint16_t x);
 161
 162 /**
 163  * Convert a 32-bit value from CPU order to little endian.
 164  */
 165 static rte_le32_t rte_cpu_to_le_32(uint32_t x);
 166
 167 /**
 168  * Convert a 64-bit value from CPU order to little endian.
 169  */
 170 static rte_le64_t rte_cpu_to_le_64(uint64_t x);
 171
 172
 173 /**
 174  * Convert a 16-bit value from CPU order to big endian.
 175  */
 176 static rte_be16_t rte_cpu_to_be_16(uint16_t x);
 177
 178 /**
 179  * Convert a 32-bit value from CPU order to big endian.
 180  */
 181 static rte_be32_t rte_cpu_to_be_32(uint32_t x);
 182
 183 /**
 184  * Convert a 64-bit value from CPU order to big endian.
 185  */
 186 static rte_be64_t rte_cpu_to_be_64(uint64_t x);
 187
 188
 189 /**
 190  * Convert a 16-bit value from little endian to CPU order.
 191  */
 192 static uint16_t rte_le_to_cpu_16(rte_le16_t x);
 193
 194 /**
 195  * Convert a 32-bit value from little endian to CPU order.
 196  */
 197 static uint32_t rte_le_to_cpu_32(rte_le32_t x);
 198
 199 /**
 200  * Convert a 64-bit value from little endian to CPU order.
 201  */
 202 static uint64_t rte_le_to_cpu_64(rte_le64_t x);
 203
 204
 205 /**
 206  * Convert a 16-bit value from big endian to CPU order.
 207  */
 208 static uint16_t rte_be_to_cpu_16(rte_be16_t x);
 209
 210 /**
 211  * Convert a 32-bit value from big endian to CPU order.
 212  */
 213 static uint32_t rte_be_to_cpu_32(rte_be32_t x);
 214
 215 /**
 216  * Convert a 64-bit value from big endian to CPU order.
 217  */
 218 static uint64_t rte_be_to_cpu_64(rte_be64_t x);
 219
 220 #endif /* __DOXYGEN__ */
 221
 222 #ifdef RTE_FORCE_INTRINSICS
 223 #if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)
 224 #define rte_bswap16(x) __builtin_bswap16(x)
 225 #endif
 226
 227 #define rte_bswap32(x) __builtin_bswap32(x)
 228
 229 #define rte_bswap64(x) __builtin_bswap64(x)
 230
 231 #endif
 232
 233 #endif /* _RTE_BYTEORDER_H_ */