Move DO* macro definitions to adler32_p.h

Add new generic definitions of DO* macros used by adler32 algorithms to
adler32_p.h to allow reuse by other adler32 implementations.

diff --git a/adler32.c b/adler32.c
index 30d888635761175c6b0eb355e6f3923d6edff2fa..84d4d6663674db87b46e4bed873b9880366acd06 100644 (file)
--- a/adler32.c
+++ b/adler32.c
@@ -11,12 +11,6 @@
 uint32_t adler32_c(uint32_t adler, const unsigned char *buf, size_t len);
 static uint32_t adler32_combine_(uint32_t adler1, uint32_t adler2, z_off64_t len2);
 
-#define DO1(buf, i)  {adler += (buf)[i]; sum2 += adler;}
-#define DO2(buf, i)  DO1(buf, i); DO1(buf, i+1);
-#define DO4(buf, i)  DO2(buf, i); DO2(buf, i+2);
-#define DO8(buf, i)  DO4(buf, i); DO4(buf, i+4);
-#define DO16(buf)    DO8(buf, 0); DO8(buf, 8);
-
 /* ========================================================================= */
 uint32_t adler32_c(uint32_t adler, const unsigned char *buf, size_t len) {
     uint32_t sum2;
@@ -48,10 +42,10 @@ uint32_t adler32_c(uint32_t adler, const unsigned char *buf, size_t len) {
 #endif
         do {
 #ifdef UNROLL_MORE
-            DO16(buf);          /* 16 sums unrolled */
+            DO16(adler, sum2, buf);          /* 16 sums unrolled */
             buf += 16;
 #else
-            DO8(buf, 0);         /* 8 sums unrolled */
+            DO8(adler, sum2, buf, 0);         /* 8 sums unrolled */
             buf += 8;
 #endif
         } while (--n);
@@ -64,12 +58,12 @@ uint32_t adler32_c(uint32_t adler, const unsigned char *buf, size_t len) {
 #ifdef UNROLL_MORE
         while (len >= 16) {
             len -= 16;
-            DO16(buf);
+            DO16(adler, sum2, buf);
             buf += 16;
 #else
         while (len >= 8) {
             len -= 8;
-            DO8(buf, 0);
+            DO8(adler, sum2, buf, 0);
             buf += 8;
 #endif
         }

diff --git a/adler32_p.h b/adler32_p.h
index 6766530408e14b3e0a532cdfe55320fa3b01237e..2e6c05e521c4f66b2ac3494e5629814074fd6108 100644 (file)
--- a/adler32_p.h
+++ b/adler32_p.h
@@ -12,6 +12,12 @@
 #define NMAX 5552
 /* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */
 
+#define DO1(sum1, sum2, buf, i)  {(sum1) += buf[(i)]; (sum2) += (sum1);}
+#define DO2(sum1, sum2, buf, i)  {DO1(sum1, sum2, buf, i); DO1(sum1, sum2, buf, i+1);}
+#define DO4(sum1, sum2, buf, i)  {DO2(sum1, sum2, buf, i); DO2(sum1, sum2, buf, i+2);}
+#define DO8(sum1, sum2, buf, i)  {DO4(sum1, sum2, buf, i); DO4(sum1, sum2, buf, i+4);}
+#define DO16(sum1, sum2, buf)    {DO8(sum1, sum2, buf, 0); DO8(sum1, sum2, buf, 8);}
+
 /* use NO_DIVIDE if your processor does not do division in hardware --
    try it both ways to see which is faster */
 #ifdef NO_DIVIDE

diff --git a/arch/power/adler32_power8.c b/arch/power/adler32_power8.c
index 3f74f0d172b8e767c89748ea353c1c3b15779e6d..41b4ed9700b8934d3140578ac792821b462953f4 100644 (file)
--- a/arch/power/adler32_power8.c
+++ b/arch/power/adler32_power8.c
@@ -43,12 +43,6 @@
 #include "zutil.h"
 #include "adler32_p.h"
 
-#define DO1(s1,s2,buf,i)  {(s1) += buf[(i)]; (s2) += (s1);}
-#define DO2(s1,s2,buf,i)  {DO1(s1,s2,buf,i); DO1(s1,s2,buf,i+1);}
-#define DO4(s1,s2,buf,i)  {DO2(s1,s2,buf,i); DO2(s1,s2,buf,i+2);}
-#define DO8(s1,s2,buf,i)  {DO4(s1,s2,buf,i); DO4(s1,s2,buf,i+4);}
-#define DO16(s1,s2,buf)   {DO8(s1,s2,buf,0); DO8(s1,s2,buf,8);}
-
 /* Vector across sum unsigned int (saturate).  */
 inline vector unsigned int vec_sumsu(vector unsigned int __a, vector unsigned int __b) {
     __b = vec_sld(__a, __a, 8);