← Back to branch summary

~rdoering/ubuntu/intrepid/erlang/fix-535090

« back to all changes in this revision

Viewing changes to erts/emulator/zlib/crc32.c

  • Committer: Bazaar Package Importer
  • Author(s): Soren Hansen
  • Date: 2007-05-01 16:57:10 UTC
  • mfrom: (1.1.9 upstream)
  • Revision ID: james.westby@ubuntu.com-20070501165710-2sapk0hp2gf3o0ip
Tags: 1:11.b.4-2ubuntu1
* Merge with Debian Unstable. Remaining changes:
  - Add -fno-stack-protector to fix broken crypto_drv.
* DebianMaintainerField update.

Show diffs side-by-side

added added

removed removed

Lines of Context:
erts/emulator/zlib/crc32.c
1
1
/* crc32.c -- compute the CRC-32 of a data stream
2
 
 * Copyright (C) 1995-1998 Mark Adler
3
 
 * For conditions of distribution and use, see copyright notice in zlib.h 
4
 
 */
5
 
 
6
 
/* @(#) $Id$ */
7
 
 
 
2
 * Copyright (C) 1995-2005 Mark Adler
 
3
 * For conditions of distribution and use, see copyright notice in zlib.h
 
4
 *
 
5
 * Thanks to Rodney Brown <rbrown64@csc.com.au> for his contribution of faster
 
6
 * CRC methods: exclusive-oring 32 bits of data at a time, and pre-computing
 
7
 * tables for updating the shift register in one step with three exclusive-ors
8
8
#ifdef HAVE_CONFIG_H
9
9
#  include "config.h"
10
10
#endif
11
 
#include "zlib.h"
 
11
 * instead of four steps with four exclusive-ors.  This results in about a
 
12
 * factor of two increase in speed on a Power PC G4 (PPC7455) using gcc -O3.
 
13
 */
 
14
 
 
15
/* @(#) $Id$ */
 
16
 
 
17
/*
 
18
  Note on the use of DYNAMIC_CRC_TABLE: there is no mutex or semaphore
 
19
  protection on the static variables used to control the first-use generation
 
20
  of the crc tables.  Therefore, if you #define DYNAMIC_CRC_TABLE, you should
 
21
  first call get_crc_table() to initialize the tables before allowing more than
 
22
  one thread to use crc32().
 
23
 */
 
24
 
 
25
#ifdef MAKECRCH
 
26
#  include <stdio.h>
 
27
#  ifndef DYNAMIC_CRC_TABLE
 
28
#    define DYNAMIC_CRC_TABLE
 
29
#  endif /* !DYNAMIC_CRC_TABLE */
 
30
#endif /* MAKECRCH */
 
31
 
 
32
#include "zutil.h"      /* for STDC and FAR definitions */
12
33
 
13
34
#define local static
14
35
 
 
36
/* Find a four-byte integer type for crc32_little() and crc32_big(). */
 
37
#ifndef NOBYFOUR
 
38
#  ifdef STDC           /* need ANSI C limits.h to determine sizes */
 
39
#    include <limits.h>
 
40
#    define BYFOUR
 
41
#    if (UINT_MAX == 0xffffffffUL)
 
42
       typedef unsigned int u4;
 
43
#    else
 
44
#      if (ULONG_MAX == 0xffffffffUL)
 
45
         typedef unsigned long u4;
 
46
#      else
 
47
#        if (USHRT_MAX == 0xffffffffUL)
 
48
           typedef unsigned short u4;
 
49
#        else
 
50
#          undef BYFOUR     /* can't find a four-byte integer type! */
 
51
#        endif
 
52
#      endif
 
53
#    endif
 
54
#  endif /* STDC */
 
55
#endif /* !NOBYFOUR */
 
56
 
 
57
/* Definitions for doing the crc four data bytes at a time. */
 
58
#ifdef BYFOUR
 
59
#  define REV(w) (((w)>>24)+(((w)>>8)&0xff00)+ \
 
60
                (((w)&0xff00)<<8)+(((w)&0xff)<<24))
 
