eal: add static endianness conversion macros

[dpdk.git] / lib / librte_eal / common / include / generic / rte_byteorder.h

diff --git a/lib/librte_eal/common/include/generic/rte_byteorder.h b/lib/librte_eal/common/include/generic/rte_byteorder.h
index df8cc84..e5e820d 100644 (file)
--- a/lib/librte_eal/common/include/generic/rte_byteorder.h
+++ b/lib/librte_eal/common/include/generic/rte_byteorder.h
@@ -74,6 +74,59 @@
 #elif defined __LITTLE_ENDIAN__
 #define RTE_BYTE_ORDER RTE_LITTLE_ENDIAN
 #endif
+#if !defined(RTE_BYTE_ORDER)
+#error Unknown endianness.
+#endif
+
+#define RTE_STATIC_BSWAP16(v) \
+       ((((uint16_t)(v) & UINT16_C(0x00ff)) << 8) | \
+        (((uint16_t)(v) & UINT16_C(0xff00)) >> 8))
+
+#define RTE_STATIC_BSWAP32(v) \
+       ((((uint32_t)(v) & UINT32_C(0x000000ff)) << 24) | \
+        (((uint32_t)(v) & UINT32_C(0x0000ff00)) <<  8) | \
+        (((uint32_t)(v) & UINT32_C(0x00ff0000)) >>  8) | \
+        (((uint32_t)(v) & UINT32_C(0xff000000)) >> 24))
+
+#define RTE_STATIC_BSWAP64(v) \
+       ((((uint64_t)(v) & UINT64_C(0x00000000000000ff)) << 56) | \
+        (((uint64_t)(v) & UINT64_C(0x000000000000ff00)) << 40) | \
+        (((uint64_t)(v) & UINT64_C(0x0000000000ff0000)) << 24) | \
+        (((uint64_t)(v) & UINT64_C(0x00000000ff000000)) <<  8) | \
+        (((uint64_t)(v) & UINT64_C(0x000000ff00000000)) >>  8) | \
+        (((uint64_t)(v) & UINT64_C(0x0000ff0000000000)) >> 24) | \
+        (((uint64_t)(v) & UINT64_C(0x00ff000000000000)) >> 40) | \
+        (((uint64_t)(v) & UINT64_C(0xff00000000000000)) >> 56))
+
+/*
+ * These macros are functionally similar to rte_cpu_to_(be|le)(16|32|64)(),
+ * they take values in host CPU order and return them converted to the
+ * intended endianness.
+ *
+ * They resolve at compilation time to integer constants which can safely be
+ * used with static initializers, since those cannot involve function calls.
+ *
+ * On the other hand, they are not as optimized as their rte_cpu_to_*()
+ * counterparts, therefore applications should refrain from using them on
+ * variable values, particularly inside performance-sensitive code.
+ */
+#if RTE_BYTE_ORDER == RTE_BIG_ENDIAN
+#define RTE_BE16(v) (rte_be16_t)(v)
+#define RTE_BE32(v) (rte_be32_t)(v)
+#define RTE_BE64(v) (rte_be64_t)(v)
+#define RTE_LE16(v) (rte_le16_t)(RTE_STATIC_BSWAP16(v))
+#define RTE_LE32(v) (rte_le32_t)(RTE_STATIC_BSWAP32(v))
+#define RTE_LE64(v) (rte_le64_t)(RTE_STATIC_BSWAP64(v))
+#elif RTE_BYTE_ORDER == RTE_LITTLE_ENDIAN
+#define RTE_BE16(v) (rte_be16_t)(RTE_STATIC_BSWAP16(v))
+#define RTE_BE32(v) (rte_be32_t)(RTE_STATIC_BSWAP32(v))
+#define RTE_BE64(v) (rte_be64_t)(RTE_STATIC_BSWAP64(v))
+#define RTE_LE16(v) (rte_be16_t)(v)
+#define RTE_LE32(v) (rte_be32_t)(v)
+#define RTE_LE64(v) (rte_be64_t)(v)
+#else
+#error Unsupported endianness.
+#endif
 
 /*
  * The following types should be used when handling values according to a
@@ -98,8 +151,7 @@ typedef uint64_t rte_le64_t; /**< 64-bit little-endian value. */
 static inline uint16_t
 rte_constant_bswap16(uint16_t x)
 {
-       return (uint16_t)(((x & 0x00ffU) << 8) |
-               ((x & 0xff00U) >> 8));
+       return RTE_STATIC_BSWAP16(x);
 }
 
 /*
@@ -111,10 +163,7 @@ rte_constant_bswap16(uint16_t x)
 static inline uint32_t
 rte_constant_bswap32(uint32_t x)
 {
-       return  ((x & 0x000000ffUL) << 24) |
-               ((x & 0x0000ff00UL) << 8) |
-               ((x & 0x00ff0000UL) >> 8) |
-               ((x & 0xff000000UL) >> 24);
+       return RTE_STATIC_BSWAP32(x);
 }
 
 /*
@@ -126,14 +175,7 @@ rte_constant_bswap32(uint32_t x)
 static inline uint64_t
 rte_constant_bswap64(uint64_t x)
 {
-       return  ((x & 0x00000000000000ffULL) << 56) |
-               ((x & 0x000000000000ff00ULL) << 40) |
-               ((x & 0x0000000000ff0000ULL) << 24) |
-               ((x & 0x00000000ff000000ULL) <<  8) |
-               ((x & 0x000000ff00000000ULL) >>  8) |
-               ((x & 0x0000ff0000000000ULL) >> 24) |
-               ((x & 0x00ff000000000000ULL) >> 40) |
-               ((x & 0xff00000000000000ULL) >> 56);
+       return RTE_STATIC_BSWAP64(x);
 }