480 lines
16 KiB
NASM
480 lines
16 KiB
NASM
; 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
|