path: root/cpukit/zlib/contrib/masmx86/gvmat32.asm

;
; gvmat32.asm -- Asm portion of the optimized longest_match for 32 bits x86
; Copyright (C) 1995-1996 Jean-loup Gailly and Gilles Vollant.
; File written by Gilles Vollant, by modifiying the longest_match
;  from Jean-loup Gailly in deflate.c
; It need wmask == 0x7fff
;     (assembly code is faster with a fixed wmask)
;
; For Visual C++ 4.2 and ML 6.11c (version in directory \MASM611C of Win95 DDK)
;   I compile with : "ml /coff /Zi /c gvmat32.asm"
;

;uInt longest_match_7fff(s, cur_match)
;    deflate_state *s;
;    IPos cur_match;                             /* current match */

	NbStack         equ     76
	cur_match       equ     dword ptr[esp+NbStack-0]
	str_s           equ     dword ptr[esp+NbStack-4]
; 5 dword on top (ret,ebp,esi,edi,ebx)
	adrret          equ     dword ptr[esp+NbStack-8]
	pushebp         equ     dword ptr[esp+NbStack-12]
	pushedi         equ     dword ptr[esp+NbStack-16]
	pushesi         equ     dword ptr[esp+NbStack-20]
	pushebx         equ     dword ptr[esp+NbStack-24]

	chain_length    equ     dword ptr [esp+NbStack-28]
	limit           equ     dword ptr [esp+NbStack-32]
	best_len        equ     dword ptr [esp+NbStack-36]
	window          equ     dword ptr [esp+NbStack-40]
	prev            equ     dword ptr [esp+NbStack-44]
	scan_start      equ      word ptr [esp+NbStack-48]
	wmask           equ     dword ptr [esp+NbStack-52]
	match_start_ptr equ     dword ptr [esp+NbStack-56]
	nice_match      equ     dword ptr [esp+NbStack-60]
	scan            equ     dword ptr [esp+NbStack-64]

	windowlen       equ     dword ptr [esp+NbStack-68]
	match_start     equ     dword ptr [esp+NbStack-72]
	strend          equ     dword ptr [esp+NbStack-76]
	NbStackAdd      equ     (NbStack-24)

    .386p

    name    gvmatch
    .MODEL  FLAT



;  all the +addstr offsets are due to the addition of pending_buf_size in zlib 1.04
;  and adding gzhead and gzindex in zlib 1.2.2.1
;  in the deflate_state structure since the asm code was first written
;  (if you compile with zlib 1.0.4 or older, set addstr to 0).
;  (if you compiler with zlib between 1.04 and 1.2.1, set addstr to 4)
;  Note : these value are good with a 8 bytes boundary pack structure

    addstr              equ     4+8
    dep_chain_length    equ     70h+addstr
    dep_window          equ     2ch+addstr
    dep_strstart        equ     60h+addstr
    dep_prev_length     equ     6ch+addstr
    dep_nice_match      equ     84h+addstr
    dep_w_size          equ     20h+addstr
    dep_prev            equ     34h+addstr
    dep_w_mask          equ     28h+addstr
    dep_good_match      equ     80h+addstr
    dep_match_start     equ     64h+addstr
    dep_lookahead       equ     68h+addstr


_TEXT                   segment

IFDEF NOUNDERLINE
			public  longest_match_7fff
			public  longest_match_686
;                        public  match_init
ELSE
			public  _longest_match_7fff
			public  _longest_match_686
;                        public  _match_init
ENDIF

    MAX_MATCH           equ     258
    MIN_MATCH           equ     3
    MIN_LOOKAHEAD       equ     (MAX_MATCH+MIN_MATCH+1)



IFDEF NOUNDERLINE
;match_init      proc near
;                ret
;match_init      endp
ELSE
;_match_init     proc near
;                ret
;_match_init     endp
ENDIF


IFDEF NOUNDERLINE
longest_match_7fff   proc near
ELSE
_longest_match_7fff  proc near
ENDIF

	mov     edx,[esp+4]



	push    ebp
	push    edi
	push    esi
	push    ebx

	sub     esp,NbStackAdd