61
   local unsigned long crc32_little OF((unsigned long,
 
62
                        const unsigned char FAR *, unsigned));
 
63
   local unsigned long crc32_big OF((unsigned long,
 
64
                        const unsigned char FAR *, unsigned));
 
65
#  define TBLS 8
 
66
#else
 
67
#  define TBLS 1
 
68
#endif /* BYFOUR */
 
69
 
 
70
/* Local functions for crc concatenation */
 
71
local unsigned long gf2_matrix_times OF((unsigned long *mat,
 
72
                                         unsigned long vec));
 
73
local void gf2_matrix_square OF((unsigned long *square, unsigned long *mat));
 
74
 
15
75
#ifdef DYNAMIC_CRC_TABLE
16
76
 
17
 
local int crc_table_empty = 1;
18
 
local uLongf crc_table[256];
 
77
local volatile int crc_table_empty = 1;
 
78
local unsigned long FAR crc_table[TBLS][256];
19
79
local void make_crc_table OF((void));
20
 
 
 
80
#ifdef MAKECRCH
 
81
   local void write_table OF((FILE *, const unsigned long FAR *));
 
82
#endif /* MAKECRCH */
21
83
/*
22
 
  Generate a table for a byte-wise 32-bit CRC calculation on the polynomial:
 
84
  Generate tables for a byte-wise 32-bit CRC calculation on the polynomial:
23
85
  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.
24
86
 
25
87
  Polynomials over GF(2) are represented in binary, one bit per coefficient,
38
100
  out is a one).  We start with the highest power (least significant bit) of
39
101
  q and repeat for all eight bits of q.
40
102
 
41
 
  The table is simply the CRC of all possible eight bit values.  This is all
42
 
  the information needed to generate CRC's on data a byte at a time for all
43
 
  combinations of CRC register values and incoming bytes.
 
103
  The first table is simply the CRC of all possible eight bit values.  This is
 
104
  all the information needed to generate CRCs on data a byte at a time for all
 
105
  combinations of CRC register values and incoming bytes.  The remaining tables
 
106
  allow for word-at-a-time CRC calculation for both big-endian and little-
 
107
  endian machines, where a word is four bytes.
44
108
*/
45
109
local void make_crc_table()
46
110
{
47
 
  uLong c;
48
 
  int n, k;
49
 
  uLong poly;            /* polynomial exclusive-or pattern */
50
 
  /* terms of polynomial defining this crc (except x^32): */
51
 
  static const Byte p[] = {0,1,2,4,5,7,8,10,11,12,16,22,23,26};
52
 
 
53
 
  /* make exclusive-or pattern from polynomial (0xedb88320L) */
54
 
  poly = 0L;
55
 
  for (n = 0; n < sizeof(p)/sizeof(Byte); n++)
56
 
    poly |= 1L << (31 - p[n]);
57
 
 
58
 
  for (n = 0; n < 256; n++)
59
 
  {
60
 
    c = (uLong)n;
61
 
    for (k = 0; k < 8; k++)
62
 
      c = c & 1 ? poly ^ (c >> 1) : c >> 1;
63
 
    crc_table[n] = c;
64
 
  }
65
 
  crc_table_empty = 0;
66
 
}
67
 
#else
 
111
    unsigned long c;
 
112
    int n, k;
 
113
    unsigned long poly;                 /* polynomial exclusive-or pattern */
 
114
    /* terms of polynomial defining this crc (except x^32): */
 
115
    static volatile int first = 1;      /* flag to limit concurrent making */
 
116
    static const unsigned char p[] = {0,1,2,4,5,7,8,10,11,12,16,22,23,26};
 
117
 
 
118
    /* See if another task is already doing this (not thread-safe, but better
 
119
       than nothing -- significantly reduces duration of vulnerability in
 
120
       case the advice about DYNAMIC_CRC_TABLE is ignored) */
 
