Don't use unaligned access for memcpy instructions due to GCC 11 assuming it is align...

diff --git a/arch/arm/chunkset_neon.c b/arch/arm/chunkset_neon.c
index 29065f77c4e93761bff0b8bd56e94d437ca62c01..3b8d2c0010ad9de7aa2cc7a4b2440237fc5b0f0c 100644 (file)
--- a/arch/arm/chunkset_neon.c
+++ b/arch/arm/chunkset_neon.c
@@ -38,19 +38,19 @@ static const lut_rem_pair perm_idx_lut[13] = {
 
 static inline void chunkmemset_2(uint8_t *from, chunk_t *chunk) {
     uint16_t tmp;
-    zmemcpy_2(&tmp, from);
+    memcpy(&tmp, from, sizeof(tmp));
     *chunk = vreinterpretq_u8_u16(vdupq_n_u16(tmp));
 }
 
 static inline void chunkmemset_4(uint8_t *from, chunk_t *chunk) {
     uint32_t tmp;
-    zmemcpy_4(&tmp, from);
+    memcpy(&tmp, from, sizeof(tmp));
     *chunk = vreinterpretq_u8_u32(vdupq_n_u32(tmp));
 }
 
 static inline void chunkmemset_8(uint8_t *from, chunk_t *chunk) {
     uint64_t tmp;
-    zmemcpy_8(&tmp, from);
+    memcpy(&tmp, from, sizeof(tmp));
     *chunk = vreinterpretq_u8_u64(vdupq_n_u64(tmp));
 }
 
@@ -76,7 +76,7 @@ static inline chunk_t GET_CHUNK_MAG(uint8_t *buf, uint32_t *chunk_rem, uint32_t
     /* See note in chunkset_sse41.c for why this is ok */
     __msan_unpoison(buf + dist, 16 - dist);
 #endif
-    
+
     /* This version of table is only available on aarch64 */
 #if defined(_M_ARM64) || defined(__aarch64__)
     uint8x16_t ret_vec = vld1q_u8(buf);

diff --git a/arch/power/chunkset_power8.c b/arch/power/chunkset_power8.c
index 47e5485262850dc47740cdf6f8601b3ef21b0bcf..83928308d614843f2a487d59849054418330ca57 100644 (file)
--- a/arch/power/chunkset_power8.c
+++ b/arch/power/chunkset_power8.c
@@ -16,19 +16,19 @@ typedef vector unsigned char chunk_t;
 
 static inline void chunkmemset_2(uint8_t *from, chunk_t *chunk) {
     uint16_t tmp;
-    zmemcpy_2(&tmp, from);
+    memcpy(&tmp, from, sizeof(tmp));
     *chunk = (vector unsigned char)vec_splats(tmp);
 }
 
 static inline void chunkmemset_4(uint8_t *from, chunk_t *chunk) {
     uint32_t tmp;
-    zmemcpy_4(&tmp, from);
+    memcpy(&tmp, from, sizeof(tmp));
     *chunk = (vector unsigned char)vec_splats(tmp);
 }
 
 static inline void chunkmemset_8(uint8_t *from, chunk_t *chunk) {
     uint64_t tmp;
-    zmemcpy_8(&tmp, from);
+    memcpy(&tmp, from, sizeof(tmp));
     *chunk = (vector unsigned char)vec_splats(tmp);
 }
 

diff --git a/arch/x86/chunkset_avx.c b/arch/x86/chunkset_avx.c
index 024b37c304b53f595ab704ea2765b6bc9c9d4e6e..c4a4d9b052ffae5d2a1153a9765a8e180d08e751 100644 (file)
--- a/arch/x86/chunkset_avx.c
+++ b/arch/x86/chunkset_avx.c
@@ -52,19 +52,19 @@ static const lut_rem_pair perm_idx_lut[29] = {
 
 static inline void chunkmemset_2(uint8_t *from, chunk_t *chunk) {
     int16_t tmp;
-    zmemcpy_2(&tmp, from);
+    memcpy(&tmp, from, sizeof(tmp));
     *chunk = _mm256_set1_epi16(tmp);
 }
 
 static inline void chunkmemset_4(uint8_t *from, chunk_t *chunk) {
     int32_t tmp;
-    zmemcpy_4(&tmp, from);
+    memcpy(&tmp, from, sizeof(tmp));
     *chunk = _mm256_set1_epi32(tmp);
 }
 
 static inline void chunkmemset_8(uint8_t *from, chunk_t *chunk) {
     int64_t tmp;
-    zmemcpy_8(&tmp, from);
+    memcpy(&tmp, from, sizeof(tmp));
     *chunk = _mm256_set1_epi64x(tmp);
 }
 

diff --git a/arch/x86/chunkset_sse2.c b/arch/x86/chunkset_sse2.c
index 8e3166f70e3df1e54a55346b5904ea0b8e6769d1..eddf5d98952a37026a0c4ac48a00bdd30360780d 100644 (file)
--- a/arch/x86/chunkset_sse2.c
+++ b/arch/x86/chunkset_sse2.c
@@ -17,19 +17,19 @@ typedef __m128i chunk_t;
 
 static inline void chunkmemset_2(uint8_t *from, chunk_t *chunk) {
     int16_t tmp;
-    zmemcpy_2(&tmp, from);
+    memcpy(&tmp, from, sizeof(tmp));
     *chunk = _mm_set1_epi16(tmp);
 }
 
 static inline void chunkmemset_4(uint8_t *from, chunk_t *chunk) {
     int32_t tmp;
-    zmemcpy_4(&tmp, from);
+    memcpy(&tmp, from, sizeof(tmp));
     *chunk = _mm_set1_epi32(tmp);
 }
 
 static inline void chunkmemset_8(uint8_t *from, chunk_t *chunk) {
     int64_t tmp;
-    zmemcpy_8(&tmp, from);
+    memcpy(&tmp, from, sizeof(tmp));
     *chunk = _mm_set1_epi64x(tmp);
 }
 

diff --git a/arch/x86/chunkset_sse41.c b/arch/x86/chunkset_sse41.c
index 42b44d0512c4278aae2fd127a1880c111ad972e9..c148db09243beacba6feedb1cfe905c610bec546 100644 (file)
--- a/arch/x86/chunkset_sse41.c
+++ b/arch/x86/chunkset_sse41.c
@@ -41,19 +41,19 @@ static const lut_rem_pair perm_idx_lut[13] = {
 
 static inline void chunkmemset_2(uint8_t *from, chunk_t *chunk) {
     int16_t tmp;
-    zmemcpy_2(&tmp, from);
+    memcpy(&tmp, from, sizeof(tmp));
     *chunk = _mm_set1_epi16(tmp);
 }
 
 static inline void chunkmemset_4(uint8_t *from, chunk_t *chunk) {
     int32_t tmp;
-    zmemcpy_4(&tmp, from);
+    memcpy(&tmp, from, sizeof(tmp));
     *chunk = _mm_set1_epi32(tmp);
 }
 
 static inline void chunkmemset_8(uint8_t *from, chunk_t *chunk) {
     int64_t tmp;
-    zmemcpy_8(&tmp, from);
+    memcpy(&tmp, from, sizeof(tmp));
     *chunk = _mm_set1_epi64x(tmp);
 }
 
@@ -69,7 +69,7 @@ static inline chunk_t GET_CHUNK_MAG(uint8_t *buf, uint32_t *chunk_rem, uint32_t
     lut_rem_pair lut_rem = perm_idx_lut[dist - 3];
     __m128i perm_vec, ret_vec;
 #ifdef Z_MEMORY_SANITIZER
-    /* Important to note: 
+    /* Important to note:
      * This is _not_ to subvert the memory sanitizer but to instead unpoison some
      * bytes we willingly and purposefully load uninitialized that we swizzle over
      * in a vector register, anyway.  If what we assume is wrong about what is used,

diff --git a/chunkset.c b/chunkset.c
index ca35929f3a58887ee7cd0abeecbcf63fb5daaa20..169e4112339e6cc384cfeeb789c7b08076c58e99 100644 (file)
--- a/chunkset.c
+++ b/chunkset.c
@@ -13,20 +13,20 @@ typedef uint64_t chunk_t;
 
 static inline void chunkmemset_4(uint8_t *from, chunk_t *chunk) {
     uint8_t *dest = (uint8_t *)chunk;
-    zmemcpy_4(dest, from);
-    zmemcpy_4(dest+4, from);
+    memcpy(dest, from, sizeof(uint32_t));
+    memcpy(dest+4, from, sizeof(uint32_t));
 }
 
 static inline void chunkmemset_8(uint8_t *from, chunk_t *chunk) {
-    zmemcpy_8(chunk, from);
+    memcpy(chunk, from, sizeof(uint64_t));
 }
 
 static inline void loadchunk(uint8_t const *s, chunk_t *chunk) {
-    zmemcpy_8(chunk, (uint8_t *)s);
+    memcpy(chunk, (uint8_t *)s, sizeof(uint64_t));
 }
 
 static inline void storechunk(uint8_t *out, chunk_t *chunk) {
-    zmemcpy_8(out, chunk);
+    memcpy(out, chunk, sizeof(uint64_t));
 }
 
 #define CHUNKSIZE        chunksize_c

diff --git a/compare256.c b/compare256.c
index 3c05969f9fb9b8a2a6e8ed59ac2bcb863c35a384..b11ac24ee076a03194391f4baebd1d049f9fb133 100644 (file)
--- a/compare256.c
+++ b/compare256.c
@@ -101,8 +101,8 @@ static inline uint32_t compare256_unaligned_32_static(const uint8_t *src0, const
     do {
         uint32_t sv, mv, diff;
 
-        zmemcpy_4(&sv, src0);
-        zmemcpy_4(&mv, src1);
+        memcpy(&sv, src0, sizeof(sv));
+        memcpy(&mv, src1, sizeof(mv));
 
         diff = sv ^ mv;
         if (diff) {
@@ -141,8 +141,8 @@ static inline uint32_t compare256_unaligned_64_static(const uint8_t *src0, const
     do {
         uint64_t sv, mv, diff;
 
-        zmemcpy_8(&sv, src0);
-        zmemcpy_8(&mv, src1);
+        memcpy(&sv, src0, sizeof(sv));
+        memcpy(&mv, src1, sizeof(mv));
 
         diff = sv ^ mv;
         if (diff) {

diff --git a/deflate.h b/deflate.h
index f8920df59c1d9c57358c8f56d9b4c9fc5c7cdcfd..ccb246a8187d94c32548e17ab035077f4a42f2c2 100644 (file)
--- a/deflate.h
+++ b/deflate.h
@@ -306,7 +306,7 @@ static inline void put_short(deflate_state *s, uint16_t w) {
 #if BYTE_ORDER == BIG_ENDIAN
     w = ZSWAP16(w);
 #endif
-    zmemcpy_2(&s->pending_buf[s->pending], &w);
+    memcpy(&s->pending_buf[s->pending], &w, sizeof(w));
     s->pending += 2;
 }
 
@@ -318,7 +318,7 @@ static inline void put_short_msb(deflate_state *s, uint16_t w) {
 #if BYTE_ORDER == LITTLE_ENDIAN
     w = ZSWAP16(w);
 #endif
-    zmemcpy_2(&s->pending_buf[s->pending], &w);
+    memcpy(&s->pending_buf[s->pending], &w, sizeof(w));
     s->pending += 2;
 }
 
@@ -330,7 +330,7 @@ static inline void put_uint32(deflate_state *s, uint32_t dw) {
 #if BYTE_ORDER == BIG_ENDIAN
     dw = ZSWAP32(dw);
 #endif
-    zmemcpy_4(&s->pending_buf[s->pending], &dw);
+    memcpy(&s->pending_buf[s->pending], &dw, sizeof(dw));
     s->pending += 4;
 }
 
@@ -342,7 +342,7 @@ static inline void put_uint32_msb(deflate_state *s, uint32_t dw) {
 #if BYTE_ORDER == LITTLE_ENDIAN
     dw = ZSWAP32(dw);
 #endif
-    zmemcpy_4(&s->pending_buf[s->pending], &dw);
+    memcpy(&s->pending_buf[s->pending], &dw, sizeof(dw));
     s->pending += 4;
 }
 
@@ -354,7 +354,7 @@ static inline void put_uint64(deflate_state *s, uint64_t lld) {
 #if BYTE_ORDER == BIG_ENDIAN
     lld = ZSWAP64(lld);
 #endif
-    zmemcpy_8(&s->pending_buf[s->pending], &lld);
+    memcpy(&s->pending_buf[s->pending], &lld, sizeof(lld));
     s->pending += 8;
 }
 

diff --git a/inffast.c b/inffast.c
index 36923317de2d7e6dd6dcc43292f0eaf4f53c49e7..bfb1c83134590438082792e4ed8d7884fa6033a5 100644 (file)
--- a/inffast.c
+++ b/inffast.c
@@ -14,7 +14,7 @@
 /* Load 64 bits from IN and place the bytes at offset BITS in the result. */
 static inline uint64_t load_64_bits(const unsigned char *in, unsigned bits) {
     uint64_t chunk;
-    zmemcpy_8(&chunk, in);
+    memcpy(&chunk, in, sizeof(chunk));
 
 #if BYTE_ORDER == LITTLE_ENDIAN
     return chunk << bits;

diff --git a/inflate_p.h b/inflate_p.h
index 20f6b1a8c30fa2e0277f01a5b0c8a57fc4ea78e8..7122d7ce650d874aeda1d48d1d79356f98e2c544 100644 (file)
--- a/inflate_p.h
+++ b/inflate_p.h
@@ -176,21 +176,21 @@ static inline uint8_t* chunkcopy_safe(uint8_t *out, uint8_t *from, uint64_t len,
         }
 
         if (tocopy >= 8) {
-            zmemcpy_8(out, from);
+            memcpy(out, from, 8);
             out += 8;
             from += 8;
             tocopy -= 8;
         }
 
         if (tocopy >= 4) {
-            zmemcpy_4(out, from);
+            memcpy(out, from, 4);
             out += 4;
             from += 4;
             tocopy -= 4;
         }
 
         if (tocopy >= 2) {
-            zmemcpy_2(out, from);
+            memcpy(out, from, 2);
             out += 2;
             from += 2;
             tocopy -= 2;

diff --git a/insert_string_tpl.h b/insert_string_tpl.h
index 643a5e0e316a0fc13844304d3f1e3184db7f6931..4acd67fd62c81ea8b0b327dfd34660b210e1c97f 100644 (file)
--- a/insert_string_tpl.h
+++ b/insert_string_tpl.h
@@ -31,7 +31,7 @@
 #ifndef HASH_CALC_READ
 #  if BYTE_ORDER == LITTLE_ENDIAN
 #    define HASH_CALC_READ \
-        zmemcpy_4(&val, strstart);
+        memcpy(&val, strstart, sizeof(val));
 #  else
 #    define HASH_CALC_READ \
         val  = ((uint32_t)(strstart[0])); \

diff --git a/match_tpl.h b/match_tpl.h
index 3fc71c15a0134a0050bba516e9e1ab56c50a4c5e..fbd34e58a5a0b4ff841350b5ed959cee10a2e56e 100644 (file)
--- a/match_tpl.h
+++ b/match_tpl.h
@@ -74,11 +74,11 @@ Z_INTERNAL uint32_t LONGEST_MATCH(deflate_state *const s, Pos cur_match) {
 #endif
 
 #ifdef UNALIGNED64_OK
-    zmemcpy_8(scan_start, scan);
-    zmemcpy_8(scan_end, scan+offset);
+    memcpy(scan_start, scan, sizeof(uint64_t));
+    memcpy(scan_end, scan+offset, sizeof(uint64_t));
 #elif defined(UNALIGNED_OK)
-    zmemcpy_4(scan_start, scan);
-    zmemcpy_4(scan_end, scan+offset);
+    memcpy(scan_start, scan, sizeof(uint32_t));
+    memcpy(scan_end, scan+offset, sizeof(uint32_t));
 #else
     scan_end[0] = *(scan+offset);
     scan_end[1] = *(scan+offset+1);
@@ -201,9 +201,9 @@ Z_INTERNAL uint32_t LONGEST_MATCH(deflate_state *const s, Pos cur_match) {
 #endif
 
 #ifdef UNALIGNED64_OK
-            zmemcpy_8(scan_end, scan+offset);
+            memcpy(scan_end, scan+offset, sizeof(uint64_t));
 #elif defined(UNALIGNED_OK)
-            zmemcpy_4(scan_end, scan+offset);
+            memcpy(scan_end, scan+offset, sizeof(uint32_t));
 #else
             scan_end[0] = *(scan+offset);
             scan_end[1] = *(scan+offset+1);

diff --git a/zbuild.h b/zbuild.h
index d82c1c388efa80d47e22410be429fe1197592132..10a7fd6b3d274ecb7a56f17aaa9500827b5e2bc9 100644 (file)
--- a/zbuild.h
+++ b/zbuild.h
@@ -218,31 +218,22 @@
 #  endif
 #endif
 
-/* Force compiler to emit unaligned memory accesses if unaligned access is supported
+/* Force compiler to emit unaligned memory comparisons if unaligned access is supported
    on the architecture, otherwise don't assume unaligned access is supported. Older
-   compilers don't optimize memcpy and memcmp calls to unaligned access instructions
-   when it is supported on the architecture resulting in significant performance impact.
-   Newer compilers might optimize memcpy but not all optimize memcmp for all integer types. */
+   compilers don't optimize memcmp calls for all integer types to unaligned access instructions
+   when it is supported on the architecture resulting in significant performance impact. */
 #ifdef UNALIGNED_OK
-#  define zmemcpy_2(dest, src)    (*((uint16_t *)(dest)) = *((uint16_t *)(src)))
 #  define zmemcmp_2(str1, str2)   (*((uint16_t *)(str1)) != *((uint16_t *)(str2)))
-#  define zmemcpy_4(dest, src)    (*((uint32_t *)(dest)) = *((uint32_t *)(src)))
 #  define zmemcmp_4(str1, str2)   (*((uint32_t *)(str1)) != *((uint32_t *)(str2)))
 #  if defined(UNALIGNED64_OK) && (UINTPTR_MAX == UINT64_MAX)
-#    define zmemcpy_8(dest, src)  (*((uint64_t *)(dest)) = *((uint64_t *)(src)))
 #    define zmemcmp_8(str1, str2) (*((uint64_t *)(str1)) != *((uint64_t *)(str2)))
 #  else
-#    define zmemcpy_8(dest, src)  (((uint32_t *)(dest))[0] = ((uint32_t *)(src))[0], \
-                                   ((uint32_t *)(dest))[1] = ((uint32_t *)(src))[1])
 #    define zmemcmp_8(str1, str2) (((uint32_t *)(str1))[0] != ((uint32_t *)(str2))[0] || \
                                    ((uint32_t *)(str1))[1] != ((uint32_t *)(str2))[1])
 #  endif
 #else
-#  define zmemcpy_2(dest, src)  memcpy(dest, src, 2)
 #  define zmemcmp_2(str1, str2) memcmp(str1, str2, 2)
-#  define zmemcpy_4(dest, src)  memcpy(dest, src, 4)
 #  define zmemcmp_4(str1, str2) memcmp(str1, str2, 4)
-#  define zmemcpy_8(dest, src)  memcpy(dest, src, 8)
 #  define zmemcmp_8(str1, str2) memcmp(str1, str2, 8)
 #endif