; initialize or check the variables used in match.asm.
	mov     ebp,edx

; chain_length = s->max_chain_length
; if (prev_length>=good_match) chain_length >>= 2
	mov     edx,[ebp+dep_chain_length]
	mov     ebx,[ebp+dep_prev_length]
	cmp     [ebp+dep_good_match],ebx
	ja      noshr
	shr     edx,2
noshr:
; we increment chain_length because in the asm, the --chain_lenght is in the beginning of the loop
	inc     edx
	mov     edi,[ebp+dep_nice_match]
	mov     chain_length,edx
	mov     eax,[ebp+dep_lookahead]
	cmp     eax,edi
; if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead;
	jae     nolookaheadnicematch
	mov     edi,eax
nolookaheadnicematch:
; best_len = s->prev_length
	mov     best_len,ebx

; window = s->window
	mov     esi,[ebp+dep_window]
	mov     ecx,[ebp+dep_strstart]
	mov     window,esi

	mov     nice_match,edi
; scan = window + strstart
	add     esi,ecx
	mov     scan,esi
; dx = *window
	mov     dx,word ptr [esi]
; bx = *(window+best_len-1)
	mov     bx,word ptr [esi+ebx-1]
	add     esi,MAX_MATCH-1
; scan_start = *scan
	mov     scan_start,dx
; strend = scan + MAX_MATCH-1
	mov     strend,esi
; bx = scan_end = *(window+best_len-1)

;    IPos limit = s->strstart > (IPos)MAX_DIST(s) ?
;        s->strstart - (IPos)MAX_DIST(s) : NIL;

	mov     esi,[ebp+dep_w_size]
	sub     esi,MIN_LOOKAHEAD
; here esi = MAX_DIST(s)
	sub     ecx,esi
	ja      nodist
	xor     ecx,ecx
nodist:
	mov     limit,ecx

; prev = s->prev
	mov     edx,[ebp+dep_prev]
	mov     prev,edx

;
	mov     edx,dword ptr [ebp+dep_match_start]
	mov     bp,scan_start
	mov     eax,cur_match
	mov     match_start,edx

	mov     edx,window
	mov     edi,edx
	add     edi,best_len
	mov     esi,prev
	dec     edi
; windowlen = window + best_len -1
	mov     windowlen,edi

	jmp     beginloop2
	align   4

; here, in the loop
;       eax = ax = cur_match
;       ecx = limit
;        bx = scan_end
;        bp = scan_start
;       edi = windowlen (window + best_len -1)
;       esi = prev


;// here; chain_length <=16
normalbeg0add16:
	add     chain_length,16
	jz      exitloop
normalbeg0:
	cmp     word ptr[edi+eax],bx
	je      normalbeg2noroll
rcontlabnoroll:
; cur_match = prev[cur_match & wmask]
	and     eax,7fffh
	mov     ax,word ptr[esi+eax*2]
; if cur_match > limit, go to exitloop
	cmp     ecx,eax
	jnb     exitloop
; if --chain_length != 0, go to exitloop
	dec     chain_length
	jnz     normalbeg0
	jmp     exitloop

normalbeg2noroll:
; if (scan_start==*(cur_match+window)) goto normalbeg2
	cmp     bp,word ptr[edx+eax]
	jne     rcontlabnoroll
	jmp     normalbeg2

contloop3:
	mov     edi,windowlen

; cur_match = prev[cur_match & wmask]
	and     eax,7fffh
	mov     ax,word ptr[esi+eax*2]
; if cur_match > limit, go to exitloop
	cmp     ecx,eax
jnbexitloopshort1:
	jnb     exitloop
; if --chain_length != 0, go to exitloop


; begin the main loop
beginloop2:
	sub     chain_length,16+1
; if chain_length <=16, don't use the unrolled loop
	jna     normalbeg0add16

