Use GCC's may_alias attribute for unaligned memory access

zlib-ng · Mar 6, 2024 · f295cca · f295cca
1 parent af494fc
commit f295cca
Show file tree

Hide file tree

Showing 24 changed files with 192 additions and 139 deletions.
diff --git a/arch/arm/chunkset_neon.c b/arch/arm/chunkset_neon.c
@@ -5,6 +5,7 @@
 #ifdef ARM_NEON
 #include "neon_intrins.h"
 #include "zbuild.h"
+#include "zmemory.h"
 #include "arch/generic/chunk_permute_table.h"
 
 typedef uint8x16_t chunk_t;
@@ -33,21 +34,15 @@ static const lut_rem_pair perm_idx_lut[13] = {
 };
 
 static inline void chunkmemset_2(uint8_t *from, chunk_t *chunk) {
-    uint16_t tmp;
-    memcpy(&tmp, from, sizeof(tmp));
-    *chunk = vreinterpretq_u8_u16(vdupq_n_u16(tmp));
+    *chunk = vreinterpretq_u8_u16(vdupq_n_u16(zng_memread_2(from)));
 }
 
 static inline void chunkmemset_4(uint8_t *from, chunk_t *chunk) {
-    uint32_t tmp;
-    memcpy(&tmp, from, sizeof(tmp));
-    *chunk = vreinterpretq_u8_u32(vdupq_n_u32(tmp));
+    *chunk = vreinterpretq_u8_u32(vdupq_n_u32(zng_memread_4(from)));
 }
 
 static inline void chunkmemset_8(uint8_t *from, chunk_t *chunk) {
-    uint64_t tmp;
-    memcpy(&tmp, from, sizeof(tmp));
-    *chunk = vreinterpretq_u8_u64(vdupq_n_u64(tmp));
+    *chunk = vreinterpretq_u8_u64(vdupq_n_u64(zng_memread_8(from)));
 }
 
 #define CHUNKSIZE        chunksize_neon

diff --git a/arch/arm/compare256_neon.c b/arch/arm/compare256_neon.c
@@ -4,7 +4,7 @@
  */
 
 #include "zbuild.h"
-#include "zutil_p.h"
+#include "zmemory.h"
 #include "deflate.h"
 #include "fallback_builtins.h"
 

diff --git a/arch/generic/Makefile.in b/arch/generic/Makefile.in
@@ -40,10 +40,10 @@ chunkset_c.o: $(SRCDIR)/chunkset_c.c  $(SRCTOP)/zbuild.h $(SRCTOP)/chunkset_tpl.
 chunkset_c.lo: $(SRCDIR)/chunkset_c.c  $(SRCTOP)/zbuild.h $(SRCTOP)/chunkset_tpl.h $(SRCTOP)/inffast_tpl.h
 	$(CC) $(SFLAGS) $(INCLUDES) -c -o $@ $(SRCDIR)/chunkset_c.c
 
-compare256_c.o: $(SRCDIR)/compare256_c.c  $(SRCTOP)/zbuild.h $(SRCTOP)/zutil_p.h $(SRCTOP)/deflate.h $(SRCTOP)/fallback_builtins.h
+compare256_c.o: $(SRCDIR)/compare256_c.c  $(SRCTOP)/zbuild.h $(SRCTOP)/zmemory.h $(SRCTOP)/deflate.h $(SRCTOP)/fallback_builtins.h
 	$(CC) $(CFLAGS) $(INCLUDES) -c -o $@ $(SRCDIR)/compare256_c.c
 
-compare256_c.lo: $(SRCDIR)/compare256_c.c  $(SRCTOP)/zbuild.h $(SRCTOP)/zutil_p.h $(SRCTOP)/deflate.h $(SRCTOP)/fallback_builtins.h
+compare256_c.lo: $(SRCDIR)/compare256_c.c  $(SRCTOP)/zbuild.h $(SRCTOP)/zmemory.h $(SRCTOP)/deflate.h $(SRCTOP)/fallback_builtins.h
 	$(CC) $(SFLAGS) $(INCLUDES) -c -o $@ $(SRCDIR)/compare256_c.c
 
 crc32_braid_c.o: $(SRCDIR)/crc32_braid_c.c  $(SRCTOP)/zbuild.h $(SRCTOP)/crc32_braid_p.h $(SRCTOP)/crc32_braid_tbl.h

diff --git a/arch/generic/chunkset_c.c b/arch/generic/chunkset_c.c
@@ -3,6 +3,7 @@
  */
 
 #include "zbuild.h"
+#include "zmemory.h"
 
 typedef uint64_t chunk_t;
 
@@ -12,21 +13,20 @@ typedef uint64_t chunk_t;
 #define HAVE_CHUNKMEMSET_8
 
 static inline void chunkmemset_4(uint8_t *from, chunk_t *chunk) {
-    uint8_t *dest = (uint8_t *)chunk;
-    memcpy(dest, from, sizeof(uint32_t));
-    memcpy(dest+4, from, sizeof(uint32_t));
+    uint32_t tmp = zng_memread_4(from);
+    *chunk = tmp | ((chunk_t)tmp << 32);
 }
 
 static inline void chunkmemset_8(uint8_t *from, chunk_t *chunk) {
-    memcpy(chunk, from, sizeof(uint64_t));
+    *chunk = zng_memread_8(from);
 }
 
 static inline void loadchunk(uint8_t const *s, chunk_t *chunk) {
-    memcpy(chunk, (uint8_t *)s, sizeof(uint64_t));
+    *chunk = zng_memread_8(s);
 }
 
 static inline void storechunk(uint8_t *out, chunk_t *chunk) {
-    memcpy(out, chunk, sizeof(uint64_t));
+    zng_memwrite_8(out, *chunk);
 }
 
 #define CHUNKSIZE        chunksize_c

diff --git a/arch/generic/compare256_c.c b/arch/generic/compare256_c.c
@@ -4,7 +4,7 @@
  */
 
 #include "zbuild.h"
-#include "zutil_p.h"
+#include "zmemory.h"
 #include "deflate.h"
 #include "fallback_builtins.h"
 
