cannam@128: ; match686.asm -- Asm portion of the optimized longest_match for 32 bits x86 cannam@128: ; Copyright (C) 1995-1996 Jean-loup Gailly, Brian Raiter and Gilles Vollant. cannam@128: ; File written by Gilles Vollant, by converting match686.S from Brian Raiter cannam@128: ; for MASM. This is as assembly version of longest_match cannam@128: ; from Jean-loup Gailly in deflate.c cannam@128: ; cannam@128: ; http://www.zlib.net cannam@128: ; http://www.winimage.com/zLibDll cannam@128: ; http://www.muppetlabs.com/~breadbox/software/assembly.html cannam@128: ; cannam@128: ; For Visual C++ 4.x and higher and ML 6.x and higher cannam@128: ; ml.exe is distributed in cannam@128: ; http://www.microsoft.com/downloads/details.aspx?FamilyID=7a1c9da0-0510-44a2-b042-7ef370530c64 cannam@128: ; cannam@128: ; this file contain two implementation of longest_match cannam@128: ; cannam@128: ; this longest_match was written by Brian raiter (1998), optimized for Pentium Pro cannam@128: ; (and the faster known version of match_init on modern Core 2 Duo and AMD Phenom) cannam@128: ; cannam@128: ; for using an assembly version of longest_match, you need define ASMV in project cannam@128: ; cannam@128: ; compile the asm file running cannam@128: ; ml /coff /Zi /c /Flmatch686.lst match686.asm cannam@128: ; and do not include match686.obj in your project cannam@128: ; cannam@128: ; note: contrib of zLib 1.2.3 and earlier contained both a deprecated version for cannam@128: ; Pentium (prior Pentium Pro) and this version for Pentium Pro and modern processor cannam@128: ; with autoselect (with cpu detection code) cannam@128: ; if you want support the old pentium optimization, you can still use these version cannam@128: ; cannam@128: ; this file is not optimized for old pentium, but it compatible with all x86 32 bits cannam@128: ; processor (starting 80386) cannam@128: ; cannam@128: ; cannam@128: ; see below : zlib1222add must be adjuster if you use a zlib version < 1.2.2.2 cannam@128: cannam@128: ;uInt longest_match(s, cur_match) cannam@128: ; deflate_state *s; cannam@128: ; IPos cur_match; /* current match */ cannam@128: cannam@128: NbStack equ 76 cannam@128: cur_match equ dword ptr[esp+NbStack-0] cannam@128: str_s equ dword ptr[esp+NbStack-4] cannam@128: ; 5 dword on top (ret,ebp,esi,edi,ebx) cannam@128: adrret equ dword ptr[esp+NbStack-8] cannam@128: pushebp equ dword ptr[esp+NbStack-12] cannam@128: pushedi equ dword ptr[esp+NbStack-16] cannam@128: pushesi equ dword ptr[esp+NbStack-20] cannam@128: pushebx equ dword ptr[esp+NbStack-24] cannam@128: cannam@128: chain_length equ dword ptr [esp+NbStack-28] cannam@128: limit equ dword ptr [esp+NbStack-32] cannam@128: best_len equ dword ptr [esp+NbStack-36] cannam@128: window equ dword ptr [esp+NbStack-40] cannam@128: prev equ dword ptr [esp+NbStack-44] cannam@128: scan_start equ word ptr [esp+NbStack-48] cannam@128: wmask equ dword ptr [esp+NbStack-52] cannam@128: match_start_ptr equ dword ptr [esp+NbStack-56] cannam@128: nice_match equ dword ptr [esp+NbStack-60] cannam@128: scan equ dword ptr [esp+NbStack-64] cannam@128: cannam@128: windowlen equ dword ptr [esp+NbStack-68] cannam@128: match_start equ dword ptr [esp+NbStack-72] cannam@128: strend equ dword ptr [esp+NbStack-76] cannam@128: NbStackAdd equ (NbStack-24) cannam@128: cannam@128: .386p cannam@128: cannam@128: name gvmatch cannam@128: .MODEL FLAT cannam@128: cannam@128: cannam@128: cannam@128: ; all the +zlib1222add offsets are due to the addition of fields cannam@128: ; in zlib in the deflate_state structure since the asm code was first written cannam@128: ; (if you compile with zlib 1.0.4 or older, use "zlib1222add equ (-4)"). cannam@128: ; (if you compile with zlib between 1.0.5 and 1.2.2.1, use "zlib1222add equ 0"). cannam@128: ; if you compile with zlib 1.2.2.2 or later , use "zlib1222add equ 8"). cannam@128: cannam@128: zlib1222add equ 8 cannam@128: cannam@128: ; Note : these value are good with a 8 bytes boundary pack structure cannam@128: dep_chain_length equ 74h+zlib1222add cannam@128: dep_window equ 30h+zlib1222add cannam@128: dep_strstart equ 64h+zlib1222add cannam@128: dep_prev_length equ 70h+zlib1222add cannam@128: dep_nice_match equ 88h+zlib1222add cannam@128: dep_w_size equ 24h+zlib1222add cannam@128: dep_prev equ 38h+zlib1222add cannam@128: dep_w_mask equ 2ch+zlib1222add cannam@128: dep_good_match equ 84h+zlib1222add cannam@128: dep_match_start equ 68h+zlib1222add cannam@128: dep_lookahead equ 6ch+zlib1222add cannam@128: cannam@128: cannam@128: _TEXT segment cannam@128: cannam@128: IFDEF NOUNDERLINE cannam@128: public longest_match cannam@128: public match_init cannam@128: ELSE cannam@128: public _longest_match cannam@128: public _match_init cannam@128: ENDIF cannam@128: cannam@128: MAX_MATCH equ 258 cannam@128: MIN_MATCH equ 3 cannam@128: MIN_LOOKAHEAD equ (MAX_MATCH+MIN_MATCH+1) cannam@128: cannam@128: cannam@128: cannam@128: MAX_MATCH equ 258 cannam@128: MIN_MATCH equ 3 cannam@128: MIN_LOOKAHEAD equ (MAX_MATCH + MIN_MATCH + 1) cannam@128: MAX_MATCH_8_ equ ((MAX_MATCH + 7) AND 0FFF0h) cannam@128: cannam@128: cannam@128: ;;; stack frame offsets cannam@128: cannam@128: chainlenwmask equ esp + 0 ; high word: current chain len cannam@128: ; low word: s->wmask cannam@128: window equ esp + 4 ; local copy of s->window cannam@128: windowbestlen equ esp + 8 ; s->window + bestlen cannam@128: scanstart equ esp + 16 ; first two bytes of string cannam@128: scanend equ esp + 12 ; last two bytes of string cannam@128: scanalign equ esp + 20 ; dword-misalignment of string cannam@128: nicematch equ esp + 24 ; a good enough match size cannam@128: bestlen equ esp + 28 ; size of best match so far cannam@128: scan equ esp + 32 ; ptr to string wanting match cannam@128: cannam@128: LocalVarsSize equ 36 cannam@128: ; saved ebx byte esp + 36 cannam@128: ; saved edi byte esp + 40 cannam@128: ; saved esi byte esp + 44 cannam@128: ; saved ebp byte esp + 48 cannam@128: ; return address byte esp + 52 cannam@128: deflatestate equ esp + 56 ; the function arguments cannam@128: curmatch equ esp + 60 cannam@128: cannam@128: ;;; Offsets for fields in the deflate_state structure. These numbers cannam@128: ;;; are calculated from the definition of deflate_state, with the cannam@128: ;;; assumption that the compiler will dword-align the fields. (Thus, cannam@128: ;;; changing the definition of deflate_state could easily cause this cannam@128: ;;; program to crash horribly, without so much as a warning at cannam@128: ;;; compile time. Sigh.) cannam@128: cannam@128: dsWSize equ 36+zlib1222add cannam@128: dsWMask equ 44+zlib1222add cannam@128: dsWindow equ 48+zlib1222add cannam@128: dsPrev equ 56+zlib1222add cannam@128: dsMatchLen equ 88+zlib1222add cannam@128: dsPrevMatch equ 92+zlib1222add cannam@128: dsStrStart equ 100+zlib1222add cannam@128: dsMatchStart equ 104+zlib1222add cannam@128: dsLookahead equ 108+zlib1222add cannam@128: dsPrevLen equ 112+zlib1222add cannam@128: dsMaxChainLen equ 116+zlib1222add cannam@128: dsGoodMatch equ 132+zlib1222add cannam@128: dsNiceMatch equ 136+zlib1222add cannam@128: cannam@128: cannam@128: ;;; match686.asm -- Pentium-Pro-optimized version of longest_match() cannam@128: ;;; Written for zlib 1.1.2 cannam@128: ;;; Copyright (C) 1998 Brian Raiter cannam@128: ;;; You can look at http://www.muppetlabs.com/~breadbox/software/assembly.html cannam@128: ;;; cannam@128: ;; cannam@128: ;; This software is provided 'as-is', without any express or implied cannam@128: ;; warranty. In no event will the authors be held liable for any damages cannam@128: ;; arising from the use of this software. cannam@128: ;; cannam@128: ;; Permission is granted to anyone to use this software for any purpose, cannam@128: ;; including commercial applications, and to alter it and redistribute it cannam@128: ;; freely, subject to the following restrictions: cannam@128: ;; cannam@128: ;; 1. The origin of this software must not be misrepresented; you must not cannam@128: ;; claim that you wrote the original software. If you use this software cannam@128: ;; in a product, an acknowledgment in the product documentation would be cannam@128: ;; appreciated but is not required. cannam@128: ;; 2. Altered source versions must be plainly marked as such, and must not be cannam@128: ;; misrepresented as being the original software cannam@128: ;; 3. This notice may not be removed or altered from any source distribution. cannam@128: ;; cannam@128: cannam@128: ;GLOBAL _longest_match, _match_init cannam@128: cannam@128: cannam@128: ;SECTION .text cannam@128: cannam@128: ;;; uInt longest_match(deflate_state *deflatestate, IPos curmatch) cannam@128: cannam@128: ;_longest_match: cannam@128: IFDEF NOUNDERLINE cannam@128: longest_match proc near cannam@128: ELSE cannam@128: _longest_match proc near cannam@128: ENDIF cannam@128: .FPO (9, 4, 0, 0, 1, 0) cannam@128: cannam@128: ;;; Save registers that the compiler may be using, and adjust esp to cannam@128: ;;; make room for our stack frame. cannam@128: cannam@128: push ebp cannam@128: push edi cannam@128: push esi cannam@128: push ebx cannam@128: sub esp, LocalVarsSize cannam@128: cannam@128: ;;; Retrieve the function arguments. ecx will hold cur_match cannam@128: ;;; throughout the entire function. edx will hold the pointer to the cannam@128: ;;; deflate_state structure during the function's setup (before cannam@128: ;;; entering the main loop. cannam@128: cannam@128: mov edx, [deflatestate] cannam@128: mov ecx, [curmatch] cannam@128: cannam@128: ;;; uInt wmask = s->w_mask; cannam@128: ;;; unsigned chain_length = s->max_chain_length; cannam@128: ;;; if (s->prev_length >= s->good_match) { cannam@128: ;;; chain_length >>= 2; cannam@128: ;;; } cannam@128: cannam@128: mov eax, [edx + dsPrevLen] cannam@128: mov ebx, [edx + dsGoodMatch] cannam@128: cmp eax, ebx cannam@128: mov eax, [edx + dsWMask] cannam@128: mov ebx, [edx + dsMaxChainLen] cannam@128: jl LastMatchGood cannam@128: shr ebx, 2 cannam@128: LastMatchGood: cannam@128: cannam@128: ;;; chainlen is decremented once beforehand so that the function can cannam@128: ;;; use the sign flag instead of the zero flag for the exit test. cannam@128: ;;; It is then shifted into the high word, to make room for the wmask cannam@128: ;;; value, which it will always accompany. cannam@128: cannam@128: dec ebx cannam@128: shl ebx, 16 cannam@128: or ebx, eax cannam@128: mov [chainlenwmask], ebx cannam@128: cannam@128: ;;; if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead; cannam@128: cannam@128: mov eax, [edx + dsNiceMatch] cannam@128: mov ebx, [edx + dsLookahead] cannam@128: cmp ebx, eax cannam@128: jl LookaheadLess cannam@128: mov ebx, eax cannam@128: LookaheadLess: mov [nicematch], ebx cannam@128: cannam@128: ;;; register Bytef *scan = s->window + s->strstart; cannam@128: cannam@128: mov esi, [edx + dsWindow] cannam@128: mov [window], esi cannam@128: mov ebp, [edx + dsStrStart] cannam@128: lea edi, [esi + ebp] cannam@128: mov [scan], edi cannam@128: cannam@128: ;;; Determine how many bytes the scan ptr is off from being cannam@128: ;;; dword-aligned. cannam@128: cannam@128: mov eax, edi cannam@128: neg eax cannam@128: and eax, 3 cannam@128: mov [scanalign], eax cannam@128: cannam@128: ;;; IPos limit = s->strstart > (IPos)MAX_DIST(s) ? cannam@128: ;;; s->strstart - (IPos)MAX_DIST(s) : NIL; cannam@128: cannam@128: mov eax, [edx + dsWSize] cannam@128: sub eax, MIN_LOOKAHEAD cannam@128: sub ebp, eax cannam@128: jg LimitPositive cannam@128: xor ebp, ebp cannam@128: LimitPositive: cannam@128: cannam@128: ;;; int best_len = s->prev_length; cannam@128: cannam@128: mov eax, [edx + dsPrevLen] cannam@128: mov [bestlen], eax cannam@128: cannam@128: ;;; Store the sum of s->window + best_len in esi locally, and in esi. cannam@128: cannam@128: add esi, eax cannam@128: mov [windowbestlen], esi cannam@128: cannam@128: ;;; register ush scan_start = *(ushf*)scan; cannam@128: ;;; register ush scan_end = *(ushf*)(scan+best_len-1); cannam@128: ;;; Posf *prev = s->prev; cannam@128: cannam@128: movzx ebx, word ptr [edi] cannam@128: mov [scanstart], ebx cannam@128: movzx ebx, word ptr [edi + eax - 1] cannam@128: mov [scanend], ebx cannam@128: mov edi, [edx + dsPrev] cannam@128: cannam@128: ;;; Jump into the main loop. cannam@128: cannam@128: mov edx, [chainlenwmask] cannam@128: jmp short LoopEntry cannam@128: cannam@128: align 4 cannam@128: cannam@128: ;;; do { cannam@128: ;;; match = s->window + cur_match; cannam@128: ;;; if (*(ushf*)(match+best_len-1) != scan_end || cannam@128: ;;; *(ushf*)match != scan_start) continue; cannam@128: ;;; [...] cannam@128: ;;; } while ((cur_match = prev[cur_match & wmask]) > limit cannam@128: ;;; && --chain_length != 0); cannam@128: ;;; cannam@128: ;;; Here is the inner loop of the function. The function will spend the cannam@128: ;;; majority of its time in this loop, and majority of that time will cannam@128: ;;; be spent in the first ten instructions. cannam@128: ;;; cannam@128: ;;; Within this loop: cannam@128: ;;; ebx = scanend cannam@128: ;;; ecx = curmatch cannam@128: ;;; edx = chainlenwmask - i.e., ((chainlen << 16) | wmask) cannam@128: ;;; esi = windowbestlen - i.e., (window + bestlen) cannam@128: ;;; edi = prev cannam@128: ;;; ebp = limit cannam@128: cannam@128: LookupLoop: cannam@128: and ecx, edx cannam@128: movzx ecx, word ptr [edi + ecx*2] cannam@128: cmp ecx, ebp cannam@128: jbe LeaveNow cannam@128: sub edx, 00010000h cannam@128: js LeaveNow cannam@128: LoopEntry: movzx eax, word ptr [esi + ecx - 1] cannam@128: cmp eax, ebx cannam@128: jnz LookupLoop cannam@128: mov eax, [window] cannam@128: movzx eax, word ptr [eax + ecx] cannam@128: cmp eax, [scanstart] cannam@128: jnz LookupLoop cannam@128: cannam@128: ;;; Store the current value of chainlen. cannam@128: cannam@128: mov [chainlenwmask], edx cannam@128: cannam@128: ;;; Point edi to the string under scrutiny, and esi to the string we cannam@128: ;;; are hoping to match it up with. In actuality, esi and edi are cannam@128: ;;; both pointed (MAX_MATCH_8 - scanalign) bytes ahead, and edx is cannam@128: ;;; initialized to -(MAX_MATCH_8 - scanalign). cannam@128: cannam@128: mov esi, [window] cannam@128: mov edi, [scan] cannam@128: add esi, ecx cannam@128: mov eax, [scanalign] cannam@128: mov edx, 0fffffef8h; -(MAX_MATCH_8) cannam@128: lea edi, [edi + eax + 0108h] ;MAX_MATCH_8] cannam@128: lea esi, [esi + eax + 0108h] ;MAX_MATCH_8] cannam@128: cannam@128: ;;; Test the strings for equality, 8 bytes at a time. At the end, cannam@128: ;;; adjust edx so that it is offset to the exact byte that mismatched. cannam@128: ;;; cannam@128: ;;; We already know at this point that the first three bytes of the cannam@128: ;;; strings match each other, and they can be safely passed over before cannam@128: ;;; starting the compare loop. So what this code does is skip over 0-3 cannam@128: ;;; bytes, as much as necessary in order to dword-align the edi cannam@128: ;;; pointer. (esi will still be misaligned three times out of four.) cannam@128: ;;; cannam@128: ;;; It should be confessed that this loop usually does not represent cannam@128: ;;; much of the total running time. Replacing it with a more cannam@128: ;;; straightforward "rep cmpsb" would not drastically degrade cannam@128: ;;; performance. cannam@128: cannam@128: LoopCmps: cannam@128: mov eax, [esi + edx] cannam@128: xor eax, [edi + edx] cannam@128: jnz LeaveLoopCmps cannam@128: mov eax, [esi + edx + 4] cannam@128: xor eax, [edi + edx + 4] cannam@128: jnz LeaveLoopCmps4 cannam@128: add edx, 8 cannam@128: jnz LoopCmps cannam@128: jmp short LenMaximum cannam@128: LeaveLoopCmps4: add edx, 4 cannam@128: LeaveLoopCmps: test eax, 0000FFFFh cannam@128: jnz LenLower cannam@128: add edx, 2 cannam@128: shr eax, 16 cannam@128: LenLower: sub al, 1 cannam@128: adc edx, 0 cannam@128: cannam@128: ;;; Calculate the length of the match. If it is longer than MAX_MATCH, cannam@128: ;;; then automatically accept it as the best possible match and leave. cannam@128: cannam@128: lea eax, [edi + edx] cannam@128: mov edi, [scan] cannam@128: sub eax, edi cannam@128: cmp eax, MAX_MATCH cannam@128: jge LenMaximum cannam@128: cannam@128: ;;; If the length of the match is not longer than the best match we cannam@128: ;;; have so far, then forget it and return to the lookup loop. cannam@128: cannam@128: mov edx, [deflatestate] cannam@128: mov ebx, [bestlen] cannam@128: cmp eax, ebx cannam@128: jg LongerMatch cannam@128: mov esi, [windowbestlen] cannam@128: mov edi, [edx + dsPrev] cannam@128: mov ebx, [scanend] cannam@128: mov edx, [chainlenwmask] cannam@128: jmp LookupLoop cannam@128: cannam@128: ;;; s->match_start = cur_match; cannam@128: ;;; best_len = len; cannam@128: ;;; if (len >= nice_match) break; cannam@128: ;;; scan_end = *(ushf*)(scan+best_len-1); cannam@128: cannam@128: LongerMatch: mov ebx, [nicematch] cannam@128: mov [bestlen], eax cannam@128: mov [edx + dsMatchStart], ecx cannam@128: cmp eax, ebx cannam@128: jge LeaveNow cannam@128: mov esi, [window] cannam@128: add esi, eax cannam@128: mov [windowbestlen], esi cannam@128: movzx ebx, word ptr [edi + eax - 1] cannam@128: mov edi, [edx + dsPrev] cannam@128: mov [scanend], ebx cannam@128: mov edx, [chainlenwmask] cannam@128: jmp LookupLoop cannam@128: cannam@128: ;;; Accept the current string, with the maximum possible length. cannam@128: cannam@128: LenMaximum: mov edx, [deflatestate] cannam@128: mov dword ptr [bestlen], MAX_MATCH cannam@128: mov [edx + dsMatchStart], ecx cannam@128: cannam@128: ;;; if ((uInt)best_len <= s->lookahead) return (uInt)best_len; cannam@128: ;;; return s->lookahead; cannam@128: cannam@128: LeaveNow: cannam@128: mov edx, [deflatestate] cannam@128: mov ebx, [bestlen] cannam@128: mov eax, [edx + dsLookahead] cannam@128: cmp ebx, eax cannam@128: jg LookaheadRet cannam@128: mov eax, ebx cannam@128: LookaheadRet: cannam@128: cannam@128: ;;; Restore the stack and return from whence we came. cannam@128: cannam@128: add esp, LocalVarsSize cannam@128: pop ebx cannam@128: pop esi cannam@128: pop edi cannam@128: pop ebp cannam@128: cannam@128: ret cannam@128: ; please don't remove this string ! cannam@128: ; Your can freely use match686 in any free or commercial app if you don't remove the string in the binary! cannam@128: db 0dh,0ah,"asm686 with masm, optimised assembly code from Brian Raiter, written 1998",0dh,0ah cannam@128: cannam@128: cannam@128: IFDEF NOUNDERLINE cannam@128: longest_match endp cannam@128: ELSE cannam@128: _longest_match endp cannam@128: ENDIF cannam@128: cannam@128: IFDEF NOUNDERLINE cannam@128: match_init proc near cannam@128: ret cannam@128: match_init endp cannam@128: ELSE cannam@128: _match_init proc near cannam@128: ret cannam@128: _match_init endp cannam@128: ENDIF cannam@128: cannam@128: cannam@128: _TEXT ends cannam@128: end