do16:
	cmp     word ptr[edi+eax],bx
	je      normalbeg2dc0

maccn   MACRO   lab
	and     eax,7fffh
	mov     ax,word ptr[esi+eax*2]
	cmp     ecx,eax
	jnb     exitloop
	cmp     word ptr[edi+eax],bx
	je      lab
	ENDM

rcontloop0:
	maccn   normalbeg2dc1

rcontloop1:
	maccn   normalbeg2dc2

rcontloop2:
	maccn   normalbeg2dc3

rcontloop3:
	maccn   normalbeg2dc4

rcontloop4:
	maccn   normalbeg2dc5

rcontloop5:
	maccn   normalbeg2dc6

rcontloop6:
	maccn   normalbeg2dc7

rcontloop7:
	maccn   normalbeg2dc8

rcontloop8:
	maccn   normalbeg2dc9

rcontloop9:
	maccn   normalbeg2dc10

rcontloop10:
	maccn   short normalbeg2dc11

rcontloop11:
	maccn   short normalbeg2dc12

rcontloop12:
	maccn   short normalbeg2dc13

rcontloop13:
	maccn   short normalbeg2dc14

rcontloop14:
	maccn   short normalbeg2dc15

rcontloop15:
	and     eax,7fffh
	mov     ax,word ptr[esi+eax*2]
	cmp     ecx,eax
	jnb     exitloop

	sub     chain_length,16
	ja      do16
	jmp     normalbeg0add16

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

normbeg MACRO   rcontlab,valsub
; if we are here, we know that *(match+best_len-1) == scan_end
	cmp     bp,word ptr[edx+eax]
; if (match != scan_start) goto rcontlab
	jne     rcontlab
; calculate the good chain_length, and we'll compare scan and match string
	add     chain_length,16-valsub
	jmp     iseq
	ENDM


normalbeg2dc11:
	normbeg rcontloop11,11

normalbeg2dc12:
	normbeg short rcontloop12,12

normalbeg2dc13:
	normbeg short rcontloop13,13

normalbeg2dc14:
	normbeg short rcontloop14,14

normalbeg2dc15:
	normbeg short rcontloop15,15

normalbeg2dc10:
	normbeg rcontloop10,10

normalbeg2dc9:
	normbeg rcontloop9,9

normalbeg2dc8:
	normbeg rcontloop8,8

normalbeg2dc7:
	normbeg rcontloop7,7

normalbeg2dc6:
	normbeg rcontloop6,6

normalbeg2dc5:
	normbeg rcontloop5,5

normalbeg2dc4:
	normbeg rcontloop4,4

normalbeg2dc3:
	normbeg rcontloop3,3

normalbeg2dc2:
	normbeg rcontloop2,2

normalbeg2dc1:
	normbeg rcontloop1,1

normalbeg2dc0:
	normbeg rcontloop0,0


; we go in normalbeg2 because *(ushf*)(match+best_len-1) == scan_end

normalbeg2:
	mov     edi,window

	cmp     bp,word ptr[edi+eax]
	jne     contloop3                   ; if *(ushf*)match != scan_start, continue

iseq:
; if we are here, we know that *(match+best_len-1) == scan_end
; and (match == scan_start)

	mov     edi,edx
	mov     esi,scan                    ; esi = scan
	add     edi,eax                     ; edi = window + cur_match = match

	mov     edx,[esi+3]                 ; compare manually dword at match+3
	xor     edx,[edi+3]                 ; and scan +3

	jz      begincompare                ; if equal, go to long compare

; we will determine the unmatch byte and calculate len (in esi)
	or      dl,dl
	je      eq1rr
	mov     esi,3
	jmp     trfinval
eq1rr:
	or      dx,dx
	je      eq1

	mov     esi,4
	jmp     trfinval
eq1:
	and     edx,0ffffffh
	jz      eq11
	mov     esi,5
	jmp     trfinval
eq11:
	mov     esi,6
	jmp     trfinval