121
    if (first) {
 
122
        first = 0;
 
123
 
 
124
        /* make exclusive-or pattern from polynomial (0xedb88320UL) */
 
125
        poly = 0UL;
 
126
        for (n = 0; n < sizeof(p)/sizeof(unsigned char); n++)
 
127
            poly |= 1UL << (31 - p[n]);
 
128
 
 
129
        /* generate a crc for every 8-bit value */
 
130
        for (n = 0; n < 256; n++) {
 
131
            c = (unsigned long)n;
 
132
            for (k = 0; k < 8; k++)
 
133
                c = c & 1 ? poly ^ (c >> 1) : c >> 1;
 
134
            crc_table[0][n] = c;
 
135
        }
 
136
 
 
137
#ifdef BYFOUR
 
138
        /* generate crc for each value followed by one, two, and three zeros,
 
139
           and then the byte reversal of those as well as the first table */
 
140
        for (n = 0; n < 256; n++) {
 
141
            c = crc_table[0][n];
 
142
            crc_table[4][n] = REV(c);
 
143
            for (k = 1; k < 4; k++) {
 
144
                c = crc_table[0][c & 0xff] ^ (c >> 8);
 
145
                crc_table[k][n] = c;
 
146
                crc_table[k + 4][n] = REV(c);
 
147
            }
 
148
        }
 
149
#endif /* BYFOUR */
 
150
 
 
151
        crc_table_empty = 0;
 
152
    }
 
153
    else {      /* not first */
 
154
        /* wait for the other guy to finish (not efficient, but rare) */
 
155
        while (crc_table_empty)
 
156
            ;
 
157
    }
 
158
 
 
159
#ifdef MAKECRCH
 
160
    /* write out CRC tables to crc32.h */
 
161
    {
 
162
        FILE *out;
 
163
 
 
164
        out = fopen("crc32.h", "w");
 
165
        if (out == NULL) return;
 
166
        fprintf(out, "/* crc32.h -- tables for rapid CRC calculation\n");
 
167
        fprintf(out, " * Generated automatically by crc32.c\n */\n\n");
 
168
        fprintf(out, "local const unsigned long FAR ");
 
169
        fprintf(out, "crc_table[TBLS][256] =\n{\n  {\n");
 
170
        write_table(out, crc_table[0]);
 
171
#  ifdef BYFOUR
 
172
        fprintf(out, "#ifdef BYFOUR\n");
 
173
        for (k = 1; k < 8; k++) {
 
174
            fprintf(out, "  },\n  {\n");
 
175
            write_table(out, crc_table[k]);
 
176
        }
 
177
        fprintf(out, "#endif\n");
 
178
#  endif /* BYFOUR */
 
179
        fprintf(out, "  }\n};\n");
 
180
        fclose(out);
 
181
    }
 
182
#endif /* MAKECRCH */
 
183
}
 
184
 
 
185
#ifdef MAKECRCH
 
186
local void write_table(out, table)
 
187
    FILE *out;
 
188
    const unsigned long FAR *table;
 
189
{
 
190
    int n;
 
191
 
 
192
    for (n = 0; n < 256; n++)
 
193
        fprintf(out, "%s0x%08lxUL%s", n % 5 ? "" : "    ", table[n],
 
194
                n == 255 ? "\n" : (n % 5 == 4 ? ",\n" : ", "));
 
195
}
 
196
#endif /* MAKECRCH */
 
197
 
 
198
#else /* !DYNAMIC_CRC_TABLE */
68
199
/* ========================================================================
69
 
 * Table of CRC-32's of all single-byte values (made by make_crc_table)
 
200
 * Tables of CRC-32s of all single-byte values, made by make_crc_table().
70
201
 */
71
 
