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 /* Local functions. */
102 local z_crc_t multmodp OF((z_crc_t a, z_crc_t b));
103 local z_crc_t x2nmodp OF((z_off64_t n, unsigned k));
105 /* If available, use the ARM processor CRC32 instruction. */
106 #if defined(__aarch64__) && defined(__ARM_FEATURE_CRC32) && W == 8
110 #if defined(W) && (!defined(ARMCRC32) || defined(DYNAMIC_CRC_TABLE))
112 Swap the bytes in a z_word_t to convert between little and big endian. Any
113 self-respecting compiler will optimize this to a single machine byte-swap
114 instruction, if one is available. This assumes that word_t is either 32 bits
117 local z_word_t byte_swap OF((z_word_t word));
119 local z_word_t byte_swap(word)
124 (word & 0xff00000000000000) >> 56 |
125 (word & 0xff000000000000) >> 40 |
126 (word & 0xff0000000000) >> 24 |
127 (word & 0xff00000000) >> 8 |
128 (word & 0xff000000) << 8 |
129 (word & 0xff0000) << 24 |
130 (word & 0xff00) << 40 |
134 (word & 0xff000000) >> 24 |
135 (word & 0xff0000) >> 8 |
136 (word & 0xff00) << 8 |
142 /* CRC polynomial. */
143 #define POLY 0xedb88320 /* p(x) reflected, with x^32 implied */
145 #ifdef DYNAMIC_CRC_TABLE
147 local z_crc_t FAR crc_table[256];
148 local z_crc_t FAR x2n_table[32];
149 local void make_crc_table OF((void));
151 local z_word_t FAR crc_big_table[256];
152 local z_crc_t FAR crc_braid_table[W][256];
153 local z_word_t FAR crc_braid_big_table[W][256];
154 local void braid OF((z_crc_t [][256], z_word_t [][256], int, int));
157 local void write_table OF((FILE *, const z_crc_t FAR *, int));
158 local void write_table32hi OF((FILE *, const z_word_t FAR *, int));
159 local void write_table64 OF((FILE *, const z_word_t FAR *, int));
160 #endif /* MAKECRCH */
163 Define a once() function depending on the availability of atomics. If this is
164 compiled with DYNAMIC_CRC_TABLE defined, and if CRCs will be computed in
165 multiple threads, and if atomics are not available, then get_crc_table() must
166 be called to initialize the tables and must return before any threads are
167 allowed to compute or combine CRCs.
170 /* Definition of once functionality. */
171 typedef struct once_s once_t;
172 local void once OF((once_t *, void (*)(void)));
174 /* Check for the availability of atomics. */
175 #if defined(__STDC__) && __STDC_VERSION__ >= 201112L && \
176 !defined(__STDC_NO_ATOMICS__)
178 #include <stdatomic.h>
180 /* Structure for once(), which must be initialized with ONCE_INIT. */
185 #define ONCE_INIT {ATOMIC_FLAG_INIT, 0}
188 Run the provided init() function exactly once, even if multiple threads
189 invoke once() at the same time. The state must be a once_t initialized with
192 local void once(state, init)
196 if (!atomic_load(&state->done)) {
197 if (atomic_flag_test_and_set(&state->begun))
198 while (!atomic_load(&state->done))
202 atomic_store(&state->done, 1);
207 #else /* no atomics */
209 /* Structure for once(), which must be initialized with ONCE_INIT. */
214 #define ONCE_INIT {0, 0}
216 /* Test and set. Alas, not atomic, but tries to minimize the period of
218 local int test_and_set OF((int volatile *));
219 local int test_and_set(flag)
229 /* Run the provided init() function once. This is not thread-safe. */
230 local void once(state, init)
235 if (test_and_set(&state->begun))
247 /* State for once(). */
248 local once_t made = ONCE_INIT;
251 Generate tables for a byte-wise 32-bit CRC calculation on the polynomial:
252 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.
254 Polynomials over GF(2) are represented in binary, one bit per coefficient,
255 with the lowest powers in the most significant bit. Then adding polynomials
256 is just exclusive-or, and multiplying a polynomial by x is a right shift by
257 one. If we call the above polynomial p, and represent a byte as the
258 polynomial q, also with the lowest power in the most significant bit (so the
259 byte 0xb1 is the polynomial x^7+x^3+x^2+1), then the CRC is (q*x^32) mod p,
260 where a mod b means the remainder after dividing a by b.
262 This calculation is done using the shift-register method of multiplying and
263 taking the remainder. The register is initialized to zero, and for each
264 incoming bit, x^32 is added mod p to the register if the bit is a one (where
265 x^32 mod p is p+x^32 = x^26+...+1), and the register is multiplied mod p by x
266 (which is shifting right by one and adding x^32 mod p if the bit shifted out
267 is a one). We start with the highest power (least significant bit) of q and
268 repeat for all eight bits of q.
270 The table is simply the CRC of all possible eight bit values. This is all the
271 information needed to generate CRCs on data a byte at a time for all
272 combinations of CRC register values and incoming bytes.
275 local void make_crc_table()
280 /* initialize the CRC of bytes tables */
281 for (i = 0; i < 256; i++) {
283 for (j = 0; j < 8; j++)
284 p = p & 1 ? (p >> 1) ^ POLY : p >> 1;
287 crc_big_table[i] = byte_swap(p);
291 /* initialize the x^2^n mod p(x) table */
292 p = (z_crc_t)1 << 30; /* x^1 */
294 for (n = 1; n < 32; n++)
295 x2n_table[n] = p = multmodp(p, p);
298 /* initialize the braiding tables -- needs x2n_table[] */
299 braid(crc_braid_table, crc_braid_big_table, N, W);
305 The crc32.h header file contains tables for both 32-bit and 64-bit
306 z_word_t's, and so requires a 64-bit type be available. In that case,
307 z_word_t must be defined to be 64-bits. This code then also generates
308 and writes out the tables for the case that z_word_t is 32 bits.
310 #if !defined(W) || W != 8
311 # error Need a 64-bit integer type in order to generate crc32.h.
316 z_word_t big[8][256];
318 out = fopen("crc32.h", "w");
319 if (out == NULL) return;
321 /* write out little-endian CRC table to crc32.h */
323 "/* crc32.h -- tables for rapid CRC calculation\n"
324 " * Generated automatically by crc32.c\n */\n"
326 "local const z_crc_t FAR crc_table[] = {\n"
328 write_table(out, crc_table, 256);
332 /* write out big-endian CRC table for 64-bit z_word_t to crc32.h */
339 "local const z_word_t FAR crc_big_table[] = {\n"
341 write_table64(out, crc_big_table, 256);
345 /* write out big-endian CRC table for 32-bit z_word_t to crc32.h */
348 "#else /* W == 4 */\n"
350 "local const z_word_t FAR crc_big_table[] = {\n"
352 write_table32hi(out, crc_big_table, 256);
358 /* write out braid tables for each value of N */
359 for (n = 1; n <= 6; n++) {
364 /* compute braid tables for this N and 64-bit word_t */
365 braid(ltl, big, n, 8);
367 /* write out braid tables for 64-bit z_word_t to crc32.h */
372 "local const z_crc_t FAR crc_braid_table[][256] = {\n");
373 for (k = 0; k < 8; k++) {
375 write_table(out, ltl[k], 256);
376 fprintf(out, "}%s", k < 7 ? ",\n" : "");
381 "local const z_word_t FAR crc_braid_big_table[][256] = {\n");
382 for (k = 0; k < 8; k++) {
384 write_table64(out, big[k], 256);
385 fprintf(out, "}%s", k < 7 ? ",\n" : "");
390 /* compute braid tables for this N and 32-bit word_t */
391 braid(ltl, big, n, 4);
393 /* write out braid tables for 32-bit z_word_t to crc32.h */
396 "#else /* W == 4 */\n"
398 "local const z_crc_t FAR crc_braid_table[][256] = {\n");
399 for (k = 0; k < 4; k++) {
401 write_table(out, ltl[k], 256);
402 fprintf(out, "}%s", k < 3 ? ",\n" : "");
407 "local const z_word_t FAR crc_braid_big_table[][256] = {\n");
408 for (k = 0; k < 4; k++) {
410 write_table32hi(out, big[k], 256);
411 fprintf(out, "}%s", k < 3 ? ",\n" : "");
424 /* write out zeros operator table to crc32.h */
427 "local const z_crc_t FAR x2n_table[] = {\n"
429 write_table(out, x2n_table, 32);
434 #endif /* MAKECRCH */
440 Write the 32-bit values in table[0..k-1] to out, five per line in
441 hexadecimal separated by commas.
443 local void write_table(out, table, k)
445 const z_crc_t FAR *table;
450 for (n = 0; n < k; n++)
451 fprintf(out, "%s0x%08lx%s", n == 0 || n % 5 ? "" : " ",
452 (unsigned long)(table[n]),
453 n == k - 1 ? "" : (n % 5 == 4 ? ",\n" : ", "));
457 Write the high 32-bits of each value in table[0..k-1] to out, five per line
458 in hexadecimal separated by commas.
460 local void write_table32hi(out, table, k)
462 const z_word_t FAR *table;
467 for (n = 0; n < k; n++)
468 fprintf(out, "%s0x%08lx%s", n == 0 || n % 5 ? "" : " ",
469 (unsigned long)(table[n] >> 32),
470 n == k - 1 ? "" : (n % 5 == 4 ? ",\n" : ", "));
474 Write the 64-bit values in table[0..k-1] to out, three per line in
475 hexadecimal separated by commas. This assumes that if there is a 64-bit
476 type, then there is also a long long integer type, and it is at least 64
477 bits. If not, then the type cast and format string can be adjusted
480 local void write_table64(out, table, k)
482 const z_word_t FAR *table;
487 for (n = 0; n < k; n++)
488 fprintf(out, "%s0x%016llx%s", n == 0 || n % 3 ? "" : " ",
489 (unsigned long long)(table[n]),
490 n == k - 1 ? "" : (n % 3 == 2 ? ",\n" : ", "));
493 /* Actually do the deed. */
500 #endif /* MAKECRCH */
504 Generate the little and big-endian braid tables for the given n and z_word_t
505 size w. Each array must have room for w blocks of 256 elements.
507 local void braid(ltl, big, n, w)
515 for (k = 0; k < w; k++) {
516 p = x2nmodp((n * w + 3 - k) << 3, 0);
518 big[w - 1 - k][0] = 0;
519 for (i = 1; i < 256; i++) {
520 ltl[k][i] = q = multmodp(i << 24, p);
521 big[w - 1 - k][i] = byte_swap(q);
527 #else /* !DYNAMIC_CRC_TABLE */
528 /* ========================================================================
529 * Tables for byte-wise and braided CRC-32 calculations, and a table of powers
530 * of x for combining CRC-32s, all made by make_crc_table().
533 #endif /* DYNAMIC_CRC_TABLE */
535 /* ========================================================================
536 * Routines used for CRC calculation. Some are also required for the table
541 Return a(x) multiplied by b(x) modulo p(x), where p(x) is the CRC polynomial,
542 reflected. For speed, this requires that a not be zero.
544 local z_crc_t multmodp(a, b)
550 m = (z_crc_t)1 << 31;
555 if ((a & (m - 1)) == 0)
559 b = b & 1 ? (b >> 1) ^ POLY : b >> 1;
565 Return x^(n * 2^k) modulo p(x). Requires that x2n_table[] has been
568 local z_crc_t x2nmodp(n, k)
574 p = (z_crc_t)1 << 31; /* x^0 == 1 */
577 p = multmodp(x2n_table[k & 31], p);
584 /* =========================================================================
585 * This function can be used by asm versions of crc32(), and to force the
586 * generation of the CRC tables in a threaded application.
588 const z_crc_t FAR * ZEXPORT get_crc_table()
590 #ifdef DYNAMIC_CRC_TABLE
591 once(&made, make_crc_table);
592 #endif /* DYNAMIC_CRC_TABLE */
593 return (const z_crc_t FAR *)crc_table;
596 /* =========================================================================
597 * Use ARM machine instructions if available. This will compute the CRC about
598 * ten times faster than the braided calculation. This code does not check for
599 * the presence of the CRC instruction at run time. __ARM_FEATURE_CRC32 will
600 * only be defined if the compilation specifies an ARM processor architecture
601 * that has the instructions. For example, compiling with -march=armv8.1-a or
602 * -march=armv8-a+crc, or -march=native if the compile machine has the crc32
608 Constants empirically determined to maximize speed. These values are from
609 measurements on a Cortex-A57. Your mileage may vary.
611 #define Z_BATCH 3990 /* number of words in a batch */
612 #define Z_BATCH_ZEROS 0xa10d3d0c /* computed from Z_BATCH = 3990 */
613 #define Z_BATCH_MIN 800 /* fewest words in a final batch */
615 unsigned long ZEXPORT crc32_z(crc, buf, len)
617 const unsigned char FAR *buf;
622 const z_word_t *word;
623 z_word_t val0, val1, val2;
624 z_size_t last, last2, i;
627 /* Return initial CRC, if requested. */
628 if (buf == Z_NULL) return 0;
630 #ifdef DYNAMIC_CRC_TABLE
631 once(&made, make_crc_table);
632 #endif /* DYNAMIC_CRC_TABLE */
634 /* Pre-condition the CRC */
635 crc = (~crc) & 0xffffffff;
637 /* Compute the CRC up to a word boundary. */
638 while (len && ((z_size_t)buf & 7) != 0) {
641 __asm__ volatile("crc32b %w0, %w0, %w1" : "+r"(crc) : "r"(val));
644 /* Prepare to compute the CRC on full 64-bit words word[0..num-1]. */
645 word = (z_word_t const *)buf;
649 /* Do three interleaved CRCs to realize the throughput of one crc32x
650 instruction per cycle. Each CRC is calcuated on Z_BATCH words. The three
651 CRCs are combined into a single CRC after each set of batches. */
652 while (num >= 3 * Z_BATCH) {
655 for (i = 0; i < Z_BATCH; i++) {
657 val1 = word[i + Z_BATCH];
658 val2 = word[i + 2 * Z_BATCH];
659 __asm__ volatile("crc32x %w0, %w0, %x1" : "+r"(crc) : "r"(val0));
660 __asm__ volatile("crc32x %w0, %w0, %x1" : "+r"(crc1) : "r"(val1));
661 __asm__ volatile("crc32x %w0, %w0, %x1" : "+r"(crc2) : "r"(val2));
665 crc = multmodp(Z_BATCH_ZEROS, crc) ^ crc1;
666 crc = multmodp(Z_BATCH_ZEROS, crc) ^ crc2;
669 /* Do one last smaller batch with the remaining words, if there are enough
670 to pay for the combination of CRCs. */
672 if (last >= Z_BATCH_MIN) {
676 for (i = 0; i < last; i++) {
678 val1 = word[i + last];
679 val2 = word[i + last2];
680 __asm__ volatile("crc32x %w0, %w0, %x1" : "+r"(crc) : "r"(val0));
681 __asm__ volatile("crc32x %w0, %w0, %x1" : "+r"(crc1) : "r"(val1));
682 __asm__ volatile("crc32x %w0, %w0, %x1" : "+r"(crc2) : "r"(val2));
686 val = x2nmodp(last, 6);
687 crc = multmodp(val, crc) ^ crc1;
688 crc = multmodp(val, crc) ^ crc2;
691 /* Compute the CRC on any remaining words. */
692 for (i = 0; i < num; i++) {
694 __asm__ volatile("crc32x %w0, %w0, %x1" : "+r"(crc) : "r"(val0));
698 /* Complete the CRC on any remaining bytes. */
699 buf = (const unsigned char FAR *)word;
703 __asm__ volatile("crc32b %w0, %w0, %w1" : "+r"(crc) : "r"(val));
706 /* Return the CRC, post-conditioned. */
707 return crc ^ 0xffffffff;
715 Return the CRC of the W bytes in the word_t data, taking the
716 least-significant byte of the word as the first byte of data, without any pre
717 or post conditioning. This is used to combine the CRCs of each braid.
719 local z_crc_t crc_word OF((z_word_t data));
721 local z_crc_t crc_word(data)
725 for (k = 0; k < W; k++)
726 data = (data >> 8) ^ crc_table[data & 0xff];
727 return (z_crc_t)data;
730 local z_word_t crc_word_big OF((z_word_t data));
732 local z_word_t crc_word_big(data)
736 for (k = 0; k < W; k++)
738 crc_big_table[(data >> ((W - 1) << 3)) & 0xff];
744 /* ========================================================================= */
745 unsigned long ZEXPORT crc32_z(crc, buf, len)
747 const unsigned char FAR *buf;
750 /* Return initial CRC, if requested. */
751 if (buf == Z_NULL) return 0;
753 #ifdef DYNAMIC_CRC_TABLE
754 once(&made, make_crc_table);
755 #endif /* DYNAMIC_CRC_TABLE */
757 /* Pre-condition the CRC */
758 crc = (~crc) & 0xffffffff;
762 /* If provided enough bytes, do a braided CRC calculation. */
763 if (len >= N * W + W - 1) {
765 z_word_t const *words;
769 /* Compute the CRC up to a z_word_t boundary. */
770 while (len && ((z_size_t)buf & (W - 1)) != 0) {
772 crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff];
775 /* Compute the CRC on as many N z_word_t blocks as are available. */
776 blks = len / (N * W);
778 words = (z_word_t const *)buf;
780 /* Do endian check at execution time instead of compile time, since ARM
781 processors can change the endianess at execution time. If the
782 compiler knows what the endianess will be, it can optimize out the
783 check and the unused branch. */
785 if (*(unsigned char *)&endian) {
811 /* Initialize the CRC for each braid. */
830 Process the first blks-1 blocks, computing the CRCs on each braid
834 /* Load the word for each braid into registers. */
835 word0 = crc0 ^ words[0];
837 word1 = crc1 ^ words[1];
839 word2 = crc2 ^ words[2];
841 word3 = crc3 ^ words[3];
843 word4 = crc4 ^ words[4];
845 word5 = crc5 ^ words[5];
853 /* Compute and update the CRC for each word. The loop should
855 crc0 = crc_braid_table[0][word0 & 0xff];
857 crc1 = crc_braid_table[0][word1 & 0xff];
859 crc2 = crc_braid_table[0][word2 & 0xff];
861 crc3 = crc_braid_table[0][word3 & 0xff];
863 crc4 = crc_braid_table[0][word4 & 0xff];
865 crc5 = crc_braid_table[0][word5 & 0xff];
871 for (k = 1; k < W; k++) {
872 crc0 ^= crc_braid_table[k][(word0 >> (k << 3)) & 0xff];
874 crc1 ^= crc_braid_table[k][(word1 >> (k << 3)) & 0xff];
876 crc2 ^= crc_braid_table[k][(word2 >> (k << 3)) & 0xff];
878 crc3 ^= crc_braid_table[k][(word3 >> (k << 3)) & 0xff];
880 crc4 ^= crc_braid_table[k][(word4 >> (k << 3)) & 0xff];
882 crc5 ^= crc_braid_table[k][(word5 >> (k << 3)) & 0xff];
892 Process the last block, combining the CRCs of the N braids at the
895 crc = crc_word(crc0 ^ words[0]);
897 crc = crc_word(crc1 ^ words[1] ^ crc);
899 crc = crc_word(crc2 ^ words[2] ^ crc);
901 crc = crc_word(crc3 ^ words[3] ^ crc);
903 crc = crc_word(crc4 ^ words[4] ^ crc);
905 crc = crc_word(crc5 ^ words[5] ^ crc);
916 z_word_t crc0, word0, comb;
918 z_word_t crc1, word1;
920 z_word_t crc2, word2;
922 z_word_t crc3, word3;
924 z_word_t crc4, word4;
926 z_word_t crc5, word5;
933 /* Initialize the CRC for each braid. */
934 crc0 = byte_swap(crc);
952 Process the first blks-1 blocks, computing the CRCs on each braid
956 /* Load the word for each braid into registers. */
957 word0 = crc0 ^ words[0];
959 word1 = crc1 ^ words[1];
961 word2 = crc2 ^ words[2];
963 word3 = crc3 ^ words[3];
965 word4 = crc4 ^ words[4];
967 word5 = crc5 ^ words[5];
975 /* Compute and update the CRC for each word. The loop should
977 crc0 = crc_braid_big_table[0][word0 & 0xff];
979 crc1 = crc_braid_big_table[0][word1 & 0xff];
981 crc2 = crc_braid_big_table[0][word2 & 0xff];
983 crc3 = crc_braid_big_table[0][word3 & 0xff];
985 crc4 = crc_braid_big_table[0][word4 & 0xff];
987 crc5 = crc_braid_big_table[0][word5 & 0xff];
993 for (k = 1; k < W; k++) {
994 crc0 ^= crc_braid_big_table[k][(word0 >> (k << 3)) & 0xff];
996 crc1 ^= crc_braid_big_table[k][(word1 >> (k << 3)) & 0xff];
998 crc2 ^= crc_braid_big_table[k][(word2 >> (k << 3)) & 0xff];
1000 crc3 ^= crc_braid_big_table[k][(word3 >> (k << 3)) & 0xff];
1002 crc4 ^= crc_braid_big_table[k][(word4 >> (k << 3)) & 0xff];
1004 crc5 ^= crc_braid_big_table[k][(word5 >> (k << 3)) & 0xff];
1014 Process the last block, combining the CRCs of the N braids at the
1017 comb = crc_word_big(crc0 ^ words[0]);
1019 comb = crc_word_big(crc1 ^ words[1] ^ comb);
1021 comb = crc_word_big(crc2 ^ words[2] ^ comb);
1023 comb = crc_word_big(crc3 ^ words[3] ^ comb);
1025 comb = crc_word_big(crc4 ^ words[4] ^ comb);
1027 comb = crc_word_big(crc5 ^ words[5] ^ comb);
1034 crc = byte_swap(comb);
1038 Update the pointer to the remaining bytes to process.
1040 buf = (unsigned char const *)words;
1045 /* Complete the computation of the CRC on any remaining bytes. */
1048 crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff];
1049 crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff];
1050 crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff];
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];
1059 crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff];
1062 /* Return the CRC, post-conditioned. */
1063 return crc ^ 0xffffffff;
1068 /* ========================================================================= */
1069 unsigned long ZEXPORT crc32(crc, buf, len)
1071 const unsigned char FAR *buf;
1074 return crc32_z(crc, buf, len);
1077 /* ========================================================================= */
1078 uLong ZEXPORT crc32_combine64(crc1, crc2, len2)
1083 #ifdef DYNAMIC_CRC_TABLE
1084 once(&made, make_crc_table);
1085 #endif /* DYNAMIC_CRC_TABLE */
1086 return multmodp(x2nmodp(len2, 3), crc1) ^ (crc2 & 0xffffffff);
1089 /* ========================================================================= */
1090 uLong ZEXPORT crc32_combine(crc1, crc2, len2)
1095 return crc32_combine64(crc1, crc2, len2);
1098 /* ========================================================================= */
1099 uLong ZEXPORT crc32_combine_gen64(len2)
1102 #ifdef DYNAMIC_CRC_TABLE
1103 once(&made, make_crc_table);
1104 #endif /* DYNAMIC_CRC_TABLE */
1105 return x2nmodp(len2, 3);
1108 /* ========================================================================= */
1109 uLong ZEXPORT crc32_combine_gen(len2)
1112 return crc32_combine_gen64(len2);
1115 /* ========================================================================= */
1116 uLong crc32_combine_op(crc1, crc2, op)
1121 return multmodp(op, crc1) ^ (crc2 & 0xffffffff);