begincompare:
	; here we now scan and match begin same
	add     edi,6
	add     esi,6
	mov     ecx,(MAX_MATCH-(2+4))/4     ; scan for at most MAX_MATCH bytes
	repe    cmpsd                       ; loop until mismatch

	je      trfin                       ; go to trfin if not unmatch
; we determine the unmatch byte
	sub     esi,4
	mov     edx,[edi-4]
	xor     edx,[esi]

	or      dl,dl
	jnz     trfin
	inc     esi

	or      dx,dx
	jnz     trfin
	inc     esi

	and     edx,0ffffffh
	jnz     trfin
	inc     esi

trfin:
	sub     esi,scan          ; esi = len
trfinval:
; here we have finised compare, and esi contain len of equal string
	cmp     esi,best_len        ; if len > best_len, go newbestlen
	ja      short newbestlen
; now we restore edx, ecx and esi, for the big loop
	mov     esi,prev
	mov     ecx,limit
	mov     edx,window
	jmp     contloop3

newbestlen:
	mov     best_len,esi        ; len become best_len

	mov     match_start,eax     ; save new position as match_start
	cmp     esi,nice_match      ; if best_len >= nice_match, exit
	jae     exitloop
	mov     ecx,scan
	mov     edx,window          ; restore edx=window
	add     ecx,esi
	add     esi,edx

	dec     esi
	mov     windowlen,esi       ; windowlen = window + best_len-1
	mov     bx,[ecx-1]          ; bx = *(scan+best_len-1) = scan_end

; now we restore ecx and esi, for the big loop :
	mov     esi,prev
	mov     ecx,limit
	jmp     contloop3

exitloop:
; exit : s->match_start=match_start
	mov     ebx,match_start
	mov     ebp,str_s
	mov     ecx,best_len
	mov     dword ptr [ebp+dep_match_start],ebx
	mov     eax,dword ptr [ebp+dep_lookahead]
	cmp     ecx,eax
	ja      minexlo
	mov     eax,ecx
minexlo:
; return min(best_len,s->lookahead)

; restore stack and register ebx,esi,edi,ebp
	add     esp,NbStackAdd

	pop     ebx
	pop     esi
	pop     edi
	pop     ebp
	ret
InfoAuthor:
; please don't remove this string !
; Your are free use gvmat32 in any fre or commercial apps if you don't remove the string in the binary!
	db     0dh,0ah,"GVMat32 optimised assembly code written 1996-98 by Gilles Vollant",0dh,0ah



IFDEF NOUNDERLINE
longest_match_7fff   endp
ELSE
_longest_match_7fff  endp
ENDIF


IFDEF NOUNDERLINE
cpudetect32     proc near
ELSE
_cpudetect32    proc near
ENDIF

	push	ebx

	pushfd                  ; push original EFLAGS
	pop     eax             ; get original EFLAGS
	mov     ecx, eax        ; save original EFLAGS
	xor     eax, 40000h     ; flip AC bit in EFLAGS
	push    eax             ; save new EFLAGS value on stack
	popfd                   ; replace current EFLAGS value
	pushfd                  ; get new EFLAGS
	pop     eax             ; store new EFLAGS in EAX
	xor     eax, ecx        ; can’t toggle AC bit, processor=80386
	jz      end_cpu_is_386  ; jump if 80386 processor
	push    ecx
	popfd                   ; restore AC bit in EFLAGS first

	pushfd
	pushfd
	pop     ecx

	mov     eax, ecx        ; get original EFLAGS
	xor     eax, 200000h    ; flip ID bit in EFLAGS
	push    eax             ; save new EFLAGS value on stack
	popfd                   ; replace current EFLAGS value
	pushfd                  ; get new EFLAGS
	pop		eax	            ; store new EFLAGS in EAX
	popfd                   ; restore original EFLAGS
	xor		eax, ecx        ; can’t toggle ID bit,
	je		is_old_486		; processor=old

	mov     eax,1
	db      0fh,0a2h        ;CPUID

exitcpudetect:
	pop	ebx
	ret

