; crc32.asm -- compute the CRC-32 of a data stream ; Copyright (C) 1995-2006, 2010, 2011, 2012 Mark Adler ; For conditions of distribution and use, see copyright notice in zlib.inc ; Thanks to Rodney Brown for his contribution of faster ; CRC methods: exclusive-oring 32 bits of data at a time, and pre-computing ; tables for updating the shift register in one step with three exclusive-ors ; instead of four steps with four exclusive-ors. This results in about a ; factor of two increase in speed on a Power PC G4 (PPC7455) using gcc -O3. ; Note on the use of DYNAMIC_CRC_TABLE: there is no mutex or semaphore ; protection on the static variables used to control the first-use generation ; of the crc tables. Therefore, if you #define DYNAMIC_CRC_TABLE, you should ; first call get_crc_table() to initialize the tables before allowing more than ; one thread to use crc32(). ; Definitions for doing the crc four data bytes at a time. TBLS equ 1 if DYNAMIC_CRC_TABLE eq 1 align 4 crc_table_empty dd 1 ;align 4 ;crc_table rd TBLS*256 ; Generate tables for a byte-wise 32-bit CRC calculation on the polynomial: ; 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. ; Polynomials over GF(2) are represented in binary, one bit per coefficient, ; with the lowest powers in the most significant bit. Then adding polynomials ; is just exclusive-or, and multiplying a polynomial by x is a right shift by ; one. If we call the above polynomial p, and represent a byte as the ; polynomial q, also with the lowest power in the most significant bit (so the ; byte 0xb1 is the polynomial x^7+x^3+x+1), then the CRC is (q*x^32) mod p, ; where a mod b means the remainder after dividing a by b. ; This calculation is done using the shift-register method of multiplying and ; taking the remainder. The register is initialized to zero, and for each ; incoming bit, x^32 is added mod p to the register if the bit is a one (where ; x^32 mod p is p+x^32 = x^26+...+1), and the register is multiplied mod p by ; x (which is shifting right by one and adding x^32 mod p if the bit shifted ; out is a one). We start with the highest power (least significant bit) of ; q and repeat for all eight bits of q. ; The first table is simply the CRC of all possible eight bit values. This is ; all the information needed to generate CRCs on data a byte at a time for all ; combinations of CRC register values and incoming bytes. The remaining tables ; allow for word-at-a-time CRC calculation for both big-endian and little- ; endian machines, where a word is four bytes. ;void () align 4 proc make_crc_table uses ecx edx edi zlib_debug 'make_crc_table' ; generate a crc for every 8-bit value xor edx, edx mov edi, crc_table .1: mov ecx, 8 mov eax, edx .2: shr eax, 1 jnc @f xor eax, 0xEDB88320 @@: loop .2 stosd inc dl jnz .1 mov dword[crc_table_empty],0 ret endp else ;!DYNAMIC_CRC_TABLE ; ======================================================================== ; Tables of CRC-32s of all single-byte values, made by make_crc_table(). ;include 'crc32.inc' end if ;DYNAMIC_CRC_TABLE ; ========================================================================= ; This function can be used by asm versions of crc32() ;const z_crc_t* () align 4 proc get_crc_table if DYNAMIC_CRC_TABLE eq 1 cmp dword[crc_table_empty],0 je @f ;if (..) call make_crc_table @@: end if mov eax,crc_table ret endp ; ========================================================================= ;unsigned long (crc, buf, len) ; unsigned long crc ; unsigned char *buf ; uInt len align 4 proc calc_crc32 uses ecx esi, p1crc:dword, buf:dword, len:dword xor eax,eax mov esi,[buf] zlib_debug 'calc_crc32 buf = %d',esi cmp esi,Z_NULL je .end_f ;if (..==0) return 0 if DYNAMIC_CRC_TABLE eq 1 cmp dword[crc_table_empty],0 je @f ;if (..) call make_crc_table @@: end if mov eax,[p1crc] mov ecx,[len] call crc .end_f: ret endp GF2_DIM equ 32 ;dimension of GF(2) vectors (length of CRC) ; ========================================================================= ;unsigned long (mat, vec) ; unsigned long *mat ; unsigned long vec align 4 proc gf2_matrix_times, mat:dword, vec:dword ; unsigned long sum; ; sum = 0; ; while (vec) { ; if (vec & 1) ; sum ^= *mat; ; vec >>= 1; ; mat++; ; } ; return sum; ret endp ; ========================================================================= ;local void (square, mat) ; unsigned long *square ; unsigned long *mat align 4 proc gf2_matrix_square, square:dword, mat:dword ; int n; ; for (n = 0; n < GF2_DIM; n++) ; square[n] = gf2_matrix_times(mat, mat[n]); ret endp ; ========================================================================= ;uLong (crc1, crc2, len2) ; uLong crc1 ; uLong crc2 ; z_off64_t len2 align 4 proc crc32_combine_, crc1:dword, crc2:dword, len2:dword ; int n; ; unsigned long row; ; unsigned long even[GF2_DIM]; /* even-power-of-two zeros operator */ ; unsigned long odd[GF2_DIM]; /* odd-power-of-two zeros operator */ ; degenerate case (also disallow negative lengths) ; if (len2 <= 0) ; return crc1; ; put operator for one zero bit in odd ; odd[0] = 0xedb88320UL; /* CRC-32 polynomial */ ; row = 1; ; for (n = 1; n < GF2_DIM; n++) { ; odd[n] = row; ; row <<= 1; ; } ; put operator for two zero bits in even ; gf2_matrix_square(even, odd); ; put operator for four zero bits in odd ; gf2_matrix_square(odd, even); ; apply len2 zeros to crc1 (first square will put the operator for one ; zero byte, eight zero bits, in even) ; do { ; apply zeros operator for this bit of len2 ; gf2_matrix_square(even, odd); ; if (len2 & 1) ; crc1 = gf2_matrix_times(even, crc1); ; len2 >>= 1; ; if no more bits set, then done ; if (len2 == 0) ; break; ; another iteration of the loop with odd and even swapped ; gf2_matrix_square(odd, even); ; if (len2 & 1) ; crc1 = gf2_matrix_times(odd, crc1); ; len2 >>= 1; ; if no more bits set, then done ; } while (len2 != 0); ; return combined crc ; crc1 ^= crc2; ; return crc1; ret endp ; ========================================================================= ;uLong (crc1, crc2, len2) ; uLong crc1 ; uLong crc2 ; z_off_t len2 align 4 proc crc32_combine, crc1:dword, crc2:dword, len2:dword stdcall crc32_combine_, [crc1], [crc2], [len2] ret endp ;uLong (crc1, crc2, len2) ; uLong crc1 ; uLong crc2 ; z_off64_t len2 align 4 proc crc32_combine64, crc1:dword, crc2:dword, len2:dword stdcall crc32_combine_, [crc1], [crc2], [len2] ret endp