local const uLongf crc_table[256] = {
72
 
  0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L,
73
 
  0x706af48fL, 0xe963a535L, 0x9e6495a3L, 0x0edb8832L, 0x79dcb8a4L,
74
 
  0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L,
75
 
  0x90bf1d91L, 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL,
76
 
  0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L, 0x136c9856L,
77
 
  0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L,
78
 
  0xfa0f3d63L, 0x8d080df5L, 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L,
79
 
  0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL,
80
 
  0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L,
81
 
  0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L, 0x26d930acL, 0x51de003aL,
82
 
  0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L,
83
 
  0xb8bda50fL, 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L,
84
 
  0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL, 0x76dc4190L,
85
 
  0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL,
86
 
  0x9fbfe4a5L, 0xe8b8d433L, 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL,
87
 
  0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L,
88
 
  0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL,
89
 
  0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L, 0x65b0d9c6L, 0x12b7e950L,
90
 
  0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L,
91
 
  0xfbd44c65L, 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L,
92
 
  0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL, 0x4369e96aL,
93
 
  0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L,
94
 
  0xaa0a4c5fL, 0xdd0d7cc9L, 0x5005713cL, 0x270241aaL, 0xbe0b1010L,
95
 
  0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL,
96
 
  0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L,
97
 
  0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL, 0xedb88320L, 0x9abfb3b6L,
98
 
  0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L,
99
 
  0x73dc1683L, 0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L,
100
 
  0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L, 0xf00f9344L,
101
 
  0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL,
102
 
  0x196c3671L, 0x6e6b06e7L, 0xfed41b76L, 0x89d32be0L, 0x10da7a5aL,
103
 
  0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L,
104
 
  0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L,
105
 
  0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL, 0xd80d2bdaL, 0xaf0a1b4cL,
106
 
  0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL,
107
 
  0x4669be79L, 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L,
108
 
  0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL, 0xc5ba3bbeL,
109
 
  0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L,
110
 
  0x2cd99e8bL, 0x5bdeae1dL, 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL,
111
 
  0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L,
112
 
  0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL,
113
 
  0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L, 0x86d3d2d4L, 0xf1d4e242L,
114
 
  0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L,
115
 
  0x18b74777L, 0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL,
116
 
  0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L, 0xa00ae278L,
117
 
  0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L,
118
 
  0x4969474dL, 0x3e6e77dbL, 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L,
119
 
  0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L,
120
 
  0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L,
121
 
  0xcdd70693L, 0x54de5729L, 0x23d967bfL, 0xb3667a2eL, 0xc4614ab8L,
122
 
  0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL,
123
 
  0x2d02ef8dL
124
 
};
125
 
#endif
 
202
#include "crc32.h"
 
203
#endif /* DYNAMIC_CRC_TABLE */
126
204
 
127
205
/* =========================================================================
128
206
 * This function can be used by asm versions of crc32()
129
207
 */
130
 
const uLongf * ZEXPORT get_crc_table()
131
 
{
132
 
#ifdef DYNAMIC_CRC_TABLE
133
 
  if (crc_table_empty) make_crc_table();
134
 
#endif
135
 
  return (const uLongf *)crc_table;
136
 
}
137
 
 
138
 
/* ========================================================================= */
139
 
#define DO1(buf) crc = crc_table[((int)crc ^ (*buf++)) & 0xff] ^ (crc >> 8);
140
 
#define DO2(buf)  DO1(buf); DO1(buf);
141
 
#define DO4(buf)  DO2(buf); DO2(buf);
142
 
#define DO8(buf)  DO4(buf); DO4(buf);
143
 
 
144
 
/* ========================================================================= */
145
 
uLong ZEXPORT crc32(crc, buf, len)
146
 
    uLong crc;
147
 
    const Bytef *buf;
148
 
    uInt len;
149
 
