Clean up adler32 short length functions

diff --git a/adler32_p.h b/adler32_p.h
index 7f814d20c21f71916f495616816a9108731dd6b4..12fb0ddf23da0425a9b23598da2d9b479902f049 100644 (file)
--- a/adler32_p.h
+++ b/adler32_p.h
@@ -18,30 +18,25 @@
 #define ADLER_DO8(sum1, sum2, buf, i)  {ADLER_DO4(sum1, sum2, buf, i); ADLER_DO4(sum1, sum2, buf, i+4);}
 #define ADLER_DO16(sum1, sum2, buf)    {ADLER_DO8(sum1, sum2, buf, 0); ADLER_DO8(sum1, sum2, buf, 8);}
 
-static inline uint32_t adler32_len_1(uint32_t adler, const uint8_t *buf, uint32_t sum2) {
-    adler += buf[0];
+static inline uint32_t adler32_copy_len_1(uint32_t adler, uint8_t *dst, const uint8_t *buf, uint32_t sum2, const int COPY) {
+    uint8_t c = *buf;
+    if (COPY) {
+        *dst = c;
+    }
+    adler += c;
     adler %= BASE;
     sum2 += adler;
     sum2 %= BASE;
     return adler | (sum2 << 16);
 }
 
-static inline uint32_t adler32_len_16(uint32_t adler, const uint8_t *buf, size_t len, uint32_t sum2) {
-    while (len) {
-        --len;
-        adler += *buf++;
-        sum2 += adler;
-    }
-    adler %= BASE;
-    sum2 %= BASE;            /* only added so many BASE's */
-    /* return recombined sums */
-    return adler | (sum2 << 16);
-}
-
-static inline uint32_t adler32_copy_len_16(uint32_t adler, const uint8_t *buf, uint8_t *dst, size_t len, uint32_t sum2) {
+static inline uint32_t adler32_copy_len_16(uint32_t adler, uint8_t *dst, const uint8_t *buf, size_t len, uint32_t sum2, const int COPY) {
     while (len--) {
-        *dst = *buf++;
-        adler += *dst++;
+        uint8_t c = *buf++;
+        if (COPY) {
+            *dst++ = c;
+        }
+        adler += c;
         sum2 += adler;
     }
     adler %= BASE;
@@ -50,7 +45,9 @@ static inline uint32_t adler32_copy_len_16(uint32_t adler, const uint8_t *buf, u
     return adler | (sum2 << 16);
 }
 
-static inline uint32_t adler32_len_64(uint32_t adler, const uint8_t *buf, size_t len, uint32_t sum2) {
+static inline uint32_t adler32_copy_len_64(uint32_t adler, uint8_t *dst, const uint8_t *buf, size_t len, uint32_t sum2, const int COPY) {
+    const uint8_t *src = buf;
+    const size_t src_len = len;
 #ifdef UNROLL_MORE
     while (len >= 16) {
         len -= 16;
@@ -64,7 +61,11 @@ static inline uint32_t adler32_len_64(uint32_t adler, const uint8_t *buf, size_t
 #endif
     }
     /* Process tail (len < 16).  */
-    return adler32_len_16(adler, buf, len, sum2);
+    adler = adler32_copy_len_16(adler, NULL, buf, len, sum2, 0);
+    if (COPY) {
+        memcpy(dst, src, src_len);
+    }
+    return adler;
 }
 
 #endif /* ADLER32_P_H */

diff --git a/arch/arm/adler32_neon.c b/arch/arm/adler32_neon.c
index 53cf48253fafd5ef42a05e3f0184e6e1ccd13a8e..f215d9b87983425237902a430e2d9eab02742ac9 100644 (file)
--- a/arch/arm/adler32_neon.c
+++ b/arch/arm/adler32_neon.c
@@ -271,23 +271,16 @@ static Z_FORCEINLINE uint32_t adler32_copy_impl(uint32_t adler, uint8_t *dst, co
     adler &= 0xffff;
 
     /* in case user likes doing a byte at a time, keep it fast */
-    if (len == 1) {
-        if (COPY)
-           *dst = *src;
-        return adler32_len_1(adler, src, sum2);
-    }
+    if (len == 1)
+        return adler32_copy_len_1(adler, dst, src, sum2, COPY);
 
     /* initial Adler-32 value (deferred check for len == 1 speed) */
     if (src == NULL)
         return 1L;
 
     /* in case short lengths are provided, keep it somewhat fast */
-    if (len < 16) {
-        if (COPY)
-            return adler32_copy_len_16(adler, src, dst, len, sum2);
-        else
-            return adler32_len_16(adler, src, len, sum2);
-    }
+    if (len < 16)
+        return adler32_copy_len_16(adler, dst, src, len, sum2, COPY);
 
     uint32_t pair[2];
     int n = NMAX;

diff --git a/arch/generic/adler32_c.c b/arch/generic/adler32_c.c
index 99aeb6767d9f2cbeb8f2aab6dbd332ff6e5d399e..d7179da8e69ac1598aaa1cbb8095e19329feaba8 100644 (file)
--- a/arch/generic/adler32_c.c
+++ b/arch/generic/adler32_c.c
@@ -17,7 +17,7 @@ Z_INTERNAL uint32_t adler32_c(uint32_t adler, const uint8_t *buf, size_t len) {
 
     /* in case user likes doing a byte at a time, keep it fast */
     if (UNLIKELY(len == 1))
-        return adler32_len_1(adler, buf, sum2);
+        return adler32_copy_len_1(adler, NULL, buf, sum2, 0);
 
     /* initial Adler-32 value (deferred check for len == 1 speed) */
     if (UNLIKELY(buf == NULL))
@@ -25,7 +25,7 @@ Z_INTERNAL uint32_t adler32_c(uint32_t adler, const uint8_t *buf, size_t len) {
 
     /* in case short lengths are provided, keep it somewhat fast */
     if (UNLIKELY(len < 16))
-        return adler32_len_16(adler, buf, len, sum2);
+        return adler32_copy_len_16(adler, NULL, buf, len, sum2, 0);
 
     /* do length NMAX blocks -- requires just one modulo operation */
     while (len >= NMAX) {
@@ -49,7 +49,7 @@ Z_INTERNAL uint32_t adler32_c(uint32_t adler, const uint8_t *buf, size_t len) {
     }
 
     /* do remaining bytes (less than NMAX, still just one modulo) */
-    return adler32_len_64(adler, buf, len, sum2);
+    return adler32_copy_len_64(adler, NULL, buf, len, sum2, 0);
 }
 
 Z_INTERNAL uint32_t adler32_copy_c(uint32_t adler, uint8_t *dst, const uint8_t *src, size_t len) {

diff --git a/arch/loongarch/adler32_lasx.c b/arch/loongarch/adler32_lasx.c
index ab416f9b27fcc82c0ada1aa6abd901cf6168fff2..bdcc32422802c2332d5e14f89b9471b23a6d86a3 100644 (file)
--- a/arch/loongarch/adler32_lasx.c
+++ b/arch/loongarch/adler32_lasx.c
@@ -44,11 +44,7 @@ static inline uint32_t adler32_copy_impl(uint32_t adler, uint8_t *dst, const uin
 
 rem_peel:
     if (len < 16) {
-        if (COPY) {
-            return adler32_copy_len_16(adler0, src, dst, len, adler1);
-        } else {
-            return adler32_len_16(adler0, src, len, adler1);
-        }
+        return adler32_copy_len_16(adler0, dst, src, len, adler1, COPY);
     } else if (len < 32) {
         if (COPY) {
             return adler32_copy_lsx(adler, dst, src, len);

diff --git a/arch/loongarch/adler32_lsx.c b/arch/loongarch/adler32_lsx.c
index 8c997f3ac0090cc8d31fbd1149a84dcfa0399219..8031ea9fc09928271a3a234babe08d378fb90995 100644 (file)
--- a/arch/loongarch/adler32_lsx.c
+++ b/arch/loongarch/adler32_lsx.c
@@ -38,13 +38,8 @@ static inline uint32_t adler32_copy_impl(uint32_t adler, uint8_t *dst, const uin
     adler0 = adler & 0xffff;
 
 rem_peel:
-    if (len < 16) {
-        if (COPY) {
-            return adler32_copy_len_16(adler0, src, dst, len, adler1);
-        } else {
-            return adler32_len_16(adler0, src, len, adler1);
-        }
-    }
+    if (len < 16)
+        return adler32_copy_len_16(adler0, dst, src, len, adler1, COPY);
 
     __m128i vbuf, vbuf_0;
     __m128i vs1_0, vs3, vs1, vs2, vs2_0, v_sad_sum1, v_short_sum2, v_short_sum2_0,

diff --git a/arch/power/adler32_power8.c b/arch/power/adler32_power8.c
index 4aaea9f50b3a1d59c107311f79da06be1a033398..8a86f70632a411584e523c5ed3be228c4b202ed8 100644 (file)
--- a/arch/power/adler32_power8.c
+++ b/arch/power/adler32_power8.c
@@ -58,7 +58,7 @@ Z_INTERNAL uint32_t adler32_power8(uint32_t adler, const uint8_t *buf, size_t le
 
     /* in case user likes doing a byte at a time, keep it fast */
     if (UNLIKELY(len == 1))
-        return adler32_len_1(s1, buf, s2);
+        return adler32_copy_len_1(s1, NULL, buf, s2, 0);
 
     /* If buffer is empty or len=0 we need to return adler initial value.  */
     if (UNLIKELY(buf == NULL))
@@ -66,7 +66,7 @@ Z_INTERNAL uint32_t adler32_power8(uint32_t adler, const uint8_t *buf, size_t le
 
     /* This is faster than VSX code for len < 64.  */
     if (len < 64)
-        return adler32_len_64(s1, buf, len, s2);
+        return adler32_copy_len_64(s1, NULL, buf, len, s2, 0);
 
     /* Use POWER VSX instructions for len >= 64. */
     const vector unsigned int v_zeros = { 0 };
@@ -147,7 +147,7 @@ Z_INTERNAL uint32_t adler32_power8(uint32_t adler, const uint8_t *buf, size_t le
     s2 = vs2[0] % BASE;
 
     /* Process tail (len < 16).  */
-    return adler32_len_16(s1, buf, len, s2);
+    return adler32_copy_len_16(s1, NULL, buf, len, s2, 0);
 }
 
 #endif /* POWER8_VSX */

diff --git a/arch/power/adler32_vmx.c b/arch/power/adler32_vmx.c
index 3470c28a12f7b75fb5381bfcb47e6752d82bc894..9ab53e1fa0c499a574c559884442df8ef55bfb79 100644 (file)
--- a/arch/power/adler32_vmx.c
+++ b/arch/power/adler32_vmx.c
@@ -135,7 +135,7 @@ Z_INTERNAL uint32_t adler32_vmx(uint32_t adler, const uint8_t *buf, size_t len)
 
     /* in case user likes doing a byte at a time, keep it fast */
     if (UNLIKELY(len == 1))
-        return adler32_len_1(adler, buf, sum2);
+        return adler32_copy_len_1(adler, NULL, buf, sum2, 0);
 
     /* initial Adler-32 value (deferred check for len == 1 speed) */
     if (UNLIKELY(buf == NULL))
@@ -143,7 +143,7 @@ Z_INTERNAL uint32_t adler32_vmx(uint32_t adler, const uint8_t *buf, size_t len)
 
     /* in case short lengths are provided, keep it somewhat fast */
     if (UNLIKELY(len < 16))
-        return adler32_len_16(adler, buf, len, sum2);
+        return adler32_copy_len_16(adler, NULL, buf, len, sum2, 0);
 
     // Align buffer
     unsigned int al = 0;

diff --git a/arch/riscv/adler32_rvv.c b/arch/riscv/adler32_rvv.c
index 586f99a22c1c5c0dcca0c489c1d981496f5d5396..d7e8c8b128cace6b4baa47c98d303f61deddc542 100644 (file)
--- a/arch/riscv/adler32_rvv.c
+++ b/arch/riscv/adler32_rvv.c
@@ -18,20 +18,16 @@ static inline uint32_t adler32_copy_impl(uint32_t adler, uint8_t* restrict dst,
     adler &= 0xffff;
 
     /* in case user likes doing a byte at a time, keep it fast */
-    if (len == 1) {
-        if (COPY) memcpy(dst, src, 1);
-        return adler32_len_1(adler, src, sum2);
-    }
+    if (len == 1)
+        return adler32_copy_len_1(adler, dst, src, sum2, COPY);
 
     /* initial Adler-32 value (deferred check for len == 1 speed) */
     if (src == NULL)
         return 1L;
 
     /* in case short lengths are provided, keep it somewhat fast */
-    if (len < 16) {
-        if (COPY) memcpy(dst, src, len);
-        return adler32_len_16(adler, src, len, sum2);
-    }
+    if (len < 16)
+        return adler32_copy_len_16(adler, dst, src, len, sum2, COPY);
 
     size_t left = len;
     size_t vl = __riscv_vsetvlmax_e8m1();

diff --git a/arch/x86/adler32_avx2.c b/arch/x86/adler32_avx2.c
index 90c0605581d8da8080346baa7dced30414a902a7..a2168e5e3e09721d9c644e82904e053d49c35e3f 100644 (file)
--- a/arch/x86/adler32_avx2.c
+++ b/arch/x86/adler32_avx2.c
@@ -28,11 +28,7 @@ static inline uint32_t adler32_copy_impl(uint32_t adler, uint8_t *dst, const uin
 
 rem_peel:
     if (len < 16) {
-        if (COPY) {
-            return adler32_copy_len_16(adler0, src, dst, len, adler1);
-        } else {
-            return adler32_len_16(adler0, src, len, adler1);
-        }
+        return adler32_copy_len_16(adler0, dst, src, len, adler1, COPY);
     } else if (len < 32) {
         if (COPY) {
             return adler32_copy_sse42(adler, dst, src, len);

diff --git a/arch/x86/adler32_sse42.c b/arch/x86/adler32_sse42.c
index 86ff9fe49d037311177cc4d75271b7868a136410..f3e79cd15ae9a4ebd3471d5df79c29751e0d92ff 100644 (file)
--- a/arch/x86/adler32_sse42.c
+++ b/arch/x86/adler32_sse42.c
@@ -19,9 +19,8 @@ Z_INTERNAL uint32_t adler32_copy_sse42(uint32_t adler, uint8_t *dst, const uint8
     adler0 = adler & 0xffff;
 
 rem_peel:
-    if (len < 16) {
-       return adler32_copy_len_16(adler0, src, dst, len, adler1);
-    }
+    if (len < 16)
+       return adler32_copy_len_16(adler0, dst, src, len, adler1, 1);
 
     __m128i vbuf, vbuf_0;
     __m128i vs1_0, vs3, vs1, vs2, vs2_0, v_sad_sum1, v_short_sum2, v_short_sum2_0,

diff --git a/arch/x86/adler32_ssse3.c b/arch/x86/adler32_ssse3.c
index 15e2f78ba35ac54fbb4a1f28062db4caeb98b8c3..7dab9b49733f2b969060c0e06b5acc50fe4c825b 100644 (file)
--- a/arch/x86/adler32_ssse3.c
+++ b/arch/x86/adler32_ssse3.c
@@ -23,7 +23,7 @@ Z_INTERNAL uint32_t adler32_ssse3(uint32_t adler, const uint8_t *buf, size_t len
 
     /* in case user likes doing a byte at a time, keep it fast */
     if (UNLIKELY(len == 1))
-        return adler32_len_1(adler, buf, sum2);
+        return adler32_copy_len_1(adler, NULL, buf, sum2, 0);
 
     /* initial Adler-32 value (deferred check for len == 1 speed) */
     if (UNLIKELY(buf == NULL))
@@ -31,7 +31,7 @@ Z_INTERNAL uint32_t adler32_ssse3(uint32_t adler, const uint8_t *buf, size_t len
 
     /* in case short lengths are provided, keep it somewhat fast */
     if (UNLIKELY(len < 16))
-        return adler32_len_16(adler, buf, len, sum2);
+        return adler32_copy_len_16(adler, NULL, buf, len, sum2, 0);
 
     const __m128i dot2v = _mm_setr_epi8(32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17);
     const __m128i dot2v_0 = _mm_setr_epi8(16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1);
@@ -150,7 +150,7 @@ unaligned_jmp:
     }
 
     /* Process tail (len < 16).  */
-    return adler32_len_16(adler, buf, len, sum2);
+    return adler32_copy_len_16(adler, NULL, buf, len, sum2, 0);
 }
 
 #endif