[wxWidgets.git] / utils / Install / sfxzip / crc_i386.asm

; crc_i386.asm, optimized CRC calculation function for Zip and UnZip, not
; copyrighted by Paul Kienitz and Christian Spieler.  Last revised 25 Mar 98.
;
; 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 ...)
;
; FLAT memory model assumed.
;
; The loop unrolling can be disabled by defining the macro NO_UNROLLED_LOOPS.
; This results in shorter code at the expense of reduced performance.
;
; Revised 25-Mar-98, Cosmin Truta (cosmint@cs.ubbcluj.ro)
;   Working without .model directive caused tasm32 version 5.0 to produce
;   bad object code. The optimized alignments can be optionally disabled
;   by defining NO_ALIGN, thus allowing to use .model flat. There is no need
;   to define this macro if using other version of tasm.
;
;==============================================================================
;
; Do NOT assemble this source if external crc32 routine from zlib gets used.
;
    IFNDEF USE_ZLIB
;
        .386p
        name    crc_i386

    IFDEF NO_ALIGN
        .model flat
    ENDIF

extrn   _get_crc_table:near    ; ZCONST ulg near *get_crc_table(void);

;
    IFNDEF NO_STD_STACKFRAME
        ; Use a `standard' stack frame setup on routine entry and exit.
        ; Actually, this option is set as default, because it results
        ; in smaller code !!
STD_ENTRY       MACRO
                push    ebp
                mov     ebp,esp
        ENDM

        Arg1    EQU     08H[ebp]
        Arg2    EQU     0CH[ebp]
        Arg3    EQU     10H[ebp]

STD_LEAVE       MACRO
                pop     ebp
        ENDM

    ELSE  ; NO_STD_STACKFRAME

STD_ENTRY       MACRO
        ENDM

        Arg1    EQU     18H[esp]
        Arg2    EQU     1CH[esp]
        Arg3    EQU     20H[esp]

STD_LEAVE       MACRO
        ENDM

    ENDIF ; ?NO_STD_STACKFRAME

; 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 ; optimize for 386, 486, Pentium
Do_CRC  MACRO
                mov     bl,al                ; tmp = c & 0xFF
                shr     eax,8                ; c = (c >> 8)
                xor     eax,[edi+ebx*4]      ;  ^ table[tmp]
        ENDM
    ELSE ; __686 : optimize for Pentium Pro, Pentium II and compatible CPUs
Do_CRC  MACRO
                movzx   ebx,al               ; tmp = c & 0xFF
                shr     eax,8                ; c = (c >> 8)
                xor     eax,[edi+ebx*4]      ;  ^ table[tmp]
        ENDM
    ENDIF ; ?__686
Do_CRC_byte     MACRO
                xor     al, byte ptr [esi]   ; c ^= *buf
                inc     esi                  ; buf++
                Do_CRC                       ; c = (c >> 8) ^ table[c & 0xFF]
        ENDM
    IFNDEF  NO_32_BIT_LOADS
Do_CRC_dword    MACRO
                xor     eax, dword ptr [esi] ; c ^= *(ulg *)buf
                add     esi, 4               ; ((ulg *)buf)++
                Do_CRC
                Do_CRC
                Do_CRC
                Do_CRC
        ENDM
    ENDIF ; !NO_32_BIT_LOADS

    IFNDEF NO_ALIGN
_TEXT   segment use32 para public 'CODE'
    ELSE
_TEXT   segment use32
    ENDIF
        assume  CS: _TEXT

        public  _crc32
_crc32          proc    near  ; ulg crc32(ulg crc, ZCONST uch *buf, extent len)
                STD_ENTRY
                push    edi
                push    esi
                push    ebx
                push    edx
                push    ecx

                mov     esi,Arg2             ; 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,Arg1             ; 1st arg: ulg crc
    IFNDEF __686
                sub     ebx,ebx              ; ebx=0; make bl usable as a dword
    ENDIF
                mov     ecx,Arg3             ; 3rd arg: extent len
                not     eax                  ;>   c = ~crc;

    IFNDEF  NO_UNROLLED_LOOPS
    IFNDEF  NO_32_BIT_LOADS
                test    ecx,ecx
                je      bail
align_loop:
                test    esi,3                ; align buf pointer on next
                jz      SHORT aligned_now    ;  dword boundary
                Do_CRC_byte
                dec     ecx
                jnz     align_loop
aligned_now:
    ENDIF ; !NO_32_BIT_LOADS
                mov     edx,ecx              ; save len in edx
                and     edx,000000007H       ; edx = len % 8
                shr     ecx,3                ; ecx = len / 8
                jz      SHORT No_Eights
    IFNDEF NO_ALIGN
; align loop head at start of 486 internal cache line !!
                align   16
    ENDIF
Next_Eight:
    IFNDEF  NO_32_BIT_LOADS
                Do_CRC_dword
                Do_CRC_dword
    ELSE ; NO_32_BIT_LOADS
                Do_CRC_byte
                Do_CRC_byte
                Do_CRC_byte
                Do_CRC_byte
                Do_CRC_byte
                Do_CRC_byte
                Do_CRC_byte
                Do_CRC_byte
    ENDIF ; ?NO_32_BIT_LOADS
                dec     ecx
                jnz     Next_Eight
No_Eights:
                mov     ecx,edx

    ENDIF ; NO_UNROLLED_LOOPS
    IFNDEF  NO_JECXZ_SUPPORT
                jecxz   bail                 ;>   if (len)
    ELSE
                test    ecx,ecx              ;>   if (len)
                jz      SHORT bail
    ENDIF
    IFNDEF NO_ALIGN
; align loop head at start of 486 internal cache line !!
                align   16
    ENDIF
loupe:                                       ;>     do {
                Do_CRC_byte                  ;        c = CRC32(c, *buf++);
                dec     ecx                  ;>     } while (--len);
                jnz     loupe

bail:                                        ;> }
                not     eax                  ;> return ~c;
fine:
                pop     ecx
                pop     edx
                pop     ebx
                pop     esi
                pop     edi
                STD_LEAVE
                ret
_crc32          endp

_TEXT   ends
;
    ENDIF ; !USE_ZLIB
;
end
Commit	Line	Data
f6bcfd97 BP	1	; crc_i386.asm, optimized CRC calculation function for Zip and UnZip, not
	2	; copyrighted by Paul Kienitz and Christian Spieler. Last revised 25 Mar 98.
	3	;
	4	; Revised 06-Oct-96, Scott Field (sfield@microsoft.com)
	5	; fixed to assemble with masm by not using .model directive which makes
	6	; assumptions about segment alignment. Also,
	7	; avoid using loop, and j[e]cxz where possible. Use mov + inc, rather
	8	; than lodsb, and other misc. changes resulting in the following performance
	9	; increases:
	10	;
	11	; unrolled loops NO_UNROLLED_LOOPS
	12	; 8 >8 <8 8 >8 <8
	13	;
	14	; +54% +42% +35% +82% +52% +25%
	15	;
	16	; first item in each table is input buffer length, even multiple of 8
	17	; second item in each table is input buffer length, > 8
	18	; third item in each table is input buffer length, < 8
	19	;
	20	; Revised 02-Apr-97, Chr. Spieler, based on Rodney Brown (rdb@cmutual.com.au)
	21	; Incorporated Rodney Brown's 32-bit-reads optimization as found in the
	22	; UNIX AS source crc_i386.S. This new code can be disabled by defining
	23	; the macro symbol NO_32_BIT_LOADS.
	24	;
	25	; Revised 12-Oct-97, Chr. Spieler, based on Rodney Brown (rdb@cmutual.com.au)
	26	; Incorporated Rodney Brown's additional tweaks for 32-bit-optimized CPUs
	27	; (like the Pentium Pro, Pentium II, and probably some Pentium clones).
	28	; This optimization is controlled by the macro symbol __686 and is disabled
	29	; by default. (This default is based on the assumption that most users
	30	; do not yet work on a Pentium Pro or Pentium II machine ...)
	31	;
	32	; FLAT memory model assumed.
	33	;
	34	; The loop unrolling can be disabled by defining the macro NO_UNROLLED_LOOPS.
	35	; This results in shorter code at the expense of reduced performance.
	36	;
	37	; Revised 25-Mar-98, Cosmin Truta (cosmint@cs.ubbcluj.ro)
	38	; Working without .model directive caused tasm32 version 5.0 to produce
	39	; bad object code. The optimized alignments can be optionally disabled
	40	; by defining NO_ALIGN, thus allowing to use .model flat. There is no need
	41	; to define this macro if using other version of tasm.
	42	;
	43	;==============================================================================
	44	;
	45	; Do NOT assemble this source if external crc32 routine from zlib gets used.
	46	;
	47	IFNDEF USE_ZLIB
	48	;
	49	.386p
	50	name crc_i386
	51
	52	IFDEF NO_ALIGN
	53	.model flat
	54	ENDIF
	55
	56	extrn _get_crc_table:near ; ZCONST ulg near *get_crc_table(void);
	57
	58	;
	59	IFNDEF NO_STD_STACKFRAME
	60	; Use a `standard' stack frame setup on routine entry and exit.
	61	; Actually, this option is set as default, because it results
	62	; in smaller code !!
	63	STD_ENTRY MACRO
	64	push ebp
