414 lines
11 KiB
NASM
414 lines
11 KiB
NASM
|
|
; match.asm -- Pentium-Pro optimized version of longest_match()
|
|
;
|
|
; Updated for zlib 1.1.3 and converted to MASM 6.1x
|
|
; Copyright (C) 2000 Dan Higdon <hdan@kinesoft.com>
|
|
; and Chuck Walbourn <chuckw@kinesoft.com>
|
|
; Corrections by Cosmin Truta <cosmint@cs.ubbcluj.ro>
|
|
;
|
|
; This is free software; you can redistribute it and/or modify it
|
|
; under the terms of the GNU General Public License.
|
|
|
|
; Based on match.S
|
|
; Written for zlib 1.1.2
|
|
; Copyright (C) 1998 Brian Raiter <breadbox@muppetlabs.com>
|
|
;
|
|
; Modified by Gilles Vollant (2005) for add gzhead and gzindex
|
|
|
|
.686P
|
|
.MODEL FLAT
|
|
|
|
;===========================================================================
|
|
; EQUATES
|
|
;===========================================================================
|
|
|
|
MAX_MATCH EQU 258
|
|
MIN_MATCH EQU 3
|
|
MIN_LOOKAHEAD EQU (MAX_MATCH + MIN_MATCH + 1)
|
|
MAX_MATCH_8 EQU ((MAX_MATCH + 7) AND (NOT 7))
|
|
|
|
;===========================================================================
|
|
; STRUCTURES
|
|
;===========================================================================
|
|
|
|
; This STRUCT assumes a 4-byte alignment
|
|
|
|
DEFLATE_STATE STRUCT
|
|
ds_strm dd ?
|
|
ds_status dd ?
|
|
ds_pending_buf dd ?
|
|
ds_pending_buf_size dd ?
|
|
ds_pending_out dd ?
|
|
ds_pending dd ?
|
|
ds_wrap dd ?
|
|
; gzhead and gzindex are added in zlib 1.2.2.2 (see deflate.h)
|
|
ds_gzhead dd ?
|
|
ds_gzindex dd ?
|
|
ds_data_type db ?
|
|
ds_method db ?
|
|
db ? ; padding
|
|
db ? ; padding
|
|
ds_last_flush dd ?
|
|
ds_w_size dd ? ; used
|
|
ds_w_bits dd ?
|
|
ds_w_mask dd ? ; used
|
|
ds_window dd ? ; used
|
|
ds_window_size dd ?
|
|
ds_prev dd ? ; used
|
|
ds_head dd ?
|
|
ds_ins_h dd ?
|
|
ds_hash_size dd ?
|
|
ds_hash_bits dd ?
|
|
ds_hash_mask dd ?
|
|
ds_hash_shift dd ?
|
|
ds_block_start dd ?
|
|
ds_match_length dd ? ; used
|
|
ds_prev_match dd ? ; used
|
|
ds_match_available dd ?
|
|
ds_strstart dd ? ; used
|
|
ds_match_start dd ? ; used
|
|
ds_lookahead dd ? ; used
|
|
ds_prev_length dd ? ; used
|
|
ds_max_chain_length dd ? ; used
|
|
ds_max_laxy_match dd ?
|
|
ds_level dd ?
|
|
ds_strategy dd ?
|
|
ds_good_match dd ? ; used
|
|
ds_nice_match dd ? ; used
|
|
|
|
; Don't need anymore of the struct for match
|
|
DEFLATE_STATE ENDS
|
|
|
|
;===========================================================================
|
|
; CODE
|
|
;===========================================================================
|
|
_TEXT SEGMENT
|
|
|
|
;---------------------------------------------------------------------------
|
|
; match_init
|
|
;---------------------------------------------------------------------------
|
|
ALIGN 4
|
|
PUBLIC _match_init
|
|
_match_init PROC
|
|
; no initialization needed
|
|
ret
|
|
_match_init ENDP
|
|
|
|
;---------------------------------------------------------------------------
|
|
; uInt longest_match(deflate_state *deflatestate, IPos curmatch)
|
|
;---------------------------------------------------------------------------
|
|
ALIGN 4
|
|
|
|
PUBLIC _longest_match
|
|
_longest_match PROC
|
|
|
|
; Since this code uses EBP for a scratch register, the stack frame must
|
|
; be manually constructed and referenced relative to the ESP register.
|
|
|
|
; Stack image
|
|
; Variables
|
|
chainlenwmask = 0 ; high word: current chain len
|
|
; low word: s->wmask
|
|
window = 4 ; local copy of s->window
|
|
windowbestlen = 8 ; s->window + bestlen
|
|
scanend = 12 ; last two bytes of string
|
|
scanstart = 16 ; first two bytes of string
|
|
scanalign = 20 ; dword-misalignment of string
|
|
nicematch = 24 ; a good enough match size
|
|
bestlen = 28 ; size of best match so far
|
|
scan = 32 ; ptr to string wanting match
|
|
varsize = 36 ; number of bytes (also offset to last saved register)
|
|
|
|
; Saved Registers (actually pushed into place)
|
|
ebx_save = 36
|
|
edi_save = 40
|
|
esi_save = 44
|
|
ebp_save = 48
|
|
|
|
; Parameters
|
|
retaddr = 52
|
|
deflatestate = 56
|
|
curmatch = 60
|
|
|
|
; Save registers that the compiler may be using
|
|
push ebp
|
|
push edi
|
|
push esi
|
|
push ebx
|
|
|
|
; Allocate local variable space
|
|
sub esp,varsize
|
|
|
|
; 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, [esp+deflatestate]
|
|
ASSUME edx:PTR DEFLATE_STATE
|
|
|
|
mov ecx, [esp+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].ds_prev_length
|
|
mov ebx, [edx].ds_good_match
|
|
cmp eax, ebx
|
|
mov eax, [edx].ds_w_mask
|
|
mov ebx, [edx].ds_max_chain_length
|
|
jl SHORT 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 [esp+chainlenwmask], ebx
|
|
|
|
; if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead;
|
|
|
|
mov eax, [edx].ds_nice_match
|
|
mov ebx, [edx].ds_lookahead
|
|
cmp ebx, eax
|
|
jl SHORT LookaheadLess
|
|
mov ebx, eax
|
|
LookaheadLess:
|
|
mov [esp+nicematch], ebx
|
|
|
|
;/* register Bytef *scan = s->window + s->strstart; */
|
|
|
|
mov esi, [edx].ds_window
|
|
mov [esp+window], esi
|
|
mov ebp, [edx].ds_strstart
|
|
lea edi, [esi+ebp]
|
|
mov [esp+scan],edi
|
|
|
|
;/* Determine how many bytes the scan ptr is off from being */
|
|
;/* dword-aligned. */
|
|
|
|
mov eax, edi
|
|
neg eax
|
|
and eax, 3
|
|
mov [esp+scanalign], eax
|
|
|
|
;/* IPos limit = s->strstart > (IPos)MAX_DIST(s) ? */
|
|
;/* s->strstart - (IPos)MAX_DIST(s) : NIL; */
|
|
|
|
mov eax, [edx].ds_w_size
|
|
sub eax, MIN_LOOKAHEAD
|
|
sub ebp, eax
|
|
jg SHORT LimitPositive
|
|
xor ebp, ebp
|
|
LimitPositive:
|
|
|
|
;/* int best_len = s->prev_length; */
|
|
|
|
mov eax, [edx].ds_prev_length
|
|
mov [esp+bestlen], eax
|
|
|
|
;/* Store the sum of s->window + best_len in %esi locally, and in %esi. */
|
|
|
|
add esi, eax
|
|
mov [esp+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 [esp+scanstart], ebx
|
|
movzx ebx, WORD PTR[eax+edi-1]
|
|
mov [esp+scanend], ebx
|
|
mov edi, [edx].ds_prev
|
|
|
|
;/* Jump into the main loop. */
|
|
|
|
mov edx, [esp+chainlenwmask]
|
|
jmp SHORT LoopEntry
|
|
|
|
;/* 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
|
|
; */
|
|
|
|
ALIGN 4
|
|
LookupLoop:
|
|
and ecx, edx
|
|
movzx ecx, WORD PTR[edi+ecx*2]
|
|
cmp ecx, ebp
|
|
jbe LeaveNow
|
|
sub edx, 000010000H
|
|
js LeaveNow
|
|
|
|
LoopEntry:
|
|
movzx eax, WORD PTR[esi+ecx-1]
|
|
cmp eax, ebx
|
|
jnz SHORT LookupLoop
|
|
|
|
mov eax, [esp+window]
|
|
movzx eax, WORD PTR[eax+ecx]
|
|
cmp eax, [esp+scanstart]
|
|
jnz SHORT LookupLoop
|
|
|
|
;/* Store the current value of chainlen. */
|
|
|
|
mov [esp+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, [esp+window]
|
|
mov edi, [esp+scan]
|
|
add esi, ecx
|
|
mov eax, [esp+scanalign]
|
|
mov edx, -MAX_MATCH_8
|
|
lea edi, [edi+eax+MAX_MATCH_8]
|
|
lea esi, [esi+eax+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, DWORD PTR[esi+edx]
|
|
xor eax, DWORD PTR[edi+edx]
|
|
jnz SHORT LeaveLoopCmps
|
|
|
|
mov eax, DWORD PTR[esi+edx+4]
|
|
xor eax, DWORD PTR[edi+edx+4]
|
|
jnz SHORT LeaveLoopCmps4
|
|
|
|
add edx, 8
|
|
jnz SHORT LoopCmps
|
|
jmp LenMaximum
|
|
ALIGN 4
|
|
|
|
LeaveLoopCmps4:
|
|
add edx, 4
|
|
|
|
LeaveLoopCmps:
|
|
test eax, 00000FFFFH
|
|
jnz SHORT 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, [esp+scan]
|
|
sub eax, edi
|
|
cmp eax, MAX_MATCH
|
|
jge SHORT 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, [esp+deflatestate]
|
|
mov ebx, [esp+bestlen]
|
|
cmp eax, ebx
|
|
jg SHORT LongerMatch
|
|
mov esi, [esp+windowbestlen]
|
|
mov edi, [edx].ds_prev
|
|
mov ebx, [esp+scanend]
|
|
mov edx, [esp+chainlenwmask]
|
|
jmp LookupLoop
|
|
ALIGN 4
|
|
|
|
;/* s->match_start = cur_match; */
|
|
;/* best_len = len; */
|
|
;/* if (len >= nice_match) break; */
|
|
;/* scan_end = *(ushf*)(scan+best_len-1); */
|
|
|
|
LongerMatch:
|
|
mov ebx, [esp+nicematch]
|
|
mov [esp+bestlen], eax
|
|
mov [edx].ds_match_start, ecx
|
|
cmp eax, ebx
|
|
jge SHORT LeaveNow
|
|
mov esi, [esp+window]
|
|
add esi, eax
|
|
mov [esp+windowbestlen], esi
|
|
movzx ebx, WORD PTR[edi+eax-1]
|
|
mov edi, [edx].ds_prev
|
|
mov [esp+scanend], ebx
|
|
mov edx, [esp+chainlenwmask]
|
|
jmp LookupLoop
|
|
ALIGN 4
|
|
|
|
;/* Accept the current string, with the maximum possible length. */
|
|
|
|
LenMaximum:
|
|
mov edx, [esp+deflatestate]
|
|
mov DWORD PTR[esp+bestlen], MAX_MATCH
|
|
mov [edx].ds_match_start, ecx
|
|
|
|
;/* if ((uInt)best_len <= s->lookahead) return (uInt)best_len; */
|
|
;/* return s->lookahead; */
|
|
|
|
LeaveNow:
|
|
mov edx, [esp+deflatestate]
|
|
mov ebx, [esp+bestlen]
|
|
mov eax, [edx].ds_lookahead
|
|
cmp ebx, eax
|
|
jg SHORT LookaheadRet
|
|
mov eax, ebx
|
|
LookaheadRet:
|
|
|
|
; Restore the stack and return from whence we came.
|
|
|
|
add esp, varsize
|
|
pop ebx
|
|
pop esi
|
|
pop edi
|
|
pop ebp
|
|
ret
|
|
|
|
_longest_match ENDP
|
|
|
|
_TEXT ENDS
|
|
END
|