libmicrohttpd2

commit c22c0875a6c9fd51fc43ccb16b99c8c2e5a78519
parent 2af0db93709b5ca955bca1a332955b410e2e0af7
Author: Evgeny Grin (Karlson2k) <k2k@drgrin.dev>
Date:   Sun, 31 Aug 2025 15:06:03 +0200

mhd_bithelpers.h: used memcpy() for unaligned access instead of byte-by-byte processing

Diffstat:
M
src/mhd2/mhd_bithelpers.h
 | 
68
++++++++++++++++++++++++++++++++++++--------------------------------

1 file changed, 36 insertions(+), 32 deletions(-)
diff --git a/src/mhd2/mhd_bithelpers.h b/src/mhd2/mhd_bithelpers.h
@@ -48,6 +48,7 @@
 #include "mhd_sys_options.h"
 
 #include "sys_base_types.h"
+#include <string.h>
 
 #include "mhd_assert.h"
 
@@ -151,16 +152,16 @@ mhd_DATA_TRUNCATION_RUNTIME_CHECK_DISABLE
 #endif /* mhd_BYTE_ORDER != mhd_BIG_ENDIAN */
 
 /* Put result safely to unaligned address */
-MHD_static_inline_ void
-mhd_PUT_64BIT_LE_UNALIGN (void *dst, uint64_t value)
-{
-#ifndef mhd_PUT_64BIT_LE_ALLOW_UNALIGNED
-  if (0 != ((uintptr_t) dst) % (mhd_UINT64_ALIGN))
-    mhd_PUT_64BIT_LE_SLOW (dst, value);
-  else
+#ifdef mhd_PUT_64BIT_LE_ALLOW_UNALIGNED
+#  define mhd_PUT_64BIT_LE_UNALIGN(addr, value64)        \
+        mhd_PUT_64BIT_LE ((addr),(value64))
+#else  /* ! mhd_PUT_64BIT_LE_ALLOW_UNALIGNED */
+#  define mhd_PUT_64BIT_LE_UNALIGN(addr, value64)           \
+        do { uint64_t mhd__aligned_dst;                      \
+             mhd_PUT_64BIT_LE (&mhd__aligned_dst, (value64)); \
+             memcpy ((addr), &mhd__aligned_dst,               \
+                     sizeof(mhd__aligned_dst)); } while (0)
 #endif /* ! mhd_PUT_64BIT_LE_ALLOW_UNALIGNED */
-  mhd_PUT_64BIT_LE (dst, value);
-}
 
 
 /* mhd_PUT_32BIT_LE (addr, value32)
@@ -188,16 +189,16 @@ mhd_PUT_64BIT_LE_UNALIGN (void *dst, uint64_t value)
 #endif /* mhd_BYTE_ORDER != mhd_BIG_ENDIAN */
 
 /* Put result safely to unaligned address */
-MHD_static_inline_ void
-mhd_PUT_32BIT_LE_UNALIGN (void *dst, uint32_t value)
-{
-#ifndef mhd_PUT_32BIT_LE_ALLOW_UNALIGNED
-  if (0 != ((uintptr_t) dst) % (mhd_UINT32_ALIGN))
-    mhd_PUT_32BIT_LE_SLOW (dst, value);
-  else
+#ifdef mhd_PUT_32BIT_LE_ALLOW_UNALIGNED
+#  define mhd_PUT_32BIT_LE_UNALIGN(addr, value32)        \
+        mhd_PUT_32BIT_LE ((addr),(value32))
+#else  /* ! mhd_PUT_32BIT_LE_ALLOW_UNALIGNED */
+#  define mhd_PUT_32BIT_LE_UNALIGN(addr, value32)           \
+        do { uint32_t mhd__aligned_dst;                      \
+             mhd_PUT_32BIT_LE (&mhd__aligned_dst, (value32)); \
+             memcpy ((addr), &mhd__aligned_dst,               \
+                     sizeof(mhd__aligned_dst)); } while (0)
 #endif /* ! mhd_PUT_32BIT_LE_ALLOW_UNALIGNED */
-  mhd_PUT_32BIT_LE (dst, value);
-}
 
 
 /* mhd_GET_32BIT_LE (addr)
@@ -223,16 +224,19 @@ mhd_PUT_32BIT_LE_UNALIGN (void *dst, uint32_t value)
 #  define mhd_GET_32BIT_LE_ALLOW_UNALIGNED 1
 #endif /* mhd_BYTE_ORDER != mhd_BIG_ENDIAN */
 
+
+#ifdef mhd_GET_32BIT_LE_ALLOW_UNALIGNED
+#  define mhd_GET_32BIT_LE_UNALIGN(addr) mhd_GET_32BIT_LE (addr)
+#else  /* ! mhd_GET_32BIT_LE_ALLOW_UNALIGNED */
 /* Get value safely from an unaligned address */
 MHD_static_inline_ MHD_FN_PAR_NONNULL_ALL_ uint32_t
 mhd_GET_32BIT_LE_UNALIGN (const void *addr)
 {
-#ifndef mhd_PUT_32BIT_LE_ALLOW_UNALIGNED
-  if (0 != ((uintptr_t) addr) % (mhd_UINT32_ALIGN))
-    return mhd_GET_32BIT_LE_SLOW (addr);
-#endif /* ! mhd_PUT_32BIT_LE_ALLOW_UNALIGNED */
-  return mhd_GET_32BIT_LE (addr);
+  uint32_t aligned_src;
+  memcpy (&aligned_src, addr, sizeof(aligned_src));
+  return mhd_GET_32BIT_LE (&aligned_src);
 }
+#endif /* ! mhd_GET_32BIT_LE_ALLOW_UNALIGNED */
 
 
 /* mhd_PUT_64BIT_BE (addr, value64)
@@ -264,16 +268,16 @@ mhd_GET_32BIT_LE_UNALIGN (const void *addr)
 #endif /* mhd_BYTE_ORDER != mhd_LITTLE_ENDIAN */
 
 /* Put result safely to unaligned address */
-MHD_static_inline_ void
-mhd_PUT_64BIT_BE_UNALIGN (void *dst, uint64_t value)
-{
-#ifndef mhd_PUT_64BIT_BE_ALLOW_UNALIGNED
-  if (0 != ((uintptr_t) dst) % (mhd_UINT64_ALIGN))
-    mhd_PUT_64BIT_BE_SLOW (dst, value);
-  else
+#ifdef mhd_PUT_64BIT_BE_ALLOW_UNALIGNED
+#  define mhd_PUT_64BIT_BE_UNALIGN(addr, value64)        \
+        mhd_PUT_64BIT_BE ((addr),(value64))
+#else  /* ! mhd_PUT_64BIT_BE_ALLOW_UNALIGNED */
+#  define mhd_PUT_64BIT_BE_UNALIGN(addr, value64)           \
+        do { uint64_t mhd__aligned_dst;                      \
+             mhd_PUT_64BIT_BE (&mhd__aligned_dst, (value64)); \
+             memcpy ((addr), &mhd__aligned_dst,               \
+                     sizeof(mhd__aligned_dst)); } while (0)
 #endif /* ! mhd_PUT_64BIT_BE_ALLOW_UNALIGNED */
-  mhd_PUT_64BIT_BE (dst, value);
-}
 
 
 /* mhd_GET_64BIT_BE (addr)