contrib/masmx86/match686.asm

; match686.asm -- Asm portion of the optimized longest_match for 32 bits x86
; Copyright (C) 1995-1996 Jean-loup Gailly, Brian Raiter and Gilles Vollant.
; File written by Gilles Vollant, by converting match686.S from Brian Raiter
; for MASM. This is as assembly version of longest_match
;  from Jean-loup Gailly in deflate.c
;
;         http://www.zlib.net
;         http://www.winimage.com/zLibDll
;         http://www.muppetlabs.com/~breadbox/software/assembly.html
;
; For Visual C++ 4.x and higher and ML 6.x and higher
;   ml.exe is distributed in
;  http://www.microsoft.com/downloads/details.aspx?FamilyID=7a1c9da0-0510-44a2-b042-7ef370530c64
;
; this file contain two implementation of longest_match
;
;  this longest_match was written by Brian raiter (1998), optimized for Pentium Pro
;   (and the faster known version of match_init on modern Core 2 Duo and AMD Phenom)
;
;  for using an assembly version of longest_match, you need define ASMV in project
;
;    compile the asm file running
;           ml /coff /Zi /c /Flmatch686.lst match686.asm
;    and do not include match686.obj in your project
;
; note: contrib of zLib 1.2.3 and earlier contained both a deprecated version for
;  Pentium (prior Pentium Pro) and this version for Pentium Pro and modern processor
;  with autoselect (with cpu detection code)
;  if you want support the old pentium optimization, you can still use these version
;
; this file is not optimized for old pentium, but it compatible with all x86 32 bits
; processor (starting 80386)
;
;
; see below : zlib1222add must be adjuster if you use a zlib version < 1.2.2.2

;uInt longest_match(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 +zlib1222add offsets are due to the addition of fields
;  in zlib in the deflate_state structure since the asm code was first written
;  (if you compile with zlib 1.0.4 or older, use "zlib1222add equ (-4)").
;  (if you compile with zlib between 1.0.5 and 1.2.2.1, use "zlib1222add equ 0").
;  if you compile with zlib 1.2.2.2 or later , use "zlib1222add equ 8").

    zlib1222add         equ     8

;  Note : these value are good with a 8 bytes boundary pack structure
    dep_chain_length    equ     74h+zlib1222add
    dep_window          equ     30h+zlib1222add
    dep_strstart        equ     64h+zlib1222add
    dep_prev_length     equ     70h+zlib1222add
    dep_nice_match      equ     88h+zlib1222add
    dep_w_size          equ     24h+zlib1222add
    dep_prev            equ     38h+zlib1222add
    dep_w_mask          equ     2ch+zlib1222add
    dep_good_match      equ     84h+zlib1222add
    dep_match_start     equ     68h+zlib1222add
    dep_lookahead       equ     6ch+zlib1222add


_TEXT                   segment

IFDEF NOUNDERLINE
            public  longest_match
            public  match_init
ELSE
            public  _longest_match
            public  _match_init
ENDIF

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


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+zlib1222add
dsWMask     equ 44+zlib1222add
dsWindow    equ 48+zlib1222add
dsPrev      equ 56+zlib1222add
dsMatchLen  equ 88+zlib1222add
dsPrevMatch equ 92+zlib1222add
dsStrStart  equ 100+zlib1222add
dsMatchStart    equ 104+zlib1222add
dsLookahead equ 108+zlib1222add
dsPrevLen   equ 112+zlib1222add
dsMaxChainLen   equ 116+zlib1222add
dsGoodMatch equ 132+zlib1222add
dsNiceMatch equ 136+zlib1222add


