Revert "[zlib] Re-sync with zlib 1.2.12, patch 13 of N"

This reverts commit 096d2447f2fdecf9693db32ba50858d5e31cca34.

Reason for revert:
Findit (https://goo.gl/kROfz5) identified this CL at revision 096d2447f2fdecf9693db32ba50858d5e31cca34 as
the culprit for failures in the continuous build including:

Sample Failed Build: https://ci.chromium.org/b/8815840511093637041
Sample Failed Step: compile

If it is a false positive, please report it at https://bugs.chromium.org/p/chromium/issues/entry?status=Available&comment=Datastore+key+for+the+culprit+entity%3A+chromium.googlesource.com%2Fchromium%2Fsrc%2Frefs%2Fheads%2Fmain%2F096d2447f2fdecf9693db32ba50858d5e31cca34&labels=Test-Findit-Wrong&components=Tools%3ETest%3EFindIt&summary=Wrongly+blame+096d2447f2fdecf9693db32ba50858d5e31cca34

Original change's description:
> [zlib] Re-sync with zlib 1.2.12, patch 13 of N
>
> Ported:
> - Add use of the ARMv8 crc32 instructions when requested.
> - Use ARM crc32 instructions if the ARM architecture has them.
> - Explicitly note that the 32-bit check values are 32 bits.
>
> Bug: 1032721
> Change-Id: Ic988198b20de6f59c5fbcd3d37a33d2594380b28
> Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/3607170
> Reviewed-by: Noel Gordon <noel@chromium.org>
> Commit-Queue: Adenilson Cavalcanti <cavalcantii@chromium.org>
> Cr-Commit-Position: refs/heads/main@{#996030}

Change-Id: Ic2edd4bdc8c8f5538414ce8e71b8666e271752df
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: 1032721
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/3607182
Reviewed-by: Christopher Lam <calamity@chromium.org>
Commit-Queue: Christopher Lam <calamity@chromium.org>
Owners-Override: Christopher Lam <calamity@chromium.org>
Cr-Commit-Position: refs/heads/main@{#996033}
NOKEYCHECK=True
GitOrigin-RevId: 7acb20d251cd57c13e3f04fa41be7b9c83d06d5e
diff --git a/crc32.c b/crc32.c
index 2864c24..ee8d472 100644
--- a/crc32.c
+++ b/crc32.c
@@ -622,122 +622,6 @@
     return (const z_crc_t FAR *)crc_table;
 }
 
-/* =========================================================================
- * Use ARM machine instructions if available. This will compute the CRC about
- * ten times faster than the braided calculation. This code does not check for
- * the presence of the CRC instruction at run time. __ARM_FEATURE_CRC32 will
- * only be defined if the compilation specifies an ARM processor architecture
- * that has the instructions. For example, compiling with -march=armv8.1-a or
- * -march=armv8-a+crc, or -march=native if the compile machine has the crc32
- * instructions.
- */
-#if defined(__aarch64__) && defined(__ARM_FEATURE_CRC32) && W == 8
-
-/*
-   Constants empirically determined to maximize speed. These values are from
-   measurements on a Cortex-A57. Your mileage may vary.
- */
-#define Z_BATCH 3990                /* number of words in a batch */
-#define Z_BATCH_ZEROS 0xa10d3d0c    /* computed from Z_BATCH = 3990 */
-#define Z_BATCH_MIN 800             /* fewest words in a final batch */
-
-unsigned long ZEXPORT crc32_z(crc, buf, len)
-    unsigned long crc;
-    const unsigned char FAR *buf;
-    z_size_t len;
-{
-    z_crc_t val;
-    z_word_t crc1, crc2;
-    const z_word_t *word;
-    z_word_t val0, val1, val2;
-    z_size_t last, last2, i;
-    z_size_t num;
-
-    /* Return initial CRC, if requested. */
-    if (buf == Z_NULL) return 0;
-
-#ifdef DYNAMIC_CRC_TABLE
-    once(&made, make_crc_table);
-#endif /* DYNAMIC_CRC_TABLE */
-
-    /* Pre-condition the CRC */
-    crc ^= 0xffffffff;
-
-    /* Compute the CRC up to a word boundary. */
-    while (len && ((z_size_t)buf & 7) != 0) {
-        len--;
-        val = *buf++;
-        __asm__ volatile("crc32b %w0, %w0, %w1" : "+r"(crc) : "r"(val));
-    }
-
-    /* Prepare to compute the CRC on full 64-bit words word[0..num-1]. */
-    word = (z_word_t const *)buf;
-    num = len >> 3;
-    len &= 7;
-
-    /* Do three interleaved CRCs to realize the throughput of one crc32x
-       instruction per cycle. Each CRC is calcuated on Z_BATCH words. The three
-       CRCs are combined into a single CRC after each set of batches. */
-    while (num >= 3 * Z_BATCH) {
-        crc1 = 0;
-        crc2 = 0;
-        for (i = 0; i < Z_BATCH; i++) {
-            val0 = word[i];
-            val1 = word[i + Z_BATCH];
-            val2 = word[i + 2 * Z_BATCH];
-            __asm__ volatile("crc32x %w0, %w0, %x1" : "+r"(crc) : "r"(val0));
-            __asm__ volatile("crc32x %w0, %w0, %x1" : "+r"(crc1) : "r"(val1));
-            __asm__ volatile("crc32x %w0, %w0, %x1" : "+r"(crc2) : "r"(val2));
-        }
-        word += 3 * Z_BATCH;
-        num -= 3 * Z_BATCH;
-        crc = multmodp(Z_BATCH_ZEROS, crc) ^ crc1;
-        crc = multmodp(Z_BATCH_ZEROS, crc) ^ crc2;
-    }
-
-    /* Do one last smaller batch with the remaining words, if there are enough
-       to pay for the combination of CRCs. */
-    last = num / 3;
-    if (last >= Z_BATCH_MIN) {
-        last2 = last << 1;
-        crc1 = 0;
-        crc2 = 0;
-        for (i = 0; i < last; i++) {
-            val0 = word[i];
-            val1 = word[i + last];
-            val2 = word[i + last2];
-            __asm__ volatile("crc32x %w0, %w0, %x1" : "+r"(crc) : "r"(val0));
-            __asm__ volatile("crc32x %w0, %w0, %x1" : "+r"(crc1) : "r"(val1));
-            __asm__ volatile("crc32x %w0, %w0, %x1" : "+r"(crc2) : "r"(val2));
-        }
-        word += 3 * last;
-        num -= 3 * last;
-        val = x2nmodp(last, 6);
-        crc = multmodp(val, crc) ^ crc1;
-        crc = multmodp(val, crc) ^ crc2;
-    }
-
-    /* Compute the CRC on any remaining words. */
-    for (i = 0; i < num; i++) {
-        val0 = word[i];
-        __asm__ volatile("crc32x %w0, %w0, %x1" : "+r"(crc) : "r"(val0));
-    }
-    word += num;
-
-    /* Complete the CRC on any remaining bytes. */
-    buf = (const unsigned char FAR *)word;
-    while (len) {
-        len--;
-        val = *buf++;
-        __asm__ volatile("crc32b %w0, %w0, %w1" : "+r"(crc) : "r"(val));
-    }
-
-    /* Return the CRC, post-conditioned. */
-    return crc ^ 0xffffffff;
-}
-
-#else
-
 /* ========================================================================= */
 unsigned long ZEXPORT crc32_z(crc, buf, len)
     unsigned long crc;
@@ -1090,8 +974,6 @@
     return crc ^ 0xffffffff;
 }
 
-#endif
-
 /* ========================================================================= */
 unsigned long ZEXPORT crc32(crc, buf, len)
     unsigned long crc;
diff --git a/zlib.h b/zlib.h
index 88961b9..a176f93 100644
--- a/zlib.h
+++ b/zlib.h
@@ -1690,9 +1690,8 @@
 ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len));
 /*
      Update a running Adler-32 checksum with the bytes buf[0..len-1] and
-   return the updated checksum. An Adler-32 value is in the range of a 32-bit
-   unsigned integer. If buf is Z_NULL, this function returns the required
-   initial value for the checksum.
+   return the updated checksum.  If buf is Z_NULL, this function returns the
+   required initial value for the checksum.
 
      An Adler-32 checksum is almost as reliable as a CRC-32 but can be computed
    much faster.
@@ -1728,10 +1727,9 @@
 ZEXTERN uLong ZEXPORT crc32 OF((uLong crc, const Bytef *buf, uInt len));
 /*
      Update a running CRC-32 with the bytes buf[0..len-1] and return the
-   updated CRC-32. A CRC-32 value is in the range of a 32-bit unsigned integer.
-   If buf is Z_NULL, this function returns the required initial value for the
-   crc. Pre- and post-conditioning (one's complement) is performed within this
-   function so it shouldn't be done by the application.
+   updated CRC-32.  If buf is Z_NULL, this function returns the required
+   initial value for the crc.  Pre- and post-conditioning (one's complement) is
+   performed within this function so it shouldn't be done by the application.
 
    Usage example: