1 /* crc32.c -- compute the CRC-32 of a data stream
2 * Copyright (C) 1995-2022 Mark Adler
3 * For conditions of distribution and use, see copyright notice in zlib.h
5 * This interleaved implementation of a CRC makes use of pipelined multiple
6 * arithmetic-logic units, commonly found in modern CPU cores. It is due to
7 * Kadatch and Jenkins (2010). See doc/crc-doc.1.0.pdf in this distribution.
13 Note on the use of DYNAMIC_CRC_TABLE: there is no mutex or semaphore
14 protection on the static variables used to control the first-use generation
15 of the crc tables. Therefore, if you #define DYNAMIC_CRC_TABLE, you should
16 first call get_crc_table() to initialize the tables before allowing more than
17 one thread to use crc32().
19 MAKECRCH can be #defined to write out crc32.h. A main() routine is also
20 produced, so that this one source file can be compiled to an executable.
25 # ifndef DYNAMIC_CRC_TABLE
26 # define DYNAMIC_CRC_TABLE
27 # endif /* !DYNAMIC_CRC_TABLE */
30 #include "zutil.h" /* for Z_U4, Z_U8, z_crc_t, and FAR definitions */
33 A CRC of a message is computed on N braids of words in the message, where
34 each word consists of W bytes (4 or 8). If N is 3, for example, then three
35 running sparse CRCs are calculated respectively on each braid, at these
36 indices in the array of words: 0, 3, 6, ..., 1, 4, 7, ..., and 2, 5, 8, ...
37 This is done starting at a word boundary, and continues until as many blocks
38 of N * W bytes as are available have been processed. The results are combined
39 into a single CRC at the end. For this code, N must be in the range 1..6 and
40 W must be 4 or 8. The upper limit on N can be increased if desired by adding
41 more #if blocks, extending the patterns apparent in the code. In addition,
42 crc32.h would need to be regenerated, if the maximum N value is increased.
44 N and W are chosen empirically by benchmarking the execution time on a given
45 processor. The choices for N and W below were based on testing on Intel Kaby
46 Lake i7, AMD Ryzen 7, ARM Cortex-A57, Sparc64-VII, PowerPC POWER9, and MIPS64
47 Octeon II processors. The Intel, AMD, and ARM processors were all fastest
48 with N=5, W=8. The Sparc, PowerPC, and MIPS64 were all fastest at N=5, W=4.
49 They were all tested with either gcc or clang, all using the -O3 optimization
50 level. Your mileage may vary.
60 # error N must be in 1..6
64 z_crc_t must be at least 32 bits. z_word_t must be at least as long as
65 z_crc_t. It is assumed here that z_word_t is either 32 bits or 64 bits, and
66 that bytes are eight bits.
70 Define W and the associated z_word_t type. If W is not defined, then a
71 braided calculation is not used, and the associated tables and code are not
80 # define W 8 /* required for MAKECRCH */
82 # if defined(__x86_64__) || defined(__aarch64__)
90 # if W == 8 && defined(Z_U8)
91 typedef Z_U8 z_word_t;
95 typedef Z_U4 z_word_t;
101 /* If available, use the ARM processor CRC32 instruction. */
102 #if defined(__aarch64__) && defined(__ARM_FEATURE_CRC32) && W == 8
106 /* Local functions. */
107 local z_crc_t multmodp OF((z_crc_t a, z_crc_t b));
108 local z_crc_t x2nmodp OF((z_off64_t n, unsigned k));
110 #if defined(W) && (!defined(ARMCRC32) || defined(DYNAMIC_CRC_TABLE))
111 local z_word_t byte_swap OF((z_word_t word));
114 #if defined(W) && !defined(ARMCRC32)
115 local z_crc_t crc_word OF((z_word_t data));
116 local z_word_t crc_word_big OF((z_word_t data));
119 #if defined(W) && (!defined(ARMCRC32) || defined(DYNAMIC_CRC_TABLE))
121 Swap the bytes in a z_word_t to convert between little and big endian. Any
122 self-respecting compiler will optimize this to a single machine byte-swap
123 instruction, if one is available. This assumes that word_t is either 32 bits
126 local z_word_t byte_swap(word)
131 (word & 0xff00000000000000) >> 56 |
132 (word & 0xff000000000000) >> 40 |
133 (word & 0xff0000000000) >> 24 |
134 (word & 0xff00000000) >> 8 |
135 (word & 0xff000000) << 8 |
136 (word & 0xff0000) << 24 |
137 (word & 0xff00) << 40 |
141 (word & 0xff000000) >> 24 |
142 (word & 0xff0000) >> 8 |
143 (word & 0xff00) << 8 |
149 /* CRC polynomial. */
150 #define POLY 0xedb88320 /* p(x) reflected, with x^32 implied */
152 #ifdef DYNAMIC_CRC_TABLE
154 local z_crc_t FAR crc_table[256];
155 local z_crc_t FAR x2n_table[32];
156 local void make_crc_table OF((void));
158 local z_word_t FAR crc_big_table[256];
159 local z_crc_t FAR crc_braid_table[W][256];
160 local z_word_t FAR crc_braid_big_table[W][256];
161 local void braid OF((z_crc_t [][256], z_word_t [][256], int, int));
164 local void write_table OF((FILE *, const z_crc_t FAR *, int));
165 local void write_table32hi OF((FILE *, const z_word_t FAR *, int));
166 local void write_table64 OF((FILE *, const z_word_t FAR *, int));
167 #endif /* MAKECRCH */
170 Define a once() function depending on the availability of atomics. If this is
171 compiled with DYNAMIC_CRC_TABLE defined, and if CRCs will be computed in
172 multiple threads, and if atomics are not available, then get_crc_table() must
173 be called to initialize the tables and must return before any threads are
174 allowed to compute or combine CRCs.
177 /* Definition of once functionality. */
178 typedef struct once_s once_t;
179 local void once OF((once_t *, void (*)(void)));
181 /* Check for the availability of atomics. */
182 #if defined(__STDC__) && __STDC_VERSION__ >= 201112L && \
183 !defined(__STDC_NO_ATOMICS__)
185 #include <stdatomic.h>
187 /* Structure for once(), which must be initialized with ONCE_INIT. */
192 #define ONCE_INIT {ATOMIC_FLAG_INIT, 0}
195 Run the provided init() function exactly once, even if multiple threads
196 invoke once() at the same time. The state must be a once_t initialized with
199 local void once(state, init)
203 if (!atomic_load(&state->done)) {
204 if (atomic_flag_test_and_set(&state->begun))
205 while (!atomic_load(&state->done))
209 atomic_store(&state->done, 1);
214 #else /* no atomics */
216 /* Structure for once(), which must be initialized with ONCE_INIT. */
221 #define ONCE_INIT {0, 0}
223 /* Test and set. Alas, not atomic, but tries to minimize the period of
225 local int test_and_set OF((int volatile *));
226 local int test_and_set(flag)
236 /* Run the provided init() function once. This is not thread-safe. */
237 local void once(state, init)
242 if (test_and_set(&state->begun))
254 /* State for once(). */
255 local once_t made = ONCE_INIT;
258 Generate tables for a byte-wise 32-bit CRC calculation on the polynomial:
259 x^32+x^26+x^23+x^22+x^16+x^12+x^11+x^10+x^8+x^7+x^5+x^4+x^2+x+1.
261 Polynomials over GF(2) are represented in binary, one bit per coefficient,
262 with the lowest powers in the most significant bit. Then adding polynomials
263 is just exclusive-or, and multiplying a polynomial by x is a right shift by
264 one. If we call the above polynomial p, and represent a byte as the
265 polynomial q, also with the lowest power in the most significant bit (so the
266 byte 0xb1 is the polynomial x^7+x^3+x^2+1), then the CRC is (q*x^32) mod p,
267 where a mod b means the remainder after dividing a by b.
269 This calculation is done using the shift-register method of multiplying and
270 taking the remainder. The register is initialized to zero, and for each
271 incoming bit, x^32 is added mod p to the register if the bit is a one (where
272 x^32 mod p is p+x^32 = x^26+...+1), and the register is multiplied mod p by x
273 (which is shifting right by one and adding x^32 mod p if the bit shifted out
274 is a one). We start with the highest power (least significant bit) of q and
275 repeat for all eight bits of q.
277 The table is simply the CRC of all possible eight bit values. This is all the
278 information needed to generate CRCs on data a byte at a time for all
279 combinations of CRC register values and incoming bytes.
282 local void make_crc_table()
287 /* initialize the CRC of bytes tables */
288 for (i = 0; i < 256; i++) {
290 for (j = 0; j < 8; j++)
291 p = p & 1 ? (p >> 1) ^ POLY : p >> 1;
294 crc_big_table[i] = byte_swap(p);
298 /* initialize the x^2^n mod p(x) table */
299 p = (z_crc_t)1 << 30; /* x^1 */
301 for (n = 1; n < 32; n++)
302 x2n_table[n] = p = multmodp(p, p);
305 /* initialize the braiding tables -- needs x2n_table[] */
306 braid(crc_braid_table, crc_braid_big_table, N, W);
312 The crc32.h header file contains tables for both 32-bit and 64-bit
313 z_word_t's, and so requires a 64-bit type be available. In that case,
314 z_word_t must be defined to be 64-bits. This code then also generates
315 and writes out the tables for the case that z_word_t is 32 bits.
317 #if !defined(W) || W != 8
318 # error Need a 64-bit integer type in order to generate crc32.h.
323 z_word_t big[8][256];
325 out = fopen("crc32.h", "w");
326 if (out == NULL) return;
328 /* write out little-endian CRC table to crc32.h */
330 "/* crc32.h -- tables for rapid CRC calculation\n"
331 " * Generated automatically by crc32.c\n */\n"
333 "local const z_crc_t FAR crc_table[] = {\n"
335 write_table(out, crc_table, 256);
339 /* write out big-endian CRC table for 64-bit z_word_t to crc32.h */
346 "local const z_word_t FAR crc_big_table[] = {\n"
348 write_table64(out, crc_big_table, 256);
352 /* write out big-endian CRC table for 32-bit z_word_t to crc32.h */
355 "#else /* W == 4 */\n"
357 "local const z_word_t FAR crc_big_table[] = {\n"
359 write_table32hi(out, crc_big_table, 256);
365 /* write out braid tables for each value of N */
366 for (n = 1; n <= 6; n++) {
371 /* compute braid tables for this N and 64-bit word_t */
372 braid(ltl, big, n, 8);
374 /* write out braid tables for 64-bit z_word_t to crc32.h */
379 "local const z_crc_t FAR crc_braid_table[][256] = {\n");
380 for (k = 0; k < 8; k++) {
382 write_table(out, ltl[k], 256);
383 fprintf(out, "}%s", k < 7 ? ",\n" : "");
388 "local const z_word_t FAR crc_braid_big_table[][256] = {\n");
389 for (k = 0; k < 8; k++) {
391 write_table64(out, big[k], 256);
392 fprintf(out, "}%s", k < 7 ? ",\n" : "");
397 /* compute braid tables for this N and 32-bit word_t */
398 braid(ltl, big, n, 4);
400 /* write out braid tables for 32-bit z_word_t to crc32.h */
403 "#else /* W == 4 */\n"
405 "local const z_crc_t FAR crc_braid_table[][256] = {\n");
406 for (k = 0; k < 4; k++) {
408 write_table(out, ltl[k], 256);
409 fprintf(out, "}%s", k < 3 ? ",\n" : "");
414 "local const z_word_t FAR crc_braid_big_table[][256] = {\n");
415 for (k = 0; k < 4; k++) {
417 write_table32hi(out, big[k], 256);
418 fprintf(out, "}%s", k < 3 ? ",\n" : "");
431 /* write out zeros operator table to crc32.h */
434 "local const z_crc_t FAR x2n_table[] = {\n"
436 write_table(out, x2n_table, 32);
441 #endif /* MAKECRCH */
447 Write the 32-bit values in table[0..k-1] to out, five per line in
448 hexadecimal separated by commas.
450 local void write_table(out, table, k)
452 const z_crc_t FAR *table;
457 for (n = 0; n < k; n++)
458 fprintf(out, "%s0x%08lx%s", n == 0 || n % 5 ? "" : " ",
459 (unsigned long)(table[n]),
460 n == k - 1 ? "" : (n % 5 == 4 ? ",\n" : ", "));
464 Write the high 32-bits of each value in table[0..k-1] to out, five per line
465 in hexadecimal separated by commas.
467 local void write_table32hi(out, table, k)
469 const z_word_t FAR *table;
474 for (n = 0; n < k; n++)
475 fprintf(out, "%s0x%08lx%s", n == 0 || n % 5 ? "" : " ",
476 (unsigned long)(table[n] >> 32),
477 n == k - 1 ? "" : (n % 5 == 4 ? ",\n" : ", "));
481 Write the 64-bit values in table[0..k-1] to out, three per line in
482 hexadecimal separated by commas. This assumes that if there is a 64-bit
483 type, then there is also a long long integer type, and it is at least 64
484 bits. If not, then the type cast and format string can be adjusted
487 local void write_table64(out, table, k)
489 const z_word_t FAR *table;
494 for (n = 0; n < k; n++)
495 fprintf(out, "%s0x%016llx%s", n == 0 || n % 3 ? "" : " ",
496 (unsigned long long)(table[n]),
497 n == k - 1 ? "" : (n % 3 == 2 ? ",\n" : ", "));
500 /* Actually do the deed. */
507 #endif /* MAKECRCH */
511 Generate the little and big-endian braid tables for the given n and z_word_t
512 size w. Each array must have room for w blocks of 256 elements.
514 local void braid(ltl, big, n, w)
522 for (k = 0; k < w; k++) {
523 p = x2nmodp((n * w + 3 - k) << 3, 0);
525 big[w - 1 - k][0] = 0;
526 for (i = 1; i < 256; i++) {
527 ltl[k][i] = q = multmodp(i << 24, p);
528 big[w - 1 - k][i] = byte_swap(q);
534 #else /* !DYNAMIC_CRC_TABLE */
535 /* ========================================================================
536 * Tables for byte-wise and braided CRC-32 calculations, and a table of powers
537 * of x for combining CRC-32s, all made by make_crc_table().
540 #endif /* DYNAMIC_CRC_TABLE */
542 /* ========================================================================
543 * Routines used for CRC calculation. Some are also required for the table
548 Return a(x) multiplied by b(x) modulo p(x), where p(x) is the CRC polynomial,
549 reflected. For speed, this requires that a not be zero.
551 local z_crc_t multmodp(a, b)
557 m = (z_crc_t)1 << 31;
562 if ((a & (m - 1)) == 0)
566 b = b & 1 ? (b >> 1) ^ POLY : b >> 1;
572 Return x^(n * 2^k) modulo p(x). Requires that x2n_table[] has been
575 local z_crc_t x2nmodp(n, k)
581 p = (z_crc_t)1 << 31; /* x^0 == 1 */
584 p = multmodp(x2n_table[k & 31], p);
591 /* =========================================================================
592 * This function can be used by asm versions of crc32(), and to force the
593 * generation of the CRC tables in a threaded application.
595 const z_crc_t FAR * ZEXPORT get_crc_table()
597 #ifdef DYNAMIC_CRC_TABLE
598 once(&made, make_crc_table);
599 #endif /* DYNAMIC_CRC_TABLE */
600 return (const z_crc_t FAR *)crc_table;
603 /* =========================================================================
604 * Use ARM machine instructions if available. This will compute the CRC about
605 * ten times faster than the braided calculation. This code does not check for
606 * the presence of the CRC instruction at run time. __ARM_FEATURE_CRC32 will
607 * only be defined if the compilation specifies an ARM processor architecture
608 * that has the instructions. For example, compiling with -march=armv8.1-a or
609 * -march=armv8-a+crc, or -march=native if the compile machine has the crc32
615 Constants empirically determined to maximize speed. These values are from
616 measurements on a Cortex-A57. Your mileage may vary.
618 #define Z_BATCH 3990 /* number of words in a batch */
619 #define Z_BATCH_ZEROS 0xa10d3d0c /* computed from Z_BATCH = 3990 */
620 #define Z_BATCH_MIN 800 /* fewest words in a final batch */
622 unsigned long ZEXPORT crc32_z(crc, buf, len)
624 const unsigned char FAR *buf;
629 const z_word_t *word;
630 z_word_t val0, val1, val2;
631 z_size_t last, last2, i;
634 /* Return initial CRC, if requested. */
635 if (buf == Z_NULL) return 0;
637 #ifdef DYNAMIC_CRC_TABLE
638 once(&made, make_crc_table);
639 #endif /* DYNAMIC_CRC_TABLE */
641 /* Pre-condition the CRC */
642 crc = (~crc) & 0xffffffff;
644 /* Compute the CRC up to a word boundary. */
645 while (len && ((z_size_t)buf & 7) != 0) {
648 __asm__ volatile("crc32b %w0, %w0, %w1" : "+r"(crc) : "r"(val));
651 /* Prepare to compute the CRC on full 64-bit words word[0..num-1]. */
652 word = (z_word_t const *)buf;
656 /* Do three interleaved CRCs to realize the throughput of one crc32x
657 instruction per cycle. Each CRC is calculated on Z_BATCH words. The
658 three CRCs are combined into a single CRC after each set of batches. */
659 while (num >= 3 * Z_BATCH) {
662 for (i = 0; i < Z_BATCH; i++) {
664 val1 = word[i + Z_BATCH];
665 val2 = word[i + 2 * Z_BATCH];
666 __asm__ volatile("crc32x %w0, %w0, %x1" : "+r"(crc) : "r"(val0));
667 __asm__ volatile("crc32x %w0, %w0, %x1" : "+r"(crc1) : "r"(val1));
668 __asm__ volatile("crc32x %w0, %w0, %x1" : "+r"(crc2) : "r"(val2));
672 crc = multmodp(Z_BATCH_ZEROS, crc) ^ crc1;
673 crc = multmodp(Z_BATCH_ZEROS, crc) ^ crc2;
676 /* Do one last smaller batch with the remaining words, if there are enough
677 to pay for the combination of CRCs. */
679 if (last >= Z_BATCH_MIN) {
683 for (i = 0; i < last; i++) {
685 val1 = word[i + last];
686 val2 = word[i + last2];
687 __asm__ volatile("crc32x %w0, %w0, %x1" : "+r"(crc) : "r"(val0));
688 __asm__ volatile("crc32x %w0, %w0, %x1" : "+r"(crc1) : "r"(val1));
689 __asm__ volatile("crc32x %w0, %w0, %x1" : "+r"(crc2) : "r"(val2));
693 val = x2nmodp(last, 6);
694 crc = multmodp(val, crc) ^ crc1;
695 crc = multmodp(val, crc) ^ crc2;
698 /* Compute the CRC on any remaining words. */
699 for (i = 0; i < num; i++) {
701 __asm__ volatile("crc32x %w0, %w0, %x1" : "+r"(crc) : "r"(val0));
705 /* Complete the CRC on any remaining bytes. */
706 buf = (const unsigned char FAR *)word;
710 __asm__ volatile("crc32b %w0, %w0, %w1" : "+r"(crc) : "r"(val));
713 /* Return the CRC, post-conditioned. */
714 return crc ^ 0xffffffff;
722 Return the CRC of the W bytes in the word_t data, taking the
723 least-significant byte of the word as the first byte of data, without any pre
724 or post conditioning. This is used to combine the CRCs of each braid.
726 local z_crc_t crc_word(data)
730 for (k = 0; k < W; k++)
731 data = (data >> 8) ^ crc_table[data & 0xff];
732 return (z_crc_t)data;
735 local z_word_t crc_word_big(data)
739 for (k = 0; k < W; k++)
741 crc_big_table[(data >> ((W - 1) << 3)) & 0xff];
747 /* ========================================================================= */
748 unsigned long ZEXPORT crc32_z(crc, buf, len)
750 const unsigned char FAR *buf;
753 /* Return initial CRC, if requested. */
754 if (buf == Z_NULL) return 0;
756 #ifdef DYNAMIC_CRC_TABLE
757 once(&made, make_crc_table);
758 #endif /* DYNAMIC_CRC_TABLE */
760 /* Pre-condition the CRC */
761 crc = (~crc) & 0xffffffff;
765 /* If provided enough bytes, do a braided CRC calculation. */
766 if (len >= N * W + W - 1) {
768 z_word_t const *words;
772 /* Compute the CRC up to a z_word_t boundary. */
773 while (len && ((z_size_t)buf & (W - 1)) != 0) {
775 crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff];
778 /* Compute the CRC on as many N z_word_t blocks as are available. */
779 blks = len / (N * W);
781 words = (z_word_t const *)buf;
783 /* Do endian check at execution time instead of compile time, since ARM
784 processors can change the endianess at execution time. If the
785 compiler knows what the endianess will be, it can optimize out the
786 check and the unused branch. */
788 if (*(unsigned char *)&endian) {
814 /* Initialize the CRC for each braid. */
833 Process the first blks-1 blocks, computing the CRCs on each braid
837 /* Load the word for each braid into registers. */
838 word0 = crc0 ^ words[0];
840 word1 = crc1 ^ words[1];
842 word2 = crc2 ^ words[2];
844 word3 = crc3 ^ words[3];
846 word4 = crc4 ^ words[4];
848 word5 = crc5 ^ words[5];
856 /* Compute and update the CRC for each word. The loop should
858 crc0 = crc_braid_table[0][word0 & 0xff];
860 crc1 = crc_braid_table[0][word1 & 0xff];
862 crc2 = crc_braid_table[0][word2 & 0xff];
864 crc3 = crc_braid_table[0][word3 & 0xff];
866 crc4 = crc_braid_table[0][word4 & 0xff];
868 crc5 = crc_braid_table[0][word5 & 0xff];
874 for (k = 1; k < W; k++) {
875 crc0 ^= crc_braid_table[k][(word0 >> (k << 3)) & 0xff];
877 crc1 ^= crc_braid_table[k][(word1 >> (k << 3)) & 0xff];
879 crc2 ^= crc_braid_table[k][(word2 >> (k << 3)) & 0xff];
881 crc3 ^= crc_braid_table[k][(word3 >> (k << 3)) & 0xff];
883 crc4 ^= crc_braid_table[k][(word4 >> (k << 3)) & 0xff];
885 crc5 ^= crc_braid_table[k][(word5 >> (k << 3)) & 0xff];
895 Process the last block, combining the CRCs of the N braids at the
898 crc = crc_word(crc0 ^ words[0]);
900 crc = crc_word(crc1 ^ words[1] ^ crc);
902 crc = crc_word(crc2 ^ words[2] ^ crc);
904 crc = crc_word(crc3 ^ words[3] ^ crc);
906 crc = crc_word(crc4 ^ words[4] ^ crc);
908 crc = crc_word(crc5 ^ words[5] ^ crc);
919 z_word_t crc0, word0, comb;
921 z_word_t crc1, word1;
923 z_word_t crc2, word2;
925 z_word_t crc3, word3;
927 z_word_t crc4, word4;
929 z_word_t crc5, word5;
936 /* Initialize the CRC for each braid. */
937 crc0 = byte_swap(crc);
955 Process the first blks-1 blocks, computing the CRCs on each braid
959 /* Load the word for each braid into registers. */
960 word0 = crc0 ^ words[0];
962 word1 = crc1 ^ words[1];
964 word2 = crc2 ^ words[2];
966 word3 = crc3 ^ words[3];
968 word4 = crc4 ^ words[4];
970 word5 = crc5 ^ words[5];
978 /* Compute and update the CRC for each word. The loop should
980 crc0 = crc_braid_big_table[0][word0 & 0xff];
982 crc1 = crc_braid_big_table[0][word1 & 0xff];
984 crc2 = crc_braid_big_table[0][word2 & 0xff];
986 crc3 = crc_braid_big_table[0][word3 & 0xff];
988 crc4 = crc_braid_big_table[0][word4 & 0xff];
990 crc5 = crc_braid_big_table[0][word5 & 0xff];
996 for (k = 1; k < W; k++) {
997 crc0 ^= crc_braid_big_table[k][(word0 >> (k << 3)) & 0xff];
999 crc1 ^= crc_braid_big_table[k][(word1 >> (k << 3)) & 0xff];
1001 crc2 ^= crc_braid_big_table[k][(word2 >> (k << 3)) & 0xff];
1003 crc3 ^= crc_braid_big_table[k][(word3 >> (k << 3)) & 0xff];
1005 crc4 ^= crc_braid_big_table[k][(word4 >> (k << 3)) & 0xff];
1007 crc5 ^= crc_braid_big_table[k][(word5 >> (k << 3)) & 0xff];
1017 Process the last block, combining the CRCs of the N braids at the
1020 comb = crc_word_big(crc0 ^ words[0]);
1022 comb = crc_word_big(crc1 ^ words[1] ^ comb);
1024 comb = crc_word_big(crc2 ^ words[2] ^ comb);
1026 comb = crc_word_big(crc3 ^ words[3] ^ comb);
1028 comb = crc_word_big(crc4 ^ words[4] ^ comb);
1030 comb = crc_word_big(crc5 ^ words[5] ^ comb);
1037 crc = byte_swap(comb);
1041 Update the pointer to the remaining bytes to process.
1043 buf = (unsigned char const *)words;
1048 /* Complete the computation of the CRC on any remaining bytes. */
1051 crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff];
1052 crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff];
1053 crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff];
1054 crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff];
1055 crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff];
1056 crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff];
1057 crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff];
1058 crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff];
1062 crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff];
1065 /* Return the CRC, post-conditioned. */
1066 return crc ^ 0xffffffff;
1071 /* ========================================================================= */
1072 unsigned long ZEXPORT crc32(crc, buf, len)
1074 const unsigned char FAR *buf;
1077 return crc32_z(crc, buf, len);
1080 /* ========================================================================= */
1081 uLong ZEXPORT crc32_combine64(crc1, crc2, len2)
1086 #ifdef DYNAMIC_CRC_TABLE
1087 once(&made, make_crc_table);
1088 #endif /* DYNAMIC_CRC_TABLE */
1089 return multmodp(x2nmodp(len2, 3), crc1) ^ (crc2 & 0xffffffff);
1092 /* ========================================================================= */
1093 uLong ZEXPORT crc32_combine(crc1, crc2, len2)
1098 return crc32_combine64(crc1, crc2, (z_off64_t)len2);
1101 /* ========================================================================= */
1102 uLong ZEXPORT crc32_combine_gen64(len2)
1105 #ifdef DYNAMIC_CRC_TABLE
1106 once(&made, make_crc_table);
1107 #endif /* DYNAMIC_CRC_TABLE */
1108 return x2nmodp(len2, 3);
1111 /* ========================================================================= */
1112 uLong ZEXPORT crc32_combine_gen(len2)
1115 return crc32_combine_gen64((z_off64_t)len2);
1118 /* ========================================================================= */
1119 uLong ZEXPORT crc32_combine_op(crc1, crc2, op)
1124 return multmodp(op, crc1) ^ (crc2 & 0xffffffff);