;;; match686.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 software is provided 'as-is', without any express or implied
;;  warranty.  In no event will the authors be held liable for any damages
;;  arising from the use of this software.
;;
;;  Permission is granted to anyone to use this software for any purpose,
;;  including commercial applications, and to alter it and redistribute it
;;  freely, subject to the following restrictions:
;;
;;  1. The origin of this software must not be misrepresented; you must not
;;     claim that you wrote the original software. If you use this software
;;     in a product, an acknowledgment in the product documentation would be
;;     appreciated but is not required.
;;  2. Altered source versions must be plainly marked as such, and must not be
;;     misrepresented as being the original software
;;  3. This notice may not be removed or altered from any source distribution.
;;

;GLOBAL _longest_match, _match_init


;SECTION    .text

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

;_longest_match:
    IFDEF NOUNDERLINE
    longest_match       proc near
    ELSE
    _longest_match      proc near
    ENDIF
.FPO (9, 4, 0, 0, 1, 0)

;;; 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 match686 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       endp
    ELSE
    _longest_match      endp
    ENDIF

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


_TEXT   ends
end
Revision:	1096
Committed:	Sat Dec 30 14:40:33 2017 UTC (7 years, 10 months ago) by s10k
File size:	15825 byte(s)
Log Message:	Added zlib, quazip, basicxmlsyntaxhighlighter, conditionalsemaphore and linenumberdisplay libraries. zlib and quazip are pre-compiled, but you can compile them yourself, just delete the dll files (or equivalent binary files to your OS)
#	Content
1	; match686.asm -- Asm portion of the optimized longest_match for 32 bits x86
2	; Copyright (C) 1995-1996 Jean-loup Gailly, Brian Raiter and Gilles Vollant.
3	; File written by Gilles Vollant, by converting match686.S from Brian Raiter
4	; for MASM. This is as assembly version of longest_match
5	; from Jean-loup Gailly in deflate.c
6	;
7	; http://www.zlib.net
8	; http://www.winimage.com/zLibDll
9	; http://www.muppetlabs.com/~breadbox/software/assembly.html
10	;
11	; For Visual C++ 4.x and higher and ML 6.x and higher
12	; ml.exe is distributed in
13	; http://www.microsoft.com/downloads/details.aspx?FamilyID=7a1c9da0-0510-44a2-b042-7ef370530c64
14	;
15	; this file contain two implementation of longest_match
16	;
17	; this longest_match was written by Brian raiter (1998), optimized for Pentium Pro
18	; (and the faster known version of match_init on modern Core 2 Duo and AMD Phenom)
19	;
20	; for using an assembly version of longest_match, you need define ASMV in project
21	;
22	; compile the asm file running
23	; ml /coff /Zi /c /Flmatch686.lst match686.asm
24	; and do not include match686.obj in your project
25	;
26	; note: contrib of zLib 1.2.3 and earlier contained both a deprecated version for
27	; Pentium (prior Pentium Pro) and this version for Pentium Pro and modern processor
28	; with autoselect (with cpu detection code)
29	; if you want support the old pentium optimization, you can still use these version
30	;
31	; this file is not optimized for old pentium, but it compatible with all x86 32 bits
32	; processor (starting 80386)
33	;
34	;
35	; see below : zlib1222add must be adjuster if you use a zlib version < 1.2.2.2
36
37	;uInt longest_match(s, cur_match)
38	; deflate_state *s;
39	; IPos cur_match; /* current match */
40
41	NbStack equ 76
42	cur_match equ dword ptr[esp+NbStack-0]
43	str_s equ dword ptr[esp+NbStack-4]
44	; 5 dword on top (ret,ebp,esi,edi,ebx)
45	adrret equ dword ptr[esp+NbStack-8]
46	pushebp equ dword ptr[esp+NbStack-12]
47	pushedi equ dword ptr[esp+NbStack-16]
48	pushesi equ dword ptr[esp+NbStack-20]
49	pushebx equ dword ptr[esp+NbStack-24]
50
51	chain_length equ dword ptr [esp+NbStack-28]
52	limit equ dword ptr [esp+NbStack-32]
53	best_len equ dword ptr [esp+NbStack-36]
54	window equ dword ptr [esp+NbStack-40]
55	prev equ dword ptr [esp+NbStack-44]
56	scan_start equ word ptr [esp+NbStack-48]
57	wmask equ dword ptr [esp+NbStack-52]
58	match_start_ptr equ dword ptr [esp+NbStack-56]
59	nice_match equ dword ptr [esp+NbStack-60]
60	scan equ dword ptr [esp+NbStack-64]
61
62	windowlen equ dword ptr [esp+NbStack-68]
63	match_start equ dword ptr [esp+NbStack-72]
64	strend equ dword ptr [esp+NbStack-76]
65	NbStackAdd equ (NbStack-24)
66
67	.386p
68
69	name gvmatch
70	.MODEL FLAT
71
72
73
74	; all the +zlib1222add offsets are due to the addition of fields
75	; in zlib in the deflate_state structure since the asm code was first written
76	; (if you compile with zlib 1.0.4 or older, use "zlib1222add equ (-4)").
77	; (if you compile with zlib between 1.0.5 and 1.2.2.1, use "zlib1222add equ 0").
78	; if you compile with zlib 1.2.2.2 or later , use "zlib1222add equ 8").
79
80	zlib1222add equ 8
81
82	; Note : these value are good with a 8 bytes boundary pack structure
83	dep_chain_length equ 74h+zlib1222add
84	dep_window equ 30h+zlib1222add
85	dep_strstart equ 64h+zlib1222add
86	dep_prev_length equ 70h+zlib1222add
87	dep_nice_match equ 88h+zlib1222add
88	dep_w_size equ 24h+zlib1222add
89	dep_prev equ 38h+zlib1222add
90	dep_w_mask equ 2ch+zlib1222add
91	dep_good_match equ 84h+zlib1222add
92	dep_match_start equ 68h+zlib1222add
93	dep_lookahead equ 6ch+zlib1222add
94
95
96	_TEXT segment
97
98	IFDEF NOUNDERLINE
99	public longest_match
100	public match_init
101	ELSE
102	public _longest_match
103	public _match_init
104	ENDIF
105
106	MAX_MATCH equ 258
107	MIN_MATCH equ 3
108	MIN_LOOKAHEAD equ (MAX_MATCH+MIN_MATCH+1)
109
110
111
112	MAX_MATCH equ 258
113	MIN_MATCH equ 3
114	MIN_LOOKAHEAD equ (MAX_MATCH + MIN_MATCH + 1)
115	MAX_MATCH_8_ equ ((MAX_MATCH + 7) AND 0FFF0h)
116
117
118	;;; stack frame offsets
119
120	chainlenwmask equ esp + 0 ; high word: current chain len
121	; low word: s->wmask
122	window equ esp + 4 ; local copy of s->window
123	windowbestlen equ esp + 8 ; s->window + bestlen
124	scanstart equ esp + 16 ; first two bytes of string
125	scanend equ esp + 12 ; last two bytes of string
126	scanalign equ esp + 20 ; dword-misalignment of string
127	nicematch equ esp + 24 ; a good enough match size
128	bestlen equ esp + 28 ; size of best match so far
129	scan equ esp + 32 ; ptr to string wanting match
130
131	LocalVarsSize equ 36
132	; saved ebx byte esp + 36
133	; saved edi byte esp + 40
134	; saved esi byte esp + 44
135	; saved ebp byte esp + 48
136	; return address byte esp + 52
137	deflatestate equ esp + 56 ; the function arguments
138	curmatch equ esp + 60
139
140	;;; Offsets for fields in the deflate_state structure. These numbers
141	;;; are calculated from the definition of deflate_state, with the
142	;;; assumption that the compiler will dword-align the fields. (Thus,
143	;;; changing the definition of deflate_state could easily cause this
144	;;; program to crash horribly, without so much as a warning at
145	;;; compile time. Sigh.)
146
147	dsWSize equ 36+zlib1222add
148	dsWMask equ 44+zlib1222add
149	dsWindow equ 48+zlib1222add
150	dsPrev equ 56+zlib1222add
151	dsMatchLen equ 88+zlib1222add
152	dsPrevMatch equ 92+zlib1222add
153	dsStrStart equ 100+zlib1222add
154	dsMatchStart equ 104+zlib1222add
155	dsLookahead equ 108+zlib1222add
156	dsPrevLen equ 112+zlib1222add
157	dsMaxChainLen equ 116+zlib1222add
158	dsGoodMatch equ 132+zlib1222add
159	dsNiceMatch equ 136+zlib1222add
160
161
162	;;; match686.asm -- Pentium-Pro-optimized version of longest_match()
163	;;; Written for zlib 1.1.2
164	;;; Copyright (C) 1998 Brian Raiter <breadbox@muppetlabs.com>
165	;;; You can look at http://www.muppetlabs.com/~breadbox/software/assembly.html
166	;;;
167	;;
168	;; This software is provided 'as-is', without any express or implied
169	;; warranty. In no event will the authors be held liable for any damages
170	;; arising from the use of this software.
171	;;
172	;; Permission is granted to anyone to use this software for any purpose,
173	;; including commercial applications, and to alter it and redistribute it
174	;; freely, subject to the following restrictions:
175	;;
176	;; 1. The origin of this software must not be misrepresented; you must not
177	;; claim that you wrote the original software. If you use this software
178	;; in a product, an acknowledgment in the product documentation would be
179	;; appreciated but is not required.
180	;; 2. Altered source versions must be plainly marked as such, and must not be
181	;; misrepresented as being the original software
182	;; 3. This notice may not be removed or altered from any source distribution.
183	;;
184
185	;GLOBAL _longest_match, _match_init
186
187
188	;SECTION .text
189
190	;;; uInt longest_match(deflate_state *deflatestate, IPos curmatch)
191
192	;_longest_match:
193	IFDEF NOUNDERLINE
194	longest_match proc near
195	ELSE
196	_longest_match proc near
197	ENDIF
198	.FPO (9, 4, 0, 0, 1, 0)
199
200	;;; Save registers that the compiler may be using, and adjust esp to
201	;;; make room for our stack frame.
202
203	push ebp
204	push edi
205	push esi
206	push ebx
207	sub esp, LocalVarsSize
208
209	;;; Retrieve the function arguments. ecx will hold cur_match
210	;;; throughout the entire function. edx will hold the pointer to the
211	;;; deflate_state structure during the function's setup (before
212	;;; entering the main loop.
213
214	mov edx, [deflatestate]
215	mov ecx, [curmatch]
216
217	;;; uInt wmask = s->w_mask;
218	;;; unsigned chain_length = s->max_chain_length;
219	;;; if (s->prev_length >= s->good_match) {
220	;;; chain_length >>= 2;
221	;;; }
222
223	mov eax, [edx + dsPrevLen]
224	mov ebx, [edx + dsGoodMatch]
225	cmp eax, ebx
226	mov eax, [edx + dsWMask]
227	mov ebx, [edx + dsMaxChainLen]
228	jl LastMatchGood
229	shr ebx, 2
230	LastMatchGood:
231
232	;;; chainlen is decremented once beforehand so that the function can
233	;;; use the sign flag instead of the zero flag for the exit test.
234	;;; It is then shifted into the high word, to make room for the wmask
235	;;; value, which it will always accompany.
236
237	dec ebx
238	shl ebx, 16
239	or ebx, eax
240	mov [chainlenwmask], ebx
241
242	;;; if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead;
243
244	mov eax, [edx + dsNiceMatch]
245	mov ebx, [edx + dsLookahead]
246	cmp ebx, eax
247	jl LookaheadLess
248	mov ebx, eax
249	LookaheadLess: mov [nicematch], ebx
250
251	;;; register Bytef *scan = s->window + s->strstart;
252
253	mov esi, [edx + dsWindow]
254	mov [window], esi
255	mov ebp, [edx + dsStrStart]
256	lea edi, [esi + ebp]
257	mov [scan], edi
258
259	;;; Determine how many bytes the scan ptr is off from being
260	;;; dword-aligned.
261
262	mov eax, edi
263	neg eax
264	and eax, 3
265	mov [scanalign], eax
266
267	;;; IPos limit = s->strstart > (IPos)MAX_DIST(s) ?
268	;;; s->strstart - (IPos)MAX_DIST(s) : NIL;
269
270	mov eax, [edx + dsWSize]
271	sub eax, MIN_LOOKAHEAD
272	sub ebp, eax
273	jg LimitPositive
274	xor ebp, ebp
275	LimitPositive:
276
277	;;; int best_len = s->prev_length;
278
279	mov eax, [edx + dsPrevLen]
280	mov [bestlen], eax
281
282	;;; Store the sum of s->window + best_len in esi locally, and in esi.
283
284	add esi, eax
285	mov [windowbestlen], esi
286
287	;;; register ush scan_start = (ushf)scan;
288	;;; register ush scan_end = (ushf)(scan+best_len-1);
289	;;; Posf *prev = s->prev;
290
291	movzx ebx, word ptr [edi]
292	mov [scanstart], ebx
293	movzx ebx, word ptr [edi + eax - 1]
294	mov [scanend], ebx
295	mov edi, [edx + dsPrev]
296
297	;;; Jump into the main loop.
298
299	mov edx, [chainlenwmask]
300	jmp short LoopEntry
301
302	align 4
303
304	;;; do {
305	;;; match = s->window + cur_match;
306	;;; if ((ushf)(match+best_len-1) != scan_end \|\|
307	;;; (ushf)match != scan_start) continue;
308	;;; [...]
309	;;; } while ((cur_match = prev[cur_match & wmask]) > limit
310	;;; && --chain_length != 0);
311	;;;
312	;;; Here is the inner loop of the function. The function will spend the
313	;;; majority of its time in this loop, and majority of that time will
314	;;; be spent in the first ten instructions.
315	;;;
316	;;; Within this loop:
317	;;; ebx = scanend
318	;;; ecx = curmatch
319	;;; edx = chainlenwmask - i.e., ((chainlen << 16) \| wmask)
320	;;; esi = windowbestlen - i.e., (window + bestlen)
321	;;; edi = prev
322	;;; ebp = limit
323
324	LookupLoop:
325	and ecx, edx
326	movzx ecx, word ptr [edi + ecx*2]
327	cmp ecx, ebp
328	jbe LeaveNow
329	sub edx, 00010000h
330	js LeaveNow
331	LoopEntry: movzx eax, word ptr [esi + ecx - 1]
332	cmp eax, ebx
333	jnz LookupLoop
334	mov eax, [window]
335	movzx eax, word ptr [eax + ecx]
336	cmp eax, [scanstart]
337	jnz LookupLoop
338
339	;;; Store the current value of chainlen.
340
341	mov [chainlenwmask], edx
342
343	;;; Point edi to the string under scrutiny, and esi to the string we
344	;;; are hoping to match it up with. In actuality, esi and edi are
345	;;; both pointed (MAX_MATCH_8 - scanalign) bytes ahead, and edx is
346	;;; initialized to -(MAX_MATCH_8 - scanalign).
347
348	mov esi, [window]
349	mov edi, [scan]
350	add esi, ecx
351	mov eax, [scanalign]
352	mov edx, 0fffffef8h; -(MAX_MATCH_8)
353	lea edi, [edi + eax + 0108h] ;MAX_MATCH_8]
354	lea esi, [esi + eax + 0108h] ;MAX_MATCH_8]
355
356	;;; Test the strings for equality, 8 bytes at a time. At the end,
357	;;; adjust edx so that it is offset to the exact byte that mismatched.
358	;;;
359	;;; We already know at this point that the first three bytes of the
360	;;; strings match each other, and they can be safely passed over before
361	;;; starting the compare loop. So what this code does is skip over 0-3
362	;;; bytes, as much as necessary in order to dword-align the edi
363	;;; pointer. (esi will still be misaligned three times out of four.)
364	;;;
365	;;; It should be confessed that this loop usually does not represent
366	;;; much of the total running time. Replacing it with a more
367	;;; straightforward "rep cmpsb" would not drastically degrade
368	;;; performance.
369
370	LoopCmps:
371	mov eax, [esi + edx]
372	xor eax, [edi + edx]
373	jnz LeaveLoopCmps
374	mov eax, [esi + edx + 4]
375	xor eax, [edi + edx + 4]
376	jnz LeaveLoopCmps4
377	add edx, 8
378	jnz LoopCmps
379	jmp short LenMaximum
380	LeaveLoopCmps4: add edx, 4
381	LeaveLoopCmps: test eax, 0000FFFFh
382	jnz LenLower
383	add edx, 2
384	shr eax, 16
385	LenLower: sub al, 1
386	adc edx, 0
387
388	;;; Calculate the length of the match. If it is longer than MAX_MATCH,
389	;;; then automatically accept it as the best possible match and leave.
390
391	lea eax, [edi + edx]
392	mov edi, [scan]
393	sub eax, edi
394	cmp eax, MAX_MATCH
395	jge LenMaximum
396
397	;;; If the length of the match is not longer than the best match we
398	;;; have so far, then forget it and return to the lookup loop.
399
400	mov edx, [deflatestate]
401	mov ebx, [bestlen]
402	cmp eax, ebx
403	jg LongerMatch
404	mov esi, [windowbestlen]
405	mov edi, [edx + dsPrev]
406	mov ebx, [scanend]
407	mov edx, [chainlenwmask]
408	jmp LookupLoop
409
410	;;; s->match_start = cur_match;
411	;;; best_len = len;
412	;;; if (len >= nice_match) break;
413	;;; scan_end = (ushf)(scan+best_len-1);
414
415	LongerMatch: mov ebx, [nicematch]
416	mov [bestlen], eax
417	mov [edx + dsMatchStart], ecx
418	cmp eax, ebx
419	jge LeaveNow
420	mov esi, [window]
421	add esi, eax
422	mov [windowbestlen], esi
423	movzx ebx, word ptr [edi + eax - 1]
424	mov edi, [edx + dsPrev]
425	mov [scanend], ebx
426	mov edx, [chainlenwmask]
427	jmp LookupLoop
428
429	;;; Accept the current string, with the maximum possible length.
430
431	LenMaximum: mov edx, [deflatestate]
432	mov dword ptr [bestlen], MAX_MATCH
433	mov [edx + dsMatchStart], ecx
434
435	;;; if ((uInt)best_len <= s->lookahead) return (uInt)best_len;
436	;;; return s->lookahead;
437
438	LeaveNow:
439	mov edx, [deflatestate]
440	mov ebx, [bestlen]
441	mov eax, [edx + dsLookahead]
442	cmp ebx, eax
443	jg LookaheadRet
444	mov eax, ebx
445	LookaheadRet:
446
447	;;; Restore the stack and return from whence we came.
448
449	add esp, LocalVarsSize
450	pop ebx
451	pop esi
452	pop edi
453	pop ebp
454
455	ret
456	; please don't remove this string !
457	; Your can freely use match686 in any free or commercial app if you don't remove the string in the binary!
458	db 0dh,0ah,"asm686 with masm, optimised assembly code from Brian Raiter, written 1998",0dh,0ah
459
460
461	IFDEF NOUNDERLINE
462	longest_match endp
463	ELSE
464	_longest_match endp
465	ENDIF
466
467	IFDEF NOUNDERLINE
468	match_init proc near
469	ret
470	match_init endp
471	ELSE
472	_match_init proc near
473	ret
474	_match_init endp
475	ENDIF
476
477
478	_TEXT ends
479	end