Simplify types used in chunkset code

diff --git a/arch/arm/arm_functions.h b/arch/arm/arm_functions.h
index 35dd12a2d90c5e85310dca238bf9ba287514dd32..34ba87b067e5045220fc9ff2e6679a7cd0d9c435 100644 (file)
--- a/arch/arm/arm_functions.h
+++ b/arch/arm/arm_functions.h
@@ -8,7 +8,7 @@
 #ifdef ARM_NEON
 uint32_t adler32_neon(uint32_t adler, const uint8_t *buf, size_t len);
 uint32_t adler32_copy_neon(uint32_t adler, uint8_t *dst, const uint8_t *src, size_t len);
-uint8_t* chunkmemset_safe_neon(uint8_t *out, uint8_t *from, unsigned len, unsigned left);
+uint8_t* chunkmemset_safe_neon(uint8_t *out, uint8_t *from, size_t len, size_t left);
 uint32_t compare256_neon(const uint8_t *src0, const uint8_t *src1);
 void inflate_fast_neon(PREFIX3(stream) *strm, uint32_t start);
 uint32_t longest_match_neon(deflate_state *const s, uint32_t cur_match);

diff --git a/arch/arm/chunkset_neon.c b/arch/arm/chunkset_neon.c
index a208451547aeb8b68d9948f3f9e89b14eeccfd40..7bc932f939858c7526b2b1065e109f5b5248eba3 100644 (file)
--- a/arch/arm/chunkset_neon.c
+++ b/arch/arm/chunkset_neon.c
@@ -43,7 +43,7 @@ static inline void storechunk(uint8_t *out, chunk_t *chunk) {
     vst1q_u8(out, *chunk);
 }
 