@@ -106,8 +106,8 @@ static inline uint32_t compare256_unaligned_32_static(const uint8_t *src0, const
     do {
         uint32_t sv, mv, diff;
 
-        memcpy(&sv, src0, sizeof(sv));
-        memcpy(&mv, src1, sizeof(mv));
+        sv = zng_memread_4(src0);
+        mv = zng_memread_4(src1);
 
         diff = sv ^ mv;
         if (diff) {
@@ -146,8 +146,8 @@ static inline uint32_t compare256_unaligned_64_static(const uint8_t *src0, const
     do {
         uint64_t sv, mv, diff;
 
-        memcpy(&sv, src0, sizeof(sv));
-        memcpy(&mv, src1, sizeof(mv));
+        sv = zng_memread_8(src0);
+        mv = zng_memread_8(src1);
 
         diff = sv ^ mv;
         if (diff) {

diff --git a/arch/power/chunkset_power8.c b/arch/power/chunkset_power8.c
@@ -5,6 +5,7 @@
 #ifdef POWER8_VSX
 #include <altivec.h>
 #include "zbuild.h"
+#include "zmemory.h"
 
 typedef vector unsigned char chunk_t;
 
@@ -15,21 +16,15 @@ typedef vector unsigned char chunk_t;
 #define HAVE_CHUNKMEMSET_8
 
 static inline void chunkmemset_2(uint8_t *from, chunk_t *chunk) {
-    uint16_t tmp;
-    memcpy(&tmp, from, sizeof(tmp));
-    *chunk = (vector unsigned char)vec_splats(tmp);
+    *chunk = (vector unsigned char)vec_splats(zng_memread_2(from));
 }
 
 static inline void chunkmemset_4(uint8_t *from, chunk_t *chunk) {
-    uint32_t tmp;
-    memcpy(&tmp, from, sizeof(tmp));
-    *chunk = (vector unsigned char)vec_splats(tmp);
+    *chunk = (vector unsigned char)vec_splats(zng_memread_4(from));
 }
 
 static inline void chunkmemset_8(uint8_t *from, chunk_t *chunk) {
-    uint64_t tmp;
-    memcpy(&tmp, from, sizeof(tmp));
-    *chunk = (vector unsigned char)vec_splats((unsigned long long)tmp);
+    *chunk = (vector unsigned char)vec_splats((unsigned long long)zng_memread_8(from));
 }
 
 static inline void loadchunk(uint8_t const *s, chunk_t *chunk) {

diff --git a/arch/power/compare256_power9.c b/arch/power/compare256_power9.c
@@ -6,7 +6,7 @@
 #ifdef POWER9
 #include <altivec.h>
 #include "zbuild.h"
-#include "zutil_p.h"
+#include "zmemory.h"
 #include "deflate.h"
 #include "zendian.h"
 

diff --git a/arch/riscv/compare256_rvv.c b/arch/riscv/compare256_rvv.c
@@ -7,7 +7,7 @@
 #ifdef RISCV_RVV
 
 #include "zbuild.h"
-#include "zutil_p.h"
+#include "zmemory.h"
 #include "deflate.h"
 #include "fallback_builtins.h"
 

diff --git a/arch/x86/chunkset_avx2.c b/arch/x86/chunkset_avx2.c
@@ -2,6 +2,7 @@
  * For conditions of distribution and use, see copyright notice in zlib.h
  */
 #include "zbuild.h"
+#include "zmemory.h"
 
 #ifdef X86_AVX2
 #include <immintrin.h>
@@ -51,21 +52,15 @@ static const lut_rem_pair perm_idx_lut[29] = {
 };
 
 static inline void chunkmemset_2(uint8_t *from, chunk_t *chunk) {
-    int16_t tmp;
-    memcpy(&tmp, from, sizeof(tmp));
-    *chunk = _mm256_set1_epi16(tmp);
+    *chunk = _mm256_set1_epi16(zng_memread_2(from));
 }
 
 static inline void chunkmemset_4(uint8_t *from, chunk_t *chunk) {
-    int32_t tmp;
-    memcpy(&tmp, from, sizeof(tmp));
-    *chunk = _mm256_set1_epi32(tmp);
+    *chunk = _mm256_set1_epi32(zng_memread_4(from));
 }
 
 static inline void chunkmemset_8(uint8_t *from, chunk_t *chunk) {
-    int64_t tmp;
-    memcpy(&tmp, from, sizeof(tmp));
-    *chunk = _mm256_set1_epi64x(tmp);
+    *chunk = _mm256_set1_epi64x(zng_memread_8(from));
 }
 
 static inline void loadchunk(uint8_t const *s, chunk_t *chunk) {

diff --git a/arch/x86/chunkset_sse2.c b/arch/x86/chunkset_sse2.c
@@ -3,6 +3,7 @@
  */
 
 #include "zbuild.h"
+#include "zmemory.h"
 
 #ifdef X86_SSE2
 #include <immintrin.h>
@@ -16,21 +17,15 @@ typedef __m128i chunk_t;
 #define HAVE_CHUNKMEMSET_8
 
 static inline void chunkmemset_2(uint8_t *from, chunk_t *chunk) {
-    int16_t tmp;
-    memcpy(&tmp, from, sizeof(tmp));
-    *chunk = _mm_set1_epi16(tmp);
+    *chunk = _mm_set1_epi16(zng_memread_2(from));
 }
 
 static inline void chunkmemset_4(uint8_t *from, chunk_t *chunk) {
-    int32_t tmp;
-    memcpy(&tmp, from, sizeof(tmp));
-    *chunk = _mm_set1_epi32(tmp);
+    *chunk = _mm_set1_epi32(zng_memread_4(from));
 }
 
 static inline void chunkmemset_8(uint8_t *from, chunk_t *chunk) {
-    int64_t tmp;
-    memcpy(&tmp, from, sizeof(tmp));
-    *chunk = _mm_set1_epi64x(tmp);
+    *chunk = _mm_set1_epi64x(zng_memread_8(from));
 }
 
 static inline void loadchunk(uint8_t const *s, chunk_t *chunk) {

diff --git a/arch/x86/chunkset_ssse3.c b/arch/x86/chunkset_ssse3.c
@@ -3,6 +3,7 @@
  */
 
 #include "zbuild.h"
+#include "zmemory.h"
 
 #if defined(X86_SSSE3)
 #include <immintrin.h>
@@ -35,21 +36,15 @@ static const lut_rem_pair perm_idx_lut[13] = {
 
 
 static inline void chunkmemset_2(uint8_t *from, chunk_t *chunk) {
-    int16_t tmp;
-    memcpy(&tmp, from, sizeof(tmp));
-    *chunk = _mm_set1_epi16(tmp);
+    *chunk = _mm_set1_epi16(zng_memread_2(from));
 }
 
 static inline void chunkmemset_4(uint8_t *from, chunk_t *chunk) {
-    int32_t tmp;
-    memcpy(&tmp, from, sizeof(tmp));
-    *chunk = _mm_set1_epi32(tmp);
+    *chunk = _mm_set1_epi32(zng_memread_4(from));
 }
 
 static inline void chunkmemset_8(uint8_t *from, chunk_t *chunk) {
-    int64_t tmp;
-    memcpy(&tmp, from, sizeof(tmp));
-    *chunk = _mm_set1_epi64x(tmp);
+    *chunk = _mm_set1_epi64x(zng_memread_8(from));
 }
 
 static inline void loadchunk(uint8_t const *s, chunk_t *chunk) {

diff --git a/arch/x86/compare256_avx2.c b/arch/x86/compare256_avx2.c
@@ -4,7 +4,7 @@
  */
 
 #include "zbuild.h"
-#include "zutil_p.h"
+#include "zmemory.h"
 #include "deflate.h"
 #include "fallback_builtins.h"
 

diff --git a/arch/x86/compare256_sse2.c b/arch/x86/compare256_sse2.c
@@ -4,7 +4,7 @@
  */
 
 #include "zbuild.h"
-#include "zutil_p.h"
+#include "zmemory.h"
 #include "deflate.h"
 #include "fallback_builtins.h"
 

diff --git a/compare256_rle.h b/compare256_rle.h
@@ -4,6 +4,7 @@
  */
 
 #include "zbuild.h"
+#include "zmemory.h"
 #include "fallback_builtins.h"
 
 typedef uint32_t (*compare256_rle_func)(const uint8_t* src0, const uint8_t* src1);
@@ -46,25 +47,21 @@ static inline uint32_t compare256_rle_c(const uint8_t *src0, const uint8_t *src1
 /* 16-bit unaligned integer comparison */
 static inline uint32_t compare256_rle_unaligned_16(const uint8_t *src0, const uint8_t *src1) {
     uint32_t len = 0;
-    uint16_t src0_cmp, src1_cmp;
+    uint16_t src0_cmp;
 
-    memcpy(&src0_cmp, src0, sizeof(src0_cmp));
+    src0_cmp = zng_memread_2(src0);
 
     do {
-        memcpy(&src1_cmp, src1, sizeof(src1_cmp));
-        if (src0_cmp != src1_cmp)
+        if (src0_cmp != zng_memread_2(src1))
             return len + (*src0 == *src1);
         src1 += 2, len += 2;
-        memcpy(&src1_cmp, src1, sizeof(src1_cmp));
-        if (src0_cmp != src1_cmp)
+        if (src0_cmp != zng_memread_2(src1))
             return len + (*src0 == *src1);
         src1 += 2, len += 2;
-        memcpy(&src1_cmp, src1, sizeof(src1_cmp));
-        if (src0_cmp != src1_cmp)
+        if (src0_cmp != zng_memread_2(src1))
             return len + (*src0 == *src1);
         src1 += 2, len += 2;
-        memcpy(&src1_cmp, src1, sizeof(src1_cmp));
-        if (src0_cmp != src1_cmp)
+        if (src0_cmp != zng_memread_2(src1))
             return len + (*src0 == *src1);
         src1 += 2, len += 2;
     } while (len < 256);
@@ -78,13 +75,13 @@ static inline uint32_t compare256_rle_unaligned_32(const uint8_t *src0, const ui
     uint32_t sv, len = 0;
     uint16_t src0_cmp;
 
-    memcpy(&src0_cmp, src0, sizeof(src0_cmp));
+    src0_cmp = zng_memread_2(src0);
     sv = ((uint32_t)src0_cmp << 16) | src0_cmp;
 
     do {
         uint32_t mv, diff;
 
-        memcpy(&mv, src1, sizeof(mv));
+        mv = zng_memread_4(src1);
 
         diff = sv ^ mv;
         if (diff) {
@@ -107,14 +104,14 @@ static inline uint32_t compare256_rle_unaligned_64(const uint8_t *src0, const ui
     uint16_t src0_cmp;
     uint64_t sv;
 
-    memcpy(&src0_cmp, src0, sizeof(src0_cmp));
+    src0_cmp = zng_memread_2(src0);
     src0_cmp32 = ((uint32_t)src0_cmp << 16) | src0_cmp;
     sv = ((uint64_t)src0_cmp32 << 32) | src0_cmp32;
 
     do {
         uint64_t mv, diff;
 
-        memcpy(&mv, src1, sizeof(mv));
+        mv = zng_memread_8(src1);
 
         diff = sv ^ mv;
         if (diff) {