end_cpu_is_386:
	mov     eax,0300h
	jmp     exitcpudetect

is_old_486:
	mov     eax,0400h
	jmp     exitcpudetect

IFDEF NOUNDERLINE
cpudetect32     endp
ELSE
_cpudetect32    endp
ENDIF




MAX_MATCH       equ     258
MIN_MATCH       equ     3
MIN_LOOKAHEAD   equ     (MAX_MATCH + MIN_MATCH + 1)
MAX_MATCH_8_     equ     ((MAX_MATCH + 7) AND 0FFF0h)


;;; stack frame offsets

chainlenwmask	equ  esp + 0	; high word: current chain len
					; low word: s->wmask
window		equ  esp + 4	; local copy of s->window
windowbestlen	equ  esp + 8	; s->window + bestlen
scanstart	equ  esp + 16	; first two bytes of string
scanend		equ  esp + 12	; last two bytes of string
scanalign	equ  esp + 20	; dword-misalignment of string
nicematch	equ  esp + 24	; a good enough match size
bestlen		equ  esp + 28	; size of best match so far
scan		equ  esp + 32	; ptr to string wanting match

LocalVarsSize	equ 36
;	saved ebx	byte esp + 36
;	saved edi	byte esp + 40
;	saved esi	byte esp + 44
;	saved ebp	byte esp + 48
;	return address	byte esp + 52
deflatestate	equ  esp + 56	; the function arguments
curmatch	equ  esp + 60

;;; Offsets for fields in the deflate_state structure. These numbers
;;; are calculated from the definition of deflate_state, with the
;;; assumption that the compiler will dword-align the fields. (Thus,
;;; changing the definition of deflate_state could easily cause this
;;; program to crash horribly, without so much as a warning at
;;; compile time. Sigh.)

dsWSize		equ 36+addstr-4
dsWMask		equ 44+addstr-4
dsWindow	equ 48+addstr-4
dsPrev		equ 56+addstr-4
dsMatchLen	equ 88+addstr-4
dsPrevMatch	equ 92+addstr-4
dsStrStart	equ 100+addstr-4
dsMatchStart	equ 104+addstr-4
dsLookahead	equ 108+addstr-4
dsPrevLen	equ 112+addstr-4
dsMaxChainLen	equ 116+addstr-4
dsGoodMatch	equ 132+addstr-4
dsNiceMatch	equ 136+addstr-4


;;; match.asm -- Pentium-Pro-optimized version of longest_match()
;;; Written for zlib 1.1.2
;;; Copyright (C) 1998 Brian Raiter <breadbox@muppetlabs.com>
;;; You can look at http://www.muppetlabs.com/~breadbox/software/assembly.html
;;;
;;; This is free software; you can redistribute it and/or modify it
;;; under the terms of the GNU General Public License.

;GLOBAL	_longest_match, _match_init


;SECTION	.text

;;; uInt longest_match(deflate_state *deflatestate, IPos curmatch)

;_longest_match:
IFDEF NOUNDERLINE
longest_match_686   proc near
ELSE
_longest_match_686  proc near
ENDIF


;;; Save registers that the compiler may be using, and adjust esp to
;;; make room for our stack frame.

		push	ebp
		push	edi
		push	esi
		push	ebx
		sub	esp, LocalVarsSize

;;; Retrieve the function arguments. ecx will hold cur_match
;;; throughout the entire function. edx will hold the pointer to the
;;; deflate_state structure during the function's setup (before
;;; entering the main loop.

		mov	edx, [deflatestate]
		mov	ecx, [curmatch]

;;; uInt wmask = s->w_mask;
;;; unsigned chain_length = s->max_chain_length;
;;; if (s->prev_length >= s->good_match) {
;;;     chain_length >>= 2;
;;; }

		mov	eax, [edx + dsPrevLen]
		mov	ebx, [edx + dsGoodMatch]
		cmp	eax, ebx
		mov	eax, [edx + dsWMask]
		mov	ebx, [edx + dsMaxChainLen]
		jl	LastMatchGood
		shr	ebx, 2