65	mov ebp,esp
66	ENDM
67
68	Arg1 EQU 08H[ebp]
69	Arg2 EQU 0CH[ebp]
70	Arg3 EQU 10H[ebp]
71
72	STD_LEAVE MACRO
73	pop ebp
74	ENDM
75
76	ELSE ; NO_STD_STACKFRAME
77
78	STD_ENTRY MACRO
79	ENDM
80
81	Arg1 EQU 18H[esp]
82	Arg2 EQU 1CH[esp]
83	Arg3 EQU 20H[esp]
84
85	STD_LEAVE MACRO
86	ENDM
87
88	ENDIF ; ?NO_STD_STACKFRAME
89
90	; These two (three) macros make up the loop body of the CRC32 cruncher.
91	; registers modified:
92	; eax : crc value "c"
93	; esi : pointer to next data byte (or dword) "buf++"
94	; registers read:
95	; edi : pointer to base of crc_table array
96	; scratch registers:
97	; ebx : index into crc_table array
98	; (requires upper three bytes = 0 when __686 is undefined)
99	IFNDEF __686 ; optimize for 386, 486, Pentium
100	Do_CRC MACRO
101	mov bl,al ; tmp = c & 0xFF
102	shr eax,8 ; c = (c >> 8)
103	xor eax,[edi+ebx*4] ; ^ table[tmp]
104	ENDM
105	ELSE ; __686 : optimize for Pentium Pro, Pentium II and compatible CPUs
106	Do_CRC MACRO
107	movzx ebx,al ; tmp = c & 0xFF
108	shr eax,8 ; c = (c >> 8)
109	xor eax,[edi+ebx*4] ; ^ table[tmp]
110	ENDM
111	ENDIF ; ?__686
112	Do_CRC_byte MACRO
113	xor al, byte ptr [esi] ; c ^= *buf
114	inc esi ; buf++
115	Do_CRC ; c = (c >> 8) ^ table[c & 0xFF]
116	ENDM
117	IFNDEF NO_32_BIT_LOADS
118	Do_CRC_dword MACRO
119	xor eax, dword ptr [esi] ; c ^= (ulg )buf
120	add esi, 4 ; ((ulg *)buf)++
121	Do_CRC
122	Do_CRC
123	Do_CRC
124	Do_CRC
125	ENDM
126	ENDIF ; !NO_32_BIT_LOADS
127
128	IFNDEF NO_ALIGN
129	_TEXT segment use32 para public 'CODE'
130	ELSE
131	_TEXT segment use32
132	ENDIF
133	assume CS: _TEXT
134
135	public _crc32
136	_crc32 proc near ; ulg crc32(ulg crc, ZCONST uch *buf, extent len)
137	STD_ENTRY
138	push edi
139	push esi
140	push ebx
141	push edx
142	push ecx
143
144	mov esi,Arg2 ; 2nd arg: uch *buf
145	sub eax,eax ;> if (!buf)
146	test esi,esi ;> return 0;
147	jz fine ;> else {
148
149	call _get_crc_table
150	mov edi,eax
151	mov eax,Arg1 ; 1st arg: ulg crc
152	IFNDEF __686
153	sub ebx,ebx ; ebx=0; make bl usable as a dword
154	ENDIF
155	mov ecx,Arg3 ; 3rd arg: extent len
156	not eax ;> c = ~crc;
157
158	IFNDEF NO_UNROLLED_LOOPS
159	IFNDEF NO_32_BIT_LOADS
160	test ecx,ecx
161	je bail
162	align_loop:
163	test esi,3 ; align buf pointer on next
164	jz SHORT aligned_now ; dword boundary
165	Do_CRC_byte
166	dec ecx
167	jnz align_loop
168	aligned_now:
169	ENDIF ; !NO_32_BIT_LOADS
170	mov edx,ecx ; save len in edx
171	and edx,000000007H ; edx = len % 8
172	shr ecx,3 ; ecx = len / 8
173	jz SHORT No_Eights
174	IFNDEF NO_ALIGN
175	; align loop head at start of 486 internal cache line !!
176	align 16
177	ENDIF
178	Next_Eight:
179	IFNDEF NO_32_BIT_LOADS
180	Do_CRC_dword
181	Do_CRC_dword
182	ELSE ; NO_32_BIT_LOADS
183	Do_CRC_byte
184	Do_CRC_byte
185	Do_CRC_byte
186	Do_CRC_byte
187	Do_CRC_byte
188	Do_CRC_byte
189	Do_CRC_byte
190	Do_CRC_byte
191	ENDIF ; ?NO_32_BIT_LOADS
192	dec ecx
193	jnz Next_Eight
194	No_Eights:
195	mov ecx,edx
196
197	ENDIF ; NO_UNROLLED_LOOPS
198	IFNDEF NO_JECXZ_SUPPORT
199	jecxz bail ;> if (len)
200	ELSE
201	test ecx,ecx ;> if (len)
202	jz SHORT bail
203	ENDIF
204	IFNDEF NO_ALIGN
205	; align loop head at start of 486 internal cache line !!
206	align 16
207	ENDIF
208	loupe: ;> do {
209	Do_CRC_byte ; c = CRC32(c, *buf++);
210	dec ecx ;> } while (--len);
211	jnz loupe
212
213	bail: ;> }
214	not eax ;> return ~c;
215	fine:
216	pop ecx
217	pop edx
218	pop ebx
219	pop esi
220	pop edi
221	STD_LEAVE
222	ret
223	_crc32 endp
224
225	_TEXT ends
226	;
227	ENDIF ; !USE_ZLIB
228	;
229	end