{
150
 
    if (buf == Z_NULL) return 0L;
151
 
#ifdef DYNAMIC_CRC_TABLE
152
 
    if (crc_table_empty)
153
 
      make_crc_table();
154
 
#endif
155
 
    crc = crc ^ 0xffffffffL;
156
 
    while (len >= 8)
157
 
    {
158
 
      DO8(buf);
159
 
      len -= 8;
160
 
    }
161
 
    if (len) do {
162
 
      DO1(buf);
163
 
    } while (--len);
164
 
    return crc ^ 0xffffffffL;
 
208
const unsigned long FAR * ZEXPORT get_crc_table()
 
209
{
 
210
#ifdef DYNAMIC_CRC_TABLE
 
211
    if (crc_table_empty)
 
212
        make_crc_table();
 
213
#endif /* DYNAMIC_CRC_TABLE */
 
214
    return (const unsigned long FAR *)crc_table;
 
215
}
 
216
 
 
217
/* ========================================================================= */
 
218
#define DO1 crc = crc_table[0][((int)crc ^ (*buf++)) & 0xff] ^ (crc >> 8)
 
219
#define DO8 DO1; DO1; DO1; DO1; DO1; DO1; DO1; DO1
 
220
 
 
221
/* ========================================================================= */
 
222
unsigned long ZEXPORT crc32(crc, buf, len)
 
223
    unsigned long crc;
 
224
    const unsigned char FAR *buf;
 
225
    unsigned len;
 
226
{
 
227
    if (buf == Z_NULL) return 0UL;
 
228
 
 
229
#ifdef DYNAMIC_CRC_TABLE
 
230
    if (crc_table_empty)
 
231
        make_crc_table();
 
232
#endif /* DYNAMIC_CRC_TABLE */
 
233
 
 
234
#ifdef BYFOUR
 
235
    if (sizeof(void *) == sizeof(ptrdiff_t)) {
 
236
        u4 endian;
 
237
 
 
238
        endian = 1;
 
239
        if (*((unsigned char *)(&endian)))
 
240
            return crc32_little(crc, buf, len);
 
241
        else
 
242
            return crc32_big(crc, buf, len);
 
243
    }
 
244
#endif /* BYFOUR */
 
245
    crc = crc ^ 0xffffffffUL;
 
246
    while (len >= 8) {
 
247
        DO8;
 
248
        len -= 8;
 
249
    }
 
250
    if (len) do {
 
251
        DO1;
 
252
    } while (--len);
 
253
    return crc ^ 0xffffffffUL;
 
254
}
 
255
 
 
256
#ifdef BYFOUR
 
257
 
 
258
/* ========================================================================= */
 
259
#define DOLIT4 c ^= *buf4++; \
 
260
        c = crc_table[3][c & 0xff] ^ crc_table[2][(c >> 8) & 0xff] ^ \
 
261
            crc_table[1][(c >> 16) & 0xff] ^ crc_table[0][c >> 24]
 
262
#define DOLIT32 DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4
 
263
 
 
264
/* ========================================================================= */
 
265
local unsigned long crc32_little(crc, buf, len)
 
266
    unsigned long crc;
 
267
    const unsigned char FAR *buf;
 
268
    unsigned len;
 
269
{
 
270
    register u4 c;
 
271
    register const u4 FAR *buf4;
 
272
 
 
273
    c = (u4)crc;
 
274
    c = ~c;
 
275
    while (len && ((ptrdiff_t)buf & 3)) {
 
276
        c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8);
 
277
        len--;
 
278
    }
 
279
 
 
280
    buf4 = (const u4 FAR *)(const void FAR *)buf;
 
281
    while (len >= 32) {
 
282
        DOLIT32;
 
283
        len -= 32;
 
284
    }
 
285
    while (len >= 4) {
 
286
        DOLIT4;
 
287
        len -= 4;
 
288
    }
 
289
    buf = (const unsigned char FAR *)buf4;
 
290
 
 
291
    if (len) do {
 
292
        c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8);
 
293
    } while (--len);
 
294
    c = ~c;
 
295
    return (unsigned long)c;
 
296
}
 
297
 
 
298
/* ========================================================================= */
 
299
#define DOBIG4 c ^= *++buf4; \
 
300
        c = crc_table[4][c & 0xff] ^ crc_table[5][(c >> 8) & 0xff] ^ \
 
301
            crc_table[6][(c >> 16) & 0xff] ^ crc_table[7][c >> 24]
 
302
#define DOBIG32 DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4
 
303
 
 
304
/* ========================================================================= */
 
305
local unsigned long crc32_big(crc, buf, len)
 
306
    unsigned long crc;
 
307
    const unsigned char FAR *buf;
 
308
    unsigned len;
 
309
{
 
310
    register u4 c;
 
311
    register const u4 FAR *buf4;
 
312
 
 
313
    c = REV((u4)crc);
 
314
    c = ~c;
 
315
    while (len && ((ptrdiff_t)buf & 3)) {
 
316
        c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8);
 
317
        len--;
 
318
    }
 