-static inline chunk_t GET_CHUNK_MAG(uint8_t *buf, uint32_t *chunk_rem, uint32_t dist) {
+static inline chunk_t GET_CHUNK_MAG(uint8_t *buf, size_t *chunk_rem, size_t dist) {
     lut_rem_pair lut_rem = perm_idx_lut[dist - 3];
     *chunk_rem = lut_rem.remval;
 

diff --git a/arch/generic/generic_functions.h b/arch/generic/generic_functions.h
index f8e564432d689834b7bf64eabd24dbe98a07ac38..1b296b8f923b773559d8c3af038f5202c2b1700a 100644 (file)
--- a/arch/generic/generic_functions.h
+++ b/arch/generic/generic_functions.h
@@ -20,7 +20,7 @@ typedef void     (*slide_hash_func)(deflate_state *s);
 uint32_t adler32_c(uint32_t adler, const uint8_t *buf, size_t len);
 uint32_t adler32_copy_c(uint32_t adler, uint8_t *dst, const uint8_t *src, size_t len);
 
-uint8_t* chunkmemset_safe_c(uint8_t *out, uint8_t *from, unsigned len, unsigned left);
+uint8_t* chunkmemset_safe_c(uint8_t *out, uint8_t *from, size_t len, size_t left);
 
 #ifdef WITH_ALL_FALLBACKS
 uint32_t compare256_8(const uint8_t *src0, const uint8_t *src1);

diff --git a/arch/loongarch/chunkset_lasx.c b/arch/loongarch/chunkset_lasx.c
index 38000474bfbb4df027b54a0409c71d8828d1c8fd..a85c07d09478c6ee630837d6c8a9234c6f8640d8 100644 (file)
--- a/arch/loongarch/chunkset_lasx.c
+++ b/arch/loongarch/chunkset_lasx.c
@@ -48,7 +48,7 @@ static inline void storechunk(uint8_t *out, chunk_t *chunk) {
     __lasx_xvst(*chunk, out, 0);
 }
 
-static inline chunk_t GET_CHUNK_MAG(uint8_t *buf, uint32_t *chunk_rem, uint32_t dist) {
+static inline chunk_t GET_CHUNK_MAG(uint8_t *buf, size_t *chunk_rem, size_t dist) {
     lut_rem_pair lut_rem = perm_idx_lut[dist - 3];
     __m256i ret_vec;
     /* While technically we only need to read 4 or 8 bytes into this vector register for a lot of cases, GCC is
@@ -97,7 +97,7 @@ static inline chunk_t halfchunk2whole(halfchunk_t *chunk) {
     return lasx_zext_128(*chunk);
 }
 
-static inline halfchunk_t GET_HALFCHUNK_MAG(uint8_t *buf, uint32_t *chunk_rem, uint32_t dist) {
+static inline halfchunk_t GET_HALFCHUNK_MAG(uint8_t *buf, size_t *chunk_rem, size_t dist) {
     lut_rem_pair lut_rem = perm_idx_lut[dist - 3];
     __m128i perm_vec, ret_vec;
     __msan_unpoison(buf + dist, 16 - dist);

diff --git a/arch/loongarch/chunkset_lsx.c b/arch/loongarch/chunkset_lsx.c
index 631052d74ae735cf46d7870d353f3d63449108b9..e626157f40f1e6c4d2d42dc9eab84091023f7df4 100644 (file)
--- a/arch/loongarch/chunkset_lsx.c
+++ b/arch/loongarch/chunkset_lsx.c
@@ -40,7 +40,7 @@ static inline void storechunk(uint8_t *out, chunk_t *chunk) {
     __lsx_vst(*chunk, out, 0);
 }
 
-static inline chunk_t GET_CHUNK_MAG(uint8_t *buf, uint32_t *chunk_rem, uint32_t dist) {
+static inline chunk_t GET_CHUNK_MAG(uint8_t *buf, size_t *chunk_rem, size_t dist) {
     lut_rem_pair lut_rem = perm_idx_lut[dist - 3];
     __m128i perm_vec, ret_vec;
     /* Important to note:

diff --git a/arch/loongarch/loongarch_functions.h b/arch/loongarch/loongarch_functions.h
index 34281432f5f4f544292834062c2cd3ff59176ca3..922c6c41653152dc0200ae5171921892431d0c56 100644 (file)
--- a/arch/loongarch/loongarch_functions.h
+++ b/arch/loongarch/loongarch_functions.h
@@ -16,7 +16,7 @@ uint32_t crc32_copy_loongarch64(uint32_t crc, uint8_t *dst, const uint8_t *src,
 #ifdef LOONGARCH_LSX
 uint32_t adler32_lsx(uint32_t adler, const uint8_t *src, size_t len);
 uint32_t adler32_copy_lsx(uint32_t adler, uint8_t *dst, const uint8_t *src, size_t len);
-uint8_t* chunkmemset_safe_lsx(uint8_t *out, uint8_t *from, unsigned len, unsigned left);
+uint8_t* chunkmemset_safe_lsx(uint8_t *out, uint8_t *from, size_t len, size_t left);
 uint32_t compare256_lsx(const uint8_t *src0, const uint8_t *src1);
 void inflate_fast_lsx(PREFIX3(stream) *strm, uint32_t start);
 uint32_t longest_match_lsx(deflate_state *const s, uint32_t cur_match);
@@ -27,7 +27,7 @@ void slide_hash_lsx(deflate_state *s);
 #ifdef LOONGARCH_LASX
 uint32_t adler32_lasx(uint32_t adler, const uint8_t *src, size_t len);
 uint32_t adler32_copy_lasx(uint32_t adler, uint8_t *dst, const uint8_t *src, size_t len);
-uint8_t* chunkmemset_safe_lasx(uint8_t *out, uint8_t *from, unsigned len, unsigned left);
+uint8_t* chunkmemset_safe_lasx(uint8_t *out, uint8_t *from, size_t len, size_t left);
 uint32_t compare256_lasx(const uint8_t *src0, const uint8_t *src1);
 void inflate_fast_lasx(PREFIX3(stream) *strm, uint32_t start);
 uint32_t longest_match_lasx(deflate_state *const s, uint32_t cur_match);

diff --git a/arch/power/power_functions.h b/arch/power/power_functions.h
index 86f21ad667ea361328fc45d6efd5c94d02b1e4fb..49ea89e819e0284adb41c985afcd35a3dc4ce509 100644 (file)
--- a/arch/power/power_functions.h
+++ b/arch/power/power_functions.h
@@ -16,7 +16,7 @@ void slide_hash_vmx(deflate_state *s);
 #ifdef POWER8_VSX
 uint32_t adler32_power8(uint32_t adler, const uint8_t *buf, size_t len);
 uint32_t adler32_copy_power8(uint32_t adler, uint8_t *dst, const uint8_t *buf, size_t len);
-uint8_t* chunkmemset_safe_power8(uint8_t *out, uint8_t *from, unsigned len, unsigned left);
+uint8_t* chunkmemset_safe_power8(uint8_t *out, uint8_t *from, size_t len, size_t left);
 uint32_t crc32_power8(uint32_t crc, const uint8_t *buf, size_t len);
 uint32_t crc32_copy_power8(uint32_t crc, uint8_t *dst, const uint8_t *src, size_t len);
 void slide_hash_power8(deflate_state *s);

diff --git a/arch/riscv/chunkset_rvv.c b/arch/riscv/chunkset_rvv.c
index 6b35f30daa10fc425bc15c7aa7aae0ab06c3cc8b..cd8ed3cfd220f24af1f258242502a95e5cc0359b 100644 (file)
--- a/arch/riscv/chunkset_rvv.c
+++ b/arch/riscv/chunkset_rvv.c
@@ -86,17 +86,17 @@ static inline void storechunk(uint8_t *out, chunk_t *chunk) {
  *         After using a single memcpy to copy N chunks, we have to use series of
  *         loadchunk and storechunk to ensure the result is correct.
  */
-static inline uint8_t* CHUNKCOPY(uint8_t *out, uint8_t const *from, unsigned len) {
+static inline uint8_t* CHUNKCOPY(uint8_t *out, uint8_t const *from, size_t len) {
     Assert(len > 0, "chunkcopy should never have a length 0");
-    ptrdiff_t dist = out - from;
-    if (dist < 0 || dist >= len) {
+    size_t dist = out - from;
+    if (out < from || dist >= len) {
         memcpy(out, from, len);
         out += len;
         from += len;
         return out;
     }
 
-    int32_t align = ((len - 1) % sizeof(chunk_t)) + 1;
+    size_t align = ((len - 1) % sizeof(chunk_t)) + 1;
     memcpy(out, from, sizeof(chunk_t));
     out += align;
     from += align;

diff --git a/arch/riscv/riscv_functions.h b/arch/riscv/riscv_functions.h
index e87989cca23f3ff37139935bb15f677d149f8d8f..9e641966a021cfe7553de3d8cf75fba50ae5978b 100644 (file)
--- a/arch/riscv/riscv_functions.h
+++ b/arch/riscv/riscv_functions.h
@@ -12,7 +12,7 @@
 #ifdef RISCV_RVV
 uint32_t adler32_rvv(uint32_t adler, const uint8_t *buf, size_t len);
 uint32_t adler32_copy_rvv(uint32_t adler, uint8_t *dst, const uint8_t *src, size_t len);
-uint8_t* chunkmemset_safe_rvv(uint8_t *out, uint8_t *from, unsigned len, unsigned left);
+uint8_t* chunkmemset_safe_rvv(uint8_t *out, uint8_t *from, size_t len, size_t left);
 uint32_t compare256_rvv(const uint8_t *src0, const uint8_t *src1);
 
 uint32_t longest_match_rvv(deflate_state *const s, uint32_t cur_match);

diff --git a/arch/x86/chunkset_avx2.c b/arch/x86/chunkset_avx2.c
index 98b6af03b0ecd14158ea2cb09ec0ae9e017bb850..953d3b05e27320bbcd45c83436c087821cd805be 100644 (file)
--- a/arch/x86/chunkset_avx2.c
+++ b/arch/x86/chunkset_avx2.c
@@ -51,7 +51,7 @@ static inline void storechunk(uint8_t *out, chunk_t *chunk) {
     _mm256_storeu_si256((__m256i *)out, *chunk);
 }
 
-static inline chunk_t GET_CHUNK_MAG(uint8_t *buf, uint32_t *chunk_rem, uint32_t dist) {
+static inline chunk_t GET_CHUNK_MAG(uint8_t *buf, size_t *chunk_rem, size_t dist) {
     lut_rem_pair lut_rem = perm_idx_lut[dist - 3];
     __m256i ret_vec;
     /* While technically we only need to read 4 or 8 bytes into this vector register for a lot of cases, GCC is
@@ -100,7 +100,7 @@ static inline chunk_t halfchunk2whole(halfchunk_t *chunk) {
     return _mm256_zextsi128_si256(*chunk);
 }
 
-static inline halfchunk_t GET_HALFCHUNK_MAG(uint8_t *buf, uint32_t *chunk_rem, uint32_t dist) {
+static inline halfchunk_t GET_HALFCHUNK_MAG(uint8_t *buf, size_t *chunk_rem, size_t dist) {
     lut_rem_pair lut_rem = perm_idx_lut[dist - 3];
     __m128i perm_vec, ret_vec;
     __msan_unpoison(buf + dist, 16 - dist);

diff --git a/arch/x86/chunkset_avx512.c b/arch/x86/chunkset_avx512.c
index 901fea0cbd06a4b319c61c489acc503698ae6519..60450c653ba0ab4fcb200418eeb5cfd1948f18e7 100644 (file)
--- a/arch/x86/chunkset_avx512.c
+++ b/arch/x86/chunkset_avx512.c
@@ -26,12 +26,12 @@ typedef __mmask16 halfmask_t;
 #define HAVE_CHUNKCOPY
 #define HAVE_HALFCHUNKCOPY
 
-static inline halfmask_t gen_half_mask(unsigned len) {
-   return (halfmask_t)_bzhi_u32(0xFFFF, len);
+static inline halfmask_t gen_half_mask(size_t len) {
+   return (halfmask_t)_bzhi_u32(0xFFFF, (unsigned)len);
 }
 
-static inline mask_t gen_mask(unsigned len) {
-   return (mask_t)_bzhi_u32(0xFFFFFFFF, len);
+static inline mask_t gen_mask(size_t len) {
+   return (mask_t)_bzhi_u32(0xFFFFFFFF, (unsigned)len);
 }
 
 static inline void chunkmemset_2(uint8_t *from, chunk_t *chunk) {
@@ -68,11 +68,11 @@ static inline void storechunk(uint8_t *out, chunk_t *chunk) {
     _mm256_storeu_si256((__m256i *)out, *chunk);
 }
 
-static inline uint8_t* CHUNKCOPY(uint8_t *out, uint8_t const *from, unsigned len) {
+static inline uint8_t* CHUNKCOPY(uint8_t *out, uint8_t const *from, size_t len) {
     Assert(len > 0, "chunkcopy should never have a length 0");
 
     chunk_t chunk;
-    uint32_t rem = len % sizeof(chunk_t);
+    size_t rem = len % sizeof(chunk_t);
 
     if (len < sizeof(chunk_t)) {
         mask_t rem_mask = gen_mask(rem);
@@ -103,7 +103,7 @@ static inline uint8_t* CHUNKCOPY(uint8_t *out, uint8_t const *from, unsigned len
 #if defined(_MSC_VER) && _MSC_VER < 1943
 #  pragma optimize("", off)
 #endif
-static inline chunk_t GET_CHUNK_MAG(uint8_t *buf, uint32_t *chunk_rem, uint32_t dist) {
+static inline chunk_t GET_CHUNK_MAG(uint8_t *buf, size_t *chunk_rem, size_t dist) {
     lut_rem_pair lut_rem = perm_idx_lut[dist - 3];
     __m256i ret_vec;
     *chunk_rem = lut_rem.remval;
@@ -143,7 +143,7 @@ static inline chunk_t halfchunk2whole(halfchunk_t *chunk) {
     return _mm256_zextsi128_si256(*chunk);
 }
 
-static inline halfchunk_t GET_HALFCHUNK_MAG(uint8_t *buf, uint32_t *chunk_rem, uint32_t dist) {
+static inline halfchunk_t GET_HALFCHUNK_MAG(uint8_t *buf, size_t *chunk_rem, size_t dist) {
     lut_rem_pair lut_rem = perm_idx_lut[dist - 3];
     __m128i perm_vec, ret_vec;
     halfmask_t load_mask = gen_half_mask(dist);
@@ -156,11 +156,11 @@ static inline halfchunk_t GET_HALFCHUNK_MAG(uint8_t *buf, uint32_t *chunk_rem, u
     return ret_vec;
 }
 
-static inline uint8_t* HALFCHUNKCOPY(uint8_t *out, uint8_t const *from, unsigned len) {
+static inline uint8_t* HALFCHUNKCOPY(uint8_t *out, uint8_t const *from, size_t len) {
     Assert(len > 0, "chunkcopy should never have a length 0");
     halfchunk_t chunk;
 
-    uint32_t rem = len % sizeof(halfchunk_t);
+    size_t rem = len % sizeof(halfchunk_t);
     if (rem == 0) {
         rem = sizeof(halfchunk_t);
     }

diff --git a/arch/x86/chunkset_ssse3.c b/arch/x86/chunkset_ssse3.c
index b0ec74ef84a8e848e53f051c5e5efd86cdf7e0f4..3085f57a35271e67e04070883556efc03b84498a 100644 (file)
--- a/arch/x86/chunkset_ssse3.c
+++ b/arch/x86/chunkset_ssse3.c
@@ -38,7 +38,7 @@ static inline void storechunk(uint8_t *out, chunk_t *chunk) {
     _mm_storeu_si128((__m128i *)out, *chunk);
 }
 
-static inline chunk_t GET_CHUNK_MAG(uint8_t *buf, uint32_t *chunk_rem, uint32_t dist) {
+static inline chunk_t GET_CHUNK_MAG(uint8_t *buf, size_t *chunk_rem, size_t dist) {
     lut_rem_pair lut_rem = perm_idx_lut[dist - 3];
     __m128i perm_vec, ret_vec;
     /* Important to note:

diff --git a/arch/x86/x86_functions.h b/arch/x86/x86_functions.h
index e1c99137dd99c8214850074426f09f98bf2ded8a..b1d623cace3263408dc16e180047fdaa8f571dc7 100644 (file)
--- a/arch/x86/x86_functions.h
+++ b/arch/x86/x86_functions.h
@@ -15,7 +15,7 @@
 #endif
 
 #ifdef X86_SSE2
-uint8_t* chunkmemset_safe_sse2(uint8_t *out, uint8_t *from, unsigned len, unsigned left);
+uint8_t* chunkmemset_safe_sse2(uint8_t *out, uint8_t *from, size_t len, size_t left);
 uint32_t compare256_sse2(const uint8_t *src0, const uint8_t *src1);
 void inflate_fast_sse2(PREFIX3(stream)* strm, uint32_t start);
 uint32_t longest_match_sse2(deflate_state *const s, uint32_t cur_match);
@@ -32,7 +32,7 @@ void slide_hash_sse2(deflate_state *s);
 #ifdef X86_SSSE3
 uint32_t adler32_ssse3(uint32_t adler, const uint8_t *buf, size_t len);
 uint32_t adler32_copy_ssse3(uint32_t adler, uint8_t *dst, const uint8_t *src, size_t len);
-uint8_t* chunkmemset_safe_ssse3(uint8_t *out, uint8_t *from, unsigned len, unsigned left);
+uint8_t* chunkmemset_safe_ssse3(uint8_t *out, uint8_t *from, size_t len, size_t left);
 void inflate_fast_ssse3(PREFIX3(stream) *strm, uint32_t start);
 #endif
 
@@ -48,7 +48,7 @@ uint32_t adler32_copy_sse42(uint32_t adler, uint8_t *dst, const uint8_t *src, si
 #ifdef X86_AVX2
 uint32_t adler32_avx2(uint32_t adler, const uint8_t *buf, size_t len);
 uint32_t adler32_copy_avx2(uint32_t adler, uint8_t *dst, const uint8_t *src, size_t len);
-uint8_t* chunkmemset_safe_avx2(uint8_t *out, uint8_t *from, unsigned len, unsigned left);
+uint8_t* chunkmemset_safe_avx2(uint8_t *out, uint8_t *from, size_t len, size_t left);
 uint32_t compare256_avx2(const uint8_t *src0, const uint8_t *src1);
 void inflate_fast_avx2(PREFIX3(stream)* strm, uint32_t start);
 uint32_t longest_match_avx2(deflate_state *const s, uint32_t cur_match);
@@ -58,7 +58,7 @@ void slide_hash_avx2(deflate_state *s);
 #ifdef X86_AVX512
 uint32_t adler32_avx512(uint32_t adler, const uint8_t *buf, size_t len);
 uint32_t adler32_copy_avx512(uint32_t adler, uint8_t *dst, const uint8_t *src, size_t len);
-uint8_t* chunkmemset_safe_avx512(uint8_t *out, uint8_t *from, unsigned len, unsigned left);
+uint8_t* chunkmemset_safe_avx512(uint8_t *out, uint8_t *from, size_t len, size_t left);
 uint32_t compare256_avx512(const uint8_t *src0, const uint8_t *src1);
 void inflate_fast_avx512(PREFIX3(stream)* strm, uint32_t start);
 uint32_t longest_match_avx512(deflate_state *const s, uint32_t cur_match);

diff --git a/chunkset_tpl.h b/chunkset_tpl.h
index d6e40e6f86c3b735e3dea471407ab324b4eabeff..82511f0e8ca8ecf7ef43a0fdc4eb4bc77318789b 100644 (file)
--- a/chunkset_tpl.h
+++ b/chunkset_tpl.h
@@ -21,10 +21,10 @@ static inline size_t CHUNKSIZE(void) {
    without iteration, which will hopefully make the branch prediction more
    reliable. */
 #ifndef HAVE_CHUNKCOPY
-static inline uint8_t* CHUNKCOPY(uint8_t *out, uint8_t const *from, unsigned len) {
+static inline uint8_t* CHUNKCOPY(uint8_t *out, uint8_t const *from, size_t len) {
     Assert(len > 0, "chunkcopy should never have a length 0");
     chunk_t chunk;
-    int32_t align = ((len - 1) % sizeof(chunk_t)) + 1;
+    size_t align = ((len - 1) % sizeof(chunk_t)) + 1;
     loadchunk(from, &chunk);
     storechunk(out, &chunk);
     out += align;
@@ -64,21 +64,21 @@ static inline uint8_t* CHUNKUNROLL(uint8_t *out, unsigned *dist, unsigned *len)
 
 #ifndef HAVE_CHUNK_MAG
 /* Loads a magazine to feed into memory of the pattern */
-static inline chunk_t GET_CHUNK_MAG(uint8_t *buf, uint32_t *chunk_rem, uint32_t dist) {
+static inline chunk_t GET_CHUNK_MAG(uint8_t *buf, size_t *chunk_rem, size_t dist) {
         /* This code takes string of length dist from "from" and repeats
          * it for as many times as can fit in a chunk_t (vector register) */
-        uint64_t cpy_dist;
-        uint64_t bytes_remaining = sizeof(chunk_t);
+        size_t cpy_dist;
+        size_t bytes_remaining = sizeof(chunk_t);
         chunk_t chunk_load;
         uint8_t *cur_chunk = (uint8_t *)&chunk_load;
         while (bytes_remaining) {
             cpy_dist = MIN(dist, bytes_remaining);
-            memcpy(cur_chunk, buf, (size_t)cpy_dist);
+            memcpy(cur_chunk, buf, cpy_dist);
             bytes_remaining -= cpy_dist;
             cur_chunk += cpy_dist;
             /* This allows us to bypass an expensive integer division since we're effectively
              * counting in this loop, anyway */
-            *chunk_rem = (uint32_t)cpy_dist;
+            *chunk_rem = cpy_dist;
         }
 
         return chunk_load;
@@ -86,9 +86,10 @@ static inline chunk_t GET_CHUNK_MAG(uint8_t *buf, uint32_t *chunk_rem, uint32_t
 #endif
 
 #if defined(HAVE_HALF_CHUNK) && !defined(HAVE_HALFCHUNKCOPY)
-static inline uint8_t* HALFCHUNKCOPY(uint8_t *out, uint8_t const *from, unsigned len) {
+static inline uint8_t* HALFCHUNKCOPY(uint8_t *out, uint8_t const *from, size_t len) {
+    Assert(len > 0, "halfchunkcopy should never have a length 0");
     halfchunk_t chunk;
-    int32_t align = ((len - 1) % sizeof(halfchunk_t)) + 1;
+    size_t align = ((len - 1) % sizeof(halfchunk_t)) + 1;
     loadhalfchunk(from, &chunk);
     storehalfchunk(out, &chunk);
     out += align;
@@ -107,22 +108,21 @@ static inline uint8_t* HALFCHUNKCOPY(uint8_t *out, uint8_t const *from, unsigned
 
 /* Copy DIST bytes from OUT - DIST into OUT + DIST * k, for 0 <= k < LEN/DIST.
    Return OUT + LEN. */
-static inline uint8_t* CHUNKMEMSET(uint8_t *out, uint8_t *from, unsigned len) {
+static inline uint8_t* CHUNKMEMSET(uint8_t *out, uint8_t *from, size_t len) {
     /* Debug performance related issues when len < sizeof(uint64_t):
        Assert(len >= sizeof(uint64_t), "chunkmemset should be called on larger chunks"); */
     Assert(from != out, "chunkmemset cannot have a distance 0");
 
     chunk_t chunk_load;
-    uint32_t chunk_mod = 0;
-    uint32_t adv_amount;
-    int64_t sdist = out - from;
-    uint64_t dist = llabs(sdist);
+    size_t chunk_mod = 0;
+    size_t adv_amount;
+    size_t dist = (size_t)ABS(out - from);
 
     /* We are supporting the case for when we are reading bytes from ahead in the buffer.
      * We now have to handle this, though it wasn't _quite_ clear if this rare circumstance
      * always needed to be handled here or if we're just now seeing it because we are
      * dispatching to this function, more */
-    if (sdist < 0 && dist < len) {
+    if (out < from && dist < len) {
 #ifdef HAVE_MASKED_READWRITE
         /* We can still handle this case if we can mitigate over writing _and_ we
          * fit the entirety of the copy length with one load */
@@ -158,7 +158,7 @@ static inline uint8_t* CHUNKMEMSET(uint8_t *out, uint8_t *from, unsigned len) {
             return HALFCHUNKCOPY(out, from, len);
 
         if ((dist % 2) != 0 || dist == 6) {
-            halfchunk_t halfchunk_load = GET_HALFCHUNK_MAG(from, &chunk_mod, (unsigned)dist);
+            halfchunk_t halfchunk_load = GET_HALFCHUNK_MAG(from, &chunk_mod, dist);
 
             if (len == sizeof(halfchunk_t)) {
                 storehalfchunk(out, &halfchunk_load);
@@ -192,7 +192,7 @@ static inline uint8_t* CHUNKMEMSET(uint8_t *out, uint8_t *from, unsigned len) {
         chunkmemset_16(from, &chunk_load);
     } else
 #endif
-    chunk_load = GET_CHUNK_MAG(from, &chunk_mod, (unsigned)dist);
+    chunk_load = GET_CHUNK_MAG(from, &chunk_mod, dist);
 
     adv_amount = sizeof(chunk_t) - chunk_mod;
 
@@ -224,11 +224,11 @@ rem_bytes:
     return out;
 }
 
-Z_INTERNAL uint8_t* CHUNKMEMSET_SAFE(uint8_t *out, uint8_t *from, unsigned len, unsigned left) {
+Z_INTERNAL uint8_t* CHUNKMEMSET_SAFE(uint8_t *out, uint8_t *from, size_t len, size_t left) {
 #if OPTIMAL_CMP < 32
-    static const uint32_t align_mask = 7;
+    static const uintptr_t align_mask = 7;
 #elif OPTIMAL_CMP == 32
-    static const uint32_t align_mask = 3;
+    static const uintptr_t align_mask = 3;
 #endif
 
     len = MIN(len, left);
@@ -258,16 +258,16 @@ Z_INTERNAL uint8_t* CHUNKMEMSET_SAFE(uint8_t *out, uint8_t *from, unsigned len,
     return out;
 }
 
-static inline uint8_t *CHUNKCOPY_SAFE(uint8_t *out, uint8_t *from, uint64_t len, uint8_t *safe)
+static inline uint8_t *CHUNKCOPY_SAFE(uint8_t *out, uint8_t *from, size_t len, uint8_t *safe)
 {
     if (out == from)
         return out + len;
 
-    uint64_t safelen = (safe - out);
+    size_t safelen = (safe - out);
     len = MIN(len, safelen);
 
 #ifndef HAVE_MASKED_READWRITE
-    uint64_t from_dist = (uint64_t)llabs(safe - from);
+    size_t from_dist = (size_t)ABS(safe - from);
     if (UNLIKELY(from_dist < sizeof(chunk_t) || safelen < sizeof(chunk_t))) {
         while (len--) {
             *out++ = *from++;
@@ -277,5 +277,5 @@ static inline uint8_t *CHUNKCOPY_SAFE(uint8_t *out, uint8_t *from, uint64_t len,
     }
 #endif
 
-    return CHUNKMEMSET(out, from, (unsigned)len);
+    return CHUNKMEMSET(out, from, len);
 }

diff --git a/functable.c b/functable.c
index 632115c5865c869b2fa5f8af64dfa290182b23d0..b3c611622ccd9f1bd3a300800c513aab91cec78a 100644 (file)
--- a/functable.c
+++ b/functable.c
@@ -371,7 +371,7 @@ static uint32_t adler32_copy_stub(uint32_t adler, uint8_t* dst, const uint8_t* s
     return functable.adler32_copy(adler, dst, src, len);
 }
 
-static uint8_t* chunkmemset_safe_stub(uint8_t* out, uint8_t *from, unsigned len, unsigned left) {
+static uint8_t* chunkmemset_safe_stub(uint8_t* out, uint8_t *from, size_t len, size_t left) {
     FUNCTABLE_INIT_ABORT;
     return functable.chunkmemset_safe(out, from, len, left);
 }

diff --git a/functable.h b/functable.h
index 0fa2e9724ad6854e164dcd4cb25c2980d772f7e5..bb33fdb86951dc4b29c1f0374ff1405211e0658c 100644 (file)
--- a/functable.h
+++ b/functable.h
@@ -27,7 +27,7 @@ struct functable_s {
     int      (* force_init)         (void);
     uint32_t (* adler32)            (uint32_t adler, const uint8_t *buf, size_t len);
     uint32_t (* adler32_copy)       (uint32_t adler, uint8_t *dst, const uint8_t *src, size_t len);
-    uint8_t* (* chunkmemset_safe)   (uint8_t *out, uint8_t *from, unsigned len, unsigned left);
+    uint8_t* (* chunkmemset_safe)   (uint8_t *out, uint8_t *from, size_t len, size_t left);
     uint32_t (* compare256)         (const uint8_t *src0, const uint8_t *src1);
     uint32_t (* crc32)              (uint32_t crc, const uint8_t *buf, size_t len);
     uint32_t (* crc32_copy)         (uint32_t crc, uint8_t *dst, const uint8_t *src, size_t len);

diff --git a/inflate_p.h b/inflate_p.h
index 5ec72ce9d22ae6cafcbc9c999a5dbe17493aaf58..0d04f72bb8444a3b332181193473c7178532340f 100644 (file)
--- a/inflate_p.h
+++ b/inflate_p.h
@@ -201,16 +201,16 @@ static inline uint64_t load_64_bits(const unsigned char *in, unsigned bits) {
 }
 
 /* Behave like chunkcopy, but avoid writing beyond of legal output. */
-static inline uint8_t* chunkcopy_safe(uint8_t *out, uint8_t *from, uint64_t len, uint8_t *safe) {
-    uint64_t safelen = safe - out;
+static inline uint8_t* chunkcopy_safe(uint8_t *out, uint8_t *from, size_t len, uint8_t *safe) {
+    size_t safelen = safe - out;
     len = MIN(len, safelen);
     int32_t olap_src = from >= out && from < out + len;
     int32_t olap_dst = out >= from && out < from + len;
-    uint64_t tocopy;
+    size_t tocopy;
 
     /* For all cases without overlap, memcpy is ideal */
     if (!(olap_src || olap_dst)) {
-        memcpy(out, from, (size_t)len);
+        memcpy(out, from, len);
         return out + len;
     }
 
@@ -224,7 +224,7 @@ static inline uint8_t* chunkcopy_safe(uint8_t *out, uint8_t *from, uint64_t len,
      * initial bulk memcpy of the nonoverlapping region. Then, we can leverage the size of this to determine the safest
      * atomic memcpy size we can pick such that we have non-overlapping regions. This effectively becomes a safe look
      * behind or lookahead distance. */
-    uint64_t non_olap_size = llabs(from - out); // llabs vs labs for compatibility with windows
+    size_t non_olap_size = (size_t)ABS(from - out);
 
     /* So this doesn't give use a worst case scenario of function calls in a loop,
      * we want to instead break this down into copy blocks of fixed lengths

diff --git a/zbuild.h b/zbuild.h
index ff7f739a5e7d5f5d1f54cf2bcc4fb91f61cd0e6f..f1a0f3217ed8aa51946dfcf883ceeb657a80cf00 100644 (file)
--- a/zbuild.h
+++ b/zbuild.h
@@ -137,6 +137,8 @@
 #define MIN(a, b) ((a) > (b) ? (b) : (a))
 /* Maximum of a and b. */
 #define MAX(a, b) ((a) < (b) ? (b) : (a))
+/* Absolute value of a. */
+#define ABS(a) ((a) < 0 ? -(a) : (a))
 /* Ignore unused variable warning */
 #define Z_UNUSED(var) (void)(var)