LastMatchGood:

;;; chainlen is decremented once beforehand so that the function can
;;; use the sign flag instead of the zero flag for the exit test.
;;; It is then shifted into the high word, to make room for the wmask
;;; value, which it will always accompany.

		dec	ebx
		shl	ebx, 16
		or	ebx, eax
		mov	[chainlenwmask], ebx

;;; if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead;

		mov	eax, [edx + dsNiceMatch]
		mov	ebx, [edx + dsLookahead]
		cmp	ebx, eax
		jl	LookaheadLess
		mov	ebx, eax
LookaheadLess:	mov	[nicematch], ebx

;;; register Bytef *scan = s->window + s->strstart;

		mov	esi, [edx + dsWindow]
		mov	[window], esi
		mov	ebp, [edx + dsStrStart]
		lea	edi, [esi + ebp]
		mov	[scan], edi

;;; Determine how many bytes the scan ptr is off from being
;;; dword-aligned.

		mov	eax, edi
		neg	eax
		and	eax, 3
		mov	[scanalign], eax

;;; IPos limit = s->strstart > (IPos)MAX_DIST(s) ?
;;;     s->strstart - (IPos)MAX_DIST(s) : NIL;

		mov	eax, [edx + dsWSize]
		sub	eax, MIN_LOOKAHEAD
		sub	ebp, eax
		jg	LimitPositive
		xor	ebp, ebp
LimitPositive:

;;; int best_len = s->prev_length;

		mov	eax, [edx + dsPrevLen]
		mov	[bestlen], eax

;;; Store the sum of s->window + best_len in esi locally, and in esi.

		add	esi, eax
		mov	[windowbestlen], esi

;;; register ush scan_start = *(ushf*)scan;
;;; register ush scan_end   = *(ushf*)(scan+best_len-1);
;;; Posf *prev = s->prev;

		movzx	ebx, word ptr [edi]
		mov	[scanstart], ebx
		movzx	ebx, word ptr [edi + eax - 1]
		mov	[scanend], ebx
		mov	edi, [edx + dsPrev]

;;; Jump into the main loop.

		mov	edx, [chainlenwmask]
		jmp	short LoopEntry

align 4

;;; do {
;;;     match = s->window + cur_match;
;;;     if (*(ushf*)(match+best_len-1) != scan_end ||
;;;         *(ushf*)match != scan_start) continue;
;;;     [...]
;;; } while ((cur_match = prev[cur_match & wmask]) > limit
;;;          && --chain_length != 0);
;;;
;;; Here is the inner loop of the function. The function will spend the
;;; majority of its time in this loop, and majority of that time will
;;; be spent in the first ten instructions.
;;;
;;; Within this loop:
;;; ebx = scanend
;;; ecx = curmatch
;;; edx = chainlenwmask - i.e., ((chainlen << 16) | wmask)
;;; esi = windowbestlen - i.e., (window + bestlen)
;;; edi = prev
;;; ebp = limit

LookupLoop:
		and	ecx, edx
		movzx	ecx, word ptr [edi + ecx*2]
		cmp	ecx, ebp
		jbe	LeaveNow
		sub	edx, 00010000h
		js	LeaveNow
LoopEntry:	movzx	eax, word ptr [esi + ecx - 1]
		cmp	eax, ebx
		jnz	LookupLoop
		mov	eax, [window]
		movzx	eax, word ptr [eax + ecx]
		cmp	eax, [scanstart]
		jnz	LookupLoop

;;; Store the current value of chainlen.

		mov	[chainlenwmask], edx

;;; Point edi to the string under scrutiny, and esi to the string we
;;; are hoping to match it up with. In actuality, esi and edi are
;;; both pointed (MAX_MATCH_8 - scanalign) bytes ahead, and edx is
;;; initialized to -(MAX_MATCH_8 - scanalign).

		mov	esi, [window]
		mov	edi, [scan]
		add	esi, ecx
		mov	eax, [scanalign]
		mov	edx, 0fffffef8h; -(MAX_MATCH_8)
		lea	edi, [edi + eax + 0108h] ;MAX_MATCH_8]
		lea	esi, [esi + eax + 0108h] ;MAX_MATCH_8]

