| 0,0 → 1,310 |
|---|
| /* |
| Copyright (c) 1990-2007 Info-ZIP. All rights reserved. |
| |
| See the accompanying file LICENSE, version 2000-Apr-09 or later |
| (the contents of which are also included in zip.h) for terms of use. |
| If, for some reason, all these files are missing, the Info-ZIP license |
| also may be found at: ftp://ftp.info-zip.org/pub/infozip/license.html |
| */ |
| /* crc_i386.c -- Microsoft 32-bit C/C++ adaptation of crc_i386.asm |
| * Created by Rodney Brown from crc_i386.asm, modified by Chr. Spieler. |
| * Last revised: 07-Jan-2007 |
| * |
| * Original coded (in crc_i386.asm) and put into the public domain |
| * by Paul Kienitz and Christian Spieler. |
| * |
| * Revised 06-Oct-96, Scott Field (sfield@microsoft.com) |
| * fixed to assemble with masm by not using .model directive which makes |
| * assumptions about segment alignment. Also, |
| * avoid using loop, and j[e]cxz where possible. Use mov + inc, rather |
| * than lodsb, and other misc. changes resulting in the following performance |
| * increases: |
| * |
| * unrolled loops NO_UNROLLED_LOOPS |
| * *8 >8 <8 *8 >8 <8 |
| * |
| * +54% +42% +35% +82% +52% +25% |
| * |
| * first item in each table is input buffer length, even multiple of 8 |
| * second item in each table is input buffer length, > 8 |
| * third item in each table is input buffer length, < 8 |
| * |
| * Revised 02-Apr-97, Chr. Spieler, based on Rodney Brown (rdb@cmutual.com.au) |
| * Incorporated Rodney Brown's 32-bit-reads optimization as found in the |
| * UNIX AS source crc_i386.S. This new code can be disabled by defining |
| * the macro symbol NO_32_BIT_LOADS. |
| * |
| * Revised 12-Oct-97, Chr. Spieler, based on Rodney Brown (rdb@cmutual.com.au) |
| * Incorporated Rodney Brown's additional tweaks for 32-bit-optimized CPUs |
| * (like the Pentium Pro, Pentium II, and probably some Pentium clones). |
| * This optimization is controlled by the macro symbol __686 and is disabled |
| * by default. (This default is based on the assumption that most users |
| * do not yet work on a Pentium Pro or Pentium II machine ...) |
| * |
| * Revised 16-Nov-97, Chr. Spieler: Made code compatible with Borland C++ |
| * 32-bit, removed unneeded kludge for potentially unknown movzx mnemonic, |
| * confirmed correct working with MS VC++ (32-bit). |
| * |
| * Revised 22-May-98, Peter Kunath, Chr. Spieler: The 16-Nov-97 revision broke |
| * MSVC 5.0. Inside preprocessor macros, each instruction is enclosed in its |
| * own __asm {...} construct. For MSVC, a "#pragma warning" was added to |
| * shut up the "no return value" warning message. |
| * |
| * Revised 13-Dec-98, Chr. Spieler: Modified path to "zip.h" header file. |
| * |
| * Revised 16-Jan-2005, Cosmin Truta: Added the ASM_CRC guard, for easier |
| * switching between ASM vs. non-ASM builds, when handling makefiles. |
| * Also enabled the 686 build by default, because there are hardly any |
| * pre-686 CPUs in serious use nowadays. (See the 12-Oct-97 note above.) |
| * |
| * Revised 03-Jan-2006, Chr. Spieler |
| * Enlarged unrolling loops to "do 16 bytes per turn"; optimized access to |
| * data buffer in loop body (adjust pointer only once in loop body and use |
| * offsets to access each item); added additional support for the "unfolded |
| * tables" optimization variant (enabled by IZ_CRCOPTIM_UNFOLDTBL). |
| * |
| * Revised 07-Jan-2007, Chr. Spieler |
| * Recognize additional conditional flag CRC_TABLE_ONLY that prevents |
| * compilation of the crc32() function. |
| * |
| * FLAT memory model assumed. |
| * |
| * Loop unrolling can be disabled by defining the macro NO_UNROLLED_LOOPS. |
| * This results in shorter code at the expense of reduced performance. |
| * |
| */ |
| |
| #include "../zip.h" |
| #include "../crc32.h" |
| |
| #if defined(ASM_CRC) && !defined(USE_ZLIB) && !defined(CRC_TABLE_ONLY) |
| |
| #if !defined(PRE_686) && !defined(__686) |
| # define __686 |
| #endif |
| |
| #ifndef ZCONST |
| # define ZCONST const |
| #endif |
| |
| /* Select wether the following inline-assember code is supported. */ |
| #if (defined(_MSC_VER) && _MSC_VER >= 700) |
| #if (defined(_M_IX86) && _M_IX86 >= 300) |
| # define MSC_INLINE_ASM_32BIT_SUPPORT |
| /* Disable warning for no return value, typical of asm functions */ |
| # pragma warning( disable : 4035 ) |
| #endif |
| #endif |
| |
| #if (defined(__BORLANDC__) && __BORLANDC__ >= 452) |
| # define MSC_INLINE_ASM_32BIT_SUPPORT |
| #endif |
| |
| #ifdef MSC_INLINE_ASM_32BIT_SUPPORT |
| /* This code is intended for Microsoft C/C++ (32-bit) compatible compilers. */ |
| |
| /* |
| * These two (three) macros make up the loop body of the CRC32 cruncher. |
| * registers modified: |
| * eax : crc value "c" |
| * esi : pointer to next data byte (or dword) "buf++" |
| * registers read: |
| * edi : pointer to base of crc_table array |
| * scratch registers: |
| * ebx : index into crc_table array |
| * (requires upper three bytes = 0 when __686 is undefined) |
| */ |
| #ifndef __686 |
| #define Do_CRC { \ |
| __asm { mov bl, al }; \ |
| __asm { shr eax, 8 }; \ |
| __asm { xor eax, [edi+ebx*4] }; } |
| #else /* __686 */ |
| #define Do_CRC { \ |
| __asm { movzx ebx, al }; \ |
| __asm { shr eax, 8 }; \ |
| __asm { xor eax, [edi+ebx*4] }; } |
| #endif /* ?__686 */ |
| |
| #define Do_CRC_byte { \ |
| __asm { xor al, byte ptr [esi] }; \ |
| __asm { inc esi }; \ |
| Do_CRC; } |
| |
| #define Do_CRC_byteof(ofs) { \ |
| __asm { xor al, byte ptr [esi+(ofs)] }; \ |
| Do_CRC; } |
| |
| #ifndef NO_32_BIT_LOADS |
| #ifdef IZ_CRCOPTIM_UNFOLDTBL |
| # define SavLen len /* the edx register is needed elsewhere */ |
| # define UpdCRC_dword { \ |
| __asm { movzx ebx,al }; \ |
| __asm { mov edx,[edi+ebx*4+3072] }; \ |
| __asm { movzx ebx,ah }; \ |
| __asm { shr eax,16 }; \ |
| __asm { xor edx,[edi+ebx*4+2048] }; \ |
| __asm { movzx ebx,al }; \ |
| __asm { shr eax,8 }; \ |
| __asm { xor edx,[edi+ebx*4+1024] }; \ |
| __asm { mov eax,[edi+eax*4] }; \ |
| __asm { xor eax,edx }; } |
| # define UpdCRC_dword_sh(dwPtrIncr) { \ |
| __asm { movzx ebx,al }; \ |
| __asm { mov edx,[edi+ebx*4+3072] }; \ |
| __asm { movzx ebx,ah }; \ |
| __asm { xor edx,[edi+ebx*4+2048] }; \ |
| __asm { shr eax,16 }; \ |
| __asm { movzx ebx,al }; \ |
| __asm { add esi, 4*dwPtrIncr }; \ |
| __asm { shr eax,8 }; \ |
| __asm { xor edx,[edi+ebx*4+1024] }; \ |
| __asm { mov eax,[edi+eax*4] }; \ |
| __asm { xor eax,edx }; } |
| #else /* !IZ_CRCOPTIM_UNFOLDTBL */ |
| # define SavLen edx /* the edx register is free for use here */ |
| # define UpdCRC_dword { \ |
| Do_CRC; \ |
| Do_CRC; \ |
| Do_CRC; \ |
| Do_CRC; } |
| # define UpdCRC_dword_sh(dwPtrIncr) { \ |
| Do_CRC; \ |
| Do_CRC; \ |
| __asm { add esi, 4*(dwPtrIncr) }; \ |
| Do_CRC; \ |
| Do_CRC; } |
| #endif /* ?IZ_CRCOPTIM_UNFOLDTBL */ |
| |
| #define Do_CRC_dword { \ |
| __asm { xor eax, dword ptr [esi] }; \ |
| UpdCRC_dword_sh(1); } |
| |
| #define Do_CRC_4dword { \ |
| __asm { xor eax, dword ptr [esi] }; \ |
| UpdCRC_dword; \ |
| __asm { xor eax, dword ptr [esi+4] }; \ |
| UpdCRC_dword; \ |
| __asm { xor eax, dword ptr [esi+8] }; \ |
| UpdCRC_dword; \ |
| __asm { xor eax, dword ptr [esi+12] }; \ |
| UpdCRC_dword_sh(4); } |
| #endif /* !NO_32_BIT_LOADS */ |
| |
| /* ========================================================================= */ |
| ulg crc32(crc, buf, len) |
| ulg crc; /* crc shift register */ |
| ZCONST uch *buf; /* pointer to bytes to pump through */ |
| extent len; /* number of bytes in buf[] */ |
| /* Run a set of bytes through the crc shift register. If buf is a NULL |
| pointer, then initialize the crc shift register contents instead. |
| Return the current crc in either case. */ |
| { |
| __asm { |
| push edx |
| push ecx |
| |
| mov esi,buf ;/* 2nd arg: uch *buf */ |
| sub eax,eax ;/*> if (!buf) */ |
| test esi,esi ;/*> return 0; */ |
| jz fine ;/*> else { */ |
| |
| call get_crc_table |
| mov edi,eax |
| mov eax,crc ;/* 1st arg: ulg crc */ |
| #ifndef __686 |
| sub ebx,ebx ;/* ebx=0; => bl usable as a dword */ |
| #endif |
| mov ecx,len ;/* 3rd arg: extent len */ |
| not eax ;/*> c = ~crc; */ |
| |
| test ecx,ecx |
| #ifndef NO_UNROLLED_LOOPS |
| jz bail |
| # ifndef NO_32_BIT_LOADS |
| align_loop: |
| test esi,3 ;/* align buf pointer on next */ |
| jz aligned_now ;/* dword boundary */ |
| } |
| Do_CRC_byte ; |
| __asm { |
| dec ecx |
| jnz align_loop |
| aligned_now: |
| # endif /* !NO_32_BIT_LOADS */ |
| mov SavLen,ecx ;/* save current len for later */ |
| shr ecx,4 ;/* ecx = len / 16 */ |
| jz No_Sixteens |
| ; align loop head at start of 486 internal cache line !! |
| align 16 |
| Next_Sixteen: |
| } |
| # ifndef NO_32_BIT_LOADS |
| Do_CRC_4dword ; |
| # else /* NO_32_BIT_LOADS */ |
| Do_CRC_byteof(0) ; |
| Do_CRC_byteof(1) ; |
| Do_CRC_byteof(2) ; |
| Do_CRC_byteof(3) ; |
| Do_CRC_byteof(4) ; |
| Do_CRC_byteof(5) ; |
| Do_CRC_byteof(6) ; |
| Do_CRC_byteof(7) ; |
| Do_CRC_byteof(8) ; |
| Do_CRC_byteof(9) ; |
| Do_CRC_byteof(10) ; |
| Do_CRC_byteof(11) ; |
| Do_CRC_byteof(12) ; |
| Do_CRC_byteof(13) ; |
| Do_CRC_byteof(14) ; |
| Do_CRC_byteof(15) ; |
| __asm { add esi,16 }; |
| # endif /* ?NO_32_BIT_LOADS */ |
| __asm { |
| dec ecx |
| jnz Next_Sixteen |
| No_Sixteens: |
| mov ecx,SavLen |
| and ecx,00000000FH ;/* ecx = len % 16 */ |
| # ifndef NO_32_BIT_LOADS |
| shr ecx,2 |
| jz No_Fours |
| Next_Four: |
| } |
| Do_CRC_dword ; |
| __asm { |
| dec ecx |
| jnz Next_Four |
| No_Fours: |
| mov ecx,SavLen |
| and ecx,000000003H ;/* ecx = len % 4 */ |
| # endif /* !NO_32_BIT_LOADS */ |
| #endif /* !NO_UNROLLED_LOOPS */ |
| jz bail ;/*> if (len) */ |
| ; align loop head at start of 486 internal cache line !! |
| align 16 |
| loupe: ;/*> do { */ |
| } |
| Do_CRC_byte ;/* c = CRC32(c,*buf++,crctab);*/ |
| __asm { |
| dec ecx ;/*> } while (--len); */ |
| jnz loupe |
| |
| bail: ;/*> } */ |
| not eax ;/*> return ~c; */ |
| fine: |
| pop ecx |
| pop edx |
| } |
| #ifdef NEED_RETURN |
| return _EAX; |
| #endif |
| } |
| #endif /* MSC_INLINE_ASM_32BIT_SUPPORT */ |
| #if (defined(_MSC_VER) && _MSC_VER >= 700) |
| #if (defined(_M_IX86) && _M_IX86 >= 300) |
| /* Reenable missing return value warning */ |
| # pragma warning( default : 4035 ) |
| #endif |
| #endif |
| #endif /* ASM_CRC && !USE_ZLIB && !CRC_TABLE_ONLY */ |