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