commit 7a25119aef52149ad7c6259cffe8cfb45eb65957
parent 49dc3c2d79527c62b09989b1e803fc0bd561fc06
Author: Evgeny Grin (Karlson2k) <k2k@drgrin.dev>
Date: Sun, 31 Aug 2025 15:16:12 +0200
mhd_bithelpers.h: replaced some macros with static inline functions to prevent multiple expansions of the arguments
Diffstat:
1 file changed, 107 insertions(+), 65 deletions(-)
diff --git a/src/mhd2/mhd_bithelpers.h b/src/mhd2/mhd_bithelpers.h
@@ -83,11 +83,18 @@ mhd_DATA_TRUNCATION_RUNTIME_CHECK_DISABLE
# define mhd_BYTES_SWAP32(value32) \
((uint32_t)__builtin_bswap32 ((uint32_t) value32))
#else /* ! mhd_HAS_BUILTIN(__builtin_bswap32) */
-# define mhd_BYTES_SWAP32(value32) \
- ( (((uint32_t) (value32)) << 24) \
- | ((((uint32_t) (value32)) & (0x0000FF00u)) << 8) \
- | ((((uint32_t) (value32)) & (0x00FF0000u)) >> 8) \
- | (((uint32_t) (value32)) >> 24) )
+MHD_static_inline_ uint32_t
+mhd_BYTES_SWAP32 (uint32_t value32)
+{
+ uint32_t ret;
+ ret = (uint32_t) (value32 << 24u);
+ ret |= (uint32_t) ((value32 << 8u) & (0x00FF0000u));
+ ret |= (uint32_t) ((value32 >> 8u) & (0x0000FF00u));
+ ret |= (uint32_t) (value32 >> 24u);
+ return ret;
+}
+
+
#endif /* ! mhd_HAS_BUILTIN(__builtin_bswap32) */
@@ -107,15 +114,20 @@ mhd_DATA_TRUNCATION_RUNTIME_CHECK_DISABLE
# define mhd_BYTES_SWAP64(value64) \
((uint64_t) __builtin_bswap64 ((uint64_t) value64))
#else /* ! mhd_HAS_BUILTIN(__builtin_bswap64) */
-# define mhd_BYTES_SWAP64(value64) \
- ( (((uint64_t) (value64)) << 56) \
- | ((((uint64_t) (value64)) & (0x000000000000FF00u)) << 40) \
- | ((((uint64_t) (value64)) & (0x0000000000FF0000u)) << 24) \
- | ((((uint64_t) (value64)) & (0x00000000FF000000u)) << 8) \
- | ((((uint64_t) (value64)) & (0x000000FF00000000u)) >> 8) \
- | ((((uint64_t) (value64)) & (0x0000FF0000000000u)) >> 24) \
- | ((((uint64_t) (value64)) & (0x00FF000000000000u)) >> 40) \
- | (((uint64_t) (value64)) >> 56) )
+MHD_static_inline_ uint64_t
+mhd_BYTES_SWAP64(uint64_t value64)
+{
+ uint64_t ret;
+ ret = (uint64_t) (value64 << 56u);
+ ret |= (uint64_t) ((value64 << 40u) & (0x00FF000000000000u));
+ ret |= (uint64_t) ((value64 << 24u) & (0x0000FF0000000000u));
+ ret |= (uint64_t) ((value64 << 8u) & (0x000000FF00000000u));
+ ret |= (uint64_t) ((value64 >> 8u) & (0x00000000FF000000u));
+ ret |= (uint64_t) ((value64 >> 24u) & (0x0000000000FF0000u));
+ ret |= (uint64_t) ((value64 >> 40u) & (0x000000000000FF00u));
+ ret |= (uint64_t) (value64 >> 56u);
+ return ret;
+}
#endif /* ! mhd_HAS_BUILTIN(__builtin_bswap64) */
@@ -123,16 +135,19 @@ mhd_DATA_TRUNCATION_RUNTIME_CHECK_DISABLE
* put 64-bit value64 to addr in little-endian mode.
*/
/* Slow version that works with unaligned addr and with any byte order */
-#define mhd_PUT_64BIT_LE_SLOW(addr, value64) do { \
- ((uint8_t*) (addr))[0] = (uint8_t) ((uint64_t) (value64)); \
- ((uint8_t*) (addr))[1] = (uint8_t) (((uint64_t) (value64)) >> 8); \
- ((uint8_t*) (addr))[2] = (uint8_t) (((uint64_t) (value64)) >> 16); \
- ((uint8_t*) (addr))[3] = (uint8_t) (((uint64_t) (value64)) >> 24); \
- ((uint8_t*) (addr))[4] = (uint8_t) (((uint64_t) (value64)) >> 32); \
- ((uint8_t*) (addr))[5] = (uint8_t) (((uint64_t) (value64)) >> 40); \
- ((uint8_t*) (addr))[6] = (uint8_t) (((uint64_t) (value64)) >> 48); \
- ((uint8_t*) (addr))[7] = (uint8_t) (((uint64_t) (value64)) >> 56); \
-} while (0)
+MHD_static_inline_ void
+mhd_PUT_64BIT_LE_SLOW(void *addr, uint64_t value64)
+{
+ uint8_t *const dst = (uint8_t *) addr;
+ dst[0] = (uint8_t) value64;
+ dst[1] = (uint8_t) (value64 >> 8u);
+ dst[2] = (uint8_t) (value64 >> 16u);
+ dst[3] = (uint8_t) (value64 >> 24u);
+ dst[4] = (uint8_t) (value64 >> 32u);
+ dst[5] = (uint8_t) (value64 >> 40u);
+ dst[6] = (uint8_t) (value64 >> 48u);
+ dst[7] = (uint8_t) (value64 >> 56u);
+}
#if mhd_BYTE_ORDER == mhd_LITTLE_ENDIAN
# define mhd_PUT_64BIT_LE(addr, value64) \
((*(uint64_t*) (addr)) = (uint64_t) (value64))
@@ -164,12 +179,15 @@ mhd_DATA_TRUNCATION_RUNTIME_CHECK_DISABLE
* put 32-bit value32 to addr in little-endian mode.
*/
/* Slow version that works with unaligned addr and with any byte order */
-#define mhd_PUT_32BIT_LE_SLOW(addr, value32) do { \
- ((uint8_t*) (addr))[0] = (uint8_t) ((uint32_t) (value32)); \
- ((uint8_t*) (addr))[1] = (uint8_t) (((uint32_t) (value32)) >> 8); \
- ((uint8_t*) (addr))[2] = (uint8_t) (((uint32_t) (value32)) >> 16); \
- ((uint8_t*) (addr))[3] = (uint8_t) (((uint32_t) (value32)) >> 24); \
-} while (0)
+MHD_static_inline_ void
+mhd_PUT_32BIT_LE_SLOW(void *addr, uint32_t value32)
+{
+ uint8_t *const dst = (uint8_t *) addr;
+ dst[0] = (uint8_t) value32;
+ dst[1] = (uint8_t) (value32 >> 8u);
+ dst[2] = (uint8_t) (value32 >> 16u);
+ dst[3] = (uint8_t) (value32 >> 24u);
+}
#if mhd_BYTE_ORDER == mhd_LITTLE_ENDIAN
# define mhd_PUT_32BIT_LE(addr,value32) \
((*(uint32_t*) (addr)) = (uint32_t) (value32))
@@ -202,11 +220,17 @@ mhd_DATA_TRUNCATION_RUNTIME_CHECK_DISABLE
* and return it in native-endian mode.
*/
/* Slow version that works with unaligned addr and with any byte order */
-#define mhd_GET_32BIT_LE_SLOW(addr) \
- ( ( (uint32_t) (((const uint8_t*) addr)[0])) \
- | (((uint32_t) (((const uint8_t*) addr)[1])) << 8) \
- | (((uint32_t) (((const uint8_t*) addr)[2])) << 16) \
- | (((uint32_t) (((const uint8_t*) addr)[3])) << 24) )
+MHD_static_inline_ uint32_t
+mhd_GET_32BIT_LE_SLOW(const void *addr)
+{
+ const uint8_t *const src = (const uint8_t *) addr;
+ uint32_t ret;
+ ret = (uint32_t) src[0];
+ ret |= (uint32_t) (((uint32_t) src[1]) << 8u);
+ ret |= (uint32_t) (((uint32_t) src[2]) << 16u);
+ ret |= (uint32_t) (((uint32_t) src[3]) << 24u);
+ return ret;
+}
#if mhd_BYTE_ORDER == mhd_LITTLE_ENDIAN
# define mhd_GET_32BIT_LE(addr) \
(*(const uint32_t*) (addr))
@@ -240,16 +264,19 @@ mhd_GET_32BIT_LE_UNALIGN (const void *addr)
* in big-endian mode.
*/
/* Slow version that works with unaligned addr and with any byte order */
-#define mhd_PUT_64BIT_BE_SLOW(addr, value64) do { \
- ((uint8_t*) (addr))[7] = (uint8_t) ((uint64_t) (value64)); \
- ((uint8_t*) (addr))[6] = (uint8_t) (((uint64_t) (value64)) >> 8); \
- ((uint8_t*) (addr))[5] = (uint8_t) (((uint64_t) (value64)) >> 16); \
- ((uint8_t*) (addr))[4] = (uint8_t) (((uint64_t) (value64)) >> 24); \
- ((uint8_t*) (addr))[3] = (uint8_t) (((uint64_t) (value64)) >> 32); \
- ((uint8_t*) (addr))[2] = (uint8_t) (((uint64_t) (value64)) >> 40); \
- ((uint8_t*) (addr))[1] = (uint8_t) (((uint64_t) (value64)) >> 48); \
- ((uint8_t*) (addr))[0] = (uint8_t) (((uint64_t) (value64)) >> 56); \
-} while (0)
+MHD_static_inline_ void
+mhd_PUT_64BIT_BE_SLOW(void *addr, uint64_t value64)
+{
+ uint8_t *const dst = (uint8_t *) addr;
+ dst[0] = (uint8_t) (value64 >> 56u);
+ dst[1] = (uint8_t) (value64 >> 48u);
+ dst[2] = (uint8_t) (value64 >> 40u);
+ dst[3] = (uint8_t) (value64 >> 32u);
+ dst[4] = (uint8_t) (value64 >> 24u);
+ dst[5] = (uint8_t) (value64 >> 16u);
+ dst[6] = (uint8_t) (value64 >> 8u);
+ dst[7] = (uint8_t) value64;
+}
#if mhd_BYTE_ORDER == mhd_BIG_ENDIAN
# define mhd_PUT_64BIT_BE(addr, value64) \
((*(uint64_t*) (addr)) = (uint64_t) (value64))
@@ -287,15 +314,21 @@ mhd_GET_32BIT_LE_UNALIGN (const void *addr)
mhd_BYTES_SWAP64 (*(const uint64_t*) (addr))
#else /* mhd_BYTE_ORDER != mhd_LITTLE_ENDIAN */
/* Endianness was not detected or non-standard like PDP-endian */
-# define mhd_GET_64BIT_BE(addr) \
- ( (((uint64_t) (((const uint8_t*) addr)[0])) << 56) \
- | (((uint64_t) (((const uint8_t*) addr)[1])) << 48) \
- | (((uint64_t) (((const uint8_t*) addr)[2])) << 40) \
- | (((uint64_t) (((const uint8_t*) addr)[3])) << 32) \
- | (((uint64_t) (((const uint8_t*) addr)[4])) << 24) \
- | (((uint64_t) (((const uint8_t*) addr)[5])) << 16) \
- | (((uint64_t) (((const uint8_t*) addr)[6])) << 8) \
- | ((uint64_t) (((const uint8_t*) addr)[7])) )
+MHD_static_inline_ uint64_t
+mhd_GET_64BIT_BE(const void *addr)
+{
+ const uint8_t *const src = (const uint8_t *) addr;
+ uint64_t ret;
+ ret = (uint64_t) (((uint64_t) src[0]) << 56u);
+ ret |= (uint64_t) (((uint64_t) src[1]) << 48u);
+ ret |= (uint64_t) (((uint64_t) src[2]) << 40u);
+ ret |= (uint64_t) (((uint64_t) src[3]) << 32u);
+ ret |= (uint64_t) (((uint64_t) src[4]) << 24u);
+ ret |= (uint64_t) (((uint64_t) src[5]) << 16u);
+ ret |= (uint64_t) (((uint64_t) src[6]) << 8u);
+ ret |= (uint64_t) src[7];
+ return ret;
+}
/* Indicate that mhd_GET_64BIT_BE does not need aligned pointer */
# define mhd_GET_64BIT_BE_ALLOW_UNALIGNED 1
#endif /* mhd_BYTE_ORDER != mhd_LITTLE_ENDIAN */
@@ -313,12 +346,15 @@ mhd_GET_32BIT_LE_UNALIGN (const void *addr)
((*(uint32_t*) (addr)) = mhd_BYTES_SWAP32 (value32))
#else /* mhd_BYTE_ORDER != mhd_LITTLE_ENDIAN */
/* Endianness was not detected or non-standard like PDP-endian */
-# define mhd_PUT_32BIT_BE(addr, value32) do { \
- ((uint8_t*) (addr))[3] = (uint8_t) ((uint32_t) (value32)); \
- ((uint8_t*) (addr))[2] = (uint8_t) (((uint32_t) (value32)) >> 8); \
- ((uint8_t*) (addr))[1] = (uint8_t) (((uint32_t) (value32)) >> 16); \
- ((uint8_t*) (addr))[0] = (uint8_t) (((uint32_t) (value32)) >> 24); \
-} while (0)
+MHD_static_inline_ void
+mhd_PUT_32BIT_BE(void *addr, uint32_t value32)
+{
+ uint8_t *const dst = (uint8_t *) addr;
+ dst[0] = (uint8_t) (value32 >> 24u);
+ dst[1] = (uint8_t) (value32 >> 16u);
+ dst[2] = (uint8_t) (value32 >> 8u);
+ dst[3] = (uint8_t) value32;
+}
/* Indicate that mhd_PUT_32BIT_BE does not need aligned pointer */
# define mhd_PUT_32BIT_BE_ALLOW_UNALIGNED 1
#endif /* mhd_BYTE_ORDER != mhd_LITTLE_ENDIAN */
@@ -335,11 +371,17 @@ mhd_GET_32BIT_LE_UNALIGN (const void *addr)
mhd_BYTES_SWAP32 (*(const uint32_t*) (addr))
#else /* mhd_BYTE_ORDER != mhd_LITTLE_ENDIAN */
/* Endianness was not detected or non-standard like PDP-endian */
-# define mhd_GET_32BIT_BE(addr) \
- ( (((uint32_t) (((const uint8_t*) addr)[0])) << 24) \
- | (((uint32_t) (((const uint8_t*) addr)[1])) << 16) \
- | (((uint32_t) (((const uint8_t*) addr)[2])) << 8) \
- | ((uint32_t) (((const uint8_t*) addr)[3])) )
+MHD_static_inline_ uint32_t
+mhd_GET_32BIT_BE(const void *addr)
+{
+ const uint8_t *const src = (const uint8_t *) addr;
+ uint32_t ret;
+ ret = (uint32_t) (((uint32_t) src[0]) << 24u);
+ ret |= (uint32_t) (((uint32_t) src[1]) << 16u);
+ ret |= (uint32_t) (((uint32_t) src[2]) << 8u);
+ ret |= (uint32_t) src[3];
+ return ret;
+}
/* Indicate that mhd_GET_32BIT_BE does not need aligned pointer */
# define mhd_GET_32BIT_BE_ALLOW_UNALIGNED 1
#endif /* mhd_BYTE_ORDER != mhd_LITTLE_ENDIAN */