319
 
 
320
    buf4 = (const u4 FAR *)(const void FAR *)buf;
 
321
    buf4--;
 
322
    while (len >= 32) {
 
323
        DOBIG32;
 
324
        len -= 32;
 
325
    }
 
326
    while (len >= 4) {
 
327
        DOBIG4;
 
328
        len -= 4;
 
329
    }
 
330
    buf4++;
 
331
    buf = (const unsigned char FAR *)buf4;
 
332
 
 
333
    if (len) do {
 
334
        c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8);
 
335
    } while (--len);
 
336
    c = ~c;
 
337
    return (unsigned long)(REV(c));
 
338
}
 
339
 
 
340
#endif /* BYFOUR */
 
341
 
 
342
#define GF2_DIM 32      /* dimension of GF(2) vectors (length of CRC) */
 
343
 
 
344
/* ========================================================================= */
 
345
local unsigned long gf2_matrix_times(mat, vec)
 
346
    unsigned long *mat;
 
347
    unsigned long vec;
 
348
{
 
349
    unsigned long sum;
 
350
 
 
351
    sum = 0;
 
352
    while (vec) {
 
353
        if (vec & 1)
 
354
            sum ^= *mat;
 
355
        vec >>= 1;
 
356
        mat++;
 
357
    }
 
358
    return sum;
 
359
}
 
360
 
 
361
/* ========================================================================= */
 
362
local void gf2_matrix_square(square, mat)
 
363
    unsigned long *square;
 
364
    unsigned long *mat;
 
365
{
 
366
    int n;
 
367
 
 
368
    for (n = 0; n < GF2_DIM; n++)
 
369
        square[n] = gf2_matrix_times(mat, mat[n]);
 
370
}
 
371
 
 
372
/* ========================================================================= */
 
373
uLong ZEXPORT crc32_combine(crc1, crc2, len2)
 
374
    uLong crc1;
 
375
    uLong crc2;
 
376
    z_off_t len2;
 
377
{
 
378
    int n;
 
379
    unsigned long row;
 
380
    unsigned long even[GF2_DIM];    /* even-power-of-two zeros operator */
 
381
    unsigned long odd[GF2_DIM];     /* odd-power-of-two zeros operator */
 
382
 
 
383
    /* degenerate case */
 
384
    if (len2 == 0)
 
385
        return crc1;
 
386
 
 
387
    /* put operator for one zero bit in odd */
 
388
    odd[0] = 0xedb88320L;           /* CRC-32 polynomial */
 
389
    row = 1;
 
390
    for (n = 1; n < GF2_DIM; n++) {
 
391
        odd[n] = row;
 
392
        row <<= 1;
 
393
    }
 
394
 
 
395
    /* put operator for two zero bits in even */
 
396
    gf2_matrix_square(even, odd);
 
397
 
 
398
    /* put operator for four zero bits in odd */
 
399
    gf2_matrix_square(odd, even);
 
400
 
 
401
    /* apply len2 zeros to crc1 (first square will put the operator for one
 
402
       zero byte, eight zero bits, in even) */
 
403
    do {
 
404
        /* apply zeros operator for this bit of len2 */
 
405
        gf2_matrix_square(even, odd);
 
406
        if (len2 & 1)
 
407
            crc1 = gf2_matrix_times(even, crc1);
 
408
        len2 >>= 1;
 
409
 
 
410
        /* if no more bits set, then done */
 
411
        if (len2 == 0)
 
412
            break;
 
413
 
 
414
        /* another iteration of the loop with odd and even swapped */
 
415
        gf2_matrix_square(odd, even);
 
416
        if (len2 & 1)
 
417
            crc1 = gf2_matrix_times(odd, crc1);
 
418
        len2 >>= 1;
 
419
 
 
420
        /* if no more bits set, then done */
 
421
    } while (len2 != 0);
 
422
 
 
423
    /* return combined crc */
 
424
    crc1 ^= crc2;
 
425
    return crc1;
165
426
}