;;; Test the strings for equality, 8 bytes at a time. At the end,
;;; adjust edx so that it is offset to the exact byte that mismatched.
;;;
;;; We already know at this point that the first three bytes of the
;;; strings match each other, and they can be safely passed over before
;;; starting the compare loop. So what this code does is skip over 0-3
;;; bytes, as much as necessary in order to dword-align the edi
;;; pointer. (esi will still be misaligned three times out of four.)
;;;
;;; It should be confessed that this loop usually does not represent
;;; much of the total running time. Replacing it with a more
;;; straightforward "rep cmpsb" would not drastically degrade
;;; performance.

LoopCmps:
		mov	eax, [esi + edx]
		xor	eax, [edi + edx]
		jnz	LeaveLoopCmps
		mov	eax, [esi + edx + 4]
		xor	eax, [edi + edx + 4]
		jnz	LeaveLoopCmps4
		add	edx, 8
		jnz	LoopCmps
		jmp	short LenMaximum
LeaveLoopCmps4:	add	edx, 4
LeaveLoopCmps:	test	eax, 0000FFFFh
		jnz	LenLower
		add	edx,  2
		shr	eax, 16
LenLower:	sub	al, 1
		adc	edx, 0

;;; Calculate the length of the match. If it is longer than MAX_MATCH,
;;; then automatically accept it as the best possible match and leave.

		lea	eax, [edi + edx]
		mov	edi, [scan]
		sub	eax, edi
		cmp	eax, MAX_MATCH
		jge	LenMaximum

;;; If the length of the match is not longer than the best match we
;;; have so far, then forget it and return to the lookup loop.

		mov	edx, [deflatestate]
		mov	ebx, [bestlen]
		cmp	eax, ebx
		jg	LongerMatch
		mov	esi, [windowbestlen]
		mov	edi, [edx + dsPrev]
		mov	ebx, [scanend]
		mov	edx, [chainlenwmask]
		jmp	LookupLoop

;;;         s->match_start = cur_match;
;;;         best_len = len;
;;;         if (len >= nice_match) break;
;;;         scan_end = *(ushf*)(scan+best_len-1);

LongerMatch:	mov	ebx, [nicematch]
		mov	[bestlen], eax
		mov	[edx + dsMatchStart], ecx
		cmp	eax, ebx
		jge	LeaveNow
		mov	esi, [window]
		add	esi, eax
		mov	[windowbestlen], esi
		movzx	ebx, word ptr [edi + eax - 1]
		mov	edi, [edx + dsPrev]
		mov	[scanend], ebx
		mov	edx, [chainlenwmask]
		jmp	LookupLoop

;;; Accept the current string, with the maximum possible length.

LenMaximum:	mov	edx, [deflatestate]
		mov	dword ptr [bestlen], MAX_MATCH
		mov	[edx + dsMatchStart], ecx

;;; if ((uInt)best_len <= s->lookahead) return (uInt)best_len;
;;; return s->lookahead;

LeaveNow:
		mov	edx, [deflatestate]
		mov	ebx, [bestlen]
		mov	eax, [edx + dsLookahead]
		cmp	ebx, eax
		jg	LookaheadRet
		mov	eax, ebx
LookaheadRet:

;;; Restore the stack and return from whence we came.

		add	esp, LocalVarsSize
		pop	ebx
		pop	esi
		pop	edi
		pop	ebp

		ret
; please don't remove this string !
; Your can freely use gvmat32 in any free or commercial app if you don't remove the string in the binary!
	db     0dh,0ah,"asm686 with masm, optimised assembly code from Brian Raiter, written 1998",0dh,0ah

IFDEF NOUNDERLINE
longest_match_686   endp
ELSE
_longest_match_686  endp
ENDIF

_TEXT   ends
end